ท้าทาย

กำหนดลำดับของตัวเลขให้สร้างฟังก์ชั่นที่คืนค่าลำดับขั้นตอน

• สมมติว่าลำดับจะเป็น 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 หารด้วยความยาวเอาต์พุต
• สมมติว่าลำดับจะเพิ่มขึ้นเรื่อย ๆ

นี่คือโค้ดกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ

เยลลี่ , 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.

JavaScript (ES6), 58 ไบต์

ส่งออกสตริงคั่นด้วยเครื่องหมายจุลภาค (พร้อมเครื่องหมายจุลภาคนำหน้า)

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

ลองออนไลน์!

หรือ56 ไบต์ถ้าเราใช้,-เป็นตัวคั่นและเราคิดว่าลำดับนั้นเพิ่มขึ้นอย่างเคร่งครัดเสมอ

อย่างไร?

ก่อนอื่นเราจะแปลงอาร์เรย์อินพุท[]เป็นรายการความแตกต่างติดต่อกันด้วย:

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

เพราะ หน้าเป็นชุดแรกเป็นค่าที่ไม่ใช่ตัวเลข (ฟังก์ชั่นการโทรกลับของแผนที่ () ) ซ้ำแรกผลตอบแทนถัวเฉลี่ยน่าน

ตัวอย่าง:

[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"

ในที่สุดเรามองหารูปแบบที่สั้นที่สุด¹ของจำนวนเต็มคั่นด้วยเครื่องหมายจุลภาค (,\d+ ) เริ่มต้นทันทีหลังจาก "NaN" และทำซ้ำจนถึงจุดสิ้นสุดของสตริง:

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.

Japt , 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}

ลองออนไลน์!

ขอบคุณ JayCe สำหรับการแนะนำเส้นทางโปรแกรมแบบเต็มและ -4 ไบต์บนฟังก์ชั่นและสำหรับ Giuseppe อีก -3

J , 22 19 ไบต์

บันทึก 3 ไบต์ด้วย FrownyFrog!

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 ไบต์

ที่บันทึกไว้ 3 ไบต์ต้องขอบคุณเควิน Cruijssen

¥.œʒË}нн

ลองออนไลน์!

05AB1E , 11 ไบต์

āεI¥ô}ʒË}нн

ลองออนไลน์!

āεI¥ô} ʒË} ннโปรแกรมเต็มรูปแบบ
āช่วงความยาว กด [1 ... len (inp)]
 ε} สำหรับแต่ละ ...
  ฉัน ... ô ... สับเดลตาเป็นชิ้นขนาดเท่ากัน
      ʒË} รักษาเฉพาะผู้ที่มีองค์ประกอบทั้งหมดเท่ากัน
         ннและเรียกองค์ประกอบแรกขององค์ประกอบแรก

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.

Javascript, 49 56ไบต์

แก้ไขแล้วขอบคุณ 7 ไบต์บันทึก (เดาว่าใคร?) Arnauld

แนวคิด regex เดียวกันกับ 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- ทำซ้ำนั้นจากนั้นเรียกใช้YLฟังก์ชัน ('แกลเลอรี') พร้อมด้วย5ตัวเลือก ('circulant') สร้างเมทริกซ์ที่มีเวกเตอร์ที่กำหนดเป็นแถวแรกจากนั้นแถวที่ต่อเนื่องกันจะเป็นเวกเตอร์เดียวกันเลื่อนเป็นวงกลมจนกว่ามันจะล้อมรอบ

FTF#Xu- ตรวจสอบแถวที่ไม่ซ้ำกันและรับหมายเลขแถวของพวกเขา (ไม่แน่ใจว่ามีวิธีที่สั้นกว่าในการทำเช่นนี้) เมื่อทำซ้ำขั้นตอนตามลำดับแถวที่เลื่อนเป็นวงกลมจะเหมือนกับแถวแรกและแถวที่ตามมาจะถูกทำซ้ำ นี่จะได้ดัชนีของการดำเนินการตามลำดับแรกก่อนที่จะเริ่มทำซ้ำ

) - ทำดัชนีโดยใช้สิ่งนั้นในอาร์เรย์ผลต่างเดิมเพื่อรับคำตอบ

เก่า:

d`tt@YS-a}@:)

ลองออนไลน์!

(-1 ไบต์ขอบคุณ Giuseppe)

คำอธิบาย:

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 ไบต์

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]

ลองออนไลน์!

ขั้นแรกสร้าง deltas dจากนั้นค้นหาคำนำหน้าแรกpของdที่เมื่อซ้ำ⌊len (L) / len (p) ⌋คูณอัตราผลตอบแทนLโดยLคือLที่รายการอินพุต

ทับทิม , 62 ไบต์

อาศัยตรรกะ Regex ดัดแปลงมาจากคำตอบของ Arnauld

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

ลองออนไลน์!

Java 10, 104 100 ไบต์

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

Regex ( ?.+?)\1*$สำหรับสตริงย่อยซ้ำที่สั้นที่สุดจาก@Neil 'แสดงความคิดเห็นเมื่อวันที่@Arnauld ' JavaScript (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

Python 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—#

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

ฉันรู้ว่ามี05AB1E สั้นกว่าสองคำตอบที่โพสต์โดย@ Mr.Xcoderแต่ฉันต้องการลองวิธีทางเลือกนี้โดยใช้การหมุนและการตรวจสอบความเท่าเทียมกัน
อาจจะสามารถเล่นกอล์ฟได้สองสามไบต์โดยไม่ต้องวางÁอาจจะสามารถกอล์ฟมันลงไม่กี่ไบต์โดยไม่ต้องวาง

-1 ไบต์หลังส่วนปลายของ@Emignaเพื่อลบการลงทะเบียน global_variable ( ©และ 2x ®) และใช้ Duplicate ( D) และ Triplicate ( Ð) แทน

คำอธิบาย:

¥             # 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 ไบต์

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

เรียกใช้อันนี้

Perl 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 ไบต์:

¥η.ΔÞ.¥-Ë

ชื่อเดียวกัน แต่แทนที่จะเปรียบเทียบกับรายการของ deltas (ซึ่งจำเป็นต้องได้รับการบันทึก / กู้คืน) การใช้นี้.¥(undelta) จะเปรียบเทียบกับอินพุต (โดยนัย)

ลองออนไลน์!

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

คำอธิบาย:

ดูเหมือนว่าหนักสำหรับสิ่งที่เรากำลังพยายามแก้ไข รับ delta ของอินพุตจากนั้นสร้างลำดับและกำหนดสั้นที่สุดที่ตรงกับมัน

(*&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 (Mathematica)ขนาด 26 ไบต์

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

ลองออนไลน์!

ส่งคืน Sequenceขั้นตอนที่มี

+2 ไบต์สำหรับListเอาต์พุต:

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

ลองออนไลน์!

Perl 5 -p , 55 ไบต์

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

ลองออนไลน์!

ตัวเลขคืออินพุตเป็นรายการคั่นด้วยช่องว่าง เอาต์พุตเป็นรูปแบบเดียวกัน