Sequenze maschili e femminili

20

Questa domanda è probabilmente più difficile di tutte quelle attività "generano una sequenza di numeri", perché ciò richiede DUE sequenze che lavorano all'unisono.

Non vedo l'ora di ricevere le risposte!

Nel suo libro " Gödel, Escher, Bach: An Eternal Golden Braid ", Douglas Hofstadter ha al suo interno alcune sequenze di numeri, tutti in qualche modo basati sul termine precedente. Per informazioni su tutte le sequenze, consultare questa pagina di Wikipedia .

Una coppia di sequenze davvero interessanti sono le sequenze Femminile e Maschile, definite in questo modo:

per n > 0.

Ecco la sequenza femminile e la sequenza maschile .

Il tuo compito è, quando viene dato un numero intero ncome input, restituire un elenco della sequenza femminile e della sequenza maschile, con la quantità di termini pari a n, in due righe di output, con la sequenza femminile sulla prima riga e la sequenza maschile su il secondo.

Ingressi e uscite di esempio: Ingresso: 5 Uscita:[1, 1, 2, 2, 3] [0, 0, 1, 2, 2]

Ingresso: 10 Uscita:[1, 1, 2, 2, 3, 3, 4, 5, 5, 6] [0, 0, 1, 2, 2, 3, 4, 4, 5, 6]

NOTA: la separazione tra gli elenchi indica un'interruzione di riga.

Questo è code-golf, quindi vince il codice più breve in byte. Inoltre, inserisci una spiegazione anche per il tuo codice.

Classifica

Mostra snippet di codice

code-golf  math  sequence 
— clismique
fonte
5
Possiamo restituire un paio di elenchi da una funzione, invece di stampare gli elenchi?
— Zgarb,
Altre sfide che coinvolgono le sequenze di Hofstadter: sequenza Q , sequenza figura-figura
— Martin Ender
@Zgarb Puoi, purché le due liste siano in righe diverse.
— clismique,
2
@DerpfacePython Non ci sono righe in una coppia di liste; se una funzione restituisce una coppia di elenchi, è possibile stamparli come desiderato. Detto questo, non sono un grande fan dei requisiti delle linee, anche durante la stampa dell'output. I formati I / O ingombranti sono una delle cose da evitare quando si scrivono sfide.
— Dennis,
4
Non è un grosso problema per alcuni approcci / lingue, ma può fare una grande differenza per altri. In C, molti byte potrebbero essere salvati stampando le sequenze in colonne anziché in righe. In Python, l'approccio più breve che mi viene in mente è un lambda ricorsivo simile alla mia risposta ricorsiva Julia che restituisce una coppia di liste, ma il fatto di convertirlo in una stringa con un avanzamento riga lo rende molto più lungo, anche più lungo dell'intero programma pubblicato da Sp3000. Altri approcci, come una soluzione ricorsiva che conta alla rovescia anziché verso l'alto, sono completamente esclusi poiché è impossibile aggiungere la nuova riga.
— Dennis,

Risposte:

3

Gelatina , 22 20 byte

ṙṪḢạL}ṭ
çƓḤ¤Ð¡1ṫ-Ṗ€G

Provalo online!

Come funziona

çƓḤ¤Ð¡1ṫ-Ṗ€G  Main link. No user arguments. Left argument defaults to 0.
   ¤          Combine the two links to the left into a niladic chain.
 Ɠ              Read an integer from STDIN.
  Ḥ             Unhalve/double it.
ç   С1       Call the helper link that many times. Return all results.
              In the first call, the left and right argument are 0 and 1 resp.
              After each iteration, the left argument is set to the return value
              and the right argument to the prior value of the left one.
       ṫ-     Tail -1; keep the last two items of the list of results.
         Ṗ€   Discard the last item of each list.
           G  Grid; format the pair of lists.


ṙṪḢạL}ṭ       Helper link. Arguments: x, y (lists)

ṙ             Rotate x k units to the left, for each k in y.
 Ṫ            Tail; extract the last rotation.
  Ḣ           Head; extract the last element.
              This essentially computes x[y[-1]] (Python notation), avoiding
              Jelly's 1-based indexing.
    L}        Yield the length of y.
   ạ          Take the absolute difference of the results to both sides.
      ṭ       Tack; append the difference to y and return the result.
— Dennis
fonte
5
E questa è la parte in cui mi sento orgoglioso di me stesso per aver fatto una sfida che fa usare a Jelly più di 10 byte.
— clismique,
13

Julia, 52 48 byte

x->[n÷φ|(5n^2|4∈(2:3n).^2)for| =(+,-),n=1:x]

Provalo online!

sfondo

Nelle funzioni coniugali di On Hofstadter , l'autore lo dimostra

Formula F / M

dove φ indica il rapporto aureo ,

formula delta / epsilon

e F n indica il n esimo numero di Fibonacci .

Inoltre, in Advanced Problems and Solutions, H-187: Fibonacci è un quadrato , il proponente lo dimostra

Identità di Fibonacci / Lucas

dove L n denota il n ° numero di Lucas , e che - al contrario - se

conversare identità di Fibonacci / Lucas

allora n è un numero di Fibonacci e m è un numero di Lucas.

Da ciò ne deduciamo

teorema delta / epsilon

ogni volta che n> 0 .

Come funziona

Dato input x , costruiamo una matrice 2 per x , dove | è l'addizione nella prima colonna e la sottrazione nella seconda e n itera sugli interi tra 1 e x nelle righe.

Il primo termine di F (n - 1) e M (n - 1) è semplicemente n÷φ.

Calcoliamo δ (n) e ε (n) calcolando 5n² | 4 e verifica se il risultato appartiene alla matrice di quadrati degli interi tra 2 e 3n . Questo verifica sia la quadratura che, poiché 1 non è compreso nell'intervallo, per n> 1 se | è sottrazione.

Infine aggiungiamo o sottraggiamo il valore booleano risultante dal 5n^2|4∈(2:3n).^2o dal numero intero precedentemente calcolato.

— Dennis
fonte
può essere espresso in modo non ricorsivo / iterativo? Qual è la forma chiusa per esso?
— Abr001,
Ho aggiunto una spiegazione.
— Dennis,
11

Python 2, 79 70 byte

a=0,;b=1,
exec"a,b=b,a+(len(a)-b[a[-1]],);"*~-input()*2
print b,'\n',a

Iterativo piuttosto che ricorsivo, perché perché no. La prima riga ha uno spazio finale - se non va bene, può essere riparata per un byte aggiuntivo. -9 byte grazie a @Dennis.

Ecco alcuni lambda combinati che non hanno davvero aiutato:

f=lambda n,k:n and n-f(f(n-1,k),k^1)or k
f=lambda n,k:[k][n:]or f(n-1,k)+[n-f(f(n-1,k)[-1],k^1)[-1]]

Entrambi accettano ne un parametro k0 o 1, specificando maschio / femmina. Il primo lambda restituisce l'ennesimo elemento e il secondo lambda restituisce i primi n elementi (con runtime esponenziale).

— SP3000
fonte
9

MATL , 23 byte

1Oiq:"@XJth"yy0)Q)_J+hw

Provalo online!

Spiegazione

Funziona in modo iterativo. Ogni sequenza è mantenuta in un array. Per ciascun indice n viene calcolato il nuovo termine di ciascuna sequenza e associato alla matrice corrispondente. Viene utilizzato un forloop con termini N −1, dove N è il numero di input.

L'aggiornamento per la sequenza M deve essere eseguito per primo. Questo perché la sequenza F è sempre maggiore o uguale alla sequenza M per lo stesso indice, quindi se provassimo prima ad aggiornare F avremmo bisogno di un termine di M non ancora calcolato.

Le due equazioni di aggiornamento sono le stesse scambiando F e M. Quindi il codice per l'aggiornamento viene riutilizzato applicando un forciclo con due iterazioni e scambiando le sequenze nello stack.

1        % Push 1: seed for F sequence
O        % Push 0: seed for M sequence
iq:      % Input N. Generate range [1 2 ... N-1]
"        % For each (i.e. iterate N-1 times)
  @      %   Push current index, n (starting at 1 and ending at N-1)
  XJ     %   Copy to clipboard J
  th     %   Duplicate and concatenate. This generates a length-2 array
  "      %   For each (i.e. iterate twice)
    yy   %   Duplicate top two elements, i.e. F and M sequences
    0)   %     In the *first* iteration: get last entry of M, i.e M(n-1)
    Q)   %     Add 1 and index into F. This is F(M(n-1))
    _J+  %     Negate and add n. This is n-F(M(n-1)), that is, M(n)
    h    %     Concatenate to update M
    w    %     Swap top two elements, to bring F to top.
         %     In the *second* iteration the procedure is repeated to update F,
         %     and then the top two elements are swapped to bring M to top again,
         %     ready for the next iteration of the outer loop
         %   End for implicitly
         % End for implicitly
         % Display implicitly from bottom to top: first line is F, second is M
— Luis Mendo
fonte
6

J, 47 byte

f=:1:`(-m@f@<:)@.*
m=:0:`(-f@m@<:)@.*
(f,:m)@i.

Usa la definizione ricorsiva. Le prime due righe definiscono i verbi fe mche rappresentano rispettivamente le funzioni femminile e maschile. L'ultima riga è un verbo che accetta un singolo argomento ne produce i primi ntermini delle sequenze femminile e maschile.

uso

   (f,:m)@i. 5
1 1 2 2 3
0 0 1 2 2
   (f,:m)@i. 10
1 1 2 2 3 3 4 5 5 6
0 0 1 2 2 3 4 4 5 6
— miglia
fonte
6

JavaScript (ES6), 75 byte

g=n=>--n?([f,m]=g(n),m=[...m,n-f[m[n-1]]],[[...f,n-m[f[n-1]]],m]):[[1],[[0]]

Potrei salvare 2 byte se mi fosse permesso di restituire prima la sequenza maschile:

g=n=>--n?([f,m]=g(n),[m=[...m,n-f[m[n-1]]],[...f,n-m[f[n-1]]]]):[[1],[[0]]
— Neil
fonte
6

Haskell, 57 byte

l#s=scanl(\a b->b-l!!a)s[1..]
v=w#1
w=v#0
(<$>[v,w]).take

Esempio di utilizzo: (<$>[v,w]).take $ 5->[[1,1,2,2,3],[0,0,1,2,2]]

La funzione helper #crea un elenco infinito con valore iniziale se un elenco lper cercare tutti gli altri elementi (all'indice del valore precedente). v = w#1è la w = v#0sequenza femminile e maschile. Nella funzione principale prendiamo i primi nelementi di entrambi ve w.

— Nome del modello
fonte
4

Python 2, 107 byte

F=lambda n:n and n-M(F(n-1))or 1
M=lambda n:n and n-F(M(n-1))
n=range(input())
print map(F,n),'\n',map(M,n)

Provalo online

Valori di input più grandi causano un RuntimeError (troppa ricorsione). Se questo è un problema, posso scrivere una versione in cui l'errore non si verifica.

— Mego
fonte
3

Pyth, 24 byte

È probabilmente impossibile usare reduceper ridurre il conteggio dei byte.

Implementazione semplice.

L&b-b'ytbL?b-by'tb1'MQyM

Provalo online!

Come funziona

L&b-b'ytb  defines a function y, which is actually the male sequence.

L          def male(b):
 &b            if not b: return b
   -b          else: return b-
     'ytb            female(male(b-1))


L?b-by'tb1 defines a function ', which is actually the female sequence.

L          def female(b):
 ?b            if b:
   -by'tb          return b-male(female(b-1))
         1     else: return 1


'MQ        print(female(i) for i from 0 to input)
yMQ        print(male(i) for i from 0 to input)
— Perdente Suora
fonte
Includo il nome anagrammatizzato o il tuo nome originale nella classifica? Inoltre, questo codice è terribilmente lungo per un programma Pyth.
— clismique,
Da quanto tempo sei qui ... come mai sai che ho cambiato il mio nome? Metti il ​​mio nuovo nome lì.
— Leaky Nun,
1
Sono qui da abbastanza tempo per sapere che hai cambiato il tuo nome.
— clismique,
@DerpfacePython Visto che le altre risposte sono quasi 4 volte più lunghe ... Direi che la mia soluzione non è molto lunga.
— Leaky Nun,
È vero, ma è ancora lungo rispetto ad altri programmi Pyth per altre domande.
— clismique,
3

Brachylog , 65 byte

:{:1-:0re.}fL:2aw,@Nw,L:3aw
0,1.|:1-:2&:3&:?--.
0.|:1-:3&:2&:?--.

Il mio tentativo di combinare entrambi i predicati per maschio e femmina in uno ha reso il codice più lungo.

È possibile utilizzare il seguente liner che ha lo stesso numero di byte:

:{:1-:0re.}fL:{0,1.|:1-:2&:3&:?--.}aw,@Nw,L:{0.|:1-:3&:2&:?--.}aw

Nota : funziona con il transpiler Prolog, non con quello vecchio Java.

Spiegazione

Predicato principale:

:{:1-:0re.}fL                Build a list L of integers from 0 to Input - 1
             :2aw            Apply predicate 2 to each element of L, write the resulting list
                 ,@Nw        Write a line break
                     ,L:3aw  Apply predicate 3 to each element of L, write the resulting list

Predicato 2 (femmina):

0,1.                         If Input = 0, unify Output with 1
    |                        Else
     :1-                     Subtract 1 from Input
        :2&                  Call predicate 2 with Input - 1 as argument
           :3&               Call predicate 3 with the Output of the previous predicate 2
              :?-            Subtract Input from the Output of the previous predicate 3
                 -.          Unify the Output with the opposite of the subtraction

Predicato 3 (maschio):

0.                           If Input = 0, unify Output with 0
  |                          Else
   :1-                       Subtract 1 from Input
      :3&                    Call predicate 3 with Input - 1 as argument
         :2&                 Call predicate 2 with the Output of the previous predicate 3
            :?-              Subtract Input from the Output of the previous predicate 3
               -.            Unify the Output with the opposite of the subtraction
— Fatalize
fonte
Aspetta ... quale predicato 3?
— clismique,
@DerpfacePython whoops, risolto. Si noti inoltre che il predicato viene {:1-:0re.}utilizzato per creare l'elenco di intervalli.
— Fatalizza
3

Clojure, 132 131 byte

(fn [n](loop[N 1 M[0]F[1]](if(< N n)(let[M(conj M(- N(F(peek M))))F(conj F(- N(M(peek F))))](recur(inc N)M F))(do(prn F)(prn M)))))

Crea semplicemente le sequenze iterativamente da zero a n.

Versione Ungolfed

(fn [n]
  (loop [N 1 M [0] F [1]]
    (if (< N n)
      (let [M (conj M (- N (F (peek M))))
            F (conj F (- N (M (peek F))))]
        (recur (inc N) M F))
      (do
        (prn F)
        (prn M)))))
— marchio
fonte
Bella risposta, benvenuta nel sito! È necessario uno spazio finale o una nuova riga? Sto contando 131 + uno spazio bianco finale.
— DJMcMayhem
No, non è necessario uno spazio bianco finale. Sneaky vim ha aggiunto una nuova riga alla fine per il conteggio del wc.
— segna
3

Pyth, 23 byte

jCuaG-LHtPs@LGeGr1Q],1Z

Provalo online: dimostrazione

Spiegazione:

jCuaG-LHtPs@LGeGr1Q],1Z

  u                ],1Z    start with G = [[1, 0]]
                           (this will be the list of F-M pairs)
  u             r1Q        for each H in [1, 2, ..., Q-1]:
              eG              take the last pair of G [F(H-1), M(H-1)]
           @LG                lookup the pairs of these values:
                              [[F(F(H-1)), M(F(H-1))], [F(M(H-1)), M(M(H-1))]]
          s                   join them:
                              [F(F(H-1)), M(F(H-1)), F(M(H-1)), M(M(H-1))]
        tP                    get rid of the first and last element:
                              [M(F(H-1)), F(M(H-1))]
     -LH                      subtract these values from H
                              [H - M(F(H-1)), H - F(M(H-1))]
   aG                         and append this new pair to G
jC                         at the end: zip G and print each list on a line

Soluzione alternativa che utilizza una funzione anziché ridurre (anche 23 byte):

L?>b1-LbtPsyMytb,1ZjCyM
— Jakube
fonte
Bello. Davvero molto bello.
— Leaky Nun,
3

Rubino, 104 92 97 82 byte

f=->n,i{n>0?n-f[f[n-1,i],-i]:i>0?1:0}
->n{[1,-1].map{|k|p (0...n).map{|i|f[i,k]}}}

Modifica: f e mora sono una funzione grazie a HopefullyHelpful . Ho cambiato la seconda funzione per stampare fpoi m. Lo spazio bianco dopo pè significativo, altrimenti la funzione stampa (0...n)invece del risultato di map.

La terza funzione stampa prima una matrice dei primi n termini di f, seguita da una matrice dei primi n termini dim

Queste funzioni sono chiamate in questo modo:

> f=->n,i{n>0?n-f[f[n-1,i],-i]:i>0?1:0}
> s=->n{[1,-1].map{|k|p (0...n).map{|i|f[i,k]}}}
> s[10]
[1, 1, 2, 2, 3, 3, 4, 5, 5, 6]
[0, 0, 1, 2, 2, 3, 4, 4, 5, 6]
— Sherlock9
fonte
puoi rilasciare la p e le parentesi. Non è necessario stampare l'output. Inoltre, puoi scorpionare le parentesi attorno all'intervallo.
— Non che Charles,
puoi sostituire la funzione 2 con 1 con 2 argomenti nei n>0?n-f(f(n-1,i),-i):i>0?1:0
— HopefullyHelpful
@HopefullyHelpful Grazie mille: D
— Sherlock9,
@NotthatCharles Non è necessario stampare l'output? In Ruby, se voglio l'interruzione di riga tra fe m, devo stamparlo. Altrimenti, ho appena ricevuto un array come[[1, 1, 2, 2, 3, 3, 4, 5, 5, 6], [0, 0, 1, 2, 2, 3, 4, 4, 5, 6]]
— Sherlock9,
oh, dice "interruzione di riga". Peccato.
— Non che Charles,
3

APL (Dyalog Unicode) , 45 25 byte

Funzione tacita anonima. Richiede ⎕IO←0, che è standard su molti sistemi APL.

1 0∘.{×⍵:⍵-(~⍺)∇⍺∇⍵-1⋄⍺}⍳

Provalo online!

Funziona combinando F e M in una singola funzione diadica con un argomento booleano a sinistra che seleziona la funzione da applicare. Usiamo 1 per F e 0 per M in modo da poter usare questo selettore come valore di ritorno per F  (0) e M  (0). Osserviamo quindi che entrambe le funzioni devono prima chiamare se stesse (sull'argomento meno uno) e poi l'altra funzione sul risultato di ciò, quindi prima facciamo riferimento al selettore dato e poi al selettore logicamente negato.

⍳ d ndices; zero attraverso argomento meno uno

1 0∘.{… } "Prodotto" esterno (cartesiano) (ma con la funzione seguente anziché la moltiplicazione) usando [1,0]come argomenti a sinistra ( ⍺) e gli indici come argomenti a destra ( ⍵):

 ×⍵ se l'argomentazione giusta è strettamente positiva (lett. il segno dell'argomentazione giusta):

  ⍵-1 sottrarre uno dall'argomento giusto

  ⍺∇ chiama self con quello come argomento destro e l'argomento sinistro come argomento sinistro

  (~⍺)∇ chiama sé con quello come arg destro e la logica negazione dell'arg sinistro come arg sinistro

  ⍵- sottrarlo dall'argomento giusto e restituire il risultato

 ⋄ altro:

  ⍺ restituisce l'argomento sinistro

— Adamo
fonte
Funziona bene, ma supponendo che l'input sia archiviato in una variabile non è consentito per impostazione predefinita.
— Dennis,
@Dennis In realtà no. È un corpo tfn. Quando ero nuovo qui, ngn mi ha detto che non dovevo contare l'intestazione tfn (che sarebbe di due byte, un nome a carattere singolo + una nuova riga, proprio come il nome del file sorgente non viene conteggiato, e gli FN anonimi sono ammessi Anche qui, dove l'intestazione è un nome di 1 carattere + spazio + un nome di argomento di 1 carattere ( n) + più una nuova riga.
— Adám,
Che cos'è esattamente un tfn?
— Dennis,
@Dennis Tfns è la tradizionale rappresentazione delle funzioni APL. Sono costituiti da righe di codice con quasi nessuna delle restrizioni del dfns . Ad esempio, puoi avere strutture di controllo adeguate ed espressioni senza risultati. La riga "0" è un'intestazione che indica la sintassi di fn .
— Adám,
2

ES6, 89 85 83 byte

2 byte salvati grazie a @ Bálint

x=>{F=[n=1],M=[0];while(n<x){M.push(n-F[M[n-1]]);F.push(n-M[F[n++-1]])}return[F,M]}

Implementazione ingenua.

Spiegazione:

x => {
    F = [n = 1], //female and term number
    M = [0]; //male
    while (n < x) {
        M.push(n - F[M[n - 1]]); //naïve
        F.push(n - M[F[n++ - 1]]); //post-decrement means n++ acts as n in the calculation
    }
    return [F, M];
}
— ASCII-only
fonte
Penso che puoi renderlo una funzione anonima e sostituire gli && - s con &
— Bálint
Non è possibile, &&cortocircuiti, il che è voluto, ma l'ho rimosso comunque perché la sintassi del tutore è ugualmente breve comunque
— solo ASCII
Quindi potresti fare`F = [n = 1]
— Bálint
2

Mathematica, 69 62 byte

Grazie a Sp3000 per aver suggerito un modulo funzionale che ha salvato 14 byte.

k_~f~0=1-k
k_~f~n_:=n-f[1-k,f[k,n-1]]
Print/@Array[f,{2,#},0]&

Questo definisce una funzione di supporto denominata fe quindi restituisce una funzione senza nome che risolve l'effettivo compito di stampare entrambe le sequenze.

— Martin Ender
fonte
2

Perl 5,10, 85 80 byte

Meh, non so se ho altre idee per giocare a golf ...

@a=1;@b=0;for(1..<>-1){push@a,$_-$b[$a[$_-1]];push@b,$_-$a[$b[$_-1]]}say"@a\n@b"

Provalo online!

Ho dovuto aggiungere use 5.10.0Ideone per accettare la sayfunzione, ma non conta per il conteggio dei byte.

È un'implementazione ingenua dell'algoritmo, @aessendo l'elenco "femmina" e @bl' elenco "maschio".

Crossed-out 85 è ancora 85?

— Paul Picard
fonte
Spiegazione, per favore?
— clismique,
Praticamente lo stesso della mia risposta JS
— ASCII, solo
@DerpfacePython In realtà è un'implementazione ingenua. :)
— Paul Picard,
Non ho ancora testato, ma non credo che dovresti aver bisogno delle parentesi intorno a ciascun pushtermine, né del punto e virgola finale prima della parentesi graffa.
— msh210,
@ msh210 In effetti, me ne sono dimenticato. Risparmia 5 byte in totale, grazie!
— Paul Picard,
2

Java, 169 byte in totale

int f(int n,int i){return n>0?n-f(f(n-1,i),-i):i>0?1:0;}void p(int n,int i){if(n>0)p(n-1,i);System.out.print(i==0?"\n":f(n,i)+" ");}void p(int n){p(n,1);p(0,0);p(n,-1);}

F (), M () 56 byte

int f(int n,int i){
    return n>0?n-f(f(n-1,i),-i):i>0?1:0;
}

ricorsivo per loop e stampa 77 byte

void p(int n,int i) {
    if(n>0) {
        p(n-1,i);
    }
    System.out.print(i==0?"\n":f(n,i)+" ");
}

emissione degli elenchi in due diverse righe 37 byte

void p(int n) {
    p(n,1);
    p(0,0);
    p(n,-1);
}

input: p ( 10)
output:

1 1 2 2 3 3 4 5 5 6 6 7 8 8 9 9 
0 0 1 2 2 3 4 4 5 6 6 7 7 8 9 9
— HopefullyHelpful
fonte
1

C, 166 byte

#define P printf
#define L for(i=0;i<a;i++)
f(x);m(x);i;c(a){L P("%d ",f(i));P("\n");L P("%d ",m(i));}f(x){return x==0?1:x-m(f(x-1));}m(x){return x==0?0:x-f(m(x-1));}

Uso:

main()
{
    c(10);
}

Produzione:

1 1 2 2 3 3 4 5 5 6
0 0 1 2 2 3 4 4 5 6

Ungolfed (331 byte)

#include <stdio.h>

int female(int x);
int male(int x);
int i;
int count(a){
    for(i=0;i<a;i++){
        printf("%d ",female(i));
    }
    printf("\n");
    for(i=0;i<a;i++){
        printf("%d ",male(i));
    }
}
int female (int x){
    return x==0?1:x-male(female(x-1));
}
int male(x){
    return x==0?0:x-female(male(x-1));
}
int main()
{
    count(10);
}
— Giacomo Garabello
fonte
0

8o , 195 byte

Codice

defer: M
: F dup not if 1 nip else dup n:1- recurse M n:- then ;
( dup not if 0 nip else dup n:1- recurse F n:- then ) is M
: FM n:1- dup ( F . space ) 0 rot loop cr ( M . space ) 0 rot loop cr ;

uso

ok> 5 FM
1 1 2 2 3 
0 0 1 2 2 

ok> 10 FM
1 1 2 2 3 3 4 5 5 6 
0 0 1 2 2 3 4 4 5 6

Spiegazione

Questo codice utilizza la ricorsione e la parola differita

defer: M- La parola Mviene dichiarata per essere definita in seguito. Questa è una parola differita

: F dup not if 1 nip else dup n:1- recurse M n:- then ;- Definire in F modo ricorsivo per generare numeri femminili in base alla definizione. Si noti che Mnon è stato ancora definito

( dup not if 0 nip else dup n:1- recurse F n:- then ) is M- Definire in M modo ricorsivo per generare numeri maschili in base alla definizione

: FM n:1- dup ( F . space ) 0 rot loop cr ( M . space ) 0 rot loop cr ; - Parola utilizzata per stampare sequenze di numeri femminili e maschili

— Chaos Manor
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.