Вызов:

Входные данные:

Два целочисленных параметра aи b(где a<bи разница не менее 2)

Выход:

Выведите или верните этот текст, где aи bзаполнены:

(a,b) = ]a,b[ = {a<x<b}   = {a<x&&x<b}   = a+1..b-1
[a,b) = [a,b[ = {a<=x<b}  = {a<=x&&x<b}  = a..b-1
(a,b] = ]a,b] = {a<x<=b}  = {a<x&&x<=b}  = a+1..b
[a,b] = [a,b] = {a<=x<=b} = {a<=x&&x<=b} = a..b

Правила соревнований:

• Ввод / вывод является гибким. Может быть напечатано в STDOUT, возвращено в виде строки / символьного массива и т. Д. Может быть введено как два целых числа, десятичные дроби, строки (не знаю почему, так как вам нужно вычислить a+1и b-1, но будьте моим гостем ..) и т. Д.
• Допускается любое количество начальных и / или конечных новых строк, и любое количество конечных и / или ведущих пробелов для каждой строки.
• Пробелы в знаках равенства (в том числе для выравнивания их в одном столбце) являются обязательными, пробелы между остальными символами не допускаются.
• a+1и b-1заменяются правильными значениями после этих расчетов.
• Вы не можете использовать ≤вместо <=.
• Вы не можете использовать &вместо &&.
• Вам разрешено выводить числа с .0(до тех пор, пока оно соответствует, и не более одного десятичного нуля).
• Вы можете предположить, что aэто как минимум на 2 меньше b(для того, (a,b)чтобы быть правильным).
• Строки должны быть выведены в указанном порядке.

Пример:

Вход: a=-5, b=10
Выход:

(-5,10) = ]-5,10[ = {-5<x<10}   = {-5<x&&x<10}   = -4..9
[-5,10) = [-5,10[ = {-5<=x<10}  = {-5<=x&&x<10}  = -5..9
(-5,10] = ]-5,10] = {-5<x<=10}  = {-5<x&&x<=10}  = -4..10
[-5,10] = [-5,10] = {-5<=x<=10} = {-5<=x&&x<=10} = -5..10

Основные правила:

• Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.
  Не позволяйте языкам кода-гольфа отговаривать вас от публикации ответов на языках, не относящихся к кодексу. Попробуйте придумать как можно более короткий ответ для «любого» языка программирования.
• К вашему ответу применяются стандартные правила , поэтому вы можете использовать STDIN / STDOUT, функции / метод с правильными параметрами и типом возврата, полные программы. Ваш звонок.
• По умолчанию лазейки запрещены.
• Если возможно, добавьте ссылку с тестом для вашего кода.
• Также, пожалуйста, добавьте объяснение, если это необходимо.

PS: Для тех, кто видел эту проблему в «Песочнице», когда она была сложной задачей с колмогоровским кодомa и bжестко запрограммирована, я изменил ее на проблему ввода, чтобы избежать скучных жестко закодированных и закодированных ответов, как мы обычно видим с КС бросает вызов.

Stax , 74 байта

ÉyU≤₧pΔz▀σ┬`♪•a≤☻Σ╕←k►¬╗Ö)ßâL╫§▐ƒ┼°╚íS3:Y¶7]7♂e╖à╙ô≥;M0h8♦Oún┼ë`←B╠╫║┌♂α▲╚

Запустите и отладьте его

При этом используются строковые шаблоны stax. Распакованный, размазанный и прокомментированный, это выглядит так.

Y                   save second input in Y register (first is already in X)
.)].([|*            cross product of ")]" and "(["; this produces [")(", ")[", "](", "]["]
{                   begin block to map over interval delimiters
  E"`x,`y"a++       push delimiters separately, then wrap them around the inputs    e.g. "(-5,10)"
  c"(])["|t         copy last value, then replace parentheses with braces           e.g. "]-5,10["
  ih'=              push half the iteration index and "="                           e.g. 0 "="
  |;'=              push iteration parity (alternating 0 and 1) and "="             e.g. 0 "=" 0 "="
  "{`x<`*x<`*`y}"   multiply each equal sign by its occurrence, and template        e.g. "{-5<x<10}"
  c'x.x&:mR         copy last value, then replace "x" with "x&&x"                   e.g. "{-5<x&&x<10}"
  yvih xi|e         calculate final bounds offsets                                  e.g. -5 1 10 -1
  "`+..`+"          add inputs to offsets, and embed in template                    e.g. "-4..9"
  5l                combine last 5 values into array
m                   map [")(", ")[", "](", "]["] using block
:<                  left-align grid colums to add extra spaces
m" = "*             for each row, join with " = " and output

Запустите этот

JavaScript (ES6), 184 182 181 180 байт

Принимает ввод в синтаксис карри (a)(b). Возвращает массив из 4 строк.

a=>b=>[1,2,3,4].map(k=>'31,23 = 31,23 = {10x72}4{10x&&x72}45..6'.replace(/\d/g,(n,i)=>[(+n?k<3:k&1)?'<':'<=',a,b,'][)([[]('[(i*17^k*718)%9],'   = '.slice(k/2),a+k%2,b-(k<3)][n%7]))

Попробуйте онлайн!

Как?

Для каждой строки k с 1 ≤ k ≤ 4 мы начинаем со следующего шаблона:

"31,23 = 31,23 = {10x72}4{10x&&x72}45..6"

и заменить каждую десятичную цифру n в позиции i в соответствии со следующей таблицей:

  n  | Replaced with           | Code
-----+-------------------------+------------------------------------------
 0,7 | comparison operator     | (+n ? k < 3 : k & 1) ? '<' : '<='
  1  | a                       | a
  2  | b                       | b
  3  | interval bound          | '][)([[]('[(i * 17 ^ k * 718) % 9]
  4  | a substring of '   = '  | '   = '.slice(k / 2)
  5  | either 'a' or 'a + 1'   | a + k % 2
  6  | either 'b' or 'b - 1'   | b - (k < 3)

Python 2 , 225 203 195 байт

a,b=input()
for d in 0,1:
 for m in 0,1:k=`a`+','+`b`;o='{'+`a`+'<'+m*'=';c='x<'+d*'='+`b`+'}'+'  '[m+d:];print' = '.join(['(['[m]+k+')]'[d],']['[m]+k+'[]'[d],o+c,o+'x&&'+c,`a+1-m`+'..'+`b-1+d`])

Попробуйте онлайн!

Python 2 , 187 байт

t=a,b=input()
for j in 1,0:
 for i in 1,0:print"%%s%d,%d%%s = "%t*2%('[('[i],'])'[j],'[]'[i],']['[j])+"{%d<%sx%%s<%s%d}%s = "%(a,'='[i:],'='[j:],b,' '*(i+j))*2%('','&&x')+`a+i`+'..'+`b-j`

Попробуйте онлайн!

Java (JDK 10) , 251 байт

a->b->("(a,b)q]a,b[q{a<x<b}  q{a<x&&x<b}  q"+-~a+".."+~-b+"\n[a,b)q[a,b[q{a<=x<b} q{a<=x&&x<b} qa.."+~-b+"\n(a,b]q]a,b]q{a<x<=b} q{a<x&&x<=b} q"+-~a+"..b\n[a,b]q[a,b]q{a<=x<=b}q{a<=x&&x<=b}qa..b").replace("a",a+"").replace("b",b+"").replace("q"," = ")

Попробуйте онлайн!

кредиты

• -50 байтов благодаря Кевину Круйссену

Perl 5 , 181 байт

Я думал, что это сработало бы намного короче ...

$_="sd,ds = sd,ds = {dsxsd}s= {dsx&&xsd}s= d..d
"x4;s!s!("()][<<   [)[[<=<  (]]]<<=  [][]<=<= "=~s/[<= ]+/$&$&/gr=~/ +|<=|./g)[$-++]!ge;s/d/$F[$x%2]+{8,1,9,-1,19,-1,28,1}->{$x++}/ge

Попробуйте онлайн!

объяснение

Первоначально для этого использовалась printfформатная строка, но она была просто sи dбыла короче в сочетании с s///.

Первая строка формата встроена в $_и quadruplicated, то все ss заменяются соответствующим кронштейн, <, <=или пространства, в зависимости от индекса замещения. Я надеялся сохранить еще несколько байтов с дублированием последних 5 символов каждого блока, но в итоге удалось сохранить только 2 байта. Результирующая строка разбивается на элементы пробелов <=или отдельных символов.

Наконец, все ds заменяются на желаемое число, которое корректируется на основе индекса текущей замены с помощью хеш-ключа.

JavaScript, 190 189 байт

x=>y=>`(0)7]0[7{1<x<2}  7{1<52}  73..4
[0)7[0[7{18x<26{185261..4
(0]7]0]7{1<x826{1<5=263..2
[0]7[0]7{18x82}7{185=2}71..2`.replace(/\d/g,d=>[[x,y],x,y,x+1,y-1,`x&&x<`,`}  = `,` = `,`<=`][d])

Попробуйте онлайн

м4 , 194

Похоже, работа для макропроцессора. Не уверен, что m4 соответствует нашим стандартам для языка программирования. У него есть циклическая способность и арифметическое вычисление, поэтому я предполагаю, что оно близко к отметке.

define(l,`$1a,b$2 = $3a,b$4 = {a<$5x<$6b} $8= {a<$5x&&x<$6b} $8= $7')dnl
l(`(',`)',],[,,,incr(a)..decr(b),`  ')
l([,`)',[,[,=,,a..decr(b),` ')
l(`(',],],],,=,incr(a)..b,` ')
l([,],[,],=,=,a..b,)

Это мой первый нетривиальный взгляд на m4, поэтому я подозреваю, что есть еще больше возможностей для игры в гольф, которые я упустил.

Входные данные передаются с использованием -Dмакроопределений в командной строке. Не уверен, что нужно что-то добавить к баллу для них, насколько я могу судить, это единственный способ осмысленно передать параметры:

$ m4 -Da=-5 -Db=10 intnot.m4
(-5,10) = ]-5,10[ = {-5<x<10}   = {-5<x&&x<10}   = -4..9
[-5,10) = [-5,10[ = {-5<=x<10}  = {-5<=x&&x<10}  = -5..9
(-5,10] = ]-5,10] = {-5<x<=10}  = {-5<x&&x<=10}  = -4..10
[-5,10] = [-5,10] = {-5<=x<=10} = {-5<=x&&x<=10} = -5..10 $

Попробуйте онлайн .

Спасибо @Dennis за быстрое добавление m4 в TIO !

Python 2 , 277 199 193 189 байт

a,b=input()
for i in 4,3,2,1:x,y=i%2,i>2;e='=';p=`a`+','+`b`;print'(['[x]+p+'])'[y],e,']['[x]+p+']['[y],e,2*('{%d<%s<%s%d} %s= '%(a,e*x+'%sx',e[y:],b,i/2*' '))%('','x&&')+`a+1-x`+'..'+`b-y`

Попробуйте онлайн!

Excel, 399 байт

="("&A1&","&B1&") = ]"&A1&","&B1&"[ = {"&A1&"<x<"&B1&"}   = {"&A1&"<x&&x<"&B1&"}   = "&A1+1&".."&B1-1&"
 ["&A1&","&B1&") = ["&A1&","&B1&"[ = {"&A1&"<=x<"&B1&"}  = {"&A1&"<=x&&x<"&B1&"}  = "&A1&".."&B1-1&"
 ("&A1&","&B1&"] = ]"&A1&","&B1&"] = {"&A1&"<x<="&B1&"}  = {"&A1&"<x&&x<="&B1&"}  = "&A1+1&".."&B1&"
 ["&A1&","&B1&"] = ["&A1&","&B1&"] = {"&A1&"<=x<="&B1&"} = {"&A1&"<=x&&x<="&B1&"} = "&A1&".."&B1

Ничего особенно интересного здесь.

C (gcc) , 224 237 байт

f(a,b,c,m,n,o){for(c=0;++c<5;printf("%c%d,%d%c = %c%d,%d%c = {%d<%sx<%s%d}%*s= {%d<%sx&&x<%s%d}%*s= %d..%d\n","[("[m],a,b,"])"[n],"[]"[m],a,b,"]["[n],a,"="+m,"="+n,b,o,"",a,"="+m,"="+n,b,o,"",a+m,b-n)){m=c%2;n=c<3;o=3-c/2;}}

Попробуйте онлайн!

Перемещение «<[=]» в строку формата позволило мне полностью удалить массив. Также переход printf()в forцикл спасает точку с запятой.

Оригинальный ответ

f(a,b,c,m,n,o){char*e[]={"<=","<"};for(c=0;++c<5;){m=c%2;n=c<3;o=3-c/2;printf("%c%d,%d%c = %c%d,%d%c = {%d%sx%s%d}%*s= {%d%sx&&x%s%d}%*s= %d..%d\n","[("[m],a,b,"])"[n],"[]"[m],a,b,"]["[n],a,e[m],e[n],b,o,"",a,e[m],e[n],b,o,"",a+m,b-n);}}

Попробуйте онлайн!

Здесь нет ничего особенно примечательного: я использовал обычные приемы для уменьшения размера функции (поднятие intавто в заголовок функции, использование стиля K & R, индексация в строковые константы.) Сохранение {"<=", "<"} в массив оказался более эффективным по размеру, чем вставка спецификатора формата для этой задачи, так как он использовался более одного раза.

Javascript, 273 258 232 байта

Спасибо Кевину Круйссену за то, что он спас мне 15 байтов!

e=>f=>'(j)h]j[h{a<x<b}  h{a<x&&x<b}  hc..d\n[j)h[j[h{a<=x<b} h{a<=x&&x<b} ha..d\n(j]h]j]h{a<x<=b} h{a<x&&x<=b} hc..b\n[j]h[j]h{a<=x<=b}h{a<=x&&x<=b}ha..b'.replace(/a|b|c|d|h|j/g,m=>{return{a:e,b:f,c:e+1,d:f-1,h:" = ",j:e+","+f}[m]})

Попробуйте онлайн

Спасибо за то, что TFeld дал мне эту идею, сэкономив около 60 байт от моего первоначального ответа.

Ungolfed:

e => f => '(j)h]j[h{a<x<b}  h{a<x&&x<b}  hc..d'
 + '\n[j)h[j[h{a<=x<b} h{a<=x&&x<b} ha..d'
 + '\n(j]h]j]h{a<x<=b} h{a<x&&x<=b} hc..b'
 + '\n[j]h[j]h{a<=x<=b}h{a<=x&&x<=b}ha..b'
.replace(/a|b|c|d|h|j/g, m=>{
        return {a:e,b:f,c:e+1,d:f-1,h:" = ",j:e+","+f}[m]
    }
)

Javascript (оригинальный ответ), 340 байт

(a,b)=>alert(`(${a},${b}) = ]${a},${b}[ = {${a}<x<${b}}   = {${a}<x&&x<${b}}   = ${a+1}..${b-1}\n[${a},${b}) = [${a},${b}[ = {${a}<=x<${b}}  = {${a}<=x&&x<${b}}  = ${a}..${b-1}\n(${a},${b}] = ]${a},${b}] = {${a}<x<=${b}}  = {${a}<x&&x<=${b}}  = ${a+1}..${b}\n[${a},${b}] = [${a},${b}] = {${a}<=x<=${b}} = {${a}<=x&&x<=${b}} = ${a}..${b}\n`)

Сетчатка , 216 байт

.+
$&()][<<  ¶$&[)[[<=< ¶$&(]]]<<= ¶$&[][]<=<=
((.*),(.*))(.)(.)(.)(.)(<=?)(<=?)( *)
$4$1$5 = $6$1$7 = {$2$8x$9$3}$10 = {$2$8x&&x$9$3}$10 = $2_$8..$3_$9
_<=

\d+_
$&*___
T`<`_` _+<|\.-_+<
___<
_
__<
-1
_(_*)
$.1
-0
0

Попробуйте онлайн! Объяснение:

.+
$&()][<<  ¶$&[)[[<=< ¶$&(]]]<<= ¶$&[][]<=<=
((.*),(.*))(.)(.)(.)(.)(<=?)(<=?)( *)
$4$1$5 = $6$1$7 = {$2$8x$9$3}$10 = {$2$8x&&x$9$3}$10 = $2_$8..$3_$9

Создайте основную массу результата.

_<=

Если переменная участвует в свободном неравенстве, то значение является включающим, поэтому мы можем удалить заполнитель.

\d+_
$&*___

Преобразуйте значение в одинарное и добавьте 2.

T`<`_` _+<|\.-_+<

Удалите заполнитель для строгого нижнего неравенства или отрицательного строгого верхнего неравенства. Он все еще имеет 2 добавленных, но 1 будет вычтен позже, давая желаемый результат.

___<
_

Вычтите 2 из других ненулевых строгих неравенств, восстановив исходное значение, из которого 1 будет вычтено позже.

__<
-1

Изменить строгое верхнее неравенство 0на -1.

_(_*)
$.1

Вычтите 1 из оставшихся строгих неравенств и преобразуйте в десятичное число.

-0
0

Исправьте другой крайний случай.

Python 3, 180 байт:

lambda a,b:[eval('f"'+"{%r[j]}{a},{b}{%r[i]} = "*2%('([',')]','][','[]')+"{{{a}<{'='[:j]}x%s<{'='[:i]}{b}}}{'  '[i+j:]} = "*2%('','&&x')+'{a+j}..{b-i}"')for i in(1,0)for j in(1,0)]

объяснение

В основном строит f-строку, которая оценивается в понимании списка. Старый стиль%Интерполяция строк в используется для задержки вычисления выражений до тех пор, пока не будет вычислена f-строка.

lambda a,b:[
    eval(
      'f"' +                                                            # f-string prefix
      "{%r[j]}{a},{b}{%r[i]} = "*2%('([',')]','][','[]') +              # first two terms
      "{{{a}<{'='[:j]}x%s<{'='[:i]}{b}}}{'  '[i+j:]} = "*2%('','&&x') + # second two terms
      '{a+j}..{b-i}"'                                                   # last term
      )
    for i in(1,0)for j in(1,0)
    ]

Первая часть строки, 'f' ', станет префиксом для f-строки.

Вторая часть строки создает строку формата для первых двух интервальных выражений. %rиспользуется, чтобы избавить от необходимости помещать кавычки в формате, т. е. "{%r[j]}"такой же, как"{'%s'[j]}" . Когда f-строка оценена, правильная скобка выбрана.

Третья часть строки строит следующие два интервальных выражения.

Последняя часть форматирует часть "a..b" f-строки.

Собранная е-строка выглядит так: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

Когда f-строка вычисляется, все выражения в фигурных скобках {}заменяются их значениями. Таким образом, {a}заменяется значением aи {'(['[j]}заменяется на, (если j равно 0 или [если j равно 1.

SOGL V0.12 , 110 байт

<ŗŗ}”⁴
"{ŗ<ŗx³
W}↔b ,e++Κ+²
4∫2\f»¹Aa{Ƨ[(²a{Ƨ[]²ba{ =*}eο+++:³⁴;³&&x⁴a_beh+H⁶;!+ƨ.+Κο++++}⁰№Iā;0E{┼ē4=‽"δY↑æ‘┼

Попробуй здесь!

Python 3, 248 байт

def f(a,b):
 l=[['(',')','[','<',1],['[',']',']','<=',0]]
 r=[0,1]
 for i in r:
  for j in r:
   print(('%s%d,%d%s='*2+'{%d%sx%s%d}={%d%sx&&x%s%d}=%d..%d')%((l[j][0],a,b,l[i][1],l[1-j][2],a,b,l[i][2])+(a,l[j][3],l[i][3],b)*2+(a+l[j][4],b-l[i][4])))

Попробуйте онлайн!