Herausforderung:

Eingang:

Zwei ganzzahlige Parameter aund b(wobei a<bund der Unterschied mindestens 2 beträgt)

Ausgabe:

Diesen Text ausgeben oder zurückgeben, wo aund bausgefüllt:

(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

Herausforderungsregeln:

• I / O ist flexibel. Kann nach STDOUT gedruckt, als String / Zeichen-Array zurückgegeben usw. Kann als zwei Ganzzahlen, Dezimalzahlen, Strings eingegeben werden (nicht sicher warum, da Sie das a+1und berechnen müssen b-1, aber mein Gast sein müssen ..) usw.
• Es sind beliebig viele führende und / oder nachfolgende neue Zeilen und beliebig viele nachfolgende und / oder nachfolgende Leerzeichen für jede Zeile zulässig.
• Die Leerzeichen an den Gleichheitszeichen (einschließlich derer, mit denen sie in derselben Spalte ausgerichtet werden) sind obligatorisch, Leerzeichen zwischen den anderen Zeichen sind nicht zulässig.
• a+1und b-1werden nach diesen Berechnungen durch die korrekten Werte ersetzt.
• Sie dürfen ≤statt nicht verwenden <=.
• Sie dürfen &statt nicht verwenden &&.
• Sie dürfen die Zahlen mit ausgeben .0(solange es konsistent ist und nicht mehr als eine Dezimalnull).
• Sie können davon ausgehen, dass amindestens 2 niedriger sind als b(um (a,b)korrekt zu sein).
• Die Zeilen sollten in der angegebenen Reihenfolge ausgegeben werden.

Beispiel:

Eingabe: a=-5, b=10
Ausgabe:

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

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

PS: Für diejenigen, die diese Herausforderung in der Sandbox gesehen hatten, als es noch eine Herausforderung mit kolmogorov-Komplexität wara und die hartcodiert warb , habe ich sie in eine Eingabe-Herausforderung geändert, um zu verhindern, dass langweilige, hartcodierte und codierte Antworten auftreten, wie wir sie normalerweise kennen KC-Herausforderungen.

Stax , 74 Bytes

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

Führen Sie es aus und debuggen Sie es

Dabei werden die Zeichenfolgenvorlagen von stax in hohem Maße verwendet. Ausgepackt, ungolfed und kommentiert sieht es so aus.

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

Führen Sie dieses aus

JavaScript (ES6), 184 182 181 180 Bytes

Übernimmt Eingaben in der Currying-Syntax (a)(b). Gibt ein Array mit 4 Zeichenfolgen zurück.

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

Probieren Sie es online!

Wie?

Für jede Zeile k mit 1 ≤ k ≤ 4 beginnen wir mit der folgenden Vorlage:

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

und ersetze jede Dezimalstelle n an der Stelle i gemäß der folgenden Tabelle:

  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 Bytes

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

Probieren Sie es online!

Python 2 , 187 Bytes

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`

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

Probieren Sie es online!

Credits

• -50 Bytes dank Kevin Cruijssen

Perl 5 , 181 Bytes

Ich dachte, das hätte viel kürzer geklappt ...

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

Probieren Sie es online!

Erläuterung

Ursprünglich wurde hier eine printfFormatzeichenfolge verwendet, aber in Kombination mit hatte sund dwar sie nur kürzer s///.

Zuerst wird das Format - String ist eingebaut in $_und vervierfacht, dann werden alle ssind s mit den entsprechenden Halterung, ersetzt <, <=oder Räume, in Abhängigkeit von der Ersatzindex. Ich hatte gehofft, mit der Verdopplung der letzten 5 Zeichen jedes Blocks noch ein paar Bytes zu sparen, aber dies führte letztendlich nur zu einer Einsparung von 2 Bytes. Die resultierende Zeichenfolge wird in Elemente von Leerzeichen <=oder einzelne Zeichen aufgeteilt.

Schließlich werden alle ds durch die gewünschte Nummer ersetzt, die anhand des Index der aktuellen Ersetzung über einen Hash-Schlüssel angepasst wird.

JavaScript, 190 189 Bytes

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

Probieren Sie es online aus

m4 , 194

Scheint ein Job für einen Makroprozessor zu sein. Ich bin mir nicht sicher, ob m4 unseren Standards für eine Programmiersprache entspricht. Es hat Looping-Fähigkeit und arithmetische Bewertung, also gehe ich davon aus, dass es nahe an der Marke liegt.

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

Dies ist mein erster nicht-trivialer Blick auf m4, daher vermute ich, dass ich mehr Möglichkeiten zum Golfen verpasst habe.

Eingaben werden mithilfe von -DMakrodefinitionen in der Befehlszeile übergeben. Ich bin mir nicht sicher, ob irgendetwas zum Score hinzugefügt werden muss, soweit ich das beurteilen kann, ist dies die einzige Möglichkeit, Parameter sinnvoll zu übergeben:

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

Probieren Sie es online aus .

Vielen Dank an @Dennis, dass Sie m4 so schnell zu TIO hinzugefügt haben !

Python 2 , 277 199 193 189 Bytes

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`

Probieren Sie es online!

Excel, 399 Bytes

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

Nichts besonders Interessantes hier.

C (gcc) , 224 237 Bytes

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

Probieren Sie es online!

Durch das Verschieben von "<[=]" in die Formatzeichenfolge konnte ich das Array vollständig entfernen. Beim Bewegen printf()in die forSchleife wurde auch ein Semikolon gespeichert.

Ursprüngliche Antwort

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

Probieren Sie es online!

Hier gibt es nichts Besonderes: Ich habe die Größe der Funktion mit den üblichen Tricks geändert ( intAutos in den Funktionsheader einfügen, K & R-Stil verwenden, in Zeichenfolgenkonstanten indizieren) Array erwies sich als größeneffizienter als das Einfügen eines Formatspezifizierers für diese Herausforderung, da es mehrmals verwendet wurde.

Javascript, 273 258 232 Bytes

Vielen Dank an Kevin Cruijssen, der mir 15 Bytes gespart hat!

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

Probieren Sie es online aus

Vielen Dank für TFeld, dass Sie mir diese Idee gegeben haben und etwa 60 Byte meiner ursprünglichen Antwort eingespart haben.

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 (ursprüngliche Antwort), 340 Bytes

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

Netzhaut , 216 Bytes

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

Probieren Sie es online! Erläuterung:

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

Bauen Sie den Hauptteil des Ergebnisses auf.

_<=

Wenn die Variable an einer losen Ungleichung beteiligt ist, ist der Wert inklusive, sodass wir den Platzhalter löschen können.

\d+_
$&*___

Wandle den Wert in unary um und addiere 2.

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

Entfernen Sie den Platzhalter für eine strengere untere Ungleichung oder eine negative strengere obere Ungleichung. Es wurden noch 2 hinzugefügt, aber 1 wird später abgezogen, um das gewünschte Ergebnis zu erzielen.

___<
_

Subtrahieren Sie 2 von den anderen strengen Ungleichungen ungleich Null und stellen Sie den ursprünglichen Wert wieder her, von dem 1 später subtrahiert wird.

__<
-1

Ändern Sie eine strikte obere Ungleichung von 0bis -1.

_(_*)
$.1

Subtrahieren Sie 1 von den verbleibenden strengen Ungleichungen und konvertieren Sie sie in Dezimalzahlen.

-0
0

Repariere einen anderen Randkasten.

Python 3, 180 Bytes:

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

Erläuterung

Baut im Grunde genommen einen F-String auf, der in einem Listenverständnis ausgewertet wird. Die %String-Interpolation alten Stils wird verwendet, um die Auswertung der Ausdrücke zu verzögern, bis der f-String ausgewertet wird.

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

Der erste Teil der Zeichenfolge, 'f "', wird zum Präfix für die f-Zeichenfolge.

Der zweite Teil der Zeichenfolge erstellt die Formatzeichenfolge für die ersten beiden Intervallausdrücke. %rwird verwendet, um zu sparen, dass Anführungszeichen im Format eingegeben werden müssen, dh "{%r[j]}"ist dasselbe wie"{'%s'[j]}" . Wenn die f-Zeichenfolge ausgewertet wird, wird die richtige Klammer ausgewählt.

Der dritte Teil der Zeichenfolge erstellt die nächsten beiden Intervallausdrücke.

Der letzte Teil formatiert den "a..b" -Teil der f-Zeichenfolge.

Die zusammengesetzte F-Saite sieht wie folgt aus: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

Wenn die f-Zeichenfolge ausgewertet wird, werden alle Ausdrücke in geschweiften Klammern {}durch ihren Wert ersetzt. So {a}wird durch den Wert ersetzt a, und {'(['[j]}wird ersetzt durch , (wenn j = 0 oder [wenn j 1.

SOGL V0.12 , 110 Bytes

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

Probieren Sie es hier aus!

Python 3, 248 Bytes

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

Probieren Sie es online!