Écrivez un programme qui ne prend aucune entrée et imprime Hello, World!sur stdout ou l'alternative la plus proche de votre langue. Le hic, c'est que chaque ligne de votre programme ne doit contenir que des caractères ASCII imprimables et elle doit être dans l'ordre lexicographique, c'est-à-dire triée.

Voici les 95 caractères ASCII imprimables dans l'ordre:

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

Ainsi, par exemple, la ligne !!A0~serait invalide car les Aet 0sont en panne. La ligne !!0A~serait valide.

Chaque ligne de votre programme peut être de n'importe quelle longueur et il peut y avoir un nombre quelconque de lignes. Les lignes vides sont considérées comme triées. Chacune des nouvelles lignes de votre programme doit être la même (pas de mixage \net \r\n). Les tabulations et autres caractères ASCII non imprimables sont interdits.

En raison de la demande populaire , la condition de gain a été inversée:
la soumission avec le moins de lignes gagne. Tiebreaker passe au programme le plus court (les nouvelles lignes comptent comme des caractères uniques).

Uniquement Hello, World!et une nouvelle ligne de fin facultative doit être sortie. Notez que HQ9 + n'est pas valide car il sort hello, world. Je peux interdire les langues similaires à HQ9 + qui ont un caractère "Hello, World!" commandes en raison de leur trivialité.

Allusion:

C'est certainement possible en Unary et en Lenguage , mais pas de manière très concise.

Headsecks , 1 ligne, 366 octets

                                                                        $(((((((((((((((((((((((((((((,000000044888<AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIIIIIIIIIIIILPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPTXXXXXXXXXXXXXXXXXXXXXXXX\```diiiiiilqqqqqqqqtyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy|

Headsecks est une substitution Brainfuck triviale où la seule chose qui compte est le point de code modulo 8. L'équivalent Brainfuck est simplement

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------.

Heureusement , cette approche naïve juste convient. Il existe un certain potentiel pour jouer au golf sur les octets, mais cela pourrait être difficile.

Testé à l'aide de cet interpréteur Python .

Génération de code

code = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------."
command_map = "+-<>.,[]"

last_point = 32
out = []

for char in code:
    curr_mod = command_map.index(char)
    last_mod = last_point % 8

    if curr_mod > last_mod:
        last_point += curr_mod - last_mod

    elif curr_mod < last_mod:
        last_point += (8 - last_mod) + curr_mod

    out.append(chr(last_point))

print("".join(out))

/// , 7 lignes, 22 octets

/
//Hello
,
 Wor
l
d
!

Une rare chance pour /// d'être compétitif (enfin tant que personne ne commence par Unary et Lenguage ...).

Le code rencontre d'abord a /et analyse le

/
//

comme instruction de substitution qui supprime toutes les nouvelles lignes du reste du programme. Ensuite, le programme lit simplement

Hello, World!

qui est imprimé textuellement car il ne contient plus de barres obliques.

JavaScript (67 66 62 lignes, 227 269 ​​octets)

(Remarque: testé uniquement sur Firefox 36 et Safari 8, contient des fonctionnalités ES6 mineures (la Setclasse))

Z
=
!""+
(0[[]]
+
(
!!""+Set
));c
=Z[~
-22]
$=Z[
3]
$$=Z[
15]
$$$=Z[
24]
$$$$=Z[
1]
$$$$$=Z[
0]
Set
[c
+
$$$+Z[
5]
+Z[
16]
+
$$$$$+
$$$$+Z[
2]
+c
+
$$$$$+
$$$+
$$$$]
(Z[
14]
+
$$+
$+
$$$$+
$$$$$+
"(\
'H\
"+
$+
$$+
$$+
$$$+
",\
 W\
"+
$$$+
$$$$+
$$+Z[
6]
+
"\
!')\
")
()

Le code ci-dessus fait essentiellement:

alert("Hello, World!")

De toute évidence alertn'est pas trié. Donc, à la place, nous devons générer l'instruction sous forme de chaîne et la "valider":

s = "alert('Hello, World!')";   // generate this using sorted code
eval(s)

Comment générer la chaîne? ES5 prend en charge la continuation de ligne afin que

"AL\
ERT" === "ALERT"

Mais le code de caractère \apparaît avant toutes les lettres minuscules, nous devons donc générer les lettres minuscules en utilisant d'autres méthodes.

Nous empruntons ici une idée de JSFuck . Les lettres minuscules impliquées dans les alertes sont:

t e r a o l d

tous ces éléments peuvent être extraits de caractères d'objets standard, qui peuvent être exprimés en termes de séquence triée:

t, e, r ← true      = !""
a, l    ← false     = !!""
o       ← function  = Set
d       ← undefined = 0[[]]

Comment évaluons-nous la chaîne? Nous ne pouvons certainement pas l'utiliser eval(s)car il n'est pas trié. Alternativement, nous pourrions utiliser Function(s)(), mais nous ne pouvons pas utiliser Functioncar il n'est pas trié non plus. Cependant, Functionest le constructeur de toutes les fonctions, ce qui signifie Set.constructor === Function.

L'ajout de l'identifiant constructorfait de la liste des lettres minuscules:

t e r a o l d c u n s

qui pourrait heureusement encore être généré par "truefalseundefinedfunction":

t, e, r, u ← true      = !""
a, l, s    ← false     = !!""
o, c, n    ← function  = Set
d          ← undefined = 0[[]]

Après avoir amélioré, le code ci-dessus devrait se lire comme suit:

// lines 1~8 defines our string containing all lowercase letters we want
Z = true + (undefined + (false + Set))
// Z = "trueundefinedfalsefunction Set() { [native code] }"

// lines 8~20 defines the variables `c`, `$` (e), `$$` (l), `$$$` (o), 
// `$$$$` (r), `$$$$$` (t)
// for the corresponding lowercase letters extracted from `Z`

// the rest calls:
Set["constructor"]("alert('Hello, World')")()
// lines 22~36 generates the "constructor" string
// lines 37~61 generates the "alert('Hello, World')" string

Mise à jour: Rebaptisé E, L, O, R, Tà diverses répétitions de $réduire de 4 lignes.

Insomnie , 4 lignes, 59 octets

 FFFFGjnnnnooty
FLLddeejkopqyyyyy~~
(<ddjnoppppqrtu
<<Fddfj

Ce programme est généré en optimisant le nombre de lignes.

10 lignes, 43 octets

(u
pt
(dppty
p~
j
<Fptt{
(otz
?o
FLu
<?FFu~

Ce programme ci-dessus est généré en optimisant le nombre d'octets.

Cygwin bash, 16 lignes, 60 octets

Cela ne fonctionne qu'en raison du nom de fichier insensible à la casse sous Windows et du fait que Cygwin recherche les utilitaires sans tenir compte de la casse même si vous ne le définissez pas pour reconnaître le chemin sans tenir compte de la casse.

A\
=Hello
A\
+=\
",
"Wor
A\
+=l
A\
+=d
A\
+=\
!
E\
CHO\
 $A

Prenez note de cela ECHOà la fin.

> <> , 6 lignes, 111 octets

  """""""/;;Hello
        &\o
      &++\oooo~~
"++++++++\bbbdlr
    +++++\ccccccccfooo}
    $++66\cfffffooooopr

J'ai du mal à jouer une ligne supplémentaire, mais en tout cas, je suis heureux d'avoir battu la méthode à 7 lignes.

Explication

> <> est un langage 2D basé sur la pile où les instructions sont des caractères uniques et le flux du programme peut être en haut, en bas, à gauche ou à droite. L' "instruction bascule l'analyse de chaîne, poussant les caractères jusqu'à ce qu'une fermeture "soit atteinte, mais en raison de la nature de> <>, il n'y a rien de tel que "l'analyse de chaîne multi-ligne" comme avec les chaînes de CJam ou les chaînes entre guillemets triples de Python. Cela s'est avéré être un problème majeur car le début et la fin d'une ligne avec a "et le fait d'avoir d'autres caractères entre (par exemple "some chars") n'est pas autorisé!

Notez cela /et \reflétez le flux du programme, donc nous exécutons en fait la première ligne puis toutes les lignes dans l'ordre inverse, et la plupart des lignes sont en fait exécutées à l'envers!

[Line 1]

""""""              Three empty strings, push nothing
"/;;Hello  "        Push "/;;Hello  ". Note the wrapping - ><> is toroidal!
""""""              Three empty strings, push nothing

[Line 6]
66++$               Turn the top " " into "," by adding 12, then swap top two
rp                  Reverse stack and pop top 3
ooooo               Print "Hello", stack is now " ,"
fffffc              Push some 15s and a 12

[Line 5]
+++++               Sum the 15s and 12 to give 87, or "W"
}ooo                Move "W" to the back and output ", W"
fcccccccc           Push a 15 and some 12s

[Line 4]
++++++++            Sum the 15 and 12s to give 111, or "o"
"rldbbb\++++++++"   Push chars to stack
r                   Reverse stack
ld                  Push length of stack and 13, not used
bbb                 Push three 11s

[Line 3]
++&                 Sum the 11s to give 33, or "!" and put in register
~~                  Pop top two
oooo                Print "orld"

[Line 2]
&                   Put "!" from register to stack
o                   Print "!"

[Line 1]
;                   Terminate

Sur une note latérale, voici une tentative amusante de> <> moins d'octets (23 lignes, 47 octets):

v
"
!
d
l
r
o
W

,
o
l
l
e
H
"
/<
l
?
!
;
o
\^

CJam, 5 4 lignes, 162 octets

"Hello
")))))))))))))))))))))))))))))))))))68S\cel
"Wor
")))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))@SX\c|

Même nombre de lignes que l'insomnie! (mais beaucoup plus d'octets)

Essayez-le en ligne .

Explication

"Hello\n"        Push "Hello" and a newline
)                Uncons the newline
)))...)))        Increment the newline into a ","
68S\             Push 68 and a space then swap, leaving 68 on top
c                Convert 68 into a char "D"
el               Lowercase "D" into "d"
"Wor\n"          Push "Wor" and a newline
)                Uncons the newline
)))...)))        Increment the newline into an "l"
@                Rotate top three elements, moving the "d" to the top
SX\              Push a space and 1 then swap, leaving the space on top
c                Convert the space (which is an array) into a char
|                Bitwise or the space (32) with 1 to give "!" (33)    

CJam imprime automatiquement la pile par la suite.

Merci à @Optimizer de m'avoir rappelé que ça Scmarche, car sinon SX|ça échoue (ça fait un setwise ou à la place, en donnant le tableau composé d'un espace et 1).

> <> (Fish) , 5 lignes, plusieurs octets

Le code est extrêmement long, quand je dis [6535529689086686142930090 '+' signs]et [6535529689086686142930090 'd' characters]dans la première ligne du code, je veux dire qu'il y a littéralement des 6535529689086686142930090signes plus dans une rangée!

(Et pour les lignes suivantes, ajoutez les espaces de préfixe nécessaires.)

'[6535529689086686142930090 '+' signs]^`[6535529689086686142930090 'd' characters]
                                   **,/288
                                     -/:o
                             %**288:;?\
                                   (1:\

Une alternative testable plus courte qui imprime uniquement Hi:

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++^`hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
                                                                                                                               **,/288
                                                                                                                                 -/:o
                                                                                                                         %**288:;?\
                                                                                                                               (1:\

Méthode:

• Dans la première ligne, nous créons un nombre énorme représentant la chaîne dans base128.
• Dans le reste des lignes (allant de bas en haut), nous imprimons le caractère suivant dans chaque boucle jusqu'à ce que la valeur de l'entier atteigne 0.
• Le code en boucle est :1(?;:882**%:o-288**,.

(Nous pouvons imprimer une chaîne longue arbitraire de 2+ caractères avec cette méthode.)

PHP (7/17 lignes, 36/59 octets):

En raison du nombre de réponses invalides, j'ai réécrit cette réponse.

La version du navigateur? Disparu.

Mais j'ai 2 solutions, toutes deux basées sur bitwise xor( ^) de chaînes en PHP.

C'est une solution extrêmement puissante! Parfois, cela permet d'économiser beaucoup d'octets.

Tout d'abord, la réponse la plus courte:

Echo
Hello
,AM^mm
,Wor
,OOO^
"#+n
";

Je sais, ça a l'air horrible, mais ça marche!

Le prochain dépend des nouvelles lignes.

Oui, il utilise des sauts de ligne (le \nstyle / UNIX est requis)!

Echo
Bo
.ff
.e
.
"&*]ex
fn
"^
"\n
\n
\n
\n
\n
\n
\n
",B^c
;

Les nouvelles lignes sur celui-ci sont nécessaires pour fonctionner.

Ce n'est pas parfait, mais ça marche!

Les deux réponses étaient basées sur la solution de @ MartinBüttner :

Echo
Hello
.
chr
(44
).
chr
(29
+3
).Wor
.l
.d
."!
";

Un merci spécial à @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , @CJDennis , @ MartinBüttner et @skagedal pour avoir détecté toutes mes erreurs et pour leurs suggestions.

Pyth, 7 lignes, 23 octets

-
"Hello
,
 Wor
l
d
!"b

Assez simple, utilisez simplement une chaîne multiligne et supprimez les retours à la ligne.

Essayez-le ici.

Forth, 41 lignes, 143 octets

Essayez-le en ligne.

Je suis très fier de ça. Je l'ai fouetté assez rapidement une fois que j'ai trouvé que je pouvais le faire, après avoir recherché Google pour les langues insensibles à la casse, et je connais déjà Forth décemment. Il peut presque certainement être raccourci, à la fois en octets et en lignes. Les suggestions sont appréciées. :RÉ

Ce programme pousse essentiellement la valeur décimale de chaque caractère ASCII, puis imprime chacun. J'ai essayé d'optimiser pendant que je l'écrivais, il est donc moins lisible que je ne le souhaiterais.

33
99
1
+
DUp
8
+
2DUp
6
+
SWap
11
+
2OVer
SWap
8
9
*
EMit
1
+
EMit
DUp
DUp
EMit
EMit
3
+
EMit
29
3
2DUp
+
EMit
*
EMit
EMit
EMit
EMit
EMit
EMit

Marbelous, 9 lignes, 94 octets

3333
    @ADD
    358C
++--29\\
++--3555DE
<<<<<<>>~~
+++++446666D
++++++++../\
      ++------

Testez-le en ligne ici. Using spaces for blank cellsdoit être vérifié.

Représentation visuelle de la source:

Explication: Chaque valeur hexadécimale de ce programme se déplace vers le bas à chaque "tick" (sauf si elle est activée \\, auquel cas elle se déplace vers la droite). ++va incrémenter la valeur, --décrémenter, ~~appliquer un pas au niveau du bit, etc. Les valeurs qui tombent du bas sont imprimées sous forme de caractère ASCII.

Par exemple: le 33dans le coin supérieur devient (((0x33 +1 +1) << 1) +1 +1 = 0x6C (l).

Perl, 17 lignes

$_
=
'pr
int
"Hello
,
 Wor
l
d
!"';s
!
!!g
;s
!.
*
!$&
!eex

Rebol - 15 lignes (51 octets)

PRin
AJOin
[
'Hello
Sp 
+
12
Sp
'Wor
'l
'd
Sp
+
1
]

Les mots dans Rebol sont insensibles à la casse (par exemple PRINT, Printet printappellent tous la même fonction).

Le code ci-dessus rangé:

prin ajoin [
    'Hello  sp + 12  sp  'Wor  'l  'd  sp + 1
]

NB. sprenvoie le caractère spatial !

Unaire , 1 ligne, beaucoup d'octets

Chaque personnage de ce programme l'est 0. La source est trop longue pour être insérée ici, mais elle se compose d'une chaîne de ce nombre de zéros:

327380789025192647555922325233404088310881092761595127419003295178342329930050528932118548

Voici la représentation décimale de ce nombre binaire:

0b1010010010010010010010010110000010010010010110000010010000010010010000010010010000010001001001001011111000010000010000011110001111001011111000000100000011011011100010010010010010010010100100010010010100000000100001011100001100010010010100011011011011011011100011011011011011011011011100000000010100

Qui a été créé à partir de ce programme BrainF ***:

++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>-[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.

Voir comment je l'ai généré: http://ideone.com/lMT40p

Lot - 39 lignes (202 octets)

Je voulais réduire la taille en permettant une expansion retardée en exécutant le code à l'intérieur d'un cmdappel à l'aide du /v oncommutateur, mais je n'ai pas pu dépasser tous les carats.

@S^
ET^
LO^
C^
AL^
 EN^
ABL^
E^
DEL^
AY^
E^
DEX^
P^
ANS^
IO^
N
@S^
ET^
 0=Hello
@S^
ET^
 1=^
,^
 Wor
@S^
ET^
 2=l
@S^
ET^
 3=d
@E^
CHO^
 !^
0^
!!1^
!!2^
!!3^
!^^^
!

Sans les sauts de ligne (et carats pour échapper aux sauts de ligne):

@SETLOCAL ENABLEDELAYEDEXPANSION
@SET 0=Hello
@SET 1=, Wor
@SET 2=l
@SET 3=d
@ECHO !0!!1!!2!!3!^^!

Ruby, 19 lignes, 95 octets

$;=
$>
$;<<
:Hello
$;<<
44::chr
$.=
33::
-1
$;<<
$.::chr
$;<<
:Wor
$;<<
:l
$;<<
:d
$;<<
33::chr

Peut-être la deuxième restriction de code la plus difficile pour Ruby que j'ai vue sur ce site, après la monstruosité ici .

Modifier pour explication: La seule méthode de sortie Ruby qui est triée est la <<méthode sur STDOUT. Malheureusement, la constante de STDOUT est $>, et >est ASCII plus élevée que la plupart des symboles, il n'est donc pas vraiment possible d'appeler une méthode dessus. Nous avons besoin d'une instruction d'affectation sur plusieurs lignes pour l'intégrer dans un nom de variable plus traitable $;(le point-virgule est encore assez élevé, mais la plupart des variables de ce formulaire sont soit non assignables, soit uniquement des chaînes).

Les symboles ( :Wor, etc.) sont le moyen le plus simple de faire un littéral, et je ne vois pas de moyen de supprimer les retours à la ligne d'une chaîne, j'ai donc besoin de plusieurs instructions d'impression. L'espace et la ponctuation ne peuvent pas entrer dans un littéral de symbole, mais heureusement, la chrméthode sur les nombres est légale, donc je peux obtenir un caractère de sa valeur ASCII. ::est une autre façon d'appeler les méthodes. L'espace est délicat car je ne peux pas écrire 32, donc je soustrais 1 de 33 et je l'assigne à une variable.

Rétine, 12 lignes, 29 octets (non concurrentes)

La langue est plus récente que le défi.

Hello
$
,
$
 Wor
$
l
$
d
$
!

Essayez-le en ligne