여성 및 남성 서열

20

이 질문은 두 개의 시퀀스가 ​​동시에 작동해야하기 때문에 모든 "일련의 시퀀스 생성"작업보다 어려울 수 있습니다.

답을 기대하고 있습니다!

그의 책 " Gödel, Escher, Bach : Eternal Golden Braid "에서 Douglas Hofstadter는 내부에 상당히 적은 수의 시퀀스를 가지고 있으며, 모두 이전 방식에 의존합니다. 모든 시퀀스에 대한 정보는 이 Wikipedia 페이지를 참조하십시오 .

실제로 흥미로운 한 쌍의 시퀀스는 다음과 같이 정의되는 여성 및 남성 시퀀스입니다.

에 대한 n > 0.

여기에 여성 시퀀스가 ​​있습니다 와 Male 순서가 있습니다.

당신의 작업은 정수가 주어지면 n 입력n , 두 개의 출력 라인에서 여성의 순서와 남성 순서의 목록을 두 줄의 출력으로 반환합니다 . 두번째.

샘플 입력 및 출력 : 입력 : 5 출력 :[1, 1, 2, 2, 3] [0, 0, 1, 2, 2]

입력 : 10 출력 :[1, 1, 2, 2, 3, 3, 4, 5, 5, 6] [0, 0, 1, 2, 2, 3, 4, 4, 5, 6]

참고 : 목록 사이의 구분은 줄 바꿈을 나타냅니다.

이것은 코드 골프이므로 바이트 단위의 가장 짧은 코드가 이깁니다. 또한 코드에 대한 설명도 입력하십시오.

리더 보드

코드 스 니펫 표시

code-golf  math  sequence 
— Clismique
소스
5
리스트를 인쇄하는 대신 함수에서리스트를 반환 할 수 있습니까?
— Zgarb
Hofstadter의 시퀀스와 관련된 다른 도전들 : Q 시퀀스 , 그림-피겨 시퀀스
— Martin Ender
@Zgarb 두 목록이 다른 줄에있는 한 가능합니다.
— clismique
2
@DerpfacePython 한 쌍의 목록 에는 줄 이 없습니다 . 함수 가 한 쌍의 목록을 반환 하면 원하는대로 인쇄 할 수 있습니다. 즉, 출력을 인쇄 할 때조차도 라인 요구 사항의 팬이 아닙니다. 까다로운 I / O 형식 은 과제를 작성할 때 피해야 할 사항 중 하나입니다.
— Dennis
4
일부 접근 방식 / 언어에는 큰 영향을 미치지 않지만 다른 접근 방식에는 큰 차이를 만들 수 있습니다. C에서는 행이 아닌 열로 시퀀스를 인쇄하여 많은 바이트를 절약 할 수 있습니다. 파이썬에서 생각할 수있는 가장 짧은 접근법은 재귀 Julia 응답과 비슷한 재귀 람다입니다. 목록 쌍을 반환하지만 줄 바꿈이있는 문자열로 변환하면 전체 프로그램보다 훨씬 길어집니다. Sp3000에 의해 게시되었습니다. 줄 바꿈을 추가하는 것이 불가능하기 때문에 카운트 업이 아닌 카운트 다운하는 재귀 솔루션과 같은 다른 접근법은 완전히 배제됩니다.
— Dennis

답변:

3

젤리 , 22 20 바이트

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

온라인으로 사용해보십시오!

작동 원리

çƓḤ¤Ð¡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.
— 데니스
소스
5
그리고 이것은 젤리가 10 바이트 이상을 사용하게 만드는 도전을 한 것에 대해 자랑스러워하는 부분입니다.
— clismique
13

줄리아, 52 48 바이트

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

온라인으로 사용해보십시오!

배경

년 에 호프스 태터의 결혼 기능 , 저자 쇼가

F/M formula

여기서 φ는 나타내고 황금비를 ,

delta/epsilon formula

및 F , N은 나타내고 N 번째 피보나치 수를 .

또한, 고급 문제 및 솔루션에서 H-187 : 피보나치는 사각형 이며 제안자는

Fibonacci/Lucas identity

여기서 L n 은 n 번째 루카스 숫자를 나타내며 반대로 –

converse Fibonacci/Lucas identity

다음 N 피보나치 수이고 m은 루카스 번호이다.

이것으로부터, 우리는 그것을 추론합니다

delta/epsilon theorem

n> 0 일 때마다 .

작동 원리

입력 감안할 때 X , 우리는 건설 (2) 에 의해 X의 행렬, 어디 | 는 첫 번째 열에 더하고 두 번째에 뺄셈이며 n 은 행에서 1 과 x 사이의 정수를 반복 합니다.

F (n-1) 과 M (n-1) 의 첫 번째 항 은 간단 n÷φ합니다.

우리 컴퓨팅 δ (N) 와 ε (n)을 계산하여 5n²을 | 4 와 결과가 2 와 3n 사이의 정수의 제곱 배열에 속하는지 테스트합니다 . 이것은 직각도를 테스트하며, 1 이 범위 내에 있지 않기 때문에 n> 1 인 경우 | 빼기입니다.

마지막으로 5n^2|4∈(2:3n).^2이전에 계산 된 정수로 또는 그로부터 나온 부울을 더하거나 뺍니다 .

— 데니스
소스
이것은 비재 귀적 / 반복적 인 방식으로 표현 될 수 있는가? 닫힌 형식은 무엇인가?
— Abr001am
설명을 추가했습니다.
— Dennis
11

파이썬 2, 79 70 바이트

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

왜 재귀 적이 지 않고 반복적입니다. 첫 번째 줄에는 후행 공백이 있습니다. 그래도 좋지 않으면 여분의 바이트로 수정할 수 있습니다. @Dennis 덕분에 -9 바이트.

다음은 실제로 도움이되지 않은 결합 된 람다입니다.

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

테이크 모두 n와 매개 변수 k남성 / 여성 지정 0 또는 1 중 하나. 첫 번째 람다는 n 번째 요소를 반환하고 두 번째 람다는 첫 번째 n 요소를 지수 런타임으로 반환합니다.

— Sp3000
소스
9

MATL , 23 바이트

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

온라인으로 사용해보십시오!

설명

이것은 반복적으로 작동합니다. 각 시퀀스는 배열로 유지됩니다. 각각의 인덱스 n 에 대해, 각 시퀀스의 새로운 항이 계산되고 대응하는 어레이에 부착된다. for와 루프 N 여기서 -1 용어는, 사용되는 N이 입력 된 숫자이다.

시퀀스 M에 대한 업데이트가 먼저 수행되어야합니다. 이는 동일한 인덱스에 대해 시퀀스 F가 항상 시퀀스 M보다 크거나 같기 때문에 F를 먼저 업데이트하려고하면 아직 계산되지 않은 M이라는 용어가 필요합니다.

두 개의 업데이트 방정식은 F와 M을 교환하는 것과 동일합니다. 따라서 업데이트를위한 코드는 for두 개의 반복이 있는 루프를 적용 하고 스택의 시퀀스를 교체하여 재사용됩니다 .

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
— 루이스 멘도
소스
6

J, 47 바이트

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

재귀 정의를 사용합니다. 처음의 두 행은 동사를 정의 f하고 m있는 각각 여성 및 남성 기능을 나타낸다. 마지막 줄은 단일 인수 를 사용하여 암수 및 수열 n의 첫 번째 n항을 출력 하는 동사입니다 .

용법

   (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
— 마일
소스
6

자바 스크립트 (ES6), 75 바이트

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

Male 시퀀스를 먼저 반환하면 2 바이트를 절약 할 수 있습니다.

g=n=>--n?([f,m]=g(n),[m=[...m,n-f[m[n-1]]],[...f,n-m[f[n-1]]]]):[[1],[[0]]
— 닐
소스
6

하스켈, 57 바이트

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

사용 예 : (<$>[v,w]).take $ 5->[[1,1,2,2,3],[0,0,1,2,2]]

도우미 함수 #는 시작 값이있는 무한 목록과 모든 추가 요소를 찾기 s위한 목록 l(이전 값의 인덱스에서)을 작성합니다. v = w#1여성과 w = v#0남성의 순서입니다. 주 함수에서 와 의 첫 번째 n요소를 사용합니다 .vw

— 니미
소스
4

파이썬 2, 107 바이트

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)

온라인으로 사용해보십시오

입력 값이 클수록 RuntimeError (너무 많은 재귀)가 발생합니다. 이것이 문제라면 오류가 발생하지 않는 버전을 작성할 수 있습니다.

— 메고
소스
3

Pyth, 24 바이트

reduce바이트 수 를 줄이기 위해 사용 하는 것은 불가능할 것입니다 .

간단한 구현.

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

온라인으로 사용해보십시오!

작동 원리

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)
— 새는 수녀
소스
리더 보드에 분석 된 이름이나 원래 이름을 포함 시키나요? 또한이 코드는 Pyth 프로그램의 경우 너무 길다.
— clismique
여기 얼마나 있었어? 내 이름이 바뀌 었다는 걸 어떻게 알 수 있니? 거기에 내 새로운 이름을 넣어
— Leaky Nun
1
나는 당신이 당신의 이름을 바꿨다는 것을 알기에 충분히 오랫동안 여기에있었습니다.
— clismique
@DerpfacePython 다른 답변의 길이가 거의 4 배 길다는 것을 알았습니다 ... 내 솔루션이 그리 길지 않다고 말하고 싶습니다.
— Leaky Nun
그것은 사실이지만 다른 질문에 대해서는 다른 Pyth 프로그램과 비교할 때까지 오랜 시간입니다.
— clismique
3

Brachylog , 65 바이트

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

남성과 여성의 술어를 하나로 결합하려는 시도는 실제로 코드를 더 길게 만들었습니다.

동일한 바이트 수를 가진 다음 라이너 하나를 사용할 수 있습니다.

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

참고 : 이것은 이전 Java가 아닌 Prolog 변환기와 함께 작동합니다.

설명

주요 술어 :

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

술어 2 (여성) :

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

술어 3 (남) :

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
— 치명적
소스
잠깐만 ... 어느 술어 3?
— clismique
@DerpfacePython 으악, 고정. 또한 술어 하나는 {:1-:0re.}범위 목록을 작성하는 데 사용됩니다.
— 치명적
3

Clojure에서, 132 131 바이트

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

단순히 0에서 n까지 반복적으로 시퀀스를 빌드합니다.

언 골프 버전

(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)))))
— 표
소스
좋은 답변, 사이트에 오신 것을 환영합니다! 후행 공백이나 줄 바꾸기가 필요합니까? 나는 131 + 후행 공백을 세고 있습니다.
— DJMcMayhem
아니요, 후행 공백이 필요 없습니다. Sneaky vim은 wc를 계산하기 위해 끝에 줄 바꿈을 추가했습니다.
— 마크
3

Pyth, 23 바이트

jCuaG-LHtPs@LGeGr1Q],1Z

온라인으로 사용해보십시오 : 데모

설명:

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

축소 대신 함수를 사용하는 대체 솔루션 (23 바이트) :

L?>b1-LbtPsyMytb,1ZjCyM
— 자쿠 베
소스
좋은. 정말 좋습니다.
— Leaky Nun
3

루비, 104 92 97 82 바이트

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

편집 : f 및 m하나 개의 기능 덕분에 지금 HopefullyHelpful가 . f그런 다음 두 번째 기능을 인쇄하도록 변경했습니다 m. 이후의 공백 p은 중요합니다. 그렇지 않으면 함수 (0...n)는의 결과 대신 인쇄 됩니다 map.

첫 번째 기능 인쇄의 제 N 조건들의 어레이 f의 제 N 조건 배열 한 후,m

이러한 함수는 다음과 같이 호출됩니다.

> 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]
— 셜록 9
소스
p와 parens를 떨어 뜨릴 수 있습니다. 출력을 인쇄 할 필요는 없습니다. 또한 범위 주변에서 도프 파렌을 수행 할 수 있습니다.
— 찰스
당신은 2 개 인자를 가지고 그 1과 2 기능을 대체 할 수 n와i n>0?n-f(f(n-1,i),-i):i>0?1:0
— HopefullyHelpful
@HopefullyHelpful 감사합니다 무리 : D
— Sherlock9
@NotthatCharles 출력을 인쇄 할 필요가 없습니까? Ruby에서 f와 사이에 줄 바꿈을 원하면 m인쇄해야합니다. 그렇지 않으면, 단지 다음과 같은 배열을 얻습니다[[1, 1, 2, 2, 3, 3, 4, 5, 5, 6], [0, 0, 1, 2, 2, 3, 4, 4, 5, 6]]
— Sherlock9
oh, it does say "line break". Too bad.
— Not that Charles
3

APL (Dyalog Unicode), 45 25 bytes

Anonymous tacit function. Requires ⎕IO←0, which is standard on many APL systems.

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

Try it online!

This works by combining F and M into a single dyadic function with a Boolean left argument which selects the function to apply. We use 1 for F and 0 for M so that we can use this selector as return value for F (0) and M (0). We then observe that both functions need to call themselves first (on the argument minus one) and then the other function on the result of that, so first we recurse with the given selector and then with the logically negated selector.

⍳ ɩndices; zero through argument minus one

1 0∘.{…} outer (Cartesian) "product" (but with the below function instead of multiplication) using [1,0] as left arguments (⍺) and the indices as right arguments (⍵):

 ×⍵ if the right argument is strictly positive (lit. the sign of the right argument):

  ⍵-1 subtract one from the right argument

  ⍺∇ call self with that as right argument and the left argument as left argument

  (~⍺)∇ call self with that as right arg and the logical negation of the left arg as left arg

  ⍵- subtract that from the right argument and return the result

 ⋄ else:

  ⍺ return the left argument

— Adám
소스
That works well, but assuming input is stored in a variable is disallowed by default.
— Dennis
@Dennis It doesn't really. It is a tfn body. When I was new here, ngn told me I didn't have to count the tfn header (which would be two bytes, a single-char name + a newline, just like the source filename isn't counted, and anonymous fns are allowed. So too here, where the header is a 1-char name + space + a 1-char argument name (n) + plus a newline.
— Adám
What exactly is a tfn?
— Dennis
@Dennis Tfns are the traditional APL representation of functions. Consist of lines of code with almost none of the dfns's restrictions. E.g you can have proper control structures, and expressions with no result. Line "0" is a header which indicates the fn's syntax.
— Adám
2

ES6, 89 85 83 bytes

2 bytes saved thanks to @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]}

Naïve implementation.

Explanation:

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
소스
I think you can make it an anonymus function, and replace the &&-s with &
— Bálint
You can't, && short-circuits, which is wanted, but I removed it anyway because brace syntax is equally short anyway
— ASCII-only
Then you could do`F=[n=1]
— Bálint
2

Mathematica, 69 62 bytes

Thanks to Sp3000 for suggesting a functional form which saved 14 bytes.

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

This defines a named helper function f and then evaluates to an unnamed function which solves the actual task of printing both sequences.

— Martin Ender
소스
2

Perl 5.10, 85 80 bytes

Meh, dunno if I have more ideas to golf this down...

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

Try it online !

I had to add use 5.10.0 on Ideone in order for it to accept the say function, but it doesn't count towards the byte count.

It's a naive implementation of the algorithm, @a being the "female" list and @b the "male" list.

Crossed-out 85 is still 85 ?

— Paul Picard
소스
Explanation, please?
— clismique
Pretty much the same as my JS answer
— ASCII-only
@DerpfacePython It's a naive implementation actually. :)
— Paul Picard
I haven't tested, but I don't think you should need the parentheses around each pushed term, nor the final semicolon before the close-brace.
— msh210
@msh210 Indeed, forgot about this. Saves 5 bytes in total, thanks!
— Paul Picard
2

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

recursive-for-loop and printing 77 Bytes

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

outputting the lists in two different lines 37 Bytes

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
소스
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));}

Usage:

main()
{
    c(10);
}

Output:

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

Ungolfed (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
소스
0

8th, 195 bytes

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

Explanation

This code uses recursion and deferred word

defer: M - The word M is declared to be defined later. This is a deferred word

: F dup not if 1 nip else dup n:1- recurse M n:- then ; - Define F recursively to generate female numbers according definition. Please note that M has not yet been defined

( dup not if 0 nip else dup n:1- recurse F n:- then ) is M - Define M recursively to generate male numbers according definition

: FM n:1- dup ( F . space ) 0 rot loop cr ( M . space ) 0 rot loop cr ; - Word used to print sequences of female and male numbers

— Chaos Manor
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.