চ্যালেঞ্জগুলির একটি অ্যারে # 2: নেস্টেড অ্যারে পৃথক করুন

36

দ্রষ্টব্য: অ্যারে-ম্যানিপুলেশন চ্যালেঞ্জগুলির একটি সিরিজের এটি # 2 । পূর্ববর্তী চ্যালেঞ্জের জন্য, এখানে ক্লিক করুন ।

নেস্টেড তালিকাগুলি পৃথক করা

নেস্টেড তালিকায় মানগুলি পৃথক করতে, এটি সমতল করুন এবং তারপরে প্রতিটি মানটি মুড়ে দিন যাতে এটি আগের মতো একই নেস্টেড গভীরতায় থাকে।

এই তালিকাটি বলতে হয়:

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

হবে:

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

চ্যালেঞ্জ

আপনার কাজটি এমন একটি প্রোগ্রাম লেখা যা ইতিবাচক পূর্ণসংখ্যার (আপনার ভাষার সীমার মধ্যে) কোনও নেস্টেড তালিকা নেয় এবং এই বিভাজন অপারেশন সম্পাদন করে।

আপনি একটি ফাংশন জমা দিতে পারেন যা তালিকাটিকে আর্গুমেন্ট হিসাবে গ্রহণ করে বা পুরো প্রোগ্রাম যা I / O সম্পাদন করে।

এটি কোড-গল্ফ হিসাবে , সংক্ষিপ্ততম জমা (বাইটে) জিতেছে! *

* স্ট্যান্ডার্ড গল্ফিং লুফোলগুলি নিষিদ্ধ করা হয়েছে। তুমি অনুশীলনটা জানো.

পরীক্ষার মামলা

ইনপুট তালিকাগুলিতে কেবল কখনও আপনার ভাষার স্ট্যান্ডার্ড পূর্ণসংখ্যার আকার থাকে inte ভাষার প্রতিবন্ধকতাগুলি প্রতিযোগিতা থেকে বিরত রাখতে, মান 10 এর বেশি গভীরতায় নেস্ট করা হবে না।

আপনি ধরে নিতে পারেন যে ইনপুটটিতে খালি উপ-তালিকা [[5, []]]থাকবে না : উদাহরণস্বরূপ - দেওয়া হবে না। তবে মূল তালিকাটি খালি থাকতে পারে।

[]            ->  []

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

আমি যদি কোনও কোণার কেস মিস করি তবে কোনও মন্তব্য করতে দ্বিধা করবেন না।

উদাহরণ

উদাহরণ হিসাবে আমি দ্রুত (অজলিত) পাইথন 3 সমাধান একসাথে ফেলেছি - আপনি এটি repl.it এ পরীক্ষা করতে পারেন ।

code-golf  array-manipulation  integer 
— FlipTack
সূত্র
স্ট্রিং ভিত্তিক উত্তরের জন্য একক অঙ্কের চেয়ে বড় সংখ্যার সাথে একটি টেস্টকেস যুক্ত করুন।
— orlp
@orlp ভাল ধারণা।
— ফ্লিপট্যাক
2
আমরা কি একটি নির্দিষ্ট সর্বোচ্চ গভীরতা অনুমান করতে পারি? বলো, 16?
— orlp
@ অরলপ আমি হ্যাঁ বলতে যাচ্ছি, সর্বাধিক নেস্টেড গভীরতা 10 হবে, কারণ আমি আপনার ভাষার সীমাবদ্ধতার চেয়ে আপনার অ্যালগরিদম এবং পদ্ধতি প্রয়োগের ক্ষেত্রে আরও আগ্রহী। থ্রেড এখন আপডেট করবে।
— ফ্লিপট্যাক
আমি কি স্ট্রিং হিসাবে আউটপুট দিতে পারি?
— রোহান ঝুনঝুনওয়ালা

উত্তর:

4

ব্র্যাচল্যাগ , 16 বাইট

:{##:0&:ga|g}ac|

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

ব্যাখ্যা

Example input: [1:[2:3]]

:{          }a     Apply the predicate below to each element of the list: [[1]:[[2]:[3]]]
              c    Concatenate: Output = [1:[2]:[3]]
               |   Or: Input = Output = []

  ##                 Input is a list: e.g. Input = [2:3]
    :0&              Call recursively the main predicate with this input: [2:3]
       :ga           Group each element in a list: Output = [[2]:[3]]
          |          Or (not a list): e.g. Input = 1
           g         Group into a list: Output = [1]
— Fatalize
সূত্র
Zটিআইও-তে তর্ক কী করে ? এটি ছাড়া এটি সত্য / মিথ্যা দিয়ে আউটপুট বলে মনে হচ্ছে যা Zবাইট গণনায় এটির মতো মনে হচ্ছে ।
— ফ্লিপট্যাক
@ ফ্লিপট্যাক ব্র্যাচলগকে Zবলে যে আউটপুট আর্গুমেন্টটি একটি পরিবর্তনশীল। এটি এই পরিবর্তনশীল যা ফলাফলের ফলাফলের সাথে একীভূত হয়। আপনি এটি সরিয়ে ফেললে এটি ব্র্যাচল্যাগকে বলে যে আউটপুটটি একটি বেনামে পরিবর্তনশীল, এবং এর পরিবর্তে মুখ্য প্রেডিকেট সফল হয় বা ব্যর্থ হয় কিনা তা মুদ্রণ করবে। এটি প্রোলোগের মতোই যেখানে ফলাফলটি ভেরিয়েবলে "পুট" করা হয়।
— ফ্যাটালাইজ করুন
ঠিক আছে :) সুন্দর উত্তর!
— ফ্লিপট্যাক
19

গণিত, 24 21 বাইট

##&@@List/@#0/@#&/@#&

বা এর মধ্যে একটি:

##&@@List/@#&/@#0/@#&
##&@@List@*#0/@#&/@#&
##&@@List/@#&@*#0/@#&

ব্যাখ্যা

এটি এত সংক্ষিপ্ত হওয়ার কারণ হ'ল এটি মূলত এমন একটি পুনরাবৃত্তি যা একটি স্পষ্ট বেসের প্রয়োজন হয় না।

এখানে প্রচুর সিনট্যাকটিক চিনি রয়েছে, সুতরাং আসুন এটির উদ্বোধন করে শুরু করা যাক। &এর বামে একটি নামহীন ফাংশন চিহ্নিত করে, যার যুক্তি হিসাবে লেখা আছে #। এই ফাংশনের অভ্যন্তরে #0ফাংশনটি নিজেই বোঝায়, যা একজনকে নামহীন পুনরাবৃত্ত ফাংশন লিখতে দেয়। তবে আসুন অভ্যন্তরীণ ফাংশনটিকে একটি নাম দিয়ে এবং এটিকে বাইরে এনে শুরু করুন:

f[x_] := ##& @@ List /@ f /@ x
f /@ # &

অন্যান্য গুরুত্বপূর্ণ সিনট্যাকটিক চিনি f/@xযা সংক্ষিপ্ত Map[f, x]অর্থাৎ এটি fপ্রতিটি উপাদানকে কল করে x। f[x_] := ... f /@ xঅসীম পুনরাবৃত্তির কারণ না হওয়ার কারণ হ'ল যে কোনও পরমাণুর উপরে কোনও কিছু ম্যাপিংয়ের ফলে ফাংশনটি কল না করেই পরমাণুটি অপরিবর্তিত থাকে। সুতরাং, আমাদের স্পষ্টভাবে বেস কেস (বর্তমান উপাদানটি একটি পূর্ণসংখ্যা) পরীক্ষা করার দরকার নেই।

সুতরাং ফাংশনটি fপ্রথমে ভিতরে গভীর তালিকাতে পুনরাবৃত্তি করে x, যার বিন্দুতে f/@কোনও অপ-বিকল্প হয়। তারপরে আমরা এটিতে কল বলি ##& @@ List /@। Listতালিকার উপরে ম্যাপিং প্রতিটি উপাদানকে পৃথক তালিকায় কেবল মোড়ানো করে, তাই {1, 2, 3}হয়ে যায় {{1}, {2}, {3}}। তারপরে আমরা এটিতে প্রয়োগ ##& করি, যার অর্থ মাথা (অর্থাৎ বাইরের তালিকা) প্রতিস্থাপন হয়ে যায় ##&, সুতরাং এটি রূপান্তরিত হয় ##&[{1}, {2}, {3}]। তবে ##&কেবল এটি হিসাবে আর্গুমেন্টগুলি ফেরত দেয় Sequence(যা আপনি একটি মোড়িত তালিকা হিসাবে বা অন্য ভাষায় "স্প্ল্যাট" অপারেটর হিসাবে বাছাই করতে পারেন)।

সুতরাং ##& @@ List /@একটি তালিকাতে {1, 2, 3}পরিণত হয় {1}, {2}, {3}(যেমন, শেষ জিনিসটি আসলে মাথায় জড়িয়ে থাকে Sequenceতবে আমরা যে কোনও জায়গায় মানটি ব্যবহার করার সাথে সাথে তা অদৃশ্য হয়ে যায়)।

এটি fইতিমধ্যে কেন চ্যালেঞ্জের সমাধান নয় এমন প্রশ্নটি ফেলে। সমস্যাটি হচ্ছে বহিরাগতের তালিকাটি আলাদাভাবে চিকিত্সা করা উচিত। আমাদের যদি ইনপুট থাকে তবে {{1, 2}, {3, 4}}আমরা চাই {{1}, {2}, {3}, {4}}এবং চাই না {{1}}, {{2}}, {{3}}, {{4}} । আমার আসল সমাধানটি আর্গুমেন্টের তালিকা হিসাবে চূড়ান্ত ফলাফলটি পাস করার মাধ্যমে এটি স্থির করেছে Joinযা তালিকার বহিরাগত স্তরটিকে পুনরুদ্ধার করবে তবে এইটি কেবল আউটপুটে একটি মানচিত্রে f নিজেকে ব্যবহার করে বাহ্যিক স্তরকে এড়িয়ে চলে । সুতরাং fকেবলমাত্র বহিরাগত তালিকার পৃথক উপাদানগুলিতে প্রয়োগ করা হয় এবং কখনই সেই তালিকাকে স্পর্শ করতে পারে না।

অন্য তিনটি সমাধান হিসাবে, প্রথমটি কেবল পুনরাবৃত্তি প্রয়োগ করে fযার বাইরেও কাজ করে। অন্য দুটি সমাধান Mapপ্রথমে দুটি ফাংশন রচনা করে এবং তারপরে ফলাফলটি একবারে ম্যাপিংয়ের মাধ্যমে পুনরাবৃত্ত অপারেশন এড়ায়।

— মার্টিন ইন্ডার
সূত্র
8

জে , 19 18 বাইট

(<@]/@,~>)S:0 1{::

এটি একটি বেনাম ক্রিয়া যা বাক্সযুক্ত অ্যারে গ্রহণ করে এবং ফেরত দেয় যা নেস্টেড অ্যারেগুলির জে এর (বরং জটিল) সংস্করণ। এটি দেখুন সমস্ত পরীক্ষার কেস পাস।

ব্যাখ্যা

এটি কিছুটা বিদেশী ক্রিয়াকলাপ {::( মানচিত্র ) এবং S:( স্প্রেড ) ব্যবহার করে যা বাক্সযুক্ত অ্যারেগুলিতে কাজ করে। {::প্রতিটি পাতাকে সেই পাতার বাক্সযুক্ত পথের সাথে প্রতিস্থাপন করে। S:প্রদত্ত নেস্টিং গভীরতায় একটি প্রদত্ত ক্রিয়া প্রয়োগ করে, তারপরে ফলাফলগুলিকে অ্যারেতে ছড়িয়ে দেয়।

(<@]/@,~>)S:0 1{::  Input is y.
(        )          Let's look at this verb first.
        >           Open the right argument,
      ,~            append the left argument to it,
    /               then reduce by
 <@]                boxing. This puts the left argument into as many nested boxes
                    as the right argument is long.
                    This verb is applied to y
               {::  and its map
            0 1     at levels 0 and 1.
                    This means that each leaf of y is paired with its path,
                    whose length happens to be the nesting depth of y,
                    and the auxiliary verb is applied to them.
          S:        The results are spread into an array.
— Zgarb
সূত্র
3

আর, 199 বাইট

function(l){y=unlist(l);f=function(x,d=0){lapply(x,function(y){if(class(y)=='list'){f(y,d=d+1)}else{d}})};d=unlist(f(l));lapply(1:length(d),function(w){q=y[w];if(d[w]){for(i in 1:d[w])q=list(q)};q})}

এই প্রশ্ন ছিল হার্ড। আরের তালিকা কিছুটা অদ্ভুত এবং সাবলিস্টের সমস্ত উপাদানকে লুপ করা একেবারে সোজা নয়। সেই তালিকার গভীরতা নির্ধারণ করার পরেও এটি সোজা নয়। তারপরে চ্যালেঞ্জটি হয়ে উঠেছে সমস্ত উপাদানকে পৃথক করে তালিকাটি পুনরায় তৈরি করা, সুতরাং আমাদেরও একটি নির্দিষ্ট গভীরতার একটি তালিকা অভিযোজিতভাবে তৈরি করার জন্য প্রয়োজন।

সমাধান দুটি বড় অংশ নিয়ে গঠিত। একটি পুনরাবৃত্ত ফাংশন যা সমস্ত তালিকার উপরে লুপ করে এবং গভীরতা রেকর্ড করে:

  f=function(x,d=0){
    lapply(x,function(y){
      if(class(y)=='list'){
        f(y,d=d+1)
      } else {
        d
      }})
  }

যখন ভেক্টরের প্রতিটি প্রবেশের গভীরতা থাকে unlist(l), এতে সঞ্চিত থাকে d, তখন আমরা স্পষ্টতই একটি তালিকা তৈরি lapplyকরি এবং নিম্নলিখিত ফাংশনটি দিয়ে এটি পূরণ করি:

  lapply(1:length(d),function(w){
    q=y[w]
    if(d[w]){
      for(i in 1:d[w]){
        q=list(q)
      }
    }
    q
  })

এই প্রয়োগ কলটিতে, আমরা qতালিকায় প্রবেশের মান সহ একটি অবজেক্ট তৈরি করি , এর গভীরতা পরীক্ষা করে দেখুন এবং এটি ননজারো কিনা। যদি এটি শূন্য হয়, আমরা কেবল এটি একটি সংখ্যার মান হিসাবে রেখে দিতে পারি। যদি এটি শূন্য-না হয়, তবে আমাদের সেই পরিমাণ তালিকাতে বাসা বাঁধতে হবে। সুতরাং আমরা একটি লুপ dবার কল এবং বার বার কল q=list(q)।

lapplyতারপরে এই সমস্ত মানগুলিকে qএকটি তালিকায় রাখে , পছন্দসই আউটপুট তৈরি করে।

যথাযথ ব্যবধান এবং এর সাথে সম্পূর্ণ প্রোগ্রাম:

function(our.list){
  values <- unlist(our.list)
  f <- function(part.list, depth = 0){
    lapply(part.list, function(y){
      if(class(y)=='list'){
        f(y, depth <- depth + 1)
      } else {
        return(depth)
      }})
  }
  depths <- unlist(f(our.list))
  new.list <- lapply(1:length(depths), function(w){
    q <- values[w]
    if(depths[w] != 0){
      for(i in 1:depths[w]){
        q <- list(q)
      }
    }
    return(q)
  })
  return(new.list)
}
— JAD
সূত্র
ভাল এক, পরীক্ষার ক্ষেত্রে প্রাথমিক পাইথন সমাধানটি দিয়ে আমি এই পদ্ধতিটি ব্যবহার করেছি :)
— ফ্লিপট্যাক
is.list(y)এর বদলে class(y)=='list'? এটি সত্যই কাজ করবে তা যাচাই করতে পারছি না।
— জিউসেপে
— জিউসেপ
3

রেটিনা , 34 বাইট

+`(.(?>()\[|(?<-2>)]|.)+)\2,
$1],[

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

— মার্টিন ইন্ডার
সূত্র
কিভাবে (?<-2>)কাজ করে?
— ক্রিটিক্সী লিথোস
@ ক্রিতিক্সিলিথোস এটি একটি ভারসাম্যপূর্ণ গ্রুপ । এটি ক্যাপচার স্ট্যাক 2 থেকে পপ হয় যা আমাকে বর্তমান নীড়ের গভীরতার উপর নজর রাখতে দেয়।
— মার্টিন এন্ডার
2

সি (জিসিসি), 147 বাইট

d=0,l,i;
P(n,c){for(;n--;)putchar(c);}
main(c){for(;~(c=getchar());l=i)i=isdigit(c),P((l<i)*d,91),P(i,c),P((l>i)*d,93),P(l>i,32),d+=(92-c)*(c>90);}

উদাহরণ ইনপুট:

1 [23 3] [40 4 [5 2] 1]

উদাহরণ আউটপুট:

1 [23] [3] [40] [4] [[5]] [[2]] [1]
— orlp
সূত্র
2

স্ট্যাকড , নন-কেপটিং, 25 বাইট

{e d:e$wrap d 1-*}cellmap

এটি এমন একটি ফাংশন যাতে এটি স্ট্যাকের শীর্ষ সদস্যকে সংশোধন করে। আপনি যদি একটি bonafide ফাংশন চান, শুধু যোগ [এবং ]শুরুতে এবং শেষে। এখানে চেষ্টা করুন!

এখানে একটি পঠনযোগ্য সংস্করণ:

{ arr :
  arr { ele depth :
    ele   $wrap depth 1- * (* execute wrap n times, according to the depth *)
  } cellmap (* apply to each cell, then collect the results in an array *)
} @:a2
(1 (2 3) (4 4 (5 2) 1)) a2 out

পরীক্ষা ক্ষেত্রে:

(1 (2 3) (4 4 (5 2) 1))    (* arg on TOS *)
{e d:e$wrap d 1-*}cellmap
out                        (* display TOS *)

নিউলাইন ছাড়া আউটপুট:

(1 (2) (3) (4) (4) ((5)) ((2)) (1))
— কনর ও ব্রায়ান
সূত্র
কি *কোড ব্লক আর্গুমেন্ট প্রাপ্ত করতে চান?
— ডাউনওয়েট
@ ডাউনগোট এই ক্ষেত্রে এটি যুক্তির d-1সময়গুলিকে আবৃত করে । $funcহ'ল এমন একটি ফাংশন যা হেরফের করা যায়।
— কনর ও'ব্রায়েন
2

পিএইচপি, 101 94 বাইট

@ ক্রিস্টফের জন্য 1 বাইট ধন্যবাদ রক্ষা করেছে, এর দ্বারা অনুপ্রাণিত আরও 6 টি সঞ্চয় করেছে।

function s($a){foreach($a as$b)if($b[0])foreach(s($b)as$c)$r[]=[$c];else$r[]=$b;return$r?:[];}

পুনরাবৃত্তি ফাংশন, বেশ সোজা এগিয়ে

ভাঙ্গন

function s($a)
{
    foreach($a as$b)                // loop through array
        if($b[0])                       // if element is array
            foreach(s($b)as$c)$r[]=[$c];    // append separated elements to result
        else$r[]=$b;                    // else append element to result
    return$r?:[];                   // return result, empty array for empty input
}
— তিতাস
সূত্র
ফলাফল কোথা থেকে শুরু হয়?
— নিল
@ নীল: পিএইচপি স্পষ্ট সূচনা প্রয়োজন হয় না। হয় $rলুপে উপাদান পায় বা ফাংশনটি একটি খালি অ্যারে দেয়। এটি বিজ্ঞপ্তি দিতে পারে তবে সেগুলি ডিফল্ট কনফিগারেশনে মুদ্রিত নয়।
— তিতাস
এর অর্থ এই নয় যে আপনি কেবল একবার কল করতে সক্ষম হবেন?
— নিল
1
আপনি ভাল হিসাবে পাগল পেতে পারে: !cos()। প্রতিটি অ্যারে এবং একটি ফ্লোটের জন্য cos()ফেরত দেয় null! = 0 প্রতিটি পজিটিভ পূর্ণসংখ্যার জন্য মানে ... সতর্কতার জন্য কে যত্ন করে?
— ক্রিস্টোফ
1
@ ক্রিসটফ: সতর্কতাগুলি মুদ্রিত হয়, নোটিশগুলি হয় না (থি ডিফল্ট কনফিগারেশনে)। তবে এটি দুর্দান্ত ধারণা! চালু is_int: শর্তটি বিপরীত করা কিছুই সংরক্ষণ করে না; আমি এর মধ্যে একটি জায়গা দরকার elseএবং foreach। বাট: $b[0]একটি পূর্ণসংখ্যা জন্য NULL।
— টাইটাস
2

পাইথন 2, 122 106 বাইট

খুব ভয়ঙ্কর স্কোর, কেবল একটি সরল বাস্তবায়ন।

16 জ্যাকেট বাঁচাতে সহায়তার জন্য @ জাচারি টিকে ধন্যবাদ!

def x(l,a=[],d=0):
 n=lambda b:b and[n(b-1)]or l
 if'['in`l`:[x(e,a,d+1)for e in l];return a
 else:a+=n(d)

xচালানোর জন্য একটি যুক্তি দিয়ে কল করুন । কোনও কারণে এটি কেবল একবার চালানো যেতে পারে।

— নীল
সূত্র
আপনি পরিবর্তন a+=[n(l,d)]করতে পারবেন a+=n(l,d),(পিছনের কমা নোট করুন)
— ফ্লিপট্যাক
আপনি এমনকি নিযুক্ত করা প্রয়োজন t?
— জাকারি
আপনি যখন একাধিকবার কল করবেন তখন কি এটি কাজ করে?
— জাকারি
আপনি nসর্বদা ফাংশনটিতে যেতে পারেন এবং প্রথম যুক্তিটি সরাতে পারেন যেহেতু এটি সর্বদা হতে চলেছে l।
— জাকারি
— জাকারিয়া
2

জাভাস্ক্রিপ্ট (ফায়ারফক্স 30-57), 53 বাইট

f=a=>[for(e of a)for(d of e.map?f(e):[e])e.map?[d]:d]

আমার এখনও অবধি সেরা ES6 উত্তরটি 76 বাইট:

f=(a,r=[],d=0)=>a.map(e=>e.map?f(e,r,d+1):r.push((n=d=>d?[n(d-1)]:e)(d)))&&r
— নিল
সূত্র
2
উভয় কোড ব্লকে, আমি মনে করি আপনি অগ্রণী বাদ দিয়েছেন f=।
— কনর ও'ব্রায়েন
@ কনরোও ব্রায়ান আবারো ...
— নিল
1

পার্ল 6 , 60 47 বাইট

sub f{[$_~~List??|([$_] for .&f)!!$_ for |$^a]}

( এটি অনলাইনে চেষ্টা করুন। )

ব্যাখ্যা:

  1. [... for |$^a]: ইনপুট অ্যারের উপরে আইট্রেট করুন এবং এটি থেকে একটি নতুন অ্যারে তৈরি করুন।
  2. $_ ~~ List ?? ... !! ...: প্রতিটি উপাদানগুলির জন্য, এটি নিজেই একটি অ্যারে কিনা তা পরীক্ষা করুন।
  3. |([$_] for .&f): যদি উপাদানটি একটি অ্যারে হয় তবে পুনরাবৃত্তভাবে এতে ফাংশনটি প্রয়োগ করুন, সেই পুনরাবৃত্ত কল থেকে ফিরে আসা নতুন অ্যারের উপাদানগুলির উপর পুনরাবৃত্তি করুন, প্রতিটি উপাদানকে তার নিজস্ব অ্যারেতে মোড়ক করুন এবং সেগুলি বাইরের তালিকায় স্লিপ করুন।
  4. $_: উপাদানটি যদি অ্যারে না হয় তবে যেমন হয় তেমন পাস করুন।
— smls
সূত্র
1

হাস্কেল, 71 বাইট

data L=N Int|C[L] 
d#C l=((C .pure.d)#)=<<l
d#n=[d n]
f(C l)=C$(id#)=<<l

আবার আমাকে নিজের তালিকার প্রকারটি সংজ্ঞায়িত করতে হবে, কারণ হাস্কেলের নেটিভ তালিকাটি নির্বিচারে বাসা বাঁধতে পারে না। এই নতুন ধরণের Lকোনও ফাংশন থেকে ফিরে আসতে পারে তবে এটি ডিফল্ট হিসাবে মুদ্রণ করা যায় না, ফলে ফলাফল দেখার showজন্য আমি উদাহরণটির সংজ্ঞা দিই L:

instance Show L where
  show (N n)=show n
  show (C l)=show l

এখন আমরা আরপিএলে কিছু পরীক্ষা করতে পারি:

*Main> f $ C[N 1, C[N 2, N 3], C[N 4, N 4, C[N 5, N 2], N 1]]
[1,[2],[3],[4],[4],[[5]],[[2]],[1]]

*Main> f $ C[C[N 6, C[C[N 7]]]]
[[6],[[[7]]]]

এটি কীভাবে কাজ করে: একটি সাধারণ পুনরাবৃত্তি যা নির্মাতাদের ফাংশন হিসাবে নীড়ের স্তরটি পাস করে C। আমরা পরিচয় ফাংশন দিয়ে শুরু করি idএবং যখনই কোনও তালিকা থাকে (-> প্যাটার্ন ম্যাচ d#C l=) আমরা তালিকার সমস্ত উপাদানগুলির পুনরাবৃত্ত কলগুলিতে C(-> C .pure.d) এর আরও একটি স্তর যুক্ত করি #। যদি আমাদের কোনও সংখ্যার মুখোমুখি হয় তবে আমরা কেবল সংখ্যাটিতে নেস্টিং-লেভেল-ফাংশনটি প্রয়োগ করি d।

— nimi
সূত্র
0

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

বেনামে ট্যাসিট প্রিফিক্স ফাংশন। নেস্টেড এপিএল তালিকাটিকে আর্গুমেন্ট হিসাবে গ্রহণ করে এবং নেস্টেড এপিএল অ্যারে প্রদান করে।

∊{⊃⊂⍣⍵,⍺}¨{⊃¨(j∊⎕D)⊆+\-⌿'[]'∘.=j←⎕JSON⍵}

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

{… } নিম্নলিখিত সুস্পষ্ট ফাংশন প্রয়োগ করুন যেখানে যুক্তিটি উপস্থাপন করে⍵ :

 ⎕JSON⍵ যুক্তিটি JSON এ রূপান্তর করুন

 j← সঞ্চয় j

 '[]'∘.= টেবিল যেখানে j সমান খোলা (শীর্ষ সারি) এবং বন্ধ (নীচের সারি) বন্ধনীগুলি

 -⌿ শীর্ষ সারি বিয়োগ তল সারি (উল্লম্ব পার্থক্য হ্রাস)

 +\ সংক্ষিপ্ত যোগ (এটি প্রতিটি চরিত্রের জন্য নীড়ের স্তর দেয়)

 (...)⊆  বিভাজন, যখনই 1 ইন 1 এর 1 এর আগে না হয় তখনই একটি নতুন পার্টিশন শুরু করা ...

  j∊⎕D যেখানে প্রতিটি চরিত্রই ডিj এর সেট এর সদস্য আইজিটসের

 ⊃¨ প্রত্যেকটির প্রথমটি চয়ন করুন (এটি বহু-অঙ্কের প্রতি প্রতি নীড়ের স্তর দেয়)

∊{... }¨ প্রতিটি পাখির স্তর (নিম্নলিখিত ফাংশন প্রয়োগ ⍵,) থেকে সংশ্লিষ্ট element ব্যবহার ε nlisted (চ্যাপ্টা) আর ডানদিকের আর্গুমেন্ট হিসাবে যুক্তি ( ⍺):

 ,⍺ সংখ্যাটি উত্সাহিত (অনুকূল করা) (কারণ স্কেলারগুলি সংযুক্ত করা যায় না)

 ⊂⍣⍵ ঘিরা ⍵ বার

 ⊃ প্রকাশ (কারণ অন্তর্নিহিত তালিকাটি নিজেই একটি ঘের)

* সঙ্গে Dyalog ক্লাসিক ব্যবহার ⎕ML←3(অনেক সিস্টেমে ডিফল্ট), বদলে ⊂জন্য ⊆এবং ↑জন্য ⊃। Tio!

— আদম
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.