Cenário

Um de seus amigos está lutando para fazer uma tarefa de casa. Ele precisa de um programa simples que imprima os primeiros 404 números naturais:

1 2 3 4 5 6 7 8 9 10 11 ... 401 402 403 404

Seu desafio é simples: escreva este programa para ele.

No entanto, sua conexão é terrível, portanto, 1 caractere aleatório é perdido toda vez que você envia o programa. Para impedir que isso interrompa seu programa, você deve fazer isso para que remover qualquer caractere único não tenha efeito: o programa funciona, independentemente. (O programa original também deve funcionar.)

Como a conexão é muito ruim para enviar arquivos grandes, seu código deve ser o mais curto possível.

_{TL: DR - faça um programa endurecido por radiação para emitir os números de 1 a 404}

Regras / Detalhes

• A saída pode ser uma lista de números inteiros em qualquer formato razoável (separados por espaços, novas linhas, vírgulas, etc.). No entanto, sua saída deve ser consistente e não ser alterada quando o programa for modificado.
• Os sinalizadores de linha de comando que contêm lógica, executam código real, geram a lista de números etc. são proibidos.
• Isso é código-golfe , então a submissão mais curta (em bytes) vence!

05AB1E , 12 bytes

Código:

XX440044ÔÔŸŸ

Explicação normal do código:

X             # Pushes the number 1.
 X            # Pushes the number 1 again.
  440044      # Pushes the number 440044.
        Ô     # Connected uniquify.
         Ô    # Connected uniquify.
          Ÿ   # Inclusive range of the top two elements.
           Ÿ  # Inclusive range on the array, which leaves it intact.

Isso leva ao seguinte código de golfe:, X404Ÿque é o que queremos alcançar.

O número 404 é gerado por qualquer uma destas variantes:

440044ÔÔ
40044ÔÔ
44044ÔÔ
44004ÔÔ
440044Ô

O intervalo inclusivo funciona da seguinte maneira em dois números:

`1 5Ÿ`             ->    [1, 2, 3, 4, 5]
[1, 5]Ÿ            ->    [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]Ÿ   ->    [1, 2, 3, 4, 5]

O que sempre faz do segundo Ÿum não-op .

Usa a codificação CP-1252 . Experimente online!

JavaScript, 228 bytes

etInterval=stInterval=seInterval=setnterval=setIterval=setInerval=setIntrval=setInteval=setInteral=setIntervl=setInterva=top=>4

setInterval
`405>(i=this.i?i:1)?alert(i++):0`///`
setInterval
`405>(i=this.i?i:1)?alert(i++):0`///`

Explicação

A avaliação do código em a setIntervalpermite que o programa continue mesmo se houver um erro. Garantimos que o código transmitido terá erro se um único caractere for removido. A sintaxe da string do modelo pode ser abusada para chamar setIntervalcom uma string constante sem parênteses. Felizmente, mesmo que a string do modelo esteja na próxima linha, ela ainda será analisada como uma chamada de função com essa sintaxe.

O primeiro problema que encontramos é que setIntervalé uma função e, portanto, se um caractere for removido e o programa tentar chamar setInteval, ele errará. Obviamente, como existem duas invocações indenticas setInterval, não precisamos nos preocupar com o fato de funcionar corretamente, desde que evitemos o erro. Portanto, a primeira linha define todos os "erros ortográficos" possíveis de setTimeoutuma função válida.

A primeira linha funciona atribuindo todos esses "erros de ortografia" à função top=>4. Observe a sintaxe do ES6; isso simplesmente pega um paramater chamado "top" e retorna 4. Por que "top"? Bem, a primeira linha nunca deve gerar um erro, mesmo que um caractere seja removido. Se um =for removido para criar top>4, essa expressão booleana será válida, pois topé predefinida nos navegadores, simplesmente produzindo false. Se o 4 for removido, o corpo da função simplesmente se torna o primeirosetInterval segmento e o segundo será executado ileso.

Agora, tudo o que resta para se preocupar é se um `é removido.

Se removido desde o início, setIntervalsimplesmente não faz nada, avaliando a si próprio como sua própria expressão. Em seguida, o restante da segunda linha simplesmente executa uma única iteração do loop, deixando a outrasetInterval fragmento termine o trabalho. Se removido do final, o backtick restante é retirado do final do comentário.

As novas linhas são colocadas para que a remoção 1 não afete o comportamento do programa, mas evitam erros no caso de algumas remoções de caracteres, como o backtick principal.

Pitão - 16 bytes

A idéia básica por trás disso é que, quando você retira um dígito 404, ele só diminui o número; portanto, precisamos obter o máximo de dois 404para garantir que tenhamos o número certo. Obviamente, existem muitas redundâncias.

SSsetSS[404  404

Explicação:

SS                       First one does 1-index range, second one sorts, which is no-op 
 s                       If the e is there, this is no-op, if only t is there, it sums a one element list, which is the item
  et                     e picks last element in list, and if e is gone, then t gets you the list without the first element which is good enough when combined with s
   SS                    Sorting twice is no-op
    [                    Start list, this can't be two element because if we get rid of initial 4, the 0 becomes third element which neeeds to be captured
     404                 One of the 404's
     <space><space>404   Need two spaces for redundancy, because 404404 *is* bigger than 404

Experimente online aqui .

Befunge-98 , 37 bytes

20020xx##;;11++::''ee44**``kk@@::..;;

Experimente online!

Explicação

Criar código reforçado por radiação no Befunge-98 não é tão ruim, porque você pode definir manualmente o "delta" (ou seja, o tamanho da etapa do ponteiro da instrução) x. Portanto, se definir o delta como (2,0), a partir de então todos os outros caracteres serão ignorados e podemos simplesmente duplicar todos os comandos. O difícil é ficar 2 0no topo da pilha de maneira confiável. Na verdade, precisamos 0 2 0que o programa funcione corretamente, mas faremos isso de graça. Aqui está como fazemos isso:

20020xx

Observe que cada dígito pressiona a si próprio; portanto, no programa completo, haverá um início 2 0 que simplesmente ignoraremos.

Conseqüentemente, a remoção do primeiro ou do segundo caractere do programa é irrelevante, porque não usaremos esses dígitos de qualquer maneira. Da mesma forma, remover o terceiro caractere é idêntico ao remover o segundo, portanto, também não precisamos nos preocupar com isso.

Vamos considerar o que acontece nos outros dois casos. Soltando o quarto caractere:

2000xx

Observe que o delta está definido como (0,0). Mas isso não move o ponteiro de instruções, então o mesmo xé executado novamente imediatamente e desta vez aparece (2,0)tudo e está bem (existem zeros implícitos na parte inferior da pilha para nossos propósitos posteriores).

Vamos largar o quinto caractere:

2002xx

Agora o delta está definido como (0,2). No entanto, como ainda não há movimento horizontal, o IP volta imediatamente parax e novamente, o delta correto é definido.

A partir deste ponto, podemos basicamente ignorar a duplicação de caracteres, bem como esta parte inicial, porque ela sempre será ignorada:

...#;1+:'e4*`k@:.;

O ;é um tipo de comando de comentário que pula tudo até que o próximo ;seja encontrado. No entanto, pulamos o primeiro ;com #apenas a parte entre o ;será executada a partir desse ponto.

1+    Increment the top of the stack.
:     Duplicate it.
'e    Push 101.
4*    Multiply by 4 to get 404.
`     Greater-than check. Pushes 1 once the top
      reaches 405, otherwise 0.
k@    Terminate the program that many times.
:.    Print a copy of the top of the stack (and a space).

> <> , 103 60 51 bytes

               vv
;?=*4o" e"n:ll<<
;?=*4o" e"n:ll<<

Testado aqui.

Usa a mesma tática que este programa . Se um caractere for excluído na primeira linha, a segunda linha ainda será executada. Se um caractere na 2ª linha for excluído, a vexecução será movida para a 3ª linha, uma vez que a 2ª linha é menor. Uma exclusão na 3ª linha não afeta o controle do programa, pois só é executada após uma exclusão na linha 2.

O programa também funcionará no caso de uma quebra de linha ser excluída:

Caso 1:

A segunda linha será executada.

               vv;?=*4o" e"n:ll<<
;?=*4o" e"n:ll<<

Caso 2:

Ambas as linhas se tornam uma linha com o dobro das instruções.

               vv
;?=*4o" e"n:ll<<;?=*4o" e"n:ll<<

Explicação:

O núcleo do programa é o seguinte. Observe que a já 1está pressionada na pilha pela primeira linha.

ll:n        Push length of the stack twice, duplicate, print as number
"e "o       Push 101, 32, output 32 as space
4*          101 * 4 is 404
=?;         Pop twice, if equal, halt
            (Execution wraps around)

> <> , 42 38 34 bytes

Experimente Online!

Agradecemos a @Martin Ender e @Teal Pelican por reduzir 8 bytes!

<<;?=*4o" e"lnll/
 ;?=*4o" e"lnll<

Semelhante à resposta do mbomb007 , mas usa apenas 2 linhas.

Em vez de contar de 1 a 404 usando um único valor de memória, empurrei continuamente o comprimento da pilha. Isso fez com que eu não precisasse colocar nada na pilha antes do início do loop, facilitando muito as coisas.

O código original

Eles <mudam o IP, e o /é um não-op, pois o IP envolve e continua ao longo de seu caminho normal. Assim, o código relevante é:

          lnll   Prints the size of the stack + 1 and pushes the stack size twice
     o" e"       Prints a space and pushes 101
   *4            Multiplies to get 404
;?=              If the number we just printed was 404, end the program

E isso se repete.

A exclusão

A grande chave aqui é o espelho /. Não faz nada se a segunda linha é modificada - apenas volta para si mesma e é essencialmente um não-op. Mas se um caractere da primeira linha for removido, a linha mudará para baixo, de modo que o espelho acerte a flecha< , levando a um loop idêntico e não modificado.

A única outra exclusão significativa seria o \npersonagem. Isso também é considerado, pois produz este código:

<<;?=*4o" e"lnll/ ;?)*4o" e"lnll<

Agora, acabamos de anexar uma cópia do loop original ;?=*4o" e"lnlla si próprio. Como esse é um loop, não faz diferença para a execução e é executado como se nada tivesse mudado.

Uma pereira , 34 bytes

O programa contém caracteres de controle, então aqui está um xxddespejo:

00000000: 7072 696e 7420 312e 2e34 3034 2327 108a  print 1..404#'..
00000010: af70 7269 6e74 2031 2e2e 3430 3423 2710  .print 1..404#'.
00000020: 8aaf                                     ..

Uma árvore de pera é basicamente um derivado de Perl, com algumas características "interessantes". Joguei tudo junto como uma piada (para que eu pudesse dizer que meu poliglota imprimiu a partridgeem A Pear Tree; de ​​fato, quase todos os programas o fazem). No entanto, é Turing completo e realmente bom nesse tipo de desafio.

O recurso com o qual nos preocupamos principalmente aqui é que o A Pear Tree só executará um programa se alguma substring do código tiver um CRC-32 00000000. O código é rotacionado para colocar a substring em questão no início. Por acaso, as duas metades (idênticas) do código têm o CRC-32 em questão (devido a esse comentário binário de aparência suspeita no final), portanto, se você excluir um caractere da fonte (quebrando o CRC), a outra metade é girada para o início e o# sinal próximo ao final comentará a metade danificada, além do lixo binário.

Outro recurso torna o programa um pouco menor: embora A Pear Tree seja principalmente interpretado como Perl, ele tem algumas pequenas alterações para fazê-lo funcionar mais como o Python. Um ponto relevante aqui é que, diferentemente da printdeclaração de Perl (que apenas une os números), a printdeclaração de A Pear Tree separa argumentos com espaços e imprime uma nova linha final. Isso nos dá uma saída bem separada do espaço, o que significa que não precisamos desperdiçar bytes na formatação. (Observe que você não deverá fornecer entrada ao programa; se o idioma receber entrada, ele assume por padrão que deve fazer algo com ele.)

Obviamente, isso não pode competir com os idiomas reais do golfe (nem eu esperava), mas achei que as pessoas poderiam achar interessante.

Entre 98 , 34 bytes

Experimente Online!

<<.:@k`*4e':+1[

2.:@k`*4e':+1<^^j

Isso funciona de maneira muito semelhante à minha >> resposta , mas, em vez do espelho /, eu uso a operação vire à esquerda [e inverto a direção do IP, que neste caso é funcionalmente equivalente a um espelho.

O código original

<<                 Reverses code direction, sending IP to right
               [   Turns the IP left, into the ^, which reverses it.
                   It then hits this again, turning left to go West. (No-op)
            :+1    Adds 1 to the sum
        *4e'       Pushes 404
     @k`           Ends the program if (sum > 404)
   .:              Prints the sum

A exclusão

Se algo na segunda linha for excluído, ele mudará de posição e não afetará a parte superior.

Se alguma coisa na primeira linha for excluída, o [IP será enviado para o <, que inicia um loop idêntico (com a exceção do 2j^^que evita os ^s usados ​​em conjunto com o [)

Como existem 2 novas linhas, não faz diferença para o código se uma for excluída (graças a @ masterX244 por isso!)

Befunge-93, 54 51 bytes

Obrigado a Mistah Figgins por me salvar 3 bytes.

111111111111111vv
+1_@#-*4"e":.:<<
+1_@#-*4"e":.:<<

Experimente online!

Esse é essencialmente o mesmo truque usado no desafio Hello World tolerante a falhas . A primeira linha começa certificando-se de que exista 1 no topo da pilha para o início da sequência e, em seguida, uma das vsetas no final da linha redireciona o caminho do código para o início da rotina principal na linha 2 , executando da direita para a esquerda.

Remover um caractere da primeira linha apenas deslocará as vsetas em uma, mas isso ainda permite que o código seja redirecionado para a segunda linha com êxito. A remoção de um caractere da segunda linha faz com que a <seta no final da linha mude para fora do caminho vacima, portanto o caminho do código será redirecionado para a rotina de backup na linha 3.

Remover a primeira quebra de linha não faz mal, porque isso apenas move a terceira linha no lugar para substituir a segunda linha. E remover qualquer coisa após o final da segunda linha não terá efeito, porque esse é apenas o código de backup.

JavaScript + HTML + Snippets de pilha, 167 158 154 bytes

Abusar do fato de que o JavaScript nos Snippets de pilha é colocado em uma página da Web dentro de um <script>elemento.

or(x="",i=405,d=document;--i;)d[i]||(x=d[i]=i+' '+x);d.write(x)</script></script><script>for(x="",i=405,d=document;--i;)d[i]||(x=d[i]=i+' '+x);d.write(x)

Na verdade , 18 bytes

:404::404kMkMMRRSS

Na verdade, é uma linguagem de golfe baseada em pilhas.

Explicação dos comandos envolvidos (como eles funcionam no contexto acima):

Numbers are indicated by round brackets () and lists by square brackets []

:         - pushes the longest string of characters in '0123456789+-.ij' as a numeric
k         - pop all the elements on the stack into a list [l] and push [l]
M         - pop [l], push max([l])
            pop (a), push (a)
R         - pop [l], push reverse([l])
            pop (a), push range([1,a])
S         - pop [a], push sorted([a])