Wyzwanie:

Wkład:

Dwa parametry całkowite ai b(gdzie a<bi różnica wynosi co najmniej 2)

Wydajność:

Wpisz lub zwróć ten tekst, gdzie ai bsą wypełnione:

(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

Zasady konkursu:

• I / O jest elastyczny. Może być drukowany do STDOUT, zwracany jako ciąg / tablica znaków itp. Może być wprowadzany jako dwie liczby całkowite, dziesiętne, ciągi (nie jestem pewien, dlaczego, skoro musisz obliczyć a+1i b-1, ale bądź moim gościem ...) itp.
• Dozwolona jest dowolna liczba wiodących i / lub końcowych nowych wierszy, a także dowolna ilość końcowych i / lub wiodących spacji dla każdej linii.
• Spacje przy znakach równości (w tym te, które służą do wyrównania ich w tej samej kolumnie) są obowiązkowe, spacje między innymi znakami są niedozwolone.
• a+1i b-1są zastępowane prawidłowymi wartościami po tych obliczeniach.
• Nie możesz używać ≤zamiast <=.
• Nie możesz używać &zamiast &&.
• Dozwolone jest wypisywanie liczb za pomocą .0(o ile jest to spójne i nie więcej niż jedno zero dziesiętne).
• Możesz założyć, że ajest co najmniej 2 niższy niż b( (a,b)aby być poprawnym).
• Linie powinny być wyprowadzane w pokazanej kolejności.

Przykład:

Wejście: a=-5, b=10
Wyjście:

(-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

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i zwracanymi typami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

PS: Dla tych, którzy nie widać tego wyzwania w piaskownicy , kiedy był jeszcze Kołmogorowa-złożoność wyzwaniem ai bzakodowane, zmieniłem go na wyzwanie wejściowego, aby zapobiec nudny zakodowane i zakodowanych odpowiedzi jak najczęściej widzimy z Wyzwania KC.

Stax , 74 bajty

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

Uruchom i debuguj

To intensywnie wykorzystuje szablony ciągów stax. Rozpakowane, niepolowane i skomentowane, wygląda to tak.

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

Uruchom ten

JavaScript (ES6), 184 182 181 180 bajtów

Pobiera dane wejściowe w składni curry (a)(b). Zwraca tablicę 4 łańcuchów.

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]))

Wypróbuj online!

W jaki sposób?

Dla każdego wiersza k z 1 ≤ k ≤ 4 zaczynamy od następującego szablonu:

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

i zamień każdą cyfrę dziesiętną n w pozycji i zgodnie z następującą tabelą:

  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 bajtów

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`])

Wypróbuj online!

Python 2 , 187 bajtów

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`

Wypróbuj online!

Java (JDK 10) , 251 bajtów

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"," = ")

Wypróbuj online!

Kredyty

• -50 bajtów dzięki Kevin Cruijssen

Perl 5 , 181 bajtów

Myślałem, że to zadziałałoby znacznie krócej ...

$_="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

Wypróbuj online!

Wyjaśnienie

Pierwotnie używano printfciąg formatu, ale po prostu miał si dbył krótszy w połączeniu z s///.

Pierwszy ciąg format jest wbudowana $_i quadruplicated, wszystkie ss są zastępowane odpowiednimi wspornik <, <=lub pomieszczenia, w zależności od wskaźnika zastępczego. Miałem nadzieję zaoszczędzić trochę więcej bajtów dzięki duplikacji ostatnich 5 znaków każdego bloku, ale skończyło się to na zapisaniu tylko 2 bajtów. Powstały ciąg jest podzielony na elementy spacji <=lub pojedyncze znaki.

Na koniec wszystkie ds są zamieniane na żądaną liczbę, która jest dostosowywana na podstawie indeksu bieżącego zastąpienia za pomocą klawisza skrótu.

JavaScript, 190 189 bajtów

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])

Wypróbuj online

m4 , 194

Wydaje się, że to zadanie dla makroprocesora. Nie jestem pewien, czy m4 spełnia nasze standardy języka programowania. Ma zdolność zapętlania i ewaluację arytmetyczną, więc zakładam, że jest blisko znaku.

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,)

To moje pierwsze nietrywialne spojrzenie na m4, więc podejrzewam, że straciłem więcej okazji do gry w golfa.

Dane wejściowe są przekazywane za pomocą -Ddefinicji makr w wierszu polecenia. Nie jestem pewien, czy należy dodać do nich wynik, o ile mogę stwierdzić, że jest to jedyny sposób na znaczące przekazanie parametrów:

$ 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 $

Wypróbuj online .

Dzięki @Dennis za tak szybkie dodanie m4 do TIO !

Python 2 , 277 199 193 189 bajtów

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`

Wypróbuj online!

Excel, 399 bajtów

="("&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

Nic szczególnie interesującego tutaj.

C (gcc) , 224 237 bajtów

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;}}

Wypróbuj online!

Przeniesienie „<[=]” do ciągu formatu pozwoliło mi całkowicie usunąć tablicę. Również przejście printf()do forpętli uratowało średnik.

Oryginalna odpowiedź

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);}}

Wypróbuj online!

Nie ma tu nic szczególnie godnego uwagi: użyłem zwykłych sztuczek do golenia wielkości funkcji (podnoszenie intaut do nagłówka funkcji, używanie stylu K&R, indeksowanie do stałych ciągów.) Przechowywanie {"<=", "<"} w tablica okazała się bardziej wydajna pod względem wielkości niż wstawianie specyfikatora formatu dla tego wyzwania, ponieważ była używana więcej niż jeden raz.

JavaScript, 273 258 232 bajty

Dzięki Kevin Cruijssen za uratowanie mnie 15 bajtów!

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]})

Wypróbuj online

Dzięki za TFeld za przekazanie mi tego pomysłu, oszczędzając około 60 bajtów od mojej oryginalnej odpowiedzi.

Nie golfowany:

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 (oryginalna odpowiedź), 340 bajtów

(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`)

Siatkówka , 216 bajtów

.+
$&()][<<  ¶$&[)[[<=< ¶$&(]]]<<= ¶$&[][]<=<=
((.*),(.*))(.)(.)(.)(.)(<=?)(<=?)( *)
$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

Wypróbuj online! Wyjaśnienie:

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

Zbuduj główną część wyniku.

_<=

Jeśli zmienna bierze udział w luźnej nierówności, wówczas wartość jest włączająca, więc możemy usunąć symbol zastępczy.

\d+_
$&*___

Konwertuj wartość na unary i dodaj 2.

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

Usuń symbol zastępczy dla ścisłej niższej nierówności lub negatywnej ścisłej górnej nierówności. Wciąż dodano 2, ale 1 zostanie odjęta później, dając pożądany wynik.

___<
_

Odejmij 2 od pozostałych niezerowych ścisłych nierówności, przywracając pierwotną wartość, od której 1 zostanie odjęta później.

__<
-1

Zmień ścisłą górną nierówność 0na -1.

_(_*)
$.1

Odejmij 1 od pozostałych surowych nierówności i przelicz na dziesiętne.

-0
0

Napraw kolejną skrzynkę na brzeg.

Python 3, 180 bajtów:

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)]

wyjaśnienie

Zasadniczo buduje ciąg f, który jest oceniany na podstawie listy. %Interpolacja ciągów w starym stylu służy do opóźniania oceny wyrażeń aż do oceny ciągu 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)
    ]

Pierwsza część łańcucha, „f”, stanie się przedrostkiem dla łańcucha F.

Druga część ciągu buduje ciąg formatu dla pierwszych dwóch wyrażeń przedziałowych. %rsłuży do oszczędzania przed koniecznością umieszczania cudzysłowów w formacie, tzn. "{%r[j]}"jest taki sam jak "{'%s'[j]}". Podczas oceny ciągu f wybierany jest właściwy nawias.

Trzecia część ciągu buduje kolejne dwa wyrażenia przedziałowe.

Ostatnia część formatuje część „a..b” ciągu f.

Złożony f-string wygląda następująco: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

Podczas oceny ciągu f wszystkie wyrażenia w nawiasach {}są zastępowane ich wartością. Tak więc {a}zostaje zastąpiony przez wartość ai {'(['[j]}zostaje zastąpiony przez, (jeśli j wynosi 0 lub [jeśli j wynosi 1.

SOGL V0.12 , 110 bajtów

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

Wypróbuj tutaj!

Python 3, 248 bajtów

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])))

Wypróbuj online!