N'importe qui peut agrandir la sortie d'un programme en ajoutant des caractères, faisons exactement l'inverse.

Ecrivez un programme complet, une fonction interne ou un extrait pour un environnement REPL dans la langue de votre choix qui répond aux critères suivants:

1. Votre code doit comporter au moins 1 caractère.

2. L'exécution du code d'origine produit x caractères de sortie vers STDOUT (ou l'alternative la plus proche), où 0 ≤ x <+ ∞ .

3. La suppression de tout caractère unique arbitraire du code d'origine génère à nouveau un code valide, qui produit au moins x + 1 caractères de la sortie vers STDOUT.

4. Ni le code original ni les modifications ne peuvent produire d’erreur, que ce soit vers STDOUT, STDERR, syslog ou ailleurs. Les seules exceptions à cette règle sont les avertissements du compilateur.

   Votre programme peut ne nécessiter aucun indicateur ou paramètre pour supprimer la sortie d'erreur.

   Votre programme ne peut contenir aucune erreur fatale, même s'il ne produit aucune sortie.

5. Le code original et les modifications doivent être déterministes et finir par aboutir (pas de boucles infinies).

6. Ni le code original ni les modifications ne peuvent nécessiter une quelconque entrée.

7. Les fonctions ou les extraits ne peuvent conserver aucun état entre les exécutions.

Considérant que cette tâche est triviale est certaines langues et carrément impossible dans d'autres, c'est un concours de popularité .

Lors du vote, tenez compte de la "brièveté relative" du code, c’est-à-dire qu’une réponse plus courte devrait être considérée comme plus créative qu’une réponse plus longue dans la même langue .

Toute REPL avec opération caret XOR, 5 octets

11^11

11^11est bien sûr 0. Les seules autres possibilités sont 1^11ou 11^1qui sont 10, ou 1111qui se produit.

TI-BASIC, 3 1

"

Lorsque la dernière ligne d'un programme est une expression, la calculatrice affiche cette expression. Sinon, la calculatrice s'affiche Doneà la fin du programme. L'expression ici est la chaîne vide, mais cela pourrait également fonctionner avec n'importe quel nombre à un chiffre.

2 octets:

isClockOn

Idem que ci-dessus mais avec un jeton de 2 octets.

3 octets:

ππ⁻¹

Impressions 1dues à la multiplication implicite. Peut être prolongé indéfiniment en ajoutant des paires de ⁻¹. Les ci-dessous fonctionnent également.

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

Des solutions plus longues:

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

Il existe probablement aussi des solutions multi-lignes mais je n'en trouve pas.

CJam, JavaScript, Python, etc., 18 octets

8.8888888888888888

Les sorties dans CJam sont:

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

JavaScript et Python fonctionnent de manière similaire. JavaScript et Python ne sont pas compétitifs, mais il n'est pas facile d'en trouver un plus court dans CJam .

Octave, 5 octets

10:10

(x: y) donne le tableau de nombres entre x et y par incréments de 1, donc entre 10 et 10, le seul élément est 10:

> 10:10
ans = 10

Lorsque le deuxième argument est inférieur au premier, octave affiche la matrice vide et ses dimensions:

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

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

Lorsqu'un caractère est supprimé du premier nombre, il y a plus d'éléments dans le tableau:

> 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

Lorsque les deux points sont supprimés, le nombre se retourne:

> 1010
ans = 1010

Microscript, 1 octet

h

Cela ne produit aucune sortie, car cela hsupprime l'impression implicite de la langue. Supprimer le caractère unique produit un programme dont le résultat est 0\n.

Je vais essayer de trouver une meilleure réponse plus tard.

ÉDITER LE 17 NOVEMBRE:

Cela fonctionne également dans Microscript II, sauf que, au lieu de produire 0\n, le programme vide produit null.

Pyth, 3 octets

cGG

Gest pré-initialisé avec les lettres minuscules de l’alphabet. cest la fonction split.

cGGdivise l'alphabet en occurrences de l'alphabet, qui se termine par ['', ''](8 octets).

Lorsque le deuxième paramètre est manquant, cdivise la chaîne en espaces, tabulations ou nouvelles lignes. Comme aucun d’entre eux n’apparaît dans G, le résultat cGest is ['abcdefghijklmnopqrstuvwxyz'](30 octets).

Et GGimprime simplement deux fois l'alphabet sur deux lignes distinctes: abcdefghijklmnopqrstuvwxyz\nabcdefghijklmnopqrstuvwxyz(53 octets).

Essayez-le en ligne: démonstration

Python REPL, 6 octets

Pas le plus court, mais voici une autre réponse abusive en virgule flottante:

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

Mais...

>>> 11e308
inf

JavaScript (et beaucoup plus), 5byte

44/44 ou

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

CJam, 5

''''=

Essayez-le en ligne

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

Durée , 5 octets

00000

La longueur du programme est 5, ce qui correspond au programme brainf *** qui ,lit un caractère de fin de saisie et se termine sans sortie.

0000Si vous .supprimez un caractère, le code ayant une longueur de 4 correspondant au programme brainf *** imprimant un caractère (point de code 0) et se terminant.

Le unaire équivalent serait 0000000000000(13 zéros) parce que vous devez préfixer un chef de file 1à la longueur binaire du code pour 101devient 1101.

PHP, 6 octets

Je regarde ce groupe depuis quelques semaines et je suis émerveillé par vos techniques de programmation. Maintenant, je devais me connecter, il y a quelque chose que je peux faire, désolé :-) Cependant, ceci pourrait être mon dernier message ici ...

<?php 

(notez l'espace après seconde p)

Ceci produit une chaîne vide. Supprimer n'importe quel caractère génère le texte sans le caractère. Notez qu'il peut produire des erreurs HTML (contenu non rendu par les navigateurs, par exemple <?ph).

J'ai aussi essayé avec la echobalise. c'est à dire. par exemple.:

<?= __LINE__;;

Celui-ci sort 1. Si =est omis, <? __LINE__;;est la sortie. Cependant, la suppression de tout caractère de la constante magique aura pour résultat E_NOTICE : Remarque: Utilisation de la constante non définie LNE - supposée ' LNE ' dans ...

Si les avis ne sont pas considérés comme des erreurs (point 4 du règlement), cela s'applique également :-)

Python, 10 à 8 octets

256**.25

Fonctionne en Python et ses amis. Merci à Jakube d’avoir montré comment réduire la taille de 2 octets.

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

à l'origine j'avais ceci (10 octets):

14641**.25

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

et sur la même note:

121**.25*121**.25

fonctionne de manière identique en raison de l'arrondi par Python, dans 17 octets.

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

Interprète SWI-Prolog

__A=__A.

Remarque: vous ne pouvez pas supprimer la finale. . Les interprètes de Prolog rechercheront toujours une dernière période pour exécuter votre requête. Par conséquent, si nous nous en tenons strictement aux règles de ce concours et nous permettons de supprimer la période pendant laquelle elle ne fonctionnera pas, il sautera d’une ligne et attendra d’autres commandes jusqu’à ce qu’une se termine par un point.

Les __A=__A.résultats de la requête d'origine true..

Les _A=__A.résultats de la requête _A = '$VAR'('__A'). Des modifications similaires (en supprimant un _ou l’un des deux A) donneront des résultats similaires.

Enfin, la requête __A__A.génère dans SWI-Prolog:

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

Sed, 1 octet

d

Comme cela sednécessite un flux d’entrée, je propose une convention selon laquelle le programme lui-même devrait être fourni en entrée.

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

Un programme alternatif est x, mais qui ne change de 1d' 2octets de sortie lorsqu'ils sont supprimés.

K, 3 octets

2!2

Sorties 0dans le REPL. Suppression des 2 premières sorties 0 1, suppression des exclamations 22et suppression des 2 derniers résultats en une chaîne qui varie entre les implémentations K, mais (2!)qui comporte toujours au moins 2 caractères (en oK, c’est ; selon les sorties @Dennis, Kona 2!).

MATLAB, 9 à 7 octets

C'est 2 octets de plus que l'autre réponse MATLAB / Octave, mais j'aime bien quand même, car c'est un peu plus complexe.

L' 'opérateur de Matlab est la transposée conjuguée complexe. En utilisant ceci sur un nombre imaginaire scalaire, vous obtenez i' = -i. Comme des nombres imaginaires peuvent être écrits simplement comme 2ion peut le faire:

2i--2i'
ans =
     0    

Si vous supprimez l'un des caractères, l'un des éléments suivants apparaît:

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 octets

Cette réponse n’est pas concurrente, mais comme c’est le code qui a inspiré ce défi, j’ai quand même voulu le partager.

:n

Par défaut, tous les programmes GolfScript impriment l'intégralité de la pile, suivie d'un saut de ligne, en s'exécutant putssur l'intégralité de la pile. La fonction putselle-même est implémentée comme {print n print}dans l'interpréteur, où printest une valeur réellement intégrée et nune variable qui contient la chaîne "\n"par défaut.

Maintenant, un programme GolfScript pousse toujours l'entrée de STDIN sur la pile. Dans ce cas, puisqu'il n'y a aucune entrée, une chaîne vide est poussée. L'affectation de variable :nenregistre cette chaîne vide n, en supprimant le saut de ligne implicite et en rendant la sortie complètement vide.

En éliminant n, l'assignation de variable incomplète :(on pourrait penser que c'est une erreur de syntaxe, mais non), donc le saut de ligne implicite est imprimé comme d'habitude.

En éliminant :, vous vous retrouvez avec nce qui pousse un saut de ligne sur la pile, de sorte que le programme imprime deux sauts de ligne.

APL, J et éventuellement d’autres variantes, 3 octets

--1

Il sort 1en APL. -1sorties ¯1et --sorties suivantes dans TryAPL :

┌┴┐
- -

J, 5 octets

|5j12

Magnitude du nombre complexe 5 + 12idans 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 octets

%0.333333

Basé sur la précision en virgule flottante, l'inverse et l'inverse de la matrice.

   %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

Essayez-le en ligne ici.

Mathematica, 3 octets

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 octets

⍴0 retourne une chaîne vide (longueur 0)

⍴retourne ⍴(longueur 1)

0retourne 0(longueur 1)

Rapide (et beaucoup plus), 8 octets

93^99<84

sortie (4 caractères):

true

Lorsque vous supprimez le nième caractère, le résultat est le suivant:

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

Il y a 78 solutions possibles comme celle-ci dans le format de a^b<c.

Je pense que l'objectif de ce défi devrait être autant d'octets que possible, car plus il y a d'octets, plus il est possible de supprimer des octets et donc plus difficile.

MathGolf , 2 octets

♂(

Essayez-le en ligne!

Explication

♂   Push 10
 (  Decrement TOS by 1

Pourquoi ça marche?

La sortie régulière est 9. Si le (est supprimé, la sortie est 10. Si le ♂est supprimé, le programme extrait implicitement un 0 de la pile pour alimenter l' (opérateur qui le génère -1.

Clojure, 11 octets

(defn x[]1)

Au début, je pensais simplement poster une réponse à un seul caractère dans le REPL, comme dans les autres langues, par exemple:

user=> 1
1

Mais le problème est que si vous supprimez ce caractère, le REPL ne fait rien lorsque vous appuyez sur la touche Entrée. Donc, au lieu de cela, il devait être encapsulé avec une fonction comme le permettaient les règles de la question. Lorsque vous appelez cette fonction, elle retourne 1. Si vous supprimez le seul caractère de la fonction,

(defn x[])

la fonction retourne nilqui affiche deux octets supplémentaires.

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

05AB1E (héritage), 1 octet

N'importe quel octet dans 05AB1E (hérité) fonctionnerait, à l'exception de [(boucle infinie).

Voyez ici toutes les sorties possibles pour tous les programmes 05AB1E à un octet possibles.

Supprimer ce seul octet pour laisser un programme vide restituera le contenu de info.txt à STDOUT à la place par défaut.

Essayez-le en ligne.

05AB1E , 1 octet

?

Essayez-le en ligne.

Malheureusement, un programme vide dans la nouvelle version de 05AB1E ne génère par défaut qu'une nouvelle ligne de 1 octet ( Try it online ), de sorte que presque aucun des caractères de 1 octet n'est possible car ils ne doivent rien afficher. Le seul programme possible qui ne génère rien (donc aussi pas la nouvelle ligne implicite) est ?à ma connaissance.

Japt , 2 octets

AÉ

Essayez-le en ligne!

Aest pré-initialisé à 10, Ésoustrait de 1, le résultat est 1 octet: 9.

Si vous supprimez É, le programme Aaffiche la valeur de A 10, de sorte que le résultat est 2 octets.

De même, supprimer A donne exactement Éce qui est interprété en tant que -1 et sorti en tant que -1, donc le résultat est 2 octets.

Enchantements runiques , 6 octets (modifiables)

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

Essayez-le en ligne!

Runic n'a pas d'environnement REPL et l'écriture d'un programme complet pour satisfaire les contraintes n'est pas facilement réalisable (conduisant à des programmes non valides ou à une absence de sortie). Ainsi, la partie du code 11-{{Bagit comme une fonction interne et seule cette partie peut être modifiée. L' Binstruction est suffisamment proche d'un pointeur de fonction et d'une déclaration de retour indiquant que cette classification devrait être acceptable (car elle place l'adresse IP dans une position du code et pousse un emplacement de retour dans la pile auquel peut accéder ultérieurement Bou être ignoré). .

• Sortie standard: 0
• Supprimer l'un des 1s:05
• Retrait du -:11
• Retrait soit {:Error051
• Retrait du B:120

La dernière ligne \à la fin de la première ligne fournit une limite externe autour de la fonction interne dans le cas où l’instruction de retour est supprimée, de sorte que l’adresse IP ne dérape pas partout bon gré mal gré (et n’imprime aucune sortie).

Notez que Error051c'est juste une chaîne arbitraire, je pourrais mettre tout ce que je voulais dans cette partie du code et "Error" était un résultat amusant parce que le code qui remontait les coordonnées de retour et les téléports IP vers un emplacement arbitraire.