Como é sabido ,

Chuck Norris contava até o infinito. Duas vezes

Além disso ,

Chuck Norris pode contar até o infinito para trás.

Além disso, embora talvez menos conhecido, Chuck Norris pode falar um pouco de espanhol , além do inglês.

O desafio

Escreva um programa (ou função) que possa ser executado em dois idiomas diferentes. Em um idioma, o programa deve exibir a sequência

1, 1, 2, 2, 3, 3, 4, 4, ...

e no outro idioma deve produzir a sequência (incluindo zeros à esquerda)

1, 2, ..., 9, 01, 11, 21, 31, ..., 89, 99, 001, 101, 201, ...

Regras

• Programas ou funções são permitidos, em qualquer linguagem de programação . As brechas padrão são proibidas.
• Versões diferentes do mesmo idioma (como Python 2/3) não contam como idiomas diferentes. Idiomas relacionados (como C / C ++ ou Matlab / Octave) contam como diferentes.
• Nenhuma entrada será aceita.
• O programa deve continuar a emitir termos da sequência até que seja interrompido pelo usuário. Como o programa não para por si só, a saída não pode ser produzida no final. Ele deve ser produzido enquanto o programa é executado, continuamente ou em lotes.
• A saída pode usar STDOUT ou equivalente, ou pode ser exibida em uma janela gráfica. Qualquer separador não numérico entre os termos da sequência é permitido, desde que cada termo possa ser claramente distinguido dos termos vizinhos. Também é aceitável se a tela for limpa entre os termos.
• Qualquer sequência pode começar em 0vez de 1. Nesse caso, na sequência "duas vezes", 0deve ser repetido, assim como os outros números.
• Os zeros à esquerda são significativos na sequência "para trás". Por exemplo, o décimo termo é 01; nem 1nem 001são aceitáveis.
• Se os dois idiomas usarem codificações de caracteres diferentes, o programa será definido por seus bytes , não por seus caracteres. Ou seja, os bytes devem ser os mesmos nos dois idiomas.
• O menor código em bytes vence.

05AB1E / Jelly ,  14  13 bytes

-1 byte graças a Adnan (evite triplicar com impressão que não se abre)

Bytes brutos (hexadecimal):

31 5b 3d 3d 3e 5d fc 06 b6 3b 87 08 15

Em 05AB1E 's código-página :

1[==>]üε¶;‡ηΩ

Experimente online!

Em Jelly 's código-página :

1[==>]‘©Ṛ;⁷®ß

Experimente online!

Quão?

O programa 05AB1E imprime a contagem dupla com cada entrada separada por novas linhas:

1[==>]üε¶;‡ηΩ
1             - push 1 onto the stack
 [            - start infinite loop:
  =           - print top of stack
   =          - print top of stack
    >         -   increment the top of the stack (pop(1), x+=1, push)
     ]        - end the infinite loop
      üε¶;‡ηΩ - this code is never executed nor is it parsed

O programa Jelly imprime a contagem revertida com cada entrada separada por novas linhas.

O analisador tratará um literal válido entre [e ]como o literal incluso; caso contrário, esses bytes serão tokens indefinidos e, como tal, se tornarão equivalentes aos tokens que separam o código em linhas. ==>não analisa como literal, portanto, o código é efetivamente:

1 - link 1 (not executed but parsed)
1 - literal 1

==> - link 2 (not executed but parsed)
=   - left equals right? (vectorises)
 =  - left equals right? (vectorises)
  > - is greater than the right argument? (vectorises)

‘©Ṛ;⁷®ß - Main link: no arguments
‘       - increment (implicit 0 on left increments to 1 on the first pass)
 ©      - copy the result to the register and yield it
  Ṛ     - reverse, this has an implicit decimal list build, e.g. 142 -> [2,4,1]
    ⁷   - a newline character
   ;    - concatenate, e.g. [2,4,1] -> [2,4,1,'\n']
     ®  - recall the number from the register, e.g. 142
        - The chain has reduced to one item of arity 0, causing a pre-evaluation print:
        -     ...and since the list contains a character it gets smashed together
        -     e.g. [2,4,1,'\n'] prints 241 followed by a newline character
      ß - call this link with the same arity, e.g. as a monad with left = 142

Python 2 / C (clang) , 109 107 100 84 95 88 89 88 87 84 bytes

i=0;
#/*
while 1:i+=1L;print`i`[::-1]
'''*/
a(){for(;;)printf("%i %1$i ",++i);}//'''

Python: Experimente online!

C: Experimente online!

OL no código Python faz parte do delimitador.

Explicação:

No código C, ele primeiro define i como 0. Em seguida, ele inicia um comentário ( #é um código válido em C para #includeinstruções) para onde o código Python vai. No final do comentário, define uma função que incrementa para sempre uma variável e a imprime duas vezes, delimitada por espaço. Em seguida, começa um comentário.

No código Python, i=0;define i como zero. Python ignora a próxima linha porque #inicia um comentário de linha única. Em seguida, ele o incrementa para sempre e o transforma em um número longo e imprime sua representação de sequência invertida. O 'L' do long faz parte do delimitador. Depois disso, ele inicia uma string de várias linhas para comentar o código C, que termina mais tarde.

-2 bytes graças a @LuisMendo. -7 bytes graças a @ZacharyT. -6 mais bytes graças a @ZacharyT. +11 bytes para corrigir um erro, graças a @ mbomb007. -7 bytes graças a @Doorknob. +1 byte para corrigir um erro, graças a @Doorknob. -1 byte graças a @yoann. -1 byte a mais, graças a @yoann. -3 bytes graças a @Cyoce.

Gelatina / Pyth, 15 bytes

.V1_`b;"1üÉÉ$

Os imprimíveis são mutilados pelo software SE, então aqui está um hexdump:

00000000: 2e56 315f 6062 3b22 7f31 fcc9 c924 0b    .V1_`b;".1...$.

Corra com jelly f filee pyth filerespectivamente.

Explicação

Primeiro vem a parte Pyth. .Vexecuta um loop infinito sobre a sequência incremental iniciando em sua entrada, que está aqui 1. Em seguida, invertemos ( _) o `índice de loop stringified ( ) ( b) e o produzimos implicitamente. O ;que há para terminar o loop, e "é necessário tratar o resto do programa como uma string literal para que o analisador não sufocá-lo.

A parte Jelly será explicada traduzindo primeiro o restante do programa da página de códigos Jelly:

¶1‘ṄṄ$¿

Ele ¶atua como um feed de linha, ignorando efetivamente a primeira parte do programa, tornando-o um link que nunca é chamado. Então começamos 1e executamos um loop while ( ¿) que usa ṄṄ$(imprime duas vezes) como sua condição e incrementa ( ‘) o valor como o corpo do loop.

Aliás, substituindo a parte Pyth com 1[DR,>] iria criar uma submissão Jelly / 05AB1E válida em 14 bytes, mas o interpeter atual contém um bug que impede isso.

Perl / JavaScript, 87 bytes

s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}

Perl

s/0;print/console.log;m/s;$_=s/s/s/m;while(++$_){print((/s,$_+`
`+$_||/&&reverse.$/))}

Um mecanismo que eu usei muito em polyglots JS / Perl é abusar do fato de que a substituição pode aceitar praticamente qualquer delimitador, utilizando =meios que podem utilizar as substituições iniciais inúteis (substituindo primeiro 0;printcom console.log;mcom uma bandeira de /sem $_, que é actualmente undef) , definindo $_o resultado da substituição spor sno modo multilinha ( /m), que é 0. Agora $_é 0e inicio o whileloop, isso então é incrementado $_. Em seguida, chamoprint , passando uma expressão regular que corresponde (devido ao ||final que corresponde a uma string vazia) e uso o &&operador para enviar o inverso de $_concatenado com uma nova linha ($/é pré-inicializado para "\n"). Isso conta para o infinito para trás.

Javascript

s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}

Muitas atribuições de variáveis ​​aqui, mascaradas nas s///chamadas Perl . Eu configurar variáveis se mcomo 0, aliás console.logpara print, executar alguma divisão inútil, definir $_para 0e iniciar o whileincremento de loop $_, chame printpassando em 0( m/s, este começa a chamada para mem Perl, mas é tratado como divisão padrão em JS) e nossa cadeia de destino ( $_+"\n"+$_) via operador de vírgula, que retorna o último item da lista. Evito a última parte do código Perl ( &&reverse.$/) porque $_+"\n"+$_será verdadeira e, portanto, posso usar ||para produzir um RegExpobjeto contendo o final do código Perl que nunca é avaliado.

Testado usando Perl 5 e Nó 6.

NodeJS / PHP, 131 106 bytes

-25 bytes graças a @Titus

<!--
printf=(_,i)=>process.stdout.write(i+i),strrev=i=>i+" "//--><?
for($i=0;;)printf("%s ",strrev($i++));

Usando o NodeJS em vez do JS do navegador para melhor formatação de saída e melhor manipulação de loop infinito.

Experimente o JavaScript online
Experimente o PHP online

Observe que a saída TIO é cortada após 128 KB.

V / Brain-flak Classic , 27 , 26 bytes

(()){[[({}())[]]]}é1òÙæ_æ

Hexdump:

00000000: 2828 2929 7b5b 5b28 7b7d 2829 295b 5d5d  (()){[[({}())[]]
00000010: 5d7d e931 f2d9 e65f 01e6                 ]}.1..._..

Experimente online! em V (modificado levemente para terminar, para que você possa ver a saída. No TIO, V sai apenas se o programa terminar)

Experimente online! no clássico Brain-flak

Esta não é a poliglota mais interessante, já que o código V não tem efeito no clássico contra ataques cerebrais e vice-versa, no entanto, é realmente divertido usar meus dois idiomas em um desafio, e as duas soluções são bem interessantes por conta deles.

V Explicação:

é1              " Insert a '1'
  ò             "   Recursively:
   Ù            "   Duplicate this number
    æ_          "   Flip this line
      <C-a>     "   Increment the number on this line
           æ    "   Flip it back (the '_' is implicit because it's at the end of the program)

Explicação BFC:

#Push a one onto the main stack
(())

#Forever:
{

  #Print twice:
  [[

    #Increment the top of the stack.
    #Evaluates to *i + 1*
    ({}())

    #Minus one
    []
  ]]

#Endwhile
}

Retina / Python 2, 61 bytes

#{*M`
#*M`
"""

}`$
1
""";i=1
while 1:print str(i)[::-1];i+=1

retina | Python 2

R / Oitava , 83 80 78 71 bytes

-3 bytes graças a Luis Mendo

i=0;
while(1)
#{
print(c(i<-i+1,i))
#}
disp(flip(num2str(i)))
i+=1;
end

#{ }#é um comentário em bloco de oitava e #é o comentário para R. O intérprete R vê apenas a próxima linha como o corpo dowhile loop, e o intérprete Oitava pula para o código Oitava

A parte R imprime pares de números começando em 1 e a parte Octave imprime os números anteriores começando em 0.

Espero totalmente ser derrotado (mesmo pela mesma combinação de idiomas); Acabei de escrever tanto código Matlab e R recentemente que pensei em tentar.

Experimente online! - Link de oitava

Ruby / Python2: 68 64 bytes

i=0
"#{loop{p i+=1,i}}"
exec('while 1:print str(i)[::-1];i+=1')

Perspectiva Ruby

init simples da variável:

i = 0

"#{}"é uma sintaxe para interpolação de cadeias. Eu o uso para executar a expressão em vez disso.

"#{loop{p i+=1,i}}"

pé uma abreviação de puts.loopcria um loop infinito.

Em seguida, existe a execcoisa, mas ela nunca é avaliada, pois o loop infinito é, por definição, infinito. Necessárioexec para não gerar erro de sintaxe com o código Python.

Perspectiva do Python

Da perspectiva do Python, existe um comum i=0. Em seguida, o Python possui uma sintaxe diferente para a interpolação de strings; portanto, essa linha é simplesmente descartada. Em seguida, há um loop infinito semelhante ao que os outros postaram.

Bash / Check , 50 28 bytes

^{Agradecemos ao @Doorknob por salvar um monte de bytes alternando de Python para Bash}

#>
#v
 #p<p<)#
seq 1 inf|rev

Agredir:

#>
#v
 #p<p<)#

Estes são apenas alguns comentários, que são ignorados.

seq 1 inf|rev

Inicie uma sequência que vai de 1 ao infinito e depois canalize o resultado para rev.

Checar:

#>

Isso muda imediatamente para o modo 2D, indo para a direita. >direciona o IP certo, o que não tem efeito. Ele volta para o início da linha e acerta #novamente, o que sai do modo 2D. Em seguida, ele atinge o >modo 1D, que empurra 0 para a pilha. Por estar no modo 1D, o IP passa para a próxima linha.

#v

#alterna o IP para o modo 2D novamente e o vdireciona para baixo.

 #p<p<)#

O primeiro #volta ao modo 1D novamente. pgera os TOS como um número (mas não o <exibe ) e imprime uma nova linha. Isso é feito duas vezes e, em seguida, o número é incrementado ). #alterna para o modo 2D novamente, então o IP passa para o início da linha, #pressiona para alternar para o modo 1D, etc.

CJam /> <>, 27 23 bytes

"la,:naonao
"1{_sW%n)}h

Para CJam:

Experimente online! - observe que você precisa aguardar o limite de 60 segundos para ver a saída, mas funciona offline.

"la,:naonao
"

Isso define um literal de seqüência de caracteres de várias linhas que nunca é usado.

 1{_sW%n)}h

A segunda linha é assim:

1     e# Push 1:               | 1 
{     e# Forever:              | 1
  _   e#   Duplicate:          | 1 1
  s   e#   Convert to string:  | 1 "1"
  W%  e#   Reverse:            | 1 "1"
  n   e#   Print with newline: | 1
  )   e#   Increment:          | 2
}h    e# End loop

Para> <>:

"

Inicia uma string literal.

 la,:naonao

Conteúdo da cadeia literal. Cada um dos códigos de caracteres é enviado individualmente para a pilha.

"

O IP se aproxima para alcançar "novamente, o que termina o modo de sequência.

 la,

lpega o comprimento da pilha, aempurra 10 e ,divide. Isso nos dá o comprimento da pilha / 10.

    :nao

:duplica, nimprime como um número, apressiona 10 e oimprime como um código de caractere (uma nova linha).

        nao

Mesma coisa. Imprima o número seguido por uma nova linha. A pilha agora tem o tamanho 10 novamente (o conteúdo do literal da string original está na pilha).

O IP então volta para o "novo, levando a mais 10 elementos a serem enviados. Próxima vez,l retorna 20, então 2 é impresso, etc.

A segunda linha nunca é tocada pelo IP.

Röda / C (gcc) , 90 bytes

main(){f(0);}f(a){a=1//1{[` $a`[::-1]];a++}while[]/*
;for(;;a++)printf("%d %d ",a,a);/**/}

Röda: Experimente online!

C: Experimente online!

Explicação

Isso abusa do fato de que // é int divison em Röda, mas um comentário de linha em C.

Nos dois idiomas, main(){}denota o programa principal e ambos chamam função fcom um argumento fictício de0 .

Em Röda, a=1//1faz divisão int e atribui o resultado 1a a. C vê a=1e faz a mesma coisa, mas tudo depois dessa atribuição é um comentário para C. A partir daí, os dois idiomas se ramificam.

Röda

Temos um loop infinito com while[]( uma condição vazia é verdadeira ). Dentro disso, ` $a`converte o número inteiro aem uma seqüência de caracteres (com um espaço à esquerda), após o qual o [::-1]reverte (e gera um espaço à direita). Então o valor de aé incrementado em um.

Fora do loop while, um comentário multilinha é iniciado /*e finalizado imediatamente antes do final da função.

C

Depois de ter ignorado o restante da linha, o programa passa para a segunda linha. Começamos com um ponto-e-vírgula porque a a=1instrução precisa ser encerrada. Depois disso, encontramos um loop for simples que imprime a variável de iteração,, aduas vezes em cada iteração.

Fora do loop for, /*existe apenas para ignorar o */comentário final de Röda .

QBIC / QBasic 4.5 , 58 bytes

do
p=p+1
if q then
'?`_f!p$|
else
?p,p,
end if
loop

Isso abusa bastante do fato de que todas as letras minúsculas são vistas como código QBasic literal pelo interpretador QBIC e, portanto, são repassadas para a camada QBasic do QBIC. Como os dois idiomas veem esse código lado a lado:

LOC         QBasic                    QBIC
-------------------------------------------------------
do                   Start an infinite loop
p=p+1                Increment p, starts off as 0
if q then    q = 0, goto ELSE         q = 1, execute IF
'?`_f!p$|    ' = comment, invalid     '?` is a 'code literal', passing PRINT to QBASIC
             syntax is ignored        followed by QBIC code to flip p cast as string.
else         q=0, execute             q=1, so ignored
?p,p,        PRINT p twice,
             separated by tab
end if               End of the branching logic
loop                 Wrap around for the next pass

laserLANG / > <> , 163 bytes

!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

Golfe pela primeira vez, por isso é um pouco maior do que provavelmente poderia ser. Eu queria usar> <>, mas como algumas pessoas já o usavam para criar a segunda sequência, decidi que queria criar a primeira sequência.

Experimente> <> online!
Para o laserLANG, é necessário um intérprete offline para experimentá-lo. Pode ser encontrado aqui .

laserLANG

!\
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

começa a execução na !qual é completamente ignorado. então ele alcança o \e começa a viajar por vários caracteres que ignora completamente. Finalmente chega a outro \e começa a diversão. Basicamente, aceitei a ideia por trás do "Olá, mundo!" loop e condensou o melhor que pude. Foi um grande desafio lidar com o fato de que o laserLANG está prestes a diminuir / incrementar o contador de memória quando o contador do programa está indo para a esquerda / direita, respectivamente. Eu sinto que a maioria dos bytes poderia ser salva aqui, fazendo alguns truques em que não pensei.

> <>

!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l

A execução é iniciada, fazendo com !que ela ignore o arquivo \. Em seguida, continua como se o código laserLANG não estivesse lá. Eu não sabia que> <> só tinha suporte para a divisão de flutuação, então um truncamento curto e simples era um pouco confuso no começo.

Befunge-98 / > <> , 32 bytes

\r.#%a/# :_::p#+a#1,#
>l::naonao

Escrevi isso antes de ver quantas ><>respostas havia. Alguns antecedentes: \é um operador de mudança de direção em> <>, nesse caso, pressionando-o para baixo, enquanto no Befunge ele troca os dois itens principais da pilha. O código Befunge se parece com:

\r.#%a/# :_::p#+a#1,#

Experimente online!

Imprime os números anteriores, separados por novas linhas. O Befunge imprime um espaço automaticamente após cada número, para que cada dígito seja separado por espaços. Obtém repetidamente o último dígito, imprime e divide o número por 10 até chegar a 0. Em seguida, aumente e repita.

O código> <> desce imediatamente para a segunda linha.

>l::naonao

Experimente online!

E é bem simples. Obtenha o comprimento da pilha, imprima duas vezes com novas linhas e deixe uma cópia do comprimento na pilha para o próximo loop.

Ruby / Stacked , 37 bytes

0#/0[1+:tostr rev out]
loop{p p$.+=1}

Experimente online!

Isso imprime 1 1 2 2... em Ruby e 1 2 3 ... 01 11 21...em Stacked.

Explicação

Em Ruby:

0#/0[1+:tostr rev out]
loop{p p$.+=1}

Depois de remover o comentário, isso se torna:

0
loop{p p$.+=1}

A única linha relevante aqui é a última. pretorna seu argumento, então p pimprime seu argumento duas vezes. $.começa em 0, então $.+=1incrementa $., retornando o valor incrementado. Portanto, isso imprime cada número 1duas vezes.

Em empilhados:

0#/0[1+:tostr rev out]
loop{p p$.+=1}

Isso é equivalente aos seguintes tokens:

0 #/ 0 [ 1 + : tostr rev out ] loop { p p $ . + = 1 }

Os dois primeiros não são relevantes (basicamente, transformando-se 0em uma fração reduzida). Em seguida, 0é enviado para a pilha. Depois, a função [1+:tostr rev out]é enviada para a pilha. loopaparece essa função e a executa infinitamente.

A parte interna da função incrementa a parte superior da pilha ( 1+), a duplica ( :), a converte em uma string ( tostr), a inverte ( rev) e a gera ( out). Este processo é repetido infinitamente. Como o loop é infinito, tudo o que vem depois desse token é essencialmente ignorado pelo intérprete.

> <> / Jelly , 37 bytes (25 na página de códigos do Jelly)

01+:nao:nao!
DU;⁷Ṙ€
®‘©Çß

Experimente> <> online!

Experimente o Jelly online!

> <> imprime a sequência até o infinito duas vezes, Jelly conta para trás.

> <> preocupa-se apenas com a linha superior:

E obrigado ao @ Challenger5 por salvar alguns bytes aqui no avanço de linha

01+:nao:nao!                           Stack at: 1st run   2nd run ...
0                 Push a 0             0         -
 1                Push a 1             0,1       1,1   
  +               Pop 2, add them      1         2 
   :              Duplicate top item   1, 1      2, 2
    n             Pop top, show as num 1         2
     a            Push the number 10   1, 10     2, 10
      o           Pop and show 10 as an ACII char (ie '\lf')
                                       1         2
         :nao     And again, for repetition
             !    ><> wraps around; this skips pushing a 0 again.

Jelly executa seu código de baixo para cima. Apenas as duas últimas linhas são relevantes.

®‘©Çß       main link, keeps track of the current number

®           Get a number from the register (0 on first run)
 ‘          Increment that by 1
  ©         Store in register
   Ç        Call helper (printer) link
    ß       Call this link again

DU;⁷Ṙ€      Printer

            (Say we are at number 21)
D           Break into digits         [2, 1]
 U          Reverse array             [1, 2]
  ;⁷        Append a line break       [1, 2, \n]
    Ṙ€      Print each char in array

C (gcc) / PHP , 102 86 80 bytes

#//\
for(;;)echo strrev(++$i).'
int main(i){for(;;i++)printf("%d %d ",i,i);}//';

Produz a sequência dupla em C e a sequência reversa em PHP.

Experimente em C!

Experimente em PHP!

Explicações

C

Em C, o #material do pré-processador de formulários. Eu realmente não sei muito sobre C, mas não reclamo quando há alguma linha vazia para essas coisas. O //formulário forma um comentário de linha. UMA\ no final de uma linha está essencialmente "escapando" da nova linha e fazendo com que as duas linhas sejam tratadas como uma. Isso também funciona para comentários de linha; portanto, a segunda linha é vista como um comentário em C. A terceira linha faz o trabalho de emitir os números com um loop for simples. Depois, há simplesmente um comentário.

PHP

No PHP, #forma um comentário de linha, portanto a primeira linha é totalmente ignorada. A segunda linha imprime os números invertidos com um loop for e os separa com \nint main(i){for(;;i++)printf("%d %d ",i,i);}//(o código C envolto em uma string).