Circa un anno fa, il 31 dicembre 2015, ho avuto l'idea che:

Dovremmo creare una stringa di capsule temporali. Tutti potranno aggiungere un personaggio e nei prossimi anni vedremo chi potrà realizzare il miglior programma tra tutti i personaggi con gli esolang che esistono allora.

Doorknob ha gentilmente raccolto personaggi della comunità PPCG e li ha tenuti al sicuro per un anno.

Un enorme 74 persone hanno partecipato quindi abbiamo uno spiffing 74 stampabili ASCII personaggi con cui giocare!

Ecco i 74 caratteri della stringa della capsula del tempo 2016 nell'ordine in cui sono stati inviati:

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Ecco i 74 caratteri della stringa della capsula del tempo 2016 in ordine ASCII (nota lo spazio iniziale):

 !!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

Non è molto da lavorare, ma qui ci piace una sfida.

La sfida

Per determinare quale lingua è "migliore" con la stringa della capsula del tempo avremo 6 (per 201 6 ) sfide che aumentano in difficoltà dove in ognuna devi usare un sottoinsieme dei 74 caratteri della capsula del tempo.

Avere 6 sfide distinte aiuta a garantire che più lingue possano competere, ma solo le migliori lingue saranno in grado di rispondere a tutte e ottenere punteggi alti.

punteggio:

• Ogni sfida verrà segnata da 0 a 74 in base al numero di personaggi utilizzati.
• I punteggi più alti sono migliori.
• Se la tua lingua non può completare una sfida, il tuo punteggio per quella sfida è 0.
• Qualsiasi sottoinsieme non vuoto delle sfide può essere completato.
• Il tuo punteggio finale è la somma dei punteggi di tutte e 6 le sfide.
• Il miglior punteggio finale possibile è 6 × 74 o 444 .

Le sfide

1. Esegui

Se il codice di una lingua non può essere eseguito in primo luogo, non sarà in grado di fare nulla.

Scrivi il programma completo più lungo possibile (usando solo i caratteri della capsula del tempo 74, ricorda) che viene eseguito / eseguito senza errori di compilazione o di runtime.

Non importa cosa fa il programma, non importa se ha input / output o entra in un ciclo infinito, importa solo che funziona senza errori. (Gli avvisi sono ok, così come gli errori causati da un input utente errato.)

I commenti sono consentiti, quindi potrebbe essere semplice come

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

in Python per un punteggio di 74.

(Non abbiate paura di rispondere se questa è l'unica sfida che la vostra lingua può completare, ma non aspettatevi nemmeno un sacco di voti.)

Punteggio = durata del programma (programma più lungo è meglio)

2. I / O

Un linguaggio che non ha alcuna forma di input o output è quasi inutile come uno che non può essere eseguito.

Dato un carattere ASCII stampabile da !(0x33) a }(0x7D) incluso, emette il carattere ASCII stampabile prima e dopo di esso.

L'output può essere una lunghezza di due stringhe o elenchi oppure i caratteri separati da uno spazio o da una nuova riga.

Ad esempio, se l'input è }l'output potrebbe essere |~o ["|", "~"]o | ~o |\n~.

Allo stesso modo, "è l'output per !ed ACè l'output per B.

Punteggio = 74 - durata del programma (programma più corto è meglio)

3. Brancabilità

I condizionali sono spesso un requisito per la completezza di Turing , che è spesso un requisito per una lingua utile.

Dato un numero intero positivo, se termina con le cifre decimali, 16cambia 6in a 7e invia il risultato; in caso contrario, immettere l'input invariato. Se lo si desidera, è possibile utilizzare stringhe per input / output.

Esempi:

2016 -> 2017
16 -> 17
116 -> 117
1616 -> 1617
6 -> 6
15 -> 15
17 -> 17
106 -> 106
2106 -> 2106

Punteggio = 74 - durata del programma (programma più corto è meglio)

4. Loopabilità

Un linguaggio che non può fare loop genererà codice ripetitivo così noioso che dovrai fare una pausa di programmazione per un po '.

Dato un numero intero positivo, genera un quadrato di arte ASCII di quella lunghezza laterale riempito con un motivo di quadrati concentrici più piccoli che si alternano tra due distinti caratteri ASCII stampabili . Non devono essere gli stessi due caratteri per input diversi.

Per esempio:

1    <- input
X    <- output

2
XX
XX

3
XXX
X-X
XXX

4
XXXX
X--X
X--X
XXXX

5
YYYYY
Y...Y
Y.Y.Y
Y...Y
YYYYY

6
XXXXXX
X----X
X-XX-X
X-XX-X
X----X
XXXXXX

7
ZZZZZZZ
Z-----Z
Z-ZZZ-Z
Z-Z-Z-Z
Z-ZZZ-Z
Z-----Z
ZZZZZZZ

Punteggio = 74 - durata del programma (programma più corto è meglio)

5. Matematica

Un linguaggio che non è buono con i numeri e la matematica può anche essere per le discipline umanistiche.

Non prendere input ma emettere i 72 divisori interi del 2016 , positivi e negativi, in qualsiasi ordine. L'output può essere formattato come stringa o elenco in modo ragionevole.

Esempio:

-1, -2, -3, -4, -6, -7, -8, -9, -12, -14, -16, -18, -21, -24, -28, -32, -36, -42, -48, -56, -63, -72, -84, -96, -112, -126, -144, -168, -224, -252, -288, -336, -504, -672, -1008, -2016, 1, 2, 3, 4, 6, 7, 8, 9, 12, 14, 16, 18, 21, 24, 28, 32, 36, 42, 48, 56, 63, 72, 84, 96, 112, 126, 144, 168, 224, 252, 288, 336, 504, 672, 1008, 2016

Punteggio = 74 - durata del programma (programma più corto è meglio)

6. Esoterismo

(No, non quello .) A PPCG piace la nostra roba esoterica e le quine ne sono un buon esempio.

Scrivi il quine più lungo che puoi, secondo le normali regole del quine . Un quine è un programma che non accetta input e si emette da solo.

Punteggio = durata del programma (programma più lungo è meglio)

Regole specifiche

• In ognuna delle 6 sfide il tuo programma deve essere un sottoinsieme dei 74 caratteri capsula del tempo riorganizzati nel modo che preferisci. Può essere un sottoinsieme vuoto o un sottoinsieme improprio , quindi ognuno dei tuoi programmi può avere fino a 0 e fino a 74 caratteri.
• Una singola riga finale alla fine di input / output / codice va bene ovunque poiché alcune lingue lo richiedono o non può essere facilmente evitata.
• Se non diversamente specificato, ogni sfida può essere completata come funzione o programma completo in base alle nostre impostazioni predefinite .
• Tutte le sfide devono essere completate nella stessa lingua.
• Devi usare una lingua (o versione di una lingua) creata prima del 2017 in qualsiasi parte della Terra .
• Chiunque è invitato a rispondere, indipendentemente dal fatto che tu abbia aggiunto o meno un personaggio alla capsula del tempo.

_{Sentiti libero di usare i personaggi della capsula del tempo 2016 nelle tue sfide.}

Glifo , 74 + ( 74-36 ) = 112

1. Esegui (74 byte)

!!#%QTQT@=A@$!!$)()*!&))+...1449:@HILOQZ\\^`````````eefmpx|||{~~~~~~y~|~ ~

2. IO (36 byte)

!!!#!$!$4419TAHT\ee\OQQQ))*+)..)|~~~

Spiegazione

Glifo sembrava una scelta abbastanza buona per questa sfida, perché non gli importava dei personaggi che venivano usati. Invece, esamina gruppi di quattro caratteri e sceglie il comando in base al modello di ripetizione in quei quattro caratteri. Dato che ci sono molti duplicati nella stringa di capsule temporali, siamo abbastanza flessibili nei programmi che possiamo scrivere, tranne per il fatto che siamo limitati a programmi di 18 comandi (che non è molto in Glypho). Mentre questo mi ha permesso di risolvere abbastanza facilmente i primi due problemi, dubito che Glypho possa gestire gli altri con così pochi personaggi.

Li ho testati usando l'interprete Java recuperato dal 23/06/2006 sulla macchina di ritorno , che utilizza una mappatura leggermente diversa dei comandi:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

Il Run programma traduce in:

1d-+[...]

Dove ... spazzatura che non mi sono preoccupato di tradurre.

1      Push 1.
d      Duplicate.
-      Turn into -1.
+      Add. Gives 0.
[...]  Skip the rest because the top of the stack is zero.

L' IO programma traduce in:

id1-+o1+o

Ecco cosa fa questo:

i   Read a character.
d   Duplicate.
1   Push 1.
-   Turn into -1.
+   Add to character, i.e. decrement it.
o   Output it.
1   Push another 1.
+   Add to character, i.e. increment it.
o   Output it.

CJam, 74 + (74-14) + (74-26) = 182 punti

1. Esegui (74 byte)

e# !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````efmpxy{||||~~~~~~~~~

In movimento e# in primo piano commenta l'intera riga.

2. I / O (14 byte)

9`)ZH*+~):Q(Q)

Dennis ha salvato 8 byte.

Spiegazione:

9`                   Push "9".
  )                  Extract character '9'.
   ZH*               Push 3 * 17 = 51.
      +              Add to get character 'l'.
       ~             Eval as CJam code. Command l reads a line.
        )            Extract the only character from the input line
         :Q(         Assign to Q and decrement
            Q)       Push Q and increment

3. Branchability (26 byte)

4`)4Z|`I!`|~^~~T$AT$*%H(=+

Spiegazione:

4`)                            Push character '4'
   4Z|`                        Push 4 | 3 = 7, stringify
       I!`                     Push !18 = 0, stringify
          |~                   Setwise or and eval to get 70
            ^                  XOR to get 'r'
             ~                 Eval to read input
              ~                Eval the input as CJam code to turn
                               it into an integer
               T$              Duplicate it
                 A             Push 10
                  T$*          Duplicate that and multiply → 100
                     %         Mod the copy by 100
                      H(=      Compare to 17 - 1 = 16
                         +     Add the result (1 or 0) to the original

Guarderò gli altri più tardi. ( EDIT : Dubito che siano possibili, senza letterali a blocchi o stringhe ... forse quello matematico?)

J, punteggio 71 + (74-19) = 126

Compito 1, lunghezza 71

AHILO=:( |T`T`Z`e`e`f`m`p`x`y|.~~%~@{|~^|Q@Q@Q+.*.449!~!~!~!!#$$&1\\~~)

Questo definisce un verbo AHILOessere l'interno. inutilizzato:

)))

Non credo che ci sia modo di allungare il tempo.

Compito 3, lunghezza 19

+($#~$~4)=1e4|&%:*~

Il modo per eseguire questa attività senza restrizioni è +16=100|]il seguente:

        ]  Input
    100|   mod 100
 16=       equals 16? (Evaluates to 1 or 0)
+          Add to input.

Ne abbiamo +, =e diverse copie o |a nostra disposizione, ed è facile spostarsi ], ma i numeri sono più problematici. Ecco la prima parte che calcola l'input modulo 100:

1e4|&%:*~
       *~  Input squared (multiplied with itself).
1e4        The number 10000.
   |       Perform modulo
    &      on
     %:    their square roots.

Dopo aver finito, produciamo il numero 16. Il modo semplice è con *~4(4 moltiplicato per se stesso), ma l'abbiamo già usato, *quindi è proibito. Invece, faremo qualche manipolazione di array.

($#~$~4)
    $~4   Reshape 4 to shape 4, resulting in the array 4 4 4 4.
  #~      Replicate wrt itself: replace each 4 by four 4s.
 $        Take length.

Lavoro

2

Questo è assolutamente impossibile. Gli unici modi per manipolare i valori dei personaggi sono a.eu: e non abbiamo accesso a nessuno dei due.

Ora, se potessimo usare ainvece, diciamo A, allora questa sarebbe una soluzione:

Q{~(*^.4%9 1)+I.~&Q=:a.

La parte più difficile per farlo funzionare è stata la produzione del numero -1.

Q{~(*^.4%9 1)+I.~&Q=:a.
                     a.  The array of all bytes.
                  Q=:    Bind it to Q
              I.~&       and find the input's index in it.
   (        )+           Add the following array:
    *                    Signum of
     ^.                  logarithm of
       4%                4 divided by
         9 1             the array 9 1.
                         This evaluates to -1 1.
Q{~                      Index back into Q.

4

(*.1:"|~@+.)

Questo genera la forma della buccia, ma non riesco a trovare un modo per generare personaggi. Ahimè.

5

Certo, questo sembra il più semplice dei compiti da svolgere in J. Tuttavia, senza i. , questo sarà abbastanza difficile.

6

Questo è probabilmente impossibile senza un quine finto 449o qualcosa del genere, perché la stringa di capsule non contiene virgolette o altri modi di produrre stringhe J.

PowerShell - Punteggio totale: 74

1. Esegui - Punteggio: 74

#~= `TeQ.)`~H|$QL4yA)\*`!^O$1)!Z`!`~|\`&T@!x+e(f|Q`.|!4%.{~`:~~)m@~`@p~I9~

Dato che questo è estremamente difficile in PowerShell (ogni possibile metodo per ottenere input è impossibile con i caratteri indicati, per quanto ne so), almeno ho deciso di randomizzare la prima sfida, quindi non tutti copiamo direttamente l'esempio dalla posta.

Quindi ecco un generatore di risposte a sfida casuale 1 (per le lingue in cui #è un commento):

'#'+$(-join([char[]]' !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~'|Get-Random -Count 73))

Provalo online!

meme , punteggio di ( 62 65 + 70) 135

1: Esegui

Ho rimosso tutti i backtick ( `) e gli operatori matematici. Sono in conflitto perché non c'erano abbastanza numeri per soddisfare ogni operatore unario e binario. Ne ho lasciati alcuni, risultando in +3 byte . Programma risultante:

 !!!!!#$$%&())))...+1^4*49:=@@@AHILOQQQTTZ\\eefmpxy{||||~~~~~~~~~

Non ho idea del perché e di come abbia funzionato. Atleast non genera alcuna eccezione di runtime C # e quindi non si arresta in modo anomalo.

6: Quine

Sai, se ci fosse stata una -o una minuscola qda qualche parte in quei 74 personaggi, sarebbe troppo facile. Sono contento per l' Ioperatore, almeno.

1/4I

Questo codice non è esattamente ovvio. Ecco una spiegazione:

1    Set object to 1 (1)
/4   Divide by 4     (0.25)
I    Set object to a fraction string. (1/4)

Le stringhe di frazione (ad es. 1/4) Vengono visualizzate con una I alla fine, per indicare esattamente quello. L' Ioperatore di solito è inutile, l'ho aggiunto per altri mezzi, ma ehi, funziona così!

Il codice sopra non è valido. Stupido, non ho visto che i 74 caratteri non contengono un solo operatore di divisione, forwardslash ( /). Ho trovato qualcos'altro però:

True

Spiegazione:

T    Set object to "true" (bool value)
rue  None of these are valid tokens, so they don't get interpreted.

Output True(a causa del modo in cui gestisce C #Boolean.ToString() maiuscole e non le minuscole). Non sono sicuro che questo sia un vero quine, nel frattempo sto ancora spaccando la testa per uno valido, davvero corretto e intuitivo.

Potrebbe forse anche risolvere la sfida I / O e matematica, ma mi mancano token (personaggi) specifici che non sono inclusi nei 74 caratteri.

Brainfuck, 74 byte

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Dovevo solo.

Spiegazione:

Qualsiasi personaggio che non sia un personaggio Brainfuck valido viene trattato come un commento. L'unico codice che viene effettivamente eseguito è questo:

.+..

Questo non produce output stampabili, poiché né 0 né 1 sono caratteri stampabili in ASCII. Tuttavia, non causa un errore, quindi completiamo con successo la prima sfida.

Mathematica, punteggio di 62

Sarei sorpreso se qualcuno riuscisse a far funzionare le sfide 2-6 in Mathematica. Ecco il meglio che ho fatto con la sfida 1:

A:=1.`!#&@(4`+4.`*9.`^$$H~I~L~O~Q~Q~Q~T~T||Z||e@@efmpxy%)!!!!

Definisce una funzione piuttosto stupida Acon un valore costante. I 12 personaggi non utilizzati sono:

)))\\`````{~

Ottava, punteggio 74

1. Esegui

x =@(AHILOQQQTTZeefmpy)+.1||!!!!!~~~~~~~~~4.^.4||9%#$$)))*@@\`````````{\&:

50 di questi caratteri fanno parte della funzione, mentre i restanti 24 non lo sono.

Cosa fa:

x =@(AHILOQQQTTZeefmpy)crea una funzione xche può accettare una variabile AHILOQQQTTZeefmpycome input.

Per capire il resto:

a||bchiama la funzione all()su entrambi ae b. Se uno o entrambi restituiscono true, l' ||operatore restituirà true.

!ae ~asignifica la stessa cosa qui, sono entrambi not(a).

a.^b è un potere saggio elemento (a(1)^b(1), a(2)^b(2) ...)

Spiegazione continua

Accorcerò ciascuno dei passaggi mentre procedo:

4.^.4||9  % This is 4 raised to the power of .4||9
          % .4||9 is true, since both .4 and 9 are true
          % true is evaluated to 1 when used in an expression
...       % 4 raised to the power of 1 is simply 4.
4         % The above expression simplified

E:

!!!!!~~~~~~~~~4  % ! and ~ are the not() operator, so this is equivalent to:
not(not(not(not(not(not(not(not(not(not(not(not(not(not(4))))))))))))))

C'è un numero pari di not, quindi questo equivale a not(not(4))quale è trueo 1.

+.1||1      % This is equivalent to all(+.1) | all(1), which returns true

Il resto è commentato.

*> <> , punteggio totale = 74

1. Corri, segna 74

f:4%*e+e14=p!Q H@~^)$.`~A|Q)~`\ZI~O.~@``#|9@)T\T`(!``|`~!y!`)Q~$x.|m~~&!L{

Provalo qui!

Questo è stato estremamente difficile da fare senza il ;personaggio. In realtà ho pensato che sarebbe stato impossibile per un paio di momenti, fino a quando non ho visto% , avevo praticamente rinunciato.

Anche questo è un programma> <> valido.

Spiegato (parti irrilevanti omesse)

f:4%*e+e14=p!Q 

f:               copy 15
  4%             pop 15, push 15%4 (3)
    *            pop 15 and 3, push 15*3 (45)
     e+          pop 45, push 45+14 (59, ascii ";")
       e         push 14
        14=      push 0
           p     replace coord (14, 0) with ";"
            !Q   skip Q (this is just filler)
              ;  end execution

Sfide affrontate

Potrei provare le altre sfide ... sarebbero estremamente difficili e potrebbero comportare la flessione delle regole in modi strani ma un uso liberale degli |specchi e! trampolini dovrebbe rendere possibile almeno un'altra sfida.

Queste sfide sono particolarmente difficili perché non è consentito alcun output con *> <> ( oe n), o anche chiamate di funzione ( C), return di funzione ( R) o terminatori di programma ( ;). Anche se ci manca anche l' iinput, possiamo ancora avere input inseriti nello stack, il che è un vantaggio. Un altro vantaggio è che otteniamo una singola pistruzione, che ci consente di sostituire un'istruzione nella casella di codice. Questo potrebbe essere usato più volte (non ho ancora trovato un modo pratico), il che farebbe iniziare a rendere più possibili gli altri programmi (dato che saremmo in grado di generare due o più istruzioni).

Haskell, punteggio 63

1. Esegui:

(!!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~)fmpxyAHILOQQQTTZ e=14`e`49

Non sono utilizzati )))```````{. I commenti in Haskell sono --o{- ... -} , quindi non esiste una versione semplice di tutti i commenti.

Questo codice definisce un operatore infix !!!!!#$$%&*+...:@@@\^||||~~~~~~~~~che accetta due argomenti:

1. fmpxyAHILOQQQTTZ che viene ignorato e può quindi essere di tipo arbitrario
2. e, che deve essere una funzione che accetta due numeri

Nel corpo della funzione eviene quindi applicato a 14 e 49, usando la `notazione -infix.

Esempio di utilizzo:

Prelude> () !!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~ (*)
686

Viene applicato l'operatore (), la tupla vuota e (*)l'operatore di moltiplicazione, quindi 14*49 = 686viene calcolato.

Provalo online!

Altre sfide

Dubito che una qualsiasi delle altre sfide sia possibile, in particolare a causa della mancanza di possibili nomi di variabili che possono apparire due volte, il che è solo e(o qualcosa del genere eQT), perché i nomi delle variabili non possono iniziare con una lettera maiuscola. Certo, averne solo uno =non aiuta neanche.

Pyth, 131 per ora (2 sfide completate)

1. Corri, 74

# `````````!!!)!)!)*$AOeIefLmpxQ|Q|y|Q|~~~~~~~~~()${+%&\=@@@^\:.1.4.49TTZH

Questo programma non accetta input e non crea output.

Questo programma utilizza $$, che consente l'esecuzione di codice arbitrario, e quindi è vietato online, quindi questo programma online funziona offline. Ecco l'output della compilation, in modo da poter vedere cosa viene effettivamente eseguito:

while True:
 try:
  (repr(repr(repr(repr(repr(repr(repr(repr(repr(Pnot(Pnot(Pnot()))))))))))))
  imp_print(Pnot())
  imp_print(Pnot())
  imp_print(times(AOeIefLmpxQ|Q|y|Q|~~~~~~~~~(),uniquify(plus(mod(("=" and lookup(lookup(lookup(Ppow(":",.1),.4),.49),T)),T),Z))))
  imp_print(H)
 except Exception:
  break

È abbastanza complicato scrivere un programma con caratteri arbitrari che non sbagliano in Pyth. Mi sono posto l'ulteriore sfida di richiedere l'esecuzione del programma senza richiedere input da parte dell'utente.

Il primo passo è usare #per mangiare tutti gli errori. Avanti, dobbiamo evitare gli errori causati da ~, Ie Lche hanno ciascuna i propri dati. Ciò si ottiene inserendoli all'interno di $$, che li incorpora nella compilation di output e li sottopone quindi alle regole di compilazione di Python, non a quelle di Python. Infine, per evitare di ricevere l'input dell'utente, i vari token arity 0 (variabili e simili) vengono posizionati alla fine e gli Qs vengono spostati all'interno del $$blocco.

2. IO

Sarà incredibilmente difficile, se possibile. Nessuna delle funzioni Pyth che creano stringhe o caratteri arbitrari è presente tranne .f, e che fa un lavoro davvero scadente nella creazione di caratteri arbitrari.

3. Branchability: 74-17 = 57

|&x%Q*TTye|LZ9Q+1

Provalo online

Un programma Pyth equivalente sarebbe:

?n%Q100 16Q+1

Questo codice prende l'input mod 100, lo confronta con 16 e quindi usa un ternario per scegliere tra l'input e l'input più uno. A causa delle restrizioni sui personaggi, ho effettuato alcune sostituzioni:

• Invece del ?ternario, ho usato |&, orquindi and, che ha la stessa funzionalità, tranne che si rompe se l'input è zero, ma dato che ci è garantito un input intero positivo, va bene. (Ciò avrebbe potuto essere risolto senza caratteri aggiuntivi, ma in questo modo è più semplice.)

• Invece di confrontare direttamente i due numeri, prendo il loro XOR con x, che è zero se e solo se sono uguali, come desiderato.

• Invece di scrivere 100direttamente, lo generi con *TT, poiché Tè inizializzato a 10.

• Invece di scrivere 16direttamente, lo generi con ye|LZ9. |LZessenzialmente funziona come funzione di intervallo, quindi |LZ9dà [0, 1, 2, 3, 4, 5, 6, 7, 8]. eprende l'ultimo elemento di un elenco, dando 8. yraddoppia, dando 16come desiderato. Con un extra +o un extra *potrei salvare un personaggio, ma sono entrambi più utili altrove.

E c'è dell'altro!

Rubino - Punteggio: 74

1. Esegui

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Afferrato dalla sfida.

JavaScript (ES6), punteggio = 74

1. Eseguire, 74 byte

Z=` !!!!!#$$%())))...1449:@@@\AHILOQQQTT^\`eefmpxy{||||~~~~~~~~~`*``+``&``

6. Esoterismo (non valido)

Per la cronaca, il mio quine suggerito era:

1.4e+49

che si è rivelato non valido, come discusso nei commenti seguenti.

Retina, punteggio 74

1. Corri, segna 74

)))` !!!!!#$$%&()*.+..1449:=@@@AHILOQQQTTZ\\^````````eefmpxy{||||~~~~~~~~~

Ho spostato le parentesi extra nella configurazione per consentire loro di bilanciarsi nella regex. Ho anche spostato il `diritto dopo quelli, e cambiato +.in .+.

Provalo online

Gli altri sono probabilmente impossibili, dal momento che non ci sono nuove linee. Non c'è anche nessun -per la traslitterazione o dper una classe di caratteri cifre.

Pip, segna 74 + (74-19) = 129

Così tanti backtick con nary una citazione da vedere, singolo o doppio!

Compito 1, punteggio 74

`` `\``!!!!!`#$$%&())))*+...1449:=@@@ILOQQQTTZ\^efmpx{|||~~~~~~~~~`|`yeAH`

Fondamentalmente solo una serie di letterali pattern (regex) in backtick, l'ultimo dei quali è stampato. Dato che esiste un numero dispari di backtick, dobbiamo fare backslash-escape di uno di essi ( `\``). Provalo online , con il-w bandiera aggiunta per dimostrare che non vengono generati avvisi.

Compito 3, punteggio 55 (lunghezza 19)

e+!!e%(1.#x.!9)=4*4

Utilizzando un metodo di input piuttosto strano - il quinto argomento della riga di comando - questo è possibile. Provalo online!

                     e is 5th cmdline arg; x is empty string
       1.#x.!9       Concatenate 1, 0 (length of x), and 0 (not 9)
    e%(       )      e mod 100...
               =4*4  ... equals 16?
  !!                 Logically negate twice
e+                   Add to e (+1 if number mod 100 is 16, +0 otherwise)
                     Expression is autoprinted

Altre attività

È possibile ottenere input per l' attività 2 , con lo stesso metodo dell'attività 3 precedente. Il problema è la conversione in codice ASCII e il ritorno in un carattere. Il primo può essere fatto con A, ma il secondo richiede C, o eventualmente indicizzare nella PAvariabile. Costruire e valutare il codice non può essere fatto senzaV . Non penso che il compito sia possibile.

L'attività 4 è impegnativa anche senza un set di caratteri limitato. Probabilmente richiederebbe elenchi (senza usare i []delimitatori o RL(ripeti elenco) e avere solo una possibilità di usare AL(aggiungi elenco) - probabilmente) o possibilmente qualcosa con CG(griglia di coordinate) o MC( coordinate mappa), entrambi non consentiti .

L'attività 5 è al limite delle possibilità. I loop sarebbero difficili, poiché Fo e Map non sono possibili e non è possibile costruire intervalli ,. Potrebbe esserci qualcosa da fare con i Tmalati. L'incremento potrebbe essere della x:x+1varietà (ovviamente con una variabile diversa da x, però). È possibile utilizzare i controlli di divisibilità% . Tuttavia, non penso che ci siano abbastanza personaggi - specialmente lettere ripetute - per fare tutto ciò che deve accadere.

L'attività 6 sembra del tutto impossibile. Tutti i quines Pip conosciuti "li contengono . Usano anche R(sostituisci), RP(repr) o V(eval), nessuno dei quali è disponibile.

In realtà, segna (74 + 0 + 0 + 0 + 0 + 0 ) = 74

Sì, la stringa di capsule funzionerà con Actually come per Run, poiché effettivamente elimina qualsiasi errore e ogni errore diventa NOP.

H@~*^)$.~+1A|Q)p~\Z!IQ~e:O.~@#|9@)Tf\eT`=(!|~!y!) Q~$x.4|m4~~&!L{%( Provalo online! )

Produrrà un casino di cose, però (ma anche la sua fonte una volta: 3).

Lavorerò su altre sfide, comunque.

05AB1E - Punteggio totale: 74

1. Eseguire, 74 byte

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Tutto ciò che provoca un errore viene ignorato da 05AB1E. Tutta questa riga di codice è un NOP.

Provalo online!

(abusato) PHP, 74 + 74 = 148

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

L'interprete PHP scarica semplicemente il codice sorgente fino a quando non trova un <?dato che ci manca <ogni permutazione di quei caratteri è un quine in esecuzione. Immagino che questo non sia poi peggio che usare un comando quin incorporato: P

Mathematica, punteggio 68

`A: = .1% *. 44y # +. 9 ^` H @ `$ I @` L @ (`$ O ~` Q ~ `Q ~` Q ~ `T ~ T ~ Z ~ e ~ e | f | m | p | x) !!!!! & \

Nota la nuova riga finale. Non credo che nessuna delle altre sfide possa essere raggiunta con Mathematica.

Labirinto, punteggio 74

AH)
IL)
OQ:
`=!)~`{+4.@ !!!$$%&(*..149@@TTZ\\^```eefmpxy||||~~~~~~~~
`Q#
`Q)
``!

Sono abbastanza sicuro che qualsiasi assortimento di questi personaggi produca un programma Labyrinth valido, ma per renderlo almeno leggermente più interessante, questo stampa 2016cifra per cifra. (In breve: spingi 2 2in pila, pop / stampa uno, sposta l'altro in pila aux, stampa 0, premi 2 1in pila, pop / stampa 1, incrementa, bit a bit no, annulla (l'ultimo1 è a 3a questo punto), somma con il2 dallo stack aux, 5 * 10 + 4 = 54, stampa come valore ASCII, termina)

La maggior parte della linea lunga viene semplicemente ignorata, come il @ termina il programma.

Le sfide 2, 3 e 4 sono impossibili poiché nessuno dei comandi di input di Labyrinth è disponibile ( ,o ?), e non ho trovato nulla per 5 o 6.

SmileBASIC, 48 punti

sfida 1:

@LOQQQTTZ A$=H$+@efmy+@9414*!exp(!!.||!!.#||I%):

spiegazione:

@LOQQTTZ 'label
A$= 'set value of A$ (string)
H$ 'string
+@efmy 'adds label, interpreted as string literal
+@9414 'adds label, interpreted as string literal
*!exp( 'multiplies by logical not e^x (= 0)
!!. 'not not 0.0 (= 0)
||!!.# 'or not not 0.0 converted to a float (= 0)
||I% 'or I% (integer variable)
: 'equivalent to a line break, does nothing here

altri:

Non sono disponibili comandi di input / output, quindi il resto non è possibile.

Tuttavia, non male per un linguaggio reale senza usare commenti.

MATL , punteggio totale 74

1. Corri, segna 74

`4.e4 1.$!!!!!T+Zyf9.)AH^ILx@Q@Q@Qm||||~~~~~~~~~:=Tp*O%#$&()))\\````````e{

Tutto è fino al %vero codice. %è un simbolo di commento, quindi i caratteri alla sua destra vengono ignorati.

Il programma viene emesso 1senza errori.

Provalo online!

bash, punteggio 74

1: Esegui. Siamo in grado di eseguire tutti e 74

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

6: Esoterismo:

Il programma vuoto è un quine in bash.

Senza caratteri di spazi bianchi, nient'altro nell'elenco può essere realizzato. Ergo, ho l'iscrizione bash vincente.

Perl 6 , punteggio totale 74

1. Corri, segna 74

my @TOTAL=$!||(e*4...9^e)Z+1~4||!!Q`{fp)))\#\&`~Q!```HI````!~Q:x~~~$~@~@~%

Non ci sono commenti.
(Basta mettere il# davanti per fare anche tutto un commento, ma questo è più divertente.)

Lavoro

Questo è il sottoinsieme della lingua Perl 6 che utilizza solo i caratteri consentiti:

Costanti: e

Digitare i nomi: IO

Funzioni: exp

metodi:
    sul tipo IO: .e .f .x
    (... probabilmente di più.)

Operatori: | infisso: | prefisso:
    ----------- + ----------------------- + ---------
    numerico: | + * + ^ + | + &% | + + ^
    stringa: | ~ x ~ ^ ~ | ~ & | ~
    booleano: | || ~~ | !
    incroci: | | & ^ |  
    misc: | =: = Z .. ... |  

sintassi:
    numero letterale: 1 4 9
    letterali stringa: Q`` Q! ! eccetera.
    comandi di shell: Q: x`` Q: x! ! eccetera.
    Qualunque stella: *
    variabili: my \ $ @ &
    raggruppamento: ()
    commenti: # # `()
    unspace: \

L'ostacolo immediato che impedisce le sfide 2-6 è che non sembra esserci un modo per eseguire l'I / O:

• Se supponiamo che ci sia un file chiamato f, potremmo usare Q`f`.IO.eper verificare se esiste o Q`f`.IO.xper verificare se è eseguibile. Ma non possiamo leggerlo o scriverne.

• Potremmo usare Q:x` `per eseguire un comando di shell (supponendo che troviamo i caratteri per uno). Ma non possiamo interpolare nulla, quindi sarebbe utile solo leggere, non scrivere.

• Poiché non è presente alcun controvento di chiusura, non è possibile creare un blocco lambda (ad esempio {1 + $_}) che restituisca automaticamente il valore della sua ultima istruzione.

• Abbiamo potuto utilizzare l'asterisco per effettuare una lambda espressione (ad esempio 1+*), ma poi possiamo prendere solo argomento, fare riferimento a questo argomento una sola volta, e sono ancora più limitato nella sintassi / operatori possiamo usare.

Lua, punteggio 31

1. Corri (31 di 74 punti)

AHILOQQQTTZeefmpxy=1.%4+(4.*9.)

Jelly , punteggio 74

1. Corri , 74

 ||||!!!!!$$~~~~~~~~^@=@~%449:`e@`e`QAHILOQQTTZ{\\f`m`p`x`y`&`*.#1+.()))).

Non sono sicuro di come fare uno degli altri.

/// , punteggio: 146

1. Corri, segna: 74

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

6. Quine, Punteggio: 72

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ^`````````eefmpxy{||||~~~~~~~~~

Yay, quando non ci sono barre in avanti o indietro nel codice, si stampa da solo.