Ci sono 88 tasti su un piano standard e 95 caratteri ASCII stampabili (codici esadecimali da 20 a 7E):

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

^{('carattere' si riferisce a qualsiasi carattere ASCII stampabile da qui in poi)}

In questo JSFiddle ne ho approfittato e ho creato una sintassi semplice che genera melodie di piano usando AudioSynth . (Se qualcuno mi può indirizzare a un set collegabile di suoni di note di pianoforte reali , te ne sarò grato.)

Ogni carattere nella stringa di input inoltre () 01+-corrisponde a un tasto di pianoforte:

 CHARACTER:  !   "   #   $   %   &   '   *   ,   .   /   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?   @   A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Y   Z   [   \   ]   ^   _   `   a   b   c   d   e   f   g   h   i   j   k   l   m   n   o   p   q   r   s   t   u   v   w   x   y   z   {   |   }   ~
KEY NUMBER:  1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88
      NOTE:  A  A#   B   C  C#   D  D#   E   F  F#   G  G#   A  A#   B   C  C#   D  D#   E   F  F#   G  G#   A  A#   B   C  C#   D  D#   E   F  F#   G  G#   A  A#   B   C  C#   D  D#   E   F  F#   G  G#   A  A#   B   C  C#   D  D#   E   F  F#   G  G#   A  A#   B   C  C#   D  D#   E   F  F#   G  G#   A  A#   B   C  C#   D  D#   E   F  F#   G  G#   A  A#   B   C
    OCTAVE:  0   0   0   1   1   1   1   1   1   1   1   1   1   1   1   2   2   2   2   2   2   2   2   2   2   2   2   3   3   3   3   3   3   3   3   3   3   3   3   4   4   4   4   4   4   4   4   4   4   4   4   5   5   5   5   5   5   5   5   5   5   5   5   6   6   6   6   6   6   6   6   6   6   6   6   7   7   7   7   7   7   7   7   7   7   7   7   8

Quindi RPNPRRRsuona le prime 7 note di Mary Had a Little Lamb usando i parametri di timing predefiniti che puoi vedere nella JSFiddle.

Lo spazio ( ) rappresenta un riposo musicale che dura per un intervallo di note. Così RPNPRRR PPP RUUsuona le prime 13 note di Mary Had a Little Lamb con i resti nei rispettivi posti.

Se qualsiasi carattere a parte ()01è preceduto da una sequenza di 0'se 1' (regex [01]+), quella sequenza viene letta come un numero binario b e il carattere viene sostituito con b copie di se stesso. Quindi 101A11 10+1-0B01Cdiventa AAAAA ++-Cperché 101= 5, 11= 3, ecc. (Una sequenza di 0'se 1' alla fine della stringa non ha alcun effetto.)

Le parentesi corrispondenti ( ()) hanno due scopi:

1. Se il loro contenuto non termina con una sequenza di 0"se 1", tutte le note vengono suonate contemporaneamente a un accordo (che altrimenti non è diverso da una nota). Lo stesso (NQU)vale per l' accordo di Do minore in ottava 4.
   Se sono presenti note duplicate, anche il loro suono viene duplicato. Quindi (NN)e (NNN)suona diverso.
2. Se il tenore fa estremità con una sequenza di 0's e 1' s, tale sequenza viene letto come numero binario b , e le parentesi e il loro contenuto sono sostituiti con b copie del contenuto. Così (NQU11)diventa 9 note individuali: NQUNQUNQU.

Dettagli tra parentesi:

• La nidificazione delle parentesi replicanti (scopo 2) va bene: (N(QU10)11)→ (NQUQU11)→ NQUQUNQUQUNQUQU.
• La nidificazione di parentesi non replicanti (scopo 1) va bene ma non ha alcun effetto: (A((+)C))è la stessa di (A+C).
• Puoi anche combinare entrambi: ((N(QU10))11)→ (NQUQU)(NQUQU)(NQUQU).
• Una sequenza di 0"se 1" prima delle parentesi non replicanti le ripete nello stesso modo in cui i singoli caratteri vengono ripetuti. Così 10(NQU)diventa (NQU)(NQU).
• Una sequenza di 0"se 1" prima della replica delle parentesi non ha alcun effetto.
• (deve sempre avere una corrispondenza ), ma non viceversa: ad es. N)è valido.

Più ( +) e meno ( -) rispettivamente aumentano e diminuiscono la durata delle note o l'intervallo di tempo tra le note, a seconda del loro contesto:

• Quando all'interno parentesi non replicante, immediatamente aumentare o diminuire la variabile durata della nota da un prefissato numero di millisecondi (vedi JSFiddle ). Quindi (++)Ngiocherà Nper una durata più lunga del normale.
• Quando si trovano all'esterno di parentesi non replicanti, aumentano o diminuiscono l'intervallo tra l'inizio della nota successiva e la nota successiva (e ogni intervallo successivo) di un numero predefinito di millisecondi. Quindi ++NPnell'intervallo tra Ne Pè più lungo del solito.

La durata delle note e l'intervallo di tempo tra di esse non possono scendere al di sotto di 0.

Sfida

Ho scelto intenzionalmente () 01+-di essere i 7 personaggi speciali perché possono essere inseriti innocuamente in molti contesti in molti linguaggi di programmazione.

Il tuo compito è quello di scrivere un quine in 512 byte o meno che produca la migliore melodia quando il codice stesso viene usato come stringa di input nel JSFiddle .

Puoi scegliere qualsiasi valore iniziale (numeri interi non negativi) per i 4 parametri intervallo / durata, ma la tua melodia non deve durare più di 10 minuti. Dovresti anche dirci se la tua melodia suona meglio in un determinato strumento.

Regole

• Nel codice sono consentite solo schede, newline e ASCII stampabile. Tutte le ASCII non stampabili vengono ignorate dal creatore della melodia.
• L'output può andare a un file o stdout o l'alternativa più vicina (ad es. Avviso JS). Non ci sono input.
• Nessuna lettura del codice sorgente. Deve essere un vero quine.
• La rimozione di 3 caratteri di origine contigui deve far sì che il programma non funzioni più come quine. Questo per garantire che le persone non scrivano una buona canzone in una stringa, quindi abbiano una piccola porzione di quine per produrla.
  • Così, se il programma è stato MYCODEpoi MYC, MYE, MDE, e ODEdovrebbero essere tutti non essere quines (che può errore o uscita qualcos'altro).

Questo è un concorso di popolarità, vince la risposta più votata.

Aggiornamento: ultima regola rilassata.

C

Ho deciso che mi piaceva il basso rumore rimbombante generato dalla stringa /**/che non è un caso per aprire e chiudere un commento in C. L'unico altro aspetto interessante qui è che 34per a "è sostituito da 35-1(Ending in a 1 intenzionalmente) a evitare accordi terribili. Ho anche provato a rendere drammatico il finale. L'ho fatto davvero. Ho intenzione di modificarlo più tardi per farlo sembrare un po 'meglio.

/**/char*p= "/**/char*p= %c%s%c; int main(){printf(p,34,p,35-1);p++;/**/}/**/";
int main(){printf(p,34,p,35-1);p++;/**/}/**/

Per la mia comprensione delle regole, le sezioni commentate continuano a passare la regola finale perché la loro rimozione si traduce in un quine fallito.

J

Sì, penso che tu possa indovinare come andrà.

È difficile ottenere qualcosa di interessante in J senza parentesi, e poiché raramente puoi terminarli con 0 e 1, la maggior parte delle cose suona come qualcuno seduto sulla metà alta e bassa della tastiera allo stesso tempo. Ho fatto del mio meglio, ti farò sapere.

Ecco una base funky per il piano, credo. Davvero non conosco la prima cosa sulla composizione, ho appena preso un quine e girato un po 'i numeri.

(23 23,~,~i.124+-100){,'(23 23,~,~i.124+-100){,'''

E, solo per divertimento, gioca a questo come EDM. Lo chiamo Japhex Twin .

".s=:'''".s=:'',''''''''&,@(,&'''''''')@(#~>:@(=&''''''''))s'

È possibile confermare la quineiness di queste belle frammenti di codice a tryj.tk .

Musique Concrete con Python

Non ho molto tempo oggi, ma volevo ottenere una risposta. Il genere è una scusa per non sembrare nulla. Forse un effetto sonoro in un videogioco?

BFIN10=r"print('BFIN10=r\"'+BFIN10+'\"'+'\nexec(BFIN10)')"
exec(BFIN10)

C

int(printf)(char*,...); (main)(){char*b=",*",i=(34),*m=("int(printf)(char*,...); (main)(){char*b="),
*z="%s%c%s%c,i=(34),*m=(%c%s%c)%sz=%c%s%c,*B=%c%s%c,*f=(%c%s%c)%s(/*)*/%s/*(*/);}//(+++fim)",*B="(f,
i,m,z),(i,z,m),(m,i),(f,b),(m,i),(m,i),(f,z,m),(m,i),(f,z,b),(m,i),(b,z),(B,i),(38,i),(29,B),(26,i),
(26,i),(B,f),(42,i),(i,m,f),B",*f=(";(printf)");(printf)(/*)*/(f,i,m,z),(i,z,m),(m,i),(f,b),(m,i),(m
,i),(f,z,m),(m,i),(f,z,b),(m,i),(b,z),(B,i),(38,i),(29,B),(26,i),(26,i),(B,f),(42,i),(i,m,f),B/*(*/)
;}//(+++fim)

Suddiviso con interruzioni di riga solo a scopo di presentazione; questo è solo un quine (e soddisfa solo i requisiti di lunghezza) se vengono rimosse le nuove righe.

La dichiarazione printf era necessaria per la compilazione (printf). /*(*/e /*)*/sono stati usati per abbinare le parentesi nel codice, mentre un mix di parentesi e l'operatore virgola sono stati usati per formare accordi dai printfparametri.

Modifica: abbreviato per adattarsi alle esigenze di dimensioni e per rendere il pezzo un po 'più veloce.

Questo suona meglio al piano.

schema

Questo potrebbe non essere particolarmente melodico (in realtà sembra che qualcuno abbia lasciato cadere un maiale morto in un baby-grand), ma almeno è un breve brano musicale. Sarebbe difficile realizzare qualcosa di molto più lungo o meno simile a un maiale volante nello schema.

((lambda (x) (list x (list 'quote x))) '(lambda (x) (list x (list 'quote x))))

Für Golfscript

":H;GHGHCFDA;[34]H+2*{-};":H;GHGHCFDA;[34]H+2*{-};

Questo soddisfa la lettera della regola della rimozione di tre lettere consecutive, anche se non l'intento, mi pare.

Cobra / Lotto

@number float# 2>nul||@echo off
/# 2>nul
for /f "delims=" %%a in (%0) do echo %%a
#/# 2>nul
class P# 2>nul
    def main# 2>nul
        r="# 2>nul"# 2>nul
        s="@number float{3}||@echo off{2}/{3}{2}for /f {1}delims={1} %%a in (%0) do echo %%a{2}#/{3}{2}class P{3}{2}    def main{3}{2}      r={1}{3}{1}{3}{2}       s={1}{0}{1}{3}{2}       Console.write(s,s,34to char,10to char){3}"# 2>nul
        Console.write(s,s,34to char,10to char,r)# 2>nul

Tecnicamente non è un quine in Batch (legge la propria fonte). È comunque una quinta a Cobra.

Suona meglio con la modalità piano, un po 'come la musica a livello di fantasma di un videogioco dell'era mondiale di Super Mario.

Pyth

J"+K+N+J+N+\K+N+K+NJ"K"J"+K+N+J+N+\K+N+K+NJ

Si gioca meglio con la quarta impostazione (quantità + e - intervallo di cambio) a circa 20, resto alle impostazioni predefinite. Suona meglio al piano.

Haskell

(Non sono sicuro che il nome della variabile violi l'ultima regola.)

main=putStr$  jjlmjiebab ++ {--} show jjlmjiebab;jjlmjiebab = "main=putStr$  jjlmjiebab ++ {--} show jjlmjiebab;jjlmjiebab = "

Ideale per pianoforte con durata della nota di 1000 millisecondi e intervallo di nota di 250 millisecondi, con valori standard + e -.