ทุกหมายเลขสามารถแสดงได้โดยใช้ลำดับที่เหลือแบบไม่สิ้นสุด ตัวอย่างเช่นถ้าเราใช้เวลาจำนวน 7, และดำเนินการ7mod2แล้ว7mod3แล้ว7mod4และอื่น ๆ 1,1,3,2,1,0,7,7,7,7,....ที่เราได้รับ

อย่างไรก็ตามเราต้องการลำดับที่เหลือที่สั้นที่สุดเท่าที่จะเป็นไปได้ซึ่งยังสามารถใช้แยกแยะได้จากตัวเลขที่ต่ำกว่าทั้งหมด การใช้ 7 อีกครั้ง[1,1,3]เป็นลำดับที่สั้นที่สุดเนื่องจากลำดับก่อนหน้าทั้งหมดไม่เริ่มต้นด้วย[1,1,3]:

0: 0,0,0,0...
1: 1,1,1,1...
2: 0,2,2,2...
3: 1,0,3,3...
4: 0,1,0,4...
5: 1,2,1,0...
6: 0,0,2,1...

โปรดทราบว่า[1,1] ไม่สามารถใช้แทน 7 ได้เพราะสามารถใช้แทน 1 ได้อย่างไรก็ตามคุณควรส่งออก[1]ด้วยอินพุต 1

Input / Output

ข้อมูลที่คุณป้อนเป็นจำนวนเต็มที่ไม่เป็นลบ คุณต้องส่งออกลำดับหรือรายการลำดับที่เหลือน้อยที่สุดตามที่กำหนดไว้ข้างต้น

กรณีทดสอบ:

0: 0
1: 1
2: 0,2
3: 1,0
4: 0,1
5: 1,2
6: 0,0,2
7: 1,1,3
8: 0,2,0
9: 1,0,1
10: 0,1,2
11: 1,2,3
12: 0,0,0,2
30: 0,0,2,0
42: 0,0,2,2
59: 1,2,3,4
60: 0,0,0,0,0,4
257: 1,2,1,2,5,5
566: 0,2,2,1,2,6,6
1000: 0,1,0,0,4,6,0,1
9998: 0,2,2,3,2,2,6,8,8,10
9999: 1,0,3,4,3,3,7,0,9,0

นี่คือ10,000 ลำดับแรกในกรณีที่คุณสนใจ (หมายเลขบรรทัดถูกปิดด้วย 1)

นี่คือรหัสกอล์ฟดังนั้นให้สั้นที่สุดเท่าที่จะทำได้ในภาษาที่คุณชื่นชอบ คะแนนโบนัสปลอมสำหรับคำตอบที่รวดเร็ว!

Mathematica, 60 53 ไบต์

#~Mod~FirstCase[2~Range~#&/@Range[#+2],x_/;LCM@@x>#]&

ค่อนข้างเร็ว (จัดการได้ 10,000 ใน ~ 0.1 วินาที แต่น่าจะมีหน่วยความจำหมดเหลือ 100000)

รหัสเกิดข้อผิดพลาด แต่คำนวณผลลัพธ์ได้อย่างถูกต้อง

คำอธิบาย

เราพบว่าก่อนหน้านี้ในการแชทว่าตัวหารที่ต้องการสามารถถูกกำหนดได้เสมอว่าเป็นรายการที่สั้นที่สุด{1, 2, ..., n}ที่มีตัวคูณร่วมน้อยที่สุดเกินกว่าอินพุต อาร์กิวเมนต์สั้น ๆ สำหรับสาเหตุที่เป็นเช่นนั้น: ถ้า LCM น้อยกว่าอินพุตดังนั้นการลบ LCM ออกจากอินพุตจะทำให้ตัวหารทั้งหมดไม่เปลี่ยนแปลงดังนั้นการแสดงจึงไม่ซ้ำกัน อย่างไรก็ตามสำหรับอินพุตทั้งหมดที่น้อยกว่า LCM ส่วนที่เหลือจะไม่ซ้ำกันมิฉะนั้นความแตกต่างระหว่างตัวเลขสองตัวที่มีค่าเศษเท่ากันจะเป็นผลคูณที่น้อยกว่าของตัวหารทั้งหมด

สำหรับรหัส ... ตามปกติคำสั่งการอ่านของ Mathematica ที่ตีกอล์ฟนั้นค่อนข้างตลก

Range[#+2]

นี้เราได้รับรายชื่อสำหรับการป้อนข้อมูล[1, 2, 3, ..., n+2] คือเพื่อให้แน่ใจว่าการทำงานอย่างถูกต้องสำหรับและn+201

2~Range~#&/@...

แผนที่2~Range~#(น้ำตาลประโยคสำหรับRange[2,#]) เหนือรายการนี้ดังนั้นเราจึงได้รับ

{{}, {2}, {2,3}, ..., {2,3,...,n+2}}

เหล่านี้คือรายการตัวหารผู้สมัคร (แน่นอนโดยทั่วไปที่มากกว่าที่เราต้องการ) ตอนนี้เราพบคนแรกของพวกเขาที่ LCM เกินอินพุตด้วย:

FirstCase[...,x_/;LCM@@x>#]

ไวยากรณ์เพิ่มเติม: x_เป็นรูปแบบที่ตรงกับใด ๆ xของรายการและเรียกมันว่า /;ยึดติดเงื่อนไขกับรูปแบบที่ นี่คือสภาพLCM@@x>#ที่@@ ใช้ฟังก์ชั่นในรายการคือวิธีการLCM@@{1,2,3}LCM[1,2,3]

ในที่สุดเราก็จะได้ส่วนที่เหลือทั้งหมดใช้ประโยชน์จากความจริงนั่นModคือListableมันจะจับคู่กับรายการโดยอัตโนมัติหากหนึ่งในข้อโต้แย้งนั้นเป็นรายการ (หรือถ้าทั้งคู่เป็นรายการที่มีความยาวเท่ากัน):

#~Mod~...

เยลลี่ขนาด 14 ไบต์

‘Ræl\>iṠ2»2r⁸%

สิ่งนี้ใช้ความจริงการแก้ปัญหา (ถ้ามี) ของระบบสมการเชิงเส้นคือโมดูโลแบบเฉพาะของ LCM ของโมดูลัส ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

‘Ræl\>iṠ2»2r⁸%  Main link. Argument: n

‘               Increment; yield n+1.
 R              Range; yield [1, ..., n+1].
  æl\           Cumulatively reduce by LCM.
                This yields [LCM(1), ..., LCM(1, ..., n+1)].
     >          Compare all LCMs with n.
      iṠ        Find the first index of sign(n).
                This yields the first m such that LCM(2, ..., m) > n if n > 0, and
                0 if n == 0.
        2»      Take the maximum of the previous result and 2, mapping 0 to 2.
          2r    Yield the range from 2 up to and including the maximum.
            ⁸%  Compute n modulo each integer in that range.

MATL , 24 ไบต์

ขอบคุณ @nimi ที่ชี้ให้เห็นข้อผิดพลาดในรุ่นก่อนหน้าของคำตอบนี้ (ตอนนี้แก้ไขแล้ว)

Q:qtQ!\t0Z)tb=YpsSP2):Q)

สิ่งนี้มีหน่วยความจำไม่เพียงพอในคอมไพเลอร์ออนไลน์สำหรับกรณีทดสอบที่ใหญ่ที่สุดสองกรณี (แต่ทำงานบนคอมพิวเตอร์ที่มี RAM ขนาด 4 GB)

ลองออนไลน์!

คำอธิบาย

สิ่งนี้ใช้คำจำกัดความในลักษณะที่ตรงไปตรงมา สำหรับการป้อนข้อมูลnมันคำนวณอาร์เรย์ 2 มิติที่มีmod(p,q)กับpจาก0ไปnและqจากไป1 n+1แต่ละpคอลัมน์และแต่ละqแถว ตัวอย่างเช่นด้วยอินพุตn=7อาร์เรย์นี้คือ

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

ตอนนี้คอลัมน์สุดท้ายที่มีส่วนที่เหลือnเป็นองค์ประกอบที่ฉลาดเมื่อเทียบกับแต่ละคอลัมน์ของอาร์เรย์นี้ อัตราผลตอบแทนนี้

1 1 1 1 1 1 1 1
0 1 0 1 0 1 0 1
0 1 0 0 1 0 0 1
0 0 0 1 0 0 0 1
0 0 1 0 0 0 0 1
0 1 0 0 0 0 0 1
1 0 0 0 0 0 0 1
0 0 0 0 0 0 0 1

ที่1บ่งบอกถึงความเท่าเทียมกัน เห็นได้ชัดว่าคอลัมน์สุดท้ายมีค่าเท่ากับตัวมันเองและประกอบด้วยคอลัมน์ทั้งหมด เราจำเป็นต้องค้นหาคอลัมน์ที่มีจำนวนเริ่มต้นมากที่สุดนอกเหนือจากคอลัมน์สุดท้ายและรับทราบจำนวนเริ่มต้นmนั้น (ในกรณีนี้คือคอลัมน์ที่สองซึ่งมีคอลัมน์m=3แรก) ด้วยเหตุนี้เราคำนวณผลิตภัณฑ์สะสมของแต่ละคอลัมน์:

1 1 1 1 1 1 1 1
0 1 0 1 0 1 0 1
0 1 0 0 0 0 0 1
0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 1

จากนั้นหาผลรวมของแต่ละคอลัมน์

1 3 1 2 1 2 1 8

3แล้วเรียงไม่ใช่มากขึ้นและนำค่าที่สองซึ่งเป็น นี่คือสิ่งที่ต้องการmซึ่งบ่งบอกถึงจำนวนที่เหลือที่เราต้องเลือก

Q:q    % take input n implicitly. Generare row array [0 1 ... n]
tQ!    % duplicate. Transform into column array [1; 2; ...; n-1]
\      % modulo, element-wise with broadcast. Gives the 2D array
t0Z)   % duplicate. Take last column
tb     % duplicate, bubble up
=      % test for equality, element-wise with broadcast
Yp     % cumumative product of each column
s      % sum of each column. This gives the number of initial coincidences
SP2)   % sort in decreasing order and take second value: m
:Q     % generate range [2 3 ... m+1]
)      % apply as index into array of remainders of n. Implicitly display

เยลลี่ , 13 11 ไบต์

r¬µ%€R‘$ḟ/Ṫ

นี่จะไม่ชนะคะแนนบราวนี่ความเร็วใด ๆ ... ลองออนไลน์! หรือตรวจสอบกรณีทดสอบที่เล็กกว่าตรวจสอบกรณีทดสอบที่มีขนาดเล็ก

มันทำงานอย่างไร

r¬µ%€R‘$ḟ/Ṫ  Main link. Argument: n

r¬           Range from n to (not n).
             This yields [n, ..., 0] if n > 0 and [0, 1] otherwise.

  µ          Begin a new, monadic chain. Argument: A (range)

       $     Combine the previous two links into a monadic chain:
     R         Range; turn each k in A into [1, ..., k] or [] if k == 0.
      ‘        Increment to map k to [2, ..., k+1].
   %€        Take each k in A modulo all the integers in the 2D list to the right.
        ḟ/   Reduce by filter-not; sequentially remove all remainder sequences of
             n-1, ..., (not n) from the remainder sequences of n.
          Ṫ  Tail; take the last remainder sequence.
             This gives the shortest sequence for descending A and the longest one
             (i.e., [0]) for ascending A.

Python 3.5, 117 95 78 ไบต์

import sympy
r=lambda n,m=2,M=1,*l:M>n and l or r(n,m+1,sympy.lcm(m,M),*l,n%m)

ต้องการ Python 3.5 และ sympy ( python3 -m pip install --user sympy) ให้เครดิตกับ @Dennis เพื่อแจ้งให้ฉันทราบว่า Python 3.5 อนุญาตให้ใช้*lเคล็ดลับพร้อมอาร์กิวเมนต์เริ่มต้น

Python 2, 73 70 69 65 ไบต์

i=l=1
n=input()
while l<=n|1:
 i+=1;a=l;print n%i
 while l%i:l+=a

โปรแกรมเต็มรูปแบบ @Dennis บันทึก 4 ไบต์ด้วยการปรับปรุงวิธีจัดการศูนย์

Haskell, 66 60 51 50 ไบต์

f i=mod i<$>[2..2+sum[1|l<-scanl1 lcm[2..i],l<=i]]

ตัวอย่างการใช้งาน: ->f 42 [0,0,2,2]มันเป็นขั้นตอนวิธีการที่อธิบายไว้ในคำตอบ @ Martin Büttnerของ

ฉันจะเก็บรุ่นก่อนหน้าไว้อ้างอิงเพราะมันค่อนข้างเร็ว:

Haskell, 51 ไบต์

f i=mod i<$>[[2..x]|x<-[2..],foldl1 lcm[2..x]>i]!!0

ใช้เวลา 0.03 วินาทีสำหรับf (10^100)แล็ปท็อปอายุห้าขวบของฉัน

แก้ไข: @xnor พบไบต์ที่จะบันทึก ขอบคุณ!

Pyth, 51 Bytes 66 Bytes

IqQZ[Z).q)IqQ1[1))IqQ2,0 1))FdhhQJu/*GHiGHtUd1I>JQVQ aY%QhN)<tYd.q

ลอง!

รุ่น 39 ไบต์ความเร็วสูงขึ้นมาก (ไม่ทำงานสำหรับ 0-2):

FdhhQJu/*GHiGHtUd1I>JQVtd aY%QhN)<tYd.q

ดูเหมือนว่าจะทำงานกับคนจำนวนมากอย่างไร้สาระเช่น 10 ^{10 3}

หมายเหตุ: คำตอบนี้ใช้ไม่ได้กับ 0, 1 และ 2 แก้ไข!

JavaScript (ES6), 81 77 ไบต์

f=(n,r=[n%2],l=i=2,g=(j,k)=>j?g(k%j,j):k)=>l>n?r:f(n,[...r,n%++i],i/g(i,l)*l)

สิ่งนี้จะสร้างคำตอบซ้ำจนกระทั่ง LCM เกินจำนวนเดิม แน่นอนว่า GCD นั้นมีการคำนวณซ้ำแล้วซ้ำอีก

แก้ไข: บันทึกแล้ว 4 ไบต์ด้วย @ user81655

Ruby, 52 ไบต์

->n{m=t=1;a=[];(a<<n%m)until n<t=t.lcm(m+=1);a<<n%m}

โซลูชันนี้จะตรวจสอบทุก ๆ ความเป็นไปได้ที่mเริ่มต้นจาก 2 ซึ่งเป็นส่วนที่เหลือซึ่งทำให้ลำดับไม่ซ้ำกัน สิ่งที่ทำให้ที่ผ่านมาmที่ไม่ซ้ำกันไม่ได้ที่เหลือของตัวเอง แต่ที่mเป็นสมาชิกคนสุดท้ายของช่วงที่เล็กที่สุด(2..m)ที่ตัวคูณร่วมน้อย (LCM) nของช่วงที่มากกว่า นี่เป็นเพราะทฤษฎีบทส่วนที่เหลือของจีนที่จะกำหนดตัวเลขที่nมีจำนวนเศษที่ไม่ซ้ำกันLCM ของส่วนที่เหลือเหล่านั้นจะต้องมากกว่าn(ถ้าเลือกnจาก(1..n)นั้นหากเลือกnจากa..b, LCM ความต้องการเพียง แต่จะมากกว่าb-a )

หมายเหตุ:ฉันใส่a<<n%mท้ายรหัสเพราะuntil n<t=t.lcm(m+=1)ลัดวงจรมาก่อนaได้รับองค์ประกอบสุดท้ายเพื่อทำให้เป็นเอกลักษณ์

หากใครมีคำแนะนำการเล่นกอล์ฟใด ๆ โปรดแจ้งให้เราทราบในความคิดเห็นหรือในการแชท PPCGแชท

Ungolfing:

def remainder_sequence(num)
  # starting with 1, as the statements in the until loop immediately increments divisor
  divisor = 1
  # starts with 1 instead of 2, as the statements in the until loop
  # immediately change product to a new lcm
  product = 1
  remainders = []

  # this increments divisor first then checks the lcm of product and divisor
  # before checking if num is less than this lcm
  until num < (product = product.lcm(divisor = divisor + 1))
    remainders << num % divisor
  end

  # until always short circuits before the last element is entered
  # so this enters the last element and returns
  return remainders << num % divisor
end

Julia, 36 33 ไบต์

\(n,k=2)=lcm(2:k)>n?n%(2:k):n\-~k

ลองออนไลน์!

Python 3.5, 194 181 169 152 149 146 ไบต์:

( ขอบคุณ @ Sherlock9 สำหรับ 2 ไบต์! )

def r(o,c=0):
 y=[[j%i for i in range(2,100)]for j in range(o+1)]
 while 1:
  c+=1;z=y[-1][:c]
  if z not in[f[:c]for f in y[:-1]]:break
 print(z)

ทำงานได้อย่างสมบูรณ์แบบและยังค่อนข้างรวดเร็ว การคำนวณหาลำดับ100000เอาต์พุตที่เหลือน้อยที่สุด[0, 1, 0, 0, 4, 5, 0, 1, 0, 10, 4, 4]และใช้เวลาประมาณ 3 วินาทีเท่านั้น มันสามารถคำนวณลำดับของอินพุต1000000(1 ล้าน) ออกได้[0, 1, 0, 0, 4, 1, 0, 1, 0, 1, 4, 1, 8, 10, 0, 9]และใช้เวลาประมาณ 60 วินาที

คำอธิบาย

โดยทั่วไปสิ่งที่ฟังก์ชั่นนี้จะเป็นตอนแรกสร้างรายการyที่มีทั้งหมดj mod iที่jเป็นจำนวนเต็มในช่วงทุก0=>7(รวม 7) และเป็นทุกจำนวนเต็มในช่วงi 0=>100โปรแกรมจากนั้นจะเข้าสู่อนันต์whileห่วงและเปรียบเทียบจำนวนเดียวกันของเนื้อหาของแต่ละรายการย่อยภายในครั้งแรกผ่านรายการย่อยที่สองไปสุดท้ายของy( y[:-1:]) ที่มีหมายเลขเดียวกันของรายการในรายการย่อยสุดท้าย ( y[-1]) yของรายการ เมื่อรายการย่อยy[-1]คือที่แตกต่างกันกว่ารายการย่อยอื่น ๆ ห่วงเสียออกจากและถูกต้องตามลำดับที่เหลือน้อยที่สุดจะถูกส่งกลับ

ตัวอย่างเช่นถ้าอินพุตเป็น 3 yจะเป็น:

[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [1, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]]

จากนั้นเมื่อเข้าสู่ห่วงในขณะที่มันจะเปรียบเทียบแต่ละรายการย่อยในรายการที่y[:-1:]มีจำนวนรายการเดียวกันในรายการy[-1]ย่อย ยกตัวอย่างเช่นมันเป็นครั้งแรกจะเปรียบเทียบและ[[0],[1],[0]] [1]ตั้งแต่รายการย่อยสุดท้ายคือในส่วนที่เหลือของyมันจะดำเนินการต่อแล้วเปรียบเทียบและ[[0,0],[0,1],[0,2]] [1,0]เนื่องจาก[1,0]ขณะนี้ไม่ได้อยู่ในส่วนที่เหลือของy ลำดับเฉพาะนั่นคือลำดับการเตือนที่น้อยที่สุดดังนั้น[1,0]จะส่งคืนอย่างถูกต้อง

C89, 105 ไบต์

g(a,b){return b?g(b,a%b):a;}main(n,m,M){scanf("%d",&n);for(m=M=1;(M=++m*M/g(m,M))<=n;)printf("%d ",n%m);}

รวบรวม (มีคำเตือน) gcc -std=c89โดยใช้ รับหมายเลขเดียวบน stdin และส่งออกลำดับของส่วนที่เหลือคั่นด้วยช่องว่างบน stdout

C, 89 ไบต์

a,i=2;main(l,n){for(n=atoi(gets(n))?:!puts(n);n/l;printf("%d ",n%i++))for(a=l;l%i;l+=a);}

รวบรวมกับ gcc ลองมันออนไลน์: n = 59 , n = 0