Chiunque può aumentare l'output di un programma aggiungendo caratteri, quindi facciamo l'esatto contrario.

Scrivi un programma completo, una funzione interna o uno snippet per un ambiente REPL in una lingua a tua scelta che soddisfi i seguenti criteri:

1. Il codice deve contenere almeno 1 carattere.

2. L'esecuzione del codice originale produce x caratteri di output su STDOUT (o alternativa più vicina), dove 0 ≤ x <+ ∞ .

3. La rimozione di qualsiasi singolo carattere arbitrario dal codice originale restituisce di nuovo un codice valido, che produce almeno x + 1 caratteri di output su STDOUT.

4. Né il codice originale né le modifiche possono produrre output di errore, sia su STDOUT, STDERR, syslog o altrove. Le uniche eccezioni a questa regola sono gli avvisi del compilatore.

   Il programma potrebbe non richiedere flag o impostazioni per eliminare l'output dell'errore.

   Il tuo programma potrebbe non contenere errori irreversibili, anche se non producono alcun output.

5. Sia il codice originale che le modifiche devono essere deterministici e finire alla fine (senza loop infiniti).

6. Né il codice originale né le modifiche possono richiedere input di alcun tipo.

7. Funzioni o frammenti non possono mantenere alcuno stato tra le esecuzioni.

Considerando che questo compito è banale in alcune lingue e assolutamente impossibile in altre, si tratta di un concorso di popolarità .

Al momento del voto, si prega di tenere conto della "carenza relativa" del codice, ovvero una risposta più breve dovrebbe essere considerata più creativa di una risposta più lunga nella stessa lingua .

Qualsiasi REPL con operazione XOR con cursore, 5 byte

11^11

11^11è ovviamente 0. Le uniche altre possibilità sono 1^11o 11^1che sono 10 o 1111che produce se stesso.

TI-BASIC, 3 1

"

Quando l'ultima riga di un programma è un'espressione, la calcolatrice visualizzerà quell'espressione. Altrimenti, la calcolatrice viene visualizzata al Donetermine del programma. L'espressione qui è la stringa vuota, ma potrebbe anche funzionare con qualsiasi numero di una cifra.

2 byte:

isClockOn

Come sopra ma con un token a 2 byte.

3 byte:

ππ⁻¹

Stampe 1dovute alla moltiplicazione implicita. Può essere esteso indefinitamente aggiungendo coppie di ⁻¹'s. Di seguito funziona anche.

√(25
e^(πi
⁻ii
ii³
2ππ   
cos(2π

Soluzioni più lunghe:

11/77►Frac
ᴇ⁻⁻44
cos(208341   //numerator of a convergent to pi; prints "-1"

Probabilmente ci sono anche soluzioni multilinea ma non ne trovo nessuna.

CJam, JavaScript, Python, ecc., 18 byte

8.8888888888888888

Le uscite in CJam sono:

8.8888888888888888 -> 8.88888888888889
8.888888888888888  -> 8.888888888888888
88888888888888888  -> 88888888888888888
.8888888888888888  -> 0.8888888888888888

JavaScript e Python funzionano in modo simile. Non è competitivo in JavaScript e Python, ma non è facile trovarne uno più corto in CJam .

Ottava, 5 byte

10:10

(x: y) fornisce l'array di numeri tra xey in incrementi di 1, quindi tra 10 e 10 l'unico elemento è 10:

> 10:10
ans = 10

Quando il secondo argomento è inferiore al primo, l'ottava stampa la matrice vuota e le sue dimensioni:

> 10:1
ans = [](1x0)

> 10:0
ans = [](1x0)

Quando un carattere viene rimosso dal primo numero, ci sono più elementi nella matrice:

> 1:10
ans = 1 2 3 4 5 6 7 8 9 10

> 0:10
ans = 0 1 2 3 4 5 6 7 8 9 10

Quando i due punti vengono rimossi, il numero restituisce se stesso:

> 1010
ans = 1010

Microscript, 1 byte

h

Questo non produce alcun risultato, poiché hsopprime la stampa implicita del linguaggio. La rimozione dell'unico carattere produce un programma il cui output è 0\n.

Proverò a trovare una risposta migliore in seguito.

MODIFICA IL 17 NOVEMBRE:

Questo funziona anche in Microscript II, con l'eccezione che, invece di cedere 0\n, produce il programma vuoto null.

Pyth, 3 byte

cGG

Gè preinizializzato con le lettere minuscole dell'alfabeto. cè la funzione split.

cGGdivide l'alfabeto per occorrenze dell'alfabeto, che termina in ['', ''](8 byte).

Quando manca il secondo parametro, cdivide la stringa in spazi bianchi, tabulazioni o righe. Poiché nessuno di essi appare in G, l'output per cGè ['abcdefghijklmnopqrstuvwxyz'](30 byte).

E GGsemplicemente stampa due volte l'alfabeto su due linee separate: abcdefghijklmnopqrstuvwxyz\nabcdefghijklmnopqrstuvwxyz(53 byte).

Provalo online: dimostrazione

Python REPL, 6 byte

Non il più breve, ma ecco un'altra risposta di abuso in virgola mobile:

>>> 1e308
1e+308
>>> 11308
11308
>>> 11e08
1100000000.0
>>> 11e38
1.1e+39
>>> 11e30
1.1e+31

Ma...

>>> 11e308
inf

JavaScript (e molto altro), 5byte

44/44 o

44/44 -> 1
44/4  -> 11
4444  -> 4444
4/44  -> 0.09090909090909091

CJam, 5

''''=

Provalo online

''''=   compares two apostrophes and prints 1
'''=    prints '=
''''    prints ''

Lenguage , 5 byte

00000

La lunghezza del programma è 5 che corrisponde al programma brainf *** che ,legge una fine del carattere di input e termina senza output.

La rimozione di qualsiasi carattere risulta nel codice 0000che ha una lunghezza di 4 corrispondente al programma brainf *** .stampando un carattere (punto di codice 0) e terminando.

L' equivalente Unario sarebbe 0000000000000(13 zeri) perché devi anteporre un anticipo 1alla lunghezza binaria del codice così 101diventa 1101.

PHP, 6 byte

Ho osservato questo gruppo per un paio di settimane e sono sorpreso delle tue tecniche di programmazione. Ora ho dovuto accedere, c'è qualcosa che posso fare, scusa :-) Tuttavia, questo potrebbe essere il mio ultimo post qui ...

<?php 

(nota lo spazio dopo il secondo p)

Questo genera una stringa vuota. La rimozione di qualsiasi carattere genera il testo senza il carattere. Nota che può produrre errori HTML (contenuto non reso dai browser per es. <?ph).

Ho anche provato con il echotag. vale a dire. per esempio.:

<?= __LINE__;;

Questo emette 1. Se =viene omesso, <? __LINE__;;è l'output. Tuttavia, la rimozione di qualsiasi carattere della costante magica si tradurrà in E_NOTICE : Avviso: uso della costante non definita LNE - assunto ' LNE ' in ...

Se gli avvisi non sono considerati errori (punto 4 delle regole), ciò vale anche :-)

Python, 10 8 byte

256**.25

Funziona con Python e gli amici. Grazie a Jakube per aver mostrato come ridurlo di 2 byte.

Da IDLE:

>>> 256**.25
4.0
>>> 26**.25
2.2581008643532257
>>> 56**.25
2.7355647997347607
>>> 25**.25
2.23606797749979
>>> 256*.25
64.0
>>> 256*.25
64.0
>>> 256**25
1606938044258990275541962092341162602522202993782792835301376L
>>> 256**.5
16.0
>>> 256**.2
3.0314331330207964

originariamente avevo questo (10 byte):

14641**.25

Da IDLE:

>>> 14641**.25
11.0
>>> 4641**.25
8.253780062553423
>>> 1641**.25
6.364688382085818
>>> 1441**.25
6.161209766937384
>>> 1461**.25
6.18247763499657
>>> 1464**.25
6.185648950548194
>>> 14641*.25
3660.25
>>> 14641*.25
3660.25
>>> 14641**25
137806123398222701841183371720896367762643312000384664331464775521549852095523076769401159497458526446001L
>>> 14641**.5
121.0
>>> 14641**.2
6.809483127522302

e sulla stessa nota:

121**.25*121**.25

funziona in modo identico grazie al piacevole arrotondamento di Python, in 17 byte.

>>> 121**.25*121**.25
11.0
>>> 21**.25*121**.25
7.099882579628641
>>> 11**.25*121**.25
6.0401053545372365
>>> 12**.25*121**.25
6.172934291446435
>>> 121*.25*121**.25
100.32789990825084
>>> 121*.25*121**.25
100.32789990825084
>>> 121**25*121**.25
3.8934141282176105e+52
>>> 121**.5*121**.25
36.4828726939094
>>> 121**.2*121**.25
8.654727864164496
>>> 121**.25121**.25
29.821567222277217
>>> 121**.25*21**.25
7.099882579628641
>>> 121**.25*11**.25
6.0401053545372365
>>> 121**.25*12**.25
6.172934291446435
>>> 121**.25*121*.25
100.32789990825084
>>> 121**.25*121*.25
100.32789990825084
>>> 121**.25*121**25
3.8934141282176105e+52
>>> 121**.25*121**.5
36.4828726939094
>>> 121**.25*121**.2
8.654727864164496

Interprete SWI-Prolog

__A=__A.

Nota: non è possibile rimuovere il finale. . Gli interpreti di Prolog cercheranno sempre un periodo finale per eseguire la tua query, quindi se rispettiamo rigorosamente le regole di questo concorso e ci permettiamo di rimuovere il periodo in cui non verrà eseguito, salterà una riga e attenderà ulteriori comandi fino a quando uno è terminato da un punto.

L' __A=__A.output della query originale true..

La query _A=__A.genera _A = '$VAR'('__A'). Modifiche simili (ovvero la rimozione di una _o una delle due A) produrranno output simili.

Infine, la query __A__A.genera in SWI-Prolog:

% ... 1,000,000 ............ 10,000,000 years later
% 
%       >> 42 << (last release gives the question)

Sed, 1 byte

d

Come sedrichiede un flusso di input, proporrò una convenzione secondo cui il programma stesso dovrebbe essere fornito come input.

$ sed -e 'd' <<<'d' | wc -c
0
$ sed -e '' <<<'d' | wc -c
2

Un programma alternativo è x, ma che cambia solo 1al 2byte di uscita quando cancellato.

K, 3 byte

2!2

Uscite 0nel REPL. Rimuovendo i primi 2 output 0 1, rimuovendo i risultati esclamativi 22e rimuovendo gli ultimi 2 si ottiene una stringa che varia tra le implementazioni K ma è sempre almeno 2 caratteri (in oK, è (2!); secondo @Dennis, output Kona 2!).

MATLAB, 9 7 byte

È 2 byte più lungo dell'altra risposta MATLAB / Octave, ma mi piace comunque, poiché è un po 'più complesso.

L' 'operatore di Matlab è la complessa trasposizione coniugata. Usandolo su un numero immaginario scalare, ottieni i' = -i. Come numeri immaginari possono essere scritti semplicemente come 2isi può fare:

2i--2i'
ans =
     0    

La rimozione di uno qualsiasi dei personaggi comporterà uno dei seguenti:

ans =
   0.0000 - 1.0000i
   2.0000 - 2.0000i
   0.0000 + 4.0000i
   0.0000 + 4.0000i
   0.0000 + 1.0000i
   2.0000 + 2.0000i
   0.0000 + 4.0000i

GolfScript, 2 byte

Questa risposta è non competitiva, ma poiché è il pezzo di codice che ha ispirato questa sfida, ho voluto condividerla comunque.

:n

Per impostazione predefinita, tutti i programmi GolfScript stampano l'intero stack, seguito da un avanzamento riga, eseguendo putsl'intero stack. La putsstessa funzione è implementata come {print n print}nell'interprete, dove printè un vero built-in ed nè una variabile che contiene la stringa "\n"di default.

Ora, un programma GolfScript invia sempre l'input da STDIN nello stack. In questo caso, poiché non è presente alcun input, viene inviata una stringa vuota. L'assegnazione delle variabili :nsalva la stringa vuota n, eliminando l'avanzamento di riga implicito e rendendo completamente vuoto l'output.

Eliminando n, rimani con l'assegnazione variabile incompleta :(penseresti che sia un errore di sintassi, ma no), quindi l'alimentazione di riga implicita viene stampata come al solito.

Eliminando :, si rimane con n, che spinge un avanzamento di riga nello stack, quindi il programma stampa due avanzamenti di riga.

APL, J e possibilmente altre varianti, 3 byte

--1

Emette 1in APL. -1genera ¯1e --genera quanto segue in TryAPL :

┌┴┐
- -

J, 5 byte

|5j12

Entità del numero complesso 5 + 12iin REPL.

   |5j12 NB. original, magnitude of the complex number `5 + 12i`
13
   5j12  NB. the complex number `5 + 12i`
5j12
   |j12  NB. magnitude of the undefined function j12
| j12
   |512  NB. magnitude of 512
512
   |5j2  NB. magnitude of 5 + 2i
5.38516
   |5j1  NB. magnitude of 5 + 1i
5.09902

.

J, 9 byte

%0.333333

Basato su precisione in virgola mobile, reciproco e matrice inversa.

   %0.333333 NB. original, reciprocal of 0.333333
3
   0.333333  NB. 0.333333
0.333333
   %.333333  NB. matrix inverse of 333333
3e_6
   %0333333  NB. reciprocal of 333333
3e_6
   %0.33333  NB. reciprocal of 0.33333
3.00003

Provalo online qui.

Mathematica, 3 byte

4!0

4!0  ->  0    the factorial of 4, times 0
4!   ->  24   the factorial of 4
40   ->  40
!0   ->  !0   the logical not of 0, but 0 is not a boolean value

Dyalog APL , 2 byte

⍴0 restituisce una stringa vuota (lunghezza 0)

⍴ritorni ⍴(lunghezza 1)

0ritorni 0(lunghezza 1)

Rapido (e molto altro), 8 byte

93^99<84

output (4 caratteri):

true

Quando si rimuove l'ennesimo carattere, l'output è:

n -> out
----------
0 -> false
1 -> false
2 -> false
3 -> false
4 -> false
5 -> 10077
6 -> false
7 -> false

Ci sono 78 possibili soluzioni come questa nel formato di a^b<c.

Penso che l'obiettivo di questa sfida dovrebbe essere il maggior numero di byte possibile, perché più byte, più byte possibili da rimuovere e quindi più difficili.

MathGolf , 2 byte

♂(

Provalo online!

Spiegazione

♂   Push 10
 (  Decrement TOS by 1

Perché funziona?

L'output normale è 9. Se (viene rimosso, l'output è 10. Se ♂viene rimosso, il programma estrae implicitamente uno 0 dallo stack per alimentare l' (operatore, che genera -1.

Clojure, 11 byte

(defn x[]1)

All'inizio ho pensato di pubblicare una sola risposta nel REPL come le altre lingue, ad es

user=> 1
1

Ma il problema è che se rimuovi quel carattere, il REPL non fa nulla quando premi il tasto Invio. Quindi, invece, ha dovuto essere avvolto con una funzione consentita dalle regole della domanda. Quando si chiama questa funzione, viene restituito 1. Se si rimuove l'unico carattere nella funzione,

(defn x[])

restituisce la funzione nilche stampa altri due byte.

user=> (defn x[]1)
#'user/x
user=> (x)
1
user=> (defn y[])
#'user/y
user=> (y)
nil

05AB1E (legacy), 1 byte

Qualsiasi singolo byte in 05AB1E (legacy) funzionerebbe, ad eccezione di [(loop infinito).

Vedi qui tutte le possibili uscite per tutti i possibili programmi 05AB1E a byte singolo.

La rimozione di quel singolo byte in modo che rimanga un programma vuoto produrrà il contenuto di info.txt su STDOUT invece di default.

Provalo online.

05AB1E , 1 byte

?

Provalo online.

Sfortunatamente un programma vuoto nella nuova versione di 05AB1E emette solo una newline a 1 byte per impostazione predefinita ( provalo online ), quindi quasi nessuno dei caratteri a 1 byte è possibile poiché non dovranno produrre nulla. L'unico programma possibile che non genera nulla (quindi non anche la newline implicita) è ?per quanto ne so.

Japt , 2 byte

AÉ

Provalo online!

Aè pre-inizializzata a 10, Ésottrae 1, ed il risultato è 1 byte: 9.

La rimozione di É comporta il programma A, che genera il valore di A 10, quindi il risultato è 2 byte.

Allo stesso modo, la rimozione di A risulta esattamente Écome interpretata come -1 e come output -1, quindi il risultato è 2 byte.

Incantesimi runici , 6 byte (modificabili)

11-{{B\
/B~~@/
\00<
R"Error"@

Provalo online!

Runic non ha un ambiente REPL e scrivere un programma completo per soddisfare i vincoli non è prontamente possibile (portando a programmi non validi o nessun output). Quindi la parte del codice 11-{{Bagisce come una funzione interna e solo questa parte può essere modificata. L' Bistruzione è abbastanza vicina a un puntatore a funzione e un'istruzione return che questa classificazione dovrebbe essere accettabile (poiché salta l'IP in una posizione nel codice, oltre a spingere una posizione di ritorno nello stack a cui può accedere un successivo Bo scartato) .

• Uscita standard: 0
• Rimozione di una delle 1s:05
• Rimozione di -:11
• Rimozione {:Error051
• Rimozione di B:120

Il finale \alla fine della prima riga fornisce un limite esterno attorno alla funzione interna nel caso in cui l'istruzione return sia rimossa in modo tale che l'IP non vada a zigzagare ovunque, volenti o nolenti (e non stampa alcun output).

Si noti che Error051è solo una stringa arbitraria, potrei mettere tutto ciò che volevo in quella parte del codice e "Errore" è stato un risultato divertente per avere il codice che riduce le coordinate di ritorno e i teletrasporti IP in una posizione arbitraria.