Bonjour le monde le plus court trié

27

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

Loisirs de Calvin
la source
7
Il est un peu tard maintenant, mais je pense que le moins de lignes puis le moins d'octets auraient pu être plus intéressants ...
Sp3000
6
@ Sp3000 Nous aurions besoin d'une mesure combinée, sinon Unary et Lenguage signifieraient que seuls les 1-liners pourraient rivaliser.
isaacg
@ Sp3000 Peut-être, je voulais juste m'assurer que Unary / Lenguage n'était pas susceptible de gagner. Je suis cependant prêt à le changer (désolé isaacg). Commentaire d'Upvote Sp si vous êtes d'accord.
Calvin's Hobbies
@ Sp3000 J'ai suivi vos conseils. Voir les mises à jour.
Calvin's Hobbies
L'ordre peut-il être inversé? Par exemple, lire de gauche à droite?
Ismael Miguel

Réponses:

17

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))
Sp3000
la source
C'était intelligent! +1
theonlygusti
Pourriez-vous utiliser un programme BF plus court, ou le programme est-il construit de manière spécifique pour une raison? J'ai essayé le programme BF que j'ai utilisé dans votre générateur, mais la sortie comprenait un peu de code Unicode.
mbomb007
1
@ mbomb007 Le problème avec les programmes BF plus courts est que même cette méthode naïve se termine au point de code 124, donc je ne pense pas qu'il y ait suffisamment de marge de manœuvre pour introduire de nouveaux caractères ...
Sp3000
30

/// , 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.

Martin Ender
la source
19
Je ne savais même pas que les URL pouvaient contenir autant de barres obliques d'affilée.
Alex A.
4
@AlexA. Il a fallu des mois pour que cette URL fonctionne, IIRC. Nous avons dû continuer à renommer l'article pour gérer les modifications apportées à la configuration du serveur et à la configuration de MediaWiki.
17

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.

kennytm
la source
2
Absolument brillant! Je ne sais pas si c'est possible d'utiliser le même temps de stratégie en Python (il est sensible à la casse).
mbomb007
Très agréable! Notez que cela =Z[3*7]peut être écrit comme =Z[~-22]ayant besoin d'un seul saut de ligne au lieu de deux.
moi et mon chat
@ mbomb007 Oui, mais les espaces sont et ils sont les premiers dans le jeu ASCII ...
Harry Beadle
@meandmycat Merci! Mis à jour.
kennytm
13

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.

n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
la source
11

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.

n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
la source
Je ne sais pas si c'est 17 ou 16 lignes (il y a une nouvelle ligne à la toute fin), mais de toute façon, cela ne gagnera rien.
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
Vous avez gagné 10 votes positifs, c'est déjà beaucoup. Les plus votés (pour l'instant) ont 12 votes positifs! Et la solution /// avec 23 votes positifs.
Ismael Miguel
11

> <> , 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
\^
Sp3000
la source
2
Dans le deuxième code, vous pouvez économiser 2 octets grâce à un
bouclage
10

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

Sp3000
la source
8

> <> (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.)

randomra
la source
Pas une solution valable; 6535529689086686142930090 n'est pas commandé.
theonlygusti
@theonlygusti "Le code est extrêmement long, interpréter [6535529689086686142930090 '+' signs]et [6535529689086686142930090 'd' characters]littéralement dans la première ligne du code." (Si vous ne
savez
Ah d'accord! Désolé, idiot: PI l'a pris au pied de la lettre.
theonlygusti
2
La taille est de 13 YB, soit environ 1000 fois la taille d'Internet.
Charles
@Charles, j'obtiens ~ 40YB, y compris les dernières lignes.
Veedrac
8

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.

Ismael Miguel
la source
1
La sortie dans le navigateur est Hello , Wor l d !. Notez les espaces supplémentaires! Ce n'est malheureusement pas une réponse valable.
CJ Dennis
1
Testé dans Firefox 36, IE 8, Opera 12.17 et Opera 28 (Chromium) sur Windows XP. Tous ont rendu la sortie à l'identique. Étant donné qu'un nombre quelconque de caractères d'espaces sont rendus sous la forme d'un seul caractère espace (sauf espace de pause, etc.), chaque nouvelle ligne est convertie en espace. Je serais intéressé de savoir si un navigateur rend votre sortie sans espaces!
CJ Dennis
1
Bon abus de la langue! Puisque les erreurs qu'il génère techniquement vont à stderr et non à stdout, votre code est maintenant valide même si dans mon cas je vois beaucoup d'erreurs dans mon navigateur! Et, incroyablement pointilleux, ma configuration PHP a des balises courtes désactivées, donc la première ligne de mon ordinateur <?phpest invalide! Cependant, je vous pardonne pour cela! OK, je viens de tester <?Phpce qui fonctionne, donc je viens d'apprendre que la balise de démarrage est insensible à la casse!
CJ Dennis
1
Les deux principales solutions de cette réponse ne respectent pas les règles. Celui du haut a, comme ligne 8,. "!<br- ce n'est pas trié. Le second a comme ligne 10: ."!- non trié.
skagedal
1
@IsmaelMiguel Je suis désolé, mais non. La ligne 7 de la première suggestion n'est pas triée. Les lignes 5 et 7 de la deuxième suggestion ne sont pas triées.
skagedal
7

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.

isaacg
la source
@orlp J'ai ajouté des chaînes multilignes il y a quelques jours, et Pyth a pris en charge les sauts de ligne dans l'entrée depuis des lustres. Cela n'utilise pas du tout le mode multiligne. Essayez-le sur le compilateur en ligne, qui n'a certainement pas de mode multiligne.
isaacg
2
C'est presque la même chose dans CJam, avec le même nombre d'octets aussi.
Optimizer
4

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
mbomb007
la source
Les Emitlignes ne fonctionnent pas, car i(105) est inférieur à m(109).
bcsb1001
Ce devrait être "EMit", alors?
skagedal
4

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:

Représentation visuelle de la source ci-dessus

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

es1024
la source
2

Perl, 17 lignes

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

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 !

draegtun
la source
Votre programme n'est pas valide, {il ne peut pas être précédé de lettres.
theonlygusti
@theonlygusti - Corrigé (passé de 9 lignes à 13). La seule ligne qui m'a causé un problème était {,}. C'est maintenant Sp + 12(sur 3 lignes) qui équivaut à un espace + 12 (c'est-à-dire une virgule)
draegtun
2

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

mbomb007
la source
2

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!^^!
dégrader
la source
1

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.

histocrate
la source
0

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

mbomb007
la source