সরল একটি অ্যারে

22

ইনপুট

একটি অ্যারে যাতে অ্যারে বা ধনাত্মক, একটানা, আরোহী পূর্ণসংখ্যার সমন্বয় করতে পারে। অ্যারেগুলির মধ্যে অনেকগুলি অ্যারে থাকতে পারে এবং এ জাতীয় আরও অনেক কিছু। কোনও অ্যারে খালি থাকবে না।

আউটপুট

এই অ্যারে সরলীকৃত

কিভাবে একটি অ্যারের সরল করা যায়

আমরা অ্যারে ব্যবহার করব, [1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]] উদাহরণ হিসাবে ।

প্রথমে আমরা পরীক্ষা করে দেখি যে মানগুলি কত গভীরভাবে নেস্ট করা হয়। এই গভীরতায় গভীরতা এবং সংখ্যাগুলি এখানে:

0  1
1  2 3 9
2  4 7
3  5 6
5  8

আউটপুট অ্যারেটি আমরা মূল অ্যারেতে সংখ্যাগুলি নিয়ে বেঁধে, সেগুলি কত গভীরভাবে বাসা বেঁধে থাকে তার তালিকাভুক্ত করে এবং তারপরে তাদের উপাদানগুলির মূল গভীরতার গভীরতায় গ্রুপগুলি বাসাতে পারি। আরোহী ক্রম এবং আরোহণের গভীরতায় সংখ্যাগুলি সাজান।

সুতরাং, আমাদের আউটপুট হয় [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]

উদাহরণ

[1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]] -> [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]
[[[1]], [2, [3]], 4, [5, [6, [7, [8], [9, [[10]]]]]]] -> [4, [2, 5], [[1, 3, 6]], [[[7]]], [[[[8, 9]]]], [[[[[[10]]]]]]]
[1] -> [1]
[1, [2], [[3]], [[[4]]], [[[[5]]]]] -> [1, [2], [[3]], [[[4]]], [[[[5]]]]]
[1, [[[[2], 3]]] [[4]]] -> [1, [[4]], [[[3]]], [[[[2]]]]]
code-golf  array-manipulation 
— ড্যানিয়েল
সূত্র
আউটপুট কি নমনীয়? বিভিন্ন লাইনের সংখ্যার মতো, যেখানে প্রতিটি লাইন এক স্তর; বা অন্যান্য অ্যারে ডিলিমিটার / বিভাজক
— লুইস মেন্ডো
— নিমি
@ লুইস মেন্ডো, হ্যাঁ এটি নমনীয়
— ড্যানিয়েল
আপনি 8লাইনে প্রায় একটি বন্ধনী জুড়ি মিস করছেন So, our output is.....। তবে আপনি উদাহরণ স্নিপেটে এটি স্থির করেছেন fixed
— এসবিসিত করুন
2
কিছু উত্তর উপাদান না দিয়ে বাসা বাঁধার জন্য একটি খালি লাইন আউটপুট দেয়। এই জাতীয় ক্ষেত্রে যেমন একটি খালি অ্যারে ফিরিয়ে দেওয়া ঠিক হবে, যেমন আপনি প্রথম উদাহরণ হিসাবে [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[]]]], [[[[[8]]]]]]?
— নিমি

উত্তর:

1

জেলি , 8 বাইট

fFṄḟ@;/ß

আউটপুট হল প্রতি লাইনে এক স্তর, উপাদান ছাড়াই খালি লাইন। এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

fFṄḟ@;/ß  Main link. Argument: A (array)

 F        Flat; yield all integers (at any level) in A.
f         Filter; intersect A with the integers, yielding those at level 0.
  Ṅ       Print the filtered array and a linefeed. Yields the filtered array.
     ;/   Reduce by concatenation.
          This decreases the levels of all integers at positive levels by 1.
   ḟ@     Swapped filter-false; remove the integers at level 0 in A from the array
          with decreased levels.
       ß  Recursively call the main link on the result.
          The program stops once A is empty, since ;/ will result in an error.
— ডেনিস
সূত্র
3

জাভাস্ক্রিপ্ট (ES6), 139 109 বাইট

f=(a,v=b=>a.filter(a=>b^!a[0]))=>a[0]?v().concat((a=f([].concat(...v(1))),b=v())[0]?[b]:[],v(1).map(a=>[a])):[]

উদাহরণ ইনপুট ব্যবহার করে ব্যাখ্যা: vএকটি সহায়ক পদ্ধতি যা অ্যারেগুলি (প্যারামিটার সহ 1) বা মানগুলি (কোনও পরামিতি ছাড়াই) প্রদান করে। আমরা শুরু করি a = [1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]], যা কিছুই নয়। আমরা অ্যারে ফিল্টার আউট, দিচ্ছি [1]। তারপরে আমরা পুনরাবৃত্তভাবে একসাথে একত্রিত অ্যারেগুলিতে নিজেকে কল করি, যা [2, 3, [4], [[5, 6], 7, [[[8]]]], 9]ফলাফল [2, 3, 9, [4, 7], [[5, 6]], [[[[8]]]]]। আমরা আবার অ্যারে ফিল্টার আউট, যা আমাদের আউটপুট এর দ্বিতীয় পদ দেয় [2, 3, 9], তবে এখানে খালি অ্যারে না carefulোকাতে সতর্ক থাকতে হবে। এটি তাদের অ্যারের [4, 7], [[5, 6]], [[[[8]]]]ভিতরে অ্যারেগুলি আবৃত করে আউটপুটগুলিতে সংযুক্ত করে রাখে, ফলস্বরূপ [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]।

— নিল
সূত্র
একটি উপাধি দিয়ে কয়েকটি বাইট সংরক্ষণ করতে সক্ষম হতে পারে filter। হতে শুরু হতে পারেF=(x,y)=>x.filter(y)
— সাইয়েস
@ কিয়েস শেষ হয়েছে 30 এ পরিণত!
— নীল
এটি করার জন্য আপনার অবশ্যই কিছু গল্ফ বাকি আছে। আমার মনে হয় আপনি নিরাপদে প্রতিস্থাপন করতে পারেন [].concat(...v(1))সঙ্গে v(1)সংরক্ষণ 14 বাইট। সম্ভবত আরও কয়েকটি জিনিস রয়েছে তবে আমার মাথায় নেস্টেড বন্ধনীগুলির ট্র্যাক রাখতে আমার বেশ কষ্ট হচ্ছে।
— প্যাট্রিক রবার্টস
1
@ পেট্রিকরোবার্টস এর [].concat(...v(1))কাছে একেবারেই আলাদা জন্তু v(1), নইলে আমি তা করতাম না! একটি সাধারণ উদাহরণের জন্য, a = [2, [3], [[4]]]তবে v(1) = [[3], [[4]]]তবে বিবেচনা করুন [].concat(...v(1)) = [3, [4]]।
— নীল
@ নীল ওহ, আমার মুখ খোলার আগে বাহ সম্পর্কে আমার পরামর্শটি সত্যিই পরীক্ষা করা উচিত ছিল। আমার মনে হচ্ছে যদিও এটি করার একটি আরও ছোট উপায় হওয়া উচিত ..
— প্যাট্রিক রবার্টস
2

05 এ বি 1 ই , 27 26 25 21 বাইট

D˜gFvyydi„ÿ ?}}¶?.gG«

এটি অনলাইন চেষ্টা করুন! ( .gটিআইও তে নেই বলে কিছুটা পরিবর্তিত হয়েছে )

ব্যাখ্যা

D˜gF                    # flattened input length times do
    vy                  # for each y current level of list
      ydi„ÿ ?}          # if y is a digit, print with space
              }         # end v-loop
               ¶?       # print newline
                 .g     # calculate length of stack (this should be .g but I can't test)
                   G«   # length stack times, concatenate items on stack

প্রধান কৌশলটি হ'ল নেস্টেড অ্যারের প্রতিটি সম্ভাব্য স্তরের উপর লুপ করা এবং একটি সারিতে কোনও অঙ্ক মুদ্রণ করা, যখন অ-অঙ্কগুলি (তালিকা) একটি তালিকায় এক স্তরের কম নেস্টেড রেখে।

— Emigna
সূত্র
2

পার্ল, 52 বাইট

কেবল একটি পুনরাবৃত্ত সাব্রোটাইন। (পার্ল উত্তরের জন্য অস্বাভাবিক, আমি জানি ..)

sub f{say"@{[grep!ref,@_]}";@_&&f(map/A/?@$_:(),@_)}

এটিকে কল করুন:

$ perl -E 'sub f{say"@{[grep!ref,@_]}";@_&&f(map/A/?@$_:(),@_)}f(1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9])'
1
2 3 9
4 7
5 6

8

আউটপুটটির প্রতিটি লাইন অ্যারের গভীরতার স্তরের সাথে সামঞ্জস্য করে (সুতরাং উপরের উদাহরণে খালি রেখা)।

এটি আরও কয়েকটি বাইটের জন্য পুরো প্রোগ্রামে রূপান্তরিত হতে পারে: ইনপুটটিকে পার্ল অ্যারে রূপান্তর করতে -nফ্ল্যাগ এবং একটি eval( @{ }ইনপুটটিকে একটি অ্যারে রূপান্তর করতে এবং একটি অ্যারেরেফ না) যুক্ত করুন:

perl -nE 'sub f{say"@{[grep!ref,@_]}";@_&&f(map/A/?@$_:(),@_)}f(@{+eval})' <<< "[1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]"

আমার পূর্ববর্তী পদ্ধতিটি কিছুটা দীর্ঘ ছিল (65 বাইট), তবে এখনও আকর্ষণীয়, তাই আমি এটি এখানে দেব: 

perl -nE '/\d/?push@{$;[$d-1]},$_:/]/?$d--:$d++for/\[|]|\d+/g;say"@$_"for@' <<< "[1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]]"
— দাদা
সূত্র
2

জাভাস্ক্রিপ্ট (ES6) 121 144 152

সম্পাদন করা অনেকগুলি সংশোধন করা হয়েছে, 1 বাইট সংরক্ষিত thx প্যাট্রিক রবার্টস এবং আরও 21 জন সবেমাত্র কোডটি পর্যালোচনা করছে

ইনপুট এবং আউটপুটে অ্যারেগুলিতে পুনরাবৃত্ত ফাংশন কাজ করছে। আমি আউটপুট অ্যারের মধ্যে একক উপাদান যেমন গভীরতা 1 উপাদান থাকার অনুরোধ মত করবেন না (বৃহত্তর মাত্রা এক উপাদান হিসেবে গোষ্ঠীবদ্ধ করে যখন): [l1,l1, [l2...], [[l3...]] ]। যদিও এটি আরও সরাসরি হবে:[ [l1...], [[l2...]], [[[l3...]]] ]

f=(l,d=0,r=[])=>l.map(v=>v[0]?f(v,d+1,r):r[d]=[...r[d]||[],v])
r.reduce((r,v,d)=>d?[...r,(n=d=>d-->1?[n(d)]:v)(d)]:v,[])

পাঠযোগ্যতার জন্য নিউলাইন যুক্ত হয়েছে।

কিছু নোট: প্রতিটি পুনরাবৃত্তির কলটিতে লাইন 2 বারবার মূল্যায়ন করা হয় তবে পুনরাবৃত্তির শেষে কেবল শেষ পুনরাবৃত্তিটি দরকারী। লাইন 2
এ থাকা বিশেষ হ্যান্ডলিং d==0স্তর 1 উপাদানগুলির জন্য অসাধারণতার যত্ন নেয়। রিকার্সিভ ফাংশন অ্যারে আউটপুটে পাখির পরিচালনা
n

পরীক্ষা

f=(l,d=0,r=[])=>l.map(v=>v[0]?f(v,d+1,r):r[d]=[...r[d]||[],v])
&&r.reduce((r,v,d)=>d?[...r,(n=d=>d-->1?[n(d)]:v)(d)]:v,[])

console.log=x=>O.textContent+=x+'\n'

test=[
 [ 
   [1, [2,3], 4], /* -> */ [1, 4, [2,3]]
 ]
,[
   [1, [2, 3], [[4]], [[[5, 6], 7, [[[8]]]], 9]], 
   // ->
   [1, [2, 3, 9], [[4, 7]], [[[5, 6]]], [[[[[8]]]]]]
 ]
,[
  [[[1]], [2, [3]], 4, [5, [6, [7, [8], [9, [[10]]]]]]],
  // ->
  [4, [2, 5], [[1, 3, 6]], [[[7]]], [[[[8, 9]]]], [[[[[[10]]]]]]] 
 ]
,[  
  [1], /* -> */ [1]
 ]
,[  
  [1, [2], [[3]], [[[4]]], [[[[5]]]]],
  // ->
  [1, [2], [[3]], [[[4]]], [[[[5]]]]]
 ]
,[  
  [1, [[[[2], 3]]], [[4]]],
  [1, [[4]], [[[3]]], [[[[2]]]]]
]]

test.forEach(t=>{
  var i=t[0], k=t[1], r=f(i),
      si=JSON.stringify(i),
      sr=JSON.stringify(r),
      sk=JSON.stringify(k)
  
  console.log((sr==sk?'OK ':'KO ')+si + " => " + sr)
})
<pre id=O></pre>
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
1
এখানে কেবল নেস্টেড অ্যারে এবং ধনাত্মক পূর্ণসংখ্যা রয়েছে এবং এটি নির্দিষ্ট করা হয়েছে যে ইনপুটটিতে থাকা অ্যারেগুলির কোনওটিই শূন্য নয়, আপনার তৃতীয় অপারেটরের v[0]পরিবর্তে একটি সহজ পরীক্ষা হবেv.map । 1 বাইট সংরক্ষণ করে।
— প্যাট্রিক রবার্টস
@ পেট্রিকরোবার্টস ধন্যবাদ ধন্যবাদ
— edc65
1

জাভাস্ক্রিপ্ট (ES6) 168 বাইট

f=a=>(s=[],b=-1,k=0,a.replace(/\d+|\[|\]/g,a=>a=='['?b++:a==']'?b--:(s[b]=s[b]||[]).push(a)),'['+s.map((a,b)=>k=a&&(k?',':'')+'['.repeat(b)+a+']'.repeat(b)).join``+']')

ডেমো

— sbisit
সূত্র
1

পিএইচপি, 145 বাইট

<?function c($r){$n=[];foreach($r as$k=>$v)if(is_array($v)){$n=array_merge($n,$v);unset($r[$k]);}if($n)$r[]=c($n);return$r;}print_r(c($_GET[a]));

ভাঙ্গন

function c($r){
  #usort($r,function($x,$y){return is_array($x)<=>is_array($y)?:$x<=>$y;}); 
#no need to sort and a simple sort($r); do it sort array after scalar
  $n=[];
  foreach($r as$k=>$v)if(is_array($v)){$n=array_merge($n,$v);unset($r[$k]);} # put arrays on the same depth together
  if($n)$r[]=c($n); # recursive if an array exists
  return$r; #return changes
}
print_r(c($_GET[a])); #Output and Input
— জার্গ হালসারম্যান
সূত্র
1

পাইথ, 19 16 বাইট

W=Qsf!&sITp+TdQk

এটি অনলাইনে চেষ্টা করুন। পরীক্ষা স্যুট.

নেতৃস্থানীয় স্থান নোট করুন। পার্ল উত্তরের মতো সারিগুলিতে আউটপুট স্তর।

ব্যাখ্যা

  • অন্তর্ভুক্ত ইনপুট Q।
  • filter আইটেম Tএর Qউপর:
    • উমটি চালু আছে কিনা sতা Iপরীক্ষা করুন T।
    • যদি এটি (এটি একটি সংখ্যা ছিল), pছোঁয়া Tপ্লাস একটি স্থান +… d।
    • যদি এটি না হয় (এটি একটি অ্যারে ছিল), এটি রাখুন।
  • sউম আইটেম। এটি প্রতিটি আইটেম থেকে অ্যারেগুলির একটি স্তর সরিয়ে দেয়। যদি কিছু না থাকে তবে ফলন হয়0 ।
  • =ফলাফল নির্ধারণ করুনQ ।
  • Wফলাফলটি শোকযুক্ত নয়, খালি স্ট্রিং kএবং একটি নতুন লাইন মুদ্রণ করুন ।
— PurkkaKoodari
সূত্র
1

হাস্কেল, 124 123 বাইট

data L=I Int|R[L]
d#R l=((d+1)#)=<<l
d#i=[(d::Int,i)]
[]!_=[]
l!1=l
l!d=[R$l!(d-1)]
h l=R$do d<-[1..];[i|(e,i)<-0#l,d==e]!d

যেহেতু হাস্কেল ডিফল্টরূপে মিশ্র তালিকাগুলি (পূর্ণসংখ্যা এবং পূর্ণসংখ্যার তালিকা) সমর্থন করে না, তাই আমি একটি কাস্টম তালিকার ধরণের সংজ্ঞা দিই L। ব্যবহারের উদাহরণ:

*Main> h (R[I 1, R[I 2, I 3], R[ R[I 4]], R[ R[ R[I 5, I 6], I 7, R[R[R[I 8]]]], I 9]])
R [I 1,R [I 2,I 3,I 9],R [R [I 4,I 7]],R [R [R [I 5,I 6]]],R [R [R [R [R [I 8]]]]]]

দ্রষ্টব্য: এটি চালাতে কিছুটা সময় নেয়, কারণ এটি নীচে নীড়ের নীচের স্তরের সন্ধান করতে সমস্ত ধনাত্মক Ints (32 বা 64 বিট) দিয়ে যায়। এছাড়াও: কাস্টম তালিকার ধরণটি ডিফল্টরূপে মুদ্রণ করা যায় না, সুতরাং যদি আপনি উপরের উদাহরণ হিসাবে ফলাফল দেখতে চান তবে আপনাকে ঘোষণায় যুক্ত deriving Showকরতে হবে data(->data L=I Int|R[L] deriving Show )। কোনও ফাংশন থেকে এল-তালিকা ফেরত দেওয়ার জন্য এটির প্রয়োজন নেই বলে আমি বাইটগুলি গণনা করি না।

কিভাবে এটা কাজ করে:

data L=I Int|R[L]               -- custom list type L, which is either an Int
                                -- (-> I Int) or a list of some L (-> R [L]) 

d#R l=((d+1)#)=<<l              -- # makes a list of (depth, I-number) pairs from
d#i=[(d::Int,i)]                -- a given L-list, e.g.
                                -- 0 # (R[I 1,R[I 2,I 3],I 4]) -> [(1,I 4),(2,I 2),(2,I 3),(1,I 4)]
                                -- the type annotation ::Int makes sure that all
                                -- depths are bounded. Without it, Haskell
                                -- would use arbitrary large numbers of type
                                -- ::Integer and the program won't finish

[]!_=[]                         -- ! wraps a list of Is with (d-1) additional
l!1=l                           --  R constructors
l!d=[R$l!(d-1)]

h l=                            -- main function, takes a L-list
      do d<-[1..]               -- for each nest level d make
        [i|(e,i)<-0#l,d==e]     -- a list of all I where the depth is d
                           !!d  -- and wrap it again with d-1 Rs         
     R$                         -- wrap with a final R

সম্পাদনা করুন @BlackCap থেকে সুইচিং দ্বারা একটি বাইট সংরক্ষিত >>=করার doস্বরলিপি। ধন্যবাদ!

— nimi
সূত্র
h l=R$do d<-[1..];[i|(e,i)<-0#l,d==e]!d
— স্বীকৃতি
0

জাভাস্ক্রিপ্ট (ES6), 127 137 134 বাইট

ইনপুট হিসাবে একটি অ্যারে নেয় এবং একটি স্ট্রিং দেয়।

f=(a,l=[],d=0,o='')=>`[${a.map(x=>x[0]?f(x,l,d+1,o+'['):l[d]=(l[d]?l[d]+',':o)+x),l.map((s,d)=>x+s+']'.repeat(d,x=','),x='').join``}]`

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

কোড স্নিপেট দেখান

— Arnauld
সূত্র
@ শেবাং লক্ষ্য করার জন্য ধন্যবাদ এটি ঠিক করা উচিত।
— আর্নৌল্ড
আমি বিশ্বাস করি যে এটি এখন ভাল দেখাচ্ছে! :)
— কেড
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.