도전

일련의 숫자가 주어지면 순서 단계를 반환하는 함수를 만듭니다.

• 시퀀스가 N >= 3
• 시퀀스는 적어도 한 번은 단계를 반복합니다
• 시퀀스는 자연수 만 포함합니다
• 함수 또는 프로그램은 가능한 가장 짧은 단계 시퀀스를 리턴해야합니다.

예:

입력: [1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17]

산출: [1, 1, 2]

설명 : 초기 순서는에서 시작 1 => 2 (1 step), 2 => 3 (1 step), 3 => 5 (2 steps)됩니다. 그런 다음 반복됩니다. 그러면 출력은[1 step, 1 step, 2 steps] => [1, 1, 2]

또 다른 예:

입력: [2, 5, 6, 7, 8, 11, 12, 13, 14, 17, 18, 19, 20]

산출: [3, 1, 1, 1]

[2, 5, 6, 7, 8, 11, 12, 13, 14, 17, 18, 19, 20]
 \  /\ /\ /\ / 
  3   1  1  1  Then it repeats...

테스트 사례

Input: [1, 4, 8, 9, 10, 13, 17, 18, 19, 22, 26, 27, 28] => Output: [3,4,1,1]

Input: [6, 11, 13, 18, 20, 25, 27, 32, 34, 39, 41] => Output: [5,2]

Input: [2, 6, 10, 13, 17, 21, 25, 28, 32, 36, 40, 43, 47] => Output: [4,4,3,4]

Input: [5, 6, 7] => Output: [1]

설명

• 입력 길이-1은 출력 길이로 나눌 수 있습니다
• 순서가 항상 증가한다고 가정

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

젤리 , 9 7 바이트

IsJEƇḢḢ

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

작동 원리

IsJEƇḢḢ  Main link. Argument: A (array)

I        Increment; compute D, the array of A's forward differences.
  J      Indices; yield [1, ..., len(A)].
 s       Split D into chunks of length k, for each k in [1, ..., len(A)].
   EƇ    Comb equal; keep only partitions of identical chunks.
     Ḣ   Head; extract the first matching parititon.
      Ḣ  Head; extract the first chunk.

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

쉼표로 구분 된 문자열을 앞에 쉼표로 출력합니다.

a=>(a.map(p=x=>-(p-(p=x)))+'').match(/N((,\d+)*?)\1*$/)[1]

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

또는 구분자로 사용 하고 시퀀스가 ​​항상 엄격 하다고 가정 하면 56 바이트,- 증가 입니다.

어떻게?

먼저 입력 배열 a [] 를 다음과 같은 연속 된 차이 목록으로 변환합니다 .

a.map(p = x => -(p - (p = x)))

때문에 , P가 처음 숫자가 아닌 값으로 설정된다 (의 콜백 함수 맵 () )의 첫 번째 반복 산출은 NaN이이 .

예:

[6, 11, 13, 18, 20, 25, 27, 32, 34, 39, 41]
[ NaN, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2 ]

그런 다음 결과를 문자열로 강제 변환합니다.

"NaN,5,2,5,2,5,2,5,2,5,2"

마지막으로, "NaN"바로 다음부터 시작하여 문자열 끝까지 반복되는 쉼표로 구분 된 정수 ( ) 의 최단 ¹ 패턴을 ,\d+찾습니다.

match(/N((,\d+)*?)\1*$/)

_{1 : 욕심없는 사용 *?}

Brachylog , 11 바이트

s₂ᶠ-ᵐṅᵐ~j₍t

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

연속적인 차이에 대한 기본 제공이있는 경우 5 바이트입니다.

설명

Example input: [6, 11, 13, 18, 20, 25, 27, 32, 34, 39, 41] 

s₂ᶠ             Find all substrings of length 2: [[6,11],[11,13],…,[34,39],[39,41]]
   -ᵐ           Map subtraction: [-5,-2,-5,-2,-5,-2,-5,-2,-5,-2]
     ṅᵐ         Map negate: [5,2,5,2,5,2,5,2,5,2]
       ~j₍      Anti-juxtapose the list of differences; the shortest repeated list is found
                  first, with the biggest number of repetitions: [5,[5,2]]
            t   Tail: [5,2]

Pyth, 11 바이트

<J.+Qf.<IJT

여기 사용해보십시오

설명

<J.+Qf.<IJT
 J.+Q          Call the sequence of differences in the input J.
     f         Find the first positive integer T...
      .<IJT    ... where rotating J by T doesn't change it.
<J             Take that many elements of J.

apt , 14 12 바이트

äa
¯@eUéX}aÄ

시도 해봐

설명

              :Implicit input of array U
äa            :Consecutive absolute differences
\n            :Reassign to U
 @    }aÄ     :Return the first positive integer X that returns true
   UéX        :  Rotate U right X times
  e           :  Check equality with U
¯             :Slice U to that element

기발한

äa
@eUîX}a@¯XÄ

시도 해봐

R , 49 46 바이트

전체 프로그램 :

d=diff(scan());while(any((s=d[1:T])-d))T=T+1;s

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

R , 72 58 54 바이트

한 곳에서 모든 테스트 사례와 함께 원래 기능 제출 :

function(a,d=diff(a)){while(any((s=d[1:T])-d))T=T+1;s}

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

전체 프로그램 라우트와 함수에 -4 바이트를 제안 해준 JayCe에게 감사 드리며, 추가 -3에 대해서는 Giuseppe에게 감사드립니다.

J , 22 19 바이트

FrownyFrog 덕분에 3 바이트가 절약되었습니다!

0{"1[:~./:|."{}.-}:

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

[온라인으로 사용해보십시오!] [TIO-ji2uiwla]

어떻게?

                 -      find the successive differences by subtracting 
                  }:    the list with last element dropped
               }.       from the list with the first element dropped 
           |."{         rotate the list of differences
         /:             0..length-1 times (the input graded up)
     [:~.               remove duplicating rows
 0{"1                   take the first element of each row

05AB1E , 8 바이트

Kevin Cruijssen 덕분에 3 바이트를 절약했습니다 .

¥.œʒË}нн

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

05AB1E , 11 바이트

āεI¥ô}ʒË}нн

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

āεI ¥ ô} ʒË} нн 전체 프로그램.
 길이 범위. [1 ... len (inp)]을 누릅니다.
 ε} 각각에 대해 ...
  I ¥ ô ... 델타를 해당 크기의 조각으로 자릅니다.
      elementsË} 모든 요소를 ​​동일하게 유지하십시오.
         그리고 먼저 첫 번째 요소의 첫 번째 요소를 검색합니다.

13 바이트

귀여운 대안, IMO :

¥©ηʒDg®ôÙ˜Q}н

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

¥©ηʒDg®ôÙ˜Q}н   Full program.
¥               Push the deltas.
 ©              Copy them to the register.
  ηʒ       }    And filter the prefixes by...
    D     Q     ... Is the prefix itself equal to...
     g®ô        ... The deltas, split into chunks of its length...
        Ù˜      ... Deduplicated and flattened?
            н   Head.

자바 스크립트, 49 56 바이트

감사합니다 7 바이트 저장 편집 (누가 추측합니까?) Arnauld

Arnauld와 같은 정규 표현식 아이디어이지만 구현 방식이 흥미 롭습니다 ...

단계 쉼표로 구분 된 문자열 (및 선행 쉼표)

p=>/N(.+?)\1+$/.exec(p.map(p=v=>[v-p,p=v][0]))[1]

테스트

var F=
p=>/N(.+?)\1+$/.exec(p.map(p=v=>[v-p,p=v][0]))[1]

;[[1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17]
,[1, 4, 8, 9, 10, 13, 17, 18, 19, 22, 26, 27, 28]
,[6, 11, 13, 18, 20, 25, 27, 32, 34, 39, 41] 
,[2, 6, 10, 13, 17, 21, 25, 28, 32, 36, 40, 43, 47]
,[5, 6, 7]]
.forEach(x=>console.log(x + ' -> ' + F(x)))

MATL , 14 13 12 바이트

dt5YLFTF#Xu)

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

MATL에 순환 기능이 있다는 것을 발견했습니다!

설명

d -연속적인 용어의 차이를 배열로 가져옵니다.

t5YL-복제 한 다음 ( 'circulant') 옵션을 사용 하여 YL( 'gallery') 함수 를 호출하십시오 5. 주어진 벡터를 첫 번째 행으로 사용하여 행렬을 만든 다음 연속 행은 줄 바꿈 될 때까지 같은 벡터를 순환 적으로 이동시킵니다.

FTF#Xu-고유 한 행을 확인하고 행 번호를 가져옵니다 (더 짧은 방법이 있는지 확실하지 않음). 시퀀스 단계가 반복되면 원형으로 이동 된 행은 첫 번째 행과 동일하며 후속 행은 반복됩니다. 따라서 이것은 반복을 시작하기 전에 첫 번째 시퀀스 단계 실행의 인덱스를 가져옵니다.

) -그것을 사용하여 원래의 차등 배열로 색인을 작성하여 답을 얻으십시오.

더 오래된 :

d`tt@YS-a}@:)

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

(주세페 덕분에 1 바이트)

설명:

d   % Get the differences between successive terms, as an array
`   % Start do-while loop
  tt  % duplicate the difference array twice
  @   % push the current loop index value
  YS  % circularly shift the difference array by that amount
  -   % subtract the shifted diffs from the original diffs
  a   % see if the subtraction resulted in any non-zeros
    % if it did, shifted differences were not equal to original differences, so continue loop 
}@ % if it didn't, then get loop index
:) % get the differences upto the loop index, before they started repeating
   % implicit loop end

파이썬 2 , 101 바이트

def f(l):d=[y-x for x,y in zip(l,l[1:])];g=len(l);print[d[:k]for k in range(1,g+1)if g/k*d[:k]==d][0]

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

우선 델타 생성 거라고 후 제 프리픽스 발견 P 의 D 반복 때 (L)을 ⌊len / 렌 (p) ⌋ 배 수율의 L , L은 입력 목록이다.

루비 , 62 바이트

Arnauld의 답변 에서 수정 된 Regex 논리에 의존합니다 .

->a{i=-2;a.map{|x|(i+=1)>=0?x-a[i]:0}*?,=~/((,\d+)*?)\1*$/;$1}

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

단계 차이의 대체 결정, 62 바이트 :

->a{[0,*a.each_cons(2).map{|x,y|y-x}]*?,=~/((,\d+)*?)\1*$/;$1}

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

자바 10, 104100 바이트

a->{var t="";for(int i=a.length;i-->1;t+=a[i]-a[i-1]+" ");return t.replaceAll("( ?.+?)\\1*$","$1");}

정규식 ( ?.+?)\1*$짧은을위한에서 하위 문자열 반복 @Neil '에 대한 코멘트 @Arnauld 의 자바 스크립트 (ES6) 대답' .

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

설명:

a->{                        // Method with integer-array parameter and String return-type
  var t="";                 //  Temp-String, starting empty
  for(int i=a.length;i-->1; //  Loop backward over the input-array, skipping the first item
    t+=a[i]-a[i-1]          //   Calculate the difference between two adjacent items
       +" ");               //   And append this with a space to the temp-String
  return t.replaceAll("( ?.+?)\\1*$", 
                            //  Find the shortest repeating substring
                     "$1");}//  And only keep one such substring

APL + WIN, 39 바이트

입력 프롬프트.

(↑((⍴v)=+/¨(⊂v)=(⍳⍴v)⌽¨⊂v)/⍳⍴v)↑v←-2-/⎕

온라인으로 사용해보십시오! Dyalog Classic 제공

설명:

v←-2-/⎕ Prompt for input and take successive differences

(⍳⍴v)⌽¨⊂v create a nested vector ans sequentially rotate by one to length of v

+/¨(⊂v)= compare to original v and sum positions where there is match

(⍴v)= identify where all elements match

(↑(....) identify number of rotations giving a first complete match

(↑(...)↑v take first number of elements from above from v as repeated sequence

파이썬 2 , 86 85 바이트

def f(a,n=1):d=[y-x for x,y in zip(a,a[1:])];return d[:-n]==d[n:]and d[:n]or f(a,n+1)

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

다음과 같이 차이점을 구성하십시오 d. d단위 크기 n로 반복 되면 d[n:]==d[:-n]; 그렇지 않으면 재귀.

레티 나 0.8.2 , 42 바이트

\d+
$*
(?<=(1+),)\1

1+(.+?)\1*$
$1
1+
$.&

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 출력에는 선행 쉼표가 포함됩니다. 설명:

\d+
$*

단항으로 변환합니다.

(?<=(1+),)\1

남은 첫 번째 숫자를 제외하고 앞으로 차이를 계산합니다.

1+(.+?)\1*$
$1

반복되는 차이를 일치시킵니다.

1+
$.&

십진수로 변환합니다.

05AB1E , 14 13 바이트

¥DηvÐNƒÁ}QD—#

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

@ Mr.Xcoder 게시 한 두 개의 더 짧은 05AB1E 답변 이 이미 있다는 것을 알고 있지만 회전 및 동등성 검사를 사용 하여이 대안을 시도하고 싶었습니다.
떨어 뜨리지 않고 몇 바이트 아래로 골프를 칠 수 있습니다 Á.

@Emigna 의 끝에서 -1 바이트를 사용 하여 global_variable 레지스터 ( ©및 2x ®) 를 제거하고 대신 중복 ( D) 및 삼중 ( Ð)을 사용하십시오.

설명:

¥             # Calculate the deltas of the input-array
              #  i.e. [1,2,3,5,6,7,9] → [1,1,2,1,1,2]
 D            # Duplicate it
  η           # Push all its prefixes
              #  [1,1,2,1,1,2] → [[1],[1,1],[1,1,2],[1,1,2,1],[1,1,2,1,1],[1,1,2,1,1,2]]
v             # For-each over these prefixes
 Ð            #  Triplicate the (duplicated) deltas-list
  NƒÁ}        #  Rotate the deltas-list N+1 amount of times,
              #  where N is the prefix index (== prefix_length-1)
              #   i.e. [1,1,2] and [1,1,2,1,1,2] (rotate 3 times) → [1,1,2,1,1,2]
      Q       #  If the rotated deltas and initial deltas are equal
              #   [1,1,2,1,1,2] and [1,1,2,1,1,2] → 1
       D—#    #  Print the current prefix-list, and stop the for-each loop

하스켈, 107 바이트

let i=map(uncurry(-))$zip(tail x)(init x)in head$filter(\s->take(length i)(concat$repeat s)==i)(tail$inits i)

x는 입력 배열입니다.

Stax , 8 6 바이트

░»F\☺»

실행 및 디버깅

작동 방식을 보여주기 위해 압축이 풀린 주석이 달린 버전이 있습니다.

:-  pairwise differences
:(  all leftward rotations of array
u   keep only unique rotations
mh  output the first element from each unique rotation

이것을 실행

펄 6 , 57 바이트

{~(.rotor(2=>-1).map:{.[1]-.[0]})~~/^(.+?){}" $0"+$/;~$0}

그것을 테스트

출력은 공백으로 구분됩니다 ("1 1 2" )

넓히는:

{      # bare block lambda with implicit parameter $_

  ~(   # stringify (space separated)

    .rotor( 2 => -1 )     # from the input take 2 backup 1, repeat
    .map: { .[1] - .[0] } # subtract each pair to find the differences
  )

  ~~   # smartmatch

  /    # regex

    ^  # beginning of string

    ( .+? ) # match at least one character, but as few as possible
    {}      # make sure $0 is set (probably a compiler bug)
    " $0"+  # match $0 one or more times (with a leading space)

    $  # end of string
  /;

  ~$0  # return the stringified $0
}

05AB1E , 9 바이트

¥©η.ΔÞ®Å?

설명:

          # take input implicitly
¥         # deltas, eg [4, 5, 7, 8, 10] -> [1, 2, 1, 2]
 ©        # save this to the global register
  η       # prefixes, eg [1, 2, 1, 2] -> [[1], [1, 2], ...]
   .Δ     # find the first one such that
     Þ    # cycled infinitely, eg [1, 2] -> [1, 2, 1, 2, ...]
       Å? # starts with
      ®   # the global register
          # and implicitly print the found element

대체 9 바이트 :

¥η.ΔÞ.¥-Ë

동일한 알고리즘이지만 델타 목록과 비교 (저장 / 복원해야 함)하는 대신 .¥ 해야하는) )를 사용한 다음 (암시 적) 입력과 비교합니다.

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

K4 , 30 바이트

해결책:

(*&d~/:c#'(!c:#d)#\:d)#d:1_-':

예 :

q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':2, 5, 6, 7, 8, 11, 12, 13, 14, 17, 18, 19, 20
3 1 1 1
q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17
1 1 2
q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':1, 4, 8, 9, 10, 13, 17, 18, 19, 22, 26, 27, 28
3 4 1 1
q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':6, 11, 13, 18, 20, 25, 27, 32, 34, 39, 41
5 2
q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':2, 6, 10, 13, 17, 21, 25, 28, 32, 36, 40, 43, 47
4 4 3 4
q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':5 6 7
,1

설명:

우리가 해결하려는 것에 무겁게 보입니다. 입력의 델타를 얻은 다음 시퀀스를 작성하고 일치하는 가장 짧은 것을 결정하십시오.

(*&d~/:c#'(!c:#d)#\:d)#d:1_-': / the solution
                           -': / deltas 
                         1_    / drop first
                       d:      / save as d
                      #        / take (#) from
(                    )         / do this together
                 #\:d          / take (#) each-left (\:) from d
          (     )              / do this together
              #d               / count length of d
            c:                 / save as c
           !                   / range 0..c-1
       c#'                     / take c copies of each
   d~/:                        / d equal (~) to each right (/:)
  &                            / where true
 *                             / first one

Wolfram Language (Mathematica) , 26 바이트

Differences@#/.{a__..}->a&

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

Sequence단계 가 포함 된를 반환 합니다.

List출력을 위한 +2 바이트 :

Differences@#/.{a__..}->{a}&

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

펄 5 -p , 55 바이트

s/\d+ (?=(\d+))/($1-$&).$"/ge;s/\d+$//;s/^(.+?)\1*$/$1/

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

숫자는 공백으로 구분 된 목록으로 입력됩니다. 출력은 같은 형식입니다.