Ihr Ziel ist es, "Hallo, Welt!" (abzüglich der Anführungszeichen). Dies ist ein Beliebtheitswettbewerb , bei dem die meisten Stimmen gewonnen haben. Die Codelänge wird zum Unterbrechen von Bindungen verwendet.
Alles ist möglich, solange die folgenden Regeln eingehalten werden:

• Alle Zeichen müssen entweder Buchstaben oder Zahlen sein, daher dürfen Sie nur Zeichen in der Zeichenfolge "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" verwenden.
• Der gesamte Code, den Sie verwenden, muss sich in einer Datei befinden, mit Ausnahme der importierten Module / Klassen / was auch immer sie in Ihrer bevorzugten Sprache heißen.
• Es sind nur die Standardbibliotheken / Frameworks für die Sprache Ihrer Wahl zulässig (z. B. Pythons Math-Modul, nicht jedoch Numpy, Scipy und Pygame). Ich werde TkInter erlauben, da es der De-facto-Standard für GUIs in Python ist.
• Es ist keine Eingabe erlaubt, sei es das Lesen von Standardinhalten, das Lesen einer Datei, das Verteilen eines Bildes oder das Lesen aus dem Internet.

+10 Brownie-Punkte, wenn du herausfindest, wie es in Java geht, ohne die Regeln zu biegen.

Auf die Plätze, fertig, Code!

BEARBEITEN: Klammern ({}), Klammern ([]) und Klammern (()) sind zulässig, da dies für die meisten Sprachen ohne sie so gut wie unmöglich wäre. Ich entferne auch die Zeichenbegrenzungsregel. Hoffentlich wird es dadurch interessanter.

EDIT ^ 2: Leerzeichen sind ebenfalls erlaubt. Mein Gehirn funktioniert nicht richtig, sorry. >. <

Perl

Einige sagen, Perl sei eine Sprache voller Ascii-Rauschen und zufälliger Symbole wie $... Das stimmt nicht: P

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

Teilen wir das in Unterausdrücke auf:

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

Es sollte offensichtlich sein, dass es von links nach rechts ausgeführt wird, solange jeder Ausdruck true zurückgibt. Aber was um alles in der Welt ist das s zqzchr 44ze?

In Perl gibt es eine Gruppe von „Zitat-like - Operatoren“ , das beinhaltet q(str), qw(li st), /regex/, s/from/to/unter anderem. Es hat sich herausgestellt, dass alle diese Operatoren mit ein paar Besonderheiten fast jedes Zeichen als Trennzeichen verwenden können: Die öffnende Parethese muss durch eine passende schließende Klammer geschlossen werden, und wenn Sie einen Buchstaben als Trennzeichen verwenden möchten, müssen Sie ein Leerzeichen einfügen nach dem Operator Letter (um es von einem Barewort zu trennen).

In diesem Fall sehen wir drei Verwendungen des s///Operators (Regex-Substitution):

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

Alle durch den Charakter begrenzt z. Das /eFlag der letzten beiden führt dazu, dass die Ersetzung als auszuwertender Code interpretiert wird, eher als wörtlicher Text.

Eine ziemlich bekannte Tatsache über Perl ist, dass die meisten Operationen standardmäßig mit der $_eingebauten Variablen arbeiten, sofern nicht anders angegeben. Alle diese drei Ersetzungen und die printOperationen werden $_in diesem Fall ausgeführt. Zuerst geben wir die Wörter Hello world in die Variable ein, dann korrigieren wir die Interpunktion mithilfe der numerischen ASCII-Werte der Zeichen und geben dann den Inhalt der Variablen aus.

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

(Bearbeiten - BBC Basic hat die Antwort wie vorgeschlagen getrennt. Die meisten Abstimmungen hierüber sind definitiv für die LOGO-Antwort.)

LOGO

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

Ausgabe (das grüne Dreieck ist der Schildkrötencursor)

Applescript

Keine Klammern [], Klammern {}oder Klammern ()in diesem:

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

Ausgabe ist:

Bash

Diese Art von Arbeiten, wenn Sie Ihre Augen schielen:

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

Erfüllt die ursprünglichen Regeln.

Python

Also, wir nehmen einfach an, dass jeder horizontal liest? Für diejenigen Benutzer, die vertikal lesen möchten:

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)

Mehrsprachig: HQ9 +, H9 +, HQ9 ++, CHIQRSX9 +, HQ9 + B und HQ9 + 2D (1 Byte)

H

Vielen Dank an @victor für die Liste der Sprachen.

OMGROFL

Ich bin ein großer Fan von esoterischen Sprachen. Zum Glück ist OMGROFL alphanumerisch:

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

Der izBefehl setzt einen Wert einer Variablen, in diesem Fall lol, loolund loooldienen als Variablen ...

Der roflBefehl gibt das ASCII-Äquivalent der in der Variablen gespeicherten Nummer aus.

Der stfuBefehl beendet das Programm;)

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 

Einige Änderungen waren erforderlich, um eine echte alphanumerische Quelle zu werden.

PROGRAM-ID kann fallengelassen werden. Sie erhalten einen generierten Programmnamen (siehe Meldungen).

ARBEITSLAGERUNG kann entfallen. Wieder stöhnt der Compiler.

Da in beiden Zeilen zuvor Punkte / Punkte fehlten, die jetzt, da die Beschreibungen vollständig fehlen, nicht mehr relevant sind, ist die Anzahl der Fehlermeldungen dieselbe wie zuvor, und der generierte Code für das Programm wird weiterhin nicht beeinflusst.

Wenn Sie COMP-5 in COMP ändern, sind die VALUE-Klauseln nicht mehr zulässig, da COMP 9999 nur vier Dezimalstellen enthält, während COMP-5 eine Zwei-Byte-Binärdatei mit allen verfügbaren Bitwerten ist.

Die Werte in den MOVEs sind die Dezimalwerte, die die Binärwerte ergeben, die die Zeichenpaare ergeben.

Auch wenn die COMP-Felder vierstellig sind und keine VALUE-Klauseln mit mehr als vier Stellen zulassen, können Sie im MOVE eines Literalwerts mehr Stellen ohne Kürzung verwenden ... fragen Sie mich nicht, warum. Die Compiler-Option DIAGTRUNC (die ich deaktiviert habe) erzeugt eine Warnungsdiagnose für diese.

Die Compiler-Option TRUNC (BIN) könnte verwendet werden, um COMP als COMP-5 zu behandeln, aber die MOVEs sind eine andere Möglichkeit, dies zu tun.

Da es sich um COBOL handelt, muss die Ausgabe in GROSSBUCHSTABEN erfolgen (eine Lüge, aber nur zum Spaß).

HELLO WORLD!

OK, unnachgiebig, produziert jetzt:

Hello, World!

Da dies eine ungerade Anzahl von Zeichen ist, sind einige weitere Änderungen erforderlich, da wir mit diesem Compiler keine binären Felder mit ungerader Anzahl von Bytes haben können. Schauen Sie sich diese Linie von 13 Xs an! Es würde normalerweise als X (13) geschrieben werden, kann aber so sein, wie ich es gezeigt habe ...

Und ORTEXT wird als Name benötigt (oder auch nicht OR), da OR für den Compiler ein reserviertes Wort ist (es bedeutet natürlich OR).

Dies sind EBCDIC-Werte, keine ASCII-Werte, da sie auf einer EBCDIC-fähigen und Big Endian-fähigen Box ausgeführt werden.

Oh, COBOL erfordert viele Punkte. Ich habe sie ausgelassen (sie sind verboten), also habe ich viele Kompilierungsnachrichten erhalten. Ich habe den Compiler gerade angewiesen, den Code trotzdem zu generieren (keine der Meldungen bezieht sich auf den Objektcode).

Auch ohne DIAGTRUNC sind die Nachrichten jetzt bis zu 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 (nur mit Alumni und Leerzeichen)

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

Ausgabe: Hello, World!

Javascript

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

Verwenden Sie zum Testen die Browserkonsole.

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

Alphanumerische Einzellösung:

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

Oben ist ein Update, das Dr. Rebmus exzellenten Vorschlag verwendet add space 1(der produziert !), um zu allen Charakteren zu gelangen.

Unten ist die Originalversion:

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

Kürzere Version mit Klammern:

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

Und noch kürzere Version mit Hosenträgern:

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

Und kürzeste Version mit beiden Klammern:

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

Rebol verwendet geschweifte Klammern {}für mehrzeilige Anführungszeichen . Also völlig gültig unter Regeländerungen, aber nicht ganz in vollem Geist (IMHO) wie meine ersten beiden Antworten oben.

NB. Das zu drucken !war ein Schmerz!

Rebol erlaubt und verwendet Interpunktionszeichen routinemäßig für Funktionsnamen und Datentypen. Optionen wie to-char 33oder sind to char! 33nach den Regeln nicht zulässig (auch wenn diese Interpunktionen keine Operatoren sind).

Zum Glück fand ich eine freche Art und Weise durch das Rebol Systemobjekt drehen: make object! [...]in einen String und Kirsche Pick , dass !von ihm :)

Update: Und jetzt auch noch ein Komma aus dem Lizenztext im Systemobjekt.

C

Verwendet nur alphanumerische Zeichen, Leerzeichen und Klammern {}, Klammern [] und Klammern ().

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

printf () akzeptiert ein Zeichen * als Argument, aber da wir keine Anführungszeichen (") verwenden können, typisiere ich die Zeichenfolge als ein langes langes Array. Die hier angezeigten Werte sind ASCII-Zeichenfolgen in Little Endian (0x48 = H, 0x65) = e, 0x6c = l usw.) Ich habe es zu long long [] typisiert, da ich auf diese Weise ein 8-Byte-Argument übergeben und daher nur zwei printf () -Aufrufe anstelle von vier verwenden kann.

BBC BASIC

Emulator bei bbcbasic.co.uk

Trenne dich von meiner LOGO-Antwort.

Der einfache Weg

Die Zahlen auf der rechten Seite sind nur ASCII-Codes. Dies ist genauso wie beim Drucken. Wenn mir ein Komma erlaubt wäre, könnte ich es in einer einzigen Zeile machen ( 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

Ein kreativerer Weg

    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 ist genau das richtige Werkzeug für diesen Job.

5735816763073854918203775149089P

Der PBefehl DCs -command ruft eine Zahl vom Stapel ab und gibt ihre rohe Computerdarstellung an STDIO aus. Sehen als 5735816763073854918203775149089 = 0x48656C6C6F2C20576F726C6421, was wie 0x21, 0x64, 0x6C... = 'H', 'e', 'l'...in einer Little-Endian-Architektur dargestellt wird, gibt es aus Hello, World!.

JavaScript!

Und sie sagten, dass es nicht möglich sei ... Keine Zuweisungsoperatoren, keine Verkettungen, keine Anführungszeichen! Arghhhh!

Fürchte dich nicht ... Für die Kraft withbist du ...

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

Update: Es ist gelungen, eine Reihe von Charakteren zu entfernen, indem auch eine Weltfunktion eingeführt wurde.

Eine andere Javascript-Lösung, die in console.log schreibt:

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

Inspiriert von diesem Eintrag .

Zuerst definiere ich die Funktionen Hello und World. Dies wird später verwendet.

Dann starte ich meine Kette von verschachtelten Withs. Die with (console)und with (String)werden verwendet, damit ich sie später aufrufen kann console.logund String.fromCharCodeohne einen Punkt zu verwenden.

Es ist nun geplant, den String Hello, World!durch den Missbrauch verschachtelter Withs zu erstellen. Jedes Mal, wenn ich concat () aufgerufen habe, wird der resultierende String der Kontext im nächsten with-Block sein. Ich mache eine Abkürzung, um schnell "Hello"auf die nameEigenschaft der HelloFunktion zuzugreifen . Dann verkette ich die Komma- und Leerzeichen mit String.fromCharCode.

Der nächste Trick ist, den "World"Teil der Zeichenfolge zu erhalten. Ich kann nicht dieselbe Methode verwenden, die ich zuvor verwendet habe Hello, da ich World.name nicht aufrufen kann. Stattdessen habe ich diese Logik in die World-Methode eingefügt und sie aufgerufen.

Schließlich hänge ich das letzte Ausrufezeichen an und sende das Ergebnis direkt an die Protokollfunktion, die natürlich console.log ist.

Perl

In einem modernen Perl (5.10 oder neuer):

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

In älterem Perl:

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

Beide oben genannten Lösungen verwenden Perl- qZitat-ähnliche Operatoren und ermöglichen selektive Begrenzer zum Zitieren einer Zeichenfolge, z. q{} q[] q() q//

Diese Lösung erfordert die Regeländerung, die Klammern, Klammern oder Parens zulässt. Ich bin der Meinung, dass eine mniipexzellente Perl-Antwort mehr im Sinne der Regeln (+1) ist, obwohl sie absolut gültig ist.

Wenn ich ein Blatt aus der mniipAntwort herausnehme, könnte meine Lösung so geschrieben werden:

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

und während es für das Auge härter ist, funktioniert es.

Perl

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

Python:

import antigravity 

verursacht "Hallo Welt!" auf Ihrem Bildschirm erscheinen. Glaubst du mir nicht? Probieren Sie es aus! Dies nutzt das Web nicht wirklich, sondern öffnet einen Browser, der möglicherweise eine Website aufruft.

Leerzeichen

Okay, wir können Whitespace verwenden. Es verwendet nur Space, Tab, LineFeedund ignoriert alle anderen Zeichen.

Mit Kommentar: S, Toder LMittel Space, Taboder LineFeedsind.

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

Mit Hervorhebung: http://en.wikipedia.org/wiki/Whitespace_(programming_language)#Sample_code

dc, (26 bytes für die golfspieler)

Leerzeichen und []Klammern sind jetzt zulässig:

[Hello]n44P[ World]n33P[]p

Ausgabe:

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

Rebmu , 46 Zeichen

pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01pnADsp01

Starke Parallelen zur Lösung von @ dragetun in Rebol (weil Rebmu ein Rebol / Red-Lehrmittel ist, das als "Dialekt" die Aufmerksamkeit auf die Sprachen lenken soll, indem es bei Code Golf rockt. :-P)

Um die fehlenden Zeichen zu finden, habe ich jedoch etwas offensichtlicheres getan. Ich habe nur das Leerzeichen erweitert, anstatt die Systemzeichenfolgen zu durchsuchen. Sie können Leerzeichen 1 hinzufügen , um das Zeichenliteral # "!" und füge Leerzeichen 12 hinzu , um das Zeichenliteral # "," zu erhalten.

Wenn wir dies ausführen, können wir sehen, dass es "unbemerkt" wird:

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

Welches ist ziemlich logisch:

; 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

T-SQL, 52

Ah, das ist besser! Direkte binäre Konvertierung, nur 52 Zeichen.

SELECT CAST(0x48656C6C6F2C20576F726C6421 AS VARCHAR)

Vorher...

Es gibt eine viel klügere und Golfier Lösung dieses Problem , die funktionieren würde, wenn wir nutzen könnten =und +(Nachschlagen integrierte Standard-Daten in msdb und die Verwendung dieser ein EXEC-able Query - String zu konstruieren)

Aber da wir nicht können, erhalten Sie diesen naiven Ansatz:

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, wer braucht den numerischen Teil von alphanumerisch?

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

Dies ist vom Gebietsschema abhängig, daher kann Ihr Kilometerstand variieren. Wenn Sie dieses Ergebnis jedoch wirklich replizieren möchten, können Sie anstelle der Importanweisungen Folgendes verwenden:

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

(Dies ist nicht Teil meines Beitrags. Ich teile nur meine Einheimischen aus Gründen der Erholbarkeit.)

J - 73 Zeichen

Es kann doch getan werden!

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

Hier ist die Sache mit J. Die meisten Primitiven sind ASCII-Interpunktion, gefolgt von bis zu zwei Punkten oder Doppelpunkten. Bei den Primitiven, die keine Interpunktion enthalten, handelt es sich um alphanumerische Zeichen, denen zwei Punkte oder Doppelpunkte folgen. Wir dürfen also nichts davon, außer { } [ ]. [und ]sind Identitätsverben und damit unbrauchbar.

Zum Glück {Indizes Arrays, also wenn wir haben, sagen sie, eine Zeichenfolge mit jedem einzelnen ASCII - Zeichen ( a.genannt Alphabet ), können wir die Buchstaben aus durch ihre ASCII - Codepunkte ziehen. Wir haben auch eine Backup-Methode, um Strings zu machen , 0 : 0und dann Sachen und dann einen Lone ). der Doppelpunkt , in dem hat einen Aliasnamen in der Standard - Bibliothek, def.

Dann gibt es ein Verb in der Standardbibliothek show, das Ihnen die interne Darstellung eines Verbs gibt, wenn Sie den Namen als Zeichenfolge übergeben. Es gibt ein anderes Verb, dodas eine Zeichenfolge auswertet. Wenn wir also aus einer a.solchen Darstellung eine herausziehen können , können wir das auswerten und herausziehen Hello, World!.

Unser Retter kommt in Form von take, ein Alias ​​für {.das hat einen ain seinem Namen. Wir show'take'werden wiederkommen take=: {., damit wir unsere a.und damit eine Lösung haben.

Wir können es loswerden, {indem wir das im Wesentlichen äquivalente pickElement aus der Standardbibliothek verwenden, aber das Paren am Ende kann nicht vermieden werden.