ক্রম পদক্ষেপ পান

17

চ্যালেঞ্জ

সংখ্যার ক্রম দেওয়া, একটি ক্রিয়াকলাপ তৈরি করুন যা অনুক্রমের পদক্ষেপগুলি দেয়।

  • অনুমান একটি ক্রম হবে 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  sequence  array-manipulation 
— লুইস ফিলিপে দে জেসুস মুনোজ
সূত্র
— অ্যাডমবর্কবার্ক
6
আমি সম্প্রতি বেশ কয়েকটি স্পষ্ট করার মত মন্তব্য সহ আপনি যে সমস্ত চ্যালেঞ্জ পোস্ট করেছেন তা দেখেছি এবং একটি দম্পতি "অস্পষ্ট" হিসাবে বন্ধ হয়ে গেছে এবং যথাযথ সম্পাদনাগুলি করার পরে পুনরায় খোলা হয়েছে। আপনি কি কয়েক দিন / এক সপ্তাহের জন্য স্যান্ডবক্সে এগুলি পোস্ট করার বিষয়টি বিবেচনা করেছেন ? আমি আপনার চ্যালেঞ্জগুলি উপভোগ করেছি যেহেতু তারা যথেষ্ট সহজলভ্য, তবে সমস্ত চ্যালেঞ্জগুলি, যতই সহজ সরল বা কারা পোস্ট করেছেন তারা পরিশোধিত ব্যবহার করতে পারে।
— জিউসেপ
2
@ জিউজ্পে আপনার পরামর্শের জন্য ধন্যবাদ। আমি বালির বাক্সে আরও কিছু চ্যালেঞ্জ পোস্ট করেছি (সাধারণত যদি আমি এর সাথে চ্যালেঞ্জ তৈরির সঠিক উপায় না পাই তবে আমি এটি মুছে ফেলব)। এই চ্যালেঞ্জগুলির জন্য আমি ভেবেছিলাম সেগুলি যথেষ্ট পরিষ্কার এবং সে কারণেই আমি তাত্ক্ষণিক পোস্ট করেছি তবে আমি প্রথমে সেগুলি স্যান্ডবক্সে পোস্ট করা শুরু করব। ধন্যবাদ
— লুইস ফেলিপ দে জেসুস মুনোজ
2
@ লুইস মেন্ডো হেরেটিক! 0 একটি প্রাকৃতিক সংখ্যা! এমনকি বিলি জোয়েলের একটি পুরো অ্যালবামটি পেরানো ম্যানকে উত্সর্গীকৃত ছিল!
— এনজিএম
1
@ অ্যাডমবার্কবার্ক, স্বেচ্ছাসেবী দৈর্ঘ্যের অপারেশন তালিকাগুলির সাথে কাজ করার ফলে এটি আরও সম্পর্কিত ।
— পিটার টেলর

উত্তর:

10

জেলি , 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.
— ডেনিস
সূত্র
9

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

কমা-বিচ্ছিন্ন স্ট্রিং আউটপুট দেয় (একটি অগ্রণী কমা সহ)।

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

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

বা 56 বাইট যদি আমরা ,-বিভাজক হিসাবে ব্যবহার করি এবং আমরা ধরে নিই যে ক্রমটি সর্বদা কঠোরভাবে হয় বৃদ্ধি পাচ্ছে।

কিভাবে?

আমরা প্রথমে ইনপুট অ্যারে a [] কে এই ধারাবাহিক পার্থক্যের তালিকায় রূপান্তর করি :

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

যেহেতু পি প্রাথমিকভাবে একটি অ-সংখ্যাসূচক মান ( মানচিত্রের কলব্যাক ফাংশন ) এ সেট করা আছে, প্রথম পুনরাবৃত্তিটি 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"

পরিশেষে, আমরা কমা-বিচ্ছিন্ন পূর্ণসংখ্যার সংক্ষিপ্ত 1 প্যাটার্নটি অনুসন্ধান করি ( ,\d+) "NaN" এর পরে শুরু হয়ে স্ট্রিংয়ের শেষ পর্যন্ত পুনরাবৃত্তি করে:

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

1: অ লোভী ব্যবহার করে *?

— Arnauld
সূত্র
আমি একই রেজেক্স আইডিয়া ভিত্তিক একটি সমাধান পোস্ট করছি, তবে বাস্তবায়নে খুব আলাদা। অবশ্যই খনি তৈরির আগে আমি অন্যান্য সমাধানগুলির দিকে নজর দিইনি এবং এটি যথেষ্ট আলাদা বলে মনে হচ্ছে, এবং সম্ভবত এটিই এখানে প্রথমবারের মতো আপনার চেয়ে আরও ভাল স্কোর পরিচালনা করতে সক্ষম।
— edc65
1
53 বাইট: /(,.+?)\1*$/।
— নীল
6

ব্র্যাচল্যাগ , 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]
— Fatalize
সূত্র
আপনি একটি বাইট সংরক্ষণ করার জন্য, লেজ পরে অবহেলা করতে পারেন?
— রড
@ রড আমার এখনও এটির মানচিত্র তৈরি করতে হবে, সুতরাং এটি একই দৈর্ঘ্য হবে। নেগেট হ'ল দুটি সংখ্যার মধ্যে একটি শিকারী, এটি অন্য ভাষার মতো তালিকায় স্বয়ংক্রিয়ভাবে ভেক্টরাইজ হয় না (অন্যথায় এটি অজানা ইনপুট / আউটপুটগুলি যা ঘোষণামূলক প্রোগ্রামগুলিতে প্রচলিত রয়েছে তা দিয়ে ভাল কাজ করবে না)
— ফ্যাটালাইজ করুন
5

পাইথ, 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.
5

আর , 49 46 বাইট

সম্পূর্ণ প্রোগ্রাম:

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

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

আর , 72 58 54 বাইট

সমস্ত পরীক্ষার ক্ষেত্রে এক জায়গায় আসল ফাংশন জমা দেওয়া:

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

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

ফাংশনে পুরো প্রোগ্রামের রুট এবং -4 বাইট প্রস্তাব করার জন্য জেসি এবং আরও -3-তে জিউস্প্পকে ধন্যবাদ জানাই।

— কিরিল এল।
সূত্র
-9 বাইটস একটি অন্তর্নির্মিতকে গালি দিয়ে এবং একটি সম্পূর্ণ প্রোগ্রাম তৈরি করে চ্যালেঞ্জটি একটি সম্পূর্ণ প্রোগ্রামকে অনুমতি দেয়।
— জয়সি
@ জায়েসির এখানেও দরকার a<-নেই
— জিউসেপ
4

জে , 22 19 বাইট

ফ্রাউনফ্রোগের জন্য 3 বাইট সংরক্ষণ করা হয়েছে! 

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

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

[এটি অনলাইনে ব্যবহার করে দেখুন!] [টিআইও-জিওউইউলা]

কিভাবে?

                 -      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
— গ্যালেন ইভানভ
সূত্র
আপনি যদি এর /:পরিবর্তে #\, আপনি 0{"1[:~.1 বাইট সংরক্ষণ করতে পারেন ।
— ফ্রাউনফ্রগ
আর "0 1নয়"{
— FrownyFrog
@ ফ্রাউনফ্র্যাগ ধন্যবাদ, আবারও!
— গ্যালেন ইভানভ
1
এটি দারুণ।
— জোনা
@ জোনাঃ হ্যাঁ, ফ্রাউনফ্রোগকে ধন্যবাদ!
— গ্যালেন ইভানভ
4

05 এ বি 1 ই , 8 বাইট

কেভিন ক্রুইজসেনকে 3 বাইট সংরক্ষণ করা হয়েছে ।

¥.œʒË}нн

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

05 এ বি 1 ই , 11 বাইট

āεI¥ô}ʒË}нн

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

আমি পুরো প্রোগ্রাম।
ā দৈর্ঘ্য ব্যাপ্তি। পুশ করুন [1 ... লেন (ইনপ)]।
 each each প্রত্যেকের জন্য ...
  আমি ô ô ... ডেল্টাসটিকে সংশ্লিষ্ট আকারের টুকরো টুকরো টুকরো টুকরো করে
      । only কেবলমাত্র তাদের সমস্ত উপাদান সমান রাখুন।
         । এবং প্রথমে প্রথমটির প্রথম উপাদানটি পুনরুদ্ধার করুন।

13 বাইট

একটি সুন্দর বিকল্প, আইএমও:

¥©ηʒ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.
— মিঃ এক্সকোডার
সূত্র
1
ব্যবহার করে 8 বাইট.œ ।
— কেভিন ক্রুইজসেন
3

জাভাস্ক্রিপ্ট, 49 56 বাইট

7 টি বাইট সম্পাদনা করুন সংরক্ষিত ধন্যবাদ (অনুমান করুন কে?) আরনাউল্ড

আর্নল্ড হিসাবে একই রেজেক্স ধারণা, তবে বাস্তবায়নে কৌতূহলজনকভাবে এত আলাদা ...

কমা দ্বারা পৃথক হওয়া পদক্ষেপের সাথে একটি স্ট্রিং ফিরিয়ে দেওয়া (এবং একটি শীর্ষস্থানীয় কমা)

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)))
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
ব্যবহার করা matchআমার একটি দুর্বল সিদ্ধান্ত ছিল। আপনি আমাকে আরও কিছু করতে পারেন । :-)
— আরনল্ড
3

এমএটিএল , 14 13 12 বাইট

dt5YLFTF#Xu)

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

সবেমাত্র আবিষ্কার হয়েছে যে এমএটিএল এর একটি সার্কুল্যান্ট ফাংশন রয়েছে!

ব্যাখ্যা

d - ধারাবাহিক পদগুলির মধ্যে একটি অ্যারে হিসাবে পার্থক্য পান

t5YL- এটির সদৃশ করুন, তারপরে YL('গ্যালারী') 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

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

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

প্রথম বদ্বীপ উত্পন্ন ঘ , তারপর প্রথম উপসর্গ খুঁজে বের করে পি এর ঘ যে যখন পুনরাবৃত্তি ⌊len (এল) / lên (P) ⌋ বার উৎপাদনের এল , যেখানে এল ইনপুট তালিকা রয়েছে।

— মিঃ এক্সকোডার
সূত্র
2

রুবি , 62 বাইট

আর্নাউল্ডের উত্তর থেকে অভিযোজিত রেজেক্স যুক্তি নির্ভর করে ।

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

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

— কিরিল এল।
সূত্র
2

জাভা 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 গুলি জাভাস্ক্রিপ্ট (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
— কেভিন ক্রুইজসেন
সূত্র
1

এপিএল + উইন, 39 বাইট

ইনপুট জন্য অনুরোধ।

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

এটি অনলাইন চেষ্টা করুন! সৌজন্যে ডায়ালগ ক্লাসিক

ব্যাখ্যা:

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
— গ্রাহাম
সূত্র
1

রেটিনা 0.8.2 , 42 বাইট

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

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

এটি অনলাইন চেষ্টা করুন! লিঙ্কে পরীক্ষার কেস অন্তর্ভুক্ত রয়েছে। আউটপুট লিডিং কমা অন্তর্ভুক্ত। ব্যাখ্যা:

\d+
$*

অ্যানারিতে রূপান্তর করুন।

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

প্রথম সংখ্যাটি বাদ দিয়ে পিছনে যে পার্থক্য রয়েছে তা গণনা করুন।

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

পুনরাবৃত্তি পার্থক্য ম্যাচ।

1+
$.&

দশমিক রূপান্তর।

— নিল
সূত্র
1

05 এ বি 1 ই , 14 13 বাইট

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

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

আমি জানি যে ইতিমধ্যে @ মিঃ এক্সকোডার দ্বারা পোস্ট করা দুটি ছোট 05AB1E উত্তর রয়েছে তবে আমি ঘূর্ণন এবং সাম্যতা পরীক্ষা করে এই বিকল্প পদ্ধতির চেষ্টা করতে চেয়েছিলাম।
কিছুটা বাইট না নামিয়ে এটিকে গল্ফ দিতে সক্ষম হতে পারেÁ ।

বিশ্বব্যাপী পরিবর্তনশীল রেজিস্টারগুলি ( এবং 2 এক্স) অপসারণ এবং একটি সদৃশ ব্যবহার করার জন্য @ এমিগানার একটি টিপ পরে -1 বাইট©®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
— কেভিন ক্রুইজসেন
সূত্র
1
এখানে একটি 9 টি রয়েছে (যেহেতু এটি একেবারে পৃথক পৃথক উত্তর, যদিও এটি ভাগ করে। Η)।
— গ্রিমি
@ গ্রিমি আপনি কি আমার সমস্ত 05AB1E উত্তরগুলি দিয়ে যাচ্ছেন এবং তাদের প্রত্যেকটি গল্ফ, হাহা? ; p ভাল উত্তর যদিও (এখনও আবার), আমার কাছ থেকে +1।
— কেভিন ক্রুইজসেন 16
1
তাদের সবাই নয়, আমি কেবল এই পোস্টে লিঙ্কযুক্তদের মধ্য দিয়ে যাচ্ছি ।
— গ্রিমি
@ গ্রিমি আহ ঠিক আছে, তা বোঝা যায়। :)
— কেভিন ক্রুইজসেন 16
1

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

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

এক্স ইনপুট অ্যারে।

— misja111
সূত্র
বিশেষত পিপিসিজি এবং হাস্কেল গল্ফিংয়ে আপনাকে স্বাগতম! আপনি ইনপুটটিকে একটি নির্দিষ্ট ভেরিয়েবলের উপস্থিতি ধরে নিতে পারবেন না, যদিও এটি সহজেই প্রিপেন্ডিংয়ের মাধ্যমে স্থির করা হয় f x=। এছাড়াও initsপ্রয়োজনীয় ব্যবহার import Data.Listযেমন উপস্থার অংশ নয়: এটি অনলাইনে চেষ্টা করুন!
— লাইকনি
তবে আপনি বেশ কয়েক বাইট সংরক্ষণ করতে পারেন: (init x)মাত্র হতে পারে xকারণ zipকাটছাঁট করে স্বয়ংক্রিয়ভাবে যদি তালিকার অন্য একজন এক চেয়ে বড়। এবং এর জন্য map(uncurry(-))$zipএকটি বিল্ট-ইন বিদ্যমান zipWith(-)। পরিবর্তে f x=let i=...inআপনি একটি প্যাটার্ন পাহারা ব্যবহার করতে পারেন: f x|i<-...=।
— লাইকোনি
উপরন্তু আপনি যদি এর পরিবর্তে একটি তালিকা ধী ব্যবহার করতে পারেন filter, !!0পরিবর্তে headএবং cycleপরিবর্তে concat$repeat: এটি অনলাইন ব্যবহার করে দেখুন!
— লাইকনি
@ লাইকনি আপনার উন্নতির জন্য অনেক ধন্যবাদ! আপনি ঠিক বলেছেন, আমার কোডটির জন্য একটি ফাংশন ঘোষণা এবং ডেটা.লিস্ট ইন্ডিটস জন্য একটি আমদানি দরকার। তবে আমি ভাবছিলাম, কোডের দৈর্ঘ্যে এটিকে যুক্ত করা উচিত? আমি জিজ্ঞাসা করছি কারণ অন্যান্য কোডের কয়েকটি নমুনা কিছু অতিরিক্ত কোডের উপরও নির্ভর করে।
— মিসজা 111
হ্যাঁ, এটি সাধারণ sensকমত্য যে সেই বাইটগুলি স্কোরের অন্তর্ভুক্ত। হাসকেলে গল্ফিংয়ের নিয়মাবলী সম্পর্কে আমাদের একটি গাইড রয়েছে যা এর বেশিরভাগ ক্ষেত্রে covers েকে থাকে
— লাইকনি
1

স্ট্যাক্স , 8 6 বাইট

░»F\☺»

এটি চালান এবং এটি ডিবাগ করুন

এটি কীভাবে কাজ করে তা দেখানোর জন্য এখানে একটি আনপ্যাক করা টীকাযুক্ত সংস্করণ।

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

এটি চালান

— পুনরাবৃত্তি
সূত্র
1

পার্ল 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
}
— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
পুরো প্রথম অংশটি হতে পারে~(.skip Z-$_)
— জো কিং
1

05 এ বি 1 ই , 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-বাইট:

¥η.ΔÞ.¥-Ë

একই রকম, তবে ডেল্টাসের তালিকার সাথে তুলনা না করে (যা সংরক্ষণ / পুনরুদ্ধার করা দরকার) এটি ব্যবহার করে .¥(আনডেল্টা) তারপরে (অন্তর্নিহিত) ইনপুটটির সাথে তুলনা করে।

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

— Grimmy
সূত্র
0

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
— streetster
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.