চ্যালেঞ্জ

কাজটি সহজ। একটি অ্যারে এবং প্রথম এবং শেষ মান দেওয়া হয়েছে: প্রথমের পরে সর্বশেষের প্রথমটি এবং শেষের আগে প্রথমটির সর্বশেষ ফিরিয়ে দিন।

বা সহজভাবে: একটি অ্যারে, var1, var2 দেওয়া।

উদাহরণ অ্যারে:

[var2,, var1,, var2,, var2, var1, var2,]

ফেরত দিন:

অ্যারে প্রদর্শিত প্রথম var1 এর ডান দিকে প্রথম var2 এর সূচক।

[বর্ণ 2, প্রথম বর্ণ 1 , প্রথম বর্ণ 2 , দ্বিতীয় বর্ণ 2, বর্ণ 1, তৃতীয় বর্ণ 2,]

অ্যারেতে উপস্থিত সর্বশেষ ভার 2 এর বাম দিকে প্রথম বর্ণ 1 এর সূচক।

[বর্ণ 2, দ্বিতীয় বর্ণ 1,, বর্ণ 2,, বর্ণ 2, প্রথম বর্ণ 1 , শেষ বর্ণ 2 ,]

ইনপুট

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

ধনাত্মক পূর্ণসংখ্যার অ্যারে

আউটপুট

উত্তরগুলির সূচী, ক্রমানুসারে

বিধি

অ্যারেতে প্রতিটি ভেরিয়েবলের মধ্যে কমপক্ষে একটি থাকতে হবে (সর্বনিম্ন 2 আকার)

ইনপুট কাজ অনুমান

উদাহরণ: 0, 1 [1, 0]বা অনুরূপ ব্যর্থ হবে

আইও নমনীয়

উদাহরণ

Input
First = 2; Last = 4; [0, 2, 4, 2, 3, 1, 4, 0, 1, 2, 4, 9]

Output
2, 9

Input
First = 4; Last = 2; [0, 2, 4, 2, 3, 1, 4, 0, 1, 2, 4, 9]

Output
3, 6

Input
First = 0; Last = 1; [0, 1]

Output
1, 0

code-golf array-manipulation

— WretchedLout
সূত্র

3

করতে var1সমান হতে var2?

— এনজিএন

1

@ জিএন না, অগত্যা নয়। যদি তারা হয় তবে এটি বেশিরভাগ তুচ্ছ ফলাফলের দিকে নিয়ে যেত, সুতরাং এই কেসটি পরিচালনা করার প্রয়োজন নেই not

— WretchedLout

3

পিপিসিজিতে আপনাকে স্বাগতম!

— জোনাথন অ্যালান

2

আমরা কি ফলাফলকে বিপরীত ক্রমে ফিরিয়ে দিতে পারি? উদাহরণস্বরূপ, পরীক্ষার বিষয় স্থাপিত হবে 9, 2, 6, 3এবং 0, 1(1-ইন্ডেক্স আউটপুট বা প্লাস এক হলে) যথাক্রমে।

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

1

দ্বিতীয় স্থানে @ যাকোব, বর্তমান শব্দটির উদাহরণগুলির সাথে মেলে না।

— নিট

3

জেলি , 17 বাইট

ẹⱮṚ>Ƈ<Ƈƭ"1,0ị"$⁺Ʋ

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

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

4

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

def f(x,y,a):i=a.index;j=a[::-1].index;print i(y,i(x)),len(a)+~j(x,j(y))

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

— লিন
সূত্র

4

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

⊃{(⊃⍵~⍳⊃⍺),⊃⌽⍺∩⍳⊃⌽⍵}/⍸¨⎕=⊂⎕

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

অ্যারে এবং তারপরে var1, var2 এর জন্য অনুরোধ জানানো হয়

— ngn
সূত্র

4

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

(x,y,a)=>a.map(P=(v,i)=>v-y?v-x?0:a=i:1/(p=a)?P=+P||i:0)&&[P,p]

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

(x, y, a) =>          // given the two integers x, y and the array a[]
  a.map(P =           // initialize P to a non-numeric value
            (v, i) => // for each value v at position i in a[]:
    v - y ?           //   if v is not equal to y:
      v - x ?         //     if v is not equal to x:
        0             //       do nothing
      :               //     else (v = x):
        a = i         //       save the current position in a
    :                 //   else (v = y):
      1 / (p = a) ?   //     update p to a (last position of x); if p is numeric (>= 0):
        P = +P || i   //       unless P is also already numeric, update it to i
                      //       (if P is numeric, it's necessarily greater than 0 because
                      //       we've also seen x before; that's why +P works)
      :               //     else:
        0             //       do nothing
  )                   // end of map()
  && [P, p]           // return [P, p]

বিকল্প সংস্করণ

জেএস বিল্ট-ইনগুলি ব্যবহার করে, আরও সহজ উত্তর 79৯ বাইট:

(x,y,a)=>[a.indexOf(y,a.indexOf(x)),a.slice(0,a.lastIndexOf(y)).lastIndexOf(x)]

যা 75 বাইটে কিছুটা সংকুচিত হতে পারে:

(x,y,a)=>[a.indexOf(y,a.indexOf(x)),a.slice(0,a[L='lastIndexOf'](y))[L](x)]

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

সম্পাদনা করুন : @ নীল এটিকে একটি খুব সুন্দর 67-বাইটে হ্রাস করতে পরিচালিত :

(x,y,a,f=s=>a[z=y,y=x,x=z,s+=`ndexOf`](x,a[s](y)))=>[f`i`,f`lastI`]

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

— Arnauld
সূত্র

lastIndexOfদুটি প্যারামিটার লাগে, যাতে এটি 70 বাইটের সরল উত্তর হ্রাস করে এবং আমি নিম্নলিখিত 67-বাইট সংস্করণটি নিয়ে আসতে সক্ষম হয়েছি:(x,y,a,f=s=>a[z=y,y=x,x=z,s+=`ndexOf`](x,a[s](y)))=>[f`i`,f`lastI`]

— নীল

3

পাইথন 3 , 97 93 বাইট

-4 বাইট ovs ধন্যবাদ

def h(f,l,a,I=list.index):j=I(a,f);i=len(a)+~I(a[::-1],l);print(I(a[j:],l)+j,i-I(a[i::-1],f))

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

— frosqh
সূত্র

a-1-b == a + (-b-1) == a + ~b-1 বাইটের জন্য ব্যবহার করা যেতে পারে, indexএকটি ফাংশনটি একটি নাম নির্ধারণ করে এটি 93 বাইট পেয়ে যায়

— ovs

2

জাপট , 27 25 24 বাইট

@ আরনাউল্ড উত্তরে অনুপ্রাণিত

ধন্যবাদ @ শেগি -২ বাইট এবং @ETH প্রোডাকশনস -১ বাইট

আমি সবেমাত্র জ্যাপ দিয়ে শুরু করেছি যাতে এটি আরও ভালতর উপায় হতে পারে \

[WsX=WbU)bV +XWsTWaV)aU]

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

— লুইস ফিলিপে দে জেসুস মুনোজ
সূত্র

1

জাপটে আপনাকে স্বাগতম :) আপনি সেই দ্বিগুণ স্থানগুলি )2 বাইট বাঁচানোর জন্য প্রারম্ভিকদের সাথে প্রতিস্থাপন করতে পারেন ।

— শেগি

@ শেগি ট্যাঙ্কস! আমি এগুলি সম্পর্কে জানতাম না

— লুইস ফিলিপ দে জেসুস মুনোজ

আপনার মত, আমিও নিশ্চিত যে একটি ছোট পদ্ধতি আছে। এই মুহুর্তে এটি বের করার চেষ্টা করার জন্য ব্রেইনস্পেসের দরকার নেই, যদিও!

— শেগি

স্বাগত! আপনি ব্যবহার করে একটি বাইট সংরক্ষণ করতে পারেন X=WbU)...+X: এটি অনলাইন চেষ্টা করে দেখুন! আমি যদিও আরও একটি ছোট পদ্ধতি আবিষ্কার করার জন্য লড়াই করছি ...

— ETH প্রোডাকশনগুলি

1

এপিএল (ডায়ালগ ইউনিকোড) , 42 বাইট ^{এসবিসিএস}

বেনামে টাসিট ইনফিক্স ফাংশন। বাম আর্গুমেন্ট হিসাবে var1, var2 এবং ডান যুক্তি হিসাবে অ্যারে নেয়।

{⍸<\(⍵=⊃⌽⍺)∧∨\⍵=⊃⍺},{⍸⌽<\(⍵=⊃⍺)∧∨\⍵=⊃⌽⍺}∘⌽

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

— আদম
সূত্র

1

আর , 81 বাইট

function(a,b,v,x=which(v==b),y=which(v==a))c(x[x>y[1]][1],tail(y[y<tail(x,1)],1))

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

(1-ইন্ডেক্স)

— digEmAll
সূত্র

1

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

y=Y>/ti=PY>P/t3G=f1)w2G=f0)

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

পর্যায়ক্রমে একই বাইটকাউন্টের জন্য:

27 বাইট

y=Y>yi=*f1)y3G=PY>Pb2G=*f0)

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

দ্বিতীয়টি ব্যাখ্যা করা সহজ:

y   % implicitly get the first two inputs (the array and var1),
    %  and duplicate the first input
    %  stack: [[0 2 4 2 3 1 4 0 1 2 4 9] 2 [0 2 4 2 3 1 4 0 1 2 4 9]]
=   % compare and return logical (boolean) array
    %  stack: [[0 2 4 2 3 1 4 0 1 2 4 9] [0 1 0 1 0 0 0 0 0 1 0 0]]
Y>  % cumulative maximum - make all values after the first 1 also 1s
    %  stack: [[0 2 4 2 3 1 4 0 1 2 4 9] [0 1 1 1 1 1 1 1 1 1 1 1]]
    %  now we have 1s in positions at and after the first time var1 appears
y   % duplicate 2nd element in stack
    %  stack: [[0 2 4 2 3 1 4 0 1 2 4 9] [0 1 1 1 1 1 1 1 1 1 1 1] [0 2 4 2 3 1 4 0 1 2 4 9]]
i=  % compare with the next input (var2), returning a boolean array
    % stack: [[0 2 4 2 3 1 4 0 1 2 4 9] [0 1 1 1 1 1 1 1 1 1 1 1] [0 0 1 0 0 0 1 0 0 0 1 0]]
*   % multiply the two boolean arrays - so we'll have 1s only where var2 was present after the first occurrence of var1
    % stack: [[0 2 4 2 3 1 4 0 1 2 4 9] [0 0 1 0 0 0 1 0 0 0 1 0]]
f1) % find the index of the first 1 in that (this is our first result value)

কোডের দ্বিতীয় অংশটি এই পরিবর্তনগুলি বাদ দিয়ে একই কাজ করে:

ব্যবহারের 2Gদ্বিতীয় ইনপুট (var1 হল) এবং জন্য 3Gপ্রথম 3 য় ইনপুট (var2) পরিবর্তে অন্তর্নিহিত ইনপুট অথবা i, যেহেতু ঐ ধ্বংস করা হয়েছে
প্রথম ঘটনার পরিবর্তে সর্বশেষ ঘটনার আগে 1s পেতে, PY>Pপরিবর্তে (বাম থেকে ডানদিকে ফ্লিপ অ্যারে ব্যবহার করুন , সঞ্চিত সর্বাধিক পান, পিছনে ফ্লিপ করুন) ব্যবহার করুনY>
ব্যবহার f0)পেতে শেষ (তাই 0 অ্যারের গত সূচক উল্লেখ করতে নেওয়া হয়, কারণ MATL মডুলার ইন্ডেক্স ব্যবহার কাজ) স্থান যেখানে উভয় অবস্থার সত্য, প্রথম স্থানে পরিবর্তে

— সূন্দর - মনিকা পুনরায় স্থাপন করুন
সূত্র

1

ম্যাটল্যাব (৮০ বাইট)

ইনপুট হয় x, yএবং a। যেহেতু ম্যাটল্যাব 1-সূচকযুক্ত তাই আপনার পরীক্ষার ক্ষেত্রে 1 টি যুক্ত করা উচিত।

xi=find(a==x);
yi=find(a==y);
yi(find(yi>xi(1),1))
xi(find(xi<yi(end),1,'last'))

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

x=4
y=2
a =  [0, 2, 4, 2, 3, 1, 4, 0, 1, 2, 4, 9]

% 
xi=find(a==x);
yi=find(a==y);
yi(find(yi>xi(1),1))
xi(find(xi<yi(end),1,'last'))

ans =

     4


ans =

     7

0

জাভা 8, 114 বাইট

একটি ল্যাম্বদা একটি java.util.List<Integer>এবং দুটি intগুলি নিয়ে চলেছে (var1, var2) এবং কমা দ্বারা পৃথককৃত জুটি ফিরে আসবে।

(a,f,l)->a.indexOf(f)+a.subList(a.indexOf(f),a.size()).indexOf(l)+","+a.subList(0,a.lastIndexOf(l)).lastIndexOf(f)

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

— জ্যাকব
সূত্র

0

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

{f:Int,l:Int,a:Array<Int>->{var p=a.indexOfFirst{it==f}
while(a[p]!=l)p++
var i=a.indexOfLast{it==l}
while(a[i]!=f)i--
Pair(p,i)}()}

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

— JohnWells
সূত্র

0

জুলিয়া , 71 64 বাইট

ধন্যবাদ সূন্দর এবং তার find(A.==x)[]পরিবর্তে তার findfirst(A,x))।

।

(A,x,y)->findnext(A,y,find(A.==x)[]),findprev(A,x,findlast(A,y))

— Tanj
সূত্র

আপনার ভাষা যদি 1-ভিত্তিক হয় তবে আপনি 1-ভিত্তিক সূচকটি ফিরে আসতে পারেন (এটি এখানে সর্বসম্মত sensকমত্য), সুতরাং -1 এর দরকার নেই। এছাড়াও, আপনি find(A.==x)[]পরিবর্তে ব্যবহার করে অন্য একটি বাইট সংরক্ষণ করতে পারেন findfirst(A,x)।

— -

প্রথম সর্বশেষ সর্বশেষ প্রথম

চ্যালেঞ্জ

ইনপুট

আউটপুট

বিধি

উদাহরণ

জেলি , 17 বাইট

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

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

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

মন্তব্য

বিকল্প সংস্করণ

পাইথন 3 , 97 93 বাইট

জাপট , 27 25 24 বাইট

এপিএল (ডায়ালগ ইউনিকোড) , 42 বাইট ^{এসবিসিএস}

আর , 81 বাইট

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

27 বাইট

ম্যাটল্যাব (৮০ বাইট)

জাভা 8, 114 বাইট

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

জুলিয়া , 71 64 বাইট

প্রথম সর্বশেষ সর্বশেষ প্রথম

চ্যালেঞ্জ

ইনপুট

আউটপুট

বিধি

উদাহরণ

জেলি , 17 বাইট

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

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

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

মন্তব্য

বিকল্প সংস্করণ

পাইথন 3 , 97 93 বাইট

জাপট , 27 25 24 বাইট

এপিএল (ডায়ালগ ইউনিকোড) , 42 বাইট এসবিসিএস

আর , 81 বাইট

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

27 বাইট

ম্যাটল্যাব (৮০ বাইট)

জাভা 8, 114 বাইট

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

জুলিয়া , 71 64 বাইট

এপিএল (ডায়ালগ ইউনিকোড) , 42 বাইট ^{এসবিসিএস}