Définissons un programme vierge comme un programme qui ne contient aucune erreur, mais qui commettra une erreur si vous le modifiez en supprimant toute sous-chaîne contiguë de N caractères, où 1 <= N < program length.

Par exemple, le programme Python 2 à trois caractères

`8`

est un programme vierge ^{( merci, Sp )} car tous les programmes résultant de la suppression de sous-chaînes de longueur 1 provoquent des erreurs (des erreurs de syntaxe, mais tout type d'erreur conviendra):

8`
``
`8

ainsi que tous les programmes résultant de la suppression de sous-chaînes de longueur 2 provoquent des erreurs:

`
`

Si, par exemple, `8il s’agissait d’un programme `8`ne faisant pas d’ erreur, il ne serait pas parfait car tous les résultats de la suppression de la sous-chaîne doivent être erronés.

Votre tâche dans ce défi consiste à écrire le programme vierge le plus court possible, qui ne prend aucune entrée, mais génère l'un des cinq mots suivants:

world
earth
globe
planet
sphere

Le mot que vous choisissez est entièrement à vous. Le mot unique plus un caractère de fin de ligne optionnel doivent être imprimés sur la sortie standard (ou l'alternative la plus proche de votre langue). Le programme le plus court en octets gagne.

Remarques:

• Un programme autonome est requis, pas une fonction.
• Les mots sont sensibles à la casse; la sortie Worldou EARTHn'est pas autorisée.
• Les avertissements du compilateur ne comptent pas comme des erreurs.
• Les sous-programmes en erreur peuvent prendre en entrée ou en sortie ou faire autre chose tant qu'ils finissent toujours par se tromper.

Voici un extrait de pile qui listera les programmes nécessitant une erreur pour un programme potentiellement vierge:

<script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>function go() { var s = $('#i').val(), e = []; for (var i = 1; i < s.length; i++) { for (var j = 0; j <= s.length - i; j++) { e.push(s.substring(0, j) + s.substring(j + i)); } } $('#o').val(e.join('\n---\n')); }</script>Program:<br><textarea id='i' rows='16' cols='80'>`8`</textarea><br><button onclick='go()' type='button'>Go</button><br><br>Programs that should error: (--- separated)<br><textarea id='o' rows='16' cols='80'></textarea><br>

Rail , 24 octets

$'main'    #
 -[world]o/

Je pense que cela fonctionne. Et c'est à la fois court et lisible (pour le rail).

• Si la sous-chaîne supprimée comprend une partie de $'main'nous obtenons Internal Error: Crash: No 'main' function found.
• Si la sous-chaîne supprimée inclut le #, il n'y a aucun moyen pour que le programme se ferme proprement, il se terminera donc toujours par Crash: No valid move. Je crois qu'il n'est pas possible de supprimer une sous-chaîne telle que la piste forme une boucle valide (infinie).
• Si la sous-chaîne retirée se trouve devant le #, elle sera déconnectée de la fin de la voie, de sorte que le train tombera en panne (avec la même erreur que ci-dessus).
• Si la sous-chaîne supprimée se trouve après le #, elle sera également déconnectée #de la fin de la piste (et potentiellement même du début de la piste du point d’entrée $). Encore une fois la même erreur.

En ce qui concerne le programme actuel: chaque programme ferroviaire doit avoir une $'main'variante (ou une variante plus longue, mais nous jouons au golf ici) comme point d’entrée dans la fonction et le train démarre en $direction du sud-est. Cependant, tout ce qui se trouve sur cette première ligne peut faire partie de la piste. Par conséquent, supprimer 'main'la piste est:

$          #
 -[world]o/

Les -et /sont simplement des morceaux de rail sur lesquels nous devons laisser le train faire ces 45 ° de virage.

[world]pousse la chaîne worldet l’ oimprime. #marque la fin de la voie - le seul moyen de mettre fin à un programme ferroviaire en toute sécurité.

Fait intéressant, cette solution est uniquement possible car rail permet aux pistes de passer par la mainligne - si cela n'a pas été possible #serait après le premier saut de ligne et le code pourrait toujours être raccourcies à

$'main'
 #

qui est un programme valide qui ne fait rien. (Les caractères non-espace entre 'et #n'affecteraient pas cela.)

Également assez intéressant: si je venais de jouer au golf, l'impression worldn'aurait pas été beaucoup plus courte ou plus simple:

$'main'
 -[world]o#

Funciton ( 186 136 octets en UTF-16)

╔══════════════╗
║19342823075080╟
║88037380718711║
╚══════════════╝

Ce programme imprime «monde».

La plupart des sous-chaînes que vous enlevez empêcheront cela d'être une boîte complète, ce dont se plaindre l'analyseur. Les seuls déménagements possibles qui laissent une boîte complète sont:

 ╔══════════════╗
|║19342823075080╟  (remove this whole line)
|║88037380718711║
 ╚══════════════╝
 ╔══════════════╗
 ║|19342823075080╟   ← substring starts at | here
 ║|88037380718711║   ← substring ends at | here
 ╚══════════════╝
... ↕ or anything in between these that removes a whole line’s worth ↕ ...
 ╔══════════════╗
 ║19342823075080|╟   ← substring starts at | here
 ║88037380718711|║   ← substring ends at | here
 ╚══════════════╝
 ╔══════════════╗
|║19342823075080╟
 ║88037380718711║  (both lines entirely)
|╚══════════════╝
 ╔══════════════╗
 ║19342823075080╟
|║88037380718711║  (remove this whole line)
|╚══════════════╝

La plupart de ceux-ci suppriment l'extrémité pendante en haut à droite du boîtier, qui est le connecteur de sortie. Sans cette extrémité libre, la boîte n'est qu'un commentaire:

╔══════════════╗
║88037380718711║
╚══════════════╝

Ce programme n’est plus valide car l’analyseur attend un programme avec exactement une sortie:

Erreur: les fichiers source ne contiennent pas de programme (le programme doit avoir une sortie).

La seule possibilité qui laisse un connecteur de sortie est le dernier de ce qui précède, ce qui laisse ceci:

╔══════════════╗
║19342823075080╟
╚══════════════╝

Cependant, ce nombre ne code pas une chaîne Unicode valide dans le format UTF-21 ésotérique de Funciton. Essayez de lancer ceci, vous obtenez:

Exception non gérée: System.ArgumentOutOfRangeException: une valeur UTF32 valide est comprise entre 0x000000 et 0x10ffff, inclus, et ne doit pas inclure de valeurs de codepoint de substitution (0x00d800 ~ 0x00dfff).

Par conséquent, ce programme est vierge.

Visual C ++ - 96 95 octets

#include<iostream>
#define I(a,b)a<<b
int main()I({std::cout,I('w',I('o',I('r',I('l','d';)))))}

Propriétés:

1. Vous ne pouvez supprimer aucune partie de int main()sans une erreur de compilation.
2. Vous ne pouvez pas supprimer la modifier l'extension des macros ALL AT, la suppression aà tous les moyens main()ne fait jamais {, enlever btout signifie que notre ligne ne se termine pas dans un ;, la suppression des <moyens std::cout<'w'provoque une erreur, et la suppression des <<causes std::cout'w', 'w''o'etc.
3. Vous ne pouvez pas supprimer les paramètres de la définition de macro ou de l'appel, les seuls noms valides pour la définition seraient I(a): ils I(b)ne correspondent jamais et se Idéveloppent auparavant (; d'autre part en utilisant des I(,causes <<<<, et ,)supprime le point-virgule (sauf toute autre erreur).
4. Vous ne pouvez pas supprimer une partie de tout std::coutsans courir dans une tête <<, et par conséquent ne pouvez pas supprimer #include<iostream>au début sans une erreur de compilation.
5. Vous ne pouvez supprimer aucune partie d'un seul caractère, vous avez ''une erreur de caractère vide et 'w,, etc., essayez de tout transformer en un seul caractère.
6. Vous ne pouvez pas supprimer le côté gauche / droit d'une macro sans en laisser trop )ou (de l'autre côté, par exemple, vous ne pouvez pas faire des choses comme I('w',I('r'.

Compile en ligne à l'aide de Visual C ++ .

Encore une fois, ce n’est pas une preuve exhaustive. Si vous pensez que vous pouvez le faire aussi travailler sans section assurez-vous de me le faire savoir.

Les versions précédentes utilisaient une approche considérablement différente et il s'est avéré que ce n'était pas parfait alors j'ai supprimé ces scores.

Vérification:

Le programme suivant a confirmé que cette version est vierge en utilisant le clcompilateur de Visual C ++ 2010. J'aurais souhaité écrire ceci plus tôt:

#include <fstream>
#include <iostream>
char *S = "#include<iostream>\n#define I(a,b)a<<b\nint main()I({std::cout,I('w',I('o',I('r',I('l','d';)))))}";
//uncomment to print source code before compile
// #define prints
int main(){
   for(int i=0; i<95; i++)
      for(int j=i; j<95; j++){
         std::fstream fs;
         fs.open ("tmptst.cpp",std::fstream::out);
         for(int k=0; k<95; k++)
         if(k<i || k>j){
            fs << S[k];
            #ifdef prints
               std::cout<<S[k];
            #endif
         }
         fs.close();
         #ifdef prints
            std::cout<<'\n';
         #endif
         //Compile and surpress/pipe all output
         //if it doesn't compile we get a nonzero errorlevel (i.e.true) from system.
         if(!system("cl -nologo tmptst.cpp >x"))
            return 0;
      }
      std::cout<<"PRISTINE!";
}

Python 3, 79 33

if 5-open(1,'w').write('world'):a

open(1,'w')ouvre la sortie standard, puis nous imprimons la chaîne. writerenvoie le nombre de caractères écrits. Ceci est utilisé pour renforcer la suppression de la sous-chaîne: La suppression d'une partie de la chaîne provoque le renvoi de tout autre élément que 5, et 5 moins cette valeur est évaluée à true. Mais cela provoque l' ifexécution du corps et an'est pas défini.

Ceci est basé sur intelligente Quine vierge de Anders Kaseorg ici .

Comme une seule déclaration doit être vérifiée, elle est beaucoup plus courte que l'ancienne solution, mais également moins générale.

Ancienne solution:

try:
 q="print('world');r=None"
 if exec('e=q')==eval(q[17:]):exec(e)
finally:r

Pour vérifier qu'il s'agit bien d'un programme vierge:

w=r'''try:
 q="print('world');r=None"
 if exec('e=q')==eval(q[17:]):exec(e)
finally:r'''
exec(w)
for j in range(1,len(w)):
 for i in range(len(w)+1-j):
  e=w[:i]+w[i+j:]
  try:exec(e,{});print('WORKED',e)
  except:pass

Quelques points clés:

• Chaque instruction exécutée peut être supprimée. Vérifier que qa été exécuté exige une déclaration en dehors de q. Le tryrésout bien, en exigeant au moins deux déclarations, dont aucune ne peut être supprimée complètement.
• La vérification de l' qexécution a lieu en évaluant rà la fin.
• La vérification de ce qui qn'a pas été modifié est réalisée par eval(q[17:]), ce qui doit être évalué Nonepour qêtre exécuté.
• La ifcondition est un peu difficile à obtenir. Pour s'assurer qu'il a été évalué, il a pour effet secondaire de créer e, ce qui est nécessaire pour définir r. (C’est la raison pour laquelle j’ai utilisé Python 3, exprcar une fonction fait des merveilles pour les effets secondaires au niveau de l’expression.)

Haskell, 61 ans

x=uncurry(:)
main=putStr$x('w',x('o',x('r',x('l',x('d',[])))))

Tout type d'erreur est OK? Dans ce cas:

Haskell, 39 ans

main=putStr$take 5$(++)"world"undefined

JavaScript, 74 73 35 octets

if((alert(a="world")?x:a)[4]!="d")x

Il s'avère que la réponse était beaucoup plus simple que je ne le pensais ...

Explication

if(
  (
    alert(a="world") // throws a is not defined if '="world"' is removed
        ?x           // throws x is not defined if 'alert' or '(a="world")' is removed
        :a           // throws a is not defined if 'a="world"' or 'a=' is removed
  )
  [4]!="d"           // if "world" is altered fifth character will not be "d"
                     // if 'd' is removed it will compare "world"[4] ("d") with ""
                     // if '[4]' is removed it will compare "world" with "d"
                     // if '(alert(a="world")?x:a)' is removed it will compare [4] with "d"
                     // if '?x:a' is removed [4] on alert result (undefined[4]) will error
                     // if '[4]!="d"' is removed the if will evaluate "world" (true)
                     // if '!', '!="d"' or '(alert...[4]!=' is removed the if will
                     //     evaluate "d" (true)
)x                   // throws x is not defined if reached

// any other combination of removing substrings results in a syntax error

Java 8, 301 octets

Parce que chaque question nécessite une réponse Java.

class C{static{System.out.print(((((w='w')))));System.out.print((((o='o'))));System.out.print(((r='r')));System.out.print((l='l'));System.out.print(d='d');e=(char)((f=1)/((g=8)-C.class.getDeclaredFields()[h=0].getModifiers()));}public static void main(String[]a){}static final char w,o,r,l,d,e,f,g,h;}

Étendu

class C {
    static {
        System.out.print(((((w = 'w')))));
        System.out.print((((o = 'o'))));
        System.out.print(((r = 'r')));
        System.out.print((l = 'l'));
        System.out.print(d = 'd');
        e = (char) ((f = 1) / ((g = 8) - C.class.getDeclaredFields()[h = 0].getModifiers()));
    }

    public static void main(String[] a) { }

    static final char w, o, r, l, d, e, f, g, h;
}

Explication

• public static main(String[]a){} est requis.
• Si les déclarations de champ sont supprimées (ou rendues non statiques), le premier bloc statique ne peut pas les trouver.
• Si le bloc statique est supprimé (ou rendu non statique), les champs ne sont pas initialisés.

La partie la plus difficile:

• Si le finalmot-clé est supprimé, la deuxième ligne est évaluée 1/(8-8), ce qui provoque une / by zeroexception.

Funciton , 143 142 136 octets

Le score est en UTF-8 comme d'habitude, car UTF-16 aurait une taille plus grande de deux octets (en raison de la nomenclature).

╔══════════╗
║1934282307║╔╗
║5080880373╟╚╝
║80718711  ║
╚══════════╝

Donc, je réfléchis à une réponse Funciton depuis un moment et je me suis dit que ce serait impossible, car vous pouvez toujours supprimer une ligne complète et le code resterait un bloc valide. Ensuite, j'ai discuté avec Timwi à ce sujet et il a compris que l'on pouvait simplement mettre le nombre entier sur une seule ligne, de telle sorte que le supprimer casserait le programme faute de connecteur de sortie.

Mais les littéraux sur une seule ligne sont notoirement coûteux, à la fois en raison du nombre de caractères plus important et du nombre plus important de caractères non-ASCII. Et sa mention d'un bloc "commentaire vide" m'a fait réfléchir ...

J'ai donc proposé cette solution plus efficace qui utilise un bloc de commentaires vide supplémentaire qui se brise lorsque vous essayez de supprimer tout ce qui laisserait le bloc littéral intact:

• Nous ne pouvons pas éventuellement supprimer la troisième ligne, car nous retirerions alors le connecteur de sortie.
• Si nous supprimons la deuxième ligne, le bloc de commentaires perd son bord supérieur et se brise.

Cela laisse deux options (merci à Steve de l' avoir signalé):

• Supprimer la quatrième ligne. Cela laisse les deux cases intacts. Toutefois, lorsque l'entier résultant 19342823075080880373est décodé, la chaîne correspondante contiendrait le point de code 0x18D53Bqui n'est pas un caractère Unicode valide, se System.Char.ConvertFromUtf32bloquant avec un ArgumentOutOfRangeException.
• Supprimer une ligne complète en commençant après le coin en haut à droite. Encore une fois, les deux cases sont laissées intactes, mais l'entier résultant 508088037380718711contient deux points de code non valides 0x1B0635et 0x140077aboutissant à la même exception.

Notez que même sans le bloc de commentaires vide, la suppression de la deuxième ligne entraînerait un point de code non valide. Mais le bloc de commentaires empêche que nous prenions une ligne à l' intérieur de la deuxième ligne, pour obtenir un entier comme 193428037380718711par exemple, ce qui ne causerait pas d'erreur.

Ruby, 36 ans

eval(*[(s="planet")[$>.write(s)^6]])

Nous assignons s="planet"puis écrivons cette chaîne à STDOUT. Ceci renvoie le nombre de caractères écrits. Nous xor cela avec 6, de sorte que si tout autre chose que 6 caractères ont été écrits, nous aurons un entier différent de zéro. Ensuite, nous découpons savec cet index. Seul le 0ème caractère de s"p" est une chaîne de code valide (non-op). Nous passons cela à eval, en utilisant la (*[argument])syntaxe qui équivaut à juste (argument)sauf que ce n'est pas valide en dehors d'un appel de méthode.

Pristineness vérifiée par programme sur Ruby 1.9.3 et 2.2

C #, 128 118 101 octets

Pensée d'abuser de la règle de sous-chaîne contiguë.

Le code

class h{static void Main()=>System.Console.Write(new char[1
#if!i
*5]{'w','o','r','l','d'
#endif
});}

Pourquoi ça marche

1. class het static void Main()sont nécessaires.
2. La suppression de l'un des caractères dans 'w','o','r','l','d'provoque une erreur car le tableau de caractères est initialisé avec la longueur 1*5.
3. Vous ne pouvez pas supprimer le contenu de Main () sans enfreindre la règle de caractère contigu, car les parties sont séparées par des préprocs. (Voir ci-dessous)

Avant le golf et la séparation

class h
{
    static void Main() =>
        System.Console.Write(new char[1 * 5]{'w','o','r','l','d'});
}

Vérifié avec

https://ideone.com/wEdB54

MODIFIER:

• Enregistré quelques octets en utilisant #if !xau lieu de #if x #else.
• =>Syntaxe de fonction utilisée . #if!xau lieu de #if !x. Crédits à @JohnBot.
• En raison de la =>syntaxe func, une condition de préproc supplémentaire peut être supprimée.

MATLAB, 37 36 33 octets

feval(@disp,reshape('world',1,5))

Étant donné que je ne suis pas sûr que nous ayons le droit de produire également le fichier ans = , je devais trouver un moyen de contourner le problème afin de générer la production de manière appropriée. L'utilisation de fprintf en elle-même n'a pas fonctionné, car peu importe ce que j'ai essayé, elle a simplement refusé l'erreur. L'utilisation de disp seule n'était pas une option, car elle ne nécessiterait qu'un seul argument et que cet argument lui-même s'exécuterait évidemment aussi sans erreur.

Si ce n'est pas un problème d'inclure également ans = dans la sortie, MATLAB peut être fait avec 20 octets :

reshape('world',1,5)

> <> , 17 octets

e"ooooo7-c0pBhtra

Essayez-le en ligne!

Imprime "la terre".

La seule manière dont un ><>programme se termine sans erreur consiste à exécuter le ;caractère, ce qui pose un problème, car vous pouvez simplement supprimer tous les caractères précédents, ce qui ;correspond au premier caractère exécuté. Vous pouvez contourner ce problème en utilisant la pcommande pour modifier le programme à inclure ;à l'exécution. Suppression de toute section du code provoque l' ;à jamais produit provoquant des erreurs par les instructions invalides B, het t, pile underflow, et des boucles infinies faire fonctionner éventuellement de mémoire. Je devais seulement m'assurer que toutes les boucles infinies continuaient à remplir la pile.

Toutes les variantes ont été testées avec cet extrait de code python:

code = 'e"ooooo7-c0pBhtra'
count = {"invalid":0, "underflow":0, "memory":0}
for l in range(1, len(code)):
    for x in range(0, len(code)-l+1):
        print(code[:x] + code[x+l:], "\t\t", end='')
        try:
            interp = Interpreter(code[:x]+code[x+l:])
            for _ in range(0,1000):
                interp.move()
            print(len(interp._stack), "< ", end='')
            interp2 = Interpreter(code[:x]+code[x+l:])
            for _ in range(0,2000):
                interp2.move()
            print(len(interp2._stack))
            count["memory"] += 1
        except Exception as e:
            print(e)
            if str(e) == "pop from empty list": count["underflow"] += 1
            else: count["invalid"] += 1
print(count) 
#don't judge me

ajouté à (une version légèrement modifiée) de l’ interprète officiel de fish.py par le créateur de> <>. Sur 152 sous-programmes possibles, 92 ont échoué à partir d'instructions non valides, 18 à partir d'un nombre insuffisant de piles et 42 à court de mémoire.

Chose amusante, la première version de ce programme e"ooooo6-c0pAhtracomportait deux sous-programmes anormaux qui ont réussi à utiliser la commande put pour placer un [élément qui effacerait la pile, à la place de l'instruction non valide A. En outre, "terre" est la seule des phrases qui fonctionnera avec cette méthode, car la première lettre eest une instruction valide en ><>. Sinon, la "commande doit être placée à l'avant du programme, et un sous-programme valide pourrait être tout "seul.

Ruby, 34 ans

eval(*[($>.write("world")-1).chr])

Cela a quelques composants:

eval(*[ expr ]) est emprunté à la réponse de histocrat , et est vierge tout en vérifiant que la valeur de retour de expr est un programme Ruby valide qui ne fait pas d'erreur. method(*arr)est une syntaxe ruby ​​qui appelle methodavec les valeurs de arrcomme arguments. Ceci est nécessaire ici parce qu'il est uniquement valide en tant que paramètre d'une méthode. Par conséquent, s'il evalest supprimé, il (*[expr])s'agit d'une erreur de syntaxe. Si expr est supprimé, se evalplaint de ne pas avoir suffisamment d'arguments

$>.write("world")-1ne peut être mutilé que pour l'intérieur de la chaîne et la soustraction. $>.write("world")écrit "world" dans STDOUT et renvoie le nombre de caractères écrits, puis soustrait 1. Par conséquent, si le programme n'est pas mutilé, la valeur sera exactement 4 . Si elle est mutilée (soit -1est supprimé, soit la chaîne est raccourcie), il renverra l'un des éléments suivants: -1,0,1,2,3 ou 5 . Toute autre modification entraîne une erreur de syntaxe.

L'appel chrd'un numéro renvoie le caractère représenté par ce numéro. Ainsi, lorsqu'il est appelé sur le résultat de l'exemple ci-dessus, il génère une erreur sur -1 et renvoie une chaîne à un caractère sinon.

Je ne sais pas vraiment pourquoi, mais il semble que ruby ​​s’interprète \x04comme un caractère d’espace, ce qui signifie que l’expression est valide (les programmes ruby ​​vides ne font rien). Cependant, tous les autres caractères ( \x00- \x03et \x05) donnent lieu à Invalid char '\x01' in expression. J'ai trouvé cela en parcourant simplement les calculs possibles que je pouvais faire avec le nombre retourné. Auparavant j'avais utilisé

$>.write("planet
")*16

où "planète" plus une nouvelle ligne était de 7 caractères, multiplié par 16 pour obtenir 112 p, la seule fonction à une seule lettre en ruby ​​définie par défaut. Quand aucun argument ne lui est donné, c'est en fait un non-op

Mention honorable: $><<"%c"*5%%w(w o r l d)est très proche mais pas vierge. Suppression des "%c"*5%résultats sans erreurs. Mini-explication:

$>est stdout, et <<une fonction est appelée dessus. "%c"*5génère la chaîne de format "%c%c%c%c%c", qui essaie ensuite d'être formaté ( %) par un tableau: %w(w o r l d)ce qui est une version plus courte de ['w','o','r','l','d']. S'il y a trop ou trop d'éléments dans le tableau, de sorte qu'il ne correspond pas à la chaîne de formatage, une erreur est générée. Le talon d’Achille, c’est ça "%c"*5, et %w(w o r l d)peut exister indépendamment, et $><<n’a besoin que de l’argument de chacun . Il existe donc différentes manières de transformer ce programme en cousins ​​non-fautifs.

Validé avec ceci:

s = 'eval(*[($>.write("world")-1).chr])'
puts s.size
(1...s.length).each do |len| #how much to remove
  (0...len).each do |i| #where to remove from
    to_test = s.dup
    to_test.slice!(i,len)
    begin #Feels so backwards; I want it to error and I'm sad when it works.
      eval(to_test)
      puts to_test
      puts "WORKED :("
      exit
    rescue SyntaxError
      #Have to have a separate rescue since syntax errors
      #are not in the same category as most other errors
      #in ruby, and so are not caught by default with 
      #a plain rescue
    rescue
      #this is good
    end
  end
end

Python 3 , 43 octets

for[]in{5:[]}[open(1,"w").write("world")]:a

Essayez-le en ligne!

Comment ça fonctionne

Pour nous protéger contre les suppressions de sous-chaînes, nous utilisons à la open(1,"w").writeplace de print. En Python 3, writerenvoie le nombre de caractères écrits, ce que nous vérifierons 5afin de nous assurer qu'aucune partie de la chaîne n'a été supprimée. Pour ce faire, nous recherchons la valeur de retour dans le dictionnaire {5:[]}et lançons une boucle sur le résultat for[]in…:a, ce qui échouera si nous n'obtenons pas une valeur itérable vide ou si l' forinstruction est supprimée.

Javascript (Node.js), 93 95 octets

if(l=arguments.callee.toString().length,l!=158)throw l;console.log("world");if(g=l!=158)throw g

Vérifiez sa taille deux fois, donc s'il manque un caractère, une erreur est générée. La longueur est 156 car Node.js est ajouté function (exports, require, module, __filename, __dirname) {au code au moment de l'exécution.

Merci Martin Büttner pour avoir signalé une erreur. Correction maintenant.

Perl 5.10+, 71 63 octets

(${open 0;@{\(read(0,$a,63)!=63?die:@_)};say"world"});{$a//die}

Imprime worldavec une nouvelle ligne. Courez comme ça:

perl -M5.010 file

Cela repose sur le nombre d'octets du code source, il filedoit donc contenir le code ci-dessus et rien d'autre (pas de shebang, pas de nouvelle ligne). Perl 5.10+ est requis pour sayet l'opérateur défini ou //.

Il est incroyablement difficile de créer un programme vierge avec Perl, car:

• Tout identifiant de bareword (par exemple foo, a, _) est une instruction valide avec no strict 'subs';(la valeur par défaut). Cela signifie que le programme ne peut ni commencer ni se terminer par une lettre, un chiffre ou un trait de soulignement.

• Comme l' explique tchrist , "les identifiants spécifiés via le déréférencement symbolique n'ont absolument aucune restriction sur leurs noms." Cela signifie que le programme ne peut commencer par l' un des sigils $, @, %ou *, depuis retirant tout sauf le premier et le dernier caractère serait toujours laisser un nom de variable valide.

• De nombreuses fonctions intégrées (y compris la plupart des fonctions capables de produire une sortie) fonctionnent $_par défaut. Par conséquent, les appels fonctionnent souvent même si vous supprimez l'argument (par exemple, say"world"vs say).

Comment ça fonctionne

Cette solution a été inspirée par la réponse de Naouak, Node.js , qui vérifie sa propre longueur pour s'assurer que les caractères n'ont pas été supprimés.

Le programme comporte deux sections, l'une entre parenthèses et l'autre dans un bloc:

(...);{...}

La première section lit le fichier source et meurt s'il contient moins de 63 caractères. La deuxième section vérifie que l' readexécution est réussie. Si l'une des sections est supprimée (avec ou sans les parenthèses ou les accolades), l'autre section lève une exception.

Supprimer le milieu, le côté gauche ou le côté droit du programme déséquilibrera les parenthèses et / ou les accolades, ce qui provoquera une erreur de syntaxe.

Si le premier dieest modifié (de d, e, di, de, ou ie, qui sont tous les identificateurs valides), la vérification de la longueur devient:

@{\(read(0,$a,63)!=63?di:@_)};

qui évalue à:

@{\'di'};

Cela prend une référence à une chaîne et essaie de la déréférencer en tant que tableau, produisant une erreur:

Not an ARRAY reference

Si une autre déclaration est modifiée, la vérification de la longueur échouera et le programme mourra.

Vérifié vierge avec le programme suivant:

#!/usr/bin/perl

use strict;
use warnings;
use 5.010;

use File::Temp;
use List::MoreUtils qw(uniq);

sub delete_substr {
    my ($str, $offset, $len) = @_;

    my $tmp = $str;
    substr($tmp, $offset, $len) = '';

    return $tmp;
}

sub generate_subprograms {
    my ($source) = @_;

    my $tot_len = length $source;
    my @subprograms;                                             

    foreach my $len (1 .. $tot_len - 1) { 
        foreach my $offset (0 .. $tot_len - $len) {
            push @subprograms, delete_substr($source, $offset, $len);
        }                                                        
    }                                                            

    return uniq @subprograms;                                    
}                                                                

chomp(my $source = <DATA>);                                                                                                       
my $temp = File::Temp->new;                                                                                        

foreach my $subprogram ( generate_subprograms($source) ) {       
    print $temp $subprogram;

    my $ret = system(qq{/usr/bin/perl -M5.010 $temp > /dev/null 2>&1});
    say($subprogram), last if $ret == 0;

    truncate $temp, 0;
    seek $temp, 0, 0;
}

__DATA__
(${open 0;@{\(read(0,$a,63)!=63?die:@_)};say"world"});{$a//die}

Ruby + coreutils, 33 27 26 octets

`base#{$>.write"world
"}4`

Essayez-le en ligne!

Les backticks en ruby ​​exécutent la commande qu'ils contiennent et renvoient ce que le programme a mis dans STDOUT sous forme de chaîne. La #{expr}syntaxe permet d'incorporer des expressions dans des chaînes et des backticks. Ce programme pourrait être réécrit (non pristinement) comme suit:

system("base" + (STDOUT.write("world\n")).to_s + "4")

IO#writeretourne le nombre d'octets écrits, donc si la chaîne est raccourcie, ce ne sera pas le bon nombre. #{}l'incorporation transforme automatiquement le nombre en chaîne. Si une partie est supprimée et qu'elle ne provoque pas d'erreur de syntaxe, la commande erronée sera exécutée. Si une partie de "world"est supprimée, l'un des base04traverses base54tentera de s'exécuter.

La nouvelle ligne, que ce soit dans ou hors de la chaîne, est obligatoire. Sinon, les 5 premiers caractères ( `base) peuvent être supprimés, faisant de la ligne entière un commentaire. De plus, il doit y avoir un ou plusieurs caractères entre le premier backtick et #, sinon, ils {peuvent être supprimés pour que le tout soit un commentaire shell .

exec(*[(s="ec%co earth")%s[10]])

execRemplace le processus ruby ​​actuel par la commande spécifiée. Voir mon autre réponse pour une explication de la meth(*[])syntaxe et de sa nécessité.

(s="ec%co earth")assigne la chaîne "ec% co earth" à la variable s. Les assignations retournent ce qui avait été assigné, donc la chaîne est aussi retournée.

"format string %d" % 5est un sucre syntaxique pour sprintf("format string %d",5), mais les espaces autour de la %ne sont pas nécéssaires.

s[10]obtient le caractère dans la chaîne à l'index 10. Lorsqu'il n'est pas mutilé, ce caractère est "h", la dernière lettre de la chaîne. Toutefois, la suppression de tous les caractères de la chaîne signifie que la chaîne est plus courte. Par conséquent, il n'y a pas de caractère à l'index 10, est s[10]renvoyé nilet "%c" % nilprovoque une erreur.

Si %s[10]est supprimé, Ruby essaie d'exécuter la commande ec%co earthqui ne fonctionne pas.

Passer 10à 1ou 0entraîne également une commande inconnue (ou eceoou ecco). Le supprimer entièrement n’est techniquement pas une erreur de syntaxe puisqu’il appelle la méthode #[]sur la chaîne, mais qu’il se plaint du manque d’arguments.

Une note sur la résolution de ce problème en général: Vous devez avoir un wrapper qui vérifie le code intérieur dans un sens abstrait tout en restant vierge. Par exemple, un programme avec division à la fin ( blablabla/somevar) ne fonctionnera jamais car une division peut toujours être supprimée ( blablabla). Voici quelques exemples de tels emballages que j'ai utilisés jusqu'à présent:

• eval(*[code ])utilisé par histocrat et dans ma première réponse. Valide que la sortie est un programme ruby ​​valide
• exec(*[code ])utilisé ci-dessus, valide que la réponse est une commande valide
• `#{ code }`

La syntaxe backtick exécute également une commande (et valide donc qu'il s'agit d'une commande valide), cependant STDOUT est capturé sous forme de chaîne au lieu d'être affiché en tant que processus parent '(Ruby's) STDOUT. Pour cette raison, je n'ai pas pu l'utiliser pour cette réponse, EDIT: je l'ai fait fonctionner. Limitations décrites ci-dessus.

Edit: Merci à @histocrat pour avoir signalé quelques défauts

PowerShell, (97 octets + 5 pour le nom du programme) = 102 octets

"$(try{if(($a=(gc .\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a

Vérifie lui-même avant qu'il ne se détruit ... deux fois.

Attend à être enregistrés en tant que c.ps1et exécutées à partir du répertoire local en tant que tel:
PS C:\Tools\Scripts\Golfing\> .\c.ps1.

L'alias gcest un raccourci pour Get-Contentet ressemble à une catlecture de fichier (dans ce cas, notre chemin d'exécution .\c.ps1). Nous obtenons le .Lengthfichier, le définissons sur $aet vérifions s'il n'est pas égal à 97 avec -eq97. S'il est égal (c'est-à-dire que le programme n'a pas été modifié), nous imprimons avec "world"et exécutons une commande non valide a. Cela oblige catchà prendre effet, ce qui nous permet de nous contrôler à nouveau. Cette fois-ci, si notre code n'est pas égal à 97, nous lançons une commande non valide afin que notre programme contienne une erreur et imprime un texte d'erreur à la sortie. Nous avons ensuite clear()l'erreur et exitnormalement.

Il est évident que si l'une des ifdéclarations est falsifiée, l'autre aura une erreur. Si une partie de "world";est falsifiée, la première ifprovoquera une erreur. Comme il doit être contigu, nous ne pouvons pas supprimer les deux ifdéclarations. Les chaînes au milieu donneront lieu à des parenthèses incohérentes ou à l' {a}exécution de la seconde . Le try/ catchest d’attraper l’erreur de la première ifdéclaration afin que nous puissions l’effacer correctement. L'extérieur "$( )"empêche les chaînes d'être coupées. La dernière ;aconsiste à éviter que des parties de la partie médiane qui sont coupées ne donnent lieu à des programmes valides (par exemple "it}a)";a, qui imprimera it}a)puis commettra une erreur).

Il y a plusieurs circonstances spéciales:

• Si le gc, gc<space>ou gc .\sont supprimés, le programme finira par erreur avec un peu de saveur d'une erreur de dépassement de mémoire ( en raison d'appels d' auto-exécution répétée) et accident probable que le shell (et peut - être l'ordinateur). Pas testé.
• Si les <space>.\c.ps1ou .\c.ps1sont supprimés, le programme s’arrêtera et vous demandera une saisie de l’utilisateur. Peu importe ce que l'utilisateur entre, le programme sera toujours en erreur, car les comptages de taille seront erronés.
• Si une sous-chaîne commençant par le $et se terminant avant le dernier "est extraite, le programme affichera tout ce qui restera, puis une erreur, car ce an'est pas valide.

Vérifié avec ce qui suit:

$x='"$(try{if(($a=(gc .\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'
$yy='"$(try{if(($a=( .\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'
$yyy='"$(try{if(($a=(.\c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'
$yyyy='"$(try{if(($a=(c.ps1).Length)-eq97){"world";a}}catch{if($a-ne97){a}$error.clear();exit}a)";a'

for($i=1;$i-lt$x.Length;$i++){
  for($j=0;$j-lt($x.Length-$i);$j++){
    $y=($x[0..$j]+$x[($i+$j+1)..$x.Length])-join''
    $y>.\c.ps1
    $error.clear()
    if(!($y-in($yy,$yyy,$yyyy))){try{.\c.ps1}catch{};if(!($error)){exit}}
    $q++;
    write-host -n "."
    if(!($q%150)){""}
  }
}
"No success."

(Merci à Martin pour son aide!)

C (gcc) (Linux -Werror=undef), 66 octets

main(a){a
=
1
/
(puts("world")/
6);
#if(7^__LINE__)
#else
}
#endif

Essayez-le en ligne!

Grand défi! C'était durement trompeur, mais je suis à peu près sûr d'avoir un programme valide maintenant!

Utilise une commande de préprocesseur pour qu'aucune nouvelle ligne ne puisse être supprimée, car le crochet de fermeture à mainn'est inclus que si __LINE__==6. Cela vous empêche également de tout effacer main, car cela laisse #endifflotter (il est donc important que ce #endifsoit en dehors de main).

J'ai utilisé #elseparce que je suis devenu assez convaincu qu'il n'y a pas de version de ce __LINE__==6qui ne peut pas avoir une sous-chaîne supprimée et toujours être vrai, puisque les deux 6et __LINE__par eux-mêmes sont la vérité. Il utilise également -Werror=undefpour que quelque chose comme #ifdef(LINE__)ne soit pas évalué comme étant faux, mais comme une erreur.

Avec gcc (sous Linux au moins), putsrenvoie le nombre de caractères imprimés (y compris le retour à la ligne suivant), ainsi la suppression de toute partie de la chaîne puts("...")/6renvoie un résultat 0, ce qui 1/0entraîne une exception en virgule flottante. Notez que cette exception n’est causée que si elle 1/0est affectée à quelque chose, elle a=est donc requise.

Aucune autre partie d'une ligne ne peut être supprimée sans créer une erreur, généralement une erreur de syntaxe ou une erreur de liaison.

En prime, cela donne une solution de 86 octets pour C ++ assez trivialement, ajoutez #include <cstdio>et déclarez en atant que int. Essayez-le en ligne! (C ++)

PHP, 73 octets

<?=call_user_func(($p='ns')|(($f="u{$p}erialize"))?$f:'','s:5:"world"');

Explication

J'assume la configuration par défaut de php.ini. Donc short_tags est désactivé. Cela signifie que vous ne pouvez pas supprimer le =de la balise d'ouverture.

Ceci est fondamentalement <?=unserialize('s:5:"world"');.

Si vous supprimez une partie de la chaîne sérialisée, vous obtiendrez une erreur.

Vous pouvez simplement supprimer unserializeet le script va simplement sortir la chaîne sérialisée. Pour surmonter cela, j'utilise call_user_func. Supprimer l'un des paramètres entraînera une erreur.

'<?=call_user_func('unserialize','s:5:"world"');

Cependant, vous pouvez supprimer un, pour appeler la serializefonction. Donc, nous sortons 'ns`. Supprimer tous les caractères ne donnerait pas un nom de fonction incorrect.

<?=call_user_func(($p='ns')&&($f="u{$p}erialize")?$f:'','s:5:"world"');

Nous allons utiliser un inline si vous utilisez une affectation de variable avec la balise de sortie. Au lieu d'utiliser, &&nous utilisons '|' pour empêcher la suppression d'un seul &ou la suppression de l' $faffectation

Vous pouvez enlever ='ns')&&($f="u{$p}erialize"et finir avec ($p)?$f:''. Par conséquent, j'ajoute une parenthèse supplémentaire autour $f="u{$p}erialize".

Remarque

Techniquement, vous pouvez supprimer les balises d'ouverture sans générer d'erreur. Ce n'est cependant plus un script PHP, mais juste un fichier texte brut.

Matlab (77)

bsxfun(@(c,b)arrayfun(@(x)getfield(c,{x}),conv(b,ismember(4,b))),'world',1:5)

l'essayer

Remarque:

Suivant les conseils de @ Optimiser concernant la conception d'un CPR ou quelque chose du genre, j'ai été confronté à une sous-chaîne imprévue qui n'a entraîné aucune erreur de compilation lors de sa suppression. Exemple: la suppression arrayfun(@(x)a(x),prod(b,ismember(4,1:5))),de cette édition précédente ne feval(@(a)arrayfun(@(x)a(x),prod(b,ismember(4,1:5))),'world')génère aucun bogue! aussi, pour la même édition récente, il y en avait bsxfun(@(a,b)arrayfun(@(x)(x),prod(b,ismember(4,b))),'world',1:5)et bsxfun(@(a,b)a,'world',1:5), si vous m'avez demandé comment étais-je lorsque je les ai trouvés dans ma console de sortie, j'ai pleuré comme un bébé, alors voici le programme:

b=0;string='bsxfun(@(c,b)arrayfun(@(x)getfield(c,{x}),conv(b,ismember(4,b))),''world'',1:5)'
for u=1:numel(string),for j=u:numel(string)-2,try a=eval([string(1:u) string(j+2:end)]);catch(b); a=0;end; if a~=0, ['here is it : ' string(1:u) string(j+2:end)],end;end;end

Un exemple de programme non vierge

modifier:

Merci à tout le monde à côté de @Martin pour avoir signalé le code (non-erreurs) précédent.

SmileBASIC, 63 octets

REPEAT
A=1/(PRGSIZE(0,1)==63)?"world
UNTIL 1/(PRGSIZE(0,1)==63)

Un poirier , 17 octets

Ce programme contient des octets avec le bit fort défini (qui ne sont pas valides UTF-8 et ne peuvent donc pas être postés sur TIO). Voici donc un xxdhexdump réversible:

00000000: 7072 696e 7427 776f 726c 6427 23cd 4290  print'world'#.B.
00000010: bf                                       .

Explication

Ceci est juste print'world'avec une somme de contrôle ajoutée. J'ai vérifié par la force brute qu'aucune des suppressions possibles ne donne un programme avec une somme de contrôle valide. Vous obtenez donc une erreur après toute suppression possible.

Assez ennuyeux, mais lie le leader actuel, alors j’ai pensé que cela valait la peine d’être publié.