Виклик:

Вхід:

Два цілих параметри 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жорстким кодом, я змінив це на вхідний виклик, щоб запобігти нудним жорстко-кодованим відповідям, як ми зазвичай бачимо Виклики KC.

Стакс , 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 байт

Здійснює введення в синтаксис currying (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`])

Спробуйте в Інтернеті!

Пітон 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///.

Спочатку рядок формату вбудовується в $_чотири сплетені, потім всі 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])

Спробуйте в Інтернеті

m4 , 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 байт.

Безголівки:

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-string виглядає так: 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])))

Спробуйте в Інтернеті!