(Ispirato dai 95 personaggi di ASCII ... 95 Citazioni di film )

La sfida

Dato input n, genera il nth numero di Fibonacci . È possibile utilizzare 0o 1indicizzare, si prega di indicare quale nella vostra presentazione. Semplice? Il trucco è che devi prendere il set di caratteri della risposta precedente immediata, rimuovere due caratteri da esso e aggiungere un carattere separato. Il personaggio separato deve

• non appartenere al set di caratteri della risposta precedente immediata
• essere dall'insieme di (ASCII stampabile, spazio, newline, scheda orizzontale)

e quindi la dimensione del tuo set di caratteri totale sarà esattamente una più piccola del set di risposte immediatamente precedenti.

La risposta iniziale

Il primo invio deve contenere un sottoinsieme di (tutti ASCII stampabili, spazio, newline e tab orizzontale) con due caratteri rimossi. Ogni invio in seguito deve limitare le proprie risposte a questo formato originale solo ASCII (il che significa che non è possibile aggiungere un carattere Unicode o ASCII esteso ... scusate Jelly, APL, et al.).

Esempi e chiarimenti

• Supponiamo che la prima risposta sia in C e contenga (quasi tutte le ASCII stampabili, la nuova riga e la scheda orizzontale) e ometta il %e ^dal suo set di caratteri. Il secondo invio, quindi, deve rimuovere due caratteri dal set di caratteri precedente (quasi tutti ASCII stampabile, nuova riga e scheda orizzontale) e aggiungere il carattere %o ^. Forse è una risposta di PowerShell a una riga che omette la nuova riga. E così via.
• Se la risposta precedente aveva print(){}!*+come set di caratteri (12 caratteri), l'invio potrebbe contenere print(){}!(10 caratteri) e un carattere aggiuntivo, print(){!+(10 caratteri) e un carattere aggiuntivo, ecc.
• Se la risposta precedente aveva print(){}!*+come set di caratteri (12 caratteri), la tua presentazione non poteva avere print()e &(8 caratteri) come set di caratteri, da allora 12 - 8 > 1.
• Se la risposta precedente aveva print(){}!*+come set di caratteri (12 caratteri), la tua presentazione non poteva avere print(){}!(10 caratteri) più carattere aggiuntivo *come set di caratteri, poiché anche se sono 11 caratteri, *è incluso nel set precedente.
• Non tutti i personaggi del tuo set di personaggi devono fare qualcosa di utile per la tua presentazione. Ad esempio, se la risposta precedente aveva print(){}!*+come set di caratteri e la tua lingua ha un built-in !che calcola la sequenza di Fibonacci e #che inizia un commento, la tua presentazione potrebbe essere !#print(){}ed essere valida.
• Puoi usare lo stesso personaggio dal tuo set di personaggi più volte. Ad esempio, supponiamo che il tuo set di caratteri fosse !*#_, la tua risposta potrebbe essere !!!**#**#_!!e sarebbe accettabile.
• Oltre al tuo codice (e anche una spiegazione è buona!), Ti preghiamo di elencare esplicitamente il tuo set di caratteri, per rendere più facile l'invio futuro.

vincente

Il vincitore della sfida sarà la persona che ha pubblicato la seconda presentazione più recente (ovvero, non la persona che ha pubblicato l'ultima volta, dal momento che hanno rotto la catena).

Regole finali

Si applicano le normali regole di concatenamento delle risposte :

• La stessa persona non può pubblicare due volte di seguito
• Se una risposta è considerata non valida (ad esempio, ha utilizzato un carattere proibito o non viene calcolata correttamente), deve essere eliminata (e anche tutte le risposte successive che si interrompono)
• Due utenti che pubblicano "contemporaneamente" dovranno lasciare in sospeso l'invio precedente
• La stessa lingua non può essere pubblicata due volte di seguito. Ai fini di questa regola, le lingue della stessa famiglia (ad esempio Python 2 e Python 3) contano come "la stessa lingua".

Cose finali:

• Questo post funziona meglio se si ordina per "Più vecchio" in modo che le risposte siano nell'ordine corretto.
• Kyle Gullion ha costruito un controllo del codice in Python qui per verificare se ti manca o se stai usando caratteri sbagliati.

1. C

Contiene no {o }.

#if 1
#define Q !"$&'",./=@[]^_\`|*
int WERTYUIOPASDFGHJKLZXCVBNM34567890(qwrtyuopasghjklzxcvbm)<%
	return qwrtyuopasghjklzxcvbm<2?1:WERTYUIOPASDFGHJKLZXCVBNM34567890(~-qwrtyuopasghjklzxcvbm)+WERTYUIOPASDFGHJKLZXCVBNM34567890(qwrtyuopasghjklzxcvbm-2);
%>
#endif

Provalo online!

_{Spero di aver fatto bene.}

2. Mathematica

Contiene no }, Zo scheda orizzontale. (Incluso {.)

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

Le due prime righe sono solo un commento; l'ultima riga è la funzione incorporata, utilizzando l'Unico True Super Cosmically Ordained Indexing in cui gli input 0 e 1 producono rispettivamente gli output 0 e 1 (non ho idea se chiamare questo 0-indexed o 1-indexed).

8. Ottava

Aggiunto Ue rimosso +e -. La soluzione non contiene +-`01AEIcaratteri di tabulazione o no .

% !"#$&\'*./256789:<>?BCDFGHJKLMNOPQRSTUVWXYZ\\_abceghijklnpqrstuvwyz{|}~
f=@(x)([mod(4,3) mod(4,3);mod(4,3) mod(4,4)]^x)(3)

Basato sulla matrice di Fibonacci .

33, MATL

Aggiunto -, rimosso (). La soluzione non contiene !&'()/\01?AEIKLMNPSTWZ`dmwz{}|~, tab, spazio o newline.

5X^Hq+G^Hq5X^-G^-HG^5X^*Hqqq^*Yo%"#$,.2346789:;<=>@BCDFJOQRUV[]_abcefghijklnprstuvxy

Provalo su MATL Online

Errore fisso: 0, 1, e \accidentalmente lasciato nel commento (dopo il %) alla fine. La loro rimozione non interrompe la funzionalità. Sposta questa risposta da 32 a 33 nel tentativo di mantenerla valida. Se deve essere eliminato, per favore fatemi sapere e lo farò.

36. Java

Aggiunto \. Rimosso qx. Non utilizza !&'()/1?AEIKLMNPSTWZ`dmnqtwxz{}|~[], tab o spazio.

\u002f\u002f"#$%*:>@BCGHJOQRUVXY^_jk
class
Fibo\u006eacci\u007b
i\u006e\u0074
fib\u0028i\u006e\u0074
\u006e\u0029\u007b
i\u006e\u0074
lo\u0077=0,high=3-2,\u0074e\u006Dp;
for\u0028i\u006e\u0074
i=3-2;i<\u006e;i++\u0029\u007b
\u0074e\u006Dp=lo\u0077;
lo\u0077=high;
high=high+\u0074e\u006Dp;
\u007D
re\u0074ur\u006e
lo\u0077;
\u007D
public
s\u0074a\u0074ic
voi\u0064
\u006Dai\u006e\u0028\u0053\u0074ri\u006eg\u005b\u005Db\u0029\u007b
Fibo\u006eacci
a=\u006ee\u0077
Fibo\u006eacci\u0028\u0029;
for\u0028i\u006e\u0074
i=3-2;i<=20;i++\u0029\u007b
\u0053ys\u0074e\u006D.ou\u0074.pri\u006e\u0074l\u006e\u0028a.fib\u0028i\u0029\u0029;
\u007D
\u007D
\u007D

So che probabilmente avrei potuto aspettare più a lungo, ma volevo assicurarmi di uscire prima che fosse troppo tardi. Questa classe non solo definisce una funzione che accetta un numero intero ne restituisce quel numero di Fibonacci, ma stampa anche i primi 20 per te solo per divertimento. Ho provato a fare la mia dovuta diligenza scrivendo questo in una semplice vecchia Java senza golf subdolo e poi ho rimosso i personaggi illegali 1 per 1 fino a quando non siamo arrivati ​​alla creatura che vedi prima di te adesso.

Provalo online!

37. Python 2

Pronto x. Non usa !&'()/1?AEIMNPSTWZdmnqtwz{}|~[], spazio, tab o `. Rimossi K e L.

f=u"\u0074"
b=u"\u006D"
i=u"\u0028"
j=u"\u0029"
h=u"\u006e"
r=2.2360679775
s=u"\u002F"
exec"p="+i+"3-2+r"+j+s+"2"
exec"g=i"+h+"pu"+f+i+j
exec"pri"+h+f+i+"i"+h+f+i+i+"p**g-"+i+"-p"+j+"**-g"+j+s+"r"+j+j
#$%´:;<=>@BCGHJOQRUVXY^agklopvy

Con commenti:

f=u"\u0074" #t
b=u"\u006D" #m
i=u"\u0028" #(
j=u"\u0029" #)
h=u"\u006e" #n
r=2.2360679775 #sqrt(5)
s=u"\u002F" #/
exec"p="+i+"3-2+r"+j+s+"2" #p=(3-2+r)/2 = (1+sqrt(5))/2 = phi
exec"g=i"+h+"pu"+f+i+j #g=input()
exec"pri"+h+f+i+"i"+h+f+i+i+"p**g-"+i+"-p"+j+"**-g"+j+s+"r"+j+j #print(int((p**g-(-p)**-g)/r))

Questo approccio usa il termine generale della serie fibonacci.

3. Brain-Flak

Non contiene Z, ~, A, o tabulazione orizzontale. (Ri-incluso })

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

Provalo online!

5, Haskell

Rimosso AEIOUe scheda, aggiuntoZ

-- #!"$%&'*./23456789;:<>?@BCDFGHJKLMNPQRSTVWXYZ[\]^`abcdeghijklmopqrstuvwxyz{|}~,_
f 0 = 1
f 1 = 1
f n = f (n-1) + f (n-2)

Provalo online!

12. Python 3

aggiunto :rimosso {;non contiene {};`01AEIPQxcaratteri di tabulazione.

#!"#$%&\',./23456789?@BCDFGHJKLMNORSTUVWXYZ[\]^_abcdgjkmopqrvwyz|~:
def fib(n,a=3-2,b=3-2):
 if n==2-2:
  return a
 a, b = b, a + b
 return fib(n-1,a,b)

6. Brain-Flak

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

Provalo online! Non utilizza tabAEIU`_e aggiunto di nuovoO

26. Prolog (SWI)

aggiunto % . Rimosso NK. Non utilizza &*01AEIKLMNPSTWZ`dmrwz{}], tab o newline.

a(X,B):-X<3,B is 4-3;C is X-4-(-3),D is X-2,a(C,G),a(D,F),B is G-(-F).%!"#$'/56789=>?@HJOQRUVY[\^_bcefghjklnopqtuvxy|~

Provalo online!

34. brainfuck

Aggiunto newline, rimosso n e t. Non utilizza !&'()/\01?AEIKLMNPSTWZ`dmntwz{}|~, tab o spazio. (forse possiamo ottenere alcuni linguaggi 2D ora)

0-indicizzati. L'ingresso / uscita è in base a valori byte.

,[->]+>+<<[->>[->+<]<[->+<]>>[-<+<+>>]<<<]>>.
"#$%*23456789:;=@BCDFGHJOQRUVXY^_abcefghijklopqrsuvxy

Provalo online!

4, Python 2

Rimosso AEIZ, scheda aggiunta~

# !"$%&'*-./23456789;<>?@BCDFGHJKLMNOPQRSTUVWXY[\]^`chjklmpqsvwxyz{|}

def f(x):
 a=0
 b=1
 for _ in range(x):
  a,b = a+b,a
 return a

Provalo online!

11. ML standard (mosml)

Aggiunto +. Rimosso :}. Non contiene :}0`1AEIPQxcaratteri di tabulazione.

(* !"#$%&\',./23456789;<>?@BCDFGHJKLMNORSTUVWXYZ[\]^_abcdgjkmopqrvwyz{|~ *)
fun f s = if s = 2-2 then 2-2 else if s = 3-2 then 3-2 else f (s-4+2) + f (s-3+2)

SML non è su TIO, e ho usato la varietà ml di Mosca, ma c'è uno SMLNJ interprete on-line qui .

10. C

Aggiunto m, rimosso PQ. Non contiene+`01AEIPQx caratteri di tabulazione.

Flag del compilatore: -lm

//!"#$%&'*346789:<=>?@BCDFGHJKLMNORSTUVWXYZ[\]^_acfghkmvyz|.

double fib(i){
    double j = -(-~-2-sqrt(5))/2;
    return floor((pow(j,i)-pow(-j,-i))/sqrt(5));
}

Provalo online!

9. Python 2

Aggiunto -, rimosso me x. Contiene il carattere no +`01AEImxo tab.

# --!"$%&'*./29;:<>?@[\]^345678BCDFGHJKLMNOPQRSTUVWXYZabcdeghijklopqrstuvwyz{|}~,_

def fibonacci(n):
    elif n==(2/2):
        return 2-2
    elif n==2:
        return 2/2
    else:
        return fibonacci(n-2/2)-(-(fibonacci(n-2)))

Funzione Python ricorsiva! Aggiunge tutti i numeri di Fibonacci all'indietro fino a quando nè 1.

18. Ottava

Aggiunto ;e rimossof e spazio. La soluzione non contiene {}:`*%01AEIPQfrd, nessuna scheda, nessuna nuova riga e nessuno spazio.

g=@(x)([4-3,4-3;4-3,4-4]^x)(3)#!"$&'+./256789<>?BCDFGHJKLMNORSTUVWXYZ\_abcehijklmnopqstuvwyz|~

Identico alla risposta 8 , solo con più odio SML: P

23. ML standard (mosml)

Eccoci di nuovo. Aggiunto Q, rimosso }e ]. Non utilizza %&*+01:AEILMPZ`dmrzM{}], scheda o avanzamento riga

fun f x = #2("!#$\\',.23456789<>?@BCDFGHJKNOQRSTUVWXY[/;^_abcgjkopqvwxy|~", if x = 2-2 then 2-2 else if x = 3-2 then 3-2 else f (~(~(x-4)-2)) + f (x-(~3-2)))

25. CJam

Aggiunto +indietro, rimosso Se T. Non utilizza %&*01AEILMPSTZ`dmrz{}]Ww, scheda o avanzamento riga.

Fondamentalmente una porta della mia risposta più vecchia, ma questa usa un po 'di trucco per evitare la mancanza di parentesi graffe.

q~"XX"a:~'|("_(j\((j+"'|)'j+++~e# !$,-./23456789;<=>?@BCDFGHJKNOQRUVY[^bcfghiklnopstuvxy

0-indicizzati.

Provalo online!

27. JavaScript

Aggiunto *, rimosso "e '. Non utilizza "&'01AEIKLMNPSTZ`dmrz{}]Ww, scheda o avanzamento riga.

f=a=>a<2?3-2:f(a-3+2)+f(a-4+2)/* !#$,.56789;%@BCDFGHJOQRUVXY[\^_bceghijklnopqstuvxy|~*/

28. Haskell

f=length"":scanl(+)(length"f")f;g=const(f!!)"#$%*,./23456789<>?@BCDFGHJOQRUVXY[\\^_bijkpquvxy|~"

Provalo online! Uso: g 3dà 2.

Aggiunto ", rimosso <space>e -. Non usa &'-01AEIKLMNPSTZ`dmrz{}]Wwo nessun bianco spcae.

30. ML standard

Aggiunto :, rimosso +e ?. Non contiene !&'+-01?AEIKLMNPSTWZ`dmrwz{}spazi bianchi.

fun$(a,b,x)n=if(length(x)=n)then(length(a))else$(b,a@b,()::x)n;("#%*./23456789<>BCDFGHJOQRUVXY\\^_cjkopqvy|~";$([],[()],[]))

La prima parte fun$(a,b,x)n=if(length(x)=n)then(length(a))else$(b,a@b,()::x)ndefinisce una funzione $che calcola il nnumero di fibonacci in modo iterativo usando una codifica elenco unaria. La lunghezza dell'argomento xindica il numero corrente e ae bsono elenchi di lunghezza fib(length(x)-1)e fib(length(x)). Se è nuguale length(x)restituiamo length(b), altrimenti aggiungere ricorsivamente ae btramite concatenazione e incremento xdell'elenco aggiungendo un elemento() ad esso.

La seconda parte ("#%*./23456789<>BCDFGHJOQRUVXY\\^_cjkopqvy|~";$([],[()],[]))è una sequenza in cui la stringa viene scartata ed $([],[()],[])è l'inizializzazione della funzione $con a = 0, b = 1e x = 0, risultante in una funzione anonima che calcola l'ennesimo numero di fibonacci.

32, Python 3

exec(chr(2**2+2**5+2**6)+chr((3^2)+2**2+2**5+2**6)+chr(2+2**2+2**5+2**6)+chr(2**5)+chr(2+2**2+2**5+2**6)+chr(2**3+2**5)+chr(2**3+2**4+2**5+2**6)+chr((3^2)+2**3+2**5)+chr(2+2**3+2**4+2**5)+chr(2+2**3)+chr(2**5)+chr((3^2)+2**5+2**6)+chr((3^2)+2**2+2**3+2**4+2**5)+chr(2**4+2**5)+chr(2+2**3)+chr(2**5)+chr(2+2**5+2**6)+chr((3^2)+2**2+2**3+2**4+2**5)+chr((3^2)+2**4+2**5)+chr(2+2**3)+chr(2**5)+chr(2+2**2+2**5+2**6)+chr((3^2)+2+2**2+2**3+2**5+2**6)+chr(2+2**4+2**5+2**6)+chr(2**5)+chr((3^2)+2+2**2+2**3+2**4+2**6)+chr(2**5)+chr((3^2)+2**3+2**5+2**6)+chr(2+2**2+2**3+2**5+2**6)+chr(2**5)+chr(2+2**4+2**5+2**6)+chr((3^2)+2**5+2**6)+chr(2+2**2+2**3+2**5+2**6)+chr((3^2)+2+2**2+2**5+2**6)+chr((3^2)+2**2+2**5+2**6)+chr(2**3+2**5)+chr(2**3+2**4+2**5+2**6)+chr((3^2)+2**3+2**5)+chr(2+2**3+2**4+2**5)+chr(2+2**3)+chr(2**5)+chr(2**5)+chr((3^2)+2**5+2**6)+chr(2**2+2**3+2**5)+chr(2+2**5+2**6)+chr(2**5)+chr((3^2)+2**2+2**3+2**4+2**5)+chr(2**5)+chr((3^2)+2**5+2**6)+chr((3^2)+2+2**3+2**5)+chr(2+2**5+2**6)+chr(2**2+2**3+2**5)+chr((3^2)+2**5+2**6)+chr(2+2**3)+chr(2**5)+chr(2+2**4+2**5+2**6)+chr((3^2)+2**2+2**5+2**6)+chr(2**2+2**4+2**5+2**6)+chr((3^2)+2**2+2**4+2**5+2**6)+chr(2+2**4+2**5+2**6)+chr(2+2**2+2**3+2**5+2**6)+chr(2**5)+chr((3^2)+2**5+2**6))#"$%,.789:;<=>@BCDFGHJOQRUVXY[]_abfgijklnopqstuvy

Aggiunto re rimosso |~. La soluzione non contiene !&'/\-01?AEIKLMNPSTWZ`dmrwz{}|~, nessuna scheda, nessuna nuova riga e nessuno spazio.

39. Python 2

Aggiunto0 . Rimosso @^. Non utilizza !^&'()/1?@AEIMNPSTWZdmntwz{}|~[] `, tab o newline.

C=u"f=la\u006Db\u0064a\u0020X:3-2if\u0020X<2else\u0020f\u0028X-3+2\u0029+f\u0028X-2\u0029";exec""+C#$%*,.57>BFGHJKLOQRUVY_ghjkopqrvy

Argomento da eseguire senza sequenze di escape:

f=lambda X:3-2if X<2else f(X-3+2)+f(X-2)

Provalo online!

38. Matl

Aggiunto q. Rimosso 0 <newline>. Non utilizza !&'()/1?AEIKLM0NPSTW{Z`dmntwxz}|~[], tab, newline o spazio.

5X^Hq+G^Hq5X^-G^-HG^5X^*Hqqq^*Yo%"#$,.2346789:;<=>@BCDFJORUV_abcefghijklprsuvy

Provalo online

7, Python 2

Re-incluso _. Personaggi rimossi: tab e AEIU`, e (solo per diventare un po 'cattivi) 0e 1. Altrimenti, solo una copia della risposta di Wheat Wizard (da qui il wiki della community).

# !"$%&'*./456789;<>?@BCDFGHJKLMNOPQRSTVWXY[\]^chjklmpqsvwxyz{|}

def f(x):
 a=2-2
 b=3-2
 for _ in range(x):
  a,b = a+b,a
 return a

Provalo online!

13. ML standard (mosml)

Aggiunto x. Rimosso :r. Non contiene :;{}0`1AEIPQrcaratteri di tabulazione.

(* !"#$%&\',./23456789<>?@BCDFGHJKLMNORSTUVWXYZ[\]^_abcdgjkmopqvwxyz|~ *)
fun f s = if s = 2-2 then 2-2 else if s = 3-2 then 3-2 else f (s-4+2) + f (s-3+2)

Dopo aver praticamente escluso i linguaggi in stile C, andiamo dopo Python. Questa risposta è praticamente identica alla risposta 11.

14. Ottava

rNewline e spazio aggiunti e rimossi. La soluzione non contiene {}:;`01AEIPQ, nessuna scheda, nessuna nuova riga e nessuno spazio.

f=@(n)round(((2/2+sqrt(5))/2)^n/sqrt(5))%!"#$&'*-,.346789<>?BCDFGHJKLMNORSTUVWXYZ[\]_abceghijklmpvwyz|~

Basato su una formula in forma chiusa (7) .

16. Octave

Added / and removed * and space. Solution contains no {}:;`*%01AEIPQ, no tab, no newline, and no space characters.

f=@(n)round(((2/2+sqrt(5))/2)^n/sqrt(5))#!"$&'-,.346789<>?BCDFGHJKLMNORSTUVWXYZ[\]_abceghijklmpvwyz|~

Identical to answer 14, just a straight up attack on SML and Python :P

15. Standard ML (mosml)

Added space and removed %/. Doesn't contain {}:;`01AEIPQ, tab, or newline.

fun f s = if s = 2-2 then 2-2 else if s = 3-2 then 3-2 else f (s-4+2) + f (s-3+2) (* !"#$&\',.23456789<>?@BCDFGHJKLMNORSTUVWXYZ[\]^_abcdgjkmopqrvwxyz|~ *)