Đối với thử thách này, một danh sách được coi là hợp lệ khi và chỉ khi nó bao gồm toàn bộ số nguyên và danh sách hợp lệ (định nghĩa đệ quy \ o /). Đối với thử thách này, được đưa ra một danh sách hợp lệ và một số nguyên, trả về một danh sách tất cả các độ sâu mà tại đó số nguyên có thể được tìm thấy.

Thí dụ

Hãy xem xét danh sách [1, [2, [3, [1, 2, 3], 4], 1], 1]và số nguyên 1. Sau đó, chúng ta có thể rút ra danh sách như thế này:

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

Bạn sẽ nhận thấy rằng 1xuất hiện ở độ sâu 0, 1, 3. Vì vậy, đầu ra của bạn nên 0, 1, 3ở một số định dạng hợp lý (thứ tự không quan trọng).

Độ sâu có thể là 0 hoặc 1 được lập chỉ mục, nhưng vui lòng chỉ định trong bài gửi của bạn.

Các trường hợp thử nghiệm (0 chỉ mục)

Đối với danh sách [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]

Đối với danh sách [[[[[1],0],1],0],1]:

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

Đối với danh sách [11,22,[33,44]]:

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

Trả về một danh sách trống nếu thuật ngữ tìm kiếm không tồn tại trong danh sách ở bất cứ đâu.

Giá trị âm và không có giá trị trong danh sách đầu vào và thuật ngữ.

Toán học, 25 byte

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

(trả về đầu ra 1 chỉ mục)

Giải trình

                         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}

Haskell , 102 93 80 76 byte

Cảm ơn Bruce Forte vì đã lưu một số byte và Laikoni vì đã tiết kiệm thêm một số.

Cảm ơn 4castle vì đã tiết kiệm 4 byte.

Haskell không có kiểu dữ liệu cho loại danh sách này, vì vậy tôi đã tạo riêng cho mình.

Giải pháp này là 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

Hãy thử trực tuyến!

Đầu tiên tôi xác định (đệ quy) một kiểu dữ liệu T

Tcó loại E Int(phần tử đơn loại Int) hoặc L[L](danh sách loại T).

(%)là hàm lấy các 2đối số, về loại T, danh sách mà chúng ta đang tìm kiếm và x, Intchúng ta đang tìm kiếm.

Bất cứ khi nào (%)tìm thấy một cái gì đó là một yếu tố duy nhất E n, nó sẽ kiểm tra nsự bằng nhau xvà trả về 0nếu True.

Khi (%)được áp dụng cho một L s(trong đó scó loại [T]), nó chạy (%)trên tất cả các yếu tố svà tăng kết quả (vì độ sâu đang tăng lên khi chúng ta nhìn vào bên trong s) và kết quả kết quả.

nub sau đó loại bỏ các bản sao khỏi danh sách

Lưu ý import Data.Listchỉ dành cho nub.

Python 2 , 68 byte

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

Hãy thử trực tuyến!

Con trăn 2 , 72 byte

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

Hãy thử trực tuyến!

Thạch , 11 8 byte

WẎÐĿċ€IT

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Chạy ví dụ

Đối với đối số trái

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

W đầu tiên mang lại mảng sau.

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

ẎÐĿliên tục nối tất cả các phần tử ở độ sâu 1 , giảm độ sâu của mảng xuống 1 trong mỗi bước. Điều này mang lại các kết quả trung gian sau đây.

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

Đối với đối số đúng 1 , ċ€tính số lần xuất hiện của 1 trong mỗi kết quả trung gian.

[0, 2, 3, 3, 4]

I bây giờ có tất cả sự khác biệt về phía trước.

[2, 1, 0, 1]

Khác không khác biệt tương ứng với bước trong đó có ít nhất một khác 1 đã được thêm vào chiều sâu 1 . Do đó, sự khác biệt khác không ở chỉ số k chỉ ra sự có mặt của 1 ở độ sâu k . Ttìm các chỉ số của tất cả các yếu tố trung thực, mang lại kết quả mong muốn:

[1, 2, 4]

R , 101 95 92 100 byte

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

Hãy thử trực tuyến!

Giải pháp đệ quy; Nó khá kém hiệu quả về byte, nhưng Rlists khó chịu khi làm việc.

Về cơ bản, lấy Lvà cho mỗi phần tử xcủa L, (là một listhoặc một atomicvectơ của một phần tử), kiểm tra nếu nlà %in% x, sau đó kiểm tra nếu xlà a list. Nếu không, thì x==nchúng ta sẽ trả lại độ sâu d; nếu không chúng tôi đệ quy gọi ftrên x, incrementing d.

Tất nhiên, điều này trả về a list, mà chúng ta unlistvà uniqueđể đảm bảo đầu ra đúng (trả về một vectơ có độ sâu nguyên); trả về NULL(một danh sách trống) cho không hợp lệ n.

Rõ ràng, %in%không tìm kiếm đệ quy thông qua listnhư tôi nghĩ, vì vậy tôi phải unlist(x)kiếm +8 byte :(

APL (Dyalog) , 39 byte *

Chương trình đầy đủ. Nhắc cho danh sách, sau đó cho số. In danh sách 1 dựa trên STDOUT.

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

Hãy thử trực tuyến!

⎕ nhắc nhở cho danh sách

⊢ mang lại rằng (tách 0và ⎕)

⎕JSON⍠'Compact'0 chuyển đổi thành chuỗi JSON thụt lề với dòng mới

⎕FMT chuyển đổi thành ma trận (một dòng phân cách dòng mới trên mỗi hàng)

⍞⍷ nhắc số dưới dạng chuỗi và cho biết nơi nó bắt đầu trong đó

∨⌿ giảm OR theo chiều dọc (nghĩa là nó bắt đầu bằng cột nào)

⍸ chỉ số của những khởi đầu

2÷⍨ giảm một nửa (mức được thụt vào với hai khoảng trắng)

⌊ làm tròn xuống (vì cột dữ liệu đầu tiên là cột 3)

^{* Trong Dyalog Classic, đếm ⍸như ⎕U2378và ⍠như ⎕OPT.}

PHP , 117 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 79 68 byte

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

Trả về một bộ. Nếu điều này là không thể chấp nhận, sử dụng&&[...r] với chi phí 5 byte.

Thạch ,  17  16 byte

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

Một chương trình đầy đủ lấy hai dòng đối số danh sách và một phần tử để kiểm tra và in độ sâu hoặc độ sâu (nếu có) mà phần tử tồn tại. Kết quả là 1 chỉ số.

Hãy thử trực tuyến!

Làm sao?

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

JavaScript (ES6), 73 74 byte

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

Giải trình:

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

Các trường hợp thử nghiệm

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

Python 3 , 123 86 82 byte

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}

Hãy thử trực tuyến!

-37 byte nhờ Hyper Neutrino và ovs

-4 byte nhờ Jonathan Frech

APL (Dyalog Classic) , 31 30 byte

Chức năng. Còn lại⍺ là kim, arg phải ⍵là haystack.

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

Hãy thử trực tuyến!

Tháng mười , 126 122 byte

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

Hãy thử trực tuyến!

Để dễ đọc, tôi đã thay thế dấu cách hoặc dấu ;bằng dòng kết thúc nếu có thể. Giải thích về mã không mã hóa:

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

Java, 154 + 19 = 173 byte

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;}

Dùng thử trực tuyến

Phương pháp khử

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;
}