इस चुनौती के लिए, एक सूची को वैध माना जाता है, यदि केवल और केवल पूर्णांक और वैध सूचियों (पुनरावर्ती परिभाषाएँ / ओ) से युक्त हो। इस चुनौती के लिए, एक मान्य सूची और पूर्णांक दिया गया है, सभी गहराई की सूची लौटाएं जिस पर पूर्णांक मिल सकता है।

उदाहरण

आइए सूची [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]

यदि सूची में कहीं भी खोज शब्द मौजूद नहीं है, तो एक खाली सूची लौटाएं।

नकारात्मक और शून्य मान इनपुट सूची और शब्द में मान्य हैं।

code-golf array-manipulation

— HyperNeutrino
स्रोत

यदि पूर्णांक कई बार एक गहराई पर दिखाई देता है, तो क्या हमें केवल एक बार उस गहराई की संख्या वापस करनी है?

— ग्यूसेप

@Giuseppe हाँ, यह सही है।

— २३:२४ पर HyperNeutrino

1

@ Adám ने कहा कि मेरे एक परीक्षण के मामले में शून्य है, नहीं। इसके अलावा, मैं कहूंगा कि नकारात्मक पूर्णांक निष्पक्ष खेल हैं।

— हाइपरएनुट्रीनो

1

बहु-अंकीय संख्याओं को एक परीक्षण मामले में भी जोड़ा जाना चाहिए, यदि वे हो सकती हैं।

— जरगब

1

@KevinCruijssen हाँ, हाँ, नहीं, और हाँ। तो आप इनपुट को स्ट्रिंग्स के रूप में ले सकते हैं, और आप किसी भी क्रम में गहराई प्रदर्शित कर सकते हैं, लेकिन कई बार नहीं।

— हाइपरएनुट्रिनो 12

7

गणितज्ञ, 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}

— मिशा लावरोव
स्रोत

7

हास्केल , 102 93 80 76 बाइट्स

धन्यवाद ब्रूस फोर्ट कुछ बाइट्स को बचाने के लिए, और Laikoni कुछ और बचाने के लिए।

4 बाइट बचाने के लिए धन्यवाद 4castle ।

इस तरह की सूची के लिए हास्केल के पास कोई डेटा प्रकार नहीं है, इसलिए मैंने अपना खुद का बनाया।

यह समाधान है 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 फिर सूची से डुप्लिकेट निकालता है

एनबी। import Data.Listकेवल के लिए है nub।

— H.PWiz
स्रोत

मैं 81 बाइट्स के लिए एक समान समाधान के साथ आया था: इसे ऑनलाइन आज़माएं!

— लकोनी

@ लिकोनी बहुत अच्छा, क्या आप इसे स्वयं पोस्ट करना चाहते हैं, या क्या आप मुझे मेरा अद्यतन करने का सुझाव देते हैं?

— H.PWiz

अपने उत्तर को अपडेट करने के लिए स्वतंत्र महसूस करें। :)

— लैकोनी

एनबी के बारे में: मैंने आयात से छुटकारा पाने की कोशिश की, लेकिन 88 बाइट्स में एंडेट: इसे ऑनलाइन आज़माएं!

— लकोनी

2

आप चारों ओर कोष्ठक को हटा सकते हैं E nऔर L s।

— 4castle

6

पायथन 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)}

इसे ऑनलाइन आज़माएं!

— XNOR
स्रोत

4

पायथन 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])

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

4

जेली , 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 पर एक गैर-शून्य अंतर गहराई k पर 1 की उपस्थिति को इंगित करता है । सभी सत्य तत्वों के सूचकांकों को खोजता है, वांछित परिणाम प्राप्त करता है:T

[1, 2, 4]

— डेनिस
स्रोत

जब जेली की तुलना पायथन से की गई तो ओ / यह मेरा सटीक समाधान था। वाह! : पी

— हाइपरनेत्रिनो

4

आर , 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)))

इसे ऑनलाइन आज़माएं!

पुनरावर्ती समाधान; यह बाइट्स में काफी अक्षम है, लेकिन आर के listsसाथ काम करने के लिए सुपर कष्टप्रद हैं।

मूल रूप से, लेता है L, और प्रत्येक तत्व के लिए xकी L, (जो या तो एक है listया एक atomicएक तत्व के वेक्टर) इसकी जांच करता है nहै %in% x, तो जांच करता है कि xएक है list। यदि ऐसा नहीं है, तो x==nहम गहराई लौटाते हैं d; अन्यथा हम पुनरावृत्ति , वृद्धि fपर कॉल करते हैं ।xd

यह, निश्चित रूप से, एक लौटाता है list, जिसे हम unlistऔर uniqueसही आउटपुट सुनिश्चित करने के लिए (पूर्णांक गहराई का एक वेक्टर लौटाते हैं); NULLअमान्य के लिए रिटर्न (एक खाली सूची) n।

जाहिरा तौर पर, जैसा मैंने सोचा था, वैसे ही %in%पुनरावर्ती खोज नहीं करता list, इसलिए मुझे unlist(x)+8 बाइट्स के लिए जाना है :(

— ग्यूसेप
स्रोत

3

APL (Dyalog) , 39 बाइट्स *

पूरा कार्यक्रम। सूची के लिए संकेत, फिर संख्या के लिए। STDOUT को 1-आधारित सूची प्रिंट करता है।

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

इसे ऑनलाइन आज़माएं!

⎕ सूची के लिए संकेत

⊢ उपज (अलग ) 0और⎕

⎕JSON⍠'Compact'0 नई सूचियों के साथ इंडेंट किए गए JSON स्ट्रिंग में कनवर्ट करें

⎕FMT मैट्रिक्स में परिवर्तित करें (एक नई पंक्ति-पंक्तिबद्ध पंक्ति)

⍞⍷ स्ट्रिंग के रूप में संख्या के लिए संकेत और संकेत मिलता है कि यह कहाँ से शुरू होता है

∨⌿ वर्टिकल या रिडक्शन (यानी यह कौन सा कॉलम शुरू होता है)

⍸ उन शुरुआत के संकेत

2÷⍨ यह बताएं कि (स्तर दो स्थानों से जुड़े हुए हैं)

⌊ राउंड डाउन (क्योंकि पहला डेटा कॉलम कॉलम 3 है)

^{* द्यलोग क्लासिक में, के ⍸रूप में ⎕U2378और के ⍠रूप में गिनती ⎕OPT।}

— एडम
स्रोत

2

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

इसे ऑनलाइन आज़माएं!

— Calimero
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 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 बाइट की लागत पर उपयोग करें ।

— नील
स्रोत

1

जेली , 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)

— जोनाथन एलन
स्रोत

अच्छा! मजेदार तथ्य हालांकि: बहुत समान दृष्टिकोण का उपयोग करके लेकिन चीजों के क्रम को थोड़ा बदलकर, आप 8 बाइट्स प्राप्त कर सकते हैं। दृष्टिकोण को संपादित करना वास्तव में थोड़ा अलग है, nvm

— HyperNeutrino

यह काफी काम नहीं करता है: tio.run/##0rNyan8//9R45ZU60MrD607sfxR446HO@YDBR7u6ju09fCEI/…

— HyperNutrino

हम्म को लिखने के दौरान कीड़े मिले ... अब के लिए हटाना।

— जोनाथन एलन

आह, मैंने किसी तरह अपने संघटन के क्रम को बदल दिया है: / अब काम करना चाहिए

— जोनाथन एलन

1

जावास्क्रिप्ट (ईएस 6), 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

स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत

हालाँकि, कोई परीक्षण मामले नहीं हैं [अभी तक], मेरे प्रश्न के पढ़ने से पता चलता है कि यह e[0]शून्य होने के लिए वैध है, जो आपके परीक्षण को समाप्त कर देगा।

— नील

@ नील, उत्कृष्ट बिंदु। अब e.popएक बाइट के नुकसान के लिए बदल गया ।

— रिक हिचकॉक

1

पायथन 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 बाइट्स हाइपर न्यूट्रिनो और अंडाणुओं के लिए धन्यवाद

जोहानस फ्रीच को -4 बाइट्स धन्यवाद

— केर्ड सिक्काहिरिंग
स्रोत

if type(a[i])!=int-1 बाइट के लिए प्रयास करें

— हाइपरनेत्रिनो

l+=[d]-5 बाइट्स के लिए प्रयास करें

— हाइपरनेत्रिनो

प्रयास करें l+=[d]*(a[i]==n)-whatever_number_of_bytes_it_is के लिए

— HyperNeutrino

1

[]==a[i]*0एक छोटे प्रकार की जाँच के लिए

— Ovs

aएक सीमा के बजाय पुनरावृत्ति करने की कोशिश करें और getitemइसके लिए बहुत अधिक उपयोग करें - ~ 20 बाइट्स

— हाइपरन्यूट्रीनो

1

APL (Dyalog Classic) , 31 30 बाइट्स

समारोह। लेफ्ट आर्ग ⍺सुई है, राइट अर्ग हैस्टैक ⍵है।

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

इसे ऑनलाइन आज़माएं!

— NGN
स्रोत

0

ऑक्टेव , 126 122 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पठनीयता के लिए, मैंने रिक्त स्थान या ;जहाँ संभव हो, रेखा के साथ प्रतिस्थापित किया है। असमतल कोड की व्याख्या:

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

— Sanchises
स्रोत

0

जावा, 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;
}

— जेकब
स्रोत

डीप सर्च लिस्ट

उदाहरण

परीक्षण मामले (0-अनुक्रमित)

गणितज्ञ, 25 बाइट्स

व्याख्या

हास्केल , 102 93 80 76 बाइट्स

पायथन 2 , 68 बाइट्स

पायथन 2 , 72 बाइट्स

जेली , 11 8 बाइट्स

यह काम किस प्रकार करता है

उदाहरण चलाते हैं

आर , 101 95 92 100 बाइट्स

APL (Dyalog) , 39 बाइट्स *

PHP , 117 बाइट्स

जावास्क्रिप्ट (ईएस 6), 79 68 बाइट्स

जेली , 17 16 बाइट्स

कैसे?

जावास्क्रिप्ट (ईएस 6), 73 74 बाइट्स

पायथन 3 , 123 86 82 बाइट्स

APL (Dyalog Classic) , 31 30 बाइट्स

ऑक्टेव , 126 122 बाइट्स

जावा, 154 + 19 = 173 बाइट्स

अघोषित विधि