একটি অ্যারে সমাপ্ত করুন

Question

^{এই চ্যালেঞ্জটি ম্যাথমেটিকা.এসই সম্পর্কিত একটি প্রশ্ন দ্বারা অনুপ্রাণিত হয়েছিল ।}

বলুন যে আপনি কিছু স্বেচ্ছাসেবী কাঠামোর নেস্টেড তালিকা / অ্যারে পেয়েছেন (প্রতিটি স্তরের তালিকাগুলিতে অভিন্নভাবে একই দৈর্ঘ্য নেই)। সরলতার জন্য, আমরা ধরে নেব যে নোডগুলি অ-নেতিবাচক পূর্ণসংখ্যা বা খালি অ্যারে। উদাহরণ হিসাবে

[[[1, 3], 2], [1, 4], 12, [[0, [], 0], [5, [7]]]]

কখনও কখনও নোডগুলির কিছু হেরফের করার জন্য সেই তালিকাটি সমতল করা আরও সুবিধাজনক eg

--> [1, 3, 2, 1, 4, 12, 0, 0, 5, 7]
--> [1, 1, 0, 1, 0, 0, 0, 0, 1, 1]

তবে শেষ পর্যন্ত আপনি প্রকৃত কাঠামোটি সংরক্ষণ করতে চান, তাই আপনি এটিকে আবার রূপান্তর করতে চান

--> [[[1, 1], 0], [1, 0], 0, [[0, [], 0], [1, [1]]]

আপনার কাজটি সেই শেষ পদক্ষেপটি সম্পাদন করা।

স্বেচ্ছাসেবী অ-নেতিবাচক পূর্ণসংখ্যার একটি নেস্টেড তালিকা দেওয়া হয়েছে, যা ফলাফলের পছন্দসই কাঠামোর প্রতিনিধিত্ব করে এবং অ-নেতিবাচক পূর্ণসংখ্যার সমতল তালিকা, যা পছন্দসই মানগুলি উপস্থাপন করে, সমতল তালিকাটিকে কাঠামোগত তালিকার আকারে পুনরায় আকার দিন। আপনি ধরে নিতে পারেন যে উভয় তালিকায় একই সংখ্যার পূর্ণসংখ্যা রয়েছে।

যথারীতি আপনাকে অবৈধ ইনপুট (যেমন দ্বিতীয় তালিকাটি সমতল না হওয়া, ইনপুটটি সিনট্যাকটিকভাবে বিকৃত হওয়া, নোড হিসাবে পূর্ণসংখ্যা না থাকা ইত্যাদি) নিয়ে কাজ করতে হবে না। আপনি আপনার কোড ইনপুট অ্যারে সংশোধন করতে পারেন।

আপনি STDIN, কমান্ড-লাইন আর্গুমেন্ট বা ফাংশন আর্গুমেন্টের মাধ্যমে ইনপুট নিয়ে কোনও ফাংশন বা প্রোগ্রাম লিখতে পারেন, এবং আপনি ফলাফলটি ফেরত দিতে বা এটি STDOUT এ মুদ্রণ করতে পারেন। ইনপুট এবং আউটপুট উপস্থাপন করতে আপনি যে কোনও সুবিধাজনক তালিকা বা স্ট্রিং ফর্ম্যাট ব্যবহার করতে পারেন (যতক্ষণ না বিন্যাসটি দ্ব্যর্থহীন এবং ইনপুটটি প্রিপ্রোসেসড হয় না)। এছাড়াও, উভয় ইনপুটগুলির ফর্ম্যাটটি সামঞ্জস্যপূর্ণ হওয়া দরকার (যাতে আপনি একটি ইনপুট স্ট্রিং হিসাবে এবং অন্যটিকে তালিকার হিসাবে নিতে পারেন না)। আপনি উভয় ক্রমে ইনপুট তালিকা নিতে পারেন, তবে দয়া করে আপনার উত্তরে সঠিক ইনপুট পদ্ধতিটি নির্দিষ্ট করুন specify

আরও একটি বিধিনিষেধ: আপনার অবশ্যই নিয়মিত অভিব্যক্তি ব্যবহার করা উচিত নয়। এটি একটি অ্যারে ম্যানিপুলেশন চ্যালেঞ্জ, স্ট্রিং ম্যানিপুলেশন চ্যালেঞ্জ নয়।

এটি কোড গল্ফ, তাই সংক্ষিপ্ত উত্তরটি (বাইটে) জেতে।

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

Structure                             Values                 Result
[[[1,3],2],[1,4],12,[[0,0],[5,[7]]]]  [1,1,0,1,0,0,0,0,1,1]  [[[1,1],0],[1,0],0,[[0,0],[1,[1]]]]
[[[0,0],0],[0,0],0,[[0,0],[0,[0]]]]   [1,1,0,1,0,0,0,0,1,1]  [[[1,1],0],[1,0],0,[[0,0],[1,[1]]]]
[]                                    []                     []
[[]]                                  []                     [[]]
[0,1,2,3]                             [5,1,0,5]              [5,1,0,5]
[[[[[0]]]]]                           [123]                  [[[[[123]]]]]
[0,[1,[]],[[]],[2,3],[]]              [1,6,1,8]              [1,[6,[]],[[]],[1,8],[]]

Comments

স্ট্রাকচার অ্যারেতে মানগুলি পরিবর্তিত হলে কি এটি অনুমোদিত?

— প্রোগ্রামফক্স

@ প্রোগ্রামগ্রামফক্স হ্যাঁ "আপনি আপনার কোডের ইনপুট অ্যারেগুলি সংশোধন করতে পারেন" "

— মার্টিন এন্ডার

হাস্যকরভাবে, এখানে জমা দেওয়ার একটি হ'ল ম্যাথেমেটিকা।

— ইসিয়া মিডোস

লিঙ্কিত প্রশ্ন থেকে উত্তর অন্য কাউকে চুরি করতে বাধা দেওয়ার জন্য @ আইপিনবুল এটি আমার, যা আমি প্রশ্নের সাথে পোস্ট করেছি, (এবং প্রকৃতপক্ষে এটি কেবল উত্তরটির একটি গল্ফ ডাউন ডাউন সংস্করণ)।

— মার্টিন এেন্ডার

@ মার্টিনব্যাটনার ওহ খুশী হলাম। এটি আসলে সংক্ষিপ্ত উত্তরগুলির মধ্যে একটিও।

— ইসিয়া মিডোস

Answer 1

সিজেম, 18 16 13 বাইট

lA,sNerN%l~]z

পূর্ববর্তী সিজেএম উত্তরের মতো একই ফর্ম্যাটে এসটিডিআইএন-এর মাধ্যমে ইনপুট নেয়:

[0 [11 []] [[]] [2 3] []]
[1 6 1 8] 

এবং ফলাফল স্ট্রিং STDOUT এ আউটপুট করে

[1 [6 []] [[]] [1 8] []]

আমি প্রথম পংক্তিকে কেবল স্ট্রিং হিসাবেই বিবেচনা করি, সমস্ত অঙ্কের অক্ষরকে নতুনরেখায় রূপান্তর করি, নিউলাইনগুলির এক বা একাধিক ঘটনায় বিভক্ত করি, দ্বিতীয় লাইনটিকে স্ট্যাকের অ্যারে হিসাবে রাখি, একটি অ্যারেতে মোড়ক করে দুটি অ্যারে (সারি) একসাথে জিপ করি। মুদ্রণটি স্বয়ংক্রিয় এবং প্রথম সারিতে স্ট্রিং হিসাবে বিবেচনা করা হয়েছিল, এটি বন্ধনীগুলি ধরে রাখে।

কোড সম্প্রসারণ

lA,sNerN%l~]z
l                     "Read the first line of input. This is the nested array";
 A,s                  "Get array [0,1,2...9] and  convert it to string '012..9'";
    Ner               "Replace all occurrences of 0,1,2,..9 with new line";
       N%             "Split on one or more occurrences of new line";
         l~           "Read the second line as an array";
           ]          "Wrap both the splitted string and the second line array";
                      "in an array";
            z         "Transpose the array, there by placing the numbers from second";
                      "input array in the split holes of first input string";

3 বাইট সংরক্ষণ করার জন্য @ ব্যবহারকারী23013 কে ধন্যবাদ।

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

Comments

ওপি থেকে, "এটি একটি অ্যারে ম্যানিপুলেশন চ্যালেঞ্জ, স্ট্রিং ম্যানিপুলেশন চ্যালেঞ্জ নয়" "

— atk

@ এটাক: এটি বিতর্কযোগ্য যেহেতু কেবল স্পষ্টভাবে নিয়মিত অভিব্যক্তিটি অস্বীকার করে।

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

জন্য ছোট /La-: %।

— jimmy23013

@ ইউজার ২৩০১৩ ওয়া, কখনই বুঝতে পারলেন না যে %এটিও বিভক্ত হয়ে গেছে, এবং এটি একাধিক ঘটনাতেও বিভক্ত হয়!

— অপটিমাইজার 6

@ অ্যাটাক হ্যাঁ, যেহেতু কেবল রেজেক্স নিষিদ্ধ ছিল তাই আমি এই কৌশলটি ব্যবহার করেছি।

— অপটিমাইজার

Answer 2

জাভাস্ক্রিপ্ট, ES6, 44 বাইট

f=(a,b,i=0)=>a.map(x=>x.map?f(x,b,i):b[i++])

এটি এমন একটি ফাংশন তৈরি করে fযা বলা যেতে পারে

f([0,[1,[]],[[]],[2,3],[]],[1,6,1,8])

যেমন নেস্টেড অ্যারে এবং ইনপুট আর্গুমেন্ট হিসাবে মান অ্যারে। ফাংশনের আউটপুট হ'ল রূপান্তরিত নেস্টেড অ্যারে।

এই প্রশ্নটি পুনরাবৃত্তি করার জন্য খুব সুন্দর প্রশ্ন, সে কারণেই উত্তরটি একটি ঝরঝরে এবং মিষ্টি পুনরাবৃত্তি ফাংশন। আমি একটি ফাংশন তৈরি করি fযা mapপদ্ধতিটি ব্যবহার করে প্রথম যুক্তিকে রূপান্তর করে । প্রতিটি উপাদানের জন্য, যদি উপাদানটি একটি অ্যারে fহয় তবে এটি আবার কল করে, অন্যথায়, পূর্ণসংখ্যার জন্য, এটি i ^ম আইটেমটি পেয়ে থাকে এবং ফিরে আসে, এর মান বাড়িয়ে তোলেi । iঅর্ডার সঠিক রক্ষণাবেক্ষণের জন্য প্রতিটি পুনরাবৃত্তির কলটিতে মানটি নিচে চলে যায়।

অ্যারে বনাম পূর্ণসংখ্যা সনাক্তকরণটি আবারও mapপদ্ধতিটি ব্যবহার করে সম্পন্ন হয়েছে । অ্যারে ভেরিয়েবলের জন্য, mapএকটি বৈধ ফাংশন, যখন পূর্ণসংখ্যার ভেরিয়েবলের জন্য, কোনও সম্পত্তি বা ফাংশন বলা হয় নাmap জন্য, ভেরিয়েবলের জন্য সংজ্ঞায়িত ।

এটি সর্বশেষতম ফায়ারফক্স ব্রাউজারে (ইএস to এর কারণে) কাজ করে।

Comments

আমি জানি আমার "+1" এবং "ধন্যবাদ" এর মতো মন্তব্যগুলি এড়ানো উচিত, তবে জঘন্য এটি একটি মিষ্টি ES6 ফাংশন! আমি এই কোড লাইনটি ঘন্টা ধরে দেখতে পারি :)

— জ্যাকব

আমি দেখেছি যে কোডটিতে 2 টি .mapবিদ্যমান আছে। এটি আরও ছোট করার কোনও উপায় আছে? যাইহোক, দুর্দান্ত কোড!

— ডেরেক 朕 會

ওহ, কখন ইএস সেই ল্যাম্বডা সিনট্যাক্স যুক্ত করেছে?

— ফ্লফি

@ ফ্লুফি ইএস 6 এ;)

— অপ্টিমাইজার

@ ডেরেক 朕 會 功夫 দুর্ভাগ্যজনকভাবে না no mapপ্রসঙ্গে আবদ্ধ, সুতরাং প্রথম মানচিত্রটি এর সাথে সম্পর্কিত aযখন পরবর্তী মানচিত্রটি xপুনরাবৃত্তির প্রতিটিটির সাথে সম্পর্কিত to রেফারেন্স দেওয়ার mapবা আর পূর্ণসংখ্যার থেকে অ্যারে আলাদা করার পক্ষে আর কোনও ছোট উপায় নেই

— অপ্টিমাইজার

Answer 3

জাভাস্ক্রিপ্ট, ES6, 41 বাইট

আমি অপ্টিমাইজারের উত্তর দেখে সত্যিই মুগ্ধ হয়েছি , এটি খুব চালাকতার সাথে করা হয়েছিল এবং আমি অনেক কিছু শিখেছি। তবে এটি সন্ধান করার সময় আমি এটির সামান্য ছোট করার এবং একটি ছোট বাগ ফিক্স করার একটি উপায় খুঁজে পেয়েছি:

f=(a,b)=>a.map(x=>x.map?f(x,b):b.shift())

আমি iভেরিয়েবলটি বের করে এটিকে প্রতিস্থাপন করেছি shift()। এটি এটিকে কিছুটা সংক্ষিপ্ত করে তোলে এবং এই সমস্যাটি সমস্যার সাথে সংশোধন করে দেয় যা iমান দ্বারা প্রেরণ করা হয় এবং রেফারেন্সের মাধ্যমে নয়, ডাইনি চূড়ান্ত অ্যারে থেকে কিছু সংখ্যার পুনরাবৃত্তি ঘটায় এবং কিছু শেষে ব্যবহার না করা হয়। আবারও, অপ্টিমাইজারের উত্তরটি সত্যিই ভালভাবে চিন্তা করা হয়েছিল, আমি যতটা করতে পারি তার চেয়ে ভাল, আমি এটিকে কিছুটা ঠিক করেছিলাম।

Comments

দুর্দান্ত গল্ফ! কিছুটা দু: খিত যে আমি এটি

— অপ্টিমাইজার

Answer 4

ডায়ালগ এপিএল, 14 টি অক্ষর

এই কোন- brainer হল: (∊a)←b।

সাধারণত, এর ∊aঅর্থ aসমতল, তবে যখন এটি কোনও অ্যাসাইনমেন্টের বাম-হাতের অংশে ঘটে, তখন সমস্যাটি কী জিজ্ঞাসা করছে তা অবিকল এটি করে। ফাংশন হওয়ার প্রয়োজনীয়তা মেনে চলার জন্য, এটি কয়েকটি অতিরিক্ত স্কুইগলস প্রয়োজন: {a←⍺⋄(∊a)←⍵⋄a}( ল্যাম্বদার জন্য কোঁকড়ানো ধনুর্বন্ধনী; ⍺এবং ⍵বাম এবং ডান যুক্তির ⋄জন্য ; বিবৃতি বিভাজক জন্য)।

Tryapl.org এ পরীক্ষা করুন। নোট করুন যে ⍬এপিএলে খালি সংখ্যামূলক ভেক্টর দ্বারা চিহ্নিত করা হয়েছে ("জিল্ড")। এক-এলিমেন্ট ভেক্টরগুলি এটি দিয়ে তৈরি করা হয়েছে (,A)কারণ এর (A)অর্থ কোনও স্কেলার। আউটপুট, এই জিনিস:

┌⊖┐
│0│
└~┘

একটি খালি সংখ্যক ভেক্টর উপস্থাপন করে। 0কেন্দ্রে "prototypical এর উপাদান" যা অ্যারের একটি উপাদান নয় দেখায়।

Comments

সেই গ্রাফিকাল উপস্থাপনাটি কী আলাদা করে না (,1)এবং (1)বা চূড়ান্ত বিটটি কেন কেবল তার [1|1]পরিবর্তে উপস্থাপিত হয় [1|[1]]?

— মার্টিন এন্ডার

ট্রাফলের (যেমন হিসাবে পরিচিত ]box on) গ্রাফিকাল উপস্থাপনা তাদের মধ্যে পার্থক্য করে না। ডায়ালগের আরও একটি ফাংশন রয়েছে ( displayথেকে dfns.dws) যা আলাদা করে তোলে, তবে দুর্ভাগ্যক্রমে ট্রাইপল অতিরিক্ত কর্মক্ষেত্র (অর্থাত্ত গ্রন্থাগার) লোডিংকে সীমাবদ্ধ করে। :(

— এনজিএন

স্কয়ার বন্ধনী করা আকারে ফলাফল দেখতে, এই চেষ্টা করে দেখুন: ∊{0=⍴⍴⍵:⍕⍵ ⋄ '['(∇¨⍵)']'}a। অথবা এটি: ∊{0=⍴⍴⍵:⍕⍵ ⋄ '['(1↓,'|',[1.5]∇¨⍵)']'}aআপনি বিভাজকের উপর জোর দিলে |,।

— এনজিএন

ওহ, আপনি ]display aট্রাইপেল ব্যবহার করতে পারেন । এটি কাঠামো সম্পর্কে সম্পূর্ণ তথ্য দেয়। দুঃখিত, আমি এটি প্রথমে বুঝতে পারি নি।

— এনজিএন

ন্যায্য বিন্দু. 2 অতিরিক্ত বাইট ব্যয়ে আমি এটি একটি ফাংশনে পরিণত করেছি।

— এনজিএন

Answer 5

পাইথন, 51

f=lambda a,b:[b.pop(0)if x<[]else f(x,b)for x in a]

উদাহরণ:

>>> f([0,[1,[]],[[]],[2,3],[]], [1,6,1,8])
[1, [6, []], [[]], [1, 8], []]

Answer 6

পাইথন 2, 50

f=lambda s,v:v.pop(0)if s<[]else[f(x,v)for x in s]

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

sকাঠামো এবং vতালিকা ফ্ল্যাট তালিকা। ধারণাটি হল পরীক্ষামূলক সংখ্যার sসাথে s<[](পাইথন 2 সংখ্যাকে তালিকার চেয়ে ছোট হিসাবে গণ্য করে) যাচাই করা উচিত । যদি তা না হয়, সহজভাবে গ্রহণ করা এবং প্রথম উপাদান আসতে v, থেকে এটি সরানোর v। অন্যথায়, এর সাবলিস্টে পুনরাবৃত্তি করুনs ।

pop খুব কার্মিক-শৈলী কোডে অনুজ্ঞাসূচক জাদু এক টুকরা। যেহেতু সমস্ত vএকই দৃষ্টিতে নির্দেশ করে, একটি থেকে কোনও উপাদান পপ করে তা vসম্পূর্ণ সম্পাদনকারী গাছ থেকে সরিয়ে দেয় , সুতরাং প্রতিটি সংখ্যা vকেবল একবার ব্যবহার করা হবে। তালিকার বোধগম্যতা [f(x,v)for x in s]এমন একটি কল ট্রি তৈরি করে যা এর গভীরতাগুলি প্রথম এবং বাম থেকে ডানে প্রসারিত হয়, এর উপাদানগুলির কারণ হয়ে থাকেv সঠিক ক্রমে স্লট করা যায়।

আমি এটি জিআরসি-র উত্তরের সাথে স্বাধীনভাবে লিখেছি , তবে এটি একটিতে সরে যাওয়ার পক্ষে পরিণত হয়েছে[ (এবং পরিবর্তনশীল নাম) । ব্যবধান ব্যবধানের কারণে সরানো একটি চর সংরক্ষণ করে। বন্ধনী সরানো মানে তালিকার বোধগম্যতার অংশ হিসাবে না, যা আমি বিবেচনা করি নি, তার পরিবর্তে ফাংশনটিতে নোড কেসটি তাত্ক্ষণিকভাবে পরিচালনা করা।

যদি আমরা STDIN এবং কাঠামোর কাছ থেকে মানটি ফাংশন আর্গুমেন্ট হিসাবে গ্রহণ করার জন্য ইনপুট প্রয়োজনীয়তাগুলি প্রসারিত করি তবে আমরা 49 এর জন্য একটি চর সংরক্ষণ করতে পারি । এটি আমাদের ব্যবহার করতে দেয় map।

v=input()
g=lambda s:v.pop(0)if s<[]else map(g,s)

Answer 7

রুবি, 39

f=->a,b{a.map{|d|f[d,b]}rescue b.shift}

তালিকার উপাদানটি পূর্ণসংখ্যা না হওয়া পর্যন্ত পুনরাবৃত্তি করে।
যেহেতু ইন্টিজার.ম্যাপ কল করা ব্যতিক্রম দেয়,
এটি উদ্ধার অংশে যায়, যা ২ য় তালিকার মধ্যে 1 ম উপাদানটিকে "পপ / শিফট" করে।

রেজেক্স সলান ... কিছুটা দীর্ঘ:

f=->a,b{eval a.to_s.split(/\d+/).zip(b)*''}

কিছু পরীক্ষার ক্ষেত্রে এটি ব্যবহার করে দেখুন

Comments

কেবল রেফারেন্সের জন্য, রেজেক্স সমাধানগুলি অনুমোদিত নয়। ;)

— মার্টিন এন্ডার

Answer 8

সিজেম, 43 37 35 33 বাইট

এটি আমার জেএস উত্তরের প্রত্যক্ষ রূপান্তর । কিছুটা দীর্ঘ, যার বেশিরভাগই ধরণ সনাক্তকরণ দ্বারা নেওয়া হয়।

q~:B;{{_`La`&{F}{;BW):W=}?}%}:F~`

STDIN এর মত দুটি লাইনে দুটি ইনপুট অ্যারে নেয়

[[[1 3] 2] [1 4] 12 [] [[0 0] [5 [7]]]]
[1 1 0 1 0 0 0 0 1 1]

এবং আউটপুটগুলি STDOUT পছন্দ করে

[[[1 1] 0] [1 0] 0 "" [[0 0] [1 [1]]]]

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

Answer 9

হাস্কেল, 113 104 বাইট (ডাটাটাইপ ঘোষণার থেকে 86 + 18)

data N=I Int|L[N]
L[]!v=(L[],v)
L(a:b)!v|(c,w)<-a!v,(L d,u)<-L b!w=(L$c:d,u)
_!(n:m)=(I n,m)
s#v=fst$s!v

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

L[I 0,L[I 1,L[]],L[L[]],L[I 2,I 3],L[]]#[1,6,1,8]

এবং মূল্যায়ন

L[I 1,L[I 6,L[]],L[L[]],L[I 1,I 8],L[]]

Answer 10

গণিত, 41 বাইট

Function[,m[[i++]],Listable][i=1;m=#2;#]&

এটি একটি নামবিহীন ফাংশন যা কাঠামোটিকে প্রথম আর্গুমেন্ট হিসাবে গ্রহণ করে এবং দ্বিতীয় আর্গুমেন্ট হিসাবে মানগুলির তালিকা (এবং একটি তালিকা ফেরত দেয়)।

এটি একটি গল্ফ সংস্করণ এই চ্যালেঞ্জকে অনুপ্রাণিত করে এমন প্রশ্নের স্বীকৃত উত্তরের । আমি নিজেই এটি পোস্ট করছি, এবং এই উত্তরটি গ্রহণ করব না (এটি আসলে সবচেয়ে কমতম হওয়া উচিত, যা আমি সন্দেহ করি)। এটি মূলত উত্তরটি অনুলিপি করে অন্য কাউকে চ্যালেঞ্জ জিততে বাধা দেওয়ার জন্য।

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

• আমরা একটি Listableখাঁটি ফাংশন সংজ্ঞায়িত করি । তালিকাভুক্ত ফাংশনগুলি স্বয়ংক্রিয়ভাবে তালিকার পরিবর্তে একটি তালিকা আর্গুমেন্টের উপাদানগুলিতে (পুনরাবৃত্তভাবে) প্রয়োগ করা হয়, সুতরাং fকাঠামোগত তালিকার উপর কল করা মূলত প্রতিটি পূর্ণসংখ্যা iদ্বারা প্রতিস্থাপিত একই কাঠামোর একটি তালিকা ফিরিয়ে আনবেf[i] ।
• আমরা বিশ্বব্যাপী মান তালিকা mএবং একটি কাউন্টার ইন সঞ্চয় করিi ।
• প্রতিবার যখন আমরা কল করি f(যুক্তি নির্বিশেষে) আমরা এর পরবর্তী উপাদানটি ফিরে পাই m।

Answer 11

রিবোল - 87 66 60

f: func[a[block!]b][map-each n a[any[attempt[f n b]take b]]]

Ungolfed:

f: func [a [block!] b] [
    map-each n a [
        any [
            attempt [f n b]  
            take b
        ]
    ]
]

উদাহরণ:

>> f [0 [1 []] [[]] [2 3] []]   [1 6 1 8]           
== [1 [6 []] [[]] [1 8] []]

Answer 12

সি #, 225 + 13 = 239 185 + 35 = 220 172 + 35 = 207 বাইট

এটি প্রয়োজন:

using System;using o=System.Object;

object[]আর্গুমেন্ট হিসাবে গ্রহণ করে ।

o[]u(o[]a,o[]b){var c=a;int i=0;Action<o[],o[]>d=null;d=(e, f)=>{for(int j=0;j<e.Length;j++){if(e[j]is int){f[j]=b[i];i++;}else{d((o[])e[j],(o[])f[j]);}}};d(a,c);return c;}

অবরুদ্ধ কোড:

object[] Unflatten(object[] structure, object[] values)
{
    var c = structure;
    int i = 0;
    Action<object[], object[]> recursiveFunc = null;
    recursiveFunc = (e, f) =>
    {
        for (int j = 0; j < e.Length; j++)
        {
            if (e[j] is int)
            {
                f[j] = values[i]; i++;
            }
            else
            {
                recursiveFunc((object[])e[j], (object[])f[j]);
            }
        }
    };
    recursiveFunc(structure, c);
    return c;
}

Comments

আপনি using o=System.Objectসমস্ত উদাহরণগুলি objectসহজভাবে ব্যবহার করে এবং প্রতিস্থাপনের মাধ্যমে এটিকে আরও কিছুটা ছোট করতে পারেন o। msdn.microsoft.com/en-us/library/sf0df423.aspx

— Kroltan

@ ক্রোলটান দুর্দান্ত টিপস, ধন্যবাদ!

— প্রোগ্রামএফক্স

Cloneঅগভীর। যদি ইনপুটগুলিকে সংশোধন করার অনুমতি দেওয়া হয় তবে আপনার একেবারেই ক্লোন করার দরকার নেই। যদি এটি অনুমোদিত না হয় তবে আপনার সঠিক ক্লোনিং প্রয়োজন।

— কোডসইনচাজস

পছন্দ করেছেন ইনপুট অ্যারে পরিবর্তন করার অনুমতি দেওয়ার সাথে সাথে আমি ক্লোনটি সরিয়েছি। ধন্যবাদ!

— ProgramFOX

Answer 13

পাইথন 2, 64 বাইট

def g(N,L):f=lambda N:L.pop(0)if`N`<":"else map(f,N);return f(N)

শুনেছি আপনি তালিকাগুলির তালিকাগুলি পছন্দ করেন তাই আমি ফাংশনগুলিতে ফাংশন রাখি।

সম্পাদনা: এখন গ্রিসির উত্তর দেখে আমি বুঝতে পারি যে এটি সম্পূর্ণ অপ্রয়োজনীয়। আচ্ছা ভালো...

Answer 14

এসডাব্লুআই-প্রোলগ 82

f([],A,[],A):-!.
f([H|T],A,[J|U],B):-(is_list(H),!,f(H,A,J,C);A=[J|C]),f(T,C,U,B).

নমুনা রান:

?- f([[[1,3],2],[1,4],12,[[0,[],0],[5,[7]]]],[1,1,0,1,0,0,0,0,1,1],R,[]).
R = [[[1,1],0],[1,0],0,[[0,[],0],[1,[1]]]].

[]ক্যোয়ারির শেষটি হ'ল উপাদানের মিলহীন সংখ্যার জন্য যাচাইয়ের জন্য যা এই প্রশ্নটিতে প্রয়োজনীয় বলে মনে হচ্ছে না।

Comments

কি কাটাগুলি (এবং এক্সটেনশনের মাধ্যমে ব্যয়বহুল is_list) প্রয়োজনীয় করে তোলে ?

— অসম্পূর্ণ স্ট্রিং

@ আনলেলেটেড স্ট্রিং: সঠিক উত্তর পেতে অপ্রয়োজনীয় মনে হলে সরাসরি উত্তর সম্পাদনা করতে দ্বিধা বোধ করবেন। আমার প্রোলোগ তখন খারাপ ছিল (আমি লাইব্রেরি ব্যবহার করি এবং ব্যাপকভাবে কাটছি) এবং আরও বেশি মরিচা এই দিনগুলিতে।

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Answer 15

এরলং, 116 93 বাইট

f(R,F)->put(n,F),[g(X)||X<-R].
g([H|T])->[g(H)|g(T)];g([])->[];g(E)->[H|T]=get(n),put(n,T),H.

দুটি অপরিষ্কার ফাংশন fএবং ব্যবহার করে g। ফ্ল্যাট তালিকায় fসেট করে প্রক্রিয়া অভিধানটি ম্যানিপুলেট করে nএবং নেস্টেড তালিকার প্রতিটি উপাদানকে মানচিত্র করে g(X)। gতারপরে nফ্ল্যাট তালিকার পুচ্ছকে সেট করে প্রতিবার এটি কোনও তালিকাবিহীন মানের সাথে মিলিত হয় এবং ফ্ল্যাট তালিকার শীর্ষস্থানটি ফেরত দেয়।

Answer 16

পার্ল 5, 49 বাইট

প্রথম যুক্তি হ'ল টেমপ্লেট কাঠামো, দ্বিতীয়টি মান।

sub u{($t,$l)=@_;ref$t?[map{u$_,$l}@$t]:shift@$l}

পরীক্ষা প্রোগ্রাম

use Test::More;
use Test::Deep;

sub u{($t,$l)=@_;ref$t?[map{u$_,$l}@$t]:shift@$l}

cmp_deeply u([[[1,3],2],[1,4],12,[[0,0],[5,[7]]]],[1,1,0,1,0,0,0,0,1,1]),[[[1,1],0],[1,0],0,[[0,0],[1,[1]]]];
cmp_deeply u([[[0,0],0],[0,0],0,[[0,0],[0,[0]]]],[1,1,0,1,0,0,0,0,1,1]),[[[1,1],0],[1,0],0,[[0,0],[1,[1]]]];
cmp_deeply u([], []), [];
cmp_deeply u([[]], []), [[]];
cmp_deeply u([0,1,2,3], [5,1,0,5]), [5,1,0,5];
cmp_deeply u([[[[[0]]]]], [123]), [[[[[123]]]]];
cmp_deeply u([0,[1,[]],[[]],[2,3],[]], [1,6,1,8]), [1,[6,[]],[[]],[1,8],[]];
done_testing;

Answer 17

পাওয়ারশেল: 115

ইনপুট অ্যারে হ'ল $ i, ম্যাপিংটি $ এম, আউটপুট। o

$h={if($_.GetType().IsArray){if($_.c -eq 0){,@()}else{,@($_|%{.$h})}}else{$m[$c++]}};$i|%{$o=@();$c=0}{$o+=,(.$h)}

$ এইচটি পুনরাবৃত্ত ফাংশনযুক্ত একটি স্ট্রিং, এবং আপনি স্ট্রিংয়ের সাথে থাকা কোডটি কার্যকর করতে পারেন $ এইচ ... এবং পাওয়ারশেল যদি স্কেলারে একক মান অ্যারে সমতল করার জন্য জোর না দেয় এবং এটি একটি অ্যারে কম হয় তবে এটি 30 বাইট সংক্ষিপ্ত হবে নাল থেকে একক নাল মান সহ

এবং ফলাফল যাচাই করার জন্য একটি সহজ অ্যারে কাঠামো প্রদর্শক

$j={if($_.GetType().IsArray){write-host '(' -n;($_|%{.$j});write-host ')' -n}else{write-host "$_" -n}};write-host '(' -n;$o|%{(.$j)}; write-host ')' -n;

সম্পাদনা করুন: 149

unflatten.ps1 হিসাবে সংরক্ষণ করুন:

$m=[array]$args[1];$h={if($_.GetType().IsArray){if($_.c -eq 0){,@()}else{,@($_|%{.$h})}}else{$m[$c++]}};$args[0]|%{$o=@();$c=0}{$o+=,(.$h)};echo $o;

সম্পাদনা: 136, ইনলাইন আউটপুট অ্যারে তৈরি এবং লিখন-আউটপুট

$m=[array]$args[1];$h={if($_.GetType().IsArray){if($_.c -eq 0){,@()}else{,@($_|%{.$h})}}else{$m[$c++]}};echo(,@($args[0]|%{$c=0}{.$h}))

কল করুন \ unflatten.ps1 [ইনপুট অ্যারে] [ম্যাপিং অ্যারে]

পাইপলাইনে আউটপুট লেখা আছে - সুতরাং এটি প্রথমে চালান:

Function View-Array{
Param([Parameter(ValueFromPipeline=$True,ValueFromPipelinebyPropertyName=$True)]
      [array]$o)

    PROCESS{
    $j={if($_.GetType().IsArray){write-host '(' -n;($_|%{.$j});write-host ')' -n}else{write-host "$_" -n}};
    write-host '(' -n;$o|%{(.$j)}; write-host ')' -n;
    }
}

এবং সাথে চালানো

.\unflatten.ps1 [input array] [mapping array] | View-Array

Answer 18

সি #, (40 + 123) = 163 বাইট OR (67 + 81) = 148 বাইট

সি # এখানে স্ট্যাটিক টাইপিং এবং দীর্ঘ নেমস্পেসে ভুগছে।

অ্যারে পদ্ধতি

বিবৃতি ব্যবহার:

using o=System.Object;using System.Linq;

কোড:

o[] u(o[] x,o[] y){int i=0;Func<o[],o[],o[]> f=null;f=(a,b)=>a.Select(e=>e is int?b[i++]:f((o[])e,b)).ToArray();return f(x,y);}

স্ট্যাক পদ্ধতি (অ্যারের পরিবর্তে স্ট্যাক কাঠামো ব্যবহার করে)

বিবৃতি ব্যবহার:

using s=System.Collections.Generic.Stack<object>;using System.Linq;

কোড:

System.Func<s,s,s>f=null;f=(a,b)=>new s(a.Select(e=>e is int?b.Pop():f((s)e,b)));

প্রথম প্রচেষ্টা, এখানে প্রথম কোড গল্ফ।