Sfida:

Ingresso:

Due parametri interi ae b(dove a<be la differenza è almeno 2)

Produzione:

Invia o restituisci questo testo, dove ae bsono compilati:

(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

Regole della sfida:

• L'I / O è flessibile. Può essere stampato su STDOUT, restituito come stringa / array di caratteri, ecc. Può essere immesso come due numeri interi, decimali, stringhe (non so perché perché è necessario calcolare il a+1e b-1, ma essere mio ospite ...), ecc.
• È consentita qualsiasi quantità di nuove righe iniziali e / o finali e qualsiasi quantità di spazi finali e / o iniziali per ciascuna riga.
• Gli spazi ai segni uguali (compresi quelli per allinearli nella stessa colonna) sono obbligatori, gli spazi tra gli altri caratteri non sono ammessi.
• a+1e b-1vengono sostituiti con i valori corretti dopo questi calcoli.
• Non ti è permesso usare ≤invece di <=.
• Non ti è permesso usare &invece di &&.
• È consentito produrre i numeri con .0(purché sia ​​coerente e non più di uno zero decimale).
• Si può presumere che asia almeno 2 inferiore a b(per (a,b)essere corretto).
• Le righe devono essere emesse nell'ordine mostrato.

Esempio:

Ingresso: a=-5, b=10
Uscita:

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

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

PS: Per coloro che avevano visto questa sfida nella Sandbox quando era ancora una sfida con complessità kolmogorova e con bhard-coded, l'ho cambiata in una sfida di input per evitare noiose risposte hard-coded e codificate come vediamo di solito con Sfide KC.

Stax , 74 byte

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

Esegui ed esegui il debug

Questo utilizza pesantemente i modelli di stringa di stax. Disimballato, non golfato e commentato, sembra così.

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

Esegui questo

JavaScript (ES6), 184 182 181 180 byte

Accetta input nella sintassi del curry (a)(b). Restituisce un array di 4 stringhe.

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

Provalo online!

Come?

Per ogni riga k con 1 ≤ k ≤ 4 , iniziamo con il seguente modello:

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

e sostituire ogni cifra decimale n nella posizione i secondo la seguente tabella:

  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 byte

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

Provalo online!

Python 2 , 187 byte

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`

Provalo online!

Java (JDK 10) , 251 byte

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

Provalo online!

Crediti

• -50 byte grazie a Kevin Cruijssen

Perl 5 , 181 byte

Pensavo che questo avrebbe funzionato molto più breve ...

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

Provalo online!

Spiegazione

Inizialmente utilizzava una printfstringa di formato, ma aveva sed dera più breve quando combinato con s///.

Innanzitutto la stringa di formato viene incorporata $_e quadruplicata, quindi tutti gli ss vengono sostituiti con la parentesi corrispondente <, <=o spazi, a seconda dell'indice di sostituzione. Speravo di salvare qualche altro byte con la duplicazione degli ultimi 5 caratteri di ciascun blocco, ma alla fine ho salvato solo 2 byte. La stringa risultante è suddivisa in elementi di spazi <=o singoli caratteri.

Alla fine tutti gli ds vengono sostituiti con il numero desiderato che viene regolato in base all'indice della sostituzione corrente tramite una chiave hash.

JavaScript, 190 189 byte

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

Provalo online

m4 , 194

Sembra un lavoro per un processore macro. Non sono sicuro che m4 soddisfi i nostri standard per un linguaggio di programmazione. Ha capacità di loop e valutazione aritmetica, quindi suppongo che sia vicino al segno.

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

Questo è il mio primo sguardo non banale su m4, quindi sospetto che ci siano più opportunità di golf che mi sono perso.

Gli input vengono passati usando -Dle definizioni macro nella riga di comando. Non sono sicuro se qualcosa deve essere aggiunto al punteggio per questi, per quanto posso dire questo è l'unico modo per passare in modo significativo i parametri:

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

Provalo online .

Grazie @Dennis per aver aggiunto m4 a TIO così in fretta!

Python 2 , 277 199 193 189 byte

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`

Provalo online!

Excel, 399 byte

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

Niente di particolarmente interessante qui.

C (gcc) , 224 237 byte

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

Provalo online!

Lo spostamento di "<[=]" nella stringa di formato mi ha permesso di rimuovere del tutto l'array. Inoltre, spostandosi printf()nel forloop è stato salvato un punto e virgola.

Risposta originale

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

Provalo online!

Non c'è nulla di particolarmente degno di nota qui: ho usato i soliti trucchi per radere la dimensione della funzione (sollevare intauto nell'intestazione della funzione, usare lo stile K&R, indicizzare in costanti di stringa.) Memorizzare {"<=", "<"} in un array si è rivelato più efficiente in termini di dimensioni rispetto all'inserimento di un identificatore di formato per questa sfida poiché è stato utilizzato più di una volta.

Javascript, 273 258 232 byte

Grazie Kevin Cruijssen per avermi salvato 15 byte!

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

Provalo online

Grazie per TFeld per avermi dato quell'idea, risparmiando circa 60 byte dalla mia risposta originale.

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 (risposta originale), 340 byte

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

Retina , 216 byte

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

Provalo online! Spiegazione:

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

Costruisci la maggior parte del risultato.

_<=

Se la variabile è coinvolta in una disparità libera, il valore è inclusivo, quindi possiamo eliminare il segnaposto.

\d+_
$&*___

Converti il ​​valore in unario e aggiungi 2.

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

Rimuovere il segnaposto per una disuguaglianza inferiore rigorosa o una disuguaglianza superiore rigorosa negativa. Sono stati ancora aggiunti 2, ma 1 verrà sottratto in seguito, dando il risultato desiderato.

___<
_

Sottrai 2 dalle altre disuguaglianze rigorose diverse da zero, ripristinando il valore originale, dal quale 1 verrà sottratto in seguito.

__<
-1

Cambia una rigida disuguaglianza superiore di 0a -1.

_(_*)
$.1

Sottrai 1 dalle disuguaglianze rigorose rimanenti e converti in decimale.

-0
0

Risolvi un altro caso limite.

Python 3, 180 byte:

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

spiegazione

Fondamentalmente crea una stringa F che viene valutata in una comprensione di lista. L' %interpolazione di stringhe vecchio stile viene utilizzata per ritardare la valutazione delle espressioni finché non viene valutata la f-stringa.

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

La prima parte della stringa, 'f "', diventerà il prefisso per la f-stringa.

La seconda parte della stringa crea la stringa di formato per le prime due espressioni di intervallo. %rviene utilizzato per salvare dalla necessità di inserire virgolette nel formato, ovvero "{%r[j]}"è uguale a "{'%s'[j]}". Quando viene valutata la stringa f, viene selezionata la parentesi corretta.

La terza parte della stringa crea le espressioni dei due intervalli successivi.

L'ultima parte formatta la parte "a..b" della stringa f.

La stringa f assemblata si presenta come: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

Quando viene valutata la stringa f, tutte le espressioni tra parentesi graffe {}vengono sostituite dal loro valore. Quindi, {a}viene sostituito dal valore di ae {'(['[j]}viene sostituito da (se j è 0 o [se j è 1.

SOGL V0.12 , 110 byte

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

Provalo qui!

Python 3, 248 byte

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

Provalo online!