Cualquiera puede aumentar el rendimiento de un programa agregando caracteres, así que hagamos exactamente lo contrario.

Escriba un programa completo, una función interna o un fragmento para un entorno REPL en un idioma de su elección que satisfaga los siguientes criterios:

1. Su código debe tener al menos 1 carácter de largo.

2. La ejecución del código original produce x caracteres de salida a STDOUT (o la alternativa más cercana), donde 0 ≤ x <+ ∞ .

3. La eliminación de cualquier carácter individual arbitrario del código original vuelve a generar un código válido, que produce al menos x + 1 caracteres de salida a STDOUT.

4. Ni el código original ni las modificaciones pueden producir ningún resultado de error, ya sea STDOUT, STDERR, syslog u otro lugar. Las únicas excepciones a esta regla son las advertencias del compilador.

   Es posible que su programa no requiera ningún indicador o configuración para suprimir la salida de error.

   Es posible que su programa no contenga errores fatales, incluso si no producen ningún resultado.

5. Tanto el código original como las modificaciones deben ser deterministas y terminar finalmente (sin bucles infinitos).

6. Ni el código original ni las modificaciones pueden requerir entrada de ningún tipo.

7. Las funciones o fragmentos pueden no mantener ningún estado entre ejecuciones.

Teniendo en cuenta que esta tarea es trivial en algunos idiomas y francamente imposible en otros, este es un concurso de popularidad .

Al votar, tenga en cuenta la "brevedad relativa" del código, es decir, una respuesta más corta debe considerarse más creativa que una respuesta más larga en el mismo idioma .

Cualquier REPL con operación caret XOR, 5 bytes

11^11

11^11es, por supuesto, 0. Las únicas otras posibilidades son 1^11o 11^1que son 10, o 1111que se produce a sí mismo.

TI-BASIC, 3 1

"

Cuando la última línea de un programa es una expresión, la calculadora mostrará esa expresión. De lo contrario, la calculadora aparece Donecuando finaliza el programa. La expresión aquí es la cadena vacía, pero también podría funcionar con cualquier número de un dígito.

2 bytes:

isClockOn

Igual que el anterior pero con un token de 2 bytes.

3 bytes:

ππ⁻¹

Impresiones 1debido a multiplicación implícita. Se puede extender indefinidamente agregando pares de ⁻¹'s. Los siguientes también funcionan.

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

Soluciones más largas:

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

Probablemente también hay soluciones de varias líneas, pero no puedo encontrar ninguna.

CJam, JavaScript, Python, etc., 18 bytes

8.8888888888888888

Las salidas en CJam son:

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

JavaScript y Python funcionan de manera similar. No es competitivo en JavaScript y Python, pero no es fácil encontrar uno más corto en CJam .

Octava, 5 bytes

10:10

(x: y) da la matriz de números entre x e y en incrementos de 1, por lo que entre 10 y 10 el único elemento es 10:

> 10:10
ans = 10

Cuando el segundo argumento es menor que el primero, la octava imprime la matriz vacía y sus dimensiones:

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

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

Cuando se elimina un carácter del primer número, hay más elementos en la 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

Cuando se eliminan los dos puntos, el número vuelve a aparecer:

> 1010
ans = 1010

Microscript, 1 byte

h

Esto no produce salida, ya que hsuprime la impresión implícita del lenguaje. Eliminar el único carácter produce un programa cuya salida es 0\n.

Trataré de encontrar una mejor respuesta más tarde.

EDITAR EL 17 DE NOVIEMBRE:

Esto también funciona en Microscript II, con la excepción de que, en lugar de ceder 0\n, el programa vacío rinde null.

Pyth, 3 bytes

cGG

Gse preinicializa con las letras minúsculas en el alfabeto. ces la función dividida

cGGdivide el alfabeto por ocurrencias del alfabeto, que termina en ['', ''](8 bytes).

Cuando falta el segundo parámetro, cdivide la cadena por espacios en blanco, tabuladores o líneas nuevas. Como ninguno de ellos aparece G, la salida cGes ['abcdefghijklmnopqrstuvwxyz'](30 bytes).

Y GGsimplemente imprime dos veces el alfabeto en dos líneas separadas: abcdefghijklmnopqrstuvwxyz\nabcdefghijklmnopqrstuvwxyz(53 bytes).

Pruébelo en línea: demostración

Python REPL, 6 bytes

No es el más corto, pero aquí hay otra respuesta de abuso de punto flotante:

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

Pero...

>>> 11e308
inf

JavaScript (y mucho más), 5byte

44/44 o

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

CJam, 5

''''=

Pruébalo en línea

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

Lenguage , 5 bytes

00000

La longitud del programa es 5, que corresponde al programa brainf *** que ,lee el final del carácter de entrada y termina sin salida.

La eliminación de cualquier resultado de caracteres en el código 0000que tiene una longitud de 4 correspondiente al programa brainf *** .imprime un carácter (punto de código 0) y termina.

El equivalente unario sería 0000000000000(13 ceros) porque tiene que anteponer un líder 1a la longitud binaria del código para que se 101convierta 1101.

PHP, 6 bytes

He estado viendo este grupo durante un par de semanas y estoy sorprendido de tus técnicas de programación. Ahora tenía que iniciar sesión, hay algo que puedo hacer, lo siento :-) Sin embargo, esta podría ser mi última publicación aquí ...

<?php 

(tenga en cuenta el espacio después de segundo p)

Esto genera una cadena vacía. La eliminación de cualquier carácter genera el texto sin el carácter. Tenga en cuenta que puede producir errores HTML (contenido no representado por los navegadores, por ejemplo <?ph).

También probé con la echoetiqueta. es decir. p.ej.:

<?= __LINE__;;

Este sale 1. Si =se omite, <? __LINE__;;es la salida. Sin embargo, eliminar cualquiera de los caracteres de la constante mágica dará como resultado E_NOTICE : Aviso: Uso de la constante indefinida LNE - asumió ' LNE ' en ...

Si los avisos no se consideran errores (punto 4 de las reglas), esto también se aplica :-)

Python, 10 8 bytes

256**.25

Funciona en Python y amigos. Gracias a Jakube por mostrar cómo hacerlo 2 bytes más pequeño.

Desde 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 tenía esto (10 bytes):

14641**.25

Desde 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

y en la misma nota:

121**.25*121**.25

funciona de manera idéntica debido al buen redondeo de Python, en 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: No puede eliminar la final. . Los intérpretes de Prolog siempre buscarán un período final para ejecutar su consulta, por lo que si nos atenemos estrictamente a las reglas de este concurso y nos permitimos eliminar el período que no se ejecutará, saltará una línea y esperará comandos adicionales hasta termina con un punto

La consulta original __A=__A.sale true..

La consulta _A=__A.sale _A = '$VAR'('__A'). Modificaciones similares (es decir, eliminar uno _o uno de los dos A) resultarán en salidas similares.

Finalmente, la consulta __A__A.sale en SWI-Prolog:

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

Sed, 1 byte

d

Como sedrequiere un flujo de entrada, propondré una convención según la cual el programa en sí debería ser suministrado como entrada.

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

Un programa alternativo es x, pero eso solo cambia de 1a 2bytes de salida cuando se elimina.

K, 3 bytes

2!2

Salidas 0en el REPL. La eliminación de las primeras 2 salidas 0 1, la eliminación de los resultados de exclamación 22y la eliminación de los últimos 2 resultados en una cadena que varía entre las implementaciones de K pero siempre tiene al menos 2 caracteres (en OK, es (2!); según @Dennis, salidas de Kona 2!).

MATLAB, 9 7 bytes

Es 2 bytes más largo que la otra respuesta de MATLAB / Octave, pero de todos modos me gusta, ya que es un poco más complejo.

El 'operador de Matlab es la transposición conjugada compleja. Usando esto en un número imaginario escalar, obtienes i' = -i. Como los números imaginarios se pueden escribir simplemente como 2ise puede hacer:

2i--2i'
ans =
     0    

Eliminar cualquiera de los caracteres dará como resultado uno de los siguientes:

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

Esta respuesta no es competitiva, pero como es el código que inspiró este desafío, quería compartirla de todos modos.

:n

Por defecto, todos los programas de GolfScript imprimen toda la pila, seguida de un salto de línea, ejecutándose putsen toda la pila. La función en putssí se implementa como {print n print}en el intérprete, donde printes una función incorporada real y nes una variable que contiene la cadena "\n"de forma predeterminada.

Ahora, un programa GolfScript siempre empuja la entrada de STDIN en la pila. En este caso, como no hay ninguna entrada, se empuja una cadena vacía. La asignación variable :nguarda esa cadena vacía n, suprime el salto de línea implícito y hace que la salida esté completamente vacía.

Al eliminar n, queda la asignación de variable incompleta :(se podría pensar que es un error de sintaxis, pero no), por lo que el salto de línea implícito se imprime como de costumbre.

Al eliminar :, queda n, lo que empuja un salto de línea en la pila, por lo que el programa imprime dos saltos de línea.

APL, J y posiblemente otras variantes, 3 bytes

--1

Sale 1en APL. -1salidas ¯1y --salidas de lo siguiente en TryAPL :

┌┴┐
- -

J, 5 bytes

|5j12

Magnitud del número complejo 5 + 12ien 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

Basado en precisión de coma flotante, inversa y matriz 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

Pruébelo en línea aquí.

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 devuelve una cadena vacía (longitud 0)

⍴devuelve ⍴(longitud 1)

0devuelve 0(longitud 1)

Swift (y mucho más), 8 bytes

93^99<84

salida (4 caracteres):

true

Al eliminar el enésimo carácter, la salida es:

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

Hay 78 posibles soluciones como esta en el formato de a^b<c.

Creo que el objetivo de este desafío debería ser tantos bytes como sea posible, porque cuantos más bytes, más bytes posibles eliminar y, por lo tanto, más difícil.

MathGolf , 2 bytes

♂(

Pruébalo en línea!

Explicación

♂   Push 10
 (  Decrement TOS by 1

¿Por qué funciona esto?

La salida regular es 9. Si (se elimina, la salida es 10. Si ♂se elimina, el programa saca implícitamente un 0 de la pila para alimentar al (operador, que genera -1.

Clojure, 11 bytes

(defn x[]1)

Al principio pensé simplemente publicar una respuesta de un solo carácter en el REPL como los otros idiomas, por ejemplo

user=> 1
1

Pero el problema es que si elimina ese carácter, el REPL no hace nada al presionar la tecla enter. Por lo tanto, tenía que envolverse con una función permitida por las reglas de la pregunta. Cuando llama a esta función, devuelve 1. Si elimina el único carácter de la función,

(defn x[])

devuelve la función nilque imprime dos bytes adicionales.

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

05AB1E (legado), 1 byte

Cualquier byte en 05AB1E (legado) funcionaría, excepto [(bucle infinito).

Vea aquí todas las salidas posibles para todos los programas 05AB1E de byte único posibles.

Al eliminar ese byte único para que quede un programa vacío, el contenido de info.txt se enviará a STDOUT de forma predeterminada.

Pruébalo en línea.

05AB1E , 1 byte

?

Pruébalo en línea.

Desafortunadamente, un programa vacío en la nueva versión de 05AB1E solo genera una nueva línea de 1 byte de forma predeterminada ( Pruébelo en línea ), por lo que casi ninguno de los caracteres de 1 byte es posible ya que no tendrán que mostrar nada. ?Hasta donde yo sé, el único programa posible que no genera nada (por lo que tampoco es la nueva línea implícita) .

Japt , 2 bytes

AÉ

Pruébalo en línea!

Ase pre-inicializado a 10, Éresta 1, y el resultado es 1 byte: 9.

La eliminación de É da como resultado el programa A, que genera el valor de A 10, por lo que el resultado es de 2 bytes.

Del mismo modo, eliminar A da como resultado exactamente lo Éque se interpreta como -1 y se genera como -1, por lo que el resultado es de 2 bytes.

Encantamientos rúnicos , 6 bytes (modificables)

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

Pruébalo en línea!

Runic no tiene un entorno REPL y escribir un programa completo para satisfacer las restricciones no es fácilmente factible (lo que lleva a programas no válidos o sin salida). Entonces, la parte del código 11-{{Bestá actuando como una función interna y solo esta parte puede modificarse. La Binstrucción está lo suficientemente cerca de un puntero de función y una declaración de retorno de que esta clasificación debe ser aceptable (ya que salta la IP a una posición en el código y empuja una ubicación de retorno a la pila a la que puede acceder un usuario posterior Bo descartado) .

• Salida estándar: 0
• Eliminar cualquiera de los 1s:05
• Quitando el -:11
• Eliminar cualquiera {:Error051
• Quitando el B:120

El final \al final de la primera línea proporciona un límite externo alrededor de la función interna en el caso de que se elimine la instrucción de retorno para que la IP no se desplace por todas partes por todas partes (e imprima sin salida).

Tenga en cuenta que Error051es solo una cadena arbitraria, podría poner lo que quisiera en esa parte del código y "Error" fue un resultado divertido por tener un código que agiliza las coordenadas de retorno y los teletransportes IP a una ubicación arbitraria.