Séquences féminines et masculines

20

Cette question est probablement plus difficile que toutes ces tâches "générer une séquence de nombres", car cela nécessite DEUX séquences fonctionnant à l'unisson.

J'ai hâte de connaître les réponses!

Dans son livre " Gödel, Escher, Bach: An Eternal Golden Braid ", Douglas Hofstadter contient un certain nombre de séquences de nombres, toutes s'appuyant sur le terme précédent d'une manière ou d'une autre. Pour plus d'informations sur toutes les séquences, consultez cette page Wikipedia .

Une paire de séquences qui est vraiment intéressante est les séquences Femme et Homme, qui sont définies comme suit:

pour n > 0.

Voici la séquence féminine et la séquence masculine .

Votre tâche consiste, lorsque vous donnez un entier nen entrée, à renvoyer une liste de la séquence féminine et de la séquence masculine, avec le nombre de termes égal à n, sur deux lignes de sortie, avec la séquence féminine sur la première ligne et la séquence masculine sur la deuxième.

Exemples d'entrées et de sorties: Entrée: 5 Sortie:[1, 1, 2, 2, 3] [0, 0, 1, 2, 2]

Entrée: 10 Sortie:[1, 1, 2, 2, 3, 3, 4, 5, 5, 6] [0, 0, 1, 2, 2, 3, 4, 4, 5, 6]

REMARQUE: la séparation entre les listes signifie un saut de ligne.

C'est le code-golf, donc le code le plus court en octets l'emporte. Mettez également une explication pour votre code.

Classement

clismique
la source
5
Pouvons-nous renvoyer une paire de listes à partir d'une fonction, au lieu d'imprimer les listes?
Zgarb
D' autres défis impliquant les séquences de Hofstadter: séquence Q , séquence figure chiffres
Martin Ender
@Zgarb Vous pouvez, tant que les deux listes sont sur des lignes différentes.
clismique
2
@DerpfacePython Il n'y a pas de lignes dans une paire de listes; si une fonction renvoie une paire de listes, vous pouvez les imprimer comme vous le souhaitez. Cela étant dit, je ne suis pas un grand fan de l'exigence de lignes, même lors de l'impression de la sortie. Les formats d'E / S encombrants sont l'une des choses à éviter lors de l'écriture de défis.
Dennis
4
Ce n'est pas grave pour certaines approches / langues, mais cela peut faire une grande différence pour d'autres. En C, beaucoup d'octets pourraient être enregistrés en imprimant les séquences en colonnes plutôt qu'en lignes. En Python, l'approche la plus courte à laquelle je peux penser est une lambda récursive similaire à ma réponse récursive Julia qui retourne une paire de listes, mais le fait de devoir convertir cela en une chaîne avec un saut de ligne le rend beaucoup plus long, voire plus long que le programme complet publié par Sp3000. D'autres approches, comme une solution récursive qui compte à rebours au lieu de monter, sont complètement exclues car il est impossible d'ajouter la nouvelle ligne.
Dennis

Réponses:

3

Gelée , 22 20 octets

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

Essayez-le en ligne!

Comment ça fonctionne

çƓḤ¤Ð¡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
la source
5
Et c'est la partie où je suis fier de moi d'avoir fait un défi qui fait que Jelly utilise plus de 10 octets.
clismique
13

Julia, 52 48 octets

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

Essayez-le en ligne!

Contexte

Dans On fonctions mariées de Hofstadter , l'auteur montre que

F/M formula

φ désigne le nombre d' or ,

delta/epsilon formula

et F n désigne le n ème nombre de Fibonacci .

De plus, dans Advanced Problems and Solutions, H-187: Fibonacci est un carré , le proposant montre que

Fibonacci/Lucas identity

L n désigne le n ème nombre de Lucas , et que - inversement - si

converse Fibonacci/Lucas identity

alors n est un nombre de Fibonacci et m est un nombre de Lucas.

On en déduit que

delta/epsilon theorem

chaque fois que n> 0 .

Comment ça fonctionne

Compte tenu de l' entrée x , on construit une 2 par x matrice, où | est l'addition dans la première colonne et la soustraction dans la seconde, et n itère sur les entiers compris entre 1 et x dans les lignes.

Le premier terme de F (n - 1) et M (n - 1) est simplementn÷φ .

On calcule δ (n) et ε (n) en calculant 5n² | 4 et tester si le résultat appartient au tableau de carrés des entiers compris entre 2 et 3n . Cela teste à la fois pour l'équerrage et, puisque 1 n'est pas dans la plage, pour n> 1 si | est la soustraction.

Enfin, nous ajoutons ou soustrayons le booléen résultant de 5n^2|4∈(2:3n).^2ou de l'entier précédemment calculé.

Dennis
la source
cela peut-il être exprimé de manière non récursive / itérative?, quelle en est la forme fermée?
Abr001am
J'ai ajouté une explication.
Dennis
11

Python 2, 79 70 octets

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

Itératif plutôt que récursif, car pourquoi pas. La première ligne a un espace de fin - si ce n'est pas correct, il peut être corrigé pour un octet supplémentaire. -9 octets grâce à @Dennis.

Voici quelques lambdas combinés qui n'ont pas vraiment aidé:

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]]

Les deux prennent net un paramètre ksoit 0 ou 1, spécifiant mâle / femelle. Le premier lambda renvoie le nième élément, et le second lambda renvoie les n premiers éléments (avec un temps d'exécution exponentiel).

Sp3000
la source
9

MATL , 23 octets

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

Essayez-le en ligne!

Explication

Cela fonctionne de manière itérative. Chaque séquence est conservée dans un tableau. Pour chaque indice n, le nouveau terme de chaque séquence est calculé et attaché au tableau correspondant. Une forboucle avec N −1 termes est utilisée, où N est le numéro d'entrée.

La mise à jour de la séquence M doit être effectuée en premier. C'est parce que la séquence F est toujours supérieure ou égale à la séquence M pour le même index, donc si nous essayions de mettre à jour F d'abord, nous aurions besoin d'un terme de M non encore calculé.

Les deux équations de mise à jour sont les mêmes F et M. interchangeables. Ainsi, le code de mise à jour est réutilisé en appliquant une forboucle avec deux itérations et en échangeant les séquences de la pile.

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
la source
6

J, 47 octets

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

Utilise la définition récursive. Les deux premières lignes définissent les verbes fet mreprésentent respectivement les fonctions féminine et masculine. La dernière ligne est un verbe qui prend un seul argument net sort le premiern termes des séquences féminines et masculines.

Usage

   (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
miles
la source
6

JavaScript (ES6), 75 octets

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

Je pourrais économiser 2 octets si j'étais autorisé à renvoyer la séquence masculine en premier:

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

Haskell, 57 octets

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

Exemple d'utilisation: (<$>[v,w]).take $ 5->[[1,1,2,2,3],[0,0,1,2,2]]

La fonction d'assistance #construit une liste infinie avec la valeur de départ set une liste lpour rechercher tous les autres éléments (à l'index de la valeur précédente). v = w#1est la w = v#0séquence féminine et la séquence masculine. Dans la fonction principale, nous prenons les premiers néléments des deux vet w.

nimi
la source
4

Python 2, 107 octets

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)

Essayez-le en ligne

Des valeurs d'entrée plus grandes provoquent une erreur d'exécution (trop de récursivité). Si c'est un problème, je peux écrire une version où l'erreur ne se produit pas.

Mego
la source
3

Pyth, 24 octets

Il est probablement impossible d'utiliser reducepour réduire le nombre d'octets.

Mise en œuvre simple.

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

Essayez-le en ligne!

Comment ça fonctionne

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)
Leaky Nun
la source
Dois-je inclure le nom anagrammatisé ou votre nom d'origine dans le classement? En outre, ce code est extrêmement long pour un programme Pyth.
clismique
Depuis combien de temps êtes-vous ici ... comment savez-vous que j'ai changé mon nom? Mettez mon nouveau nom là-bas.
Leaky Nun
1
Je suis ici depuis assez longtemps pour savoir que tu as changé de nom.
clismique
@DerpfacePython Voyant que les autres réponses sont presque 4 fois plus longues ... Je dirais que ma solution n'est pas très longue.
Leaky Nun
C'est très vrai, mais c'est encore long par rapport à d'autres programmes Pyth pour d'autres questions.
clismique
3

Brachylog , 65 octets

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

Ma tentative de combiner les deux prédicats masculins et féminins en un seul a en fait allongé le code.

Vous pouvez utiliser le liner suivant qui a le même nombre d'octets:

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

Remarque : Cela fonctionne avec le transpilateur Prolog, pas l'ancien Java.

Explication

Prédicat principal:

:{: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

Prédicat 2 (femelle):

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

Prédicat 3 (masculin):

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
la source
Attendez ... lequel est le prédicat 3?
clismique
@DerpfacePython whoops, corrigé. Notez également qu'un prédicat est {:1-:0re.}utilisé pour créer la liste de plages.
Fatalize
3

Clojure, 132 131 octets

(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)))))

Construit simplement les séquences de manière itérative de zéro à n.

Version non golfée

(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)))))
marque
la source
Belle réponse, bienvenue sur le site! Un espace de fin ou une nouvelle ligne est-il nécessaire? Je compte 131 + un espace de fuite.
DJMcMayhem
Non, il n'y a pas besoin d'espace blanc de fin. Sneaky vim a ajouté une nouvelle ligne à la fin pour que wc compte.
marquez
3

Pyth, 23 octets

jCuaG-LHtPs@LGeGr1Q],1Z

Essayez-le en ligne: Démonstration

Explication:

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

Solution alternative qui utilise une fonction au lieu de réduire (également 23 octets):

L?>b1-LbtPsyMytb,1ZjCyM
Jakube
la source
Agréable. Très beau effectivement.
Leaky Nun
3

Rubis, 104 92 97 82 octets

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]}}}

Edit: f et msont désormais une fonction grâce à HopefullyHelpful . J'ai changé la seconde fonction d'imprimer fensuite m. L'espace après pest significatif, sinon la fonction s'imprime (0...n)au lieu du résultat demap .

La troisième fonction imprime d'abord un tableau des n premiers termes de f, suivi d'un tableau des n premiers termes dem

Ces fonctions sont appelées comme ceci:

> 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
la source
vous pouvez supprimer le p et les parens. Il n'est pas nécessaire d'imprimer la sortie. En outre, vous pouvez dorp parens autour de la plage.
Pas que Charles
vous pouvez remplacer la fonction 2 par 1 qui a 2 arguments neti n>0?n-f(f(n-1,i),-i):i>0?1:0
HopefullyHelpful
@HopefullyHelpful Merci beaucoup: D
Sherlock9
@NotthatCharles La sortie ne doit-elle pas être imprimée? En Ruby, si je veux que le saut de ligne entre fet m, je dois l'imprimer. Sinon, je reçois juste un tableau comme[[1, 1, 2, 2, 3, 3, 4, 5, 5, 6], [0, 0, 1, 2, 2, 3, 4, 4, 5, 6]]
Sherlock9
oh, ça dit "coupure de ligne". Dommage.
Pas que Charles
3

APL (Dyalog Unicode) , 45 25 octets

Fonction tacite anonyme. Requiert ⎕IO←0, qui est standard sur de nombreux systèmes APL.

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

Essayez-le en ligne!

Cela fonctionne en combinant F et M en une seule fonction dyadique avec un argument gauche booléen qui sélectionne la fonction à appliquer. Nous utilisons 1 pour F et 0 pour M afin de pouvoir utiliser ce sélecteur comme valeur de retour pour F  (0) et M  (0). Nous observons ensuite que les deux fonctions doivent s'appeler d'abord (sur l'argument moins un) et ensuite l'autre fonction sur le résultat de cela, donc nous récursions d'abord avec le sélecteur donné, puis avec le sélecteur nié logiquement.

ɩ ndices; zéro à travers l'argument moins un

1 0∘.{} "Produit" externe (cartésien) (mais avec la fonction ci-dessous au lieu de la multiplication) en utilisant [1,0]comme arguments de gauche ( ) et les indices comme arguments de droite ( ):

×⍵ si le bon argument est strictement positif (allumé le signe du bon argument):

  ⍵-1 soustraire un du bon argument

  ⍺∇ appeler soi avec cela comme argument de droite et l'argument de gauche comme argument de gauche

  (~⍺)∇ appeler soi avec cela comme arg de droite et la négation logique de l'arg de gauche comme arg de gauche

  ⍵- soustrayez cela du bon argument et retournez le résultat

 autre:

   retourner l'argument de gauche

Adam
la source
Cela fonctionne bien, mais en supposant que l'entrée est stockée dans une variable est interdite par défaut.
Dennis
@Dennis Ce n'est pas vraiment le cas. C'est un organisme tfn. Quand j'étais nouveau ici, ngn m'a dit que je n'avais pas à compter l'en-tête tfn (qui serait de deux octets, un nom de caractère unique + une nouvelle ligne, tout comme le nom de fichier source n'est pas compté et les fns anonymes sont autorisés Ici aussi, où l'en-tête est un nom à 1 caractère + espace + un nom d'argument à 1 caractère ( n) + plus une nouvelle ligne.
Adám
Qu'est-ce qu'un TFN exactement?
Dennis
@Dennis Tfns sont la représentation APL traditionnelle des fonctions. Composé de lignes de code avec presque aucune des restrictions du dfns . Par exemple, vous pouvez avoir des structures de contrôle et des expressions appropriées sans résultat. La ligne "0" est un en-tête qui indique la syntaxe du fn .
2016
2

ES6, 89 85 83 octets

2 octets économisés grâce à @ 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]}

Mise en œuvre naïve.

Explication:

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 uniquement
la source
Je pense que vous pouvez en faire une fonction anonyme et remplacer les && - s par &
Bálint
Tu ne peux pas, && courts-circuits, ce qui est voulu, mais je l'ai quand même supprimé car la syntaxe des accolades est tout aussi courte de toute façon
ASCII uniquement
Ensuite, vous pouvez faire`F = [n = 1]
Bálint
2

Mathematica, 69 62 octets

Merci à Sp3000 d'avoir proposé une forme fonctionnelle qui a permis d'économiser 14 octets.

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

Cela définit une fonction d'assistance nommée f, puis s'évalue en fonction sans nom qui résout la tâche réelle d'imprimer les deux séquences.

Martin Ender
la source
2

Perl 5.10, 85 80 octets

Meh, ne sais pas si j'ai plus d'idées pour jouer au golf ...

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

Essayez-le en ligne!

J'ai dû ajouter use 5.10.0Ideone pour qu'il accepte lesay fonction, mais cela ne compte pas dans le nombre d'octets.

C'est une implémentation naïve de l'algorithme, @a étant la liste "féminine" et@b la "masculine".

Barré 85 est toujours 85?

Paul Picard
la source
Explication, s'il vous plaît?
clismique
À peu près la même que ma réponse JS
ASCII uniquement
@DerpfacePython C'est en fait une implémentation naïve. :)
Paul Picard
Je n'ai pas testé, mais je ne pense pas que vous devriez avoir besoin des parenthèses autour de chaque pushterme éd, ni du point-virgule final avant l'accolade.
msh210
@ msh210 En effet, j'ai oublié cela. Enregistre 5 octets au total, merci!
Paul Picard
2

Java, 169 octets au total

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 octets

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

récursif pour boucle et impression 77 octets

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

sortie des listes sur deux lignes différentes 37 octets

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

entrée: p ( 10)
sortie:

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
Si tout va bien
la source
1

C, 166 octets

#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));}

Usage:

main()
{
    c(10);
}

Production:

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

Non golfé (331 octets)

#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
la source
0

8ème , 195 octets

Code

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 ;

Usage

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 

Explication

Ce code utilise la récursivité et le mot différé

defer: M- Le mot Mest déclaré défini ultérieurement. C'est un mot différé

: F dup not if 1 nip else dup n:1- recurse M n:- then ;- Définir F récursivement pour générer des nombres féminins selon la définition. Veuillez noter que Mn'a pas encore été défini

( dup not if 0 nip else dup n:1- recurse F n:- then ) is M- Définir M récursivement pour générer des nombres masculins selon la définition

: FM n:1- dup ( F . space ) 0 rot loop cr ( M . space ) 0 rot loop cr ; - Mot utilisé pour imprimer des séquences de nombres féminins et masculins

Manoir du Chaos
la source