Votre objectif : écrire un morceau de code qui donnera le résultat classique de "Hello, world!" en cours d'impression sur STDOUT ou équivalent.

Règles : Le code doit être entièrement imprimé en ASCII. Tout le code doit être fonctionnel - la suppression de tout caractère de comptage unique doit modifier le résultat ou empêcher le code de fonctionner. Toutes les variables doivent être utilisées après l'affectation. Les littéraux de caractère et de chaîne doivent être nécessaires à la sortie - c'est-à-dire que le remplacement de tout littéral de caractère ou de tout caractère dans un littéral de chaîne par un autre caractère doit être capable de changer le résultat (et non via l'effet de la séquence d'échappement - remplacer le caractère par une barre oblique inverse) ou équivalent)

(REMARQUE: la règle finale a été modifiée dans)

Scoring : C'est là que ça devient intéressant. Le score le plus élevé l'emporte en fonction du nombre de caractères, selon les règles de bowling de code typiques. Mais l'utilisation répétée de caractères entraînera des déductions de points. Plus précisément...

1. L'utilisation répétée de tout caractère alphanumérique (az, AZ, 0-9) entraînera une déduction de 3 points par répétition (la première utilisation n'entraîne pas de déduction).
2. L'utilisation répétée de la ponctuation de base ([!? .-, ": ';]) - y compris les crochets - entraînera une déduction de 2 points par répétition.
3. L'utilisation répétée d'autres caractères ASCII {`~ @ # $% ^ & * _ + = | \ /> <} - y compris les accolades - entraînera une déduction de 4 points par répétition.
4. L'utilisation répétée d'espaces, de tabulations et de nouvelles lignes entraînera une déduction de 1 point par répétition. Autrement dit, seule la première utilisation d'un espace, d'un onglet ou d'une nouvelle ligne comptera pour votre total.

Remarque: les commentaires ne comptent pas dans le total, bien que les caractères marquant le début / la fin d'un commentaire le soient. Par exemple, en C / C ++, si vous en avez /* This is a comment */, alors il comptera deux barres obliques et deux astérisques, mais rien entre eux.

Quelques exemples (remarque: utiliser Julia comme exemple de langue) ...

print("Hello, world!");

Nombre total de caractères visibles: 22
Contient un espace: +1
Alphanumériques répétés: -12 pour llor Ponctuation
répétée: -2 pour "
Score final: 22 + 1-12-2 = 9

print("Hel",char(108),"o, wor",0x108,"d!"); # 0x108 makes a Uint8 that prints as ASCII

Nombre total de caractères: 43 (ne compte aucun caractère après #, qui est le caractère de commentaire)
Contient un espace: +1
Alphanumériques répétés: -18 pour rr1008 Ponctuation
répétée: -24 pour () "" "" ",,,,,
Final score: 43 + 1-24-18 = 2

xy=STDOUT
m="Hello, world!"
print(xy,m);

Nombre total de caractères visibles: 37
Contient une nouvelle ligne: +1
Contient un espace: +1
Alphanumériques répétés: -18 pour xyllor Ponctuation
répétée: -4 pour ",
Autres ASCII répétés: -4 pour =
Score final: 37 + 1 + 1-18-4 -4 = 13

Quelques morceaux de code invalides ...

x=2;print("Hello,world!")  

Problème: xest attribué, mais pas utilisé.

print("Hello,"*" world!")  

Problème: *inutile, le résultat sera le même sans lui.

k=1
if k>0
  print("Hello, world!")
else
  print("abcghjmquvxyzABCDEFGIJKLMNOPQRSTUVWXYZ_+*-&|")
end  

Problème: la deuxième printcommande ne s'exécutera pas. De plus, la suppression des caractères entre guillemets dans la deuxième printcommande ne changera pas la sortie.

x="Hello, world!";
print(x)  

Problème: la suppression de la nouvelle ligne ne changera pas le résultat ou ne provoquera pas d'erreur (dans Julia, le point-virgule n'est nécessaire que si plusieurs commandes sont sur la même ligne, sinon supprime simplement la valeur de retour).

print("Hellos\b, world!")  

Problème: le scaractère n'affecte pas le résultat, car il est effacé par \b. Ceci est acceptable si cela se fait via le code ( "Hello",char(100),"\b, world!"), mais ne peut pas être fait via des littéraux de chaîne ou des littéraux de caractère.

Calculatrice de score pratique - http://jsfiddle.net/4t7qG/2/ - grâce à Doorknob

Perl - 96

(Assez bien, étant donné le score théorique maximal de 97)

s{}[Hel0o, w3$=d!];y<"#%&'*.124578:?@BCDEFGIJKLMNOQ/-9>(
    6PRSTUVWXYZ^_`abfghjmqvxz|~\cAk-u)+print

(Notez que la deuxième ligne commence par un \tcaractère de tabulation réel )

Le code comporte 98 caractères et contient chaque caractère ascii exactement une fois, plus un extra -.
98 - 2 = 96

Il n'y a pas de littéraux de chaîne ici, mais la suppression d' un caractère unique interrompt le programme.

Désobfuscation

Il y a 3 déclarations dans ce programme (enfin, en fait 2 mais j'ai abusé +comme une sorte de séparateur de déclaration)

1. s{}[Hel0o, w3$=d!]
   Il s'agit d'un cas très étiré de l'opérateur sed. Il est plus communément écrit comme s/a/b/, ou s:a:b:, mais perl permet beaucoup plus de fantaisie ici:, s(a)(b) s(a)^b^ s(a)[b]et même s qaqbq.
   Il remplace une chaîne vide (à l'intérieur {}) par Hel0o w360d!(à l'intérieur []) ( $=interpole à 60par défaut). En raison de l'absence d'un ~=opérateur, il fonctionne $_.

2. y<"#%&'*.124578:?@BCDEFGIJKLMNOQ/-9>(\n\t6PRSTUVWXYZ^_`abfghjmqvxz|~\cAk-u)
   Il s'agit également d'un cas très étiré, mais d'un tropérateur, également appelé y( y< >( )).
   Regardons le tableau de remplacement:
   " # %&'*.124578:?@BCDEFGIJKLMNOQ /-9
\n\t6PRSTUVWXYZ^_`abfghjmqvxz|~\cA k-u
   j'ai déplacé certains caractères pour que la chaîne existante ne soit pas rompue. La seule partie réellement fonctionnelle ici est /-9-> k-u. Il remplace 0par l, 3avec oet 6par r.
   Encore une fois, faute d' ~=opérateur, il fonctionne. $_
   Nous avons donc maintenant la phrase complète dans la $_variable.

3. print
   Le manque d'arguments permet d'imprimer uniquement la $_variable.

Cette réponse a été créée avant l'ajout de la règle sur les littéraux de chaîne et ne participe pas au concours.

#include <iostream>
int main(){std::cout<<56+"  !$%^&*?12347890-_QWERTYUIOPASDFGJKLZXVBNM,.qypfghjk:zvbHel\x6Co, world!";}

C'est complètement légitime. : P Si vous supprimez un caractère de cette chaîne, il s'imprimera ello, world!.

CJam, 94

{'H"EJO, WoRLD!"el96A+c/~_-3=0$@}"# 
`&^<>|;:?.()[]\1aBCdfFgGhiIjkKmMnNpPqQrsStTuUvVwxXyYzZ"254b87%*

Essayez-le en ligne! Notez qu'il doit y avoir un tabulateur juste avant le saut de ligne. SE n'aime pas les tabulateurs, vous devrez donc les insérer manuellement.

• 100 caractères
• alnum répété: -0 ()
• ponctuation répétée: -6 ("" ")
• répété autre: -0 ()
• espace répété: -0 ()

Note totale: 94

J'ai utilisé le code suivant pour vérifier qu'aucun des caractères à l'intérieur de la chaîne ne peut être supprimé:

"#  
`&^<>|;:?.()[]\1aBCdfFgGhiIjkKmMnNpPqQrsStTuUvVwxXyYzZ"
:A,,{_A\<A@)>+254b87%}%`

Il imprime un tableau indiquant le nombre de fois Hello, world! serait imprimé si le caractère correspondant à l'index était supprimé.

Rubis, 28 41

Pour commencer les réponses avec une solution dans l'esprit de la question:

print"He#{?l*2}o, "+'world!'if[$`&(9<=>6)^7|~8-5/3.1%0x4]

Notation (je pense avoir bien compris):

• 57 caractères de long
• alnum répété: -12 ( orli)
• ponctuation répétée: -4 ( "')
• répété autre: -0
• espaces répétés: -0

PHP, 1 (oui, un point!)

Utilisation de caractères magiques pour générer une somme de contrôle qui, sous forme binaire, correspond à "Hell", "o, w", "orld" et "!".

D'habitude, j'aime trouver des échappatoires, mais cette fois j'ai décidé de jouer selon l'esprit et l'intention du concours. Chaque personnage et sa position sont essentiels à la sortie. Les seuls endroits que vous pouvez remplacer sont des noms de variables qui ne sont pas des valeurs littérales, les espaces entre phpet foreachqui PHPtraitent comme équivalents et l'utilisation de 'vs "qui PHPtraite comme similaires.

<?php foreach(array('_MC:`~+V4@SbHR/l[J','dN#UB`5!Rv^NG@D}','9gm6L&-kuD','8OM97g.q]XQ0')as$j)print(hash("crc32",$j,1))?>

Pour info, ce sont quelques autres chaînes magiques et hachages d'intérêt:

E.D}S:  Hell
9UDIRQ: Hell
N\7&*`%:    orld
UWX[E^O:    orld
mAHzDEb:    !   
uLJ7Ck&:    Hell
B+bG5mYJ:   Hell
:OvMzuOR:   !   
TgYR9g!6k:  o, w
NkFN`!8mI:  o, w
N#VA\j~}J[: Hell
vEl*]@0XQ5: o, w
9gm6L&-kuD: orld
*}{Xg@HN`\: !   
Pj@Y44uA6YJ:    Hell
|7OX0VF8gv}:    !   
DLRJAjgMj}\:    !   
!0bT*D}O4Lw:    orld
YGN97^v7ZY`:    Hell
++~bL/kP:|]W:   o, w
8OM97g.q]XQ0:   !   
l^m-DqZ^g[&+:   !   
Ewu]Rv~*DHQ7:   Hell
JIqjgF|S!\`8l:  Hell
b4l!MEG7vTu6/:  Hell
+B:zEq*J\k-Cm:  !   
_}E7wZD76^`Y9AU:    orld
q:Nq-~+_S7~N9Hz:    !   

Befunge-98 , 97 points!

"v!dlrow ,h
B[CDEFGIJkLMNOPH
$<QRSTUV@|5cg1fe':-%\64*ab+7_/89}{0  j2
WXYZK`.=#>]
s()impq	n 3~
Atuxz&;y^ ?

Essayez-le en ligne!

L'onglet est entre le qet le n.

Utilise une astuce similaire à la réponse Befunge précédente pour remplir les lignes avec les caractères restants, mais évite d'utiliser des caractères en double dans la section d'exécution. La suppression de l'un des caractères non exécutables a pour conséquence que les parties en cours d'exécution sont déplacées, se terminant généralement par des boucles infinies ou imprimant la mauvaise sortie.

Comment ça fonctionne

Vraiment, la seule partie d'exécution ressemble à:

"v!dlrow ,h
         k     H
$<      @|5cg1fe':-%\64*ab+7
         >]
        ^ ?

Tout d'abord, il utilise un littéral de chaîne d'habillage pour ajouter , world!à la pile. Cela évite deux "s.

$<      @|5cg1fe':-%\64*ab+7

Cela ajoute Helloà la pile en utilisant une variété de méthodes pour éviter les caractères en double. $saute l'espace excédentaire causé par le littéral de chaîne d'habillage

7+ajoute 7 à la hfin du littéral de chaîne pour créer le o . ba*46\%:calcule 111, la valeur ascii let la duplique.

'e ajoute e à la pile.

f1g obtient le personnage à 1,15 qui est le H

Il réutilise ensuite le ,dans la chaîne pour imprimer le tout Hello, world!. Le reste n'est que des changements de direction pour naviguer jusqu'à la fin @.

Rubis, 78

Plus d'abus de règles, je me sens, je ne sais pas exactement quel serait le patch. Prend une longue chaîne et vérifie la somme du résultat, donc toute suppression ou modification entraînera l'échec du programme. Pourrait probablement être optimisé un peu pour supprimer la duplication de certaines lettres et y ajouter des espaces.

puts('Hello, world!')if%["\#$&*+-/:;<>?@ABCDEFGIJKLMNOPQRSTUVWXYZ^_`abcghjknqvxyz{|}~123].sum==4980

PHP, 2257

Faille: la barre oblique inverse a été omise des spécifications et du calculateur de score!

Ce code compte le nombre d'occurrences de barres obliques inverses dans chaque chaîne et imprime un équivalent ASCII. Le remplacement d'une barre oblique inverse par un autre caractère ou la suppression d'une barre oblique inverse provoque une erreur d'analyse ou modifie le résultat.

Une caractéristique intéressante des barres obliques inversées PHPest qu'elles doivent être échappées, de sorte que le score double automatiquement! Vous pouvez re-doubler, tripler, etc., le score en multipliant le nombre de barres obliques inverses, mais vous ne voulez pas être gourmand, et je pense que cela pourrait dépasser les limites de ce que vous pouvez entrer.

<?php foreach(array('\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\','\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\')as$x)print(chr(substr_count($x,"\\")))?>

Befunge - 87

"dlrow ,olleH"bk,                                                                   v
!#$%&'()*+-./0123456789:;  <=>?ABCDEFGIJKLMNOPQRSTUVWXYZ[\]^_`acfghijmnpqstuvxyz{|}~@

La première ligne vaut quatre points en raison de toutes les répétitions, mais il n'y a pas de caractères dupliqués sur la deuxième ligne. Le seul littéral de chaîne dans ce code est dlrow ,olleH, qui est inversé et imprimé en sortie. La suppression d'un caractère entraînera la déconnexion vde la fin de la première ligne de @la fin de la seconde, ce qui empêchera le programme de se terminer. Si le vlui-même est supprimé, le code entrera dans une boucle infinie imprimant la sortie correcte.

Aceto , 3

Enfin réussi à obtenir un score positif!

"Hello, "-J' sJ"world!"∑-JUJpn

Essayez-le en ligne!

Acc !! , -138 (et oui c'est négatif 138)

Bien que ce ne soit pas exactement le meilleur score que j'ai jamais obtenu en PPCG, je doute qu'il puisse être plus élevé que cela en Acc !!

108
Write 72
Write 101
Count i while i-2 {
	Write _
}
Write _+3
Write 44
Write 32
Write 119
Write 111
Write 114
Write _
Write 100
Write 33

Essayez-le en ligne!