Reto:

Entrada:

Dos parámetros enteros ay b(donde a<by la diferencia es al menos 2)

Salida:

Imprima o devuelva este texto, donde ay bse completan:

(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

Reglas de desafío:

• I / O es flexible. Puede imprimirse en STDOUT, devolverse como una cadena / matriz de caracteres, etc. Puede ingresarse como dos enteros, decimales, cadenas (no estoy seguro de por qué, ya que necesita calcular el a+1y b-1, pero ser mi invitado ...), etc.
• Se permite cualquier cantidad de nuevas líneas iniciales y / o finales, y se permite cualquier cantidad de espacios finales y / o iniciales para cada línea.
• Los espacios en los signos iguales (incluidos aquellos para alinearlos en la misma columna) son obligatorios, no se permiten espacios entre los otros caracteres.
• a+1y b-1se reemplazan con los valores correctos después de estos cálculos.
• No está permitido usar en ≤lugar de <=.
• No está permitido usar en &lugar de &&.
• Puede emitir los números con .0(siempre que sea coherente y no más de un cero decimal).
• Puede suponer que aes al menos 2 menor que b(para (a,b)ser correcto).
• Las líneas deben salir en el orden que se muestra.

Ejemplo:

Entrada: a=-5, b=10
Salida:

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

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

PD: Para aquellos que habían visto este desafío en el recinto de seguridad , cuando todavía era un Kolmogorov-complejidad reto con ay bno modificable, he cambiado a un desafío de entrada para evitar aburrido respuestas codificadas de forma rígida y codificados como usualmente vemos con KC desafíos.

Stax , 74 bytes

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

Ejecutar y depurarlo

Esto utiliza las plantillas de cadena de stax en gran medida. Desempaquetado, sin golf y comentado, se ve así.

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

Ejecute este

JavaScript (ES6), 184 182 181 180 bytes

Toma entrada en la sintaxis de curry (a)(b). Devuelve una matriz de 4 cadenas.

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

Pruébalo en línea!

¿Cómo?

Para cada fila k con 1 ≤ k ≤ 4 , comenzamos con la siguiente plantilla:

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

y reemplace cada dígito decimal n en la posición i de acuerdo con la siguiente tabla:

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

Pruébalo en línea!

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`

Pruébalo en línea!

Java (JDK 10) , 251 bytes

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

Pruébalo en línea!

Créditos

• -50 bytes gracias a Kevin Cruijssen

Perl 5 , 181 bytes

Pensé que esto habría funcionado mucho más corto ...

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

Pruébalo en línea!

Explicación

Originalmente, esto estaba usando una printfcadena de formato, pero solo tenía sy dera más corto cuando se combinaba con s///.

Primero, la cadena de formato está integrada en $_ y cuadruplicó, a continuación, todos los ss son reemplazados con el soporte, lo que corresponde <, <=o espacios, en función del índice de sustitución. Esperaba guardar algunos bytes más con la duplicación de los últimos 5 caracteres de cada bloque, pero esto solo terminó ahorrando 2 bytes. La cadena resultante se divide en elementos de espacios <=o caracteres individuales.

Finalmente, todos los ds se reemplazan con el número deseado que se ajusta según el índice del reemplazo actual a través de una tecla hash.

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

Pruébalo en línea

m4 , 194

Parece un trabajo para un procesador macro. No estoy seguro si m4 cumple con nuestros estándares para un lenguaje de programación. Tiene capacidad de bucle y evaluación aritmética, por lo que supongo que está cerca de la marca.

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

Este es mi primer vistazo no trivial a m4, por lo que sospecho que hay más oportunidades de golf que he perdido.

Las entradas se pasan utilizando -Ddefiniciones de macro en la línea de comando. No estoy seguro de si es necesario agregar algo al puntaje para estos, por lo que puedo decir, esta es la única forma de pasar parámetros de manera significativa:

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

Pruébalo en línea .

¡Gracias @Dennis por agregar m4 a TIO tan rápido!

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`

Pruébalo en línea!

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

Nada particularmente interesante aquí.

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

Pruébalo en línea!

Mover el "<[=]" en la cadena de formato me permitió eliminar la matriz por completo. Además, pasar printf()a lafor bucle salvó un punto y coma.

Respuesta original

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

Pruébalo en línea!

Aquí no hay nada particularmente notable: utilicé los trucos habituales para reducir el tamaño de la función (elevar intautos al encabezado de la función, usar el estilo K&R, indexar en constantes de cadena). Almacenar el {"<=", "<"} en un La matriz demostró ser más eficiente en tamaño que insertar un especificador de formato para este desafío, ya que se usó más de una vez.

Javascript, 273 258 232 bytes

¡Gracias Kevin Cruijssen por salvarme 15 bytes!

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

Pruébalo en línea

Gracias por TFeld por darme esa idea, ahorrando alrededor de 60 bytes de mi respuesta original.

Sin 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 (respuesta original), 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`)

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

Pruébalo en línea! Explicación:

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

Acumula la mayor parte del resultado.

_<=

Si la variable está involucrada en una desigualdad flexible, entonces el valor es inclusivo, por lo que podemos eliminar el marcador de posición.

\d+_
$&*___

Convierta el valor a unario y agregue 2.

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

Elimine el marcador de posición para una desigualdad inferior estricta o una desigualdad superior estricta negativa. Todavía tiene 2 agregados, pero 1 se restará más tarde, dando el resultado deseado.

___<
_

Reste 2 de las otras desigualdades estrictas distintas de cero, restaurando el valor original, del cual se restará 1 más adelante.

__<
-1

Cambiar una estricta desigualdad superior de 0 a -1.

_(_*)
$.1

Resta 1 de las desigualdades estrictas restantes y convierte a decimal.

-0
0

Arregle otro caso de borde.

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

explicación

Básicamente construye una cadena f que se evalúa en una comprensión de la lista. La %interpolación de cadenas de estilo antiguo se usa para retrasar la evaluación de las expresiones hasta que se evalúe la cadena 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)
    ]

La primera parte de la cadena, 'f "', se convertirá en el prefijo de la cadena f.

La segunda parte de la cadena construye la cadena de formato para las dos primeras expresiones de intervalo. %rse utiliza para evitar la necesidad de poner comillas en el formato, es decir, "{%r[j]}"es lo mismo que"{'%s'[j]}" . Cuando se evalúa la cadena f, se selecciona el corchete correcto.

La tercera parte de la cadena construye las siguientes dos expresiones de intervalo.

La última parte formatea la parte "a..b" de la cadena f.

La cuerda f ensamblada se ve así: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

Cuando se evalúa la cadena f, todas las expresiones entre llaves {}se reemplazan por su valor. Entonces, {a}se reemplaza por el valor de a, y {'(['[j]}se reemplaza por (si j es 0 o [si j es 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↑æ‘┼

Pruébalo aquí!

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

Pruébalo en línea!