Bonjour le monde 0.0!

78

Dilbert est génial
source: Dilbert, 8 septembre 1992

J'espère ajouter une nouvelle tournure au classique "Hello World!" programme.

Coder un programme qui sort Hello World!sans:

  • Littéraux chaîne / caractère
  • Numéros (toute base)
  • Fonctions prédéfinies qui renvoient "Hello World!"
  • RegEx littéraux

À l'exception de "O" et 0.

† "O" est en majuscule, "o" n'est pas acceptable.

zzzzBov
la source
4
Un de [code-golf] et [code-challenge] s'il vous plaît, pas les deux. L'objectif de ces balises est d'aider les gens à trouver des questions avec les règles qu'ils souhaitent utiliser. Essentiellement, chaque question sur ce site devrait être un jeu d’un genre ou d’un autre.
dmckee
4
-1 Nous avons déjà eu Hello World Obfuscated , et je pense que ce défi est trop similaire. J'aurais voté comme un doublon si je n'étais pas un mod.
Chris Jester-Young
2
@zzzzBov: Je ne pense pas que ce soit suffisamment différent pour justifier une autre question dans le thème "hello world"; un thème différent aurait été mieux. Mais c'est juste mon opinion.
Chris Jester-Young
1
Je pense que c'est un bon code de golf - et meilleur que le précédent.
MtnViewMark
2
Certaines personnes semblent supposer que cela "O"*signifie qu'elles peuvent avoir un littéral de chaîne avec un nombre quelconque de 0, y compris zéro. Je ne pense pas que c'était l'intention. Précisez s'il vous plaît.
Timwi

Réponses:

83

Windows PowerShell, beaucoup trop

Oui, en effet, à l'époque, nous devions écrire un "Hello world" en utilisant (presque exclusivement) des zéros ...

&{-join[char[]]($args|% Length)} `
O00000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000

Sur une note plus sérieuse:

Windows PowerShell, 25

Write-Host Hello World!

Pas de chaîne littérale. Il Hello World!se trouve que la chaîne in est analysée comme une chaîne, car PowerShell est en mode d’analyse des arguments.

Joey
la source
2
Comment est-ce réel ?? O_o
Josh
1
J'ai cherché sur Internet quelques exemples ou une histoire de cela. Cela est tellement bizarre. Pourriez-vous fournir des liens?
Caleb Jares
1
"A l'époque". :) Vous les millennials craquer moi
Oh. Unaire. J'ai compris.
Matthew Roh
86

C, 327 caractères

#define O(O)-~O
#define OO(o)O(O(o))
#define Oo(o)OO(OO(o))
#define oO(o)Oo(Oo(o))
#define oo(o)oO(oO(o))
#define O0 putchar
main() {
    O0(OO(oO(!O0(~O(Oo(OO(-O0(~O(Oo(-O0(O(OO(O0(oo(oO(O0(O(oo(oO(OO(Oo(oo(oO(
    O0(oo(oo(!O0(O(OO(O0(O0(O(OO(Oo(O0(O(Oo(oo(oO(O0(oo(oo(oO(oo(oo(0))))))))
    ))))))))))))))))))))))))))))))))))))));
}

Étrangement, il ne perd pas sa beauté après le prétraitement:

main() {
putchar(-~-~-~-~-~-~-~-~-~-~!putchar(~-~-~-~-~-~-~-~-putchar(~-~-~-~-~-~-
putchar(-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~!putchar(-~-~-~putchar(putchar(-~-~-~-~-~-~-~putchar
(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0))))))))))));
}
Ugoren
la source
2
Impressionnant. Manquer le!
Mark Reed
1
C'est du vrai art!
Askaga
Je sens que le corps pourrait être raccourci avec encore plus de pré-processeurs. Je ne sais pas si le code dans son ensemble serait bénéfique.
Zwei
@Zwei, il est certainement possible de le raccourcir. Je n’ai fait aucun effort pour trouver l’ensemble optimal de macros.
Ugoren
Pourquoi n'incluez-vous pas les parens dans CLANG #define? économiserait quelques octets, non? Edit: tant pis, juste essayé et maintenant je vois pourquoi cela ne fonctionnera pas ahaha
Albert Renshaw
52

BrainFuck, 102 111 caractères

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

Répond à toutes les règles.

Le mérite en revient à Daniel Cristofani .

Kevin Brown
la source
1
Je ne peux pas décider si les règles doivent également être énoncées 0 and/or "O" must be used. C'est un peu méchant pour BrainFuck et Golfscript, mais ils n'ont pas vraiment de difficulté avec ce défi.
zzzzBov
35
@zzzzBov: S'ils doivent être utilisés, le code Brainfuck les inclura simplement. Cependant, ils n’affectent pas le programme.
Joey
38

C, 182 octets

#define decode(c,o,d,e,g,O,l,f) e##c##d##o
#define HelloWorld decode(a,n,i,m,a,t,e,d)
#define Puzzles(flog) #flog
#define CodeGolf Puzzles(Hello World!)
HelloWorld(){puts(CodeGolf);}
FRODDY
la source
1
+1, Lol, vous utilisez toujours le tour opérateur de collage de jetons! Nice mate :-)
Quixotic
35

Programme C - 45

(La triche)

Lexicalement, cela n’utilise pas de littéraux de chaîne ni de littéraux de regex. Il tire parti de la fonction de stringification du préprocesseur C. s(x)est une macro qui transforme son argument en une chaîne.

#define s(x)#x
main(){puts(s(Hello World!));}
Joey Adams
la source
3
Pour une notion très pratique de "lexicalement" :) Mais fadouille FTW!
JB
24

Haskell - 143 caractères

o%y=o.o.o$y;o&y=(o%)%y;o!y=o$o$(o%)&y
r=succ;w=pred;a=r%y;e=r$w&l;l=r!'O';o=r e;u=(w&)&a;y=r%l
main=putStrLn[w!o,o,l,l,y,w u,w$r&'O',y,a,l,e,u]

oy, c'était laineux!

Pas de chiffres, pas d'opérations numériques, variables renommées pour l'amusement.

Certaines expositions pourraient être sympas:

  • o%y,, o&yet o!ychacun applique la fonction oà yplusieurs fois: 3, 9 et 29 fois respectivement. 29?!?! Oui, 29 ans!
  • ret wsont les caractères suivant et précédent, qui, lorsqu'ils sont appliqués à l'aide des fonctions d'ordre supérieur ci-dessus, peuvent être configurés pour obtenir tous les caractères nécessaires 'O'.

La séquence de sauts nécessaire est la suivante:

'O' +29    -> 'l'
'O'  +9 -1 -> 'W'
'l'  -9 +1 -> 'd'
'l'  +3    -> 'o'
'd'  +1    -> 'e'
'o'  +3    -> 'r'
'e' -29    -> 'H'
'r' -81    -> '!'
'!'  -1    -> ' '

  • Edit: (134 -> 144) Oubli de générer un point d'exclamation, soupir ....
  • Edit: (144 -> 143) Suppression d'un inutile $, renommé #en !Hugs.
MtnViewMark
la source
1
o rly? oo ....
Joey Adams
Ça ne marche pas codepad.org/lyKyj1Ox
nyuszika7h
@ Nyuszika7H C'est parce que ce service active certaines options du compilateur par défaut. Il devrait compiler avec GHC simple.
FUZxxl
@ Nyuszika7H Cela fonctionne très bien avec GHC. Le problème est que ce service utilise Hugs depuis 2006. Il semble y avoir deux choses que Hugs ne peut pas gérer: 1) Utiliser '#' en tant qu'opérateur. Passer à "!" ça marche. 2) Les définitions r=succet w=predaller à l' encontre de la façon dont étreintes met en œuvre la restriction de monomorphisme. Changer r x=succ xet le w x=pred xfaire fonctionner (au prix de 4 caractères). Ceux-ci semblent être des problèmes dans Hugs.
MtnViewMark
Est-il toujours valide après la modification de @Community?
Hosch250
22

Unary , 10 197 1137672766964589547169964037018563746793726105983919528073581559828 octets

Je suis surpris que personne ne l'ait encore fait ...

C'est trop long de poster ici, mais c'est 1137672766964589547169964037018563746793726105983919528073581559828 zéros.

Ou, plus facilement, lisez: ~ 10 67 zéros.

Merci à @dzaima pour avoir économisé 10 197 octets

Beta Decay
la source
2
Quand j'ai lu "une fois, j'ai écrit toute une base de données en utilisant seulement des zéros", ma première pensée a été "il doit l'avoir fait de manière unaire". +1 pour être la seule réponse pour travailler exactement comme le comique
Cyoce
21

Mathematica 12 caractères

Seuls les symboles, pas de chaînes.

Hello World!   

Le ! est un opérateur factoriel, mais comme les symboles Hello et World ne sont pas définis, retourne l’entrée inchangée.

Si on modifie un peu le programme:

Hello=2;
World=3;
Hello World!  

Ensuite, il imprime 12(2 * 3!)

Dr. belisarius
la source
16

assemblage i386 (Linux, syntaxe gcc), 440 442 435

Aujourd'hui, c'est mon jour d'assemblée, et après j'en aurai assez pendant un moment. Je me suis permis le numéro 128, voir ci-dessous le programme pour discuter de pourquoi. Rien d'extraordinaire: je suis juste en train d'encoder "Hello World!" en tant qu'opodes d'assemblage où cela avait un sens sans constantes numériques et complétait le reste avec de l'arithmétique.

#define M mov
M $0,%ecx;inc %cx;M %ecx,%ebx;inc %cx;M %ecx,%eax;add %ax,%ax
M %ecx,%edx;shl %cl,%dx;M (e),%ch;add %dl,%ch;dec %ch;M %ch,(l)
M %ch,(j);M %ch,(z);M $0,%ch;shl %cl,%edx;M %dl,(s);inc %dl
M %dl,(b);M (o),%dl;M %dl,(u);add %al,%dl;dec %dl;M %dl,(r)
M $m,%ecx;M $n,%edx;int $c;M %ebx,%eax;M $0,%ebx;int $c
.data
m:dec %eax;e:gs;l:es;j:es;o:outsl (%esi),(%dx)
s:es;push %edi;u:es;r:es;z:es;fs;b:es;n=.-m
t=(n+n)/n;c=t<<(t*t+t)

(assembler avec gcc -nostartfiles hello.S -o hello, éventuellement en -m32fonction de votre arcade)

Pourquoi la tolérance pour 128? J'ai besoin d'appels système pour montrer quoi que ce soit; Les appels système Linux sont sur INT 80h (128 décimales); le seul format d'opérande pour INT est immédiat, il n'est donc pas possible d'y avoir autre chose qu'une constante (du code). Je pourrais (après que je sois sobre) essayer de l'exprimer en fonction d'autres constantes symboliques du code, probablement n , mais cela devient très ennuyeux pour un gain minime. J'ai lu la contrainte sur les chiffres comme un moyen d'empêcher le codage ASCII, et ce n'est certainement pas ce que je fais ici, alors je me sens suffisamment innocent pour le soumettre. (FWIW, j'ai aussi essayé d'auto-modifier le code, mais celui-ci est défectueux) Il ne reste plus 128 maintenant. Le code est pur!

  • Edit1 reformaté pour sauvegarder les lignes; enlevé un 1 numérique (personne n'a remarqué?!)
  • Edit2 compressé movavec des macros CPP; éliminé les 128 restants.
JB
la source
6
C'est comme ça que les vrais hommes programment.
Nit
14

Javascript - 305

Un peu long mais j'aime bien la méthode utilisée.

O=0;O++;O=O.toString();alert([O+0+0+O+0+0+0,0+O+O+0+0+O+0+O,O+O+0+O+O+0+0,O+O+0+O+O+0+0,O+O+0+O+O+O+O,O+0+0+0+0+0,O+0+O+0+O+O+O,O+O+0+O+O+O+O, O+O+O+0+0+O+0,O+O+0+O+O+0+0,O+O+0+0+O+0+0,O+0+0+0+0+O].map(function(e){O=0;O++;O++;return String.fromCharCode(parseInt(e,O))}).reduce(function (a,b){return a+b}))
david4dev
la source
Je l'aime. Il serait mieux avec les paramètres de la fonction que OO, OOOmais bien sûr , qui rendraient plus.
zzzzBov
Vraiment sympa. Est-ce que le ', new String ()' doit être présent à la fin? Cela semble fonctionner sans elle.
Stephen Perelson
3
Ah non non. Parfois, j'oublie à quel point le javascript typé est faible.
david4dev
Vous n'avez pas besoin non plus de bits restants ('0+'), et l'espace et l'exclamation ont deux bits restants. Réduction totale de 28 caractères.
Stephen Perelson
10

C # (131 caractères)

141 caractères 142 caractères

enum X{Hello,World,A,B=A<<A<<A}class Y{static void Main(){var c=(char)X.B;System.Console.Write(X.Hello.ToString()+c+++X.World+c);}}

Lisible:

// Define some constants (B = 32)
enum X { Hello, World, A, B = A << A << A }
class Y
{
    static void Main()
    {
        // Generate the space (character #32)
        var c = (char) X.B;

        // Remember that “!” is character #33
        System.Console.Write(X.Hello.ToString() + c++ + X.World + c);
    }
}
Timwi
la source
2
c'est tordu et gentil. J'aime cela.
Jcolebrand
+1 bon moyen de générer certains nombres. Je dois m'en souvenir!
Igby Largeman le
Programme LINQPad, 102 caractères:enum X{Hello,World,A,B=A<<A<<A}void Main(){var c=(char)X.B;(X.Hello.ToString()+c+++X.World+c).Dump();}
Cœur le
.ToString()-> +""sauve des cahrs
Firo
2
@Firo: ... et enfreint les règles. (Aucune chaîne de caractères autorisée.)
Timwi
8

JavaScript, 88

t=!0<<-~-~-~-~!0
r=[]
for(i in{Hello:"O",World:0})r+=i+String.fromCharCode(t++)
alert(r)

99

Merci à @ Timwi pour les suggestions

opérateur ternaire retiré:

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
r=c(0)
for(i in o)r+=i+c(t++)
alert(r)

103
aliasString.fromCharCode

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
for(i in o)o[i]?r=i+c(t):alert(r+i+c(++t))

117
Basculé si-sinon sur opérateur ternaire

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)o[i]?r=i+String.fromCharCode(t):alert(r+i+String.fromCharCode(++t))

125
Je garde "O"juste le droit d'avoir un "O" dans le programme.

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else alert(r+i+String.fromCharCode(++t))

133

o={Hello:"O",World:0},t=!0<<(!0+!0<<!0)+!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else r+=i+String.fromCharCode(t+!0)
alert(r)
zzzzBov
la source
@ Joey, c'est en grande partie le but.
zzzzBov
@ Joey, j'ai lu sur la méta de codegolf qu'il fallait éviter de répondre à leur propre question pendant un certain temps pour encourager les autres à essayer différentes approches. Mon plan était de ne pas commenter dans un jour ou deux.
zzzzBov
@ Joey, ne travaillait pas sur ma propre machine à l'époque, et je n'avais pas envie de m'envoyer la réponse par courrier électronique alors que je pouvais simplement la poster dans un commentaire.
zzzzBov
@ Joey: "Il n'y a que cinq d'entre eux" est faux. Tout le monde peut suggérer une modification. Il suffit de cliquer sur "modifier" entre "lien" et "drapeau" et vous pouvez voir le code.
John
@zzz: "c'est en grande partie le point" Tout le monde peut toujours le voir. Tout le monde peut suggérer une modification en cliquant sur "modifier" entre "lien" et "drapeau", ce qui fera apparaître la boîte de dialogue de modification, révélant votre code.
John
7

GolfScript, 63 caractères

[0))):O.)?O.*-.O.?+)).O.*+((..O+.O(.O+?.O-O*@.O+O.+$.O.*-).O/]+

Quoi, pas encore d'entrée GolfScript?

Celui-ci utilise un seul littéral numérique 0et une variable nommée O(utilisée pour stocker le nombre 3). Tout le reste est arithmétique et manipulation de pile. La chaîne Hello World!est construite à partir de ses codes ASCII, caractère par caractère.

Voilà comment cela fonctionne:

[             # insert start-of-array marker
  0))):O      # increment 0 thrice to get 3, and save it in the variable O
  .)?O.*-     # calculate 3^(3+1) - 3*3 = 81 - 9 = 72 = "H" 
  .O.?+))     # calculate 72 + 3^3 + 1 + 1 = 72 + 27 + 2 = 101 = "e"
  .O.*+((     # calculate 101 + 3*3 - 1 - 1 = 101 + 9 - 2 = 108 = "l"
  .           # ...and duplicate it for another "l"
  .O+         # calculate 108 + 3 = 111 = "o"
  .           # ...and duplicate it for later use
  O(.O+?      # calculate (3-1)^(3-1+3) = 2^5 = 32 = " "
  .O-O*       # calculate (32 - 3) * 3 = 29 * 3 = 87 = "W"
  @           # pull the second 111 = "o" to the top of the stack
  .O+         # calculate 111 + 3 = 114 = "r"
  O.+$        # copy the (3+3 = 6)th last element on the stack, 108 = "l", to top
  .O.*-)      # calculate 108 - (3*3) + 1 = 108 - 9 + 1 = 100 = "d"
  .O/         # calculate int(100 / 3) = 33 = "!"
]             # collect everything after the [ into an array
+             # stringify the array by appending it to the input string
Ilmari Karonen
la source
7

Brainfuck, 111 octets

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

Algorithme expliqué

Increment cell 0 to 10 (it will be loop counter)
Repeat 10 times ; will stop at cell 0
  Increment cell 1 to 7
  Increment cell 2 to 10
  Increment cell 3 to 3
  Increment cell 4 to 1
Increment cell 1 by 2 and output it ; Thus, output ASCII 72 'H'
etc. for all symbols in 'Hello World!'

Version plus longue sans boucle, 389 octets:

+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+++++++++++++++++
++++++++++++.+++++++..+++.-------------------
---------------------------------------------
---------------.+++++++++++++++++++++++++++++
++++++++++++++++++++++++++.++++++++++++++++++
++++++.+++.------.--------.------------------
---------------------------------------------
----.-----------------------.
Michael
la source
C’est un casse-tête code-golf, le but est de faire le programme le plus court possible. Cela implique en partie l'affichage de la longueur de votre code.
zzzzBov
5

Lua 144 97 86 caractères

Une approche différente, basée sur le fait que les clés de table sont également des chaînes et sur le fait que #Hello == #World == 32 == string.byte '\ n'

e=#"O"t=e+e for k,v in pairs{Hello=0,World=e}do T=t^#k io.write(k,string.char(T+v))end

Solution de 145 caractères

  • pas de chaînes sauf "O" ou 0
  • pas de regex
  • pas de fonctions prédéfinies

Est-ce que l'encodage delta des octets, puis quelques primers, etc etc :)

Version golfée:

e=#"O"d=e+e t=d+e v=d+t z=v+t T=t^d*d^t n=0 for l,m in pairs{T,T/t-z,z,0,d,-T-z,z*z+t*d,T/d,d,-d*t,-t^d,-T+v}do n=n+m io.write(string.char(n))end

Commenté:

-- without numbers, strings, regex
-- except "O" and 0
e=#"0"
t=e+e --2
d=t+e -- 3
v=d+t -- 5
z=v+t -- 7
n=0
T=t^d*d^t -- 72 = 2^3+3^2
for l,m in pairs{T, --72
T/t-z, -- 29 = 72/2-7
z, --7
0, -- 0
d, -- 3
-T-z, -- -79 = -72 - 7
z*z+t*d, -- 55 = 7*7 + 2*3
T/d, -- 24 = 72/3
d, -- 3
-d*t, -- -6
-t^d, -- -8
-T+v -- -67 = -72+5
} do
    n=n+q[k]
    io.write(string.char(n))
end

Edit: Modifié plusieurs chaînes en O et trouvé quelques optimisations supplémentaires.

jpjacobs
la source
"O" * - Je pense que le * était pour la note de bas de page, pas "n'importe quel nombre de O
RomanSt
Bien, la regex est ce que je fais naturellement: p. Pourrait le remplacer au prix de 5 ou 3 caractères supplémentaires pour respectivement la première et la deuxième solution
jpjacobs
Quoi qu'il en soit, je vais les éditer, merci pour le heads-up
jpjacobs
Hello et World in constructeur de table sont toujours des chaînes de caractères - ce n'est qu'un sucre syntatique.
Oleg V. Volkov
5

Python ( 126 130)

O=ord("O")
N=O/O
T=N+N
R=N+T
E=T**R
E<<T
print'O'[0].join(chr(c+O)for c in[N-E,E*R-T,_-R,_-R,_,N-_-E-E,E,_,_+R,_-R,E*R-R,T-_-E-E])
Hoa Long Tam
la source
Le littéral ''n'est pas autorisé.
RomanSt
1
@romkyns: Très vrai, corrigé.
Hoa Long Tam
5
Non corrigé (mauvaise sortie). Vous pensez probablement à [:0].
WolframH
5

J, 250

oo=:#a.
o0=:<.o.^0
o0o=:%:%:%:oo
ooo=:p:^:(-*oo)
o=:<.(^^^0)*(^^0)*(^^0)
o00=:o,~(,[)o0(**(**[))o0o
oo0=:*/p:(!0),>:p:!0
echo u:(o0(**(**]))o0o),(ooo ooo ooo(o.o.^^^0)*oo),o00,(+:%:oo),(oo0-~!p:>:>:0),o,(<.-:o.o.^o.^0),(>:p:(]^])#o00),(*:#0,#:oo),oo0

Je me suis beaucoup trop amusé avec celui-ci et j’ai appris un peu plus J à démarrer. Aussi, ooo ooo ooopeut-être le code le plus stupide que j'ai jamais écrit.

Jesse Millikan
la source
5

QR avec demi-blocs (169) 121 caractères

Avec QR-Code en utilisant les caractères de demi-blocs UTF-8:

▗▄▄▄▗▄▖▗▄▄▄  
▐▗▄▐▝█▙▐▗▄▐  
▐▐█▐▝▄ ▐▐█▐  
▐▄▄▟▗▗▗▐▄▄▟  
▗▗▖▄▞▝ ▗ ▖▄  
 ▟▜ Code ▀▟  
 ▙▀ Golf ▘▚  
▗▄▄▄▐▗▘▟▙▝▝  
▐▗▄▐▝▀▛▘▘█▖  
▐▐█▐▐▖▐▝▖▜▘  
▐▄▄▟▗ ▌█▛▗▝  3

Malheureusement, cela ne rendra pas bien ici. Il y a un petit extrait avec la feuille de style appropriée, mais .. Non! Le langage présenté ici n'est pas HTML! La langue présentée ici est le code QR ! (HTML et CSS sont utilisés ici uniquement pour contourner un bogue de présentation!)

QR avec demi-blocs (169)

  ▛▀▀▌▚▝▐▀▌▛▀▀▌
  ▌█▌▌▖▞▚▚▘▌█▌▌
  ▌▀▘▌ ▚▛▞ ▌▀▘▌
  ▀▀▀▘▚▌▙▘▌▀▀▀▘
  ▄▙▛▚▜▀▄▀█▖▝▄▌
  ▖▄▄▘▖▄▄▄▟▗ ▀▘
  ▜Code  golf!▌
  ▚▟▘▘▝▙▛▚▐▀▖▜▘
  ▘▘ ▀▛▗▚▗▛▀▌▄ 
  ▛▀▀▌▟▌▜▖▌▘█▐▘
  ▌█▌▌▘█▌▟█▜▙▐ 
  ▌▀▘▌▚▌▌█▗▝▌▚▘
  ▀▀▀▘ ▝▘▘▀▀▀▀▘

Idéalement, cela pourrait ressembler à:

QR: Bonjour tout le monde!

F. Hauri
la source
Utilisez votre téléphone intelligent pour voir ceci ou zbarsous linux. (exemple: xwd | xwdtopnm | zbarimg /dev/stdin)
F. Hauri
Un Code golf!personnage n'est-il pas littéral?
Ugoren
2
Je pense en fait que cette réponse, bien que créative, ne remplit pas les conditions requises car ce n'est pas un programme. QR est un moyen de coder des données, pas un langage de programmation.
Ugoren
1
Et qu'en est-il des langues telles que postscript, svgou d'autres langues de présentation déjà utilisées là-bas!? Une façon d'encoder est une langue quand même ... je pense!
F. Hauri
1
J'ai utilisé HTML (moins JS) comme exemple pour ce qui n'est pas un langage. Même chose pour QR. Voir ces critères .
Ugoren
4

Scala ( 357 423 361 caractères)

Malheureusement, ce n’est pas la réponse la plus courte, mais nous espérons obtenir des points en prime pour la plupart des utilisateurs 'O'.'0'

def h(){type t=scala.Char;def OO(c:t)={(c-('O'/'O')).toChar};def O(c:t)={OO(OO(OO(c)))};def O00(c:t)={(c+('O'/'O')).toChar};def O0(c:t)={O00(O00(O00(c)))};val l=O('O');val z=O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))));print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+l+l+'O'+OO(z)+O0(O0(O0(OO('O'))))+'O'+O0('O')+l+OO(OO(O(O(O('O')))))+z).toLowerCase)}

Précédemment:

def h(){type t=scala.Char;print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+O('O')+O('O')+'O'+OO(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0))))))))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))))).toLowerCase);def OO[Char](c:t)={(c-('O'/'O')).toChar};def O[Char](c:t)={OO(OO(OO(c)))};def O00[Char](c:t)={(c+('O'/'O')).toChar};def O0[Char](c:t)={O00(O00(O00(c)))}}

Ancienne version (illégale):

def h(){type t=scala.Char;print(""+OO(O(O('O')))+(""+OO(O(O(O('O'))))+O('O')+O('O')+'O'+OO(O(O(O(O(O('0'))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O(O(O(O(O('0')))))).toLowerCase);def O0[Char](c:t)={O00(O00(O00(c)))};def O[Char](c:t)={OO(OO(OO(c)))};def OO[Char](c:t)={(c-('O'/'O')).toChar};def O00[Char](c:t)={(c+('O'/'O')).toChar}}
Gareth
la source
Je crois que la chaîne vide ( "") et les chaînes / caractères contenant le caractère zéro ( '0') ne sont pas autorisés. Seuls la chaîne "O"(majuscule O) et le nombre 0sont.
Timwi
Bugger. Quelques retouches nécessaires alors ...
Gareth
4

C (ou C ++) (segment du corps: 49) (tricherie)

lors de la compilation, compilez en un binaire appelé Hello\ World\!, le code est le suivant:

#include <stdio.h>
#include <string.h>
int main(int i,char**a)
{
  int j=i+i,k=j<<j;puts(strrchr(*a,'O'-(k<<j))+i);
}

Le strrchrsegment est requis pour supprimer le chemin complet dans le cas où le nom du programme transmis contient le chemin complet, aucun argument ne doit être passé .

La ligne de compilation typique pourrait être: gcc -o Hello\ World\! foo.c

Nim
la source
4

Java 389 caractères

repéré une déclaration inutile

class A{static int a=0,b=a++,f=a,e=a++;static char p(String s){return(char)Byte.parseByte(s,a);}public static void main(String[]z){long x=e,y=b;String c=((Long)x).toString(),d=((Long)y).toString();char l=p(c+c+d+c+c+d+d),m=p(c+c+d+d+c+d+c),o=(char)(l+a+f),_=p(c+d+d+d+d+d),$=_++;System.out.print(new char[]{p(c+d+d+c+d+d+d),m,l,l,o,$,p(c+d+c+d+c+c+c),o,(char)(o+a+f),l,(char)(m-f),_});}}

L'historique est dans l'historique des modifications, maintenant la version originale non lue lisible:

// H  e  l    l   o      W  o  r   l    d  !
//72,101,108,108,111,32,87,111,114,108,100 33
import static java.lang.Integer.*;
class A
{


    public static void main(String[] args)
    {
        Integer a=0,b=a++,e=a++;  // making a 0 a 1 and a 2 which is required later;
        String c=e.toString(),d=b.toString(),z=c.substring(0,0);  //

        String H = ((char)parseInt(d+c+d+d+c+d+d+d,a))+z+  // make binary values and then to char
                (char)parseInt(d+c+c+d+d+c+d+c,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+d+c+d+d+d+d+d,a)+
                (char)parseInt(d+c+d+c+d+c+c+c,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+c+c+c+d+d+c+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+d+c+d+d,a)+
                (char)parseInt(d+d+c+d+d+d+d+c,a)
                ;
        System.out.println(H);  //obvious
    }
masterX244
la source
3

C ++, 141, 146

La première fois que l’on essaie l’un d’eux, on peut probablement encore s’y améliorer un peu:

char o='O'/'O',T=o+o,X=T+o,f=T+X,t=f+f,F=t*f,h=F+F,l=h+t-T,O=l+X;
char c[]={F+t+t+T,h+o,l,l,O,o<<f,h-t-X,O,l+f+o,l,h,0};
cout<<c;

MODIFIER:

J'ai volé le piège d'un autre billet, je ne peux pas croire que je n'y ai pas pensé :(

LorenVS
la source
1
Techniquement, vous êtes censé inclure tout le programme de travail dans le nombre de caractères, y compris des éléments tels que la bibliothèque principale, les bibliothèques incluses std::, etc.
Wug
3

Haskell - 146

a:b:c:f:g:s:j:z=iterate(\x->x+x)$succ 0
y=[f+j,d+a,c+s+h,l,a+b+l,s,f-s+o,o,a+b+o,l,l-f,a+s]
[h,e,l,_,o,_,w,_,r,_,d,x]=y
main=putStrLn$map toEnum y

J'ai pensé que l'appariement de motifs donnerait un avantage considérable à Haskell, en particulier parce que vous pouvez initialiser des puissances de deux comme ceci:

one:two:four:eight:sixteen:thirty_two:sixty_four:the_rest = iterate (*2) 1

Cependant, comme on le voit dans Haskell de MtnViewMark réponse (qui mérite beaucoup beaucoup upvotes, en passant) et d' autres réponses, une meilleure compression peut être obtenue en utilisant plus que juste +et -.

Joey Adams
la source
3

Clojure - 46 caractères

(map print(butlast(rest(str'(Hello World!)))))

Notez que Helloet World!sont des symboles, pas des littéraux de toutes sortes.

Mikera
la source
3

C ++

/*
Hello World!
*/
#define CodeGolf(r) #r
#include<iostream>
using namespace std;
int main()
{
    char str[*"O"];
    freopen(__FILE__,CodeGolf(r),stdin);
    gets(str);gets(str);puts(str);
}
FRODDY
la source
1
La 100viole la règle sur les nombres. S'il vous plaît remplacez-le par quelque chose de plus amusant.
Joey Adams
@ joey-adams Merci de l'avoir signalé. Changé cela.
fr0ddy
Line 7: error: ISO C++ forbids declaration of 'main' with no type
Nathan Osman
@ george-edison Corrigé. Bien que cela a fonctionné sans intg ++
fR0DDY
3

PHP - 49 caractères

<?=Hello.chr(($a=-~-~-~0).~-$a).World.chr($a.$a);

Changelog :

  • (73 -> 86) Oubli de sortie d'un point d'exclamation ... soupir
  • (86 -> 57) Utilise une seule variable avec incrémentation
  • (57 -> 51) Changé pour utiliser des opérateurs au niveau des bits sur 0
  • (51 -> 49) Plus d'opérateurs bitwise
nyuszika7h
la source
1
À peu près sûr que les constantes compteraient comme des littéraux de chaîne à cause des conversions.
Kevin Brown
@ Bass5098 Merci pour votre modification! Je l'ai approuvé.
nyuszika7h
@ Bass5098 cela ne fonctionne pas, vous devez avoir les caractères 32 et 33, pas 21 et 22. <?$a=-~-~-~0;echo Hello.chr($a.$a-1).World.chr($a.$a);ça marche, mais c'est 54 caractères.
zzzzBov
@zzzzBov Je ne savais pas comment effacer le montage au départ et j'ai oublié de le restaurer une fois qu'il avait été approuvé.
Kevin Brown
oups, j'ai laissé le 1dedans. Là je vais enfreindre mes propres règles ... <?$a=-~-~-~0;echo Hello,chr($a.~-$a),World,chr($a.$a);est ce que j'aurais dû utiliser, toujours 54 caractères.
zzzzBov
3

Python, 106

o=-~-~-~0
L=o+o
d,W=-~L,o**o
_=o*W
print str().join(chr(L+W+_-i)for i in[d*L,L+d,L,L,o,-~_,W,o,0,L,d+d,_])
flornquake
la source
Utilisez '' (sans espace précédent) au lieu de str ()
aditsu
2
Aussi, très sympa! :) Au fait, l'affectation multiple n'enregistre aucun caractère
Aditsu
@aditsu: Je ne peux pas, ce serait un littéral de chaîne. Merci pour vos commentaires. :)
Flornquake
Oh oups, d'une certaine manière, la chaîne vide ne s'est pas inscrite comme un littéral dans mon esprit
Aditsu
3

Perl, 186 octets

@A=(0,0,0,0);@B=(@A,@A);@C=(@B,@B);@D=(@C,@C);@E=(@D,@D);@d=(@E,@D,@A);$l=[@d,@B];$o=[@$l,0,0,0];print(chr@$_)for[@E,@B],[@d,0],$l,$l,$o,\@D,[@E,@C,@A,0,0,0],$o,[@$o,0,0,0],$l,\@d,[@D,0]

Chaque caractère est imprimé via son nombre ordinal, qui est la longueur d'un tableau. La construction des tableaux est optimisée via la représentation binaire des numéros de caractères.

Ungolfed:

@A = (0, 0, 0, 0);          # A = 2^2
@B = (@A, @A);              # B = 2^3
@C = (@B, @B);              # C = 2^4
@D = (@C, @C);              # D = 2^5
@E = (@D, @D);              # E = 2^6

# d = 100 = 0x64 = 1100100b
@d = (@E, @D, @A);          # d = 2^6 + 2^5 + 2^2 

# l = 108 = 0x6C = 1101100b
$l = [@d, @B];              # l = d + 2^3

# o = 111 = 0x6F = 1101111b
$o = [@$l, 0, 0, 0];        # o = l + 3

print (chr @$_) for
    [@E, @B],              # "H"    H  =  72 = 0x48 = 1001000b = 2^6 + 2^3
    [@d, 0],               # "e"    e  = 101 = 0x65 = 1100101b = d + 1  
    $l, $l, $o,            # "llo"
    \@D,                   # " "   ' ' =  32 = 0x20 = 0100000b = 2^5
    [@E, @C, @A, 0, 0, 0], # "W"    W  =  87 = 0x57 = 1010111b = 2^6 + 2^4 + 2^2 + 3
    $o,                    # "o"
    [@$o, 0, 0, 0],        # "r"    r  = 114 = 0x72 = 1110010b = o + 3
    $l, \@d,               # "ld"
    [@D,0]                 # "!"    !  =  33 = 0x21 = 0100001b = 2^5 + 1
Heiko Oberdiek
la source
semble que mon vodoo binaire vous a inspiré :) +1
masterX244
3

Perl 6 , 199 octets

my \O=+[0];my \t=O+O;my \T=t+O;my \f=(t+t,O);my \F=t+T;my \S=T+T;my \L=(S,F);
say [~] ((S,T),(|L,t,0),(my \l=(|L,T,t)),l,(my \o=(|l,O,0)),F,(S,|f,t,0),o,(|L,|f),l,(|L,t),(F,0),)
.map({chr [+] t X**@_})

(les nouvelles lignes sont ajoutées pour réduire la largeur, mais sont inutiles et ne sont donc pas comptabilisées)


Hello World! est codé comme une liste de listes des puissances de 2 de chaque lettre.

Il y a exactement un endroit où j'ai un littéral 0qui est utilisé pour autre chose qu'un 0. Il est utilisé pour créer une liste à un élément, qui est immédiatement transformée en nombre 1avec l'opérateur de préfixe numérique ( +[0]).

my \O=+[0];    # one          # (List.elems)
my \t=O+O;     # two
my \T=t+O;     # Three
my \f=(t+t,O); # (four, one)  # <W r>
my \F=t+T;     # five
my \S=T+T;     # six

my \L=(S,F);   # lowercase letter  # (6,5)

say [~] (
  (S,T),            # H
  (|L,t,0),         # e
  (my \l=(|L,T,t)), # l
  l,                # l  reuse <l>
  (my \o=(|l,O,0)), # o  reuse <l>, add 0,1
  F,                # ␠
  (S,|f,t,0),       # W
  o,                # o  reuse <o>
  (|L,|f),          # r
  l,                # l  reuse <l>
  (|L,t),           # d
  (F,0),            # !
).map({chr [+] t X**@_})
Brad Gilbert b2gills
la source
3

JavaScript 662 caractères

O=[[,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[],[,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]];for(O_O=[].length;O.length>O_O;O_O++)document.write(String.fromCharCode((O[O_O].length||-Math.pow([,,].length,[,,,,,].length)-[,,,,,,,].length)+Math.pow([,,].length,[,,,,,,].length)+Math.pow(++[,].length,[,,,].length)-[,].length));document.write(String.fromCharCode(Math.pow([,,].length,[,,,,,].length)+[,].length))

Qu'en est-il d'abuser des littéraux de tableau juste pour avoir une base unaire. Ce programme a l'avantage de ne pas utiliser 0.

Konrad Borowski
la source
Bien que cela puisse être valable, ce casse-tête particulier est un code de golf, ce qui signifie que vous devriez viser le code le plus court possible. Avec plus de 600 caractères, vous êtes loin des <100 caractères des solutions JS existantes.
zzzzBov
1
@zzzzBov: En fait, je ne cherche pas à gagner.
Konrad Borowski
1
Ce programme a l'avantage de ne pas utiliser 0. Qu'en est- il O_O=0;?
Erik the Outgolfer
@EriktheGolfer: Corrigé, merci. Je n'ai pas remarqué celui-là.
Konrad Borowski
O_O=[].lengthpeut être écrit comme O_O=falsece qui le diminue de 4.
Atmocreations