নবম পার্থক্য

26

গণিতে, পার্থক্য গণনা করার জন্য প্রদত্ত সম্পর্কের ধরণের (লিনিয়ার, চতুর্ভুজ ইত্যাদি) কী তা বোঝার এক উপায়। এটি করার জন্য আপনি y মানগুলির একটি তালিকা নিয়েছেন যার জন্য সংবাদদাতা x মানগুলির মধ্যে ব্যবধানটি একই, এবং উপরের সংখ্যা থেকে প্রত্যেককে বিয়োগ করুন, তারপরে আগের তালিকাটির চেয়ে আরও ছোট সংখ্যার একটি তালিকা তৈরি করুন। যদি ফলাফলের তালিকাটি সম্পূর্ণরূপে অভিন্ন সংখ্যার সমন্বয়ে গঠিত হয়, তবে সম্পর্কের ক্ষেত্রে 1 এর পার্থক্য রয়েছে (এটি লিনিয়ার)। যদি সেগুলি অভিন্ন না হয়, তবে আপনি নতুন তালিকায় প্রক্রিয়াটি পুনরাবৃত্তি করুন। যদি তারা এখন অভিন্ন হয় তবে সম্পর্কের মধ্যে 2 এর পার্থক্য রয়েছে (এটি চতুর্ভুজযুক্ত)। যদি সেগুলি অভিন্ন না হয় তবে আপনি কেবল না হওয়া পর্যন্ত এই প্রক্রিয়াটি কেবল চালিয়ে যান। উদাহরণস্বরূপ, ক্রমবর্ধমান এক্স মানগুলির জন্য যদি আপনার y মানগুলির [1,6,15,28,45,66] তালিকা থাকে:

First Differences:

1
6   1-6  =-5
15  6-15 =-9
28  15-28=-13
45  28-45=-17
66  45-66=-21

Second differences:

-5 
-9  -5+9  =4
-13 -9+13 =4
-17 -13+17=4
-21 -17+21=4

As these results are identical, this relation has a difference of 2

তোমার কাজ:

একটি প্রোগ্রাম বা ফাংশন লিখুন, যখন ইনপুট হিসাবে পূর্ণসংখ্যার অ্যারে দেওয়া হয়, উপরে বর্ণিত হিসাবে অ্যারের দ্বারা বর্ণিত সম্পর্কের পার্থক্যটি প্রদান করে।

ইনপুট:

পূর্ণসংখ্যার একটি অ্যারে, যে কোনও দৈর্ঘ্যের হতে পারে> 1।

আউটপুট:

একটি পূর্ণসংখ্যা ইনপুট দ্বারা বর্ণিত সম্পর্কের পার্থক্যের প্রতিনিধিত্ব করে।

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

Input                            => Output
[1,2,3,4,5,6,7,8,9,10]           => 1
[1,4,9,16,25,36]                 => 2
[1,2,1]                          => 2 (when there is only one value left, all values are automatically identical, so the largest difference an array can have is equal to the length of the array-1)
"Hello World"                    => undefined behavior (invalid input)
[1,1,1,1,1,1,1,1,1]              => 0 (all elements are already identical)
[1, 3, 9, 26, 66, 150, 313, 610] => 6

স্কোরিং:

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

code-golf  math  array-manipulation 
— গ্রিফন - মনিকা পুনরায় স্থাপন করুন
সূত্র
ইনপুটটি যেমন হিসাবে "অবৈধ" হতে পারে, যদি ইনপুটটি প্রদত্ত অনুমানের সাথে সামঞ্জস্য না হয় তবে আমাদের কী ত্রুটি করা উচিত? আউটপুট হিসাবে -1 সরবরাহ করবেন?
— ম্যাজিক অক্টোপাস উর্ন
আচরণ অবৈধ ইনপুট জন্য undefined হয় (আমি কেয়ার করি না কি আপনার কোড আছে)
— Gryphon - পুনর্বহাল মনিকা
[1,2,1]2 দেওয়া উচিত নয় ? [1,2,1] -> [1,-1] -> [-2]
— হাইপারনিউটারিনো
@ হাইপারনিউট্রিনো, হ্যাঁ, দুঃখিত আমার সেখানে একটি মস্তিষ্কের উচ্ছ্বাস ছিল
— গ্রিফন -
এই পরীক্ষার [1,3,9,26,66,150,313,610]6
— কেসটি যুক্ত করুন

উত্তর:

10

কাস্তে , 6 বাইট

লিও আপনাকে তার সংস্করণটি ব্যবহার করতে দেওয়ার জন্য ধন্যবাদ যার জন্য এটি কাজ করে[1,1,1,1,1,1]

←VE¡Ẋ-

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

ব্যাখ্যা

   ¡     Repeatedly apply function, collecting results in a list
    Ẋ-     Differences
 VE      Get the index of the first place in the list where all the elements are equal
←        Decrement
— H.PWiz
সূত্র
2
যখনই কেউ বলেছেন যে হুস্কই নতুন জেলি, তারা বেশ ডান ছিল। > _ <
— জ্যাচার
অভিশাপ, আমি এই পোস্ট করছিলাম । ভাল কাজ যদিও, +1!
— লিও
@ লিও, পরীক্ষার কেস আমি দেখিনি, আমি কি [1,1,1,1]আপনার ব্যবহার করতে পারি?
— এইচপিউইজ
@ এইচ.পি.উইজ নিশ্চিত, এগিয়ে যান!
— লিও
7

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

f=a=>-a.every(x=>i=!x)||1+f(a.map(n=>n-a[++i]))

পরীক্ষার মামলা

কোড স্নিপেট দেখান

— Arnauld
সূত্র
7

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

`dta}x@q

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

ব্যাখ্যা

ফলটি সমস্ত শূন্য বা খালি না হওয়া পর্যন্ত এটি ধারাবাহিকভাবে পৃথক পার্থক্যগুলিকে পুনরুদ্ধার করে। আউটপুট হল পুনরাবৃত্তির বিয়োগ সংখ্যা 1 এর প্রয়োজনীয় সংখ্যা।

`      % Do... while
  d    %   Consecutive diffferences. Takes input (implicitly) the first time
  t    %   Duplicate
  a    %   True if any element is nonzero. This is the loop condition
}      % Finally (execute before exiting the loop)
  x    %   Delete. This removes the array of all zeros
  @    %   Push iteration index
  q    %   Subtract 1. Implicitly display
       % End (implicit). Proceed with next iteration if top of the stack is true
— লুইস মেন্ডো
সূত্র
7

আর , 50 44 বাইট

function(l){while(any(l<-diff(l)))F=F+1
F*1}

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

একটি লাগে diffএর l, সেট এটি l, এবং চেক যদি ফলাফলের কোনো অশূন্য মান ধারণ করে। যদি এটি হয়, ইনক্রিমেন্ট F(অন্তর্ভুক্ত হিসাবে প্রারম্ভিক FALSE), এবং ইতিমধ্যে সমস্ত F*1একইরূপে রূপান্তর FALSEকরতে ফিরে আসে ।0l

— : Giuseppe
সূত্র
সম্পূর্ণ প্রোগ্রাম এবং +F5 বাইট জন্য কৌশল । পরিষ্কার উত্তর বিটিডব্লিউ!
— জয়সি
5

গণিত, 49 বাইট

(s=#;t=0;While[!SameQ@@s,s=Differences@s;t++];t)&

থ্যানেক্স @alephalpa -6 বাইট এবং @ hftf -1 বাইট জন্য

এবং এখানে @hftf এর অন্য পদ্ধতি

গণিত, 49 বাইট

Length@NestWhileList[Differences,#,!SameQ@@#&]-1&
— J42161217
সূত্র
(s=#;t=0;While[UnsameQ@@s,s=Differences@s;t++];t)&
— আলেফাল্ফ
1
UnsameQ[1,2,1]মিথ্যা; !SameQ[1,2,1]সত্য. আমি মনে করি না ম্যানুয়াল লুপ পারেন অক্ষর সংরক্ষণ না: Length@NestWhileList[Differences,#,!SameQ@@#&]-1&ইতিমধ্যে প্রতিস্থাপন পর পুলিশের হিসাবে একই দৈর্ঘ্য হল UnsameQসঙ্গে !SameQ।
— hftf
4

জাপট , 10 7 বাইট

è@=ä-)d

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

ফলাফলটি ইনপুট অ্যারের দৈর্ঘ্যের মধ্যে গ্যারান্টিযুক্ত তা নির্ভর করে।

ব্যাখ্যা

è@=ä-)d     Implcit input of array U
 @          For each value in U...
  =ä-)      Update U to be equal to its subsections, each reduced by subtraction
      d     Check if any values in that are truthy
è           Count how many items in that mapping are true

শেষে, এই অ্যারের ম্যাপ করবে
[1, 3, 9, 26, 66, 150, 313, 610]করার [true, true, true, true, true, true, false, false],
যা ধারণ করে 6 trueসে।

পূর্ববর্তী 10 বাইট সংস্করণ

@=ä-)e¥0}a

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

— জাস্টিন মেরিনার
সূত্র
4

পার্ল 6 , 37 বাইট

{($_,{@(.[] Z- .[1..*])}...*.none)-2}

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

ব্যাখ্যা: ফাংশনটি একটি তালিকা হিসাবে ইনপুট নেয়। এটি এর পরে একটি পুনরাবৃত্ত ক্রম তৈরি করে: প্রথম উপাদানটি মূল তালিকা ( $_) হয়, পরবর্তী উপাদানগুলি {@(@$_ Z- .[1..*])}পূর্ববর্তী উপাদানটিতে ডেকে ফিরে আসে এবং শর্তটি *.noneসত্য না হওয়া পর্যন্ত এটি পুনরাবৃত্তি হয়, কেবলমাত্র তালিকাটি হয় তবেই ঘটে খালি বা এতে কেবল শূন্য রয়েছে (বা, প্রযুক্তিগতভাবে, অন্যান্য ভুয়া মান)। তারপরে আমরা তালিকাটি দখল করি এবং এটি থেকে 2 বিয়োগ করি, যা এটি প্রথমে সংখ্যার প্রসঙ্গে চলে আসে (এবং সংখ্যার প্রসঙ্গে তালিকাগুলি তাদের উপাদানগুলির সংখ্যার সমান হয়) এবং শেষে, উপাদানগুলির সংখ্যার চেয়ে 2 কম ফেরত দেয় তালিকা।

অদ্ভুত ব্লক {@(@$_ Z- .[1..*])}কেবলমাত্র প্রদত্ত তালিকাটি গ্রহণ করে ( .[]- তথাকথিত জেন স্লাইস - খালি বন্ধনী দিয়ে সূচকগুলি পুরো তালিকাটি দেয়), Z-প্রথম উপাদান ছাড়াই একই তালিকাতে মাইনাস অপারেটর ( ) ব্যবহার করে এটি জিপ করে .[1..*]এবং এটিকে একটি তালিকায় জোর করে ( @(...)- আমাদের এটি দরকার কারণ জিপ কেবল একটি সেক ফেরত দেয়, যা মূলত একমুখী তালিকা যা কেবল একবারে পুনরাবৃত্তি করা যায় Which যা আমাদের পছন্দ নয় এমন একটি বিষয়)) এবং এটিই।

— Ramillies
সূত্র
পরিবর্তন @(.[] Z- .[1..*])করার জন্য [.[] Z-.[1..*]]দুই বাইট সংরক্ষণ করা উচিত।
— nwellnhof
4

জাভা 8, 191 + 58 = 249 198 140 বাইট।

51 বাইটের জন্য PunPun1000 ধন্যবাদ।
58 বাইটের জন্য নেভাকে ধন্যবাদ।

int f(int[]a){int x=a.length-1,b[]=new int[x];for(;x-->0;)b[x]=a[x+1]-a[x];return java.util.Arrays.stream(a).distinct().count()<2?0:1+f(b);}

অনলাইনে চেষ্টা করে দেখুন!

এটি অনলাইনে ব্যবহার করে দেখুন (198 বাইট সংস্করণ)

সুতরাং, এটি আমার এখানে প্রথমবারের মতো পোস্ট করা হচ্ছে পিপিসিজিতে (এবং প্রথমবারের মতো কোনও কোড গল্ফ চ্যালেঞ্জ করছে)। যে কোনও গঠনমূলক সমালোচনা স্বাগত এবং প্রশংসা করা হয়। আমি পোস্ট করার জন্য নির্দেশিকাগুলি অনুসরণ করার চেষ্টা করেছি, যদি কিছু ঠিক না থাকে তবে এটিকে নির্দিষ্ট করে নির্দ্বিধায় মনে করি।

সুন্দর সংস্করণ:

int f(int[] a) {
    int x = a.length - 1, b[] = new int[x];
    for (; x-- > 0;) {
        b[x] = a[x + 1] - a[x];
    }
    return java.util.Arrays.stream(a).distinct().count() < 2 ? 0 : 1 + f(b);
}
— জে স্যালা
সূত্র
3
সাইটে স্বাগতম!
— ডিজেএমসিএমহেম
এই মডিউলগুলি আমদানির পরিবর্তে আপনি কেবল ব্যবহার করতে পারেনjava.util.stream.IntStream k = java.util.Arrays.stream(a);
— PunPun1000
বাস্তবে, আপনি নিখরচায় কিছু পরিবর্তন করতে পারেন। 1) publicবাইট গণনায় অন্তর্ভুক্ত করার দরকার নেই। ২) আপনার দ্বিতীয় প্যারামিটারটি গ্রহণ করা উচিত নয়, তবে এটি সরিয়ে ফেলা আসলে বাইটস সংরক্ষণ করতে পারে। 3) আপনি সেখানে কিছু অপ্রয়োজনীয় বন্ধনীগুলি সরাতে পারেন
— পুনপুন1000
4) সেভার নয় তবে আপনার যদি সম্ভব হয় তবে টিআইওও অন্তর্ভুক্ত করা উচিত,
— 1988
1
— নেভায়ে
3

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

g l|all(==l!!0)l=0|0<1=1+g(zipWith(-)l$tail l)

এটি কেবল পুনরাবৃত্তি করে - zipWith(-)l$last lএর পার্থক্য তালিকা l। এবং gফাংশন যা প্রশ্নের উত্তর দেয়।

— গর্বিত হাসেলেলার
সূত্র
পুনরাবৃত্তির সমাধান ভাল ছিল।
— jferard
@ jferard এটি খুব সত্য
— গর্বিত হাসেলেলার
3

কোটলিন , 77 বাইট

প্রথম পোস্ট, 2 বার কোটলিনে শেষ উত্তর সম্পাদনা করার চেষ্টা করেছে; ডি

{var z=it;while(z.any{it!=z[0]})z=z.zip(z.drop(1),{a,b->a-b});it.size-z.size}

@jrtapsell থেকে পরীক্ষার অংশ নিয়েছে

TryItOnline

— cab404
সূত্র
পিপিসিজিতে আপনাকে স্বাগতম! প্রথম প্রথম উত্তর, একটি আউটগল্ফ।
— এইচ.পি.উইজ
3

এপিএল (ডায়ালগ ক্লাসিক) , 22 17 বাইট

{1=≢∪⍵:0⋄1+∇2-/⍵}

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

-২ বাইটের জন্য @ngn ধন্যবাদ!

কিভাবে?

  • { ... }, কাজ
  • 1=≢∪⍵:0, যদি প্রতিটি উপাদান যুক্তিতে সমান হয় তবে ফিরে আসুন 0
  • 1+∇2-/⍵, অন্যথায়, 1 টি nপার্থক্য ফিরিয়ে দিন (যা এটি n-1এভাবে যুক্ত করে n)
— Zachary
সূত্র
আপনি যদি পুচ্ছ-পুনরাবৃত্তির ত্যাগ করেন তবে এটি খাটো:{1=≢∪⍵:0⋄1+∇2-/⍵}
— ngn
2

জেলি , 7 বাইট

IÐĿEÐḟL

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

ব্যাখ্যা

IÐĿEÐḟL  Main link
 ÐĿ      While results are unique (which is never so it stops at [])
I        Take the increments, collecting intermediate values # this computes all n-th differences
    Ðḟ   Filter out
   E     Lists that have all values equal (the first n-th difference list that is all equal will be removed and all difference lists after will be all 0s)
      L  Take the length (this is the number of iterations required before the differences become equal)

-1 বাইট জোনাথন অ্যালানকে ধন্যবাদ

— HyperNeutrino
সূত্র
1
@ গ্রিফোন হয়ে গেল! :)
— হাইপারনিউটারিনো
IÐĿEÐḟLসাতটির জন্য (আমি মাইলগুলি পুনরাবৃত্তির সাহায্যে একটি সাতও পেয়েছি দেখতে পাচ্ছি)।
— জোনাথন অ্যালান
@ জোনাথান অ্যালান শীতল ধন্যবাদ!
— হাইপারনিউটারিনো
2

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

f=a=>+(b=a.slice(1).map((e,i)=>e-a[i])).some(e=>e)&&1+f(b)
— নিল
সূত্র
+0, পর্যাপ্ত নয় জ্যাকুইরি: পি। সত্যিই যদিও, +1, খুব ভাল কাজ, আমি জানি আমি কখনই জেএস-তে গল্ফ করতে পারব না।
— জাকারি
2

পাইথন 2 , 65 বাইট

-7 বাইট জনাথন অ্যালান ধন্যবাদ।

f=lambda l,c=1:any(l)and f([j-i for i,j in zip(l,l[1:])],c-1)or-c

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

— totallyhuman
সূত্র
একটি বাইট initialising সংরক্ষণ cকরতে 1, decrementing এবং তারপর ব্যবহার print-c।
— জোনাথন অ্যালান
এটিকে পুনরাবৃত্ত ফাংশনে পরিণত করে আরও ছয়টি সংরক্ষণ করুন:f=lambda l,c=1:any(l)and f([j-i for i,j in zip(l,l[1:])],c-1)or-c
— জোনাথন অ্যালান
এটি কি কেবল আমার বা একটি পুনরাবৃত্ত ল্যাম্বডায় স্যুইচ করা যথেষ্ট বাইট সংরক্ষণ করছে না? : পি ধন্যবাদ!
— সম্পূর্ণরূপে
আমি মনে করি পরীক্ষার কেসগুলি max(...,0)পাস করার [1, 1, 1, 1, ...]জন্য এটির দরকার।
— যোনাতন এন
2

ডায়ালগ এপিএল, 19 বাইট

≢-1+(≢2-/⍣{1=≢∪⍵}⊢)

ব্যাখ্যা:

≢                      length of input
 -1+(             )    minus 1+
     ≢                 length of
      2-/              differences between elements
         ⍣             while
          {1=≢∪⍵}      there is more than 1 unique element
                 ⊢     starting with the input
— সামুদ্রিক
সূত্র
1
এটা কি কাজ করে? ≢-1+∘≢2-/⍣{1=≢∪⍵}⊢
— জাকারি
2

কে , 21 বাইট

#1_(~&/1_=':)(1_-':)\

এটি কে-তে কাজ করে, তবে ওকে নয়, কারণ ওকে যখন লুপটি শর্তটি পরীক্ষা করার আগে চালিত হয় (প্রথমে শর্তটি পরীক্ষা করার বিপরীতে, এবং তারপরে কোড চালাচ্ছে)। অতএব, ওকে, 1 1 1 1 1উদাহরণটি সঠিকভাবে কাজ করবে না।

অনলাইনে ওকে চেষ্টা করে দেখুন!

কে দোভাষীটিতে 1 1 1 1 1 1 দিয়ে কে উদাহরণ চালাচ্ছেন।

ব্যাখ্যা:

   (        )       \ /while(
    ~&/               /      not(min(
       1_=':          /              check equality of all pairs))) {
             (1_-':)  /    generate difference list
                      /    append to output }
#1_                   /(length of output) - 1
— zgrep
সূত্র
~&/1_=':->1<#?
— এনজিএন
2

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

z=(=<<tail).zipWith
f=length.takeWhile(or.z(/=)).iterate(z(-))

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

খ্রিস্টান সিভার্সকে 5 বাইট সংরক্ষণ করা হয়েছে

গর্বিত-হাসেলেলারকে 1 বাইট সংরক্ষণ করা হয়েছে

iterate(z(-)) পার্থক্য তালিকা গণনা।

or.z(/=) এই তালিকায় যদি অ সমান উপাদান থাকে তবে পরীক্ষা করে দেখুন equal

length.takeWhile অ সমতুল্য উপাদানগুলির সাথে পার্থক্যগুলির তালিকা গণনা করে।

— jferard
সূত্র
আমি মনে করি আপনি এর সাথে সম-সম-উপাদানগুলির জন্য পরীক্ষা করতে পারবেনor.z(/=)
— খ্রিস্টান সিভর্স
@ ক্রিশ্চিয়ানসিভার্স ধন্যবাদ! এটি সুস্পষ্ট ছিল, তবে আমি এটি দেখতে পাইনি ...
— jferard
আপনি z=(=<<tail).zipWithএক বাইট আরও খাটো ব্যবহার করতে পারেন
— গর্বিত হাসেলেলার
সর্বদা পয়েন্ট ফ্রি সংজ্ঞা সহ @ প্রগাডাসকেলার এবং আরও মার্জিত। ধন্যবাদ!
— jferard
2

জাপট , 7 বাইট

জাস্টিন হিসাবে একই বাস্তবায়নের সাথে একই পদ্ধতির (তবে স্বতন্ত্রভাবে প্রাপ্ত))

£=äaÃèx

এটা পরীক্ষা করো

ব্যাখ্যা

অ্যারের অন্তর্নিহিত ইনপুট U।

£   Ã

প্রতিটি উপাদান উপর মানচিত্র।

äa

äউপাদানগুলির প্রতিটি ক্রমিক জোড় ( ) নিন এবং একে Uসম্পূর্ণ পার্থক্য ( a) দ্বারা হ্রাস করুন ।

=

সেই অ্যারেটিতে পুনরায় নিয়োগ করুন U।

èx

èসংযুক্তি ( ) সাব-অ্যারেগুলির সংখ্যা গণনা করুন যা সংযোজন দ্বারা কমে গেলে সত্যবাদী (যেমন, শূন্য নয়) ফেরত দেয়।

— রোমশ
সূত্র
1

টিআই-বেসিক, 19 বাইট

While max(abs(ΔList(Ans
ΔList(Ans
IS>(A,9
End
A

ডিফল্টরূপে, ভেরিয়েবলগুলি শূন্য থেকে শুরু হয়। এছাড়াও, কখনও ভাবিনি যে আমি IS>(দরকারী কোনও কিছুর জন্য ব্যবহার করব।

— Timtech
সূত্র
1

সি # (.নেট কোর) , 70 69 + 18 বাইট

-1 বাইট ধন্যবাদ কেভিন ক্রুইজসেনকে

g=a=>i=>a.Distinct().Count()>1?g(a.Zip(a.Skip(1),(y,z)=>y-z))(i+1):i;

সঠিকভাবে পরিচালনার জন্য কল করার সময় অবশ্যই 0 দিতে হবে। বাইট গণনায় অন্তর্ভুক্ত:

using System.Linq;

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

ব্যাখ্যা:

g = a => i =>                      // Function taking two arguments (collection of ints and an int)
    a.Distinct()                   // Filter to unique elements
    .Count() > 1 ?                 // If there's more than one element
        g(                         //     Then recursively call the function with
            a.Zip(                 //     Take the collection and perform an action on corresponding elements with another one
                a.Skip(1),         //         Take our collection starting at second element
                (y, z) => y - z    //         Perform the subtraction
            )
        )(i + 1)                   //     With added counter
        : i;                       // Otherwise return counter

Iterative সংস্করণ 84 + 18 বাইট:

a=>{int i=0;for(;a.Distinct().Count()>1;i++)a=a.Zip(a.Skip(1),(y,z)=>y-z);return i;}

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

— গ্রেজগোর্জ পুয়াওস্কি
সূত্র
1
আপনি এলোমেলো স্থান সরাতে পারেন (y,z)=>y-z। তবে চমৎকার উত্তর, আমার কাছ থেকে +1।
— কেভিন ক্রুইজসেন
@ কেভিন ক্রুজসেন আপনাকে ধন্যবাদ! উফফফফ।
— গ্রজেগোর্জ পুয়াওস্কি
1

ক্লোজার, 62 বাইট

#(loop[c % i 0](if(apply = c)i(recur(map -(rest c)c)(inc i))))

সুন্দরভাবে =যে কোনও সংখ্যক আর্গুমেন্ট নিতে পারে এবং একটি একক যুক্তি "নিজেই" এর মতো। (apply = [1 2 3])হিসাবে কার্যকর করা হয় (= 1 2 3)।

— NikoNyrh
সূত্র
ভাল লাগল, আমি ঠিক যা করার চেষ্টা করছিলাম কিন্তু আমি একটি কমপ্যাক্ট পেয়ারওয়াইজ ডিফার্সের জন্য লড়াই করে যাচ্ছিলাম। এটি উজ্জ্বল, আমাকে ভবিষ্যতের জন্য এটি মনে রাখতে হবে।
— ম্যাটপুটনাম
1

পাইথ , 15 বাইট

W.E.+Q=.+Q=hZ)Z

সমস্ত পরীক্ষার কেস যাচাই করুন।

কিভাবে?

ব্যাখ্যা # 1

W.E.+Q=hZ=.+Q)Z   ~ Full program.

W                 ~ While...
 .E.+Q            ~ ... The deltas of Q contain a truthy element.
      =hZ         ~ Increment a variable Z, which has the initial value of 0.
         =        ~ Transform the variable to the result of a function applied to itself...
          .+Q     ~ ... Operate on the current list and deltas.
             )Z   ~ Close the loop and output Z.
— মিঃ এক্সকোডার
সূত্র
-1 বাইটWtl{Q=hZ=.+Q)Z
— ডেভ
আরও ভাল করে @Dave: WP{Q=hZ=.+Q)Z। ধন্যবাদ!
— মিঃ এক্সকোডার
0

পাইথ, 10 বাইট

tf!t{.+FQt

যদি আমরা 1 থেকে সূচক করতে পারি তবে আমরা অগ্রণীটি সরিয়ে একটি বাইট সংরক্ষণ করতে পারি t।

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

ব্যাখ্যা

tf!t{.+FQt
 f        T  Find the first (1-indexed) value T...
     .+FQt   ... such that taking the difference T - 1 times...
  !t{        ... gives a set with more than one value in it.
t            0-index.
0

কোটলিন , 83 বাইট

{var z=it
var c=0
while(z.any{it!=z[0]}){c++
z=(0..z.size-2).map{z[it+1]-z[it]}}
c}

শোভিত

{
    // Make input mutable
    var z=it
    // Count for returning
    var c=0
    // While the array is not identical
    while (z.any { it != z[0] }) {
        // Increment count
        c++
        // Update list to differences
        z = (0..z.size-2).map { z[it+1] - z[it] }
    }
    // Return count
    c
}

পরীক্ষা

var n:(List<Int>)->Int =
{var z=it
var c=0
while(z.any{it!=z[0]}){c++
z=(0..z.size-2).map{z[it+1]-z[it]}}
c}

data class TestData(var input: List<Int>, var output: Int)

fun main(args: Array<String>) {
    val items = listOf(
        TestData(listOf(1,2,3,4,5,6,7,8,9,10), 1),
        TestData(listOf(1,4,9,16,25,36), 2),
        TestData(listOf(1,2,1), 2),
        TestData(listOf(1,1,1,1,1,1,1,1,1), 0),
        TestData(listOf(1, 3, 9, 26, 66, 150, 313, 610), 6)
    )

    val fails = items.map { it to n(it.input) }.filter { it.first.output != it.second }

    if (fails.isEmpty()) {
        println("Test passed")
    } else {
        fails.forEach {println("FAILED: $it")}
    }
}

TryItOnline

— jrtapsell
সূত্র
যদি কেউ আমার ভাষার ইঙ্গিতগুলি ঠিক করতে সম্পাদনা করতে পারে তবে আমি তাদের এগুলি কাজ করে দেখছি না
— jrtapsell
এটি হাইলাইটার ইঙ্গিতগুলিতে lang-kotlinসহজভাবে নয় kotlin।
— Ruslan
0

সুইফট 4 , 90 বাইট

func f(_ a:[Int])->Int{return a.contains{$0 != a[0]} ?f(zip(a, a.dropFirst()).map(-))+1:0}

বিকল্প, বন্ধ-ভিত্তিক বাস্তবায়ন:

var f: ((_ input: [Int]) -> Int)!
f = {a in a.contains{$0 != a[0]} ?f(zip(a, a.dropFirst()).map(-))+1:0}

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

let testcases: [(input: [Int], expected: Int)] = [
    (input: [1,2,3,4,5,6,7,8,9,10],           expected: 1),
    (input: [1,4,9,16,25,36],                 expected: 2),
    (input: [1,2,1],                          expected: 2),
    (input: [1,1,1,1,1,1,1,1,1],              expected: 0),
    (input: [1, 3, 9, 26, 66, 150, 313, 610], expected: 6),
]

for (caseNumber, testcase) in testcases.enumerated() {
    let actual = f(testcase.input)
    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \(testcase.input) failed. Got \(actual), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}
— আলেকজান্ডার - মনিকা পুনরায় স্থাপন করুন
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.