Stufo dell'affidabilità dell'archiviazione flash, hai deciso di archiviare tutti i tuoi programmi su uno di quei buoni vecchi floppy da 1.440 KiB. Tuttavia, dopo aver copiato nemmeno 3.000 programmi, il disco era pieno. Com'è possibile? Esperto nell'arte del code golf come sei, la maggior parte dei tuoi programmi non è lunga nemmeno 100 byte, quindi dovrebbe esserci molto spazio a disposizione ...

Dopo averlo chiesto a Super User, scopri di essere stato torto dalle dimensioni del cluster del file system , una trama malvagia dei progettisti di FAT12 che lascia inutilizzata una parte significativa del tuo floppy e ti costringe ad acquistare più di quanto tu abbia realmente bisogno.

Acquista più floppy? Mai! La dimensione del cluster sarà meno problematica se salviamo semplicemente più programmi in un unico file, il che è possibile perché diversi compilatori / interpreti si comporteranno in modo diverso per lo stesso codice sorgente.

Compito

Scrivi un poliglotta che si adatta a un singolo cluster (512 byte o meno) e risolve il maggior numero possibile delle seguenti attività.

stringa

1. Leggi tutti gli input e stampali.

2. Stampa Ciao, mondo! .

3. Leggi una riga / argomento ( nome ) come input e stampa Buon compleanno, [nome]! .

4. Leggi tutti gli input e stampa I love tabs! se contiene uno o più tabulatori (0x09) e odio gli spazi! se non lo fa.

5. Leggi due righe / argomenti e stampa un valore di verità se il secondo è una sottostringa del primo e un valore di falsa in caso contrario.

6. Leggi una riga / argomento e stampa un valore di verità se i suoi personaggi sono in ordine strettamente crescente e un valore di falsa in caso contrario.

7. Leggi una riga / argomento e un carattere e stampa gli indici di tutte le occorrenze di quel personaggio.

8. Leggi una riga / argomento e stampa uno dei caratteri con il maggior numero di occorrenze.

matematica

9. Leggi due numeri interi compresi tra 0 e 255 e stampa la loro somma.

10. Leggi un singolo intero compreso tra 0 e 255 e stampa il quoziente e il residuo della sua divisione per 7 .

11. Leggi un singolo numero intero compreso tra 1 e 255 e stampa un valore di verità se è un numero composto (né 1 né primo) e un valore di falsa in caso contrario.

12. Leggi un singolo intero compreso tra 1 e 255 e stampa un valore di verità se è una potenza di 2 e un valore di falsa in caso contrario.

13. Leggi due numeri interi compresi tra 0 e 255 e stampa quello più grande.

14. Leggi un numero intero decimale compreso tra 0 e 255 e stampa la sua rappresentazione esadecimale.

15. Leggi un singolo numero intero compreso tra 0 e 255 e stampa il suo peso di Hamming (numero di 1 bit).

16. Leggere un singolo intero n tra il 1 e il 13 e stampare il F _n , il n ^° numero di Fibonacci .

    Ad esempio, per l'input 13, stampa 233.

ascii-art

17. Leggi una riga / argomento di input e inquadralo.

    Ad esempio, per l'input Programming Puzzles & Code Golf, stampare questo:

    +---------------------------------+
    | Programming Puzzles & Code Golf |
    +---------------------------------+
    

18. Leggi un blocco rettangolare di caratteri e ruotalo di un quarto di giro in senso orario.

    Ad esempio, per l'input

    tye
    xll
    epb
    tma
     id
     sa
    s e
    i r
    hsn
    Tiu
    

    stampa questo:

    This  text
    is  simply
    unreadable
    

19. Leggi un numero intero compreso tra 1 e 40 e stampa un diamante di quella lunghezza laterale.

    Ad esempio, per l'input 3, stampare questo:

      /\
     /  \
    /    \
    \    /
     \  /
      \/
    

20. Stampa questo:

    ....@@@@....@@@@....@@@@....@@@@
    ....@@@@....@@@@....@@@@....@@@@
    ....@@@@....@@@@....@@@@....@@@@
    @@@@....@@@@....@@@@....@@@@....
    @@@@....@@@@....@@@@....@@@@....
    @@@@....@@@@....@@@@....@@@@....
    ....@@@@....@@@@....@@@@....@@@@
    ....@@@@....@@@@....@@@@....@@@@
    ....@@@@....@@@@....@@@@....@@@@
    @@@@....@@@@....@@@@....@@@@....
    @@@@....@@@@....@@@@....@@@@....
    @@@@....@@@@....@@@@....@@@@....
    ....@@@@....@@@@....@@@@....@@@@
    ....@@@@....@@@@....@@@@....@@@@
    ....@@@@....@@@@....@@@@....@@@@
    @@@@....@@@@....@@@@....@@@@....
    @@@@....@@@@....@@@@....@@@@....
    @@@@....@@@@....@@@@....@@@@....
    ....@@@@....@@@@....@@@@....@@@@
    ....@@@@....@@@@....@@@@....@@@@
    ....@@@@....@@@@....@@@@....@@@@
    @@@@....@@@@....@@@@....@@@@....
    @@@@....@@@@....@@@@....@@@@....
    @@@@....@@@@....@@@@....@@@@....
    

punteggio

Vince la risposta che riesce a incorporare il maggior numero di programmi in un singolo file che si inserisce in un singolo cluster da 512 byte. I legami sono interrotti dal conteggio dei byte (inferiore è meglio).

Regole aggiuntive

• Per ogni attività che richiedi per il tuo punteggio, lo stesso file (byte per byte) deve costituire un programma completo - in una lingua di tua scelta - che risolve questa particolare attività.

• Ogni compito deve essere risolto in una lingua diversa.

  Le lingue contano come diverse se non sono versioni diverse della stessa lingua. Ad esempio, c'è solo un JavaScript, un Python e un TI-BASIC, ma C, C ++, Octave e MATLAB sono quattro lingue diverse.

• La lingua selezionata per ogni attività deve soddisfare la nostra solita definizione di linguaggio di programmazione .

  Inoltre, la lingua deve essere stata pubblicata e implementata prima del 9 settembre 2015.

• Il compilatore / interprete potrebbe non richiedere alcun flag non standard per produrre il comportamento previsto.

  Le eccezioni a questa regola includono flag richiesti per specificare una lingua particolare, per leggere il programma da un (singolo) file o per sopprimere un banner.

• L'input per ciascuna attività sarà composto da caratteri ASCII stampabili (da 0x20 a 0x7E) e da avanzamenti di riga (0x0A) e non supererà i 255 byte di lunghezza.

• Tutti i numeri interi possono essere letti in decimale o unario, se non diversamente indicato nell'attività.

• Il comportamento per input non valido non è definito.

• È possibile leggere l'input da STDIN (o la sua alternativa più vicina) o come argomenti della riga di comando.

  Se un'attività richiede la lettura di due elementi di input, è possibile leggerli, in qualsiasi ordine, separati da un delimitatore a un byte di propria scelta, come argomenti della riga di comando separati o uno da STDIN e l'altro come argomento della riga di comando.

  Se uno dei pezzi di input è una riga, l'unico delimitatore possibile è un avanzamento riga.

• Stampa l'output su STDOUT (o l'alternativa più vicina). Tutti gli output su STDERR verranno ignorati.

• Per ogni attività, si applicano le regole standard del golf di codice .

  In particolare, ciò include le scappatoie che sono vietate per impostazione predefinita , ad eccezione della codifica effettiva dell'output , che è esplicitamente consentito per questa sfida.

12 lingue, 418 byte

"1\"# &&+.@\""" "" "
#=
''''
<<s
""'("']0=~2base{+}*}
 ?
 :_7/!\_7%!@
"
R"Happy Birthday, "[?S"!"*"
>0[0>i:0(?v:{)?v0n;\!/
$'main';n1< .95<
 \@-[I love tabs!]o#
  \ >qi---@
( @-[ ]e<''';print hex(
input())#-[I hate spaces!]o#"]];ri:X{_~X+S*'/@S*_'\4$N}%_sW%1>"))?(!?)
'''=#print(([1 1;1 0]^int(readline()))[1,2])
#=
Tr is here.
>Tr, Hello, World!
>X Tr
s
l=gets
a='+-'+?-*~/$/+'-+'
puts a+'
| %s |
'%l+a#=#.91<0#'''#";

Questa è una sfida divertente. Sta diventando difficile adattarsi a più lingue, ma con così tanti byte rimasti probabilmente ne potrei fare ancora uno.

Utilizza gratuitamente i linguaggi 2D. Si noti che il carattere tra [ ]la @-[ ]e<linea è una scheda. Inoltre, ciò richiede la \nfine delle righe affinché TRANSCRIPT funzioni.

Preludio (Task 1 / Cat)

( 
      )?(!?)

?(!?)è solo una traduzione diretta di ,[.,]in BF. I ()loop di preludio si comportano come []loop di BF , quindi tutto, dalla (colonna più a sinistra a quella )precedente, non viene eseguito il programma principale.

Le regole di sintassi di Prelude significano che le parentesi devono essere abbinate (leggendo da sinistra a destra colonna) e può esserci solo una parentesi per colonna. A parte questo, è un linguaggio abbastanza semplice per adattarsi.

Assicurarsi che NUMERIC_OUTPUTsia impostato su Falsese si utilizza l'interprete Python.

TRANSCRIPT (Task 2 / Hello world)

Tr is here.
>Tr, Hello, World!
>X Tr

TRANSCRIPT è un esolang tematico basato sulla narrativa interattiva. Le linee non riconosciute da TRANSCRIPT vengono ignorate, facilitando l'adattamento.

Tr is here.dichiara una Trvariabile stringa e la seconda riga imposta il contenuto della variabile su Hello, World!. X Tr( Xper esaminare) quindi genera la stringa.

Sebbene TRANSCRIPT sia molto facile da integrare, è un linguaggio piuttosto prolisso, quindi l'ho fatto accettare la sfida più semplice.

Fissione (compito 3 / messaggio di compleanno)

R"Happy Birthday, "[?S"!"*
                   \!/

che stampa la prima parte, inserisce l'input con un piccolo ciclo 2D, quindi emette il punto esclamativo finale. I Rsignifica che un atomo inizia qui muovono verso destra, che è utile perché questo programma può essere spostato ovunque.

Rail (Task 4 / Schede)

$'main'
 \@-[I love tabs!]o#
  \ >qi---@
  @-[ ]e<
         -[I hate spaces!]o#

Come Fission, Rail è un linguaggio 2D che ha il vantaggio di poter essere spostato ovunque. Esecuzione inizia dal $della mainfunzione direzione sud-est.

Per prima cosa scendiamo a \s, giriamo a sinistra in -, colpendo [<tab>]che spinge una linguetta. e<poi rami basati su EOF - se EOF, ci dirigiamo verso il basso e stampiamo "I hate spaces!"prima di fermarci, altrimenti andiamo su. Se ci dirigiamo verso l'alto, leggiamo il carattere successivo e lo confrontiamo con la scheda, ancora una volta ramificata - se la scheda, vai su e stampa "I love tabs!"prima di fermarti, altrimenti vai giù e continua il ciclo di input.

Questo programma è piuttosto costoso, ma dal momento che TRANSCRIPT ha preso Hello World, è stato difficile scegliere il compito appropriato per Rail.

> <> (Attività 6 / Ingresso crescente)

"1\"#      \""" "" "


>0[0>i:0(?v:{)?v0n;
       ;n1< .95<


        .91<

Stampa 1se strettamente ascendente, 0altrimenti.

> <> è un altro linguaggio 2D e l'esecuzione inizia in alto a sinistra. "..."è la modalità stringa, spingendo i caratteri interni uno alla volta. Dopo la prima stringa che colpiamo #, che riflette l'IP verso sinistra, spingendo più stringhe e avvolgendo (> <> è toroidale) prima di colpire \, uno specchio che ci riflette verso l'alto.

Alla fine del programma c'è .91<, che ci teletrasporta (9, 1), dove si trova il programma principale. Dopo questo 0[rimuove tutta la spazzatura dalle stringhe, 0spinge uno zero per rappresentare l'ultimo carattere letto, e dopo questo sta solo leggendo i caratteri uno alla volta, assicurandoci che stiamo ancora salendo.

Probabilmente è meglio spostare il programma principale verso il basso invece di teletrasportarsi, ma se ne occuperà in seguito, se necessario.

Befunge (Task 9 / Aggiunta)

"1\"# &&+.@

Testato con l'interprete trovato qui . Questo è un programma piuttosto semplice, con l'inizio che spinge una corda inutile e #salta nello spazio. Dopodiché è solo il programma principale &&+.@.

Labyrinth (Task 10 / Divmod by 7)

"1
 =
 '
 <
""'("']
 ?
 :_7/!\_7%!@

Convenientemente, 'e "sono i NOP di Labyrinth che agiscono come un percorso percorribile nel labirinto. Salterò la navigazione disordinata, ma fondamentalmente c'è molto da girare e vagare in giro prima di colpire ?, che è l'inizio del programma principale.

Il programma non è completamente a sinistra per tenere conto di Prelude (ad esempio, ?viene letto l'input in Prelude).

Python 2 (Task 14 / Esadecimale)

"1\"# &&+.@\""" "" "
#=
''''
xxx
xxx''';print hex(
input())#xxx
'''
xxx
xxx'''#";

Le xxxs rappresentano parti irrilevanti commentate da stringhe o commenti multilinea. Nel mezzo c'è print hex(input())il programma principale. Questo produce un vantaggio 0x, ma suppongo che vada bene (in caso contrario, è comunque una soluzione semplice).

La prima riga è una stringa "1\"# &&+.@\""seguita da due " "s. Queste tre stringhe vengono concatenate dal parser e non vengono utilizzate (questa prima riga funziona in modo simile per Ruby e Julia in seguito).

GolfScript (Task 15 / Peso di Hamming)

"1\"# &&+.@\""" "" "
#=
''''
<<s
""'("']0=~2base{+}*}

La prima riga spinge tre stringhe e la seconda riga è un commento. ''''spinge altre due stringhe, quindi <<esegue due confronti ( sviene ignorato). Alla fine, ""'("'preme altre due stringhe.

Tutto questo è spazzatura viene quindi rimosso avvolgendolo in un array e ottenendo il primo elemento ( ]0=), che è l'input inizialmente nello stack. Quindi valutiamo l'input con ~, trasformiamo in binario con 2basequindi sommiamo i bit con {+}*. Il prossimo }è senza eguali e commenta in modo superbo il resto del programma.

Julia (Task 16, Fibonacci)

"1\"# &&+.@\""" "" "
#=
xxx
xxx=#print(([1 1;1 0]^int(readline()))[1,2])
#=
xxx
xxx=#.91<0#xxx

#=avvia un commento multilinea e =#termina un commento multilinea. Il programma principale utilizza l'esponenziazione della matrice per calcolare i numeri di Fibonacci (presi da Rosetta ).

Ruby (Task 17 / frame ASCII)

"1\"# &&+.@\""" "" "
#=
''''
<<s
xxx
s
l=gets
a='+-'+?-*~/$/+'-+'
puts a+'
| %s |
'%l+a#xxx

Questo programma presuppone che l'input non si concluda con una nuova riga finale.

Abbiamo una stringa inutile, un commento, un'altra stringa inutile quindi un'eredità che commenta la maggior parte del programma. Dopodiché è il programma principale, seguito da un #commento a riga singola .

CJam (Task 19 / Diamond)

"1\"# &&+.@\""" "" "
#=
''''
<<s
""'("xxx
"
R"xxx"[?S"!"*"
xxx
xxx"ri:X{_~X+S*'/@S*_'\4$N}%_sW%1>"xxx
xxx
xxx";

Le due stringhe di spazio alla fine della prima riga devono soddisfare CJam, poiché #=sono due operatori binari. Non entrerò in troppi dettagli con questo, ma fondamentalmente è un disastro, con il programma principale che è il semplice

ri:X{_~X+S*'/@S*_'\4$N}%_sW%1>

nel mezzo.

Il principale fattore di differenziazione tra GolfScript e CJam è che, in CJam, una singola virgoletta 'non inizia e termina le stringhe, ma inserisce invece il carattere successivo nello stack. Ciò significa che in CJam

'("'

push a (quindi avvia una stringa con "(il cui primo carattere è '), mentre quanto sopra è solo una singola stringa dritta in GolfScript.

Provalo online . 1>viene utilizzato invece di (tenere conto di Prelude.

Ecco 12 lingue, 373 byte . Alcune attività sono state spostate, TRANSCRIPT è stato rimosso (ha reso Rail troppo costoso) e è stato aggiunto Scheme (pollo). Questo è solo il mio campo da golf per i futuri aggiornamenti poiché l'aggiornamento del post principale richiede un'eternità.

"1\"09!#.&&+.@"" "" "#|"
#=
''''
<<s
11]0=~2base{+}*}
 ?
 :_7/!\_7%!@
"
R"Happy Birthday, "[?S"!"*"
>0[0>i:0(?v:{)?v0n;\!/
$'main';n1< .95<
(-[Hello, World!]o#''';print(input()in input());'''"]];ri:X{_~X+S*'/@S*_'\4$N}%_sW%1>"=#print(([1 1;1 0]^int(readline()))[1,2])#=)?(!?)
s
l=gets
a='+-'+?-*~/$/+'-+'
puts a+'
| %s |
'%l+a# =##'''#";e# |#(print(format"~x"(eval(read))))

Potrei salvare alcuni byte per Julia poiché i commenti multilinea non terminati generano un errore su STDERR.

7 8 9 10 lingue, 398 431 447 507 byte

Questo è probabilmente il massimo che posso inserire nella soluzione attuale.

#if      + 0+0/*^",v  +- '[.,][[" ,yadhtrib yppaH"l?!;offf4+ + +0.0 +aa<*/
a=0--0;b=input();print(sorted(set(b))==list(b));[[""""                 ^ <
print("Hello, World!")--[[vv? +<
#endif/*  >.!0 + +1ffr"!"~< */
#include<stdio.h>/*>:1 +?!^>i:1^*/
int main(){int a=1,b=1,c,i;scanf("%d",&i);if(1//**/1==2
){printf("%x",/*>&:7/.7%.@*/i);}else{for(;--i-1>0;a=b,b=c)c=a +b;printf("%d",b);}}/*]]--"""]];#@;_J + + \+*\-hhlz \+s[\|dzd\|)J "` + +,*.]]]*/SSSTNSSNSNSTNTTTTTSSSTNSNSTNTTTTTTSSTNTTSNSSNNSSSNTTTTNSTNNNN

L'ultima riga contiene il codice degli spazi bianchi codificato in modo che SE non lo mangi. Per eseguire il codice, sostituire tuttoS con spazi, Tcon schede e Ncon nuove righe.

C89, compito 16

Ecco cosa vede il compilatore:

int main(){int a=1,b=1,c,i;scanf("%d",&i);if(1/ 1==2
){printf("%x",i);}else{for(;--i-1>0;a=b,b=c)c=a+b;printf("%d",b);}}

Tutto il resto è messo a nudo come commenti o all'interno di #if 0 .

C ++, compito 14

Ho usato un trucco rubato da qui per differenziare tra C89 e C ++.

int main(){int a=1,b=1,c,i;scanf("%d",&i);if(1
){printf("%x",i);}else{for(;--i-1>0;a=b,b=c)c=a+b;printf("%d",b);}}

Lua, compito 2

Ecco la struttura di base.

#comment
a=0--comment
print("Hello, World!")--[[
... multiline comment ...
]]--comment

Brainfuck, compito 1

Dovevo solo assicurarmi che non .,si trovassero loop infiniti o randagi . Anche i commenti multilinea di Lua raddoppiano come i commenti di BF. Tutto a parte i primi 2 caratteri è un grande ciclo NOP.

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

Python, compito 6

Ancora una volta, sto usando le funzionalità specifiche della lingua per NOP o commentare l'altro codice.

#comment
a=0--0;b=input();print(sorted(b)==list(b));[["""
... multiline string ...
"""]];#comment

Pyth, task 17

Pyth è carino per questa cosa. Prende il primo #come un while True:ciclo che esce silenziosamente in caso di errore . Quindi, ho solo trasformato la maggior parte del codice in una stringa (in modo da evitare di ;terminare anticipatamente il ciclo), quindi basta terminare il ciclo, uscire da un altro creato dal commento di Python ed eseguire l'attività. Eccolo con tutte le stringhe non vuote sostituite con " string ", è ancora funzionalmente equivalente:

#if      + 0+0/*^" string " ,yadhtrib yppaH" string """" string "Hello, World!" string "!"  string "%d"  string "%x" string "%d" string """]];#@;_J + + \+*\-hhlz \+s[\|dzd\|)J " string

> <>, attività 3

Questo è molto interessante. L'esecuzione rimbalza nel codice, usando i salti dove necessario per aggirare gli ostacoli. Le parti rilevanti:

#                  v            " ,yadhtrib yppaH"l?!;offf4+ + +0.0 +aa<*/
                   i                                                   ^ <
                   !      vv? +<
          >.!0 + +1ffr"!"~<
                   >:1 +?!^>i:1^

Stellato , compito 9

Qui ho dovuto iniziare ad andare nelle lingue "scarta tutti i caratteri tranne". Qualsiasi altra cosa spogliata, sembra:

      + +*,  + '., , + + +. +*                  ,  +*  . + + *.* +*  ,,,,**,*..*, +,* + + +* + ` + +,*.*

Il codice salta la maggior parte della punteggiatura con un salto per evitare un momento difficile, semplicemente usando l'inizio e la fine del codice. Il codice è funzionalmente equivalente a

      + +*,  + + +,*.*

Befunge-98, compito 10

Funziona in modo simile a> <> uno. Fortunatamente, #è un mirror in> <> e un salto in Befunge, quindi possiamo implementare comportamenti diversi. Inoltre, 0/0 == 0.

#if      + 0+0/*^
                >&:7/.7%.@

Spazio bianco , compito 13

Questa è stata l'ultima cosa in cui mi inserisco. Le prime poche righe stanno semplicemente spingendo gli zero nello stack, poiché contengono solo spazi e nuove righe dal codice "normale". Il codice è codificato; sostituisci tutto Scon spazio, Tcon schede e Ncon nuove righe.

SSSSSSSSSSSSSSSN
SSSSSSSSSSSSSSSSSSN
SSN
SSSSSN
SN
SSN
SSSSSSSSSSSTN
SSN
SN
STN
TTTTTSSSTN
SN
STN
TTTTTTSSTN
TTSN
SSN
N
SSSN
TTTTN
STN
N
N

17 diverse versioni di Pip, 383 byte (non valido)

Mentre questa domanda era in modalità sandbox, ho esaminato tutte le revisioni della mia lingua Pip e ne escogitato un poliglotta utilizzandone 17. Purtroppo, ora le versioni della sfida non consentono versioni della stessa lingua, ma con il permesso di Dennis e una dichiarazione di non responsabilità sto pubblicando il mio lavoro comunque.

Il codice grezzo

I!ga:0m@0:0v:uIN[(oTM0,0i)EN1N1Y1RCkw(hR`1.+0``&2o`)@>3@AB0`u`rZ4AB6({a}V7)BN8AZ9@m]Iv<2W##YqlPByc:((J['.'@]X4)X4RL3)Jnc.:n.RVcc:cRL4|0Iv=3{d:sXaRLaFj,ad@j@j:'\d:(RVdR'\'/).d|0dJ:n}m:'+.'-X#a+2.'+.n."| "Iv=5La{i+:oSio}j:ak:bPv=11?a>1&0INa%(2,a)[((J_M ZRVl)|0)Jnl?lJnlcJnd.n.RVdm.a.RVmih:$+TBa({j@aEQk}FI0,#a).saTB16a>b?abh=1ua//7.s.a%7a+bbINa"Happy Birthday, ".a.'!"Hello, World!"]@v

La strategia

In Pip, le lettere minuscole sono variabili. Le lettere maiuscole sono più complicate: sono suddivise in serie di al massimo due caratteri, che possono essere operatori o variabili. Se un token maiuscolo non è specificamente definito come variabile o operatore, si presume che sia una variabile non definita, che viene valutata nulla.

Quindi, per distinguere tra due versioni di Pip, devo solo trovare un operatore variabile o alfabetico che è stato aggiunto nel più recente dei due. Nel precedente, sarà invece zero. Il codice v:uIN[...]mette insieme una grande lista contenente uno di questi controlli per ogni versione che voglio testare, scopre quanti zero sono in quella lista (la uvariabile è esplicitamente inizializzata a zero) e memorizza il numero in v(per "versione") .

Dopo alcuni altri calcoli, c'è un altro grande elenco che calcola i risultati per 17 delle attività dalla sfida e utilizza vper selezionarne uno in base alla versione che è.

Versioni e attività

0.15.09.04

Diagnostica: (oTM0,0i)(risolto un bug con l' operatore Tri in Mcui il taglio di 0 caratteri da ciascuna estremità di una stringa avrebbe dato invece la stringa vuota; l'indicizzazione in stringa vuota dà zero)

Attività 18: Iv<2W##YqlPBy(installazione: leggere tutte le righe da stdin se vè inferiore a 2) seguite da ((J_M ZRVl)|0)Jn(elenco inverso di linee, trasporre e ricollegare in stringa)

0.15.08.06

Diagnostica: EN1(aggiunto ENoperatore umerate)

Attività 1: Iv<2W##YqlPBy(stesso codice di configurazione come sopra) seguito da l?lJnl(join su newline)

0.15.08.03

Diagnostica: 1N1(aggiunta Ncome versione breve INdell'operatore)

Operazione 20: c:((J['.'@]X4)X4RL3)Jnc.:n.RVcc:cRL4|0(impostazione: genera un elenco contenente le metà superiore e inferiore della scacchiera e memorizza in c) seguito da cJn(join su newline)

0.15.08.01

Diagnostica: Y1(aggiunto Yoperatore ank)

Operazione 19: Iv=3{d:sXaRLaFj,ad@j@j:'\d:(RVdR'\'/).d|0dJ:n}(installazione: se vè 3, costruisci la metà superiore del diamante in d) seguito da d.n.RVd(inverti per la metà inferiore e unisciti a Newline)

0.15.06.19

Diagnostica: RCk(aggiunto operatore Rhoom Choice)

Attività 17: m:'+.'-X#a+2.'+.n."| "(setup: build +----+\n| string in m) seguito da m.a.RVm(avvolgi input me reverse di m)

0.15.06.12

Diagnostica: k( kvariabile preinizializzata a ", "; precedentemente non era definita e quindi nulla)

Compito 16: Iv=5La{i+:oSio}(se vè 5, genera il numero di Fibonacci in i) seguito dai

0.15.06.08 ^{(nota: il numero di versione non è stato modificato fino al seguente commit)}

Diagnostica: w( wvariabile preinizializzata a `\s+`)

Attività 15: h:$+TBa(convertire l'input in cifre binarie e somma; salvare il risultato hper l'attività 12 successiva)

0.15.05.29

Diagnostico: (hR`1.+0``&2o`)@>3@AB0

Questa versione è stata aggiunta &come modello sostitutivo per l'intera stringa abbinata in una sostituzione regex (ispirata a sed). Il codice sopra prende h( 100) e lo sostituisce con `&2o`(cioè "1002o"nelle versioni più recenti ma semplicemente "&2o"nelle versioni precedenti). Quindi taglia tutti i caratteri dopo il 3 ° ( "2o"nelle versioni più recenti, ""nelle versioni precedenti) e tenta di indicizzare in quella stringa. L'indicizzazione in una stringa vuota dà zero.

Compito 7: j:ak:b(impostazione: copia i var locali a, i var bglobali j, kquindi saranno disponibili all'interno di una funzione) seguito da ({j@aEQk}FI0,#a).s(filtro per gli indici in acui il carattere corrispondente è uguale be unirsi nello spazio)

0.15.05.26

Diagnostica: `u`(tipo di pattern aggiunto; nelle versioni precedenti, i backtick vengono ignorati come caratteri non riconosciuti e l'espressione viene valutata a uzero)

Compito 14: aTB16(convertire To il B16)

0.15.05.24

Diagnostica: rZ4(creata runa variabile speciale che restituisce un valore casuale compreso tra 0 e 1 ogni volta che viene referenziata; in precedenza non era definita e quindi l'espressione veniva valutata nulla)

Compito 13: a>b?ab(espressione ternaria)

0.15.05.12

Diagnostica: rZ4(aggiunto Zoperatore ip)

Attività 12: h=1(la somma dei bit dell'attività 15 deve essere uguale a 1)

0.15.05.11

Diagnostica: AB6( ABoperatore con valore del soluto aggiunto )

Attività 11: Pv=11?a>1&0INa%(2,a)[...]@v(se vè 11, l'output 1se l'input è maggiore di 1 e un numero più piccolo lo divide esattamente, 0altrimenti; se vnon altro, utilizzare vcome indice nell'elenco per decidere cosa produrre)

0.15.05.02

Diagnostica: ({a}V7)( Voperatore aggiunto ; quando Vnon definito, inviava gli argomenti zero e 7 a una funzione {a}che restituisce il suo primo argomento)

Compito 10: a//7.s.a%7(input int diviso per 7 e mod 7, spazio separato)

0.15.04.26

Diagnostica: BN8(aggiunto operatore Begation itwise N)

Compito 9: a+b

0.15.04.23

Diagnostica: AZ(preinizializzataAZ variabile in alfabeto maiuscolo)

Attività 5: bINa( INfornisce il conteggio delle occorrenze)

0.15.04.20

Diagnostico: m@0:0 seguita da9@m

La mvariabile è preinizializzata su 1000. In questo commit, l' @operatore è stato corretto per restituire i valori; in precedenza, assegnando a ha m@0dato un avviso e non ha fatto nulla. Quindi, post-bugfix, la prima istruzione imposta msu 0000, che è un indice legale per 9; pre-bugfix, mrimane1000 , che non è un indice legale. (Gli indici non erano ancora ciclici.)

Compito 3: "Happy Birthday, ".a.'!

0.15.04.18

Tutta la diagnostica precedente comporta l'aggiunta di un valore zero all'elenco di diagnostica.

Compito 2: "Hello, World!"

La maggior parte dell'altro codice sono modifiche che ho dovuto fare per evitare errori in varie versioni. Questo post è già troppo lungo, quindi se vuoi sapere qualcosa che non ho spiegato, passiamo alla discussione nella chat room delle lingue esoteriche .

6 lingue, 226 byte (229 a seconda di come \x1bviene accettato!)

/&&#[+.#]@>>+[>,]<[<]>>[.>]>\[/;//;#<?die("\x1bc".max($argv[1],$argv[2]));/*
$a=['Hello','World'];//;printf"%s, %s!
",$a[0]||'Happy Birthday',$a[1]||pop;#";$a="\
#";alert(prompt().match("\t")?"I hate tabs!":"I love spaces!");/\]/

Quindi, non credo di aver fatto la scelta migliore delle lingue e immagino che non sia particolarmente competitivo, ma ho trovato comunque una sfida interessante! Nel complesso, non sono state completate molte sfide, ma potrei probabilmente calzare una sfida negli spazi bianchi o qualcosa di simile, ma questo è quello che ho finora:

1. Brainfuck

[+.]>>+[>,]<[<]>>[.>]>[<.[],[][,],,[],[].]

Testato su http://copy.sh/brainfuck/ e http://brainfuck.tk/ .

Dopo aver eliminato tutti i caratteri ignorati, il programma sopra è tutto ciò che ci rimane, che è solo il programma cat di esempio con alcuni loop vuoti extra per bypassare l'uso delle altre lingue dei simboli.

2. Rubino

/&&#[+.#]@>>+[>,]<[<]>>[.>]>\[/;//;
$a=['Hello','World'];//;printf"%s, %s!
",$a[0]||'Happy Birthday',$a[1]||pop;

Uso:

ruby cluster

Quanto sopra è il codice dopo che tutti i commenti sono stati rimossi. La prima linea è del tutto inutile in Ruby, come si definiscono alcune espressioni regolari per contenere il codice Befunge-93 e Brainfuck, viene creato un array per contenere Helloed Worlde stamparlo utilizzando printf(per aggiungere l' ,e! ).

3. Perl

/&&#[+.#]@>>+[>,]<[<]>>[.>]>\[/;//;
$a=['Hello','World'];//;printf"%s, %s!
",$a[0]||'Happy Birthday',$a[1]||pop;

Uso:

perl cluster <name>

Molto simile a Ruby, tranne che dal momento che stiamo memorizzando un riferimento di matrice in $a, quando proviamo ad accedere $a[0]è vuoto, quindi possiamo sostituirlo con il testo per challenge 3, Happy Birthdaye pop(che mostra l'ultimo argomento al programma da riga di comando ).

4. JavaScript

/&&#[+.#]@>>+[>,]<[<]>>[.>]>\[/;
$a=['Hello','World'];
",$a[0]||'Happy Birthday',$a[1]||pop;#";$a="\
#";alert(prompt().match("\t")?"I hate tabs!":"I love spaces!");/\]/

Utilizzo: incolla nella console del browser ed esegui.

Come Ruby e Perl, la prima riga crea essenzialmente RegExpoggetti inutili , quindi memorizziamo un array inutile $ae istanziamo due stringhe inutili, una contenente il codice Ruby / Perl e una contenente una nuova riga e una #, quindi noi prompt()per l'input e alert()il risultato attesi dalla maggior parte degli umani per la sfida 4. Finiamo con un altro inutileRegExp Finiamo oggetto per chiudere l'anello del cervello.

9. Befunge-93

/&&#[+.#]@

Testato su http://www.quirkster.com/iano/js/befunge.html .

A quanto ho capito, /divide lo stack e spinge il risultato che non ha effetti negativi se non spingendo NaNsul sito sopra, &chiede l'inserimento di un numero intero in modo da leggere entrambi i numeri richiesti dalla sfida 9 sullo stack, #assicurandoci di saltare il [che è lì per Brainfuck, +quindi aggiunge i primi due numeri in pila, .li emette, #]per Brainfuck di nuovo ed @esce.

13. PHP (in esecuzione in Bash)

/&&#[+.#]@>>+[>,]<[<]>>[.>]>\[/;//;#<?die("\x1bc".max($argv[1],$argv[2]));

Uso:

php cluster <x> <y>

In PHP, tutto ciò che non è incluso nei <?tag viene emesso testualmente, quindi questo emette Befunge-93 e il codice brainfuck, quindi die()immediatamente nel codice, produciamo uno schermo clear ( \x1bc) quindi max()il primo dei due argomenti.

6 lingue, 450 404 byte

bash, brainfuck, C, gawk4, JavaScript e Minimal-2D

/*\t/#[R,+/D
/\t/ # UL.-L<script>var s=prompt().split(' ');alert(+s.pop()+ +s.pop())</script>
sed "s/^\(.*\)$/Happy Birthday, &!/;q"&&0
/\t/#*/
#define func
func main(){puts("Hello, World!");}
//{split($0,b,_);for(i in b)a[NR][i]=b[i++]}END{for(;j++<i;print"")for(k=NR;k;)printf a[k--][j]}
#//]++++++++[>+>+>++++++>++++++++<<<<-]>>++>--<<[>>>>>+++[<++++[<<....>....>-]<<<.>>>>-]<<<[>>+<<-]<[[>+<-]<]>>-]

Aggiornamento: golfato un po 'verso il basso. Non sono ancora sicuro di cos'altro aggiungere, e non sono sicuro di come i membri in competizione penserebbero di usare le loro lingue per compiti diversi. Sto cercando di spiegare l'algoritmo Brainfuck.

Bene, questa è / è stata la mia prima esperienza poliglotta, quindi ho dovuto imparare tutto da zero. Iniziare con awk non è stata l'idea più intelligente che penso, perché è relativamente spietata. Poiché il numero di attività completate è rilevante, ho iniziato prima con le attività più semplici. Non sono sicuro che fosse una mossa intelligente. Non si tratta molto di golf, perché non ho avuto abbastanza problemi a far lavorare insieme questi sei, ma ho fatto quello che potevo per farla breve.

Ecco le lingue e cosa fanno in ordine alfabetico. Mostrerò un modo semplice per testarli tutti più in basso. Poiché alcuni di questi potrebbero essere specifici della versione, ti fornirò i numeri di versione degli strumenti che ho usato.

bash, compito 3

Bene, è ovvio che ho usato sed. Ho provato a mettere una sceneggiatura sed in questo in qualche modo, ma non sono riuscito a farlo funzionare, quindi ho seguito la strada bash. Il modo in cui lo dico, è all'interno di un commento in C e Awk lo valuta False.

sed --version dà sed (GNU sed) 4.2.2

bash --version dà GNU bash, Version 4.3.30(1)-release (x86_64-pc-linux-gnu)

Quindi la parte sed si riduce a

sed "s/^\(.*\)$/Happy Birthday, &!/;q"

Raggruppa l'input, lo incolla in una nuova stringa e stampa il risultato. Roba abbastanza comune.

brainfuck, compito 20

Beh, questo è sempre abbastanza facile da nascondere, immagino. Una riga che inizia con #//viene ignorata da C e awk. O almeno possono convivere con la spazzatura dietro.

bf dà bf - a Brainfuck interpreter version 20041219

Questo è il codice condensato. La prima riga è solo la spazzatura delle altre lingue.

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

Proverò a spiegare come funziona

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

questo organizza il nastro e il puntatore a questo

0 8 10 46 64 C2 C1
  ^

la cella che tiene 8 è il contatore globale per il ciclo seguente
è il numero di volte in cui vengono stampate 3 stesse linee

[>>>>>+++

imposta C1su 3, il numero delle stesse righe

    [<++++

imposta C2su 4, il numero di " ....@@@@" in una riga (all'inizio)

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

stampa un decremento completo della linea C2nel processo
quando C2è zero stampa una nuova riga e diminuisce C1.

se C1è zero la magia accade

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

il 46 viene spostato dietro il 64
il 10 e il contatore globale viene spostato di uno a destra

>>-]

quindi il contatore globale viene decrementato
se è zero il programma esce

C, compito 2

Esaurisco ogni ultima piccola abilità di C qui stampando "Hello, World!". Beh, qualcuno ha dovuto fare il lavoro ...

gcc --version dà gcc (Ubuntu 4.9.2-10ubuntu13) 4.9.2

Il codice C attuale

#define func
func main(){puts("Hello, World!");}
#

Lo scopo #define funcè quello di rendere ok Awk con questo. Pensa che questa sia una funzione awk. L'abbreviazione di func è una caratteristica gawk.

gawk4, compito 18

Dato che ho usato awk praticamente per tutto qui, ho deciso che doveva essere in questo.

awk --version dà GNU Awk 4.1.1, API: 1.1 (GNU MPFR 3.1.2-p11, GNU MP 6.0.0)

awk vede questo

/*\t/
/\t/
sed "s/^\(.*\)$/Happy Birthday, &!/;q"&&0
/\t/
func main(){puts("Hello, World!");}
//{split($0,b,_);for(i in b)a[NR][i]=b[i++]}END{for(;j++<i;print"")for(k=NR;k;)printf a[k--][j]}
#

I modelli di ricerca inclusi \tvalutano false. Ho scelto la scheda qui, perché penso che non possa essere nell'input. sedvaluta false. "the string"&&0valuta falso. La funzione è ok Il programma viene eseguito se viene trovato un modello vuoto, che è per qualsiasi input.

Lo fa

Ingresso

elaic
Parli
ucfit
srigs

Produzione

supe
RCAL
IFRA
gili
STIC

Devi assicurarti che tutte le linee di input abbiano la stessa lunghezza. Usa gli spazi per riempirli.

JavaScript, attività 9

Non sono sicuro che questo sia legittimo, perché era troppo facile. Se si dà la fine del file html al file di programma e lo si apre in un browser (ho usato Firefox 40.0.3 e Chrome 45.0.2454.85), viene richiesto un input. Devi inserire due numeri separati da uno spazio e avviserà la somma di quelli.

<script>var s=prompt().split(' ');alert(+s.pop()+ +s.pop())</script>

Minimal-2D , attività 1

È stato abbastanza facile adattarsi alle righe dei commenti. Ho usato l'interprete , che gira in Python, per provare questo. Stampa l'input sull'output. Il programma si presenta così

R,+/D
UL.-L

RUDL sono a destra, in alto, in basso e a sinistra. Quindi inizia a funzionare correttamente, legge un personaggio dallo stdin in memoria e ne aggiunge uno. La barra salta il comando successivo se la memoria ha il valore 0. Questo serve a terminare. Se viene letto un carattere con valore -1, l'input è terminato. Quindi, se -1 viene letto, salta la D e termina. Se qualcos'altro viene letto, scende a sinistra, aggiunge quel 1 alla memoria e stampa il personaggio su stdout. Quindi va a sinistra, su e ricomincia.

analisi

Dichiarazione di non responsabilità: non mi assumerò alcuna responsabilità per eventuali danni arrecati al sistema con questo.

Questo presuppone che tu abbia bash & co, gawk (almeno la versione 4, perché utilizza array multidimensionali), gcc, python, bf come interprete brainfuck e Firefox installato.

Per semplificare, copiare l'origine del programma in un file denominato cluster.html. Rendi quel file eseguibile per l'attività bash. Copia e incolla l' interprete per Minimal-2d in un file chiamato minimal2D.pynella stessa directory. Quindi copia e incolla il seguente script in un file di script e mettilo nella stessa directory, rendilo eseguibile ed eseguilo ... beh, con chi sto parlando. Se leggi questo probabilmente non avrai bisogno di molte spiegazioni e comunque riuscirai a farlo funzionare in qualche modo.

#!/bin/bash
# Task  3: bash
echo "Dr. Hfuhruhurr" | ./cluster.html 2>/dev/null;echo
# Task 18: awk 
printf "elaic\nparli\nucfit\nsrigs\n" | awk -f cluster.html 2>/dev/null;echo
# Task  2: C
cp ./cluster.html ./cluster.c;gcc -w -o cluster cluster.c;./cluster;rm cluster cluster.c;echo
# Task  1: Minimal-2D
python minimal2D.py cluster.html <<<"This
has
to be
copied     !!!";echo
# Task 20: brainfuck
bf cluster.html;echo
# Task  9: JavaScript
firefox cluster.html 2>/dev/null
#google-chrome cluster.html 2>/dev/null

Lì troverai anche il comando per eseguire i test singolarmente.

Divertiti!