Rivelatore di radiazioni!

26

Un programma indurito dalle radiazioni è un programma in cui, se viene rimosso qualsiasi carattere del codice, il programma funzionerà comunque allo stesso modo. Per questa domanda, scriveremo un programma che rileva quando viene irradiato.

Scrivi un programma o una funzione che, quando viene rimosso un singolo byte, il programma risultante emetterà quel byte e solo quel byte. ( È possibile emettere quel byte più volte, purché non si emetta alcun altro byte )

Regole:

  • Il programma deve contenere almeno 2 byte distinti. (Nessuna soluzione di soli 0 secondi;)
  • Non importa cosa fa il programma originale
  • Non leggere il tuo codice sorgente.
  • Il codice verrà assegnato in base al numero di byte distinti, in cui vince la quantità più alta. Ad esempio, abc= 3 punti, ababba= 2 punti, abcvince.
    • Il tie-breaker è il conteggio di byte più piccolo, seguito dal tempo di invio precedente

In bocca al lupo!

code-challenge  radiation-hardening 
— Jo King
fonte
— Jo King
Ho perso quella linea. Mi vergogno!
— Mego
5
"Il codice verrà assegnato in base al numero di caratteri distinti, in cui vince il massimo." Mi aspetto che la maggior parte (se non tutte) le soluzioni avranno una qualche forma di stringa da qualche parte che possono semplicemente riempire con caratteri arbitrari senza effettivamente cambiare la soluzione (quindi dipende solo dal fatto che la tua lingua sia limitata a ASCII, ASCII esteso o Unicode) .
— Martin Ender,
3
... La sandbox non è perfetta. :( / Puoi semplicemente misurare "byte distinti" anziché "caratteri distinti", poiché i caratteri sono correlati alla codifica e ad altri problemi.
— user202729
1
Il programma può ricevere input?
— gggg,

Risposte:

15

05AB1E , 9 7 byte (punteggio di 3)

22'''rr

Provalo online!

Rimozione a '

Se 'rimossi, il 22''rrrisultato sarà che 22 sarà la prima cosa in pila e un 'essere l'ultima cosa in pila, che quando invertita due volte si tradurrà in '.

Rimozione di un r

Se rrimosso, il 22'''rrisultato è che 22 è la prima cosa nello stack, 'essendo la seconda cosa nello stack e un ressere l'ultima cosa nello stack. Questo r, tuttavia, era preceduto da un carattere 'che lo rende la stringa letterale "r"(al contrario del comando reverse stack), che è implicitamente stampata.

Rimozione a 2

Se 2rimossi, il 2'''rrrisultato sarà l' 2essere la prima cosa in pila, 'essere la seconda cosa in pila e infine ressere l'ultima cosa in pila, che una volta invertita si traduce in una volta 2.

Pertanto, questa risposta è valida. Senza nulla rimosso ', questo risulta irrilevante. Funziona anche con un numero diverso da 2.

Creato un controllo di validità, puoi usarlo per competere in 05AB1E *.

* Non sono sicuro al 100% di quante soluzioni siano persino possibili in 05AB1E ...

Soluzioni più valide che sono peggio o uguali

  • 1 punto (non valido)
  • 2-Point
    • '''''''VV, '''''''XXo'''''''<any command that pops a without pushing>x2
    • Qualsiasi numero dispari di 'sopra di 3 seguito da un numero pari di ssopra di 1 (EG '''''''''ssss).
    • '''..con un numero qualsiasi di periodi superiori a 1 e un numero dispari 'superiore a 2.
  • 3-Point
    • '\\'''rr- stessa idea di 22'''rrma \è "rimuovi ultimo elemento dello stack".
— Urna di polpo magico
fonte
L'output normale di 'è irrilevante dalle regole, come dici tu. Ma invalida l'obiettivo nominale di rilevare anomalie, il che è un po 'divertente.
— gggg,
1
@gggg Sono abbastanza sicuro che almeno UNA delle mie alternative non stampa nulla di lol.
— Magic Octopus Urn,
1
@MagicOctopusUrn Prego. Ho pensato di poterlo modificare invece di commentare.
— boboquack,
@boboquack ha funzionato il mio tag originale (@boboquack) o l'hai trovato visualizzando nuovamente il post? Sto cercando di capire come funzionano i tag quando l'utente non ha mai commentato lol.
— Magic Octopus Urn
@boboquack Volevo dire che hai ricevuto una notifica dal mio "grazie"? Inoltre, dovremmo probabilmente eliminare questa discussione fino al mio +1 per il tuo "Prego".
— Magic Octopus Urn
9

Brainfuck, Punteggio 3

Potrebbe non essere competitivo poiché l'output viene visualizzato solo attraverso un dump della memoria. 

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

Supponendo che l'input sia vuoto e EOF lasci invariata la cella. Utilizza un interprete che scarica la memoria su un output, come questo .

Rimuovi un plus e la memoria è il valore unicode per "+", altrimenti è il valore unicode per ",". È più una regola più che una risposta. Praticamente lo stesso con "-". Abusa del fatto che questi tre personaggi si susseguono nel set di caratteri unicode.

— Håvard Nygård
fonte
Intelligente, a dire il vero, non pensare che sia una scappatoia.
— Magic Octopus Urn
Stai supponendo che EOF lasci invariata la cella, sì?
— Jo King,
Sì, e fintanto che non ci sono input, dovrebbe andare bene 😊
— Håvard Nygård
Sono tentato di permettere questo, ma non si hanno un interprete che ha un dump di memoria che le cellule output sarebbe solo cambiato e le foglie della cella invariato su EOF?
— Jo King,
1
copy.sh/brainfuck Questo dovrebbe funzionare bene. Basta eseguirlo e premere "Visualizza memoria".
— Håvard Nygård,
9

Un albero di pere, 256 byte distinti, 975 byte

Sfortunatamente, la domanda richiede praticamente una soluzione ottimale per contenere un byte NUL da qualche parte (poiché deve contenere tutti i 256 byte da qualche parte). Ciò significa che a) non posso darti un link TIO (perché a TIO non piace NUL nei programmi, o almeno, non ho trovato un modo per scriverlo con il quale il mio browser può far fronte), eb) I impossibile incollare il programma in Stack Exchange letteralmente. Invece, ho inserito un xxdhexdump reversibile nascosto dietro il link "snippet di codice" sottostante.

Mostra snippet di codice

Spiegazione

Questo programma è composto da tre parti identiche. (Concatenare più parti identiche di un programma è per me qualcosa di un tema nei programmi di indurimento delle radiazioni .) Ogni albero di pere richiede un checksum da qualche parte per far sapere all'interprete quali parti del programma eseguire; ruota qualsiasi parte del programma per il quale il checksum riesce all'inizio prima di eseguirlo (o stampa a partridgese nessun checksum corrisponde). In questo caso, abbiamo una somma di controllo su ciascuna delle tre parti e quindi una parte non irradiata si sposterà all'inizio. Quindi possiamo presumere che il programma sia costituito da una parte non modificata, seguita da altre due parti (una delle quali potrebbe essere stata modificata).

Ogni parte inizia con una nuova riga, quindi continua con il seguente codice (ho aggiunto spazi bianchi e commenti di seguito):

$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

Dopodiché arriva una copia di ogni ottetto che non è stato finora utilizzato nel programma (puramente per aumentare il punteggio) e infine il checksum. (Non c'è una nuova riga finale; le parti iniziano con una nuova riga ma non finiscono con una.)

Esistono tre casi distinti qui:

  • Un carattere diverso da una nuova riga è stato eliminato . In questo caso, apparirà un numero dispari di volte nella seconda e terza parte. Ciò significa che verrà aggiunto e / o rimosso da %zun numero dispari di volte, finendo infine nella tabella hash. In effetti, sarà l' unica chiave nella tabella hash (poiché la stringa parte dalla riga successiva della seconda parte fino alla fine della terza parte e la tabella hash è iniziata con una sola riga nuova), quindi " Verrò stampato da solo.
  • La prima o la terza riga è stata eliminata . In questo caso, il programma verrà ruotato in modo tale che manchi la terza delle newline, fondendo efficacemente la seconda e la terza parte in un'unica riga. La stringa letterale a cui si accede <DATA>contiene ogni carattere un numero pari di volte, quindi la tabella hash avrà il suo contenuto originale, una sola nuova riga e verrà stampata.
  • La seconda riga è stata eliminata . In questo caso, il programma non verrà ruotato (poiché la prima parte ha un checksum valido), quindi la seconda parte verrà spostata sulla stessa riga della prima parte. <DATA>inizia a leggere solo dalla riga in basso __DATA__, quindi vedrà solo la terza parte. Questo ha più di cinque caratteri che appaiono un numero dispari di volte, quindi attiverà il caso speciale per stampare una nuova riga.

Verifica

Un'ultima cosa che deve essere verificata praticamente per qualsiasi programma A Pear Tree temprato dalle radiazioni è se una cancellazione accada casualmente per fare in modo che una sezione indesiderata del codice esegua il checksum correttamente e ruoti il ​​codice nel posto sbagliato; dato che stiamo usando checksum a 32 bit, questo è improbabile ma non impossibile. Ho usato il seguente script di forza bruta per assicurarmi che ciò non accada per nessuna cancellazione:

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!";

Lo script di verifica conferma che questo programma funziona correttamente.

— ais523
fonte
7

Stax , 11 byte (punteggio di 4)

'''cc'~~'dd

Esegui ed esegui il debug online!

È mio onore avere la prima (cronologicamente) risposta a questa sfida con un punteggio maggiore o uguale a 4. Forse il punteggio può essere ancora più alto.

In Stax, viene scritto un letterale stringa composto da un singolo carattere ', così '', 'c, 'd, '~come tutti i letterali stringa. I comandi corrispondenti per c de ~significano duplicare la parte superiore dello stack principale, aprire la parte superiore dello stack principale e far apparire la parte superiore dello stack principale e spingere nello stack di input, rispettivamente. Per questa sfida, lo stack di input non influisce sull'output e non è importante, quindi possiamo dire de ~sono identici.

Spiegazione

È meglio dividere il codice in più parti e considerarle separatamente.

Quando non viene manomesso, '''ccspinge un valore letterale 'e un valore letterale cnella pila principale e duplica la parte superiore, in modo che la pila risulti (dal basso) c,c,'.

Quando non viene manomesso, '~~spinge il valore letterale ~e quindi lo pop (e spinge nello stack di input), che è fondamentalmente un no-op per lo stack principale.

Quando non viene manomesso, 'ddspinge il valore letterale de poi lo apre, un altro no-op per lo stack principale.

Alla fine del programma, poiché non viene eseguito alcun output esplicito, la parte superiore dello stack principale verrà stampata implicitamente.

Se il programma è in esecuzione così com'è, lo stack finale è ancora c,c,'e verrà emesso c.

Se la prima parte diventa ''cc, allora abbiamo un letterale 'e due istruzioni per la copia, lo stack finale sarà ',','. Dato che le altre due parti non sono operative, il risultato sarà '.

Se la prima parte diventa '''c, il risultato è sostanzialmente lo stesso con quello non manomesso, ma cnon viene duplicato. Quindi lo stack sarà c,'. Dopo due no-op è in cima alla pila c.

Quindi possiamo rilevare le radiazioni nella prima parte.

La seconda parte e la terza parte funzionano esattamente allo stesso modo. Prenderò la terza parte come esempio.

Se la terza parte viene manomessa, le prime due parti vengono mantenute così come sono e lo stack prima di eseguire la terza parte è c,c,'

Se la terza parte diventa 'd, un letterale dviene spinto in cima allo stack principale e non viene fatto altro. La parte superiore dello stack principale è ora quella dche verrà prodotta.

Se la terza parte diventa dd, due elementi vengono estratti dalla pila principale e ora la parte superiore della pila è 'e viene emessa.

Quindi possiamo rilevare le radiazioni nella terza parte. Per lo stesso motivo possiamo rilevare le radiazioni nella seconda parte.

— Weijun Zhou
fonte
5

05AB1E , punteggio 2, 6 byte

„"""„„

Stampa il doppio del carattere rimosso a volte. Non contiene '.

Come funziona:

Rimozione del primo „

"""„„

Provalo online!

Innanzitutto, inseriamo una stringa vuota letteralmente nello stack. Quindi spingiamo „„, che viene stampato implicitamente.

Rimozione a "

„""„„

Provalo online!

Innanzitutto, spingiamo ""nello stack con l' 2-char stringistruzione. Quindi proviamo a ottenere un'altra stringa di 2 caratteri, ma questa viene interrotta (non sono esattamente sicuro del perché) e ""viene stampato.

Rimozione del secondo o terzo „

„"""„

Provalo online!

Innanzitutto, spingiamo ""nello stack con l' 2-char stringistruzione. Quindi spingiamo „, che viene stampato implicitamente.

— boboquack
fonte
5

Gelatina , 5 byte, punteggio 2

”””ḷḷ

Provalo online!

Con qualsiasi ”rimosso:

””ḷḷ

Provalo online!

Il carattere ”inizia letteralmente un carattere di un byte. Questo programma inizia con il ””quale produce la stringa ”. La ḷdiade prende l'argomento sinistro. La stringa ”viene appena passata attraverso le due istanze di ḷ.

Con qualsiasi ḷrimosso:

”””ḷ

Provalo online!

In questo programma ””cede il personaggio ”quindi ”ḷcede il personaggio ḷe solo questo viene emesso.

Altre soluzioni

  • Molti altri personaggi come ao oavrebbero lavorato al posto di ḷquesta presentazione.
  • ⁾⁾⁾⁾FFF. Funziona in modo simile. ⁾è come ”ma inizia una stringa di due byte letterale. I programmi "irradiati" producono due volte il byte cancellato che è stato ritenuto valido nei commenti.

Ecco una versione (molto meno elaborata) di Jelly del controllo di validità di Magic Octopus Urn. La colonna sinistra dell'output è il carattere eliminato e la colonna destra è l'output del programma risultante.

— dylnan
fonte
Il mio controllo di validità non è niente di speciale. Non riesce per l'altra soluzione pubblicata;).
— Magic Octopus Urn,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.