Défi:

Contribution:

Deux paramètres entiers aet b(où a<bet la différence est d'au moins 2)

Sortie:

Sortez ou renvoyez ce texte, où aet bsont remplis:

(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

Règles du défi:

• Les E / S sont flexibles. Peut être imprimé dans STDOUT, renvoyé sous forme de chaîne / tableau de caractères, etc. Peut être entré sous la forme de deux entiers, décimaux, chaînes (je ne sais pas pourquoi car vous devez calculer le a+1et b-1, mais soyez mon invité ..), etc.
• Toute quantité de nouvelles lignes de début et / ou de fin est autorisée, et toute quantité d'espaces de fin et / ou de début pour chaque ligne est autorisée.
• Les espaces aux signes égaux (y compris ceux pour les aligner dans la même colonne) sont obligatoires, les espaces entre les autres caractères ne sont pas autorisés.
• a+1et b-1sont remplacés par les valeurs correctes après ces calculs.
• Vous n'êtes pas autorisé à utiliser à la ≤place de <=.
• Vous n'êtes pas autorisé à utiliser à la &place de &&.
• Vous êtes autorisé à sortir les nombres avec .0(tant qu'il est cohérent et pas plus d'un zéro décimal).
• Vous pouvez supposer qu'il aest au moins 2 inférieur à b(pour (a,b)être correct).
• Les lignes doivent être sorties dans l'ordre indiqué.

Exemple:

Entrée: a=-5, b=10
Sortie:

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

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

PS: Pour ceux qui avaient vu ce défi dans le bac à sable quand il s'agissait encore d'un défi de complexité kolmogorov avec aet bcodé en dur, je l'ai changé en un défi d'entrée pour éviter les réponses ennuyeuses codées en dur et codées comme nous le voyons habituellement avec Défis KC.

Stax , 74 octets

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

Exécuter et déboguer

Cela utilise fortement les modèles de chaînes de stax. Déballé, non golfé et commenté, il ressemble à ceci.

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

Exécutez celui-ci

JavaScript (ES6), 184 182 181 180 180 octets

Prend une entrée dans la syntaxe de curry (a)(b). Renvoie un tableau de 4 chaînes.

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

Essayez-le en ligne!

Comment?

Pour chaque ligne k avec 1 ≤ k ≤ 4 , nous commençons avec le modèle suivant:

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

et remplacez chaque chiffre décimal n à la position i selon le tableau suivant:

  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 octets

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

Essayez-le en ligne!

Python 2 , 187 octets

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`

Essayez-le en ligne!

Java (JDK 10) , 251 octets

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

Essayez-le en ligne!

Crédits

• -50 octets grâce à Kevin Cruijssen

Perl 5 , 181 octets

Je pensais que cela aurait fonctionné beaucoup plus court ...

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

Essayez-le en ligne!

Explication

À l'origine, cela utilisait une printfchaîne de format, mais juste set détait plus court lorsqu'il était combiné avec s///.

Tout d' abord la chaîne de format est intégré dans $_et quadruplicated, tous ss sont remplacés par les correspondants, support <, <=ou des espaces, en fonction de l'indice de remplacement. J'espérais économiser quelques octets de plus avec la duplication des 5 derniers caractères de chaque bloc, mais cela n'a fini par économiser 2 octets. La chaîne résultante est divisée en éléments d'espaces <=ou en caractères uniques.

Enfin, tous les ds sont remplacés par le nombre souhaité qui est ajusté en fonction de l'index du remplacement actuel via une clé de hachage.

JavaScript, 190 189 octets

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

Essayez-le en ligne

m4 , 194

On dirait un travail pour un macro processeur. Je ne sais pas si m4 répond à nos normes pour un langage de programmation. Il a une capacité de boucle et une évaluation arithmétique, donc je suppose que c'est proche de la marque.

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

Ceci est mon premier regard non trivial sur m4, donc je soupçonne qu'il y a plus d'occasions de golf que j'ai ratées.

Les entrées sont transmises à l'aide de -Ddéfinitions de macro sur la ligne de commande. Je ne sais pas si quelque chose doit être ajouté au score pour ceux-ci, pour autant que je sache, c'est la seule façon de transmettre les paramètres de manière significative:

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

Essayez-le en ligne .

Merci @Dennis d'avoir ajouté m4 à ​​TIO si rapidement!

Python 2 , 277 199 193 189 189 octets

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`

Essayez-le en ligne!

Excel, 399 octets

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

Rien de particulièrement intéressant ici.

C (gcc) , 224 237 octets

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

Essayez-le en ligne!

Déplacer le "<[=]" dans la chaîne de format m'a permis de supprimer complètement le tableau. En outre, le déplacement printf()dans la forboucle a enregistré un point-virgule.

Réponse 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);}}

Essayez-le en ligne!

Il n'y a rien de particulièrement remarquable ici: j'ai utilisé les astuces habituelles pour raser la taille de la fonction (hisser les intautos dans l'en-tête de la fonction, utiliser le style K&R, indexer dans les constantes de chaîne.) Stocker le {"<=", "<"} dans un tableau s'est avéré plus efficace en termes de taille que l'insertion d'un spécificateur de format pour ce défi car il a été utilisé plusieurs fois.

Javascript, 273 258 232 octets

Merci à Kevin Cruijssen de m'avoir sauvé 15 octets!

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

Essayez-le en ligne

Merci à TFeld de m'avoir donné cette idée, économisant environ 60 octets par rapport à ma réponse d'origine.

Non golfé:

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 (réponse originale), 340 octets

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

Rétine , 216 octets

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

Essayez-le en ligne! Explication:

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

Construisez l'essentiel du résultat.

_<=

Si la variable est impliquée dans une inégalité lâche, alors la valeur est inclusive, nous pouvons donc supprimer l'espace réservé.

\d+_
$&*___

Convertissez la valeur en unaire et ajoutez 2.

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

Supprimez l'espace réservé pour une inégalité stricte inférieure ou une inégalité supérieure stricte négative. Il en reste encore 2 ajoutés, mais 1 sera soustrait plus tard, donnant le résultat souhaité.

___<
_

Soustrayez 2 des autres inégalités strictes non nulles, en restaurant la valeur d'origine, à laquelle 1 sera soustrait plus tard.

__<
-1

Modifiez une stricte inégalité supérieure de 0à -1.

_(_*)
$.1

Soustrayez 1 des inégalités strictes restantes et convertissez-les en décimales.

-0
0

Réparez un autre cas de bord.

Python 3, 180 octets:

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

explication

Fondamentalement, construit une chaîne f qui est évaluée dans une compréhension de liste. L' %interpolation de chaîne à l' ancienne est utilisée pour retarder l'évaluation des expressions jusqu'à ce que la chaîne f soit évaluée.

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 première partie de la chaîne, «f», deviendra le préfixe de la chaîne f.

La deuxième partie de la chaîne crée la chaîne de format pour les deux premières expressions d'intervalle. %rest utilisé pour éviter d'avoir à mettre des guillemets au format, c'est-à-dire qu'il "{%r[j]}"est le même que "{'%s'[j]}". Lorsque la chaîne f est évaluée, le crochet correct est sélectionné.

La troisième partie de la chaîne crée les deux expressions d'intervalle suivantes.

La dernière partie formate la partie "a..b" de la chaîne f.

La chaîne f assemblée ressemble à: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

Lorsque la chaîne f est évaluée, toutes les expressions entre accolades {}sont remplacées par leur valeur. Donc, {a}est remplacé par la valeur de a, et {'(['[j]}est remplacé par (si j est 0 ou [si j est 1.

SOGL V0.12 , 110 octets

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

Essayez-le ici!

Python 3, 248 octets

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

Essayez-le en ligne!