Desafío

La tarea es simple. Dada una matriz y un primer y último valor: Devuelve el primero del último después del primero, y el último del primero antes del último.

O simplemente: dada una matriz, var1, var2.

Matriz de ejemplo:

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

Regreso:

• El índice de la primera var2 en el lado derecho de la primera var1 que aparece en la matriz.

[Var2,, primero var1 ,, primero var2 ,, segunda var2, var1, var2 tercero,]

• El índice de la primera var1 en el lado izquierdo de la última var2 que aparece en la matriz.

[var2`` segundo var1`` var2`` var2, primer var1 , último var2 ,]

Entrada

Dos enteros positivos distintos

Matriz de enteros positivos

Salida

Índice de respuestas, en orden

Reglas

La matriz contendrá al menos una de cada variable (tamaño mínimo de 2)

Suponga que las entradas funcionan

Ejemplo: 0, 1 [1, 0]o similar fallaría

IO es flexible

Ejemplos

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

Jalea , 17 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

APL (Dyalog Classic) , 29 27 bytes

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

Pruébalo en línea!

solicita la matriz y luego var1, var2

JavaScript (ES6), 63 bytes

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

Pruébalo en línea!

Comentado

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

Versiones alternativas

Usando JS incorporado, una respuesta más directa es de 79 bytes:

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

que se puede comprimir ligeramente a 75 bytes:

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

Pruébalo en línea!

Editar : @Neil logró reducirlo a un muy agradable 67 bytes :

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

Pruébalo en línea!

Python 3 , 97 93 bytes

-4 bytes gracias a 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))

Pruébalo en línea!

Japt , 27 25 24 bytes

Inspirado en la respuesta de @Arnauld

Gracias @Shaggy -2 bytes y @ETHproductions -1 byte

Acabo de comenzar con Japt, así que debe ser una mejor manera.

[WsX=WbU)bV +XWsTWaV)aU]

Pruébalo en línea!

APL (Dyalog Unicode) , 42 bytes ^SBCS

Función de infijo tácito anónimo. Toma var1, var2 como argumento izquierdo y la matriz como argumento derecho.

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

Pruébalo en línea!

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

Pruébalo en línea!

(1 indexado)

MATL , 27 bytes

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

Pruébalo en línea!

Alternativamente para el mismo bytecount:

27 bytes

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

Pruébalo en línea!

El segundo es más fácil de explicar:

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 segunda parte del código hace lo mismo, excepto por estos cambios:

• use 2Gpara la segunda entrada (var1) y la 3Gprimera tercera entrada (var2) en lugar de la entrada implícita o i, ya que se han consumido
• use PY>P(voltear matriz de izquierda a derecha, obtener el máximo acumulado, voltear hacia atrás) en lugar de Y>, para obtener 1s antes de la última aparición en lugar de después de la primera aparición
• use f0)para obtener el último lugar donde ambas condiciones son verdaderas, en lugar del primer lugar (funciona porque MATL usa indexación modular, por lo que se toma 0 para referirse al último índice de la matriz)

MATLAB (80 bytes)

De entrada es x, yy a. Como MATLAB está indexado en 1, debe agregar 1 a los casos de prueba.

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

Caso de prueba:

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

Una lambda que toma ay java.util.List<Integer>dos ints (var1, var2) y devuelve un par separado por comas.

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

Pruébalo en línea

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

Pruébalo en línea!

Julia , 71 64 bytes

gracias a sundar y su en find(A.==x)[]lugar de findfirst(A,x)).

.

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