Desafio:

Entrada:

Dois parâmetros inteiros ae b(onde a<be a diferença é pelo menos 2)

Saída:

Envie ou retorne este texto, onde ae bé preenchido:

(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

Regras do desafio:

• A E / S é flexível. Pode ser impresso em STDOUT, retornado como uma seqüência de caracteres / matriz, etc. Pode ser inserido como dois números inteiros, decimais, seqüências de caracteres (não sei por que, desde que você precisa calcular a+1e b-1, mas seja meu convidado ...), etc.
• Qualquer quantidade de novas linhas à esquerda e / ou à direita é permitida, e qualquer quantidade de espaços à direita e / ou à esquerda para cada linha.
• Os espaços nos sinais de igual (incluindo aqueles para alinhá-los na mesma coluna) são obrigatórios, espaços entre os outros caracteres não são permitidos.
• a+1e b-1são substituídos pelos valores corretos após esses cálculos.
• Você não tem permissão para usar em ≤vez de <=.
• Você não tem permissão para usar em &vez de &&.
• Você tem permissão para emitir os números com .0(desde que sejam consistentes e não mais que um zero decimal).
• Você pode assumir que aé pelo menos 2 menor que b( (a,b)para estar correto).
• As linhas devem ser exibidas na ordem mostrada.

Exemplo:

Entrada: a=-5, b=10
Saída:

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

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

PS: Para aqueles que tinham visto este desafio no Sandbox quando ainda era um Kolmogorov-complexidade desafio com ae bhard-coded, eu mudei-o para um desafio de entrada para evitar chato respostas codificados e codificados como costumamos ver com Desafios da KC.

Stax , 74 bytes

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

Execute e depure

Isso usa fortemente os modelos de string do stax. Descompactado, não jogado e comentado, parece com isso.

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

Execute este

JavaScript (ES6), 184 182 181 180 bytes

Recebe entrada na sintaxe de currying (a)(b). Retorna uma matriz de 4 strings.

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

Experimente online!

Quão?

Para cada linha k com 1 ≤ k ≤ 4 , começamos com o seguinte modelo:

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

e substitua cada dígito decimal n na posição i de acordo com a tabela a seguir:

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

Experimente 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`

Experimente online!

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

Experimente online!

Créditos

• -50 bytes graças a Kevin Cruijssen

Perl 5 , 181 bytes

Eu pensei que isso teria funcionado muito mais curto ...

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

Experimente online!

Explicação

Originalmente, isso era usando uma printfstring de formato, mas apenas tendo se dera mais curta quando combinada com s///.

Primeiro, a sequência de formatação é incorporada $_e quadruplicada; todos os ss são substituídos pelo colchete correspondente <, <=ou espaços, dependendo do índice de substituição. Eu esperava salvar mais alguns bytes com a duplicação dos últimos 5 caracteres de cada bloco, mas isso acabou salvando apenas 2 bytes. A sequência resultante é dividida em elementos de espaços <=ou caracteres únicos.

Finalmente, todos os ds são substituídos pelo número desejado, que é ajustado com base no índice da substituição atual por meio de uma chave de 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])

Experimente online

m4 , 194

Parece um trabalho para um processador de macro. Não tenho certeza se m4 atende aos nossos padrões para uma linguagem de programação. Ele tem capacidade de loop e avaliação aritmética, então suponho que esteja próximo da 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 é o meu primeiro olhar não trivial para o m4, então suspeito que tenha perdido mais oportunidades de golfe.

As entradas são transmitidas usando -Ddefinições de macro na linha de comandos. Não tenho certeza se alguma coisa precisa ser adicionada à pontuação para eles, tanto quanto posso dizer, essa é a única maneira de passar parâmetros de forma 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 $

Experimente online .

Obrigado @Dennis por adicionar m4 ao TIO tão rapidamente!

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`

Experimente 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

Nada particularmente interessante aqui.

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

Experimente online!

Mover o "<[=]" para a cadeia de formato permitiu-me remover completamente a matriz. Além disso, a mudança printf()para o forloop salvou um ponto e vírgula.

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

Experimente online!

Não há nada particularmente digno de nota aqui: usei os truques comuns para reduzir o tamanho da função (içar intautomóveis no cabeçalho da função, usar o estilo K&R, indexar em constantes de seqüência de caracteres). Armazenar o {"<=", "<"} em um O array mostrou-se mais eficiente em tamanho do que inserir um especificador de formato para esse desafio, pois foi usado mais de uma vez.

Javascript, 273 258 232 bytes

Obrigado Kevin Cruijssen por me salvar 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]})

Experimente online

Obrigado por TFeld por me dar essa idéia, economizando cerca de 60 bytes da minha resposta original.

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

Experimente online! Explicação:

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

Construa a maior parte do resultado.

_<=

Se a variável estiver envolvida em uma desigualdade fraca, o valor será inclusivo, para que possamos excluir o espaço reservado.

\d+_
$&*___

Converta o valor em unário e adicione 2.

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

Remova o espaço reservado para uma desigualdade inferior estrita ou uma desigualdade superior estrita negativa. Ainda foram adicionados 2, mas 1 será subtraído mais tarde, fornecendo o resultado desejado.

___<
_

Subtraia 2 das outras desigualdades estritas diferentes de zero, restaurando o valor original, do qual 1 será subtraído posteriormente.

__<
-1

Altere uma desigualdade superior estrita de 0para -1.

_(_*)
$.1

Subtraia 1 das desigualdades estritas restantes e converta em decimal.

-0
0

Corrija outro estojo de borda.

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

explicação

Cria basicamente uma string f que é avaliada em uma compreensão de lista. A %interpolação de string no estilo antigo é usada para atrasar a avaliação das expressões até que a string f seja avaliada.

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

A primeira parte da string, 'f "', se tornará o prefixo da string f.

A segunda parte da string cria a string de formato para as duas primeiras expressões de intervalo. %ré usado para evitar a necessidade de colocar aspas no formato, ou seja, "{%r[j]}"é o mesmo que "{'%s'[j]}". Quando a string f é avaliada, o suporte correto é selecionado.

A terceira parte da string cria as próximas duas expressões de intervalo.

A última parte formata a parte "a..b" da string f.

A string f montada se parece com: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

Quando a string f é avaliada, todas as expressões entre chaves {}são substituídas por seu valor. Portanto, {a}é substituído pelo valor de ae {'(['[j]}é substituído por (se j for 0 ou [se j for 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↑æ‘┼

Experimente aqui!

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

Experimente online!