Sfida

Il compito è semplice. Dato un array e un primo e ultimo valore: restituisce il primo dell'ultimo dopo il primo e l'ultimo del primo prima dell'ultimo.

O semplicemente: dato un array, var1, var2.

Matrice di esempio:

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

Ritorno:

• L'indice del primo var2 sul lato destro del primo var1 che appare nell'array.

[Var2,, prima var1 ,, prima var2 ,, secondo var2, var1, var2 terzo,]

• L'indice del primo var1 sul lato sinistro dell'ultimo var2 che appare nell'array.

[var2,, second var1,, var2,, var2, first var1 , last var2 ,]

Ingresso

Due interi positivi distinti

Matrice di numeri interi positivi

Produzione

Indice delle risposte, in ordine

Regole

L'array conterrà almeno una di ciascuna variabile (dimensione minima di 2)

Supponiamo che gli input funzionino

Esempio: 0, 1 [1, 0]o simile fallirebbe

IO è flessibile

Esempi

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

Gelatina , 17 byte

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

Provalo online!

Python 2 , 72 byte

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

Provalo online!

APL (Dyalog Classic) , 29 27 byte

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

Provalo online!

richiede l'array e quindi var1, var2

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]

Provalo online!

Commentate

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

Versioni alternative

Utilizzando gli incorporati JS, una risposta più semplice è di 79 byte:

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

che può essere leggermente compresso a 75 byte:

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

Provalo online!

Modifica : @Neil è riuscito a ridurlo a un bellissimo 67 byte :

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

Provalo online!

Python 3 , 97 93 byte

-4 byte grazie agli 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))

Provalo online!

Japt , 27 25 24 byte

Ispirato alla risposta di @Arnauld

Grazie @Shaggy -2 byte e @ETHproductions -1 byte

Ho appena iniziato con japt, quindi deve essere un modo migliore. \

[WsX=WbU)bV +XWsTWaV)aU]

Provalo online!

APL (Dyalog Unicode) , 42 byte ^SBCS

Funzione anonimo di tacita infissione. Prende var1, var2 come argomento sinistro e l'array come argomento destro.

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

Provalo online!

R , 81 byte

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

Provalo online!

(1-indicizzati)

MATL , 27 byte

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

Provalo online!

In alternativa per lo stesso conteggio parziale:

27 byte

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

Provalo online!

Il secondo è più facile da spiegare:

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)

La seconda parte del codice fa la stessa cosa, ad eccezione di queste modifiche:

• utilizzare 2Gper il secondo input (var1) e il 3Gprimo 3rd input (var2) invece di input implicito o i, poiché quelli sono stati consumati
• usare PY>P(capovolgi l'array da sinistra a destra, ottieni il massimo cumulativo, capovolgi) invece di Y>, per ottenere 1 s prima dell'ultima occorrenza invece che dopo la prima occorrenza
• usa f0)per ottenere l' ultimo posto in cui entrambe le condizioni sono vere, invece del primo posto (funziona perché MATL usa l'indicizzazione modulare, quindi 0 viene preso per fare riferimento all'ultimo indice dell'array)

MATLAB (80 byte)

Ingresso è x, ye a. Poiché MATLAB è 1 indicizzato, è necessario aggiungere 1 ai casi di test.

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

Caso di prova:

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 byte

Una lambda che prende ae java.util.List<Integer>due ints (var1, var2) e restituisce una coppia separata da virgola.

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

Provalo online

Kotlin , 132 byte

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

Provalo online!

Julia , 71 64 byte

grazie a Sundar e al suo find(A.==x)[]invece di findfirst(A,x)).

.

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