একটি তালিকা গভীর অনুসন্ধান

Question

এই চ্যালেঞ্জের জন্য, কোনও তালিকা বৈধ হিসাবে বিবেচিত হবে এবং কেবলমাত্র যদি এটি সম্পূর্ণরূপে পূর্ণসংখ্যার এবং বৈধ তালিকাগুলি (পুনরাবৃত্ত সংজ্ঞা \ 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]

তালিকার কোথাও যদি অনুসন্ধান শব্দটির অস্তিত্ব না থাকে তবে খালি তালিকাটি ফিরিয়ে দিন।

নেতিবাচক এবং শূন্য মানগুলি ইনপুট তালিকা এবং পদটিতে বৈধ।

Comments

যদি পূর্ণসংখ্যার এক গভীরতায় একাধিকবার উপস্থিত হয়, আমরা কি কেবল একবার সেই গভীরতা নম্বরটি ফিরিয়ে দিতে পারি?

— জিউসেপ

@ জিউসেপ হ্যাঁ, এটি সঠিক correct

— হাইপারনিউটারিনো

@ অ্যাডম ভাল করে দিয়েছি যে আমার পরীক্ষার একটি মামলায় জিরোস রয়েছে, না। এছাড়াও আমি যুক্ত করব যে negativeণাত্মক পূর্ণসংখ্যাগুলি সুষ্ঠু খেলা।

— হাইপারনিউটারিনো

বহু-সংখ্যার নম্বরগুলি পরীক্ষার ক্ষেত্রেও যুক্ত করা উচিত, যদি তারা ঘটতে পারে।

— Zgarb

@ কেভিন ক্রুজসেন হ্যাঁ, হ্যাঁ, না, এবং হ্যাঁ সুতরাং আপনি উভয় স্ট্রিং হিসাবে ইনপুট নিতে পারেন এবং আপনি কোনও ক্রমে গভীরতা প্রদর্শন করতে পারেন, তবে একাধিকবার নয়।

— হাইপারনিউটারিনো

Answer 1

গণিত, 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}

Answer 2

হাস্কেল , 102 93 80 76 বাইট

কিছু বাইট সংরক্ষণ করার জন্য ব্রুস ফোর্ট এবং ধন্যবাদ আরও কিছু সঞ্চয় করার জন্য লাইকোনিকে ধন্যবাদ Thanks

4 বাইট সংরক্ষণ করার জন্য ধন্যবাদ 4 ক্যাসল ।

এই ধরণের তালিকার জন্য হাস্কেলের কোনও ডেটা টাইপ নেই, তাই আমি নিজের তৈরি করেছি।

এই সমাধান হয় 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।

Comments

আমি 81 বাইটের জন্য বেশ অনুরূপ সমাধান নিয়ে এসেছি: এটি অনলাইনে চেষ্টা করুন!

— লাইকনি

@ লাইকনি খুব সুন্দর, আপনি কি নিজে এটি পোস্ট করতে চান, বা আপনি আমার আপডেট করার পরামর্শ দিচ্ছেন?

— এইচপিউইজ

আপনার উত্তর আপডেট করতে নির্দ্বিধায়। :)

— লাইকোনি

এনবি সম্পর্কিত: আমি আমদানি থেকে মুক্তি পাওয়ার চেষ্টা করেছি, তবে 88 বাইটে শেষ করছি: এটি অনলাইনে চেষ্টা করুন!

— লাইকনি

আপনি কাছাকাছি E nএবং প্রথম বন্ধনী সরাতে পারেন L s।

— ক্যাসেল

Answer 3

পাইথন 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)}

এটি অনলাইন চেষ্টা করুন!

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

এটি অনলাইন চেষ্টা করুন!

Answer 5

জেলি , 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 এ যুক্ত হয়েছিল । সুতরাং, সূচক কে -তে একটি শূন্য-পার্থক্য গভীরতার কেতে 1 এর উপস্থিতি নির্দেশ করে । পছন্দসই ফলাফল প্রদান করে সমস্ত সত্য উপাদানগুলির সূচকগুলি সন্ধান করে:T

[1, 2, 4]

Comments

জেলির সাথে পাইথনের তুলনা করার সময় / o / এটিই আমার সঠিক সমাধান ছিল। হ্যাঁ! : পি

— হাইপারনিউট্রিনো

Answer 6

আর , 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; অন্যথায় আমরা যাও recursively কল fউপর x, বৃদ্ধিশীল d।

এটি অবশ্যই প্রত্যাবর্তন করে list, যা আমরা unlistএবং uniqueসঠিক আউটপুট নিশ্চিত করতে (পূর্ণসংখ্যার গভীরতার ভেক্টরকে ফিরিয়ে দেওয়া); NULLঅবৈধ জন্য রিটার্ন (একটি খালি তালিকা) n।

স্পষ্টতই, আমি যা ভাবি তার মতো %in%পুনরাবৃত্তি অনুসন্ধান listকরি না, সুতরাং আমাকে unlist(x)+8 বাইটের জন্য করতে হবে :(

Answer 7

এপিএল (ডায়ালগ) , 39 বাইট *

পুরো প্রোগ্রাম। তালিকার জন্য প্রম্পট দেয়, তারপরে সংখ্যার জন্য। 1-ভিত্তিক তালিকাটি STDOUT এ মুদ্রণ করে।

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

এটি অনলাইন চেষ্টা করুন!

⎕ তালিকার জন্য প্রম্পট

⊢ ফলন যে (পৃথক 0এবং ⎕)

⎕JSON⍠'Compact'0 নতুন লাইনের সাথে ইনডেন্টেড জেএসএন স্ট্রিংয়ে রূপান্তর করুন

⎕FMT ম্যাট্রিক্সে রূপান্তর করুন (সারি প্রতি একটি নতুন লাইন-বিস্মৃত রেখা)

⍞⍷ স্ট্রিং হিসাবে সংখ্যার জন্য অনুরোধ জানানো হবে এবং এটি শুরু হয় যেখানে এটি শুরু হয়

∨⌿ উল্লম্ব OR হ্রাস (যার মধ্যে এটি শুরু হয় কলামগুলি)

⍸ সূচনা সূচনা

2÷⍨ অর্ধেক যে (স্তর দুটি স্থানের সাথে যুক্ত হয়)

⌊ রাউন্ড ডাউন (কারণ প্রথম ডেটা কলামটি কলাম 3)

---

^{* ডায়ালগ ক্লাসিকে, ⍸হিসাবে ⎕U2378এবং ⍠হিসাবে গণনা ⎕OPT।}

Answer 8

পিএইচপি , 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);

এটি অনলাইন চেষ্টা করুন!

Answer 9

জাভাস্ক্রিপ্ট (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 বাইট ব্যয়ে ব্যবহার করুন ।

Answer 10

জেলি ,  17  16 বাইট

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

একটি সম্পূর্ণ প্রোগ্রাম দুটি কমান্ড লাইনের আর্গুমেন্ট তালিকা এবং একটি উপাদান যাচাইয়ের জন্য এবং উপাদানটি যে গভীরতায় বা গভীরতা (যদি থাকে) মুদ্রণ করে at ফলাফলগুলি 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)

Comments

নিস! মজাদার ঘটনা যদিও: খুব অনুরূপ পদ্ধতির ব্যবহার করে তবে জিনিসগুলির ক্রমটি কিছুটা পরিবর্তন করে আপনি 8 বাইট পেতে পারেন। পদ্ধতির সম্পাদনাটি আসলে কিছুটা আলাদা,

— এনভিএম

এটি বেশ কার্যকর নয়: tio.run/##y0rNyan8//9R45ZU60MrD607sfxR446HO@YDBR7u6ju09fCEI/…

— হাইপারনিউটারিনো

হুঁ লেখার সময় বাগগুলি খুঁজে পেয়েছে ... আপাতত মোছা হচ্ছে।

— জোনাথন অ্যালান

আহ আমি একরকম আমার কনটেন্টেশনের ক্রম পরিবর্তন করেছি: / এখন কাজ করা উচিত

— জোনাথন অ্যালান

Answer 11

জাভাস্ক্রিপ্ট (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

Comments

যদিও কোনও পরীক্ষার মামলা নেই [এখনও], আমার প্রশ্নটি পড়ার পরামর্শ দেয় যে এটি e[0]শূন্য হওয়ার জন্য বৈধ , যা আপনার পরীক্ষা বন্ধ করে দেবে।

— নীল

@ নীল, দুর্দান্ত পয়েন্ট এখন e.popএক বাইট হারাতে পরিবর্তিত হয়েছে ।

— রিক হিচকক

Answer 12

পাইথন 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 বাইট হাইপার নিউট্রিনো এবং ovs ধন্যবাদ

-4 বাইট জনাথন ফ্রেচকে ধন্যবাদ

Comments

if type(a[i])!=int-1 বাইটের জন্য চেষ্টা করুন

— হাইপারনিউট্রিনো

l+=[d]-5 বাইটের জন্য চেষ্টা করুন

— হাইপারনিউটারিনো

ব্যবহার করে দেখুন l+=[d]*(a[i]==n)-whatever_number_of_bytes_it_is জন্য

— HyperNeutrino

[]==a[i]*0একটি সংক্ষিপ্ত প্রকারের চেকের জন্য

— ovs

aপরিসরের পরিবর্তে পুনরাবৃত্তি করার চেষ্টা করুন getitem- এবং ~ 20 বাইটের জন্য এত বেশি ব্যবহার করুন

— হাইপারনিউটারিনো

Answer 13

এপিএল (ডায়ালগ ক্লাসিক) , 31 30 বাইট

ফাংশন। বাম দিকের আর্কটি ⍺হ'ল সুই, ডান দিকের খালি ⍵খড়ের খালি ack

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

এটি অনলাইন চেষ্টা করুন!

Answer 14

অষ্টাভে , 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

Answer 15

জাভা, 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;
}