도전

작업은 간단합니다. 배열과 첫 번째 및 마지막 값이 주어지면 첫 번째와 마지막 값 중 첫 번째와 마지막 값 중 첫 번째 값을 반환합니다.

또는 간단히 : 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

젤리 , 17 바이트

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

온라인으로 사용해보십시오!

파이썬 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))

온라인으로 사용해보십시오!

APL (Dyalog Classic) , 29 27 바이트

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

온라인으로 사용해보십시오!

배열에 대한 프롬프트를 표시 한 다음 var1, var2에 대한 프롬프트

자바 스크립트 (ES6), 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]

대체 버전

JS 내장 기능을 사용하면보다 간단한 대답은 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`]

온라인으로 사용해보십시오!

파이썬 3 , 97 93 바이트

ovs 덕분에 -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))

온라인으로 사용해보십시오!

Japt , 27 25 24 바이트

@Arnauld의 답변 에서 영감을 얻었습니다.

감사합니다 @Shaggy -2 바이트 및 @ETHproductions -1 바이트

방금 jap으로 시작 했으므로 더 나은 방법이어야합니다. \

[WsX=WbU)bV +XWsTWaV)aU]

온라인으로 사용해보십시오!

APL (Dyalog Unicode) , 42 바이트 ^SBCS

익명의 암묵적 삽입 기능. var1, var2를 왼쪽 인수로, 배열을 오른쪽 인수로 사용합니다.

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

온라인으로 사용해보십시오!

R , 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 인덱스)

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제 2 입력 (VAR1)와위한 3G제 3 입력 (VAR2) 대신 암시 입력이나 i그 소비 된 이후,
• 사용 PY>P(플립 어레이는 왼쪽에서 오른쪽으로, 최대 누적 플립 다시 얻기) 대신에 Y>(1S)를 얻기 위해, 마지막에 검출되기 전에 대신 최초로 출현 후
• 사용 f0)얻기 위해 마지막 (0 배열의 마지막 인덱스를 참조 촬영되도록, MATL이 모듈 색인을 사용하기 때문에 작품) 두 조건이 모두 대신 처음의 해당 장소를

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

자바 8, 114 바이트

s 는 a java.util.List<Integer>와 2를 취하고 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)

온라인 시도

코 틀린 , 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)}()}

온라인으로 사용해보십시오!

줄리아 , 71 64 바이트

find(A.==x)[]대신 sundar와 그의 덕분 에 findfirst(A,x)).

.

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