चुनौती

कार्य सरल है। किसी सरणी और पहले और अंतिम मान को देखते हुए: पहले के बाद अंतिम और पहले के अंतिम को पहले लौटें।

या बस: एक सरणी, var1, var2 को देखते हुए।

उदाहरण सरणी:

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

वापसी:

सरणी में दिखाई देने वाले पहले var1 के दाईं ओर पहले var2 का सूचकांक।

[var2,, पहला var1 ,, पहला var2 ,, दूसरा var2, var1, तीसरा var2,]

सरणी में दिखाई देने वाले अंतिम var2 के बाईं ओर पहले var1 का सूचकांक।

[var2, दूसरा var1,, var2,, var2, पहला var1 , अंतिम var2 ]

इनपुट

दो अलग-अलग सकारात्मक पूर्णांक

सकारात्मक पूर्णांकों की सरणी

उत्पादन

क्रम में उत्तर का सूचकांक

नियम

सरणी में प्रत्येक चर का कम से कम एक होगा (न्यूनतम आकार 2)

इनपुट कार्य मान लें

उदाहरण: 0, 1 [1, 0]या इसी तरह विफल होगा

IO लचीला है

उदाहरण

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?

— 8

1

@ नहीं, जरूरी नहीं। यदि वे होते तो ज्यादातर तुच्छ परिणाम होते, इसलिए उस मामले को संभालना आवश्यक नहीं होता।

— WretchedLout

3

PPCG में आपका स्वागत है!

— जोनाथन एलन

2

क्या हम उल्टे क्रम में आउटपुट वापस कर सकते हैं? उदाहरण के लिए, परीक्षण के मामले में परिणाम होगा 9, 2, 6, 3और 0, 1(1 अनुक्रमित उत्पादन होता है या प्लस वन यदि) क्रमशः।

— आउटगॉल्फ जूल

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

APL (Dyalog Classic) , 29 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सरणी के लिए संकेत देता है और फिर var1, var2 के लिए

— NGN
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 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)]

इसे ऑनलाइन आज़माएं!

संपादित करें : @Neil इसे बहुत अच्छी 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 बाइट्स ओव्स के लिए धन्यवाद

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 बाइट्स

@Arnauld उत्तर में प्रेरित

धन्यवाद @ शगुन -2 बाइट्स और @ETHproductions -1 बाइट

मैंने सिर्फ जाप के साथ शुरुआत की है इसलिए यह एक बेहतर तरीका होना चाहिए। "

[WsX=WbU)bV +XWsTWaV)aU]

इसे ऑनलाइन आज़माएं!

— लुइस फेलिप डी जीसस मुनोज
स्रोत

1

Japt में आपका स्वागत है :) आप )2 बाइट्स को बचाने के लिए शुरुआत के साथ उन डबल स्थानों को बदल सकते हैं ।

— झबरा

@ शैगी टैंक! मुझे यह पता नहीं था कि

— लुइस फेलिप डी जीसस मुनोज

आपकी तरह, मुझे यकीन है कि एक छोटी विधि है। इस समय यह पता लगाने की कोशिश करने के लिए दिमाग नहीं है, हालांकि!

— शैगी

स्वागत हे! आप एक बाइट का उपयोग करके बचा सकते हैं X=WbU)...+X: इसे ऑनलाइन आज़माएं! मैं भी एक छोटी विधि खोजने के लिए संघर्ष कर रहा हूँ ...

— ETHproductions

1

एपीएल (Dyalog यूनिकोड) , 42 बाइट्स ^SBCS

बेनामी tacit infix फ़ंक्शन। 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

MATL , 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, क्योंकि वे भस्म कर दिया है
उपयोग PY>P (फ्लिप सरणी बाएं से दाएं, संचयी अधिकतम प्राप्त करें, पीछे पलटें) Y>, पहली घटना के बाद अंतिम घटना से पहले 1s प्राप्त करने के लिए
अंतिम स्थान f0)पाने के लिए उपयोग करें जहां दोनों स्थितियां पहले स्थान के बजाय सत्य हैं (काम करता है क्योंकि MATL मॉड्यूलर इंडेक्सिंग का उपयोग करता है, इसलिए 0 को सरणी के अंतिम सूचकांक को संदर्भित करने के लिए लिया जाता है)

— sundar - मोनिका को बहाल करना
स्रोत

1

MATLAB (80 बाइट्स)

इनपुट है x, yऔर a,। चूंकि MATLAB 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-आधारित इंडेक्स वापस कर सकते हैं, इसलिए -1 s की कोई आवश्यकता नहीं है। इसके अलावा, आप इसके find(A.==x)[]बजाय का उपयोग करके एक और बाइट बचा सकते हैं findfirst(A,x)।

— सूंदर -

पहला लास्ट लास्ट फर्स्ट

चुनौती

इनपुट

उत्पादन

नियम

उदाहरण

जेली , 17 बाइट्स

पायथन 2 , 72 बाइट्स

APL (Dyalog Classic) , 29 27 बाइट्स

जावास्क्रिप्ट (ईएस 6), 63 बाइट्स

टिप्पणी की गई

वैकल्पिक संस्करण

पायथन 3 , 97 93 बाइट्स

जाप , 27 25 24 बाइट्स

एपीएल (Dyalog यूनिकोड) , 42 बाइट्स SBCS

आर , 81 बाइट्स

MATL , 27 बाइट्स

27 बाइट्स

MATLAB (80 बाइट्स)

जावा 8, 114 बाइट्स

कोटलिन , 132 बाइट्स

जूलिया , 71 64 बाइट्स

एपीएल (Dyalog यूनिकोड) , 42 बाइट्स ^SBCS