Detector de radiação!

26

Um programa reforçado por radiação é um programa em que, se algum caractere do código for removido, o programa continuará funcionando da mesma maneira. Para esta pergunta, escreveremos um programa que detecta quando é irradiado.

Escreva um programa ou função que, quando qualquer byte único for removido, o programa resultante produzirá esse byte e somente esse byte. ( Você pode gerar esse byte várias vezes, desde que não produza nenhum outro byte )

Regras:

  • O programa deve conter pelo menos 2 bytes distintos. (Nenhuma solução de apenas 0s;)
  • Não importa o que o programa original faz
  • Não é possível ler seu próprio código-fonte.
  • O código será pontuado no número de bytes distintos, onde a quantidade mais alta vencer. Por exemplo, abc= 3 pontos, ababba= 2 pontos, abcvence.
    • O desempatador é a menor contagem de bytes, seguida pelo tempo de envio anterior

Boa sorte!

code-challenge radiation-hardening Brincadeira
fonte
Postagem da caixa de areia (excluída) Relacionada , relacionada , relacionada
Jo King
Eu perdi essa linha. Que vergonha!
Mego 29/01
5
"O código será pontuado no número de caracteres distintos, onde a maior quantidade vencer." Espero que a maioria das soluções (se não todas) possua algum tipo de string em algum lugar, onde elas podem ser preenchidas com caracteres arbitrários sem alterar a solução (por isso, tudo se resume ao fato de seu idioma ser restrito a ASCII, ASCII estendido ou Unicode) .
Martin Ender 29/01
3
... A caixa de areia não é perfeita. :( / Você pode apenas medir "bytes distintos" em vez de "caracteres distintos", porque os caracteres estão relacionados à codificação e outros problemas.
user202729
1
O programa pode receber alguma entrada?
Gggg

Respostas:

15

05AB1E , 9 7 bytes (Pontuação 3)

22'''rr

Experimente online!

Removendo um '

Se 'removido, 22''rrresultará em 22 sendo a primeira coisa na pilha e 'sendo a última coisa na pilha, que quando revertida duas vezes resulta em '.

Removendo um r

Com qualquer rremoção, 22'''rresulta em 22 sendo a primeira coisa na pilha, 'sendo a segunda coisa na pilha e rsendo a última coisa na pilha. No rentanto, isso foi precedido por um 'que a torna a string literal "r"(em oposição ao comando reverse stack), que é implicitamente impressa.

Removendo um 2

Com qualquer 2remoção, 2'''rrresultará em 2ser a primeira coisa na pilha, 'sendo a segunda coisa na pilha e finalmente ra última coisa na pilha, que quando revertida uma vez resulta 2.

Portanto, esta resposta é válida. Sem nada removido, o resultado 'é irrelevante. Isso funciona para qualquer número diferente de 2 também.

Criado um verificador de validade, você pode usá-lo para competir no 05AB1E *.

* Não tenho 100% de certeza de quantas soluções são possíveis no 05AB1E ...

Soluções mais válidas que são piores ou iguais

  • 1 ponto (inválido)
  • 2 pontos
    • '''''''VV, '''''''XXou'''''''<any command that pops a without pushing>x2
    • Qualquer número ímpar 'acima de 3 seguido de qualquer número par sacima de 1 (EG '''''''''ssss).
    • '''..com qualquer número de períodos acima de 1 e qualquer número ímpar 'acima de 2.
  • 3 pontos
    • '\\'''rr- mesma ideia que 22'''rrmas \é 'remover o último item da pilha'.
Urna de polvo mágico
fonte
A saída normal de 'é irrelevante pelas regras, como você diz. Mas invalida o objetivo nominal de detectar anomalias, o que é um pouco engraçado.
Gggg
1
@gggg Tenho quase certeza de que pelo menos UMA das minhas alternativas não imprime nada, lol.
Urna de polvo mágico
1
@MagicOctopusUrn De nada. Apenas pensei em editar, em vez de comentar.
boboquack
@boboquack minha tag original (@boboquack) funcionou ou você a encontrou visualizando a postagem novamente? Estou tentando descobrir como as tags funcionam quando o usuário nunca comentou lol.
Magic Octopus Urn
@boboquack, eu quis dizer que você recebeu uma notificação do meu "obrigado"? Além disso, provavelmente devemos excluir este tópico até o meu +1 no seu "De nada".
Urna Mágica de Polvo
9

Pontuação 3

Pode não ser competitivo, pois a saída é vista apenas através de um despejo de memória. 

+++++++++++++++++++++++++++++++++++++++++++++,-

Supondo que a entrada esteja vazia e o EOF deixe a célula inalterada. Usa um intérprete que despeja a memória em uma saída, como esta .

Remova um sinal de adição e a memória é o valor unicode para "+", caso contrário, é o valor unicode para ",". É mais uma regra dobradora do que uma resposta. Praticamente o mesmo com "-". Abusa do fato de que esses três caracteres estão um após o outro no conjunto de caracteres unicode.

Håvard Nygård
fonte
Inteligente, para ser totalmente honesto, não pense que é uma brecha.
Urna de polvo mágico
Você está assumindo que o EOF deixa a célula inalterada, sim?
Jo rei
Sim, e enquanto não houver entrada, ele deve estar bem 😊
Håvard Nygård
Estou tentado a permitir isso, mas você tem um intérprete que possui um despejo de memória que produziria apenas células alteradas e deixa a célula inalterada no EOF?
Jo rei
1
copy.sh/brainfuck Este deve funcionar bem. Basta executá-lo e clicar em "ver memória".
Håvard Nygård 14/02
9

Uma árvore de pêra, 256 bytes distintos, 975 bytes

Infelizmente, a pergunta requer uma solução ótima para conter um byte NUL em algum lugar (pois precisa conter todos os 256 bytes em algum lugar). Isso significa que: a) não posso fornecer um link TIO (porque o TIO não gosta de NUL em programas ou, pelo menos, não descobri uma maneira de digitá-lo que meu navegador possa suportar) eb) Não é possível colar o programa no Stack Exchange literalmente. Em vez disso, coloquei um xxdhexdump reversível escondido atrás do link "snippet de código" abaixo.

Mostrar snippet de código

Explicação

Este programa consiste em três partes idênticas. (Concatenar várias partes idênticas de um programa é um tema para mim em programas de proteção contra radiação .) Toda árvore A Pear requer uma soma de verificação em algum lugar para que o intérprete saiba quais partes do programa serão executadas; ele gira qualquer parte do programa para o qual a soma de verificação é bem-sucedida até o início antes de executá-la (ou imprime a partridgese nenhuma soma de verificação corresponder). Nesse caso, temos uma soma de verificação em cada uma das três partes e, portanto, uma parte não irradiada será movida para o início. Portanto, podemos assumir que o programa consiste em uma parte não modificada, seguida por duas outras partes (uma das quais pode ter sido modificada).

Cada parte começa com uma nova linha e depois continua com o seguinte código (adicionamos espaços em branco e comentários abaixo):

$z{$/}++;      # In the hash table %z, set the key "\n" to 1
$/=$\=$@;      # Turn off newline handling when reading ($/ = undef);
               # Also don't add newlines when printing ($\ = undef)
               # $@ is set to undef by default
!$z{$_}?       #   If the current character is not in the hash table %z
  $z{$_}=1:    #   place it in the hash table %z
  delete$z{$_} #   else remove it from the hash table %z
for split//,   # for each character in
    <DATA>;    # the text appearing from the line beneath __DATA__ to EOF
print          # Print the following (no newline because $\ was undefined):
  keys%z>5?    # if the hash table %z contains more than 5 elements:
  "\n":        #   a newline; otherwise
  keys%z;      #   every key of %z, separated by spaces
__DATA__       # Start a string literal running from after this line to EOF

Depois disso, vem uma cópia de todos os octetos que não foram usados ​​no programa até agora (apenas para aumentar a pontuação) e, finalmente, a soma de verificação. (Não há nova linha final; as peças começam com uma nova linha, mas não terminam com uma.)

Existem três casos distintos aqui:

  • Um caractere diferente de uma nova linha foi excluído . Nesse caso, aparecerá um número ímpar de vezes na segunda e terceira partes. Isso significa que será adicionado e / ou removido de %zum número ímpar de vezes, finalmente terminando na tabela de hash. Na verdade, será a única chave na tabela de hash (como a sequência será executada após a nova linha da segunda parte até o final da terceira parte e a tabela de hash começou com apenas uma única nova linha). apenas será impresso por conta própria.
  • A primeira ou terceira nova linha foi excluída . Nesse caso, o programa será rotacionado de modo que seja a terceira das novas linhas ausentes, mesclando efetivamente a segunda e a terceira parte em uma única linha. A string literal acessada via <DATA>contém todos os caracteres um número par de vezes, portanto, a tabela de hash terá seu conteúdo original, uma única nova linha, e isso será impresso.
  • A segunda nova linha foi excluída . Nesse caso, o programa não será rotacionado (como a primeira parte possui uma soma de verificação válida); portanto, a segunda parte será movida para a mesma linha da primeira parte. <DATA>só começa a ler a partir da linha abaixo __DATA__, então só verá a terceira parte. Isso tem mais de cinco caracteres que aparecem um número ímpar de vezes, portanto, acionará o caso especial para imprimir uma nova linha.

Verificação

Uma última coisa que deve ser verificada para praticamente qualquer programa A Pear Tree endurecido por radiação é se uma exclusão causa aleatoriamente uma seção indesejada do código para somar a soma de verificação corretamente e girar o código para o lugar errado; como estamos usando somas de verificação de 32 bits, isso é improvável, mas não impossível. Usei o seguinte script de força bruta para garantir que isso não ocorra com nenhuma exclusão:

use 5.010;
use IPC::Run qw/run/;
use warnings;
use strict;
use Data::Dumper;
$Data::Dumper::Useqq=1;
$Data::Dumper::Terse=1;
$Data::Dumper::Indent=0;
undef $/;
$| = 1;
my $program = <>;

for my $x (0 .. (length($program) - 1)) {
    my $p = $program;
    my $removed = substr $p, $x, 1, "";
    alarm 4;
    say Dumper($p);
    run [$^X, '-M5.010', 'apeartree.pl'], '<', \$p, '>', \my $out, '2>', \my $err;
    if ($out ne $removed) {
        print "Unexpected output deleting character $x ($removed)\n";
        print "Output: {{{\n$out}}}\n";
        print "Errors: {{{\n$err}}}\n";
        exit;
    }
}

say $program;
run [$^X, '-M5.010', 'apeartree.pl'], '<', \$program, '>', \my $out, '2>', \my $err;
if ($out ne '') {
    print "Unexpected output not mutating\n";
    print "Output: {{{\n$out}}}\n";
    print "Errors: {{{\n$err}}}\n";
    exit;
}

say "All OK!";

O script de verificação confirma que este programa funciona corretamente.

ais523
fonte
7

Stax , 11 bytes (Pontuação 4)

'''cc'~~'dd

Execute e depure online!

É minha honra ter a primeira resposta (cronologicamente) a esse desafio com uma pontuação maior ou igual a 4. Talvez a pontuação possa ser ainda maior.

No Stax, uma literal de string composta por um único caractere é escrita com ', assim '', 'c, 'd, '~como todos os literais de string. Os comandos c de ~meios correspondentes duplicam a parte superior da pilha principal, pop na parte superior da pilha principal, pop na parte superior da pilha principal e empurre para a pilha de entrada, respectivamente. Para esse desafio, a pilha de entrada não afeta a saída e não é importante; portanto, podemos dizer de ~somos idênticos.

Explicação

É melhor dividir o código em várias partes e considerá-los separadamente.

Quando não é violado, '''ccempurra um literal 'e um literal cpara a pilha principal e duplica a parte superior, de modo que a pilha seria (de baixo para cima) c,c,'.

Quando não violado, '~~empurra o literal ~e o abre (e empurra para a pilha de entrada), o que é basicamente um não operacional para a pilha principal.

Quando não adulterado, 'ddempurra o literal de, em seguida, abre, outro não-op para a pilha principal.

No final do programa, como nenhuma saída explícita é feita, a parte superior da pilha principal será impressa implicitamente.

Se o programa estiver sendo executado como está, a pilha final ainda está c,c,'e será exibida c.

Se a primeira parte se tornar ''cc, então temos 'instruções literais e duas cópias, a pilha final será ',','. Dado que as outras duas partes não são opcionais, o resultado será '.

Se a primeira parte se tornar '''c, o resultado será basicamente o mesmo com a não alterada, mas cnão será duplicada. Então a pilha será c,'. Depois de dois no-op's, o topo da pilha é c.

Para que possamos detectar radiação na primeira parte.

A segunda parte e a terceira parte funcionam exatamente da mesma maneira. Vou pegar a terceira parte como exemplo.

Se a terceira parte for violada, as duas primeiras serão mantidas como estão e a pilha antes de executar a terceira parte será c,c,'

Se a terceira parte se tornar 'd, um literal dé empurrado para o topo da pilha principal e nada mais é feito. O topo da pilha principal é agora o dque será produzido.

Se a terceira parte se tornar dd, dois elementos serão exibidos na pilha principal e agora o topo da pilha é 'e é gerado.

Portanto, podemos detectar radiação na terceira parte. Pela mesma razão, podemos detectar radiação na segunda parte.

Weijun Zhou
fonte
5

05AB1E , pontuação 2, 6 bytes

„"""„„

Às vezes, imprime o dobro do caractere removido. Não contém '.

Como funciona:

Removendo o primeiro „

"""„„

Experimente online!

Primeiro, colocamos uma string vazia literal na pilha. Em seguida, pressionamos „„, que é impresso implicitamente.

Removendo um "

„""„„

Experimente online!

Primeiro, empurramos ""para a pilha com as 2-char stringinstruções. Em seguida, tentamos obter outra sequência de 2 caracteres, mas isso é abortado (não sei exatamente por que) e o ""é impresso.

Remoção do segundo ou terceiro „

„"""„

Experimente online!

Primeiro, empurramos ""para a pilha com as 2-char stringinstruções. Em seguida, pressionamos „, que é impresso implicitamente.

boboquack
fonte
5

Geléia , 5 bytes, pontuação 2

”””ḷḷ

Experimente online!

Com qualquer um ”removido:

””ḷḷ

Experimente online!

O caractere ”inicia um caractere de um byte literal. Este programa começa com o ””qual produz a string ”. A ḷdíade leva seu argumento à esquerda. A cadeia ”apenas é passada pelas duas instâncias de ḷ.

Com qualquer um ḷremovido:

”””ḷ

Experimente online!

Neste programa ””yields o personagem ”, em seguida, ”ḷproduz o caráter ḷe só esta é a saída.

Outras soluções

  • Muitos outros personagens como aou oteriam trabalhado no lugar ḷdessa submissão.
  • ⁾⁾⁾⁾FFF. Isso funciona de maneira semelhante. ⁾é como ”mas inicia uma string de dois bytes literal. Os programas "irradiados" produzem o byte excluído duas vezes, que foi considerado válido nos comentários.

Aqui está uma versão Jelly (muito menos chique) do verificador de validade do Magic Octopus Urn. A coluna esquerda da saída é o caractere excluído e a coluna direita é a saída do programa resultante.

dylnan
fonte
Meu verificador de validade não é thaaat fantasia. Falha na outra solução publicada;).
Magic Octopus Urn