Thử thách

Đưa ra một chuỗi các số, tạo một hàm trả về các bước của chuỗi.

• Giả sử một chuỗi sẽ là N >= 3
• Trình tự sẽ lặp lại các bước ít nhất một lần
• Chuỗi sẽ chỉ chứa số tự nhiên
• Chức năng hoặc chương trình của bạn sẽ trả về chuỗi các bước ngắn nhất có thể

Thí dụ:

Đầu vào: [1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17]

Đầu ra: [1, 1, 2]

Giải thích: Trình tự ban đầu đi từ 1 => 2 (1 step), 2 => 3 (1 step), 3 => 5 (2 steps). Rồi nó lặp lại. Đầu ra sau đó là[1 step, 1 step, 2 steps] => [1, 1, 2]

Một vi dụ khac:

Đầu vào: [2, 5, 6, 7, 8, 11, 12, 13, 14, 17, 18, 19, 20]

Đầu ra: [3, 1, 1, 1]

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

Các trường hợp thử nghiệm

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]

Làm rõ

• Độ dài đầu vào - 1 chia hết cho chiều dài đầu ra
• Giả sử trình tự sẽ luôn luôn tăng

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Thạch , 9 7 byte

IsJEƇḢḢ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

JavaScript (ES6), 58 byte

Xuất ra một chuỗi được phân tách bằng dấu phẩy (có dấu phẩy hàng đầu).

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

Hãy thử trực tuyến!

Hoặc 56 byte nếu chúng ta sử dụng ,-làm dấu phân cách và chúng tôi giả sử rằng chuỗi luôn luôn nghiêm ngặt tăng .

Làm sao?

Trước tiên, chúng tôi chuyển đổi mảng đầu vào a [] thành một danh sách các khác biệt liên tiếp với:

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

Do p ban đầu được đặt thành giá trị không phải là số (hàm gọi lại của map () ), nên lần lặp đầu tiên mang lại NaN .

Thí dụ:

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

Sau đó chúng tôi ép kết quả thành một chuỗi:

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

Cuối cùng, chúng tôi tìm mẫu ¹ số nguyên ngắn nhất được phân tách bằng dấu phẩy ( ,\d+) bắt đầu ngay sau "NaN" và lặp lại cho đến hết chuỗi:

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

_{1: sử dụng không tham lam *?}

Brachylog , 11 byte

s₂ᶠ-ᵐṅᵐ~j₍t

Hãy thử trực tuyến!

Sẽ là 5 byte nếu có tích hợp cho các khác biệt liên tiếp.

Giải trình

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]

Bình thường, 11 byte

<J.+Qf.<IJT

Hãy thử nó ở đây

Giải trình

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

Japt , 14 12 byte

äa
¯@eUéX}aÄ

Thử nó

Giải trình

              :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

Nguyên

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

Thử nó

R , 49 46 byte

Chương trình đầy đủ:

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

Hãy thử trực tuyến!

R , 72 58 54 byte

Trình chức năng gốc với tất cả các trường hợp thử nghiệm ở một nơi:

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

Hãy thử trực tuyến!

Cảm ơn JayCe đã đề xuất lộ trình chương trình đầy đủ và -4 byte trên hàm và Giuseppe để biết thêm -3.

J , 22 19 byte

3 byte được lưu nhờ FrownyFrog!

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

Hãy thử trực tuyến!

[Dùng thử trực tuyến!] [TIO-ji2uiwla]

Làm sao?

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

Đã lưu 3 byte nhờ Kevin Cruijssen .

¥.œʒË}нн

Hãy thử trực tuyến!

05AB1E , 11 byte

āεI¥ô}ʒË}нн

Hãy thử trực tuyến!

εεI ô} ʒË} н chương trình đầy đủ.
ā Phạm vi chiều dài. Đẩy [1 ... len (inp)].
 ε} Đối với mỗi ...
  Tôi ¥ ô ... Cắt các đồng bằng thành các miếng có kích thước tương ứng
      ʒË} Chỉ giữ lại những phần tử có tất cả các phần tử bằng nhau.
         нн Và đầu tiên lấy phần tử đầu tiên của phần đầu tiên.

13 byte

Một lựa chọn dễ thương, IMO:

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

Hãy thử trực tuyến!

¥©ηʒ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.

Javascript, 49 56 byte

Biên tập 7 byte được lưu cảm ơn (đoán ai?) Arnauld

Cùng một ý tưởng regex như Arnauld, nhưng thật kỳ lạ khi thực hiện ...

Trả lại một chuỗi với các bước được phân tách bằng dấu phẩy (và dấu phẩy hàng đầu)

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

Kiểm tra

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 byte

dt5YLFTF#Xu)

Hãy thử trực tuyến!

Chỉ cần phát hiện ra rằng MATL không có chức năng tuần hoàn!

Giải trình

d - Nhận sự khác biệt giữa các điều khoản liên tiếp, như là một mảng

t5YL- sao chép đó, sau đó gọi hàm YL('gallery') với5 tùy chọn ('tuần hoàn'). Tạo một ma trận với vectơ đã cho là hàng đầu tiên, sau đó các hàng liên tiếp là cùng một vectơ được dịch chuyển theo vòng tròn, cho đến khi nó bao quanh.

FTF#Xu- Kiểm tra các hàng duy nhất và nhận số hàng của chúng (không chắc có cách nào ngắn hơn để thực hiện việc này không). Khi các bước tuần tự lặp lại, hàng được dịch chuyển vòng tròn sẽ giống như hàng đầu tiên và các hàng tiếp theo sẽ được lặp lại. Vì vậy, điều này nhận được các chỉ số của bước đầu tiên của chuỗi bước trước khi chúng bắt đầu lặp lại.

) - chỉ mục sử dụng điều đó vào mảng khác biệt ban đầu, để có câu trả lời.

Lớn hơn:

d`tt@YS-a}@:)

Hãy thử trực tuyến!

(-1 byte nhờ Giuseppe)

Giải trình:

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

Python 2 , 101 byte

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]

Hãy thử trực tuyến!

Đầu tiên tạo ra deltas d , sau đó tìm tiền tố đầu tiên p của d mà khi lặp lại ⌊len (L) / len (p) lần mang lại L , trong đó L là danh sách đầu vào.

Hồng ngọc , 62 byte

Dựa vào logic Regex được điều chỉnh từ câu trả lời của Arnauld .

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

Hãy thử trực tuyến!

Xác định thay thế khác biệt bước, cũng là 62 byte:

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

Hãy thử trực tuyến!

Java 10, 104 100 byte

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

Regex ( ?.+?)\1*$cho ngắn lặp đi lặp lại substring từ @Neil bình luận 's trên @Arnauld ' JavaScript (ES6) câu trả lời s .

Hãy thử trực tuyến.

Giải trình:

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 + THẮNG, 39 byte

Nhắc cho đầu vào.

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

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

Giải trình:

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

Python 2 , 86 85 byte

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)

Hãy thử trực tuyến!

Xây dựng sự khác biệt như d; nếu dlặp lại với kích thước đơn vị nthì d[n:]==d[:-n]; khác tái diễn.

Võng mạc 0.8.2 , 42 byte

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

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Đầu ra bao gồm dấu phẩy hàng đầu. Giải trình:

\d+
$*

Chuyển đổi sang unary.

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

Tính toán sự khác biệt về phía trước, ngoại trừ số đầu tiên, bị bỏ lại phía sau.

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

Phù hợp lặp lại sự khác biệt.

1+
$.&

Chuyển đổi thành số thập phân.

05AB1E , 14 13 byte

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

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Tôi biết đã có hai câu trả lời 05AB1E ngắn hơn được đăng bởi @ Mr.Xcoder , nhưng tôi muốn thử phương pháp thay thế này bằng cách sử dụng kiểm tra xoay vòng và bình đẳng.
Có thể đánh gôn xuống một vài byte mà không làm rơiÁ .

-1 byte sau một mẹo của @Emigna để xóa các thanh ghi global_variable ( ©và 2x ®) và sử dụng một Bản sao ( D) và Triplicate ( Ð) để thay thế.

Giải trình:

¥             # 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

Haskell, 107 byte

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

x là mảng đầu vào.

Stax , 8 6 byte

░»F\☺»

Chạy và gỡ lỗi nó

Đây là một phiên bản chú thích được giải nén để hiển thị cách thức hoạt động.

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

Chạy cái này

Perl 6 , 57 byte

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

Kiểm tra nó

Đầu ra được phân tách không gian ("1 1 2" )

Mở rộng:

{      # 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 byte

¥©η.ΔÞ®Å?

Giải trình:

          # 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 byte thay thế:

¥η.ΔÞ.¥-Ë

Cùng một thuật toán, nhưng thay vì so sánh với danh sách các vùng đồng bằng (cần được lưu / khôi phục), thì điều này sử dụng .¥(undelta) sau đó so sánh với đầu vào (ẩn).

Hãy thử trực tuyến!

K4 , 30 byte

Giải pháp:

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

Ví dụ:

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

Giải trình:

Có vẻ nặng nề cho những gì chúng tôi đang cố gắng giải quyết. Nhận deltas của đầu vào và sau đó xây dựng các chuỗi và xác định chuỗi ngắn nhất phù hợp với nó.

(*&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

Ngôn ngữ Wolfram (Mathicala) , 26 byte

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

Hãy thử trực tuyến!

Trả về một Sequencechứa các bước.

+2 byte cho Listđầu ra:

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

Hãy thử trực tuyến!

Perl 5 -p , 55 byte

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

Hãy thử trực tuyến!

Các số được nhập dưới dạng một danh sách được phân tách bằng dấu cách. Đầu ra là định dạng tương tự.