La tua sfida è semplice: scrivi il più a lungo possibile di un programma incontaminato nella lingua che preferisci usando solo byte unici. (La definizione completa di un programma incontaminato, copiata da quel link, è in fondo a questa domanda.)

Esatto, nessun vincolo. Il tuo codice non deve fare nulla, basta eseguire senza errori, soddisfare i requisiti per un programma incontaminato (linkato sopra) e non includere byte duplicati nella codifica che usi.

Ai fini della spiegazione di cui sopra e della definizione collegata di "programma incontaminato", un errore è definito come qualsiasi cosa che impedisca l'esecuzione del programma o la sua chiusura con un codice di uscita diverso da zero dopo un periodo di tempo limitato.

Poiché si tratta di code-bowling , il codice più lungo , non il più breve, vince (misurato dal conteggio dei byte). Il punteggio massimo teoricamente possibile è 256, poiché sono possibili 256 byte distinti. In caso di pareggio, vince la prima risposta con il punteggio più alto.

Ecco la definizione completa di un programma incontaminato, copiata dal link sopra:

Definiamo un programma incontaminato come un programma che non ha alcun errore in sé, ma lo farà se lo modifichi rimuovendo qualsiasi sottostringa contigua di N caratteri, dove 1 <= N < program length.

Ad esempio, il programma Python 2 a tre caratteri

`8`

è un programma incontaminato perché tutti i programmi risultanti dalla rimozione di sottostringhe di lunghezza 1 causano errori (in effetti errori di sintassi, ma qualsiasi tipo di errore lo farà):

8`
``
`8

e anche tutti i programmi risultanti dalla rimozione di sottostringhe di lunghezza 2 causano errori:

`
`

Se, per esempio, `8fosse stato un programma senza errori, allora `8`non sarebbe incontaminato perché tutti i risultati della rimozione della sottostringa devono essere errati.

Gelatina , 253 254 256 byte

M“¢£¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#%&'()*+,-./0145689:;<=>?@ABCDEFGHIJKNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|~¶°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż”L»«’Ɗạ‘}237$¤¡

Provalo online! o verificalo!

Si scopre che le lingue del golf possono giocare ...

• +1 byte lavorando in ‘. Ora «»non vengono utilizzati solo
• +2 byte con con «». Ora ottieni il punteggio ottimale!

Come?

La caratteristica cruciale di Jelly che lo rende possibile è che i caratteri di apertura e chiusura dei letterali a stringa non sono gli stessi di quasi tutte le altre lingue.

La struttura del programma è la seguente:

M <239 character long string> L»«’Ɗạ‘}237$¤¡

Mtrova gli indici del suo argomento che indicano elementi massimi. Tutto ciò che conta è che senza alcun argomento a questo programma Jelly assegni 0alla catena e agli errori Jelly quando Mviene applicato 0.

Per evitare Mdi agire 0nel programma completo, utilizziamo il ¡rapido, che si applica Mun numero di volte determinato dal risultato del collegamento immediatamente precedente. In questo caso quel link è <239 character long string> L»«’Ɗạ‘}237$¤.

Lprende la lunghezza di questa stringa (239) e la »«’Ɗdiminuisce a 238. La »«parte non fa altro che Ɗ(ultimi tre collegamenti come monade) fa in modo che se vengono eliminati si verificherà un errore. Quindi ạprende la differenza assoluta tra il risultato di »«’Ɗe la monade ‘}237$applicata alla stringa. ‘incrementa ed è una monade, ma la }trasforma in una diade e la applica alla sua giusta argomentazione 237, cedendo 238. Così ạcede 0nel programma completo.

¤rimanda alla stringa letterale formando un nilad. Il risultato di questo è 0, quindi Mnon viene applicato affatto, impedendo qualsiasi errore.

Possibili sottoprogrammi:

• Se una parte della stringa viene rimossa, <string>..¤sarà diversa da zero e Mverrà applicata 0, causando un errore.
• Se una parte di L»«’Ɗạ‘}237$viene rimossa Mverrà applicata 0o ci saranno operazioni tra la stringa e un numero, risultante in un TypeError.
• Se ¤¡viene rimosso, Mviene applicato a 0.
• Se il carattere di chiusura della stringa ”e entrambi ’‘vengono rimossi e “non lo fanno, tutto ciò che Msi trasforma in una stringa, quindi Magirà 0.
  • Se la stringa chiude il carattere ”e ’viene rimossa e “no, tutto tra ”e ‘si trasforma in un elenco di numeri interi.
• Se Mviene rimosso da solo c'è un EOFErrorperché si ¡aspetta un collegamento prima del precedente nilad.
• Se M“e un numero qualsiasi di caratteri dopo che è stato rimosso, ci sarà un EOFErrorperché ¤cerca un nilad che lo precede ma non lo trova. 238non conta perché fa parte di una monade.

Questo praticamente copre tutto.

In precedenza non avevo usato «»‘perché gli ultimi due non possono essere inclusi nella stringa perché corrispondono al “personaggio per formare cose diverse dalle stringhe. «non può essere neanche in una “”stringa ma non so perché.

Haskell , 39 45 50 52 60 byte

main=do{(\𤶸	陸 ⵙ商ߜ 新->pure fst)LT
EQ[]3
2$1}

L'identificatore maindeve avere un tipo IO aper un certo tipo a. Quando viene eseguito il programma, viene eseguito il calcolo maine il suo risultato viene scartato. In questo caso il suo tipo è IO ((a,b)->a).

Il risultato è un'applicazione della funzione (λ a b c d e f → return fst), una funzione costante a sei argomenti che restituisce la funzione prima (che fornisce il primo elemento di una 2 tupla), iniettata nella monade IO. I sei argomenti sono LT(enum per meno), EQ(enum per l'uguaglianza), elenco vuoto [], 3, 2e 1.

Quali sarebbero gli spazi sono sostituiti da caratteri unici che contano come spazi: una scheda, uno spazio non interrotto, un formfeed, una scheda verticale, OGHAM SPACE MARK, spazio normale, newline e ritorno a capo. Se manca uno di questi, ci sarà una discrepanza nel numero di argomenti. I nomi dei parametri sono scelti come caratteri UTF-8 a tre o quattro byte 𤶸陸ⵙ商ߜ新, scegliendo accuratamente i caratteri che non generano byte duplicati.

Grazie a @BMO per i suoi preziosi contributi.

Discarica esadecimale:

00000000: 6d61 696e 3d64 6f7b 285c f0a4 b6b8 09ef  main=do{(\......
00000010: a793 c2a0 e2b5 990c e595 860b df9c e19a  ................
00000020: 80e6 96b0 2d3e 7075 7265 2066 7374 294c  ....->pure fst)L
00000030: 540a 4551 5b5d 330d 3224 317d            T.EQ[]3.2$1}

Provalo online!

Python 2 ,  20 21 33 39 45  50 byte

Ora è davvero uno sforzo collaborativo!

+2 grazie a Aidan F. Pierce (sostituisci sorted({0})con map(long,{0}))

+8 grazie a dylnan (uso di \e newline per sostituire lo spazio; suggerimenti per passare da 0un'espressione matematica; sostituzione -1con -True; uso di esadecimali)

+11 grazie ad Angs ( 4*23+~91->~4836+9*1075/2 poi dopo ~197836254+0xbCABdDF-> ~875+0xDEAdFBCbc%1439/2*6)

if\
map(long,{~875+0xDEAdFBCbc%1439/2*6})[-True]:q

Provalo online! O vedi la suite di conferma

0xDEAdFBCbcè esadecimale e valuta 59775106236.
~è un complemento bit-saggio quindi ~875valuta -876.
%è l'operatore modulo così 0xDEAdFBCbc%1439valuta 293.
/è la divisione intera quindi 0xDEAdFBCbc%1439/2valuta 146.
*è la moltiplicazione così xDEAdFBCbc%1439/2*6valuta 876.
+è aggiunta così ~875+xDEAdFBCbc%1439/2*6valuta 0.
... nessuna versione ridotta viene valutata 0.

{0}è un setcontenente un singolo elemento, 0.

chiamata sorted con a setcome argomento produce un elenco, che può essere indicizzato con [...].

Senza sortedil codice({0}) otterrebbe semplicemente il sete questo non può essere indicizzato nello stesso modo, if({0})[-True]:qaumenterebbe a TypeError.

L'indicizzazione in Python è basata su 0 e consente l'indicizzazione negativa dal retro ed Trueè equivalente a 1, quindi sorted({0})[-True]trova l'elemento 0, mentre sorted({0})[True]solleverà unIndexError , come volontà sorted({})[-True]ed sorted({0})[]è sintassi non valida.

Quello 0che si trova è falso, quindi il corpo del if,q non viene mai eseguito, tuttavia se fosse si solleverebbe un NameErrorpoiché qnon è stato definito.

Dal momento che un elenco non vuoto è veritiero, non possiamo tagliare if[-1]:qneanche a.

Vedi la suite di conferma per vedere: conferma che i byte sono unici; tutti gli errori; e il successo del codice stesso.

C (tcc) , x86_64, 29 31 33 39 40 byte

main[]={(23*8),-~0xABEDFCfebdc%95674+1};

Restituisce 0 . Grazie a @feersum per aver suggerito cifre esadecimali maiuscole.

Provalo online!

Come funziona

L'assegnazione scrive due ints ( 184 e 49664 ) nella posizione di memoria del main . Con ints a 32 bit e ordine dei byte little-endian, i byte esatti sono b8 00 00 00 00 c2 00 00.

Dal momento che tcc non dichiara l'array definito come .data (la maggior parte dei compilatori lo farebbe), quindi saltare al main esegue il codice macchina a cui punta.

• b8 00 00 00 00( mov eax, imm32) memorizza int 0 nel registro eax.

• c2 00 00( ret imm16) estrae 0 byte extra dallo stack e restituisce. (Il valore nel registro eax è il valore restituito dalla funzione).

> <> , 122 byte

e"~l=?!z6-d0p}xwutsrqonmkjihgfcba`_]\[>ZYXWVUTSRQPONMLKJIHGFEDCB@<:98754321/,+*)('&%$# .	|{Ay

Provalo online!

Non fa nulla. Basato sullo stesso formato della mia risposta Programming a Pristine World .

Innanzitutto, controlliamo che la lunghezza del codice sia 122 e, se non lo è, si verifica un errore. ><>i programmi non possono terminare senza l'uso del ;comando, ma se questo comando è nel programma, possiamo semplicemente rimuovere tutto ciò che lo precede per far terminare immediatamente il programma. Per combattere questo, usiamo il pcomando per inserire a ;nel codice durante il runtime. Per fare ciò, sottraggiamo 6 Ae lo posizioniamo dopo ilp .

Probabilmente aggiungerò la maggior parte degli altri valori al di sopra di 127 una volta che avrò capito i due valori di byte corretti. I 5 valori mancanti sono v^;e le due nuove righe.

Dei 7502 sottoprogrammi, 7417 di questi hanno commesso un errore a causa di istruzioni non valide, 72 da memoria insufficiente e 13 da memoria insufficiente.

JavaScript, 42 byte

if([0XacdCADE*Proxy.length]!=362517948)田

• Rimozione i, fo ifcauserà SyntaxError: missing ; before statement;
• La rimozione 田causerà SyntaxError: expected expression, got end of script;
• La rimozione di 1 o 2 byte 田causerà Invalid or unexpected token;
• La modifica dell'espressione booleana provoca l'attivazione dell'errore di sintassi o dell'errore di riferimento 田

00000000: 6966 285b 3058 6163 6443 4144 452a 5072  if([0XacdCADE*Pr
00000010: 6f78 792e 6c65 6e67 7468 5d21 3d33 3632  oxy.length]!=362
00000020: 3531 3739 3438 29e7 94b0                 517948)...

(function () {
  let valid = code => { try { eval(code); return true; } catch (e) { return false; } };
  let test = P => {
    for (let i = 0; i < P.length; i++) for (j = i + 1; j <= P.length; j++) {
      let Q = P.slice(0,i) + P.slice(j);
      if (Q && valid(Q)) {
        console.log(Q);
        return false;
      }
    }
    return true;
  };
  let unique = P => !/(.).*\1/.test(P);
  let P = 'if([0XacdCADE*Proxy.length]!=362517948)田';
  console.log(unescape(encodeURIComponent(P)).length);
  console.log(valid(P));
  console.log(unique(P));
  console.log(test(P));  
}());

Brain-Flak , 2 byte

<>

Provalo online!

In alternativa [], {}o (). La rimozione di una delle parentesi provoca un adattamento dell'altra parentesi.

Prova che questa è la soluzione ottimale:

Un programma Brain-Flak è composto da nilad (una coppia di parentesi per conto proprio) o monadi (una coppia di parentesi contenenti 1 o più nilad). Una monade non può essere in un programma incontaminato, poiché puoi semplicemente rimuovere uno o più dei nilad. Allo stesso modo, non è possibile avere più di un nilad nel programma, poiché è possibile rimuoverne uno senza interrompere il programma.

Come tale, questo potrebbe essere il linguaggio meno ottimale per una programmazione originale o unica.

Ada, 110 byte (latino1)

Probabilmente la migliore risposta che otterrai da qualsiasi lingua in uso nell'industria?

hexdump:

0000000: 7061 636b 4167 4520 6266 686a 6c6d 6f71  packAgE bfhjlmoq
0000010: 7274 7576 7778 797a e0e1 e2e3 e4e5 e6e7  rtuvwxyz........
0000020: e8e9 eaeb eced eeef f0f1 f2f3 f4f5 f6f8  ................
0000030: f9fa fbfc fdfe 0d69 730b 656e 6409 4246  .......is.end.BF
0000040: 484a 4c4d 4f51 5254 5556 5758 595a c0c1  HJLMOQRTUVWXYZ..
0000050: c2c3 c4c5 c6c7 c8c9 cacb cccd cecf d0d1  ................
0000060: d2d3 d4d5 d6d8 d9da dbdc ddde 3b0a       ............;.

Compilare salvando su qualsiasi file che termina .adse in esecuzione gcc -c <filename>. Produce un eseguibile che non fa nulla. (Non è possibile fornire il collegamento TIO poiché TIO inserisce il codice in un .adbfile e, gccper impostazione predefinita, cerca di trovare una specifica corrispondente per loro)

In sostanza dichiara un pacchetto con un nome che abusa di lettere maiuscole / minuscole in latino1. Ha bisogno di un carattere diverso per gli spazi bianchi per ciascuno degli spazi, quindi utilizza spazio, CR, LF e TAB.

Come appare in versione vim:

packAgE bfhjlmoqrtuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ^Mis^Kend^IBFHJLMOQRTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ;

Come funziona

In Ada è possibile anche compilare specifiche. Le specifiche sono come i file di intestazione di c, ma sono più complete e possono compilare un codice di base. Per essere valida qualsiasi specifica deve avere il formato: package <NAME> is ... end <NAME>;con <NAME>corrispondenza. La cosa bella di Ada è che non fa distinzione tra maiuscole e minuscole. Quindi, finché il tuo nome ha varianti maiuscole e minuscole, sarai a posto!

La parte difficile era ottenere un'unità compilabile. Normalmente i programmi Ada hanno una procedura o una funzione "principale" al di fuori di qualsiasi pacchetto che diventerà l'eseguibile finale. Sfortunatamente le procedure richiedono la beginparola chiave, che porta a troppi es (solo 2 casi noti) mentre le funzioni richiedono la returnparola chiave, che porta a troppi ns. Quindi ho dovuto solo compilare un pacchetto.

C, 8 byte

main(){}

Non fa nulla.

Provalo online!

JavaScript, 22 byte

with(0xF?JSON:[])parse

Provalo online!

Possibili errori

Se modificato, genererà uno dei seguenti errori ¹ :

[some_identifier] is not defined
expected expression, got ')'
expected expression, got ':'
expected expression, got '?'
expected expression, got ']'
expected expression, got end of script
identifier starts immediately after numeric literal
missing ( before with-statement object
missing ) after with-statement object
missing : in conditional expression
missing ] after element list
missing exponent
missing hexadecimal digits after '0x'
missing octal digits after '0o'
unexpected token: ')'
unexpected token: ']'
unexpected token: identifier

_{1. Il numero esatto di errori distinti dipende dal motore. Questo elenco è stato generato con SpiderMonkey (Firefox).}

Python 3 + Flask-Env , 7 13 14 17 byte

import\
flask_env

Nessun TIO perché non ha flask-env.

Trovato il nome del modulo più lungo che non ha intersezioni importe non ha numeri alla fine del nome. _sha256è più lungo ma 256da solo non si sbaglia. Ho trovato una libreria, b3j0f.syncche è un byte più lungo ma non sono riuscito a importarlo correttamente.

• +1 byte sostituendo uno spazio dopo importcon\<newline> . La rimozione di uno o entrambi provoca un errore.

Potrebbero esserci ancora opzioni più lunghe rispetto a flask_env, non ho fatto una ricerca esaustiva ma ho guardato attraverso circa 70.000 moduli. Aperto a suggerimenti.

R , 14 byte

(Sys.readlink)

Provalo online!

Questo potrebbe essere il più lungo possibile in R. Chiamare qualsiasi funzione è destinata a fallire, perché si sarebbe in grado di rimuovere tutto tranne il nome della funzione, il che comporterebbe solo la stampa del codice sorgente della funzione. Questo è l'oggetto con il nome più lungo nell'impostazione R predefinita senza caratteri duplicati e senza nome oggetto rimasto durante la rimozione di caratteri contigui.

Questo primo tentativo non ha funzionato, ma ho imparato molto provandoci!

dontCheck({family;NROW})

Perl 5, 3 byte

y=>

=>è la "virgola grassa", che cita la parola nuda a sinistra. Quindi questo equivale a

"y",

che non fa nulla.

Senza la virgola grassa, y è l'operatore di traslitterazione, che non è valido senza tre dello stesso carattere ripetuto in seguito.

Anche la virgola grassa non è valida, così come è =e >da sola.

Brainfuck , 2 byte

[]

Provalo online!

Ispirato dalla risposta Brain-Flak di Jo King . Questo è ottimale perché l'unico errore nel brainfuck è rappresentato dalle parentesi senza pari. (Ancora una volta grazie a Jo King per queste informazioni.)

Rubino , 28 byte

(?2*0xA)[%r<\d{1}>].unpack$/

Provalo online!

Verificalo!

ML standard , 22 byte

val 1089=op-(765,~324)

Provalo online! op-(a,b)è la forma de-zuccherata di a-b. ~indica il meno unario, quindi stiamo effettivamente calcolando 765+324. Questa espressione è associata al modello sulla costante 1089. Questa partita ha successo se il programma non è stato manomesso e lo fa - beh, niente.

Se la partita non riesce perché alcune cifre sono state rimosse si ottiene un unhandled exception: Bind. La rimozione op-provoca un errore di tipo perché una tupla è abbinata su un int. Tutte le altre rimozioni dovrebbero causare un errore di sintassi.

Swift 4 , 19 byte

[].contains{1 !=
0}

Provalo online!

Tutti i possibili errori che ho trovato sono:

• Rimuovere qualsiasi [, ], {o }si tradurrà in un errore di sintassi
• La rimozione [].comporteràUse of unresolved identifier 'contains'
• La rimozione .comporteràConsecutive statements on a line must be separated by ';'
• La rimozione []comporteràReference to member 'contains' cannot be resolved without a contextual type
• La rimozione {1 !=␊0}comporteràExpression resolves to an unused function
• La rimozione 1 !=␊0comporteràMissing return in a closure expected to return 'Bool'
  • La rimozione della nuova riga comporterà '!=' is not a prefix unary operator
  • La rimozione dello spazio comporterà '=' must have consistent whitespace on both sides
  • La rimozione !=comporteràMissing return in a closure expected to return 'Bool'
    • Anche la rimozione della nuova riga comporterà Consecutive statements on a line must be separated by ';'
    • La rimozione dello spazio e della nuova riga (e zero o una delle cifre) comporterà Contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored
• La rimozione [].containscomporteràClosure expression is unused

Alcuni altri programmi interessanti sono (uno su ogni riga):

[].isEmpty
[:].values
[1:2]

Tcl , 6 byte

puts a

Provalo online!

pwd

Provalo online!

cd

Provalo online!

Lotto, 7 byte

set/px=

Un buon inizio

Retina , 2 byte

Non sarei sorpreso se questo fosse ottimale ...

()

Provalo online!

Il regex contiene un gruppo vuoto. La rimozione di entrambi i paren causerà un errore di analisi dovuto a parentesi senza pari.

Altre soluzioni sono: \(, \), \[, \], \*, \+, \?,a]

C (gcc) , 73 75 byte

#include <ftw.h>
ABCEGHIJKLMNOPQRSUVXYZabjkmopqrsvxz234567890(){g FTW_D-1;}

Provalo online!

Basato sulla risposta di @Steadybox, grazie a @Angs per il rilevamento di errori gravi.

Sì, è un trucco sporco (perché in realtà utilizza un#define con -DABCEGHIJKLMNOPQRSUVXYZabjkmopqrsvxz234567890=maine -Dg=return), ma non vedo alcuna regola che vieti tale opzione del compilatore.