Abbiamo una sfida per generare il tuo punteggio , ma sembra che tutte le risposte siano solo hardcodificate l'output e questo è noioso ¹ . Quindi facciamo una nuova sfida. Il tuo programma deve generare la sua lunghezza in byte seguita dalla stringa " bytes", ma per evitare soluzioni hardcoded se riduciamo le sue dimensioni rimuovendo un byte qualsiasi , il nuovo programma deve anche generare il suo nuovo conteggio di byte, sempre seguito da " bytes". L'output non deve essere sensibile al maiuscolo / minuscolo. Puoi anche scegliere di generare una nuova riga finale.

Le risposte verranno assegnate in byte con un numero inferiore di byte migliori.

^{1: In realtà mi piacciono alcune delle risposte lì.}

Rovescio , 40 36 29 byte

vv""sseettyybb  ""jjHHOO]

Provalo online! Verifica!

In caso di dubbio, raddoppia su tutto. Questo utilizza la capacità di Backhand di spostare più di un passo alla volta per implementare la ridondanza. Tutti gli non stampabili hanno il valore di byte 28.

Spiegazione:

Programma non irradiato:

v       Reduce step count to 2
  "    Start string literal
    s e t y b        Push the " bytes" part of the output
                  " Push 28 twice and end the string literal
                       j    Jump to the 28th position (0 indexed) 
                             ]   Increment the 28 to 29
                           O     Print the 29
                         H       Halt and output the entire stack

Programma irradiato:

Se un carattere viene eliminato, ogni carattere successivo viene spostato verso il basso.

vv"sseettyybb
v " s e t y b     The same instructions are still executed

Tuttavia, invece di saltare al ], si riflette invece sulla fine del programma e atterra Oinvece sul.

                             v  28th character (0 indexed)
vv""sseettyybb       ""jjHHOO]
v""sseettyybb       ""jjHHOO]OOHHjj"".....
                             ^ 28th character, reflecting off the end of the code

Incantesimi runici , 47 byte

>>yyLL     @"setyb 64"/
"47 bytes"@"setyb 64"L\

Provalo online!

Che è più o meno una porta della mia risposta Geiger Counter , ma con output diverso (che è, di per sé, una porta di una risposta di Klein).

>>yyLLè necessario per Runic per generare (almeno) un IP, unire due IPS e riflettere di nuovo a sinistra, in modo che tutte le variazioni si traducano in un singolo IP in movimento a sinistra. Potrebbe essere sostituito da yy<<ma non salva alcun byte.

I riflettori a destra forzano l'IP nella stringa in basso a sinistra, quindi la rimozione di uno in alto a destra consente l'IP nella stringa in alto a destra. La rimozione di un byte in qualsiasi altro punto lungo la linea superiore regola il riflettore superiore in modo che si trovi sopra la L (consentendo il programma in basso a destra). La rimozione di un byte lungo il fondo regola quel riflettore (o lo rimuove) in modo che l'ultimo carattere venga riempito implicitamente di uno spazio, che consente all'IP di rimbalzare su entrambi i lati del riflettore in alto a destra e nella stringa in alto a destra.

Gli spazi in eccesso sono deludenti, però. Ma tutti i tentativi di ridurli hanno portato a programmi più grandi, programmi della stessa dimensione o programmi che non sono al 100% a prova di radiazione. Entrambe le risposte Klein e> <> utilizzano funzionalità non disponibili in Runic.

> <> , 43 39 byte

||vn-{"' bytes"-10/
 o>o<"38 bytes"[0/0

Provalo online! Verifica!

Nel programma non irradiato, aggiungiamo 0a '(39), e nel programma irradiato saltiamo lo 0 e -1invece lo aggiungiamo ad esso. Se qualcosa viene rimosso dalla riga superiore, passiamo invece alla riga inferiore e solo l'output 38 bytes.

Esagonia , 71 byte

//.........||.>e;s;@..\;t;y;b<>}F"+!P0;/|/F!P0$@;<...t;ye;bs/.........)

Provalo online! Verifica!

Ho passato troppo tempo a cercare di ottenere questo in un esagono di dimensione 5, ma invece ho dovuto accontentarmi di una dimensione inferiore a 6 :(.

Allargato:

      / / . . . .
     . . . . . | |
    . > e ; s ; @ .
   . \ ; t ; y ; b <
  > } F " + ! P 0 ; /
 | / F ! P 0 $ @ ; < .
  . . t ; y e ; b s /
   . . . . . . . . .
    ) . . . . . . .
     . . . . . . .
      . . . . . .

Inizialmente l'ho fatto con il ) una riga in basso, ma si scopre che è esattamente dove si trova la divisione tra esagoni di dimensione 5 e 6. Ciò significa che quando viene rimosso un byte, la dimensione si sposta verso il basso e rovina i percorsi. Sono sicuramente sicuro che una dimensione 5 sia possibile.

Klein 000, 41 byte

<<@"setyb "$"4"+"0"/
..@"setyb 04"(....<1

Provalo online! JoKing's Verifier

Penso che questa risposta sia simile a risposta <>> JoKing , ma non leggo> <> quindi non posso esserne sicuro.

Esistono 4 diversi tipi di rimozione di byte qui

1. Un byte viene rimosso dalla prima riga prima /. In questo caso la barra viene effettivamente spostata a sinistra di uno spazio, deviandola sulla riga inferiore e impedendo l'esecuzione della parte modificata del codice. Questo ci fa eseguire il codice ("40 bytes"@, che genera 40 bytes.

2. Il primo /viene rimosso dalla prima riga. In questo caso eseguiamo il codice "0"+"4"$" bytes"@, che è un modo contorto o stampa 40 bytes.

3. La nuova riga viene rimossa. Questo ci fa iniziare dalla fine della seconda riga e il codice risultante (senza noops rimosso) è 1("40 bytes"@, che stampa solo 40 bytes.

4. Viene rimosso un byte dall'ultima riga. Questo fa sì che la 1fine della prima riga venga spostata a sinistra e ne impedisce l'aggiunta alla pila quando il punto viene deviato da /. Il codice "0"+per quel motivo spinge 0invece di 1, il resto del codice trasforma 0in 40 bytes.

Klein 001, 41 byte

\("40 bytes"@......1
..@"setyb "$"4"+"0"/

Provalo online! JoKing's Verifier

Ecco una risposta usando una topologia diversa. Ha le stesse dimensioni ma penso che ci sia spazio per miglioramenti.