Défi

La tâche est simple. Étant donné un tableau et une première et une dernière valeur: renvoyer le premier du dernier après le premier et le dernier du premier avant le dernier.

Ou tout simplement: étant donné un tableau, var1, var2.

Exemple de tableau:

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

Revenir:

• Index du premier var2 sur le côté droit du premier var1 qui apparaît dans le tableau.

[Var2,, premier var1 ,, premier var2 , deuxième var2, var1, var2 troisième,]

• L'index du premier var1 sur le côté gauche du dernier var2 qui apparaît dans le tableau.

[var2,, second var1,, var2,, var2, premier var1 , dernier var2 ,]

Contribution

Deux entiers positifs distincts

Tableau d'entiers positifs

Production

Index des réponses, dans l'ordre

Règles

Le tableau contiendra au moins une de chaque variable (taille minimale de 2)

Supposons que les entrées fonctionnent

Exemple: 0, 1 [1, 0]ou similaire échouerait

IO est flexible

Exemples

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

Gelée , 17 octets

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

Essayez-le en ligne!

Python 2 , 72 octets

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

Essayez-le en ligne!

APL (Dyalog Classic) , 29 27 octets

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

Essayez-le en ligne!

invite pour le tableau, puis pour var1, var2

JavaScript (ES6), 63 octets

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

Essayez-le en ligne!

Commenté

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

Versions alternatives

En utilisant les fonctionnalités intégrées de JS, une réponse plus simple est de 79 octets:

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

qui peut être légèrement compressé à 75 octets:

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

Essayez-le en ligne!

Edit : @Neil a réussi à le réduire à un très joli 67 octets :

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

Essayez-le en ligne!

Python 3 , 97 93 octets

-4 octets grâce aux 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))

Essayez-le en ligne!

Japt , 27 25 24 octets

Inspiré de la réponse @Arnauld

Merci @Shaggy -2 octets et @ETHproductions -1 octet

Je viens de commencer avec japt, ce doit donc être une meilleure solution. \

[WsX=WbU)bV +XWsTWaV)aU]

Essayez-le en ligne!

APL (Dyalog Unicode) , 42 octets ^SBCS

Fonction infixe tacite anonyme. Prend var1, var2 comme argument de gauche et le tableau comme argument de droite.

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

Essayez-le en ligne!

R , 81 octets

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

Essayez-le en ligne!

(1 index)

MATL , 27 octets

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

Essayez-le en ligne!

Alternativement pour le même bytecount:

27 octets

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

Essayez-le en ligne!

Le second est plus facile à expliquer:

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 deuxième partie du code fait la même chose, à l'exception de ces modifications:

• utiliser 2Gpour la deuxième entrée (var1) et la 3Gpremière 3e entrée (var2) au lieu de l'entrée implicite ou i, puisque celles-ci ont été consommées
• utiliser PY>P(inverser le tableau de gauche à droite, obtenir le maximum cumulatif, revenir en arrière) au lieu de Y>, pour obtenir 1 s avant la dernière occurrence plutôt qu'après la première occurrence
• utiliser f0)pour obtenir le dernier endroit où les deux conditions sont vraies, au lieu de la première place (fonctionne parce que MATL utilise l'indexation modulaire, donc 0 est pris pour se référer au dernier index du tableau)

MATLAB (80 octets)

L' entrée est x, yet a. MATLAB étant indexé 1, vous devez ajouter 1 aux cas de test.

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

Cas de test:

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 octets

Un lambda prenant un java.util.List<Integer>et deux ints (var1, var2) et retournant une paire séparée par des virgules.

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

Essayez-le en ligne

Kotlin , 132 octets

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

Essayez-le en ligne!

Julia , 71 64 octets

merci à Sundar et à lui find(A.==x)[]au lieu de findfirst(A,x)).

.

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