สำหรับความท้าทายนี้รายการจะถือว่าถูกต้องหากว่าประกอบด้วยจำนวนเต็มและรายการที่ถูกต้องทั้งหมด (นิยามแบบเรียกซ้ำ \ o /) สำหรับความท้าทายนี้ให้รายการที่ถูกต้องและจำนวนเต็มกลับรายการของความลึกทั้งหมดที่สามารถพบจำนวนเต็ม

ตัวอย่าง

ลองพิจารณารายชื่อและจำนวนเต็ม[1, [2, [3, [1, 2, 3], 4], 1], 1] 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]

ส่งคืนรายการว่างถ้าคำค้นหาไม่มีอยู่ในรายการที่ใดก็ได้

ค่าลบและศูนย์จะใช้ได้ในรายการอินพุตและคำศัพท์

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}

Haskell , 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รายการที่เรากำลังค้นหาและxที่Intเรากำลังค้นหา

เมื่อใดก็ตามที่(%)พบสิ่งที่เป็นองค์ประกอบเดียวE nมันจะตรวจสอบnความเท่าเทียมกันกับxและส่งกลับ0ถ้าเป็นจริง

เมื่อ(%)นำไปใช้กับL s(ที่sมีประเภท[T]) มันจะทำงาน(%)ในองค์ประกอบทั้งหมดของsและเพิ่มผล (ในขณะที่ความลึกเพิ่มขึ้นเนื่องจากเรามองเข้าไปข้างในs) และเชื่อมต่อผลลัพธ์

nub จากนั้นลบรายการที่ซ้ำกันออกจากรายการ

NB เป็นเพียงการimport Data.Listnub

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

ลองออนไลน์!

Python 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ให้ċ€นับการเกิดขึ้นของ1ในผลลัพธ์กลางแต่ละรายการ

[0, 2, 3, 3, 4]

I ตอนนี้ใช้ความแตกต่างไปข้างหน้าทั้งหมด

[2, 1, 0, 1]

ไม่ใช่ศูนย์ความแตกต่างสอดคล้องกับขั้นตอนในซึ่งอย่างน้อยหนึ่งอื่น ๆ1ถูกบันทึกอยู่ในความลึก1 ดังนั้นไม่ใช่ศูนย์ความแตกต่างที่ดัชนีkบ่งชี้ว่าการปรากฏตัวของที่1ที่ระดับความลึกk Tพบว่าดัชนีขององค์ประกอบความจริงทั้งหมดให้ผลลัพธ์ที่ต้องการ:

[1, 2, 4]

R , 101 95 92 100 ไบต์

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แล้วตรวจสอบว่าเป็นx listถ้ามันไม่ได้แล้วx==nดังนั้นเราจึงกลับความลึกd; มิฉะนั้นเราจะเรียกซ้ำ ๆfไปxเรื่อยdๆเพิ่มขึ้น

แน่นอนนี่คืนค่า a list, ซึ่งเราunlistและuniqueเพื่อให้แน่ใจว่าผลลัพธ์ที่ถูกต้อง (คืนค่าเวกเตอร์ของความลึกจำนวนเต็ม); ผลตอบแทนNULL(รายการที่ว่างเปล่า) nไม่ถูกต้อง

เห็นได้ชัด%in%ว่าไม่ได้ค้นหาซ้ำ ๆlistอย่างที่ฉันคิดดังนั้นฉันจึงต้องมีจำนวนunlist(x)8 ไบต์ :(

APL (Dyalog) 39 ไบต์ *

โปรแกรมเต็มรูปแบบ แจ้งให้สำหรับรายการแล้วสำหรับจำนวน พิมพ์รายการที่ใช้ 1 ไปยัง STDOUT

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

ลองออนไลน์!

⎕ พรอมต์สำหรับรายการ

⊢ ให้ผลผลิตนั้น (แยก0และ⎕)

⎕JSON⍠'Compact'0 แปลงเป็นสตริง JSON ที่เยื้องพร้อมการขึ้นบรรทัดใหม่

⎕FMT แปลงเป็นเมทริกซ์ (หนึ่งบรรทัดที่คั่นด้วยบรรทัดใหม่ต่อแถว)

⍞⍷ แจ้งให้เป็นตัวเลขเป็นสตริงและระบุว่าจะเริ่มต้นจากตรงไหน

∨⌿ แนวตั้งหรือการลดขนาด (เช่นเริ่มจากคอลัมน์ใด)

⍸ ดัชนีของจุดเริ่มต้นเหล่านั้น

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

ลองออนไลน์!

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

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

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

ลองออนไลน์!

-37 ไบต์ขอบคุณ Hyper Neutrino และ ovs

-4 ไบต์ขอบคุณ Jonathan Frech

APL (Dyalog Classic) , 31 30 ไบต์

ฟังก์ชัน หาเรื่องซ้าย⍺คือเข็มหาเรื่องขวา⍵คือกองหญ้า

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

ลองออนไลน์!

อ็อกเทฟ126 126ไบต์

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 code:

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 ไบต์

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