Votre objectif est d'écrire "Hello, World!" (moins les citations). Ceci est un concours de popularité , donc la majorité des votes sont gagnants. La longueur du code sera utilisée pour rompre les liens.
Tout est permis, dans la mesure où il respecte les règles suivantes:

• Tous les caractères doivent être des lettres ou des chiffres, vous ne pouvez donc utiliser que des caractères dans la chaîne "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".
• Tout le code que vous utilisez doit être dans un seul fichier, à l'exception des modules / classes importés / peu importe leur nom, dans votre langue préférée.
• Seules les bibliothèques / infrastructures standard pour la langue de votre choix sont autorisées (par exemple, le module Math de Python est autorisé, mais Numpy, Scipy et Pygame ne le sont pas). Je vais autoriser TkInter car il s’agit du standard de facto pour les interfaces graphiques en Python.
• Aucune saisie n'est autorisée, qu'il s'agisse de lire à partir de stdin, de lire un fichier, de déplacer une image ou de lire sur le Web.

+10 points brownie si vous savez comment le faire en Java sans contourner les règles.

À vos marques, prêts, code!

EDIT: les accolades ({}), les crochets ([]) et les parenthèses (()) sont autorisés car cela serait pratiquement impossible pour la plupart des langues sans eux. Je supprime également la règle de limite de personnage. Espérons que cela le rendra plus intéressant.

EDIT ^ 2: les espaces sont également autorisés. Mon cerveau ne fonctionne pas correctement, désolé. >. <

Perl

Certains disent que perl est une langue pleine de bruit ascii et de symboles aléatoires comme $... Ce n'est pas vrai: P

s zzHelloq worldmz and s zqzchr 44ze and s zmzchr 33ze and print

Divisons cela en sous-expressions:

(s zzHelloq worldmz) and (s zqzchr 44ze) and (s zmzchr 33ze) and (print)

Il devrait être évident qu'il s'exécute de gauche à droite tant que chaque expression retourne vraie. Mais qu'est-ce que c'est s zqzchr 44ze?

En Perl, il y a un groupe de « citation comme les opérateurs » qui comprend q(str), qw(li st), /regex/, s/from/to/entre autres. Il s'avère que tous ces opérateurs peuvent utiliser presque n'importe quel caractère comme délimiteur, avec quelques particularités: la paréthèse d'ouverture doit être fermée par une parenthèse de fermeture correspondante, et si vous souhaitez utiliser une lettre comme délimiteur, vous devez insérer un espace. après la lettre de l’opérateur (pour la dissocier des mots non résolus).

Dans ce cas, nous voyons trois utilisations de l’ s///opérateur (substitution de regex):

s//Helloq worldm/
s/q/chr 44/e
s/m/chr 33/e

Tous délimités par le personnage z. Le /edrapeau sur les deux derniers fait que la substitution doit être interprétée comme un code à évaluer, plutôt qu'un texte littéral.

Un fait assez connu à propos de perl est que la plupart des opérations opèrent par défaut sur la $_variable intégrée, sauf indication contraire. Toutes ces trois substitutions et l' printopération $_dans ce cas, nous avons donc d'abord placé les mots Hello world dans la variable, puis nous avons corrigé la ponctuation en utilisant les valeurs numériques ascii des caractères, puis nous avons imprimé le contenu de la variable.

C

int main(void) {
  if (putchar(72))
    if (putchar(101))
      if (putchar(putchar(108)))
        if (putchar(111))
          if (putchar(44))
            if (putchar(32))
              if (putchar(87))
                if (putchar(111))
                  if (putchar(114))
                    if (putchar(108))
                      if (putchar(100))
                        if (putchar(33)) 
                        {
                        }
}

(Edit - BBC Basic a déplacé la réponse séparée comme suggéré. La plupart des votes à ce sujet sont définitivement pour la réponse LOGO.)

LOGO

Interprète à http://www.calormen.com/jslogo/#

TO h        pd  fd 100 rt  90  pu  fd 50  rt 90  pd  fd 100  rt 180 fd 50  lt 90  fd 50  rt 90  pu END 
TO e        pu  fd 25  rt  90  pd  fd 25  rt 90  arc 270 25  lt 90  fd 25  lt 90  pu END  
TO l        pd  fd 100 pu  END  
TO o        rt  45 fd  35  pd  arc 360 25  lt  45  pu END 
TO comma    pd  rt 90  arc 90  15  lt  90  pu END 
TO w         l  rt 180 l   pd  lt  135 fd  35  rt  90  fd 35  lt 135  l  END  
TO r        pd  fd 25  rt  90  pu  fd  25  rt 180  arc 180 25 rt 90 END 
TO d         o  rt 135 fd  35  lt  135  l  END      
TO exclaim arc 360 5   fd  10  l  END 

clearscreen  
setpencolor 4 pu 
setxy 0 150      h 
setxy 100 150    e  
setxy 200 150    l 
setxy 250 150    l 
setxy 300 150    o 
setxy 350 150    comma  
setpencolor 1 
setxy 0 0        w 
setxy 100 0      o 
setxy 200 0      r  
setxy 300 0      l 
setxy 350 0      d 
setxy 450 0      exclaim 
fd 100

Sortie (le triangle vert est le curseur de la tortue)

Applescript

Pas de crochets [], accolades {}ou parenthèses ()du tout dans celui-ci:

set s to ASCII character 72
set s to s as list
set end of s to ASCII character 101
set end of s to ASCII character 108
set end of s to end of s
set end of s to ASCII character 111
set end of s to ASCII character 44
set end of s to space
set end of s to ASCII character 87
set end of s to item 5 of s
set end of s to ASCII character 114
set end of s to third item of s
set end of s to ASCII character 100
set end of s to ASCII character 33
display dialog s as text

La sortie est:

Frapper

Cette sorte de travail, si vous plisser les yeux:

echo NN i NN i i i iNN NNi i i i i i i NN i NN i i i i i i i NNi i i NN NN
echo NN i NNi i i i NN NN i i i i i i iNN i NN i i i i i i i NN i i iNN NN
echo NN i NN iNNNNi NN NN iNNNNi i i i NN i NN iNNNNi NN NN iNN iNNN NN NN
echo NNNNNNN NN iNN NN NN NN iNN i i i NN i NN NN iNN NNN iN NN NN iNNN N
echo NN i NN NNNNNN NN NN NNi NN i i i NN N NN NNi NN NN i i NN NNi iNN N
echo NN i NN NN i i NN NN NN iNN i i i NNN NNN NN iNN NN i i NN NN i NN
echo NN i NN iNNNi iNN NN iNNNNi N i i NN i NN iNNNNi NN i i NN iNNNN N NN
echo i i i i i i i i i i i i i i N

base64

SGVsbG8sIFdvcmxkIQ

Satisfait les règles d'origine.

Python

Alors quoi, nous supposons juste que tout le monde lit horizontalement? Pour les utilisateurs qui aiment lire verticalement:

print chr(72) 
print chr(101)
print chr(108)
print chr(108)
print chr(111)
print chr(44)
print chr(32)
print chr(87)
print chr(111)
print chr(114)
print chr(108)
print chr(100)
print chr(33)

Polyglotte: HQ9 +, H9 +, HQ9 ++, CHIQRSX9 +, HQ9 + B et HQ9 + 2D (1 octet)

H

Merci @victor pour la liste des langues.

OMGROFL

Je suis un grand fan des langues ésotériques. Heureusement, OMGROFL est alphanumérique:

lol iz 72
rofl lol
lol iz 101
rofl lol
lol iz 108
rofl lol
rofl lol
lool iz 111
rofl lool
loool iz 44
rofl loool
loool iz 32
rofl loool
loool iz 87
rofl loool
rofl lool
lool iz 114
rofl lool
rofl lol
lol iz 100
rofl lol
lol iz 33
rofl lol
stfu

La izcommande définit une valeur sur une variable, dans ce cas lol, loolet looolsert de variable ...

La roflcommande renvoie l'équivalent ASCII au nombre stocké dans la variable.

La stfucommande termine le programme;)

COBOL

   ID DIVISION 
   DATA DIVISION 
   01  HELLOWORLDBINARY 
       05  HE                       COMP    PIC 9999 
       05  LL                       COMP    PIC 9999 
       05  OCOMMA                   COMP    PIC 9999 
       05  SPACEW                   COMP    PIC 9999 
       05  ORTEXT                   COMP    PIC 9999 
       05  LD                       COMP    PIC 9999 
       05  EXCLAMATION              COMP    PIC 9999 
   01  FILLER REDEFINES HELLOWORLDBINARY 
       05  HELLOWORLDTEXT                   PIC XXXXXXXXXXXXX
       05  FILLER                           PIC X 
   PROCEDURE DIVISION 
       MOVE 51333                   TO HE 
       MOVE 37779                   TO LL 
       MOVE 38507                   TO OCOMMA 
       MOVE 16614                   TO SPACEW 
       MOVE 38553                   TO ORTEXT 
       MOVE 37764                   TO LD 
       MOVE 23104                   TO EXCLAMATION 
       DISPLAY HELLOWORLDTEXT 
       GOBACK 

Quelques modifications nécessaires pour devenir une source véritablement alphanumérique uniquement.

PROGRAM-ID peut être supprimé. Vous obtenez un nom de programme généré (voir les messages).

WORKING-STORAGE peut être abandonné. Encore une fois, le compilateur gémit.

Étant donné que les deux lignes précédemment manquaient de points / points manquants, qui ne sont plus pertinents maintenant que les descriptions sont totalement manquantes, le nombre de messages d'erreur est le même qu'auparavant et n'affecte toujours pas le code généré pour le programme.

En remplaçant COMP-5 par COMP, les clauses VALUE ne sont plus autorisées, car COMP 9999 ne comporte que quatre chiffres décimaux, tandis que COMP-5 est un fichier binaire à deux octets avec toutes les valeurs de bits disponibles.

Les valeurs dans les MOVE sont les valeurs décimales qui donnent les valeurs binaires qui donnent les paires de caractères.

Même si les champs COMP comportent quatre chiffres et n'autorisent pas les clauses VALUE comportant plus de quatre chiffres, vous pouvez utiliser plus de chiffres dans le déplacement d'une valeur littérale sans troncature à ce stade ... ne me demandez pas pourquoi. L'option du compilateur DIAGTRUNC (que j'ai désactivée) produira des diagnostics d'avertissement pour ceux-ci.

L'option de compilation TRUNC (BIN) peut être utilisée pour traiter COMP comme COMP-5, mais les MOVE sont un autre moyen de le faire.

Comme il s'agit de COBOL, la sortie doit être en majuscule (un mensonge, mais juste pour le fun).

HELLO WORLD!

OK, cédé, produit maintenant:

Hello, World!

Qui, étant un nombre impair de caractères, a nécessité quelques modifications supplémentaires, car nous ne pouvons pas avoir de champs binaires avec un nombre impair avec ce compilateur. Regardez cette ligne de 13 X! Ce serait normalement écrit comme X (13), mais peut être comme je l'ai montré ...

Et ORTEXT est nécessaire (ou pas OR, de toute façon) comme nom car OR est un mot réservé au compilateur (cela signifie OU, bien sûr).

Il s’agit de valeurs EBCDIC et non ASCII, car il s’exécute sur une boîte compatible EBCDIC et Big Endian.

Oh, COBOL nécessite beaucoup de points / périodes. Je les ai laissés de côté (ils sont bannis) donc j'ai reçu beaucoup de messages de compilation. Je viens de dire au compilateur de générer le code de toute façon (aucun des messages ne concerne le code de l'objet).

Même sans DIAGTRUNC, les messages sont maintenant à 17 ...

  1  IGYDS1003-E   A "PROGRAM-ID" paragraph was not found. 
  Program-name "CBLNAM01" was assumed. 

  2  IGYDS1082-E   A period was required.  A period was assumed 
  before "DATA". 

  3  IGYDS1082-E   A period was required.  A period was assumed 
  before "01". 

                   Same message on line:     11 

  3  IGYDS1040-E   A data item was found in the "DATA DIVISION" 
                   before a section header was encountered. 
                   "WORKING-STORAGE SECTION" was assumed. 

  4  IGYDS1082-E   A period was required.  A period was assumed 
  before "05". 

                   Same message on line:      5      6      7      8
                   9     10     12     13 

 14  IGYDS1082-E   A period was required.  A period was assumed 
 before "PROCEDURE". 

 15  IGYPS2145-E   A period was required.  A period was assumed 
 before "MOVE". 

 23  IGYSC1082-E   A period was required.  A period was assumed 
 before "END OF PROGRAM". 

Ruby (n'utilisant que des alnums et des espaces)

putc 72
putc 101
putc 108
putc 108
putc 111
putc 44
putc 32
putc 87
putc 111
putc 114
putc 108
putc 100
putc 33

Sortie: Hello, World!

Javascript

with (function SGVsbG8sIFdvcmxkIQ(){}) atob(name)

Utilisez la console du navigateur pour tester.

JavaScript

with (String) with ([]) {
    push(fromCharCode(72))
    push(fromCharCode(101))
    push(fromCharCode(108))
    push(fromCharCode(108))
    push(fromCharCode(111))
    push(fromCharCode(44))
    push(fromCharCode(32))
    push(fromCharCode(87))
    push(fromCharCode(111))
    push(fromCharCode(114))
    push(fromCharCode(108))
    push(fromCharCode(100))
    push(fromCharCode(33))
    alert(join([]))
}

ferNANDo

h E R
e I S
h E
l L O
w O
r L
d U S
i N G
o N L
y L E
t T E
r S

H e L L o W O R
L d h E L l O w
O r l D h e L L
O w o R l d H E
L l o W o r l d
H E l L o w O R
L D h E L L O W
O r L d H e l l
O w o R l d h e
L l o w O R l D
H e l L o w O R
L d h E L l O W
O R l D H E L l
O w O
r L d

Rebol

Seule solution alphanumérique:

prin quote Hello prin add space 12 prin space prin quote World print add space 1

Ci-dessus est une mise à jour qui utilise le Dr Rebmu excellente suggestion de add space 1(qui produit !) pour obtenir tous les caractères.

Ci-dessous la version originale:

prin quote Hello prin pick mold system 264 prin space prin quote World print pick mold system 12

Version plus courte avec crochets:

print rejoin [quote Hello pick mold system 264 space quote World pick mold system 12] 

Et même version plus courte avec des accolades:

print join {Hello} join pick mold system 264 join { World} pick mold system 12

Et la version la plus courte avec les deux supports et accolades:

print rejoin [{Hello} pick mold system 264 { World} pick mold system 12]

Rebol utilise des accolades {}pour les devis multilignes. Tellement valide sous les changements de règles mais pas tout à fait dans l’esprit (IMHO) comme mes deux premières réponses ci-dessus.

NB L'impression !était pénible!

Rebol autorise et utilise régulièrement des caractères de ponctuation pour les noms de fonction et les types de données. Ainsi, des options telles que to-char 33ou to char! 33non autorisées par les règles (même si ces ponctuations ne sont pas des opérateurs en soi).

Heureusement, j’ai trouvé un moyen effronté en transformant l’objet système Rebol: make object! [...]en une chaîne que l’on choisit comme point de !départ :)

Mise à jour: Et maintenant, choisissez aussi une virgule dans le texte de licence de l'objet système.

C

Utilise uniquement des caractères alphanumériques, des espaces et des accolades {}, des crochets [] et des parenthèses ().

main()
{
        if(printf((long long []){0x202c6f6c6c6548}))
                if(printf((long long []){0x21646c726f57})){}
}

printf () accepte un caractère * comme argument, mais comme nous ne pouvons pas utiliser de guillemets ("), je transtype la chaîne sous la forme d'un tableau long-long. Les valeurs observées ici sont des chaînes ASCII, en little endian (0x48 = H, 0x65 = e, 0x6c = l, etc.) Je transtype le texte en long long [], car je peux ainsi passer un argument de 8 octets et utiliser uniquement deux appels printf () au lieu de quatre.

BBC BASIC

Emulator sur bbcbasic.co.uk

Séparer de ma réponse au LOGO.

Le moyen facile

Les chiffres à droite ne sont que des codes ASCII. Ceci est identique à l'impression. Si on me permettait une virgule je pourrais le faire sur une seule ligne ( VDU 72,101,108,etc.)

   10 VDU 72
   20 VDU 101
   30 VDU 108
   40 VDU 108
   50 VDU 111
   55 VDU 44
   60 VDU 32
   70 VDU 87
   80 VDU 111
   90 VDU 114
  100 VDU 108
  110 VDU 100
  120 VDU 33

Une manière plus créative

    5 MODE 6
   10 READ B
   12 WHILE B
   15   PROC1(B)
   16   PRINT
   17   READ B
   18 ENDWHILE
   20 END

REM procedure prints first square on line, 
REM then calls itself recursively with A DIV 2 to print the next
REM VDU 17 tell VDU controller we want to change colour
REM Next line changes background colour. 
REM Then following line VDU 32 prints a space in that background colour.

  110 DEFPROC1(A)
  115 VDU 17
  120 IF A AND 1 THEN VDU VPOS DIV 6 EOR 133 ELSE VDU 128
  125 VDU 32
  130 IF A THEN PROC1(A DIV2)
  140 ENDPROC

REM binary bitmap data for each row, least significant at left
  150 DATA 463221
  160 DATA 332053
  170 DATA 332151
  180 DATA 332053
  190 DATA 2586485
  200 DATA 1048576
  210 DATA 4395895
  220 DATA 4527447
  230 DATA 4526935
  240 DATA 333143
  250 DATA 4420981
  260 DATA 0

Mathematica

Unprotect[Times]
ClearAll[Times]
Print[Hello FromCharacterCode[44] world FromCharacterCode[33]]

DC

DC est à peu près l'outil idéal pour ce travail.

5735816763073854918203775149089P

La commande de Pcontrôleurs de domaine extrait un numéro de la pile et envoie sa représentation informatique brute à STDIO. See as 5735816763073854918203775149089 = 0x48656C6C6F2C20576F726C6421, qui est représenté comme 0x21, 0x64, 0x6C... = 'H', 'e', 'l'...dans une architecture little-endian, il génère Hello, World!.

JavaScript!

Et ils ont dit que cela ne pouvait pas être fait ... Pas d'opérateurs d'affectation, pas de concaténateurs, pas de guillemets! Arghhhh!

Ne crains pas ... Car la force c'est withtoi ...

function w(x){
    with(document){
        with(String){
            write(fromCharCode(x))
        }
    }
}
w(72)
w(101)
w(108)
w(108)
w(111)
w(44)
w(32)
w(87)
w(111)
w(114)
w(108)
w(100)
w(33)

Output (on browser screen): Hello, World!

Javascript

Mise à jour: Géré pour couper un tas de caractères en introduisant une fonction World.

Une autre solution Javascript qui écrit sur console.log:

function World() { with (World) return name }
function Hello() {}
with (console)
with (String)
with (Hello)
with (name)
with (concat(fromCharCode(44)))
with (concat(fromCharCode(32)))
with (concat(World()))
log(concat(fromCharCode(33)))

Inspiré par cette entrée .

Premièrement, je définis des fonctions nommées Hello et World. Cela sera utilisé plus tard.

Ensuite, je commence ma chaîne de fichiers imbriqués. Les with (console)et with (String)sont utilisés pour que je puisse ultérieurement invoquer console.loget String.fromCharCodesans utiliser de point.

Le plan est maintenant de construire la chaîne Hello, World!en abusant des imbriqués avec. Chaque fois que j'appellerai concat (), la chaîne résultante sera le contexte du prochain bloc with. Je prends un raccourci pour obtenir rapidement "Hello"en accédant à la namepropriété de la Hellofonction. Ensuite, je concatène les caractères virgule et espace en utilisant String.fromCharCode.

L'astuce suivante consiste à obtenir la "World"partie de la chaîne. Je ne peux pas utiliser la même méthode que j'avais Hello, car je ne peux pas appeler World.name. Au lieu de cela, je mets cette logique dans la méthode World et l'invoque.

Enfin, j’ajoute le dernier point d’exclamation et envoie le résultat directement à la fonction log, qui est bien sûr console.log.

Perl

Dans un Perl moderne (5.10 ou plus récent):

print q{Hello} and print chr 44 and print q{ World} and say chr 33

Dans les anciens Perl:

print q{Hello} and print chr 44 and print q{ World} and print chr 33 and print chr 10

Les deux solutions ci-dessus utilisent un qopérateur de type citation Perl et permettent aux délimiteurs sélectifs de citer une chaîne, par exemple. q{} q[] q() q//

Cette solution nécessite le changement de règle qui autorise les accolades, les crochets ou les parenthèses. Ainsi, bien qu’il soit tout à fait valide, je pense que l’ mniipexcellente réponse de Perl correspond davantage à l’esprit des règles (+1).

Cependant, mniipma solution pourrait prendre la forme suivante:

print q xHellox and print chr 44 and print q x Worldx and say chr 33

et bien que cela soit plus dur pour les yeux, cela fonctionne.

Perl

print chr hex for qw z48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21z

Python:

import antigravity 

provoque "Bonjour, le monde!" apparaître sur votre écran. Ne me crois pas? Essayez vous-même! En outre, cela n'utilise pas réellement le Web, il ouvre un navigateur, qui pourrait rechercher un site Web.

dc, (26 octets pour les golfeurs)

Les espaces et les []crochets sont maintenant autorisés:

[Hello]n44P[ World]n33P[]p

Sortie:

$ dc <<< "[Hello]n44P[ World]n33P[]p"
Hello, World!
$ 

Rebmu , 46 caractères

pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01pnADsp01

Fortement parallèle à la solution de @ dragetun dans Rebol (Rebmu étant un outil pédagogique Rebol / Red qui est un "dialecte" qui vise à attirer l'attention sur les langues en basculant sur Code Golf. :-P)

Cependant, pour obtenir les personnages manquants, j'ai fait quelque chose de plus évident. Je viens d'ajouter l'espace, au lieu d'aller chercher dans les chaînes du système. Vous pouvez obtenir un espace supplémentaire 1 pour obtenir le caractère littéral # "!" et ajoutez un espace 12 pour obtenir le caractère littéral # ",".

Si nous courons cela, nous pouvons le voir devenir "sans ambages":

>> rebmu/debug/stats "pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01prADsp01"
Original Rebmu string was: 46 characters.
Rebmu as mushed Rebol block molds to: 46 characters.
Unmushed Rebmu molds to: 62 characters.
Executing: [pn upp q hello 1 pn ad sp 12 pn sp pn upp q world 1 pr ad sp 1]
Hello, World!

Ce qui est assez logial:

; print with no newline the result of doing an uppercase/part
; on the quoting of the symbolic word hello, of only the first
; N characters (where N is 1)
pn upp q hello 1

; print the character you get when you add 12 to the space
; character literal, a.k.a. comma...again no newline
pn ad sp 12

; print a space, no newline
pn sp

; do the same trick of printing the quoted word hello with the
; first letter converted to uppercase
pn upp q world 1

; print the character you get when you add 1 to the space
; character literal, a.k.a. exclamation point...with newline now
pr ad sp 1

Espace blanc

Ok, nous pouvons utiliser des espaces. Il utilise seulement Space, Tab, LineFeedet ne tient pas compte des autres personnages.

Avec commentaire: S, Tou Lmoyen Space, Tabou LineFeedrespectivement.

S S S T S S T   S S S L
T   L
S S S S S T T   S S T   S T L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T S T T   S S L
T   L
S S S S S T S S S S S L
T   L
S S S S S T T   T   S T T   T   L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T T   T   S S T   S L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S S T   S S L
T   L
S S S S S T S S S S T   L
T   L
S S L
L
L

Avec en surbrillance: http://en.wikipedia.org/wiki/Whitespace_(programming_language)#Sample_code

T-SQL, 52

Ah, c'est mieux! Conversion binaire directe, seulement 52 caractères.

SELECT CAST(0x48656C6C6F2C20576F726C6421 AS VARCHAR)

Précédemment...

Il existe une solution beaucoup plus astucieuse et plus golfeuse qui fonctionnerait si nous pouvions utiliser =et +(Rechercher des données intégrées standard dans msdb et les utiliser pour construire une chaîne de requête exécutable avec EXEC)

Mais puisque nous ne pouvons pas, vous obtenez cette approche naïve:

SELECT CHAR(72)SELECT CHAR(101)SELECT CHAR(108)SELECT CHAR(108)SELECT CHAR(111)SELECT CHAR(44)SELECT CHAR(32)SELECT CHAR(87)SELECT CHAR(111)SELECT CHAR(114)SELECT CHAR(108)SELECT CHAR(100)SELECT CHAR(33)

Python:

Pfff, qui a besoin de la partie numérique de alphanumérique?

from string import lowercase
from string import uppercase
from string import punctuation
print uppercase[len(str([[[len(str())]]]))]
print lowercase[len(str([[]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([[[[[[[]]]]]]]))]
print punctuation[len(str([[[[[len(str())]]]]]))]
print
print uppercase[len(str([[[[[[[[[[[]]]]]]]]]]]))]
print lowercase[len(str([[[[[[[]]]]]]]))]
print lowercase[len(str([[[[[[[[len(str())]]]]]]]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([len(str())]))]
print punctuation[len(str())]

Cela dépend des paramètres régionaux, donc votre kilométrage peut varier. Toutefois, si vous souhaitez vraiment répliquer ce résultat, vous pouvez utiliser les instructions suivantes à la place des instructions d'importation:

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

(cela ne fait pas partie de ma soumission, je partage simplement mes sections locales pour en améliorer le caractère reproductible)

J - 73 caractères

Cela peut être fait, après tout!

72 101 108 108 111 44 32 87 111 114 108 100 33{do 1 8{show 0 def 0
take
)

Voici la chose à propos de J. La plupart des primitives sont la ponctuation ASCII, suivie de deux points ou deux points au maximum. Les primitives qui ne sont pas faites de ponctuation sont un caractère alphanumérique suivi de deux points ou deux points. Donc, nous ne sommes autorisés à rien, sauf pour { } [ ]. [et ]sont des verbes d'identité et sont donc inutiles.

Heureusement, {les tableaux d'index, donc si nous avions, par exemple, une chaîne avec chaque caractère ASCII ( a.appelé Alphabet ), nous pourrions extraire les lettres par leurs points de code ASCII. Nous avons également une méthode de sauvegarde pour créer des chaînes , 0 : 0puis des trucs, puis un seul ); le côlon où possède un alias dans la bibliothèque standard def.

Ensuite, il y a un verbe dans la bibliothèque standard show, qui vous donne la représentation interne d'un verbe si vous lui transmettez le nom sous forme de chaîne. Il y a un autre verbe, doqui va évaluer une chaîne. Donc, si nous pouvons sortir a.d’une telle représentation, nous pouvons l’évaluer et le retirer Hello, World!.

Notre sauveur se présente sous la forme de take, un pseudonyme {.qui a un adans son nom. show'take'reviendra take=: {., alors nous avons notre a.et donc une solution.

Nous pouvons nous en débarrasser {en utilisant l’équivalent pickde la bibliothèque standard, mais le paren à la fin ne peut être évité.