이 문제의 경우 목록이 정수와 유효한 목록 (재귀 적 정의 \ o /)으로 만 구성된 경우에만 목록이 유효한 것으로 간주됩니다. 이 문제를 해결하려면 유효한 목록과 정수가 주어지면 정수를 찾을 수있는 모든 깊이의 목록을 반환하십시오.

예

list [1, [2, [3, [1, 2, 3], 4], 1], 1]와 integer를 고려해 봅시다 1. 그런 다음 목록을 다음과 같이 그릴 수 있습니다.

Depth 0 1 2 3
Num   1
        2
          3
            1
            2
            3
          4
        1
      1

당신은 1깊이에 나타납니다 0, 1, 3. 따라서 출력은 0, 1, 3합리적인 형식 이어야 합니다 (순서는 중요하지 않음).

수심은 0 또는 1 색인 일 수 있지만 제출시 어떤 수인지 지정하십시오.

테스트 사례 (0 인덱스)

목록 [1,[2,[3,4],5,[6,7],1],[[[[5,2],4,[5,2]]],6],3]:

1 -> [0, 1]
2 -> [1, 4]
3 -> [0, 2]
4 -> [2, 3]
5 -> [1, 4]
6 -> [1, 2]
7 -> [2]

목록 [[[[[1],0],1],0],1]:

0 -> 1, 3
1 -> 0, 2, 4

목록 [11,22,[33,44]]:

11 -> [0]
22 -> [0]
33 -> [1]
44 -> [1]

검색어가 목록에 없으면 빈 목록을 반환하십시오.

입력 목록 및 용어에서 음수 및 0 값이 유효합니다.

Mathematica, 25 바이트

Tr/@Union[1^Position@##]&

(1 인덱스 출력을 반환)

설명

                         test  {1, {2, {3, {1, 2, 3}, 4}, 1}, 1}
             Position[test,1]  {{1}, {2, 2, 2, 1}, {2, 3}, {3}}
           1^Position[test,1]  {{1}, {1, 1, 1, 1}, {1, 1}, {1}}
    Union[1^Position[test,1]]  {{1}, {1, 1}, {1, 1, 1, 1}}
Tr/@Union[1^Position[test,1]]  {1, 2, 4}

하스켈 , 102 93 80 76 바이트

바이트를 절약 해 준 Bruce Forte 와 더 절약 해준 Laikoni 에게 감사드립니다 .

덕분에 4castle 4 바이트를 저장할.

Haskell에는 이러한 종류의 목록에 대한 데이터 유형이 없으므로 직접 만들었습니다.

이 솔루션은 1-indexed

import Data.List
data T=E Int|L[T]
E n%x=[0|x==n]
L s%x=nub$map(+1).(%x)=<<s

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

먼저 데이터 유형을 (재귀 적으로) 정의합니다. T

T유형 E Int( 유형의 단일 요소 Int) 또는 L[L](유형 목록 T)이 있습니다.

(%)소요 함수 2유형에 인수를 T, 우리가 검색되는 목록을, 그리고 x1, Int우리가 찾고있는가.

때마다 (%)하나의 요소 뭔가 발견 E n, 그것은 검사 n와 평등에 대한 x반환 0진정한 경우입니다.

를 (where where type )에 (%)적용 하면 모든 요소에서 실행 되고 결과를 증가시킵니다 (내부를 살펴본 후에 깊이가 증가함에 따라 ). 결과를 연결합니다.L ss[T](%)ss

nub 그런 다음 목록에서 중복을 제거합니다

NB. import Data.List입니다 nub.

파이썬 2 , 68 바이트

f=lambda l,k,d=-1:l>[]and f(l[0],k,d+1)|f(l[1:],k,d)or{d}-{d+(l==k)}

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

파이썬 2 , 72 바이트

f=lambda l,k,d=0:set([d]*(k in l)).union(*[f(x,k,d+1)for x in l if[]<x])

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

젤리 , 11 8 바이트

WẎÐĿċ€IT

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

작동 원리

WẎÐĿċ€IT  Main link. Left argument: A (array). Right argument: n (integer)

W         Wrap; yield [A].
  ÐĿ      Repeatedly apply the link to the left until the results are no longer
          unique. Yield the array of all unique results.
 Ẏ          Concatenate all elements at depth 1 in the array.
          The last array of the array of results is completely flat.
    ċ€    Count the occurrences of n in each intermediate result.
      I   Compute all forward differences.
       T  Truth; yield the array of all indices of non-zero differences.

예제 실행

왼쪽 인수

[1, [2, [3, [1, 2, 3], 4], 1], 1]

W 먼저 다음 배열을 생성합니다.

[[1, [2, [3, [1, 2, 3], 4], 1], 1]]

ẎÐĿ깊이 1 에서 모든 요소를 ​​반복적으로 연결 하여 각 단계에서 어레이의 깊이를 1 씩 줄입니다. 이렇게하면 다음과 같은 중간 결과 배열이 생성됩니다.

[
 [[1, [2, [3, [1, 2, 3], 4], 1], 1]],
 [ 1, [2, [3, [1, 2, 3], 4], 1], 1 ],
 [ 1,  2, [3, [1, 2, 3], 4], 1,  1 ],
 [ 1,  2,  3, [1, 2, 3], 4,  1, 1  ],
 [ 1,  2,  3,  1, 2, 3,  4,  1, 1  ]
]

오른쪽 인자를 들어 1 , ċ€의 발생 계산 한 각 중간 결과에서합니다.

[0, 2, 3, 3, 4]

I 이제 모든 앞으로 차이가 있습니다.

[2, 1, 0, 1]

0이 아닌 차이 는 하나 이상의 다른 1 이 깊이 1 에 추가 된 단계에 해당합니다 . 따라서, 인덱스 k 에서 0이 아닌 차이 는 깊이 k 에서 1 의 존재를 나타낸다 . T모든 진실 요소의 색인을 찾아 원하는 결과를 얻습니다.

[1, 2, 4]

R , 101 95 92100 바이트

f=function(L,n,d=0)unique(unlist(Map(function(x)if(n%in%unlist(x))"if"(is.list(x),f(x,n,d+1),d),L)))

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

재귀 솔루션; 바이트 단위로는 비효율적이지만 R lists은 작업하기가 매우 귀찮습니다.

기본적으로 필요 L하고, 각 요소 x의 L(중 하나 인 list또는 atomic하나 개의 벡터 요소)이, 검사하는 경우 n이고 %in% x, 다음 수표 경우 xA는 list. 그렇지 않은 경우 x==n깊이를 반환합니다 d. 그렇지 않으면 우리는 재귀 적으로 호출 f하고 x증가 d합니다.

물론, 이것은을 반환 list, 그것은 우리 unlist와 unique올바른 출력 (정수 깊이의 벡터를 반환) 보장하기 위해; NULLinvalid에 대해 (빈 목록)을 반환합니다 n.

분명히, 내가 생각한 것처럼 %in%반복적으로 검색하지 않으므로 +8 바이트를 사용해야합니다.listunlist(x)

APL (Dyalog) , 39 바이트 *

전체 프로그램. 목록을 요청한 다음 번호를 묻습니다. 1 기반 목록을 STDOUT에 인쇄합니다.

⌊2÷⍨⍸∨⌿⍞⍷⎕FMT⎕JSON⍠'Compact'0⊢⎕

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

⎕ 목록 요청

⊢ 수확량 (별도 0및 ⎕)

⎕JSON⍠'Compact'0 줄 바꿈으로 들여 쓴 JSON 문자열로 변환

⎕FMT 행렬로 변환 (행당 하나의 줄 바꿈으로 구분 된 줄)

⍞⍷ 숫자를 문자열로 묻고 그 시작 위치를 나타냅니다

∨⌿ 수직 OR 축소 (즉, 시작되는 열)

⍸ 그 시작의 지표

2÷⍨ 반으로 줄임 (레벨은 두 칸으로 들여 쓰기)

⌊ 반올림 (첫 번째 데이터 열이 열 3이므로)

^{*에서 Dyalog 클래식 계수 ⍸로 ⎕U2378와 ⍠같이 ⎕OPT.}

PHP , 117 바이트

$r;function z($a,&$r,$i=0){foreach($a as $v){is_int($v)?(@in_array($i,$r[$v])?:$r[$v][]=$i):z($v,$r,$i+1);}}z($s,$r);

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

자바 스크립트 (ES6), 79 68 바이트

f=(a,n,r=new Set,d=0)=>a.map(e=>e.map?f(e,n,r,d+1):e-n||r.add(d))&&r

세트를 돌려줍니다. 허용되지 않는 경우 &&[...r]5 바이트의 비용으로 사용하십시오 .

젤리 ,  17  16 바이트

⁴e®;©ȧ⁸ḟ⁴ẎµÐĿȧ®T’

두 개의 명령 줄 인수 목록과 검사 할 요소를 가져 와서 요소가 존재하는 깊이를 인쇄합니다. 결과는 1- 색인입니다.

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

어떻게?

⁴e®;©ȧḟ⁴ẎµÐĿȧ®T’ - Main link: list, L
          µÐĿ    - loop, collecting updated values of L, until a fixed point is reached:
⁴                -   4th argument (2nd program input) = the number
 e               -   exists in (the current version of) L?
  ®              -   recall value from the register (initially 0)
   ;             -   concatenate the two
    ©            -   (copy this result to the register)
       ⁴         -   4th argument (2nd program input) again
      ḟ          -   filter out (discard any instances of the number)
     ȧ           -   logical and (non-vectorising)
        Ẏ        -   tighten (flatten the filtered L by one level to create the next L)
             ®   - recall value from the register
            ȧ    - logical and (non-vectorising)
              T  - truthy indexes (1-indexed)
               ’ - decrement (account for the leading zero from the initial register)

자바 스크립트 (ES6), 73 74 바이트

f=(a,n,i=0,o={})=>a.map(e=>e.pop?f(e,n,i+1,o):e-n||o[i]++)&&Object.keys(o)

설명:

f=(a,                             //input array
   n,                             //input number to search
   i=0,                           //start at first level
   o={}                           //object to store the finds
  )=>
    a.map(                        //loop through the array
      e => e.pop ?                //is this element an array?
             f(e, n, i+1, o) :    //if so, recurse on it to the next level
             e-n || o[i]++        //otherwise, update o if element equals the number
    ) &&
    Object.keys(o)                //return o's keys

테스트 사례

f=(a,n,i=0,o={})=>a.map(e=>e.pop?f(e,n,i+1,o):e-n||o[i]++)&&Object.keys(o)

var a = [1,[2,[3,4],5,[6,7],1],[[[[5,2],4,[5,2]]],6],3];
console.log(f(a,1));
console.log(f(a,2));
console.log(f(a,3));
console.log(f(a,4));
console.log(f(a,5));
console.log(f(a,6));
console.log(f(a,7));

console.log('___________');
var a = [[[[[1],0],1],0],1];
console.log(f(a,0));
console.log(f(a,1));

console.log('___________');
var a = [11,22,[33,44]];
console.log(f(a,11)) // [0]
console.log(f(a,22)) // [0]
console.log(f(a,33)) // [1]
console.log(f(a,44)) // [1]
console.log(f(a,55)) // empty set

파이썬 3 , 123 86 82 바이트

def f(a,n,l=[],d=0):
 for e in a:l+=[d]*(e==n);0*e==[]and f(e,n,l,d+1)
 return{*l}

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

Hyper Neutrino 및 ov 덕분에 -37 바이트

Jonathan Frech 덕분에 -4 바이트

APL (Dyalog Classic) , 31 30 바이트

함수. 왼쪽 arg ⍺는 바늘이고 오른쪽 arg ⍵는 건초 더미입니다.

{×≢⍵:(⍳⍺∊⍵),1+⍺∇⊃,/⍵/⍨≢¨⍴¨⍵⋄⍬}

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

옥타브 , 126122 바이트

function n=r(p,t,l)n=[];if nargin<3
l=0;end
for x=p
if iscell(q=x{1})a=r(q,t,l+1);else
a=l*find(q==t);end
n=union(n,a);end

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

가독성을 위해 ;가능한 한 공백이나 줄을 줄 끝으로 바꿨습니다. ungolfed 코드에 대한 설명 :

function n=r(p,t,l) % Declare function with list p, integer t and optional recursion depth l
n=[];
if nargin<3
    l=0;            % If l is not given (first iteration), set l to zero (or one for 1-indexing)
end
for x=p             % Loop over list
if iscell(q=x{1})   % If loop variable x is a cell, we must go down one level.
     a=r(q,t,l+1);  % So recurse to l+1.
else
    a=l*find(q==t); % Empty if q~=t (because find(false)==[], and l*[]==[]), else equal to l*1==l.
end
n=union(n,a);       % Append to list of levels, make sure we only get distinct values.
end

자바, 154 + 19 = 173 바이트

import java.util.*;

Set<Long>f(List l,long n){Set s=new HashSet();if(l.contains(n))s.add(0l);for(Object o:l)if(o instanceof List)for(long d:f((List)o,n))s.add(d+1);return s;}

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

풀리지 않은 방법

Set<Long> f(List l, long n) {
    Set s = new HashSet();
    if (l.contains(n))
        s.add(0l);
    for (Object o : l)
        if (o instanceof List)
            for (long d : f((List) o, n))
                s.add(d + 1);
    return s;
}