Secuencias Masculina y Femenina

20

Esta pregunta es probablemente más difícil que todas esas tareas de "generar una secuencia de números", porque esto requiere DOS secuencias que funcionen al unísono.

Realmente esperando las respuestas!

En su libro " Gödel, Escher, Bach: An Eternal Golden Braid ", Douglas Hofstadter tiene bastantes secuencias de números en su interior, todas ellas se basan en el término anterior de alguna manera. Para obtener información sobre todas las secuencias, consulte esta página de Wikipedia .

Un par de secuencias que es realmente interesante son las secuencias femenina y masculina, que se definen así:

para n > 0.

Aquí está la secuencia femenina y la secuencia masculina .

Su tarea es, cuando se le da un número entero ncomo entrada, devolver una lista de la secuencia femenina y la secuencia masculina, con la cantidad de términos igual a n, en dos líneas de salida, con la secuencia femenina en la primera línea y la secuencia masculina en el segundo.

Entradas y salidas de muestra: Entrada: 5 Salida:[1, 1, 2, 2, 3] [0, 0, 1, 2, 2]

Entrada: 10 Salida:[1, 1, 2, 2, 3, 3, 4, 5, 5, 6] [0, 0, 1, 2, 2, 3, 4, 4, 5, 6]

NOTA: La separación entre listas significa un salto de línea.

Este es el código de golf, por lo que gana el código más corto en bytes. Además, ponga una explicación también para su código.

Tabla de clasificación

Mostrar fragmento de código

code-golf math sequence clismique
fuente
55
¿Podemos devolver un par de listas de una función, en lugar de imprimir las listas?
Zgarb
Otros desafíos que involucran las secuencias de Hofstadter: secuencia Q , secuencia figura-figura
Martin Ender
@Zgarb Puedes, siempre y cuando las dos listas estén en diferentes líneas.
clismique
2
@DerpfacePython No hay líneas en un par de listas; Si una función devuelve un par de listas, puede imprimirlas como desee. Dicho esto, no soy un gran admirador del requisito de líneas, incluso cuando imprimo la salida. Los formatos de E / S engorrosos son una de las cosas que se deben evitar al escribir desafíos.
Dennis
44
No es gran cosa para algunos enfoques / idiomas, pero puede hacer una gran diferencia para otros. En C, se pueden guardar muchos bytes imprimiendo las secuencias en columnas en lugar de filas. En Python, el enfoque más corto que se me ocurre es una lambda recursiva similar a mi respuesta recursiva de Julia que devuelve un par de listas, pero tener que convertirla en una cadena con un salto de línea hace que sea mucho más larga, incluso más larga que el programa completo publicado por Sp3000. Se descartan por completo otros enfoques, como una solución recursiva que cuenta hacia atrás en lugar de hacia arriba, ya que es imposible agregar la nueva línea.
Dennis

Respuestas:

3

Jalea , 22 20 bytes

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

Pruébalo en línea!

Cómo funciona

çƓḤ¤Ð¡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
fuente
55
Y esta es la parte en la que me siento orgulloso de mí mismo por hacer un desafío que hace que Jelly use más de 10 bytes.
clismique
13

Julia, 52 48 bytes

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

Pruébalo en línea!

Antecedentes

En las funciones casadas de On Hofstadter , el autor muestra que

F / M formula

donde φ denota la proporción áurea ,

fórmula delta / épsilon

y F n denota el n º número de Fibonacci .

Además, en Problemas y soluciones avanzadas, H-187: Fibonacci es un cuadrado , el proponente muestra que

Identidad de Fibonacci / Lucas

donde L n denota el n º número Lucas , y que - por el contrario - si

conversar la identidad de Fibonacci / Lucas

entonces n es un número de Fibonacci ym es un número de Lucas.

De esto, deducimos que

Teorema delta / épsilon

siempre que n> 0 .

Cómo funciona

Dada la entrada x , construimos una matriz 2 por x , donde | es además en la primera columna y la resta en el segundo, y n itera sobre los números enteros entre 1 y x en las filas.

El primer término de F (n - 1) y M (n - 1) es simplemente n÷φ.

Calculamos δ (n) y ε (n) calculando 5n² | 4 y probar si el resultado pertenece a la matriz de cuadrados de los enteros entre 2 y 3n . Esto prueba tanto la cuadratura como, dado que 1 no está en el rango, para n> 1 si | es resta.

Finalmente, sumamos o restamos el valor booleano resultante de 5n^2|4∈(2:3n).^2ay del entero previamente calculado.

Dennis
fuente
¿Se puede expresar de manera no recursiva / iterativa? ¿Cuál es la forma cerrada para ello?
Abr001am
He añadido una explicación.
Dennis
11

Python 2, 79 70 bytes

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

Iterativo en lugar de recursivo, porque por qué no. La primera línea tiene un espacio final; si no está bien, se puede arreglar para un byte adicional. -9 bytes gracias a @Dennis.

Aquí hay algunas lambdas combinadas que realmente no ayudaron:

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

Ambos toman ny un parámetro k0 o 1, especificando hombre / mujer. La primera lambda devuelve el enésimo elemento, y la segunda lambda devuelve los primeros n elementos (con tiempo de ejecución exponencial).

Sp3000
fuente
9

MATL , 23 bytes

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

Pruébalo en línea!

Explicación

Esto funciona de forma iterativa. Cada secuencia se mantiene en una matriz. Para cada índice n, el nuevo término de cada secuencia se calcula y se adjunta a la matriz correspondiente. Se utiliza un forbucle con N −1 términos, donde N es el número de entrada.

La actualización para la secuencia M debe hacerse primero. Esto se debe a que la secuencia F siempre es mayor o igual que la secuencia M para el mismo índice, por lo que si intentamos actualizar F primero, necesitaríamos un término de M aún no calculado.

Las dos ecuaciones de actualización son las mismas que intercambian F y M. Por lo tanto, el código para la actualización se reutiliza aplicando un forbucle con dos iteraciones e intercambiando las secuencias en la pila.

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
fuente
6

J, 47 bytes

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

Utiliza la definición recursiva. Las dos primeras líneas definen los verbos fy mrepresentan las funciones masculina y femenina, respectivamente. La última línea es un verbo que toma un solo argumento ny genera los primeros ntérminos de las secuencias femenina y masculina.

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
millas
fuente
6

JavaScript (ES6), 75 bytes

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

Podría guardar 2 bytes si se me permitiera devolver primero la secuencia masculina:

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

Haskell, 57 bytes

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

Ejemplo de uso: (<$>[v,w]).take $ 5->[[1,1,2,2,3],[0,0,1,2,2]]

La función auxiliar #crea una lista infinita con valor inicial sy una lista lpara buscar todos los elementos adicionales (en el índice del valor anterior). v = w#1es la w = v#0secuencia femenina y masculina. En la función principal tomamos los primeros nelementos de ambos vy w.

nimi
fuente
4

Python 2, 107 bytes

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)

Pruébalo en línea

Los valores de entrada más grandes provocan un RuntimeError (demasiada recursividad). Si esto es un problema, puedo escribir una versión donde el error no ocurra.

Mego
fuente
3

Pyth, 24 bytes

Probablemente sea imposible de usar reduce para reducir el conteo de bytes.

Implementación directa.

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

Pruébalo en línea!

Cómo funciona

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)
Monja permeable
fuente
¿Incluyo el nombre anagramático o su nombre original en la tabla de clasificación? Además, este código es muy largo para un programa Pyth.
clismique
¿Cuánto tiempo llevas aquí? ¿Cómo sabes que cambié mi nombre? Pon mi nuevo nombre allí.
Leaky Nun
1
He estado aquí el tiempo suficiente para saber que cambiaste tu nombre.
clismique
@DerpfacePython Al ver que otras respuestas son casi 4 veces más largas ... Diría que mi solución no es muy larga.
Leaky Nun
Eso es muy cierto, pero aún es largo en comparación con otros programas de Pyth para otras preguntas.
clismique
3

Brachylog , 65 bytes

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

Mi intento de combinar ambos predicados para hombre y mujer en uno solo hizo que el código fuera más largo.

Puede usar el siguiente revestimiento que tiene el mismo número de bytes:

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

Nota : Esto funciona con el transpilador Prolog, no con el antiguo Java.

Explicación

Predicado 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

Predicado 2 (femenino):

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

Predicado 3 (masculino):

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
Fatalizar
fuente
Espera ... ¿cuál es el predicado 3?
clismique
@DerpfacePython whoops, corregido. También tenga en cuenta que el predicado uno se {:1-:0re.}usa para crear la lista de rangos.
Fatalize
3

Clojure, 132 131 bytes

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

Simplemente construye las secuencias iterativamente de cero a n.

Versión sin golf

(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)))))
marca
fuente
Buena respuesta, bienvenido al sitio! ¿Es necesario un espacio final o una nueva línea? Estoy contando 131 + un espacio en blanco al final.
DJMcMayhem
No, no hay necesidad de un espacio en blanco al final. Sneaky vim agregó una nueva línea al final para que wc cuente.
Marque
3

Pyth, 23 bytes

jCuaG-LHtPs@LGeGr1Q],1Z

Pruébelo en línea: demostración

Explicación:

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

Solución alternativa que utiliza una función en lugar de reducir (también 23 bytes):

L?>b1-LbtPsyMytb,1ZjCyM
Jakube
fuente
Agradable. Muy bueno de verdad.
Leaky Nun
3

Ruby, 104 92 97 82 bytes

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

Editar: f y mahora son una función gracias a HopefullyHelpful . Cambié la segunda función para imprimir fentonces m. El espacio en blanco después pes significativo, ya que de lo contrario la función se imprime en (0...n)lugar del resultado demap .

La tercera función imprime primero una matriz de los primeros n términos de f, seguido de una matriz de los primeros n términos dem

Estas funciones se llaman así:

> 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
fuente
puedes soltar la p y parens. No es necesario imprimir la salida. Además, puedes dorp parens alrededor del rango.
No es que Charles
puede reemplazar la función 2 con 1 que tiene 2 argumentos nyi n>0?n-f(f(n-1,i),-i):i>0?1:0
HopefullyHelpful
@HopefullyHelpful Muchas gracias: D
Sherlock9
@NotthatCharles ¿No es necesario imprimir la salida? En Ruby, si quiero ese salto de línea entre fy m, necesito imprimirlo. De lo contrario, solo obtengo una serie como[[1, 1, 2, 2, 3, 3, 4, 5, 5, 6], [0, 0, 1, 2, 2, 3, 4, 4, 5, 6]]
Sherlock9
oh, dice "salto de línea". Demasiado.
No es que Charles
3

APL (Dyalog Unicode) , 45 25 bytes

Función tácita anónima. Requiere ⎕IO←0, que es estándar en muchos sistemas APL.

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

Pruébalo en línea!

Esto funciona combinando F y M en una única función diádica con un argumento izquierdo booleano que selecciona la función a aplicar. Usamos 1 para F y 0 para M para poder usar este selector como valor de retorno para F  (0) y M  (0). Luego observamos que ambas funciones deben llamarse a sí mismas primero (en el argumento menos uno) y luego la otra función en el resultado de eso, por lo que primero recurrimos con el selector dado y luego con el selector negado lógicamente.

⍳ ɩ ndices; argumento cero a uno menos uno

1 0∘.{... } "producto" externo (cartesiano) (pero con la siguiente función en lugar de multiplicación) usando [1,0]como argumentos izquierdos ( ⍺) y los índices como argumentos correctos⍵ ):

 ×⍵ si el argumento correcto es estrictamente positivo (literalmente, el signo del argumento correcto):

  ⍵-1 reste uno del argumento correcto

  ⍺∇ llamarse a sí mismo con eso como argumento correcto y el argumento izquierdo como argumento izquierdo

  (~⍺)∇ llamarse a sí mismo con eso como argumento derecho y la negación lógica del argumento izquierdo como argumento izquierdo

  ⍵- reste eso del argumento correcto y devuelva el resultado

 ⋄ más:

  ⍺ devolver el argumento izquierdo

Adán
fuente
Eso funciona bien, pero suponiendo que la entrada se almacena en una variable no está permitida de manera predeterminada.
Dennis
@ Dennis Realmente no. Es un cuerpo tfn. Cuando era nuevo aquí, ngn me dijo que no tenía que contar el encabezado tfn (que sería dos bytes, un nombre de un solo carácter + una nueva línea, al igual que no se cuenta el nombre de archivo de origen, y se permiten las entradas anónimas También aquí, donde el encabezado es un nombre de 1 carácter + espacio + un nombre de argumento de 1 carácter ( n) + una nueva línea.
Adám
¿Qué es exactamente un tfn?
Dennis
@Dennis Tfns son la representación tradicional APL de funciones. Consiste en líneas de código con casi ninguna de las dfns restricciones de . Por ejemplo, puede tener estructuras de control adecuadas y expresiones sin resultado. La línea "0" es un encabezado que indica la sintaxis de fn .
Adám
2

ES6, 89 85 83 bytes

2 bytes guardados gracias 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]}

Implementación ingenua.

Explicación:

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];
}
Solo ASCII
fuente
Creo que puede convertirlo en una función anónima y reemplazar los && - s con &
Bálint
No puede, &&cortocircuitos, lo que se desea, pero lo eliminé de todos modos porque la sintaxis de llaves es igualmente corta de todos modos
solo ASCII
Entonces podría hacer`F = [n = 1]
Bálint
2

Mathematica, 69 62 bytes

Gracias a Sp3000 por sugerir un formulario funcional que ahorró 14 bytes.

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

Esto define una función auxiliar con nombre fy luego se evalúa como una función sin nombre que resuelve la tarea real de imprimir ambas secuencias.

Martin Ender
fuente
2

Perl 5.10, 85 80 bytes

No sé si tengo más ideas para jugar golf ...

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

Pruébalo en línea!

Tuve que agregar use 5.10.0 Ideone para que aceptara elsay función, pero no cuenta para el conteo de bytes.

Es una implementación ingenua del algoritmo, @a siendo la lista "femenina" y@b la "masculina".

Tachado 85 sigue siendo 85?

Paul Picard
fuente
¿Explicación, por favor?
clismique
Más o menos lo mismo que mi respuesta de JS
solo ASCII
@DerpfacePython Es una implementación ingenua en realidad. :)
Paul Picard
No lo he probado, pero no creo que debas necesitar los paréntesis alrededor de cada push término ed ni el punto y coma final antes del paréntesis.
msh210
@ msh210 De hecho, se olvidó de esto. Ahorra 5 bytes en total, ¡gracias!
Paul Picard
2

Java, 169 bytes en 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 bytes

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

recursivo para bucle e impresión de 77 bytes

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

Salida de las listas en dos líneas diferentes 37 Bytes

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

entrada: p ( 10)
salida:

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
Con suerte
fuente
1

C, 166 bytes

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

Salida:

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

Sin golf (331 Bytes)

#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
fuente
0

8o , 195 bytes

Código

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

Explicación

Este código usa recursividad y palabra diferida

defer: M- Se Mdeclara que la palabra se define más tarde. Esta es una palabra diferida

: F dup not if 1 nip else dup n:1- recurse M n:- then ;- Definir F recursivamente para generar números femeninos según la definición. Tenga en cuenta que Maún no se ha definido

( dup not if 0 nip else dup n:1- recurse F n:- then ) is M- Definir M recursivamente para generar números masculinos según definición

: FM n:1- dup ( F . space ) 0 rot loop cr ( M . space ) 0 rot loop cr ; - Palabra utilizada para imprimir secuencias de números femeninos y masculinos.

Chaos Manor
fuente