Hallo Welt 0.0!

78

Dilbert ist großartig
Quelle: Dilbert, 8. September 1992

Ich hoffe, dem Klassiker "Hello World!" Programm.

Code ein Programm, das Hello World!ohne ausgibt :

  • String / Character Literale
  • Zahlen (beliebige Basis)
  • Vorgefertigte Funktionen, die "Hello World!"
  • RegEx-Literale

Mit Ausnahme von "O" und 0.

† "O" wird großgeschrieben, "o" ist nicht akzeptabel.

zzzzBov
quelle
4
Eines von [Code-Golf] und [Code-Challenge], bitte nicht beides. Der Zweck dieser Tags besteht darin, den Benutzern zu helfen, Fragen mit den Regeln zu finden, die sie verwenden möchten. Im Grunde genommen sollte jede Frage auf dieser Seite so oder so ein Spiel sein.
dmckee
4
-1 Wir hatten bereits Obfuscated Hello World , und ich denke, diese Herausforderung ist zu ähnlich. Ich hätte eine "Close as Duplicate" -Stimme abgegeben, wenn ich kein Mod wäre.
Chris Jester-Young
2
@zzzzBov: Ich denke nicht, dass es anders genug ist, um eine weitere Frage im Thema "Hallo Welt" zu rechtfertigen. Ein anderes Thema wäre besser gewesen. Aber das ist nur meine Meinung.
Chris Jester-Young
1
Ich denke, dies ist ein Fine Code Golf - und besser als der vorherige.
MtnViewMark
2
Einige Leute scheinen anzunehmen, dass dies "O"*bedeutet , dass sie ein String-Literal mit einer beliebigen Anzahl von Os haben können, einschließlich Null. Ich glaube nicht, dass das die Absicht war. Bitte klären Sie.
Timwi

Antworten:

83

Windows PowerShell, viel zu viel

Ja, damals mussten wir eine »Hallo-Welt« mit (fast ausschließlich) Nullen schreiben ...

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

Im Ernst:

Windows PowerShell, 25

Write-Host Hello World!

Kein String-Literal. Das Hello World!darin enthaltene Argument wird zufällig als Zeichenfolge analysiert, da sich PowerShell dort im Argument-Parsing-Modus befindet.

Joey
quelle
2
Wie ist das real? O_o
Josh
1
Ich habe im Internet nach Beispielen oder der Geschichte dafür gesucht. Das ist so seltsam. Könnten Sie irgendwelche Links bereitstellen?
Caleb Jares
1
"Zurück in den Tag". :) Sie Millennials Crack Me Up 👍
Oh. Unär. Ich verstehe es.
Matthew Roh
86

C 327 Zeichen

#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))))))))
    ))))))))))))))))))))))))))))))))))))));
}

Seltsamerweise verliert es nach der Vorverarbeitung nicht seine Schönheit:

main() {
putchar(-~-~-~-~-~-~-~-~-~-~!putchar(~-~-~-~-~-~-~-~-putchar(~-~-~-~-~-~-
putchar(-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~!putchar(-~-~-~putchar(putchar(-~-~-~-~-~-~-~putchar
(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0))))))))))));
}
ugoren
quelle
2
Genial. Aber ich vermisse das!
Mark Reed
1
Das ist echte Kunst!
Askaga
Ich habe das Gefühl, dass der Körper mit noch mehr Präprozessoren verkürzt werden könnte. Ich bin mir nicht sicher, ob der Code insgesamt davon profitieren würde.
Zwei
@ Zwei, es ist sicherlich möglich, es zu verkürzen. Ich habe mich nicht bemüht, die optimalen Makros zu finden.
Ugoren
Warum nehmen Sie die Parens nicht in das CLANG #define auf? würde ein paar Bytes sparen, nein? Edit: vergiss, habe gerade versucht und jetzt sehe ich, warum das nicht funktioniert ahaha
Albert Renshaw
52

BrainFuck, 102 111 Zeichen

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

Erfüllt alle Regeln.

Dank geht an Daniel Cristofani .

Kevin Brown
quelle
1
Ich kann mich nicht entscheiden, ob die Regeln auch besagen sollen 0 and/or "O" must be used. Für BrainFuck und golfscript ist es ein bisschen gemein, aber sie haben es nicht gerade schwer mit dieser Herausforderung.
zzzzBov
34
@zzzzBov: Wenn sie verwendet werden müssen , enthält der Brainfuck-Code sie nur. Sie wirken sich jedoch überhaupt nicht auf das Programm aus.
Joey
38

C 182 Bytes

#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);}
fR0DDY
quelle
1
+ 1, Lol, Du benutzt immer noch den Token-Einfügeoperator-Trick! Netter Kumpel :-)
Quixotic
35

C-Programm - 45

(Betrug)

Lexikalisch werden keine String-Literale oder Regex-Literale verwendet. Es nutzt die Stringifizierungsfunktion des C-Präprozessors. s(x)ist ein Makro, das sein Argument in einen String verwandelt.

#define s(x)#x
main(){puts(s(Hello World!));}
Joey Adams
quelle
3
Für eine sehr bequeme Vorstellung von "lexikalisch" :) Aber frech FTW!
JB
24

Haskell - 143 Zeichen

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, das war wollig!

Keine Zahlen, keine numerischen Operationen, Variablen, die zur Unterhaltung umbenannt wurden.

Einige Ausführungen mögen nett sein:

  • o%y, o&yUnd o!yjeweils wendet die Funktion oauf ymehrere Male: 3, 9, und 29 - mal auf. 29?!?! Ja, 29!
  • rund wsind das nächste und vorherige Zeichen, von denen bei Anwendung mit den oben genannten Funktionen höherer Ordnung alle benötigten Zeichen abgerufen werden können 'O'.

Die Reihenfolge der benötigten Sprünge ist:

'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) Ich habe vergessen, ein Ausrufezeichen auszugeben, seufz ...
  • Bearbeiten: (144 -> 143) Unnötiges entfernt $, umbenannt #in !für Umarmungen.
MtnViewMark
quelle
1
O rly? oo ....
Joey Adams
Es funktioniert nicht codepad.org/lyKyj1Ox
nyuszika7h
@ Nyuszika7H Das liegt daran, dass dieser Dienst standardmäßig einige Compileroptionen aktiviert. Es sollte mit normalem GHC kompiliert werden.
FUZxxl
@ Nyuszika7H Es funktioniert gut mit GHC. Das Problem ist, dass dieser Dienst Hugs aus dem Jahr 2006 verwendet. Es scheint zwei Dinge zu geben, mit denen Hugs nicht umgehen kann: 1) Verwenden von '#' als Operator. Ändern auf "!" macht es funktioniert. 2) Die Definitionen r=succund w=predVerstöße gegen die Implementierung der Monomorphismus-Beschränkung durch Hugs. Wechseln zu r x=succ xund w x=pred xes funktioniert (auf Kosten von 4 Zeichen). Dies scheinen Probleme in Umarmungen zu sein.
MtnViewMark
Ist es nach der @ Community-Bearbeitung noch gültig?
Hosch250
22

Unary , 10 197 1137672766964589547169964037018563746793726105983919528073581559828 Bytes

Ich bin überrascht, dass noch niemand dies getan hat ...

Es ist zu lang, um hier zu posten, aber es sind 1137672766964589547169964037018563746793726105983919528073581559828 Nullen.

Oder einfacher zu lesen: ~ 10 67 Nullen.

Vielen Dank an @dzaima für das Speichern von 10 197 Bytes

Beta-Zerfall
quelle
2
Als ich las "Ich habe einmal eine ganze Datenbank nur mit Nullen geschrieben", war mein erster Gedanke "er muss es unärgerlich gemacht haben". +1 für die einzige Antwort, die genau so funktioniert wie der Comic
Cyoce
21

Mathematica 12 Zeichen

Nur Symbole, keine Zeichenketten.

Hello World!   

Das ! ist ein Fakultätsoperator, aber da die Symbole Hello und World nicht definiert sind, wird die Eingabe unverändert zurückgegeben.

Wenn wir das Programm etwas modifizieren:

Hello=2;
World=3;
Hello World!  

Dann wird gedruckt 12(2 * 3!)

Dr. belisarius
quelle
16

i386-Assembly (Linux, gcc-Syntax), 440 442 435

Heute ist mein Montagetag, und danach habe ich eine Weile genug. Ich erlaubte mir Nummer 128, siehe unten Programm für die Diskussion, warum. Nichts Außergewöhnliches: Ich codiere nur "Hello World!" als Assembler-Opcodes, wo das ohne numerische Konstanten Sinn machte und im Rest mit Arithmetik gefüllt wurde.

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

(Zusammenbauen mit gcc -nostartfiles hello.S -o hello, möglicherweise -m32abhängig von Ihrem Bogen)

Warum die Toleranz für 128? Ich brauche Syscalls, um etwas zu zeigen. Linux-Systemaufrufe erfolgen auf INT 80h (128 Dezimalstellen). Das einzige Operandenformat für INT ist das Sofortformat. Es ist also nicht möglich, dort etwas anderes als eine Konstante (für den Code) zu haben. Ich könnte (nachdem ich nüchtern geworden bin) versuchen, es als Funktion anderer symbolischer Konstanten im Code auszudrücken, wahrscheinlich n , aber das wird sehr langweilig , wenn man nicht viel davon gewinnt. Ich habe die Einschränkung für Zahlen gelesen, um ASCII-Codierung zu verhindern, und das tue ich hier definitiv nicht, deshalb fühle ich mich unschuldig genug, dies einzureichen. (FWIW, ich habe auch versucht, den Code selbst zu ändern, aber dieser Fehler ist aufgetreten.) Es sind jetzt auch keine 128 mehr vorhanden. Der Code ist rein!

  • Edit1 neu formatiert, um Zeilen zu speichern; hat eine 1 entfernt (niemand hat es bemerkt ?!)
  • Edit2mov mit CPP-Makros komprimiert ; die restlichen 128 beseitigt.
JB
quelle
6
So programmieren echte Männer.
Nit
14

Javascript - 305

Ein bisschen lang, aber ich mag die Methode.

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
quelle
Ich mag das. Es wäre besser mit Funktionsparametern wie OO, OOOaber das würde es natürlich länger machen.
zzzzBov
Wirklich nett. Muss der ', new String ()' am Ende vorhanden sein? Es scheint ohne es zu funktionieren.
Stephen Perelson
3
Ah, nein, tut es nicht. Manchmal vergesse ich nur, wie schwach getippt Javascript ist.
David4Dev
Sie brauchen auch keine linken 0-Bits ('0+'), und das Leerzeichen und der Ausruf haben zwei linke 0-Bits. Gesamtreduktion von 28 Zeichen.
Stephen Perelson
10

C # (131 Zeichen)

141 Zeichen 142 Zeichen

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);}}

Lesbar:

// 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
quelle
2
Das ist verdreht und schön. Ich liebe es.
Jcolebrand
+1 schöner Weg, um bestimmte Zahlen zu generieren. Muss ich mir merken!
Igby Largeman
LINQPad-Programm, 102 Zeichen: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
.ToString()-> +""spart einige cahrs
Firo
2
@Firo: ... und verstößt gegen die Regeln. (Keine String-Literale erlaubt.)
Timwi
8

JavaScript, 88

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

99

Vielen Dank an @Timwi für die Vorschläge

Ternärer Operator entfernt:

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
aliasiertString.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
If-else auf Ternäroperator umgestellt

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
Ich behalte das "O"Recht, ein "O" im Programm zu haben.

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
quelle
@Joey, das ist größtenteils der Punkt.
zzzzBov
@Joey, ich habe auf der Codegolf-Meta gelesen, dass man es für einige Zeit vermeiden sollte, ihre eigene Frage zu beantworten, um andere zu ermutigen, verschiedene Ansätze auszuprobieren. Mein Plan war es, es in ein oder zwei Tagen zu kommentieren.
zzzzBov
@Joey, arbeitete zu der Zeit nicht an meinem eigenen Computer und ich hatte keine Lust, mir die Antwort per E-Mail zu schicken, wenn ich sie einfach in einem Kommentar posten konnte.
zzzzBov
@ Joey: "Es gibt nur fünf davon" ist falsch. Jeder kann eine Bearbeitung vorschlagen. Klicken Sie einfach auf "Bearbeiten" zwischen "Link" und "Flag" und Sie können den Code sehen.
John
@zzz: "das ist größtenteils der Punkt" Jeder kann es immer noch sehen. Jeder kann eine Bearbeitung vorschlagen, indem er auf "Bearbeiten" zwischen "Link" und "Flag" klickt. Der Bearbeitungsdialog wird geöffnet und Ihr Code wird angezeigt.
John
7

GolfScript, 63 Zeichen

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

Was, noch kein GolfScript-Eintrag?

Dieser verwendet ein einzelnes numerisches Literal 0und eine Variable mit dem Namen O(in der die Nummer gespeichert wird 3). Alles andere ist Arithmetik und Stapelmanipulation. Die Zeichenfolge Hello World!wird zeichenweise aus ihren ASCII-Codes aufgebaut.

So funktioniert das:

[             # 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
quelle
7

Brainfuck, 111 Bytes

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

Algorithmus erklärt

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!'

Längere Version ohne Schleife, 389 Bytes:

+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+++++++++++++++++
++++++++++++.+++++++..+++.-------------------
---------------------------------------------
---------------.+++++++++++++++++++++++++++++
++++++++++++++++++++++++++.++++++++++++++++++
++++++.+++.------.--------.------------------
---------------------------------------------
----.-----------------------.
Michael
quelle
Hierbei handelt es sich um ein Code-Golf-Puzzle, bei dem es darum geht, ein möglichst kurzes Programm zu erstellen. Ein Teil davon beinhaltet das Posten der Länge Ihres Codes.
zzzzBov
5

Lua 144 97 86 Zeichen

Ein anderer Ansatz basiert auf der Tatsache, dass Tabellenschlüssel auch Zeichenfolgen sind und dass #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

145 char Lösung

  • Keine Zeichenfolgen außer "O" oder 0
  • keine Regexes
  • Keine vorgefertigten Funktionen

Hat Delta-Codierung der Bytes, dann einige Primzahlen etc etc :)

Golf Version:

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

Kommentiert:

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

Bearbeiten: Mehrere O-Strings geändert und weitere Optimierungen gefunden.

jpjacobs
quelle
"O" * - Ich denke, das * war für die Fußnote, nicht irgendeine Anzahl von O's
RomanSt
Nun, Regex ist das, was ich natürlich tue: p. Könnte es auf Kosten von 5 oder 3 zusätzlichen Zeichen für die erste und zweite Lösung
ersetzen
Aber trotzdem, ich werde sie herausschneiden, danke für die Köpfe hoch
jpjacobs
Hello und World im Tabellenkonstruktor sind immer noch String-Literale - das ist nur ein syntatischer Zucker.
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
quelle
Das Literal ''ist nicht erlaubt.
RomanSt
1
@romkyns: Sehr wahr, behoben.
Hoa Long Tam
5
Nicht behoben (falsche Ausgabe). Sie denken wahrscheinlich an [: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

Ich hatte viel zu viel Spaß damit, und ich habe ein bisschen mehr gelernt, um zu booten. Auch ooo ooo oookann der dümmste Code , den ich je geschrieben habe.

Jesse Millikan
quelle
5

QR mit Halbblöcken (169) 121 Zeichen

Mit QR-Code unter Verwendung von UTF-8-Halbblöcken:

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

Leider wird dies dort nicht gut wiedergegeben. Es gibt ein kleines Snippet mit passendem Style Sheet, aber .. Nein! Die hier dargestellte Sprache ist kein HTML! Die hier präsentierte Sprache ist QR Code ! (HTML und CSS werden hier nur verwendet, um den Präsentationsfehler zu umgehen!)

QR mit Halbblöcken (169)

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

Im Idealfall könnte dies so aussehen:

QR: Hallo Welt!

F. Hauri
quelle
Verwenden Sie Ihr Smartphone, um dies oder zbarunter Linux zu sehen. (Beispiel: xwd | xwdtopnm | zbarimg /dev/stdin)
F. Hauri
Ist Code golf!ein Zeichen nicht wörtlich?
Ugoren
2
Ich denke tatsächlich, dass diese Antwort, obwohl kreativ, nicht geeignet ist, weil sie kein Programm ist. QR ist eine Möglichkeit, Daten zu verschlüsseln, keine Programmiersprache.
Ugoren
1
Auch das, was über Sprachen wie postscript, svgoder andere Präsentation Sprachen bereits dort verwendet !? Eine Art zu kodieren ist sowieso eine Sprache ... Ich denke!
F. Hauri
1
Ich habe HTML (minus JS) als Beispiel für das verwendet, was keine Sprache ist. Gleiches gilt für QR. Siehe diese Kriterien .
Ugoren
4

Scala ( 357 423 361 Zeichen)

Leider nicht die kürzeste Antwort, aber in der Hoffnung, Bonuspunkte für die Verwendung von 'O'und zu erhalten'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)}

Vorher:

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

Alte (illegale) Version:

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
quelle
Ich glaube, die leere Zeichenfolge ( "") und Zeichenfolgen / Zeichenliterale mit dem Zeichen Null ( '0') sind nicht zulässig. Nur die Zeichenfolge "O"(Großbuchstabe O) und die Nummer 0sind.
Timwi
Bugger. Einige Bearbeitung erforderlich, dann ...
Gareth
4

C (oder C ++) (Körpersegment: 49) (Betrug)

Kompilieren Sie beim Kompilieren in eine aufgerufene Binärdatei. Hello\ World\!Der Code lautet:

#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);
}

Das strrchrSegment muss den vollständigen Pfad entfernen, wenn der übergebene Programmname den vollständigen Pfad enthält. Außerdem müssen keine Argumente übergeben werden .

Eine typische Kompilierungszeile könnte sein: gcc -o Hello\ World\! foo.c

Nim
quelle
3

C ++, 141, 146

Das erste Mal, wenn Sie eines dieser Programme ausprobieren, kann sich wahrscheinlich noch einiges verbessern:

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;

BEARBEITEN:

Hat den Divide-Trick von einem anderen Post gestohlen, kann nicht glauben, dass ich nicht daran gedacht habe :(

LorenVS
quelle
1
Technisch gesehen std::
solltest
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

Ich dachte, Pattern Matching würde Haskell einen großen Schritt nach oben bringen, insbesondere weil Sie Potenzen von zwei wie folgt initialisieren können:

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

Wie in der Haskell-Antwort von MtnViewMark (die übrigens viele, viele positive Stimmen verdient) und anderen Antworten zu sehen ist, kann eine bessere Komprimierung erzielt werden, wenn mehr als nur +und verwendet werden -.

Joey Adams
quelle
3

Clojure - 46 Zeichen

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

Beachten Sie, dass Hellound World!Symbole sind, keine Literale jeglicher Art.

mikera
quelle
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);
}
fR0DDY
quelle
1
Das 100verstößt gegen die Regel über Zahlen. Bitte ersetzen Sie es durch etwas amüsanteres.
Joey Adams
@ joey-adams Danke für den Hinweis. Das hat sich geändert.
Freitag,
Line 7: error: ISO C++ forbids declaration of 'main' with no type
Nathan Osman
@ George-Edison Korrigiert. Obwohl es ohne intg ++
geklappt hat
3

PHP - 49 Zeichen

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

Änderungsprotokoll :

  • (73 -> 86) Ich habe vergessen, ein Ausrufezeichen auszugeben ... seufz
  • (86 -> 57) Verwendet eine einzelne Variable mit Inkrementierung
  • (57 -> 51) Die Verwendung von bitweisen Operatoren für 0 wurde geändert
  • (51 -> 49) Mehr bitweise Operatoren
nyuszika7h
quelle
1
Ziemlich sicher, dass die Konstanten aufgrund der Konvertierungen als Zeichenfolgenliterale zählen würden.
Kevin Brown
@ Bass5098 Danke für deine Bearbeitung! Ich habe es genehmigt.
nyuszika7h
@ Bass5098, das nicht funktioniert, Sie müssen die Zeichen 32 und 33 haben, nicht 21 und 22. <?$a=-~-~-~0;echo Hello.chr($a.$a-1).World.chr($a.$a);funktioniert, aber es ist 54 Zeichen.
zzzzBov
@zzzzBov Ich konnte zunächst nicht herausfinden, wie die Bearbeitung gelöscht werden soll, und vergaß, sie zurückzusetzen, sobald sie genehmigt wurde.
Kevin Brown
Hoppla, ich habe die 1da drin gelassen . Dort gehe ich meine eigenen Regeln brechen ... <?$a=-~-~-~0;echo Hello,chr($a.~-$a),World,chr($a.$a);ist, was ich hätte verwenden sollen, immer noch 54 Zeichen.
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,_])
Flornbeben
quelle
Verwenden Sie '' (ohne vorangestelltes Leerzeichen) anstelle von str ()
aditsu
2
Auch sehr schön! :)
Übrigens
@aditsu: Ich kann nicht, das wäre ein String-Literal. Danke für deine Kommentare. :)
Flornquake
Oh hoppla, irgendwie hat sich die leere Zeichenfolge in meinem Kopf nicht als wörtlich registriert
aditsu 20.03.13
3

Perl, 186 Bytes

@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]

Jedes Zeichen wird über seine Ordnungszahl gedruckt, die der Länge eines Arrays entspricht. Der Aufbau der Arrays wird über die binäre Darstellung der Zeichenzahlen optimiert.

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
quelle
scheint, dass mein binäres Vodoo dich inspiriert hat :) +1
masterX244
3

Java 389 Zeichen

eine unnötige Erklärung entdeckt

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),_});}}

History ist in der Edit History nun die original ungolfed version lesbar:

// 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
quelle
3

Perl 6 , 199 Bytes

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**@_})

(Zeilenumbrüche werden hinzugefügt, um die Breite zu verringern, sind jedoch nicht erforderlich, werden also nicht gezählt.)


Hello World! ist als eine Liste von Listen der Potenzen von 2 jedes Buchstabens codiert.

Es gibt genau einen Ort, an dem ich ein Literal habe 0, das für etwas anderes als a verwendet wird 0. Es wird verwendet, um eine Liste mit einem Element zu erstellen, die sofort in die Zahl 1mit dem numerischen Präfixoperator ( +[0]) umgewandelt wird.

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
quelle
3

JavaScript 662 Zeichen

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

Was ist mit dem Missbrauch von Array-Literalen, nur um eine unäre Basis zu haben? Dieses Programm hat den Vorteil, dass es nicht verwendet wird 0.

Konrad Borowski
quelle
Während dies gültig sein mag, handelt es sich bei diesem speziellen Puzzle um ein Code-Golfspiel, was bedeutet, dass Sie den kürzestmöglichen Code anstreben sollten. Bei mehr als 600 Zeichen sind Sie weit entfernt von den <100 Zeichen, über die die vorhandenen JS-Lösungen bereits verfügen.
zzzzBov
1
@zzzzBov: Ich versuche eigentlich nicht zu gewinnen.
Konrad Borowski
1
Dieses Programm hat den Vorteil, dass es nicht verwendet wird 0. Was ist O_O=0;?
Erik der Outgolfer
@EriktheGolfer: Behoben, danke. Ich habe es nicht bemerkt.
Konrad Borowski
O_O=[].lengthkann so geschrieben werden O_O=false, dass es um 4 abnimmt.
Atmocreations