처음 두 항이 (또는 때때로 ) 있는 피보나치 수열에 익숙 할 것입니다. 그 이후의 모든 항은 이전 두 항의 합입니다. 다음과 같이 시작됩니다.0, 11, 1

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

때로는 시퀀스에 흥미로운 패턴이있는 숫자가 포함되어 있습니다. 인접한 숫자 쌍의 차이는 다른 쌍과 같습니다. 예를 들어로 시작하는 순서 0, 1에서 18 번째 항은 987입니다. 9-8=1그리고 8-7=1. 나는 약간 만족합니다.

도전

두 개의 초기 값 F(0)과가 주어지면 F(1)그에 의해 생성 된 시퀀스의 모든 숫자 F(n) = F(n-1) + F(n-2)가 다음 기준을 충족합니다.

• 인접한 숫자 쌍의 차이는 다른 쌍과 동일합니다.
• 길이는 3 자리 이상입니다 (1과 2 자리 숫자는이 패턴에서 흥미롭지 않습니다)

입력

• 10 ** 10 (100 억)보다 작은 음이 아닌 정수 2 개

산출

• 10 ** 10 미만이고 챌린지 섹션의 기준을 충족하는 모든 정수
• 10 ** 10보다 큰 숫자를 출력 할 수 있지만 필수는 아닙니다.
• 반복되는 자릿수가 패턴 (예 777:)을 충족하는 경우, 기준을 충족하는 무한한 숫자가있을 수 있지만 프로그램이 영원히 출력 할 필요는 없습니다.
• 그러한 정수가 존재하지 않으면 숫자가 아닌 한 원하는 것을 출력하십시오 (1, null, 빈 배열, 오류 메시지, 슬픈 얼굴 등).
• 패턴과 일치하는 숫자가 시퀀스에서 두 번 이상 나타나면 패턴을 한 번 또는 여러 번 출력 할 수 있습니다
• 입력이 기준을 충족하는 경우 출력에 포함되어야합니다.

규칙

• 입력 및 출력은 모든 표준 형식 일 수 있습니다
• 표준 허점 은 금지되어 있습니다
• 이것은 코드 골프 이므로 바이트 단위의 가장 짧은 코드가 승리합니다.

예 / 테스트 사례

Input , Output   
[1,10] , []   

[0,1] , [987]   
[2,1] , [123]   
[2,3] , [987]   

[61,86] , [147]   
[75,90] , [420]   
[34,74] , [1234]   
[59,81] , [2468]   
[84,85] , [7531]   

[19,46] , [111]   
[60,81] , [222]   
[41,42] , [333]   
[13,81] , [444]   
[31,50] , [555]   
[15,42] , [666]   
[94,99] , [777]   
[72,66] , [888]  
[3189,826] , [888888888]    

[15,3] , [159,258]   
[22,51] , [321,1357]   
[74,85] , [159,4444]   
[27,31] , [147,11111]   

[123,0] , [123,123,123,246,369]   
[111,0] , [111,111,111,222,333,555,888]
[111,222] , [111,222,333,555,888]      

[33345,692] , [987654321]   
[3894621507,5981921703] , [9876543210]
[765432099,111111111] , [111111111,876543210,987654321]   

[1976,123] , [123, 2222, 4321, 6543, 45678]   

MATL , 14 바이트

실수를 지적한 Emigna에게 감사합니다.

`yVdd~?yD]wy+T

발견 된 숫자를 출력하는 무한 루프.

온라인으로 사용해보십시오! 온라인 인터프리터에서 결과는 1 분 시간 초과 후에 표시됩니다.

설명

하자 F(n)및 F(n+1)피보나치 시퀀스의 두 가지 일반적인 연속 용어를 나타낸다. 루프의 각 반복은 스택 함유 시작 F(n), F(n+1)일부 n.

`         % Do...while
  y       %   Duplicate from below. Takes the two inputs F(0), F(1) (implicitly)
          %   in the first iteration
          %   STACK: F(n), F(n+1), F(n)
  V       %   Convert to string. Let the digits of F(n) be '3579' for example
          %   STACK: F(n), F(n+1), '3579'
  d       %   Consecutive differences (of ASCII codes)
          %   STACK: F(n), F(n+1), [2 2 2]
  d       %   Consecutive differences
          %   STACK: F(n), F(n+1),  [0 0]
  ~       %   Logical negate, element-wise
          %   STACK: F(n), F(n+1), [1 1]
  ?       %   If top of the stack is non-empty and only contains non-zero entries
          %   (this is the case for digits '3579', but not for '3578' or '33')
          %   STACK: F(n), F(n+1)
    y     %     Duplicate from below
          %     STACK: F(n), F(n+1), F(n)
    D     %     Display immediately. This prints the copy of F(n)
          %     STACK: F(n), F(n+1)
  ]       %   End
  w       %   Swap
          %   STACK: F(n+1), F(n)
  y       %   Duplicate from below
          %   STACK: F(n+1), F(n), F(n+1)
  +       %   Add. Note that F(n)+F(n+1) is F(n+2) 
          %   STACK: F(n+1), F(n+2)
  T       %   Push true. This will be used as loop condition
          %   STACK: F(n+1), F(n+2), true
          % End (implicit). The top of the stack is consumed as loop condition.
          % Since it is true, a new iteration will begin, with the stack
          % containing F(n+1), F(n+2)

05AB1E , 17 16 15 바이트

тFÂ2£O¸«}ʒS¥¥_W

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

설명

                  # implicitly input list of F(0) and F(1)
тF      }         # 100 times do:
  Â               # bifurcate current list
   2£             # take the first 2 items
     O            # sum
      ¸«          # append to list
         ʒ        # filter, keep only elements that are true after:
          S¥¥     # delta's of delta's of digits
             _    # logically negate each
              W   # min

자바 스크립트 (ES6), 85 84 81 바이트

f=(p,q,a=[])=>p|q?f(q,p+q,![...p+''].some(x=d=n=>r=d-(d=x-(x=n)))/r?[...a,p]:a):a

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

인접한 자리 테스트

![...p + ''].some(x = d = n => r = d - (d = x - (x = n))) / r

x 와 d 는 모두 익명 함수로 초기화되어 NaN관련된 모든 산술 연산 을 강제 합니다. 첫 번째 반복은 some()항상 (d = [function] - n) === NaNand (r = [function] - d) === NaN(false)입니다. 두 번째 반복에서는 d = x - n(정수)와 (r = NaN - d) === NaN(거짓 다시)가 있습니다. 세 번째 반복에서 시작하여 r 은 숫자 # 3과 숫자 # 2의 차이가 숫자 # 2와 숫자 # 1의 차이와 같지 않으면 0이 아닌 정수로 설정됩니다.

숫자 p 는 some()허위 (모든 인접 숫자가 동일한 차이가 있음)이고 r 의 최종 값 이 0 (최소 3 회 이상 반복 된 경우 ) 인 경우 필수 기준을 충족합니다 . 이것은 준다!false / 0 === true / 0 === Infinity (더러운)을 .

우리는 그렇지 않으면 :

• !true / r와 R> 0 또는 R <0 준다 false / r === 0(falsy)
• !false / NaN, true / NaN === NaN(가짜)

정지 조건

재귀는 0으로p | q 평가 되면 중지됩니다 . 이것은 p 와 q 가 모두 84 비트 길이 인 10 ²⁵ 주위의 값에 도달 할 때 발생 합니다. JS에는 52 비트 가수가 있으므로 마지막 32 비트는 0이됩니다. 따라서 32 비트 비트 단위 OR은 0으로 평가됩니다 .

시퀀스의 빠른 성장 속도로 인해 이것은 다소 빠르게 발생합니다.

자바 (8) 151 144 140 136 130 바이트

(a,b)->{for(long n,m,d,p;;System.out.print(m>99&p==d?m+" ":""),m=a+b,a=b,b=m)for(m=n=a,d=p=10;n>9&d==p|p>9;d=n%10-(n/=10)%10)p=d;}

무한 루프는 숫자를 찾을 때 출력합니다.
온라인으로 사용해보십시오 (60 초 후 시간 초과).

10 ¹⁰ 제한 ( a<1e10) 이 추가 된 136 바이트 버전 :

(a,b)->{for(long n,m,d,p;a<1e10;System.out.print(m>99&p==d?m+" ":""),m=a+b,a=b,b=m)for(m=n=a,d=p=10;n>9&d==p|p>9;d=n%10-(n/=10)%10)p=d;}

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

설명:

(a,b)->{         // Method with two long parameters and no return-type
  for(long n,m,  //  Temp numbers
           d,p;  //  Current and previous differences
      a<1e10;    //  Loop as long as `a` is still below 10^10
      ;          //    After every iteration:
       System.out.print(
                 //     Print:
        m>99     //      If the number has at least three digits,
        &p==d?   //      and the previous and current differences are still the same
         m+" "   //       Print the current number with a space delimiter
        :        //      Else:
         ""),    //       Print nothing
                 //     Go to the next Fibonacci iteration by:
       m=a+b,    //      Setting the temp-number `m` to `a+b`
       a=b,      //      Replacing `a` with `b`
       b=m)      //      And then setting `b` to the temp number `m`
    for(m=n=a,   //   Set both `m` and `n` to `a`
        d=p=10;  //   Set both `d` and `p` to 10
        n>9      //   Inner loop as long as `n` has at least two digits,
        &d==p    //   and `p` and `d` are still the same,
         |p>9    //   or `p` is still 10
        ;        //     After every iteration:
         d=n%10-(n/=10)%10)
                 //      Set `d` to the difference between the last two digits of `n`
                 //      And integer-divide `n` by 10 at the same time
      p=d;}      //    Set the previous difference `p` to `d`

젤리 , 20 19 18 바이트

>ȷ2ȧDIEƊ
+ƝḢ;Ɗȷ¡ÇƇ

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

+ƝḢ;Ɗȷ¡ȷ시리즈에서 처음 으로 충분한 항을 생성합니다. 나는 이것을하는 더 짧은 방법이 있다고 생각합니다. +ȷ¡가까워 지지만 첫 번째 항이 0 인 경우에만 작동합니다.

나는 우리가 1 바이트를 허용하는 두 숫자를 반대로 취할 수 있다고 가정합니다 DIE.

입력 중 하나를 출력 할 필요가없는 경우 :

젤리 , 15 바이트

>ȷ2ȧDIEƊ
+ṄÇ¡ß@

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

옥타브 , 91 90 83 바이트

Luis Mendo 덕분에 7 바이트가 절약되었습니다!

@(t)eval"for i=3:99,if~diff(diff(+num2str(t(1))))disp(t(1))end,t=[t(2) sum(t)];end"

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

잘 작동합니다!

evalfor 루프 를 사용하여 몇 바이트를 절약하십시오. 콜론과 세미콜론 을 건너 뛰어 몇 가지를 절약하십시오. 모든 요소가 저장 비제이다 IFF에 벡터가 truthy 간주된다는 사실 사용 any또는 all.

그 외에는 피보나치의 간단한 구현입니다.

파이썬 2 , 102 98 바이트

f=lambda x,y:x<1e10and[x]*(len(set(int(a)-int(b)for a,b in zip(`x`,`x`[1:])))<2<99<x)+f(y,x+y)or[]

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

4 바이트에 대한 Thx ovs

하스켈 , 105 바이트

u%v|let s=u:scanl(+)v s=[n|n<-s,d<-[f(-).map fromEnum.show$n],length d>1,and$f(==)d]
f g=zipWith g=<<tail

(%)모든 솔루션과 함께 무한 목록을 반환하는 연산자 를 정의합니다 . 실제로 stdout 에서 결과를 보려면 버퍼링을 비활성화해야합니다.ghci 또는과 runhaskell), 온라인 그것을 시도!

설명 / 비 골프

이 함수 f는 이진 함수와 목록을 기대하는 도우미 함수 일 뿐이며 g모든 인접한 쌍에 함수 를 적용합니다 . 본질적으로 다음과 같습니다.

adjacent g xs = zipWith (tail xs) xs

연산자 (%)는 일부 필터링을 수행하는 목록 이해입니다 (최소 3 자리 숫자와 인접 숫자의 거리가 동일해야 함).

u % v
  -- recursively define s as the "Fibonacci sequence" with f(0) = u and f(1) = v
  | let sequence = u : scanl (+) v sequence
  -- take all numbers from that sequence using the filters below
  = [ number | number <- sequence
  -- convert to string, get the ASCII codepoints and build a list of the adjacent differences
        , let differences = adjacent (-) . map fromEnum . show $ number
  -- numbers with > 3 digits have >= 2 adjacent digits (or rather differences of digits)
        , length differences > 1
  -- make sure all of these are equal by comparing them and reducing with logical and
        , and $ adjacent (==) differences
    ]

CJam , 55 바이트

q~{1$_99>"_`2\ew{{-}*}%""3,"?~_(+="0$p"*~;_@+_11_#<}g;;

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

첫 번째 CJam 제출물은 짧지 않지만 재미있었습니다. 어떤 제안이라도 환영합니다!

Stax , 26 24 바이트

Ç╕SôεPN^:·░ßⁿ {@ÿ}Ü╫╣1╣X

실행 및 디버깅

설명

E{b+}99*L{E%2>|cd_E:-u%1=!C_Qf    # Full program, unpacked, implicit input
E                                 # Push all elements from array onto stack.
 {b+}99*L                         # Generate the first 99 numbers of the  Fibonacci sequence given the input
         {                   f    # Loop through all Fibonacci elements
          E                       # Array of decimal digit
           %2>                    # Does the array have at least 3 digits
              |c                  # Assume Truthy past this point
                d                 # discard top of stack
                 _E               # Copy the current element of the Fibonacci sequence and Digitize it
                  :-              # Pairwise difference of array.
                    :u            # Is there exactly 1 unique number
                        !C        # Flip the comparison, if truthy proceed
                          _Q      # Copy the current element of the Fibonacci sequence and Peek and print with a newline.

내가 원하는만큼 짧지 않고 아마 조금 더 골프를 칠 수는 있지만 작동합니다.

루비 , 79 바이트

->a,b{loop{a>99&&!(a.digits.each_cons(2).map{|a,b|a-b}|[])[1]&&p(a);a,b=b,a+b}}

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

줄리아 0.6 , 86 81 바이트

a<b=b>=0&&((n->n>99&&2>endof(∪(diff(digits(n))))&&println(n)).([a,b]);a+b<a+2b)

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

매우 간단합니다. 입력에 3 자리 이상 ( n>99) 이 있는지 확인한 다음 숫자 ( )의 각 숫자 쌍의 차이를 diff(digits(n))확인하고 길이 ( endof)의 고유 한 세트 (∪ 가 1인지 확인하십시오 (예 : 모든 차이점) 같은 경우), 그렇다면 숫자를 인쇄하십시오. 주어진 숫자에 대해 그렇게 한 다음 다음 두 숫자로 재귀 적으로 함수를 호출하십시오.

(안타깝게도 ±이보다 우선 순위가 높은 것으로 보이 +거나 그렇지 않으면 최종 호출이 a+b±a+2b3 바이트를 절약 한 것 같습니다.) 이제 <연산자를 오버로드 하여 연산자 바이트와 우선 순위 대괄호를 모두 절약합니다. ( <하지만 우리 코드 에서는 사용할 수 없으므로로 다시 정렬 endof(...)<2하십시오 2>endof(...)).

일부 외부 출력이 허용되면, 우리가 사용하는 2 바이트를 절약 할 수 있습니다 @show대신 println인쇄, n = 987대신의 987. 그보다 dump1 바이트 낮은 값을 사용할 수도 있지만 dump값과 함께 유형 정보를 인쇄하므로 출력은 Int64 987그냥 대신됩니다 987.