Il tuo obiettivo è quello di scrivere "Ciao, mondo!" (meno le virgolette). Questo è un concorso di popolarità , quindi vince la maggior parte dei voti. La lunghezza del codice verrà utilizzata per rompere i legami.
Tutto va bene, purché rientri nelle seguenti regole:

• Tutti i caratteri devono essere lettere o numeri, pertanto è possibile utilizzare solo caratteri nella stringa "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".
• Tutto il codice che usi deve essere in un unico file, ad eccezione dei moduli / classi importati / qualunque cosa vengano chiamati nella tua lingua preferita.
• Sono consentite solo le librerie / i framework standard per la tua lingua preferita (ad esempio, il modulo Math di Python è consentito, ma Numpy, Scipy e Pygame non lo sono). Consentirò a TkInter di essere lo standard di fatto per le GUI in Python.
• Non è consentito alcun input, che si tratti di leggere da stdin, leggere un file, dispacciare un'immagine o leggere dal web.

+10 punti brownie se capisci come farlo in Java senza piegare le regole.

Sui tuoi marchi, preparati, codifica!

EDIT: parentesi graffe ({}), parentesi ([]) e parentesi (()) sono consentite in quanto ciò sarebbe praticamente impossibile per la maggior parte delle lingue senza di esse. Sto anche rimuovendo la regola del limite di caratteri. Spero che questo lo renderà più interessante.

EDIT ^ 2: è consentito anche lo spazio bianco. Il mio cervello non funziona correttamente, scusa. >. <

Perl

Alcuni dicono che perl è un linguaggio pieno di rumori ascii e simboli casuali come $... Questo non è vero: P

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

Dividiamo questo in sottoespressioni:

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

Dovrebbe essere ovvio che viene eseguito da sinistra a destra fintanto che ogni espressione ritorna vera. Ma che diavolo è s zqzchr 44ze?

In Perl, c'è un gruppo di "quote-come operatori" che comprende q(str), qw(li st), /regex/, s/from/to/tra le altre cose. Si scopre che tutti questi operatori possono usare quasi tutti i caratteri come delimitatore, con un paio di peculiarità: l'apertura della paretesi deve essere chiusa da una parentesi di chiusura corrispondente e se si desidera utilizzare una lettera come delimitatore, è necessario inserire uno spazio dopo la lettera dell'operatore (per chiarirla da una parola nuda).

In questo caso vediamo tre usi dell'operatore s///(sostituzione regex):

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

Tutto delimitato dal personaggio z. La /ebandiera sulle ultime due fa sì che la sostituzione venga interpretata come codice da valutare, piuttosto testo letterale.

Un fatto abbastanza noto su perl è che la maggior parte delle operazioni non è operativa sulla $_variabile builtin se non diversamente specificato. Tutte e tre le sostituzioni continuano a printfunzionare $_in questo caso, quindi prima inseriamo le parole Hello world nella variabile, quindi fissiamo la punteggiatura usando i valori numerici ASCII dei caratteri, quindi stampiamo il contenuto della variabile.

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

(modifica - BBC Basic è passato alla risposta separata come suggerito. La maggior parte dei voti su questo è sicuramente per la risposta LOGO.)

LOGO

Traduzione al sito 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

Uscita (il triangolo verde è il cursore della tartaruga)

Applescript

Nessuna parentesi [], parentesi graffa {}o parentesi ()affatto in questo:

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

L'output è:

bash

Questo tipo di lavori, se socchiudi gli occhi:

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

Soddisfa le regole originali.

Pitone

Quindi, supponiamo che tutti leggano in senso orizzontale? Per quegli utenti a cui piace leggere in verticale:

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)

Poliglotta: HQ9 +, H9 +, HQ9 ++, CHIQRSX9 +, HQ9 + B e HQ9 + 2D (1 byte)

H

Grazie @victor per l'elenco delle lingue.

OMGROFL

Sono un grande fan delle lingue esoteriche. Fortunatamente OMGROFL è alfanumerico:

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

Il izcomando imposta un valore su una variabile, in questo caso lol, loole looolfungono da variabili ...

Il roflcomando riecheggia l'equivalente ASCII del numero memorizzato nella variabile.

Il stfucomando termina il programma;)

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 

Sono necessarie alcune modifiche per diventare solo una fonte alfanumerica.

L'ID PROGRAM può essere eliminato. Ottieni un nome di programma generato (vedi messaggi).

WORKING-STORAGE può essere lasciato cadere. Ancora una volta il compilatore geme.

Dal momento che entrambe le righe in precedenza avevano punti / punti mancanti, che non sono più rilevanti ora che le descrizioni sono del tutto mancanti, il numero di messaggi di errore è lo stesso di prima e continua a non influire sul codice generato per il programma.

Modificando COMP-5 in COMP, le clausole VALUE non sono più consentite, poiché COMP 9999 ha solo quattro cifre decimali mentre COMP-5 è un binario a due byte con tutti i valori di bit disponibili.

I valori nei MOVE sono i valori decimali che danno i valori binari che danno le coppie di caratteri.

Anche se i campi COMP hanno quattro cifre e non consentono clausole VALUE con più di quattro cifre, puoi usare più cifre nel MOVE di un valore letterale senza troncamento a quel punto ... non chiedermi perché. L'opzione del compilatore DIAGTRUNC (che ho disattivato) produrrà una diagnostica di avviso per questi.

L'opzione del compilatore TRUNC (BIN) potrebbe essere utilizzata per trattare COMP come COMP-5, ma i MOVE sono un altro modo per farlo.

Dato che è COBOL, l'output deve essere in MAIUSCOLO (una bugia, ma solo per divertimento).

HELLO WORLD!

OK, ceduto, ora produce:

Hello, World!

Il che, trattandosi di un numero dispari di caratteri, ha richiesto ulteriori modifiche, poiché non possiamo avere campi binari con numero dispari byte con questo compilatore. Guarda quella linea di 13 X! Normalmente sarebbe scritto come X (13), ma può essere come ho mostrato ...

E ORTEXT è necessario (o meno OR, comunque) come nome perché OR è una parola riservata al compilatore (significa ovviamente OR).

Questi sono valori EBCDIC, non ASCII, poiché sono in esecuzione su una casella compatibile con EBCDIC e Big Endian.

Oh, COBOL richiede molti arresti / periodi. Li ho lasciati fuori (sono vietati), quindi ho ricevuto molti messaggi di compilazione. Ho appena detto al compilatore di generare il codice comunque (nessuno dei messaggi si riferisce al codice oggetto).

Anche senza DIAGTRUNC, i messaggi ora sono fino a 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". 

Rubino (usando solo alnum e spazi bianchi)

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

Produzione: Hello, World!

Javascript

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

Usa la console del browser per testare.

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

Solo soluzione alfanumerica:

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

Sopra è un aggiornamento che utilizza il Dr Rebmu, un eccellente suggerimento di add space 1(che produce !) per arrivare a tutti i personaggi.

Di seguito è la versione originale:

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

Versione più corta con parentesi:

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

E anche la versione più corta con le parentesi graffe:

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

E la versione più corta con entrambe le staffe e le parentesi graffe:

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

Rebol utilizza parentesi graffe {}per la quotazione su più righe. Così completamente valido sotto le regole cambia, ma non del tutto in pieno spirito (IMHO) come le mie prime due risposte sopra.

NB. Stampare è !stato un dolore!

Rebol consente e utilizza abitualmente i caratteri di punteggiatura per nomi di funzioni e tipi di dati. Quindi le opzioni come to-char 33o to char! 33non sarebbero consentite dalle regole (anche se queste punteggiatura non sono operatori di per sé).

Fortunatamente ho trovato un modo sfacciato trasformando l'oggetto di sistema Rebol: make object! [...]in una stringa e una ciliegia selezionalo !da esso :)

Aggiornamento: E ora anche Cherry ha selezionato la virgola dal testo della licenza nell'oggetto di sistema.

C

Utilizza solo caratteri alfanumerici, spazi e parentesi graffe {}, parentesi [] e parentesi ().

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

printf () accetta un carattere * come argomento, ma poiché non possiamo usare le virgolette ("), ho inserito la stringa come una matrice lunga lunga. I valori visualizzati qui sono stringhe ASCII, in little endian (0x48 = H, 0x65 = e, 0x6c = l, e così via). L'ho digitato in long long [] poiché in questo modo posso passare un argomento a 8 byte e quindi usare solo due chiamate printf () invece di quattro.

BBC BASIC

Emulatore su bbcbasic.co.uk

Dividi dalla mia risposta LOGO.

Il modo semplice

I numeri a destra sono solo codici ASCII. È lo stesso della stampa. Se mi fosse permesso una virgola potrei farlo su una sola riga ( 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

Un modo più creativo

    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

matematica

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

DC

DC è quasi lo strumento perfetto per il lavoro.

5735816763073854918203775149089P

Il Pcomando DC estrae un numero dallo stack e invia la sua rappresentazione di computer non elaborata a STDIO. Vedendo come 5735816763073854918203775149089 = 0x48656C6C6F2C20576F726C6421, che è rappresentato come 0x21, 0x64, 0x6C... = 'H', 'e', 'l'...in un'architettura little-endian, emette Hello, World!.

Javascript!

E dissero che non si poteva fare ... Niente operatori di assegnazione, niente concatenatori, niente preventivi! Arghhhh!

Non temere ... Perché la forza withsei tu ...

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

Aggiornamento: gestito per tagliare un sacco di personaggi introducendo anche una funzione mondiale.

Un'altra soluzione Javascript che scrive su 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)))

Ispirato da questa voce .

Innanzitutto, definisco le funzioni denominate Hello e World. Questo verrà usato in seguito.

Quindi inizio la mia catena di with nidificati. Gli with (console)e with (String)vengono utilizzati in modo da poter in seguito invocare console.loge String.fromCharCodesenza utilizzare un punto.

Il piano è ora quello di costruire la stringa Hello, World!abusando di nidificati con. Ogni volta che ho invocato concat (), la stringa risultante sarà il contesto nel prossimo blocco con. Prendo una scorciatoia per ottenere rapidamente "Hello"accedendo alla nameproprietà della Hellofunzione. Quindi concateno i caratteri virgola e spazio usando String.fromCharCode.

Il prossimo trucco è ottenere la "World"parte della stringa. Non posso usare lo stesso metodo che ho usato per ottenere Hello, dal momento che non posso invocare World.name. Invece ho inserito quella logica all'interno del metodo World e l'ho invocata.

Infine, aggiungo il punto esclamativo finale e invio il risultato direttamente alla funzione log, che è ovviamente console.log.

Perl

In un Perl moderno (5.10 o più recente):

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

Nel vecchio Perl:

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

Entrambe le soluzioni sopra utilizzano un qoperatore a virgoletta Perl e consentono delimitatori selettivi per la citazione di una stringa, ad es. q{} q[] q() q//

Questa soluzione richiede la modifica della regola che consente parentesi graffe, parentesi o parentesi. Quindi, sebbene del tutto valido, penso che l' mniipeccellente risposta del Perl sia più nel vero spirito delle regole (+1).

Tuttavia, togliendo una foglia dalla mniiprisposta, la mia soluzione potrebbe essere scritta in questo modo:

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

e mentre più duro per gli occhi funziona.

Perl

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

Pitone:

import antigravity 

provoca "Ciao, mondo!" per apparire sullo schermo. Non mi credi? Provalo tu stesso! Inoltre, questo in realtà non utilizza il Web, apre un browser che potrebbe cercare un sito Web.

dc, (26 byte per i golfisti)

Gli spazi bianchi e le []parentesi sono ora consentiti:

[Hello]n44P[ World]n33P[]p

Produzione:

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

Rebmu , 46 caratteri

pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01pnADsp01

Parallelamente alla soluzione di @ dragetun in Rebol (Perché Rebmu è uno strumento di insegnamento Rebol / Red che è un "dialetto" che mira ad attirare l'attenzione sulle lingue dondolando al Code Golf. :-P)

Tuttavia, per ottenere i personaggi mancanti, ho fatto qualcosa di più ovvio. Ho appena aggiunto spazio, invece di andare a cercare le stringhe di sistema. Puoi ottenere spazio 1 per ottenere il carattere letterale # "!" e aggiungi spazio 12 per ottenere il carattere letterale # ",".

Se eseguiamo questo, possiamo vedere che diventa "unmushed":

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

Che è abbastanza logico:

; 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

Lo spazio bianco

Ok, possiamo usare gli spazi bianchi. Si utilizza solo Space, Tab, LineFeede ignora tutti gli altri personaggi.

Con commento: S, To Lmezzi Space, Tabo LineFeed, rispettivamente.

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

Con evidenziazione: http://it.wikipedia.org/wiki/Whitespace_(programming_language)#Sample_code

T-SQL, 52

Ah, va meglio! Conversione binaria diretta, solo 52 caratteri.

SELECT CAST(0x48656C6C6F2C20576F726C6421 AS VARCHAR)

In precedenza...

Esiste una soluzione molto più intelligente e più golfistica che funzionerebbe se potessimo usare =e +(Cercare dati incorporati standard in msdb e usarli per costruire una stringa di query compatibile con EXEC)

Ma poiché non possiamo, ottieni questo approccio ingenuo:

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)

Pitone:

Pfff, chi ha bisogno della parte numerica dell'alfanumerico?

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

Questo dipende dalle impostazioni locali, quindi il tuo chilometraggio può variare. Tuttavia, se si desidera veramente replicare questo risultato, è possibile utilizzare quanto segue anziché le istruzioni di importazione:

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

(questo non fa parte della mia proposta, è solo condividere i miei locali per la ricreabilità)

J - 73 caratteri

Dopo tutto si può fare!

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

Ecco la cosa su J. La maggior parte dei primitivi sono punteggiatura ASCII, seguita da un massimo di due punti o due punti. Quei primitivi che non sono fatti di punteggiatura sono un carattere alfanumerico seguito da due punti o due punti. Quindi non ci è permesso nessuno di questi, tranne che per { } [ ]. [e ]sono verbi di identità e sono quindi inutili.

Fortunatamente, {indicizza le matrici, quindi se avessimo, per esempio, una stringa con ogni singolo carattere ASCII ( a., chiamato Alphabet ), potremmo estrarre le lettere dai loro punti di codice ASCII. Abbiamo anche un modo di backup per creare stringhe , 0 : 0quindi cose e poi un solitario ); i due punti in cui ha un alias nella libreria standard, def.

Quindi c'è un verbo nella libreria standard show, che ti dà la rappresentazione interna di un verbo se gli passi il nome come una stringa. C'è un altro verbo doche valuterà una stringa. Quindi, se riusciamo a estrarre un a.da una tale rappresentazione, possiamo valutarlo ed estrarlo Hello, World!.

Il nostro salvatore si presenta sotto forma di take, un alias per {.quello che ha un anel suo nome. show'take'tornerà take=: {., quindi abbiamo la nostra a.e quindi una soluzione.

Possiamo liberarci {usando l'equivalente essenzialmente pickdella libreria standard, ma il paren alla fine non può essere evitato.