Qualquer um pode aumentar a saída de um programa adicionando caracteres, então vamos fazer exatamente o oposto.

Escreva um programa completo, uma função interna ou um trecho para um ambiente REPL em um idioma de sua escolha que atenda aos seguintes critérios:

1. Seu código deve ter pelo menos 1 caractere.

2. A execução do código original produz x caracteres de saída para STDOUT (ou alternativa mais próxima), onde 0 ≤ x <+ ∞ .

3. A remoção de qualquer caractere único arbitrário do código original resulta novamente em código válido, que produz pelo menos x + 1 caracteres de saída para STDOUT.

4. Nem o código original nem as modificações podem produzir saída de erro, seja para STDOUT, STDERR, syslog ou outro local. As únicas exceções a esta regra são avisos do compilador.

   Seu programa pode não exigir sinalizadores ou configurações para suprimir a saída de erro.

   Seu programa pode não conter erros fatais, mesmo que eles não produzam nenhuma saída.

5. O código original e as modificações devem ser determinísticos e terminar eventualmente (sem loops infinitos).

6. Nem o código original nem as modificações podem exigir entrada de qualquer tipo.

7. Funções ou trechos não podem manter nenhum estado entre execuções.

Considerando que essa tarefa é trivial em alguns idiomas e absolutamente impossível em outros, este é um concurso de popularidade .

Ao votar, leve em consideração a "relativa falta" do código, ou seja, uma resposta mais curta deve ser considerada mais criativa do que uma resposta mais longa no mesmo idioma .

Qualquer REPL com operação XOR de intercalação, 5 bytes

11^11

11^11é claro que 0. As únicas outras possibilidades são 1^11ou 11^1são 10 ou 1111se produzem.

TI-BASIC, 3 1

"

Quando a última linha de um programa é uma expressão, a calculadora exibirá essa expressão. Caso contrário, a calculadora será exibida Donequando o programa terminar. A expressão aqui é a cadeia vazia, mas também pode funcionar com qualquer número de um dígito.

2 bytes:

isClockOn

O mesmo que o acima, mas com um token de 2 bytes.

3 bytes:

ππ⁻¹

Imprime 1devido à multiplicação implícita. Pode ser estendido indefinidamente adicionando pares de ⁻¹'s. O abaixo também funciona.

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

Soluções mais longas:

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

Provavelmente também existem soluções com várias linhas, mas não consigo encontrar nenhuma.

CJam, JavaScript, Python, etc, 18 bytes

8.8888888888888888

As saídas no CJam são:

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

JavaScript e Python funcionam de maneiras semelhantes. Não é competitivo em JavaScript e Python, mas não é fácil encontrar um mais curto no CJam .

Oitava, 5 bytes

10:10

(x: y) fornece a matriz de números entre x e y em incrementos de 1; portanto, entre 10 e 10, o único elemento é 10:

> 10:10
ans = 10

Quando o segundo argumento é menor que o primeiro, a oitava imprime a matriz vazia e suas dimensões:

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

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

Quando um caractere é removido do primeiro número, há mais elementos na matriz:

> 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 os dois pontos são removidos, o número retorna:

> 1010
ans = 1010

Microscript, 1 byte

h

Isso não produz saída, pois hsuprime a impressão implícita da linguagem. A remoção do caractere único produz um programa cuja saída é 0\n.

Vou tentar encontrar uma resposta melhor mais tarde.

EDITAR EM 17 DE NOVEMBRO:

Isso também funciona no Microscript II, com a exceção de que, em vez de render 0\n, o programa vazio produz null.

Pitão, 3 bytes

cGG

Gé pré-inicializado com as letras minúsculas no alfabeto. cé a função de divisão.

cGGdivide o alfabeto por ocorrências do alfabeto, que terminam em ['', ''](8 bytes).

Quando o segundo parâmetro estiver ausente, cdivida a sequência por espaços em branco, tabulações ou novas linhas. Como nenhum deles aparece G, a saída para cGé ['abcdefghijklmnopqrstuvwxyz'](30 bytes).

E GGsimplesmente imprime duas vezes o alfabeto em duas linhas separadas: abcdefghijklmnopqrstuvwxyz\nabcdefghijklmnopqrstuvwxyz(53 bytes).

Experimente online: Demonstração

REPL Python, 6 bytes

Não é o mais curto, mas aqui está outra resposta de abuso de ponto flutuante:

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

Mas...

>>> 11e308
inf

JavaScript (e muito mais), 5 bytes

44/44 ou

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

CJam, 5

''''=

Experimente online

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

Linguagem , 5 bytes

00000

A duração do programa é 5, que corresponde ao programa brainf *** que ,lê um final de caractere de entrada e termina sem saída.

A remoção de qualquer caractere resulta no código 0000que possui um comprimento de 4 correspondente ao programa brainf ***, .imprimindo um caractere (ponto de código 0) e finalizando.

O Unário equivalente seria 0000000000000(13 zeros) porque você tem que preceder um líder 1para o comprimento binário do código de modo 101torna-se 1101.

PHP, 6 bytes

Estou assistindo esse grupo há algumas semanas e fico impressionado com suas técnicas de programação. Agora eu tive que entrar, há algo que posso fazer, desculpe :-) No entanto, este pode ser meu último post aqui ...

<?php 

(observe o espaço após o segundo p)

Isso gera uma string vazia. A remoção de qualquer caractere gera o texto sem o caractere. Observe que ele pode produzir erros de HTML (conteúdo não renderizado pelos navegadores, por exemplo <?ph).

Eu também tentei com a echotag. ie por exemplo.:

<?= __LINE__;;

Este sai 1. Se =for omitido, <? __LINE__;;é a saída. No entanto, remover qualquer caractere constante mágica resultará em E_NOTICE : Aviso: Uso de LNE constante indefinida - assumido ' LNE ' em ...

Se os avisos não forem considerados erros (ponto 4 das regras), o mesmo se aplica :-)

Python, 10 8 bytes

256**.25

Trabalha em Python e amigos. Agradecemos a Jakube por mostrar como torná-lo 2 bytes menor.

Do 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

originalmente eu tinha isso (10 bytes):

14641**.25

Do 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 na mesma nota:

121**.25*121**.25

funciona de forma idêntica devido ao bom arredondamento do Python, em 17 bytes.

>>> 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

Intérprete SWI-Prolog

__A=__A.

Nota: Você não pode remover a final. . Os intérpretes do Prolog sempre procurarão um período final para executar sua consulta. Portanto, se seguirmos estritamente as regras deste concurso e permitirmos remover o período em que ele não será executado, ele pulará uma linha e aguardará comandos adicionais até que um termina em um período.

A consulta original é __A=__A.exibida true..

A consulta é _A=__A.exibida _A = '$VAR'('__A'). Modificações semelhantes (isto é, remover uma _ou uma das duas A) resultarão em saídas semelhantes.

Por fim, a consulta __A__A.gera no SWI-Prolog:

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

Sed, 1 byte

d

Como sedrequer um fluxo de entrada, proponho uma convenção de que o próprio programa deve ser fornecido como entrada.

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

Um programa alternativo é x, mas que somente muda de 1para 2bytes de saída quando excluído.

K, 3 bytes

2!2

Saídas 0no REPL. A remoção das 2 primeiras saídas 0 1, a remoção dos resultados da exclamação 22e a remoção dos 2 últimos resultam em uma sequência que varia entre as implementações K, mas sempre tem pelo menos 2 caracteres (em OK, é (2!); de acordo com @Dennis, saídas Kona 2!).

MATLAB, 9 7 bytes

Tem 2 bytes a mais do que a outra resposta do MATLAB / Octave, mas eu gosto disso, pois é um pouco mais complexo.

O 'operador do Matlab é a transposição conjugada complexa. Usando isso em um número imaginário escalar, você entende i' = -i. Como números imaginários podem ser escritos simplesmente como 2ise pode fazer:

2i--2i'
ans =
     0    

A remoção de qualquer um dos caracteres resultará em uma das opções abaixo:

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 bytes

Essa resposta não é competitiva, mas como é o código que inspirou esse desafio, eu queria compartilhá-lo de qualquer maneira.

:n

Por padrão, todos os programas GolfScript imprimem a pilha inteira, seguida por um avanço de linha, executando putsna pilha inteira. A função em putssi é implementada como {print n print}no intérprete, onde printé um built-in real e né uma variável que mantém a string "\n"por padrão.

Agora, um programa GolfScript sempre empurra a entrada de STDIN na pilha. Nesse caso, como não há nenhuma entrada, uma string vazia é pressionada. A atribuição de variável :nsalva essa sequência vazia n, suprimindo o avanço de linha implícito e tornando a saída completamente vazia.

Ao eliminar n, você fica com a atribuição de variável incompleta :(você acha que é um erro de sintaxe, mas não), para que o avanço de linha implícito seja impresso como de costume.

Ao eliminar :, você fica com n, o que pressiona um avanço de linha na pilha, para que o programa imprima dois feeds de linha.

APL, J e possivelmente outras variantes, 3 bytes

--1

Ele gera 1em APL. -1saídas ¯1e --produz o seguinte no TryAPL :

┌┴┐
- -

J, 5 bytes

|5j12

Magnitude do número complexo 5 + 12ino 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 bytes

%0.333333

Com base na precisão do ponto flutuante, recíproco e inverso da matriz.

   %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

Experimente online aqui.

Mathematica, 3 bytes

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 bytes

⍴0 retorna uma string vazia (comprimento 0)

⍴retornos ⍴(comprimento 1)

0retornos 0(comprimento 1)

Swift (e muito mais), 8 bytes

93^99<84

saída (4 caracteres):

true

Ao remover o enésimo caractere, a saída é:

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

Existem 78 soluções possíveis como esta no formato de a^b<c.

Eu acho que o objetivo desse desafio deve ser o maior número possível de bytes, porque quanto mais bytes, mais bytes possíveis serão removidos e, portanto, mais difíceis.

MathGolf , 2 bytes

♂(

Experimente online!

Explicação

♂   Push 10
 (  Decrement TOS by 1

Por que isso funciona?

A saída regular é 9. Se o (item for removido, a saída será 10. Se o ♂item for removido, o programa implicitamente exibirá um 0 da pilha para alimentar o (operador, o qual será emitido -1.

Clojure, 11 bytes

(defn x[]1)

No começo, pensei em publicar apenas uma resposta de caractere no REPL, como os outros idiomas, por exemplo

user=> 1
1

Mas o problema é que, se você remover esse caractere, o REPL não fará nada ao pressionar a tecla Enter. Então, ao invés disso, ele teve que ser envolvido com uma função permitida pelas regras da pergunta. Quando você chama essa função, ela retorna 1. Se você remover o único caractere na função,

(defn x[])

a função retorna, nilque imprime mais dois bytes.

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

05AB1E (herdado), 1 byte

Qualquer byte único em 05AB1E (legado) funcionaria, exceto em [(loop infinito).

Veja aqui todas as saídas possíveis para todos os programas 05AB1E de byte único possíveis.

A remoção desse byte único para que um programa vazio permaneça produzirá o conteúdo de info.txt para STDOUT, por padrão.

Experimente online.

05AB1E , 1 byte

?

Experimente online.

Infelizmente, um programa vazio na nova versão do 05AB1E gera apenas uma nova linha de 1 byte por padrão ( Experimente on-line ); portanto, quase nenhum dos caracteres de 1 byte é possível, pois eles não precisam produzir nada. O único programa possível que não produz nada (também não é a nova linha implícita) é ?até onde eu sei.

Japonês , 2 bytes

AÉ

Experimente online!

Aé pré-inicializada a 10, Ésubtrai um, e o resultado é um byte: 9.

A remoção de É resulta no programa A, que gera o valor de A 10, então o resultado é 2 bytes.

Da mesma forma, a remoção de A resulta exatamente no Éque é interpretado como -1 e como saída -1, portanto, o resultado é 2 bytes.

Encantos Rúnicos , 6 bytes (modificáveis)

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

Experimente online!

O Runic não possui um ambiente REPL e a gravação de um programa completo para satisfazer as restrições não é prontamente viável (levando a programas inválidos ou sem saída). Portanto, a parte do código 11-{{Bestá atuando como uma função interna e somente essa parte pode ser modificada. A Binstrução está próxima o suficiente de um ponteiro de função e declaração de retorno para que essa classificação seja aceitável (pois salta o IP para uma posição no código, além de empurrar um local de retorno para a pilha que pode ser acessada por um subseqüente Bou descartado) .

• Saída padrão: 0
• Removendo um dos 1s:05
• Removendo o -:11
• Removendo {:Error051
• Removendo o B:120

A final \no final da primeira linha fornece um limite externo em torno da função interna, no caso de a instrução de retorno ser removida, para que o IP não seja sinuoso em todos os lugares por todo o lado, quer ou não (e não imprime saída).

Observe que Error051é apenas uma sequência arbitrária; eu poderia colocar o que quisesse nessa parte do código e "Erro" foi um resultado divertido por ter um código que altera as coordenadas de retorno e o IP é teleportado para um local arbitrário.