Herausforderung

Die Aufgabe ist einfach. Gegeben ein Array und ein erster und letzter Wert: Gibt den ersten vom letzten nach dem ersten und den letzten vom ersten vor dem letzten zurück.

Oder einfach: Gegeben ein Array, var1, var2.

Beispielarray:

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

Rückkehr:

• Der Index der ersten var2 auf der rechten Seite der ersten var1, die im Array angezeigt wird.

[Var2, erste var1 , erste var2 , zweite var2, var1, dritten var2,]

• Der Index der ersten var1 auf der linken Seite der letzten var2, die im Array angezeigt wird.

[var2 ,, zweite var1 ,, var2 ,, var2, erste var1 , letzte var2 ,]

Eingang

Zwei verschiedene positive ganze Zahlen

Array positiver Ganzzahlen

Ausgabe

Index der Antworten in der richtigen Reihenfolge

Regeln

Das Array enthält mindestens eine von jeder Variablen (Mindestgröße 2).

Angenommen, die Eingaben funktionieren

Beispiel: 0, 1 [1, 0]oder ähnliches würde fehlschlagen

IO ist flexibel

Beispiele

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

Gelee , 17 Bytes

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

Probieren Sie es online aus!

Python 2 , 72 Bytes

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

Probieren Sie es online aus!

APL (Dyalog Classic) , 29 27 Bytes

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

Probieren Sie es online aus!

fordert zur Eingabe des Arrays und dann zu var1, var2 auf

JavaScript (ES6), 63 Byte

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

Probieren Sie es online aus!

Kommentiert

(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]

Alternative Versionen

Bei Verwendung von JS-integrierten Funktionen beträgt eine einfachere Antwort 79 Byte:

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

die leicht auf 75 Bytes komprimiert werden kann:

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

Probieren Sie es online aus!

Edit : @Neil hat es geschafft, es auf ein sehr schönes 67-Byte zu reduzieren :

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

Probieren Sie es online aus!

Python 3 , 97 93 Bytes

-4 Bytes dank 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))

Probieren Sie es online aus!

Japt , 27 25 24 Bytes

Inspiriert von der Antwort von @Arnauld

Danke @Shaggy -2 Bytes und @ETHproductions -1 Bytes

Ich habe gerade mit japt angefangen, also muss es ein besserer Weg sein. \

[WsX=WbU)bV +XWsTWaV)aU]

Probieren Sie es online aus!

APL (Dyalog Unicode) , 42 Byte ^SBCS

Anonyme stillschweigende Infix-Funktion. Nimmt var1, var2 als linkes Argument und das Array als rechtes Argument.

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

Probieren Sie es online aus!

R 81 Bytes

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

Probieren Sie es online aus!

(1-indiziert)

MATL , 27 Bytes

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

Probieren Sie es online aus!

Alternativ für die gleiche Anzahl von Bytes:

27 Bytes

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

Probieren Sie es online aus!

Der zweite ist leichter zu erklären:

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)

Der zweite Teil des Codes macht dasselbe, mit Ausnahme dieser Änderungen:

• Verwendung 2Gfür die zweite Eingabe (var1) und die 3Gerste dritte Eingabe (var2) anstelle der impliziten Eingabe oder i, da diese verbraucht wurden
• Verwenden Sie PY>P(Flip-Array von links nach rechts, kumulatives Maximum abrufen, zurückblättern) anstelle von Y>, um 1s vor dem letzten Vorkommen statt nach dem ersten Vorkommen zu erhalten
• Verwenden Sie f0)diese Option , um die letzte Stelle abzurufen, an der beide Bedingungen erfüllt sind, anstatt die erste Stelle (funktioniert, weil MATL die modulare Indizierung verwendet, sodass 0 als Verweis auf den letzten Index des Arrays verwendet wird).

MATLAB (80 Bytes)

Eingegeben wird x, yund a. Da MATLAB 1-indiziert ist, sollten Sie Testfällen 1 hinzufügen.

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

Testfall:

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

Java 8, 114 Bytes

Ein Lambda, das a java.util.List<Integer>und zwei ints (var1, var2) nimmt und ein durch Kommas getrenntes Paar zurückgibt.

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

Probieren Sie es online aus

Kotlin , 132 Bytes

{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)}()}

Probieren Sie es online aus!

Julia , 71 64 Bytes

danke an sundar und sein find(A.==x)[]statt findfirst(A,x)).

.

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