Любой может увеличить вывод программы, добавив символы, поэтому давайте сделаем прямо противоположное.

Напишите полную программу, внутреннюю функцию или фрагмент для среды REPL на языке по вашему выбору, который удовлетворяет следующим критериям:

1. Ваш код должен быть не менее 1 символа.

2. Запуск исходного кода приводит к выводу x символов в STDOUT (или ближайшую альтернативу), где 0 ≤ x <+ ∞ .

3. Удаление любого произвольного одиночного символа из исходного кода снова приводит к правильному коду, который выдает как минимум x + 1 символов вывода в STDOUT.

4. Ни исходный код, ни изменения не могут привести к выводу ошибок, будь то STDOUT, STDERR, syslog или где-либо еще. Единственными исключениями из этого правила являются предупреждения компилятора.

   Ваша программа может не требовать каких-либо флагов или настроек для подавления вывода ошибок.

   Ваша программа может не содержать фатальных ошибок, даже если они не выдают никаких результатов.

5. И исходный код, и модификации должны быть детерминированными и в конечном итоге заканчиваться (без бесконечных циклов).

6. Ни исходный код, ни модификации не могут требовать ввода любого вида.

7. Функции или фрагменты могут не поддерживать состояния между выполнениями.

Учитывая, что эта задача тривиальна в одних языках и совершенно невозможна в других, это конкурс на популярность .

При голосовании учитывайте «относительную краткость» кода, т. Е. Более короткий ответ следует считать более креативным, чем более длинный ответ на том же языке .

Любой REPL с каретной операцией XOR, 5 байтов

11^11

11^11это, конечно, 0. Единственные другие возможности, 1^11или 11^1которые 10, или 1111который производит сам.

TI-BASIC, 3 1

"

Когда последняя строка программы является выражением, калькулятор отобразит это выражение. В противном случае калькулятор отображается Doneпосле завершения программы. Выражение здесь является пустой строкой, но оно также может работать с любым однозначным числом.

2 байта:

isClockOn

То же, что и выше, но с 2-байтовым токеном.

3 байта:

ππ⁻¹

Печать 1из-за подразумеваемого умножения. Может быть расширен до бесконечности путем добавления пар ⁻¹. Ниже также работают.

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

Более длинные решения:

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

Возможно, есть и многострочные решения, но я не могу их найти.

CJam, JavaScript, Python и т. Д., 18 байт

8.8888888888888888

Выходы в CJam:

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

JavaScript и Python работают одинаково. Он не конкурентен в JavaScript и Python, но в CJam не так просто найти более короткий .

Октава, 5 байт

10:10

(x: y) дает массив чисел между x и y с шагом 1, поэтому между 10 и 10 единственным элементом является 10:

> 10:10
ans = 10

Когда второй аргумент меньше первого, октава печатает пустую матрицу и ее размеры:

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

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

Когда символ удаляется из первого числа, в массиве появляется больше элементов:

> 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

Когда двоеточие удалено, номер возвращается сам:

> 1010
ans = 1010

Microscript, 1 байт

h

Это не производит никакого вывода, поскольку hподавляет неявную печать языка. Удаление единственного символа производит программу, чей вывод - 0\n.

Я постараюсь придумать лучший ответ позже.

РЕДАКТИРОВАТЬ 17 НОЯБРЯ:

Это также работает в Microscript II, за исключением того, что вместо выдачи 0\nпустая программа дает null.

Pyth, 3 байта

cGG

Gинициализируется строчными буквами в алфавите. cэто функция разделения

cGGразделяет алфавит по вхождению алфавита, который заканчивается ['', ''](8 байтов).

Если второй параметр отсутствует, cразбивает строку на пробелы, символы табуляции или перевода строки. Так как ни один из них не появляется в G, вывод для cG- ['abcdefghijklmnopqrstuvwxyz'](30 байтов).

И GGпросто печатает дважды алфавит на две отдельные строки: abcdefghijklmnopqrstuvwxyz\nabcdefghijklmnopqrstuvwxyz(53 байта).

Попробуйте онлайн: демонстрация

Python REPL, 6 байтов

Не самый короткий, но вот еще один ответ о злоупотреблении с плавающей запятой:

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

Но...

>>> 11e308
inf

JavaScript (и многое другое), 5 байтов

44/44 или же

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

CJam, 5

''''=

Попробуйте онлайн

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

Lenguage , 5 байт

00000

Длина программы равна 5, что соответствует программе brainf ***, которая ,читает конец введенного символа и завершается без вывода.

Удаление любого символа приводит к коду 0000длиной 4, соответствующему программе brainf ***, которая .печатает один символ ( кодовую точку 0) и завершается.

Унарное эквивалент будет 0000000000000(13 нулей) , потому что вы должны предварять ведущие 1к двоичному длины кода так 101становится 1101.

PHP, 6 байт

Я наблюдал за этой группой в течение нескольких недель и поражен вашими методами программирования. Теперь я должен был войти, есть кое-что, что я могу сделать, извините :-) Однако, это может быть мой последний пост здесь ...

<?php 

(обратите внимание на пробел после второго p)

Это выводит пустую строку. Удаление любого символа выводит текст без символа. Обратите внимание, что это может привести к ошибкам HTML (например, содержимое не отображается браузерами <?ph).

Я тоже попробовал с echoтегом. то есть. например.:

<?= __LINE__;;

Этот вывод 1. Если =опущено, <? __LINE__;;вывод. Однако удаление любого символа магической константы приведет к E_NOTICE : Примечание: использование неопределенной константы LNE - предполагается, что LNE в ...

Если уведомления не считаются ошибками (пункт 4 правил), это также относится :-)

Python, 10 8 байт

256**.25

Работает на Python и у друзей. Спасибо Jakube за то, что показал, как сделать его на 2 байта меньше.

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

Первоначально у меня было это (10 байт):

14641**.25

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

и на той же ноте:

121**.25*121**.25

работает идентично благодаря хорошему округлению Python, в 17 байтах.

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

SWI-Пролог переводчик

__A=__A.

Примечание: вы не можете удалить финал. . Интерпретаторы Prolog всегда будут искать последний период для выполнения вашего запроса, поэтому, если мы будем строго придерживаться правил этого конкурса и позволим себе удалить период, в котором он не будет выполняться, он перешагнет строку и будет ждать дополнительных команд до заканчивается периодом.

Исходный запрос __A=__A.выводится true..

Запрос _A=__A.выходы _A = '$VAR'('__A'). Подобные модификации (то есть удаление одного _или одного из двух A) приведут к аналогичным результатам.

Наконец, __A__A.вывод результатов запроса в SWI-Prolog:

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

Sed, 1 байт

d

Поскольку sedтребуется поток ввода, я предложу соглашение, что сама программа должна быть предоставлена ​​в качестве ввода.

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

Альтернативная программа x, но изменяется только 1в 2байты вывода при удалении.

К, 3 байта

2!2

Выходы 0в REPL. Удаление первых 2-х выходов 0 1, удаление восклицательных результатов 22и удаление 2-х последних приводит к строке, которая варьируется между реализациями K, но всегда не менее 2 символов (в oK это (2!); в соответствии с @Dennis, выходами Kona 2!).

MATLAB, 9 7 байт

Это на 2 байта длиннее, чем другой ответ MATLAB / Octave, но, тем не менее, он мне нравится, так как он немного сложнее.

'Оператор Матлаба является комплексно-сопряженным транспонированием. Используя это на скалярном мнимом числе, вы получите i' = -i. В качестве мнимых чисел можно написать просто, как 2iэто можно сделать:

2i--2i'
ans =
     0    

Удаление любого из символов приведет к одному из следующих:

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 байта

Этот ответ неконкурентный, но так как этот код вдохновил меня на решение этой проблемы, я все равно хотел поделиться им.

:n

По умолчанию все программы GolfScript печатают весь стек, а затем перевод строки, выполняя putsвесь стек. Сама функция putsреализована так же, как {print n print}в интерпретаторе, где printона является встроенной и nявляется переменной, которая содержит строку "\n"по умолчанию.

Теперь программа GolfScript всегда помещает ввод из STDIN в стек. В этом случае, поскольку нет никакого ввода, пустая строка помещается. Присвоение переменной :nсохраняет эту пустую строку n, подавляя неявный перевод строки и делая вывод полностью пустым.

Удаляя n, вы :получаете неполное присвоение переменной (вы можете подумать, что это синтаксическая ошибка, но нет), поэтому неявный перевод строки печатается как обычно.

Удаляя :, вы остаетесь с n, что помещает перевод строки в стек, поэтому программа печатает два перевода строки.

APL, J и, возможно, другие варианты, 3 байта

--1

Выводит 1в APL. -1выводит ¯1и --выводит следующее в TryAPL :

┌┴┐
- -

J, 5 байт

|5j12

Величина комплексного числа 5 + 12iв 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 байт

%0.333333

На основе точности с плавающей запятой, обратной и матричной инверсии.

   %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

Попробуйте это онлайн здесь.

Mathematica, 3 байта

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

Дьялог АПЛ , 2 байта

⍴0 возвращает пустую строку (длина 0)

⍴возвращается ⍴(длина 1)

0возвращается 0(длина 1)

Swift (и многое другое), 8 байт

93^99<84

выходной (4 символа):

true

При удалении n-го символа получается:

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

Есть 78 возможных решений в формате a^b<c.

Я думаю, что целью этой задачи должно быть как можно больше байтов, потому что чем больше байтов, тем больше байтов удаляется и, следовательно, сложнее.

MathGolf , 2 байта

♂(

Попробуйте онлайн!

объяснение

♂   Push 10
 (  Decrement TOS by 1

Почему это работает?

Обычный вывод есть 9. Если (удаляется, вывод равен 10. Если ♂удаляется, программа неявно извлекает 0 из стека для подачи (оператора, который выводит -1.

Clojure, 11 байт

(defn x[]1)

Сначала я подумал просто опубликовать односимвольный ответ в REPL, как и на других языках, например

user=> 1
1

Но проблема в том, что если вы удалите этот символ, REPL ничего не сделает при нажатии клавиши ввода. Поэтому вместо этого он должен был быть обернут функцией, разрешенной правилами вопроса. Когда вы вызываете эту функцию, она возвращает 1. Если вы удалите единственный символ в функции,

(defn x[])

функция возвращает, nilкоторая печатает дополнительные два байта.

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

05AB1E (legacy), 1 байт

Любой отдельный байт в 05AB1E (устаревший) будет работать, кроме [(бесконечный цикл).

Смотрите здесь все возможные выходы для всех возможных однобайтовых программ 05AB1E.

Удаление этого единственного байта, так что остается пустая программа, выводит содержимое info.txt в STDOUT по умолчанию.

Попробуйте онлайн.

05AB1E , 1 байт

?

Попробуйте онлайн.

К сожалению, пустая программа в новой версии 05AB1E по умолчанию выводит только 1-байтовый символ новой строки ( попробуйте онлайн ), поэтому почти ни один из 1-байтовых символов невозможен, так как они ничего не должны выводить. ?Насколько я знаю, единственная возможная программа, которая ничего не выводит (так что не является неявным переводом строки) .

Japt , 2 байта

AÉ

Попробуйте онлайн!

Aпредварительно инициализированы до 10, Éвычитает 1, и результат 1 байт: 9.

Удаление É приводит к программе A, которая выводит значение A, 10поэтому результат составляет 2 байта.

Точно так же удаление A приводит только к тому, Éчто интерпретируется как -1, а выводится как -1, то есть результат составляет 2 байта.

Рунические чары , 6 (изменяемые) байты

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

Попробуйте онлайн!

Runic не имеет среды REPL, и написание полной программы, удовлетворяющей ограничениям, неосуществимо (что приводит либо к недопустимым программам, либо к выходу). Таким образом, часть кода 11-{{Bдействует как внутренняя функция, и только эта часть может быть изменена. Эта Bинструкция достаточно близка к указателю на функцию и оператору возврата, что эта классификация должна быть приемлемой (так как она перемещает IP на позицию в коде, а также помещает место возврата в стек, доступ к которому может получить последующий Bили отброшенный) ,

• Стандартный вывод: 0
• Удаление любого из 1s:05
• Удаление -:11
• Удаление либо {:Error051
• Удаление B:120

Финал \в конце первой строки обеспечивает внешнюю границу вокруг внутренней функции в случае, если инструкция возврата удалена, так что IP не будет извилистым повсюду повсюду, но не выводить ничего.

Обратите внимание, что Error051это просто произвольная строка, я мог поместить все, что хотел, в эту часть кода, и «Ошибка» была забавным результатом для кода, который получает координаты возврата и телепортирует IP в произвольное место.