প্রতিটি সংখ্যা অসীম দীর্ঘ অবশেষ ক্রম ব্যবহার করে প্রতিনিধিত্ব করা যেতে পারে। উদাহরণস্বরূপ, আমরা যদি 7 নম্বরটি নিয়ে যাই এবং সম্পাদনা করি 7mod2তবে 7mod3তারপরে 7mod4, এবং আরও কিছু, আমরা পাই 1,1,3,2,1,0,7,7,7,7,....।

যাইহোক, আমাদের সবচেয়ে সংক্ষিপ্ত সম্ভাব্য অবশিষ্ট অংশ প্রয়োজন যা এখনও এটি সমস্ত নিম্ন সংখ্যা থেকে আলাদা করতে ব্যবহার করা যেতে পারে। আবার Using ব্যবহার করা [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...

নোট করুন যে 7 টি উপস্থাপন [1,1] করতে কাজ করে না , কারণ এটি 1 টি প্রতিনিধিত্ব করতেও ব্যবহৃত হতে পারে তবে যাইহোক, আপনার [1]1 এর ইনপুট দিয়ে আউটপুট করা উচিত ।

ইনপুট আউটপুট

আপনার ইনপুটটি একটি অ-নেতিবাচক পূর্ণসংখ্যা। উপরে বর্ণিত অনুসারে আপনাকে অবশ্যই ন্যূনতম-দৈর্ঘ্যের অনুক্রমের ক্রম বা তালিকাটি আউটপুট করতে হবে।

পরীক্ষার কেস:

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 দ্বারা বন্ধ রয়েছে)।

এটি একটি কোড-গল্ফ , তাই এটি আপনার প্রিয় ভাষায় যতটা সম্ভব সংক্ষিপ্ত করুন। দ্রুত যে কোনও উত্তরের জন্য জাল বোনাস পয়েন্ট!

— নাথান মেরিল
সূত্র

সম্পর্কিত

— পিটার টেলর

@ নিমিমি আমরা আড্ডায় সেই বিষয়ে কথা বলেছি এবং আমি সিদ্ধান্ত নিয়েছি যে সিকোয়েন্সগুলি কমপক্ষে 1 টি উপাদান দীর্ঘ হওয়া দরকার।

— নাথান মেরিল

1

আমি কিছুটা অবাক হয়েছি আপনি এটিকে প্রধান বাকী অনুসারীদের মধ্যে সীমাবদ্ধ করেননি।

— নীল

যদি কোনও তালিকাতে আউটপুট ফেরত দেওয়া হয় তবে তা ঠিক আছে?

— আর কাপ,

@ নিল, আমি এটিও বিবেচনা করেছি, তবে বাকি অংশগুলি যৌগিক সংখ্যার সাথে আলাদা হওয়ার কারণে, আমি এটি রাখার পক্ষে ভোট দিয়েছি

— নাথান মেরিল

5

গণিত, 60 53 বাইট

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

কিছুটা দ্রুত (এটি 10000কে ~ 0.1 সেকেন্ডে পরিচালনা করে, তবে সম্ভবত 100000 এর জন্য মেমরি শেষ হয়ে যাবে)।

কোডটি একটি ত্রুটি ছুঁড়েছে তবে ফলাফলটি সঠিকভাবে গণনা করে।

ব্যাখ্যা

আমরা আগে আড্ডায় খুঁজে পেয়েছি যে প্রয়োজনীয় বিভাজনগুলি সর্বদা সংক্ষিপ্ত তালিকা হিসাবে নির্ধারিত হতে পারে {1, 2, ..., n}যার সর্বনিম্ন সাধারণ একাধিক ইনপুট ছাড়িয়ে যায়। কেন এটির জন্য একটি সংক্ষিপ্ত যুক্তি: এলসিএম যদি ইনপুটটির চেয়ে কম হয়, তবে ইনপুট থেকে এলসিএম বিয়োগ করলে সমস্ত বিভাজন অপরিবর্তিত থাকবে, সুতরাং প্রতিনিধিত্বটি অনন্য নয়। তবে, এলসিএমের চেয়ে কম সমস্ত ইনপুটগুলির জন্য, অবশিষ্টগুলি অনন্য হবে, অন্যথায় সমান বাকী দু'টি সংখ্যার মধ্যে পার্থক্য সমস্ত বিভাজকের তুলনায় একটি ছোট গুণক হবে।

কোড হিসাবে ... যথারীতি গল্ফযুক্ত গাণিতিকের পড়ার ক্রমটি কিছুটা মজার।

Range[#+2]

এটি আমাদের [1, 2, 3, ..., n+2]ইনপুট জন্য একটি তালিকা পেতে n। +2তা নিশ্চিত করার জন্য এটি জন্য সঠিকভাবে কাজ করে 0এবং 1।

2~Range~#&/@...

এই তালিকার উপরে মানচিত্র 2~Range~#(সিনট্যাকটিক চিনি Range[2,#]), সুতরাং আমরা পাই

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

এগুলি প্রার্থী বিভাজকের তালিকা (অবশ্যই আমাদের প্রয়োজনের তুলনায় এটি অনেক বেশি)। এখন আমরা তাদের মধ্যে প্রথমটি খুঁজে পাই যার সাথে এলসিএম ইনপুট ছাড়িয়ে গেছে:

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

আরও সিনট্যাক্স: x_এমন একটি প্যাটার্ন যা তালিকার কোনওটির সাথে মেলে এবং এটি কল করে x। এই /;প্যাটার্নের সাথে একটি শর্ত সংযুক্ত করে। এই শর্তটি LCM@@x>#যেখানে তালিকায় ফাংশনটি @@ প্রয়োগ করে, তার LCM@@{1,2,3}অর্থ LCM[1,2,3]।

অবশেষে আমরা কেবল সত্য যে ব্যবহার করে সব remainders পেতে, Modহয় Listable, IE এটি স্বয়ংক্রিয়ভাবে একটি তালিকা উপর মানচিত্র থাকলে আর্গুমেন্ট এক একটি তালিকা রয়েছে (অথবা যদি তাদের উভয়ের একই দৈর্ঘ্য তালিকা হয়):

#~Mod~...

— মার্টিন ইন্ডার
সূত্র

5

জেলি , 14 বাইট

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

লিনিয়ার কংগ্রেসগুলির একটি পদ্ধতির সমাধান (যদি থাকে তবে) এটি মডিউলগুলির এলসিএম অনন্য মডিউল uses এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

কিভাবে এটা কাজ করে

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

— ডেনিস
সূত্র

5

এমএটিএল , 24 বাইট

এই উত্তরের পূর্ববর্তী সংস্করণে ত্রুটিটি নির্দেশ করার জন্য @ নিমিকে ধন্যবাদ (এখন সংশোধন করা হয়েছে)

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

দুটি বৃহত্তম পরীক্ষার ক্ষেত্রে অনলাইন সংকলকটিতে এটি মেমরির বাইরে চলে যায় (তবে এটি 4 জিবি র‌্যাম সহ কম্পিউটারে কাজ করে)।

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

এটি সংজ্ঞাটি সহজবোধ্যভাবে প্রয়োগ করে। ইনপুট করতে nএটা সম্বলিত একটি 2D অ্যারে নির্ণয় 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

— লুইস মেন্ডো
সূত্র

4

জেলি , 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.

— ডেনিস
সূত্র

কেন আপনি দুটি উত্তর অন্তর্ভুক্ত করেছেন ???

— এরিক দ্য আউটগল্ফার

কারণ তারা দুটি সম্পূর্ণ ভিন্ন পন্থা। এটি যখন 3 বাইট সংক্ষিপ্ত, অন্য একটি প্রকৃতপক্ষে সমস্ত পরীক্ষার কেস গণনা করার জন্য যথেষ্ট দ্রুত।

— ডেনিস

আমি যদি আপনি থাকতাম তবে আমি এটি করতাম না ... যদি এটি উপরের / ডাউন ভোটের জিনিস হত।

— এরিক দ্য আউটগল্ফার

বিভিন্ন ভাষা / পন্থা বিভিন্ন উত্তরে যায়। এটি আমার প্রথম মেটা প্রশ্ন ছিল।

— ডেনিস

3

পাইথন 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)

পাইথন 3.5 এবং সিম্পি ( python3 -m pip install --user sympy) প্রয়োজন। @ ডেনিসকে ক্রেডিট আমাকে অবহিত করতে যে পাইথন ৩.৩ *lডিফল্ট যুক্তি দিয়ে কৌশলটিকে মঞ্জুরি দেয় ।

— orlp
সূত্র

SymPy 0.7.5 সঙ্গে, আপনি খাটো করতে পারেন M>n and lথেকে l*(M>n)।

— ডেনিস

3

পাইথন 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

একটি সম্পূর্ণ প্রোগ্রাম। @ ডেনিস জিরো হ্যান্ডেল করার পদ্ধতি উন্নত করে 4 বাইট সংরক্ষণ করেছেন।

— xsot
সূত্র

3

হাস্কেল, 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]। এটি @ মার্টিন বাটনার এর উত্তরে বর্ণিত অ্যালগরিদম ।

আমি পূর্ববর্তী সংস্করণটিকে রেফারেন্সের জন্য রাখব, কারণ এটি বেশ দ্রুত:

হাস্কেল, 51 বাইট

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

f (10^100)আমার পাঁচ বছরের পুরানো ল্যাপটপের জন্য এটি 0.03s সময় নেয় ।

সম্পাদনা করুন: @ xnor সংরক্ষণ করতে একটি বাইট খুঁজে পেয়েছে। ধন্যবাদ!

— nimi
সূত্র

সূচকগুলি গণনা করে একটি বাইট সংরক্ষণ করুন যখন এলসিএম খুব বেশি না হয়ে যায়:h i=mod i<$>[2..2+sum[1|l<-scanl1 lcm[2..i],l<=i]]

— xnor

2

পাইথ, 51 বাইট 66 বাইট

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 ¹⁰^{^{3 এর}} মতো অযৌক্তিক সংখ্যক জন্য কাজ করছে বলে মনে হচ্ছে

~~দ্রষ্টব্য: এই উত্তর 0, 1 এবং 2 এর জন্য কাজ করে না~~ ed স্থির!

— poi830
সূত্র

2

জাভাস্ক্রিপ্ট (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 মূল সংখ্যাটি অতিক্রম না করা পর্যন্ত এটি পুনরাবৃত্তভাবে উত্তরটি তৈরি করে। জিসিডি অবশ্যই অবশ্যই পুনরাবৃত্তভাবে গণনা করা হয়।

সম্পাদনা করুন: @ ব্যবহারকারী81655 ধন্যবাদ 4 টি বাইট সংরক্ষণ করা।

— নিল
সূত্র

@ ব্যবহারকারী81655 এটি স্রেফ আন্ডারহ্যান্ডেড ...

— নীল

2

রুবি, 52 বাইট

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

এই সমাধানটি m2 থেকে শুরু করে প্রতিটি সম্ভাব্যতা পরীক্ষা করে যা এই অনুক্রমটিকে অনন্য করে তোলে। যা সর্বশেষটিকে mঅনন্য করে তোলে তা নিজেই বাকী নয়, তবে mএটিই সর্বনিম্নতম পরিসরের সর্বশেষ সদস্য (2..m)যেখানে এই ব্যাপ্তির সর্বনিম্ন সাধারণ একাধিক (এলসিএম) এর চেয়ে বেশি n। এটি চীনা রিমাইন্ডার তত্ত্বের কারণে, যেখানে nবেশ কয়েকটি অবশিষ্টের সাথে কী সংখ্যাটি অনন্যতার সাথে নির্ধারণ করতে হবে, সেই অবশিষ্টাংশের এলসিএম অবশ্যই বৃহত্তর হতে হবে n(যদি নির্বাচিত nহয় (1..n); যদি নির্বাচন করা nহয় a..b, তবে এলসিএম কেবলমাত্র এর চেয়ে বেশি হওয়া উচিত b-a)

দ্রষ্টব্য: আমি a<<n%mকোডের শেষে রেখেছি কারণ until n<t=t.lcm(m+=1)শর্ট সার্কিটগুলি এর আগে aএটির অনন্য করতে সর্বশেষ উপাদানটি পেয়েছে।

কারও কাছে যদি কোনও গল্ফিং পরামর্শ থাকে তবে দয়া করে আমাকে মন্তব্য বা পিপিসিজি চ্যাটে জানান ।

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

— Sherlock9
সূত্র

2

জুলিয়া, 36 33 বাইট

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

এটি অনলাইন চেষ্টা করুন!

— ডেনিস
সূত্র

1

পাইথন 3.5, 194 181 169 152 149 146 বাইট:

( 2 বাইটের জন্য @ শার্লক 9 কে ধন্যবাদ! )

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সমস্ত সংখ্যার পরিধি (7 সহ) থাকে এবং এটি পরিসরের প্রতিটি পূর্ণসংখ্যা হয় । প্রোগ্রাম তারপর অসীম মধ্যে যায় লুপ এবং দ্বিতীয় টু গত sublists মাধ্যমে প্রথম মধ্যে প্রতিটি sublist বিষয়বস্তু একই সংখ্যক তুলনা ( গত sublist (আইটেম একই সংখ্যক সঙ্গে) তালিকার) । যখন sublist হয় বিভিন্ন অন্য কোন sublist চেয়ে, লুপ থেকে বের নষ্ট হয়ে গেছে, এবং সঠিক সংক্ষিপ্ত বাকি ক্রম ফিরিয়ে দেওয়া হয়।j mod ij0=>7i0=>100whileyy[:-1:]y[-1]yy[-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]সঠিকভাবে ফিরে আসবে।

— আর কাপ
সূত্র

বাইট সংরক্ষণ করতে, y[:c:]হিসাবে একইy[:c]

— Sherlock9

0

সি 89, 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। স্টিডিনে একক সংখ্যা নেয় এবং স্টাডাউটের ফাঁকে ফাঁকে পৃথক করে থাকা অবশিষ্টদের ক্রমটি আউটপুট দেয়।

— orlp
সূত্র

1

এটি যখন এন = 0

— xsot

0

সি, 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);}

জিসিসি দিয়ে সংকলন করুন। এটি অনলাইনে ব্যবহার করে দেখুন: n = 59 , n = 0 ।

— xsot
সূত্র

সর্বনিম্ন অবশিষ্ট ক্রম উত্পন্ন করুন rate

ইনপুট আউটপুট

পরীক্ষার কেস:

গণিত, 60 53 বাইট

ব্যাখ্যা

জেলি , 14 বাইট

কিভাবে এটা কাজ করে

এমএটিএল , 24 বাইট

ব্যাখ্যা

জেলি , 13 11 বাইট

কিভাবে এটা কাজ করে

পাইথন 3.5, 117 95 78 বাইট

পাইথন 2, 73 70 69 65 বাইট

হাস্কেল, 66 60 51 50 বাইট

হাস্কেল, 51 বাইট

পাইথ, 51 বাইট 66 বাইট

জাভাস্ক্রিপ্ট (ES6), 81 77 বাইট

রুবি, 52 বাইট

জুলিয়া, 36 33 বাইট

পাইথন 3.5, 194 181 169 152 149 146 বাইট:

ব্যাখ্যা

সি 89, 105 বাইট

সি, 89 বাইট