পটভূমি

জেলির পাটিগণিত পরমাণুগুলি স্বয়ংক্রিয়ভাবে ভেক্টরাইজ হয়। আসলে, এক্স এবং ওয়াই সংজ্ঞায়িত হয় যখনই এক্স এবং ওয়াই সংখ্যার বা রাগযুক্ত অ্যারে হয়। জেলির সোর্স কোডটি জেনেরিক ভেক্টরাইজার ব্যবহার করে এই আচরণটি প্রয়োগ করে তবে এই চ্যালেঞ্জের জন্য আমরা কেবলমাত্র পূর্ণসংখ্যা এবং নেস্টেড পূর্ণসংখ্যার অ্যারেগুলি বিবেচনা করব।

সংজ্ঞা

গভীরতা নির্ধারণ করুন এক্স যেমন 0 যদি এক্স , একটি পূর্ণসংখ্যা হিসাবে 1 যদি এটি একটি (সম্ভবত খালি) পূর্ণসংখ্যার ফ্ল্যাট অ্যারে, এবং যেমন এন +1 যদি এটা গভীরতা অন্তত একটি উপাদান রয়েছে এন এবং গভীরতা কোন উপাদান ট> এন ।

এইভাবে, 1 এর গভীরতা 0 , [] এবং [1] এবং [1, 1] গভীরতা 1 , [[], []] এবং [[1], [1]] এবং [[1]] এবং [1 ] , []] গভীরতা 2 , [1, [1, [1]]] এর গভীরতা 3 , ইত্যাদি রয়েছে etc.

অপারেশন x + y নিম্নলিখিত হিসাবে সংজ্ঞায়িত করা হয়।

যদি x এবং y এর গভীরতা 0 থাকে তবে তাদের যোগফলটি ফেরত দিন।
তাহলে এক্স এবং ওয়াই সমান কিন্তু ইতিবাচক অতল আছে, যাও recursively প্রয়োগ + + সব আইটেম এক্স এবং সংশ্লিষ্ট আইটেম Y ।

যদি x এবং y এর দৈর্ঘ্য আলাদা হয় তবে লম্বরের অ্যারের লেজটি যোগফলের অ্যারেতে যুক্ত করুন।

ফলাফলটি ফিরিয়ে দিন।
তাহলে এক্স এর গভীরতা থেকে যথাযথভাবে ছোট Y এর গভীরতা যাও recursively প্রয়োগ + + থেকে এক্স এবং সব আইটেম Y , এবং এর ফলে ফিরে যান।

বিপরীত না যদি Y এর গভীরতা থেকে যথাযথভাবে ছোট এক্স s 'এর।

উদাহরণস্বরূপ, অপারেশনটি [1, [2, 3], [4]] + [[[10, 20], [30], 40, 50], 60] বিবেচনা করুন ।

বাম আর্গুমেন্টের গভীরতা 2 , এবং ডান আর্গুমেন্টের গভীরতা 3 , তাই আমরা গণনা করি [1, [2, 3], [4]] + [[[10, 20], [30], 40, 50 ] এবং [1, [2, 3], [4]] + 60 ।
- [1, [2, 3], [4]] এবং [[10, 20], [30], 40, 50] উভয়ের গভীরতা 2 , তাই আমরা 1 + [10, 20] , [2, 3] গণনা করব + [30] এবং [4] + 40 ।
  - 1 + [10, 20] = [1 + 10, 1 + 20] = [11, 21]
  - [2, 3] + [30] = [2 + 30, 3] = [32, 3]
    
    মনে রাখবেন যে 3 টি অপরিচ্ছন্ন রয়ে গেছে, যেহেতু এটির সাথে কোনও মিল নেই।
  - [৪] + ৪০ = [৪ + ৪০] = [৪৪]
  50 তাই ফলাফল, একটি মানানসই উপাদান নেই [[[11, 21], [32, 3], [44] 50]] ।
- [1, [2, 3], [4]] + 60 = [1 + 60, [2, 3] + 60, [4] + 60] = [61, [2 + 60, 3 + 60], [ 4 + 60]] , [61, [62, 63], [64]] এর ফলস্বরূপ ।
চূড়ান্ত ফলাফলটি [[[11, 21], [32, 3], [44], 50], [61, [62, 63], [64]]] ।

কার্য

একটি প্রোগ্রাম বা একটি ফাংশন লিখুন যা দুটি পূর্ণসংখ্যার, দুটি নেস্টেড অ্যারে বা এর সংমিশ্রণটিকে ইনপুট হিসাবে গ্রহণ করে এবং উপরে বর্ণিত হিসাবে তাদের যোগফল প্রদান করে।

যদি আপনার ভাষায় একাধিক অ্যারে-জাতীয় ধরণের (তালিকাগুলি, টিপলস, ভেক্টর ইত্যাদি) থাকে তবে আপনি নিজের উত্তরের জন্য সেগুলির মধ্যে যে কোনও একটি চয়ন করতে পারেন। রিটার্ন টাইপটি অবশ্যই যুক্তির ধরণের সাথে মেলে।

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

অন্যান্য সমস্ত ভাষার সমস্ত বিল্ট-ইন অনুমোদিত। যদি আপনার পছন্দের ভাষা এটির অনুমতি দেয় তবে আপনি বিল্ট-ইন সংযোজন অতিরিক্ত ওভারলোড এবং / বা পুনরায় সংজ্ঞায়িত করতে পারেন।

এটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

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

0 + 0                           = 0
[-1, 0, -1] + [1]               = [0, 0, -1]
[] + [0]                        = [0]
[] + 0                          = []
[] + []                         = []
[[], 0] + []                    = [[], []]
[1, 2, 3] + 10                  = [11, 12, 13]
[1, 2, 3] + [10]                = [11, 2, 3]
[1, 2, 3] + [10, [20]]          = [[11, 12, 13], [21, 2, 3]]
[1, 2, 3, []] + [10, [20]]      = [11, [22], 3, []]
[1, [2, [3, [4]]]] + [10, [20]] = [[11, [21]], [[12, [22]], [13, [24]]]]

আরও পরীক্ষার কেস উত্পন্ন করতে আপনি এই জেলি প্রোগ্রামটি ব্যবহার করতে পারেন ।

— ডেনিস
সূত্র

আমাদের ভাষা যদি রাগযুক্ত অ্যারেগুলিকে সমর্থন না করে? আমাদের কি ইনপুটটিকে পুনর্গঠন করার অনুমতি দেওয়া হয়েছে বা আমাদের কি র‌্যাগড অ্যারেগুলি প্রয়োগ করা উচিত? অথবা সম্ভবত একটি ভিন্ন ভাষা ব্যবহার করবেন?

— মাইল

ইনপুট পুনর্গঠন দ্বারা আপনি কী বোঝাতে চান ?

— ডেনিস

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

— মাইল মাইল

অ্যারেগুলিও ভিন্ন ভিন্ন হতে পারে, তাই ভরাট মানগুলি তাদের আয়তক্ষেত্রাকার হিসাবে তৈরি করার পক্ষে যথেষ্ট হবে না। শেষ অবলম্বন হিসাবে, সবসময় স্ট্রিংগুলিতে অপারেট করার বিকল্প রয়েছে তবে এটি সম্ভবত খুব জটিল।

— ডেনিস

3

আরে, দুর্দান্ত শিরোনাম! .. এখন যে গুগল আমাকে এটি পেতে সহায়তা করেছে :-)

— লুইস মেন্ডো

3

পাইথ, 42 বাইট

L?sIb0heSyM+b0M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ

পরীক্ষা স্যুট

শেষ 4 বাইট কেবল ইনপুটটিতে ফাংশনটি চালায়।

L?sIb0heSyM+b0M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ

L?sIb0heSyM+b0
                  Define y(b), a helper function to calculate the depth.
 ?                Ternary:
  sIb             If b is invariant under the s function, which is only the case
                  if s is an int.
     0            The depth is 0.
           +b0    Add a 0 on to b. This handles the edge case where b is [].
         yM       Map each to their depth
       eS         Take the max.
      h           Add one.

M?qFyMJ,GH?yGgM.tJ0+GHgLFyDJ
M                               Define g(G, H), which calculates the Jelly +.
 ?                              Ternary:
       ,GH                      Form [G, H].
      J                         Save it to J.
    yM                          Map each to its depth.
  qF                            Check if they are equal.
          ?yG                   If so, check if the depth is nonzero.
               .tJ0             If so, transpose J, pairing each element of each
                                argument with the corresponding element of the
                                other. Pad with zeroes.
             gM                 Map each to its Jelly +.
                   +GH          If the depths are zero, return the normal sum.
                         yDJ    If the depths are different, order J by depth.
                      gLF       Apply the function which left-maps the Jelly +
                                function to the two values. The first is
                                treated as a constant, while the second varies
                                over elements over the second values.

— isaacg
সূত্র

7

এপিএল, 44 বাইট

{1=≡⍺⍵:⍺+⍵⋄=/∆←|≡¨⍺⍵:⊃∇¨/↓↑⍺⍵⋄</∆:⍺∘∇¨⍵⋄⍵∇⍺}

এপিএলগুলি +অ্যারেগুলিতেও বিতরণ করে, তবে ভিন্নভাবে এটি কার্যকরভাবে ব্যবহার করা যায় না। তবে সেখানে একটি অন্তর্নির্মিত গভীরতার ফাংশন রয়েছে ( ≡)।

ব্যাখ্যা:

1=≡⍺⍵:⍺+⍵: যদি গভীরতা ⍺ ⍵উভয়ই শূন্য হয় (এবং সুতরাং এর গভীরতা ⍺ ⍵1), এগুলি যুক্ত করুন।
∆←|≡¨⍺⍵: উভয় গভীরতা পরম নিতে ⍺এবং ⍵তাদের সঞ্চয় ∆। ( ≡সমস্ত উপাদানের একই গভীরতা না থাকলে একটি নেতিবাচক মান দেয়))
=/∆: যদি তাদের একই গভীরতা থাকে:
- ↓↑⍺⍵: দীর্ঘতর অ্যারের সাথে মিলিয়ে যাওয়ার জন্য শূন্যতম অ্যারে প্যাড করুন
- ⊃∇¨/: উভয় অ্যারে ফাংশন বিতরণ
</∆: এর গভীরতা যদি এর ⍺থেকে কম হয় ⍵:
- ⍺∘∇¨⍵: বাঁধুন ⍺এবং তারপরে ম্যাপ করুন⍵
⍵∇⍺: আর কিছু না হলে (এর ⍵চেয়ে গভীরতর ⍺), তর্কগুলি অদলবদল করে আবার চেষ্টা করুন।

— সামুদ্রিক
সূত্র

3

কখনও কখনও আমি মনে করি আমি এপিএলকে ঠিক জানি। তারপরে আমি এর মতো একটি মাস্টারপিস দেখতে পেয়েছি এবং বুঝতে পারি যে আমি এটি সবেই জানি।

— অ্যালেক্স এ

এপিএল চরিত্রগুলি কি সত্যিই বাইট হিসাবে গণনা করে?

— ধাতব

@ মেটালিম এপিএলে লিগ্যাসি কোড পৃষ্ঠা রয়েছে যা ইউনিকোডকে কয়েক দশক আগেই পূর্বাভাস দেয়। এর মধ্যে প্রতিটি চরিত্রই একক বাইট।

— ডেনিস

তারপরে এনকোডিং ধরণের সমাধান সহ সরবরাহ করা উচিত। শুধু আইএমও

— ধাতব

@metalim আমি একটি লিঙ্ক যুক্ত করেছি।

— Adám

5

গণিত, 122 বাইট

d=Depth
x_~f~y_/;d@x>d@y:=y~f~x
x_~f~y_/;d@x<d@y:=x~f~#&/@y
x_List~f~y_:=MapThread[f,{x,y}~PadRight~Automatic]
x_~f~y_=x+y

একটি পুনরাবৃত্ত ফাংশন সংজ্ঞা দেয় fযা যোগফলের গণনা করে। গাণিতিকের প্যাটার্ন মিলটি ব্যবহার করে এই ফাংশনটি চারটি পৃথক সংজ্ঞা দ্বারা গঠিত:

x_~f~y_/;d@x>d@y:=y~f~x

এর গভীরতা যদি এর xচেয়ে বেশি হয় yতবে আর্গুমেন্টগুলি অদলবদল করুন যাতে আমাদের কেবল বিতরণকে এক দিকে পরিচালনা করতে হয় (যা আমরা করতে পারি, যেহেতু সংযোজনীয় হয়)।

x_~f~y_/;d@x<d@y:=x~f~#&/@y

গভীরতা যদি xকম যে Thann হয় y, প্রতিটি মানকে প্রতিস্থাপন #মধ্যে yদিয়ে f[x,#]যা অসম গভীরতা অফ আর্গুমেন্ট বিতরণের যত্ন নেয়।

x_List~f~y_:=MapThread[f,{x,y}~PadRight~Automatic]

অন্যথায়, যদি একটি যুক্তি একটি তালিকা হয় (যা বোঝায় যে অন্যটিও একটি তালিকা, যেহেতু আমরা জানি যে তাদের একই গভীরতা রয়েছে), তবে আমরা উভয় যুক্তি একটি তালিকায় রাখি, সমান দৈর্ঘ্যে প্যাড দিয়ে থাকি PadRight[..., Automatic](যা কেবল একটি ফিল পূরণ করে) এটি আয়তক্ষেত্রাকার করতে জিরো দিয়ে অ্যারেটি ছড়িয়ে দেওয়া) এবং তারপরে দুটি তালিকার সাথে সম্পর্কিত জোড় MapThreadপ্রয়োগ fকরতে ব্যবহার করুন ।

এবং অবশেষে, বেস কেস:

x_~f~y_=x+y

যদি অন্য কোনও নিদর্শন মেলে না তবে আমাদের অবশ্যই দুটি সংখ্যা যুক্ত করার চেষ্টা করতে হবে, তাই আমরা এটিই করি।

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

5

হাস্কেল, দেড়শ বাইট

data L=S Int|V{v::[L]}
d(V z)=1+maximum(d<$>S 0:z);d _=0
S x!S y=S$x+y
x!y|d x<d y=V$(x!)<$>v y|d x>d y=y!x|1<2=V$v x#v y
(x:a)#(y:b)=x!y:a#b;a#b=a++b

ব্যাখ্যা

প্রথম লাইনটি একটি বীজগণিত তথ্য টাইপ সংজ্ঞায়িত করে L, যা হয় Sক্যালার (একটিযুক্ত Int) বা একটি ইক্টর ( রেকর্ড প্রাপ্তি ব্যবহার করে অ্যাক্সেস করা একটি Vতালিকা রয়েছে , যা একটি আংশিক ফাংশন ))LvL → [L]

দ্বিতীয় লাইনটি গভীরতার ফাংশনটি সংজ্ঞায়িত করে : একটি VEctor এর গভীরতা তার প্লাসের সর্বোচ্চ গভীরতা। আমি S 0ভেক্টরের মানগুলিতে প্রিপেন্ড করি , তাই depth [] == 1 + maximum [depth (S 0)] == 1। "অন্য কিছু" (একটি স্কেলার) এর গভীরতা 0।

তৃতীয় লাইনটি !(অতিরিক্ত ফাংশন) এর জন্য বেস কেসটি সংজ্ঞায়িত করে : স্কেলারের যোগফলটি কেবল একটি স্কেলার।

পঞ্চম লাইনটি একটি বৈকল্পিক সংজ্ঞা দেয় zipWith (!)যা কেবলমাত্র দীর্ঘতম তালিকা থেকে উপাদানগুলি বাছাই করে যখন তাদের মধ্যে একটি শূন্য থাকে।

চতুর্থ লাইনটি তিনটি ক্ষেত্রে বিভক্ত:

x!y | d x<d y = V$(x!)<$>v y
    | d x>d y = y!x
    | True    = V$v x#v y

এর গভীরতা যদি গভীরতার xচেয়ে কঠোরভাবে কম হয় তবে এর উপাদানগুলির উপর yম্যাপ করুন । (এর ব্যবহারটি বৈধ হওয়ার গ্যারান্টিযুক্ত, যেমন ))(x!)yvd(y) ≥ 1
এর গভীরতা xযদি কঠোরভাবে বেশি হয় তবে আর্গুমেন্টগুলি ফ্লিপ করুন এবং পুনরায় চালু করুন।
যদি তাদের গভীরতা সমান হয় তবে আর্গুমেন্টগুলি একসাথে জিপ করুন (!)। ( কেসটি বেস কেস হিসাবে হ্যান্ডেল করা হওয়ায় এর ব্যবহার vবৈধ হওয়ার গ্যারান্টিযুক্ত d(x) = d(y) = 0))

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

instance Show L where
  show (S x) = show x
  show (V x) = show x

lArg = V [S 1, V [S 2, V [S 3, V [S 4]]]]
rArg = V [S 10, V [S 20]]

তারপরে show (lArg ! rArg) == "[[11,[21]],[[12,[22]],[13,[24]]]]"।

— লিন
সূত্র

আমি কেবল এটি ঠিক করেছিলাম ^^ (আমি পঠনযোগ্যতার জন্য লাইনগুলি অদলবদল করেছিলাম, তবে আমি এটি ভুল উপায়ে করেছি ...) importকারণ আইডিয়নের একটি পুরানো হাস্কেল সংকলক রয়েছে। জিএইচসি-র আধুনিক সংস্করণগুলি রেখে দেওয়া <$>হয়েছে Prelude, সুতরাং Control.Applicativeআজকাল এটি ব্যবহারের জন্য আপনার আমদানি করার দরকার নেই ।

— লিন

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

— FryAmTheEggman

একদম ঠিক।

— লিন

ঠিক আছে, আপনার সমস্ত সহায়তার জন্য ধন্যবাদ :) "আমি কোনও দিন এই ভাষার হ্যাঙ্গ পেয়ে যাব" - 7 বছর আগে ফ্রাইআম দ্য এজিগম্যান।

— FryAmTheEggman

4

জাভা, 802 794 754 746 বাইট

"শেষ অবলম্বন হিসাবে" স্ট্রিংগুলিতে পরিচালনা করার চ্যালেঞ্জের জন্য আমি @ ডেনিসকে গ্রহণ করার সিদ্ধান্ত নিয়েছি কারণ এটি সম্ভবত "খুব জটিল" ছিল। এছাড়াও, গল্ফ চালু করার জন্য সবচেয়ে খারাপ ভাষায়।

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

একটি ক্লাসে মোড়ানো ফাংশন এবং পরীক্ষার কেস সহ পুরো প্রোগ্রাম

import java.util.*;
List<String>p(String s){List r=new ArrayList<String>();String p="";int l=0;for(char c:s.substring(1,s.length()-1).toCharArray()){l+=c=='['?1:c==']'?-1:0;if(c==','&&l<1){r.add(p);p="";}else p+=c;}if(p!="")r.add(p);return r;}
int d(String s){int l=0;if(s.contains("[")){for(String c:p(s))l=d(c)>l?d(c):l;l++;}return l;}
String f(String x,String y){int i=0;String r="";if(d(x)<1&&d(y)<1)r+=Integer.valueOf(x)+Integer.valueOf(y);else{r="[";if(d(x)<d(y))for(String k:p(y))r+=(i++<1?"":",")+f(x,k);else if(d(x)>d(y))for(String k:p(x))r+=(i++<1?"":",")+f(k,y);else for(;i<p(x).size()||i<p(y).size();i++)r+=(i<1?"":",")+(i<p(x).size()&&i<p(y).size()?f(p(x).get(i),p(y).get(i)):i<p(x).size()?p(x).get(i):p(y).get(i));r+="]";}return r;}

আমি এটি সি ++ এর পরে পোর্ট করতে পারি কারণ এটি আমার জানা অন্য ভাষা যা র‌্যাগড অ্যারেগুলিকে সমর্থন করে না, কারণ আমি ~~যথেষ্ট নিশ্চিত যে~~ এটি উত্তরটির চেয়ে কম হবে। এটি বেশিরভাগ ধারণার প্রমাণ ছিল তবে কোনও গল্ফিং টিপস এখনও প্রশংসা করা হবে!

@ ব্যবহারকারী 902383 থেকে -31 বাইটগুলি রূপান্তরিত চরিত্রের অ্যারের উপরে পূর্বাঞ্চ ব্যবহারের পরামর্শ দিয়েছিল এবং তারপরে আমি চূড়ান্ত অংশে যদি ইফ ব্লকগুলি পুনরায় সাজানো থেকে আরও কিছুটা সঞ্চয় করেছিলাম।

— মান কালি
সূত্র

ঐটা চিত্তাকর্ষক.

— ডেনিস

আমি মনে করি আপনি যদি স্ট্রিং থেকে প্রাপ্ত ফোরচ লুপ ট্রুপ চর অ্যারের সাথে আপনার লুপগুলি প্রতিস্থাপন করেন তবে আপনি বেশ কয়েকটি বাইট সংরক্ষণ করতে পারেন।

— ব্যবহারকারী 902383

1

এরর ... জাভা রাগযুক্ত অ্যারেগুলিকে সমর্থন করে; আপনি কি বলতে চাইছেন তা আমি নিশ্চিত নই। ব্যবহার করুন Object[], যা হয় নেস্টেড Object[]বা থাকে Integer। অথবা কেবল অ-জেনেরিক তালিকা।

— রবার্ট ফ্রেজার 18

4

পাইথন 2.7, 261 209 202 198 191 185 197 181 বাইট

FGITW তুচ্ছ সমাধান

সম্পাদনা: অবশ্যই @ ডেনিস এটিকে মারধর করে

ল্যাম্বডা এক্সপ্রেশন সম্পর্কে টিপস সহ 57 বাইট এবং অপরিশোধিত বন্ধনী থেকে 2 বাইট সংরক্ষণ করার জন্য @ লিক্যনুনকে ধন্যবাদ।

typeপরিবর্তে ব্যবহারের পরামর্শের কারণে @ আদনানকে 4 বাইটের জন্য ধন্যবাদisinstance

@ লিনকে সাথে -~এবং 7 বাইটের জন্য ধন্যবাদmap

z>=[]পরিবর্তে এর জন্য @ ফ্রাইআমডেজিগম্যানকে ধন্যবাদtype

ল্যাম্বডাকে অন্যথায় রূপান্তর করতে +12 বাইট এবং একটি বড় বাগটি ঠিক করতে

-16 বাইটস কেভিন লাউ - কেনিকে ধন্যবাদ জানায়

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

d=lambda z:z==[]or z>[]and-~max(map(d,z))
p=lambda x,y:p(y,x)if d(x)>d(y)else(x+y if d(x)<1 else[p(a,b)for a,b in zip(x,y)]+x[len(y):]+y[len(x):])if d(x)==d(y)else[p(a,x)for a in y]

— নীল
সূত্র

এটি পাইথন ২.7 এ পরিবর্তন করতে আরও ছোট এবং লিখতে হবেz==[]or`z`>']'and ...

— লিন

এছাড়াও, আমি প্রতিস্থাপন মনে max(d(a)+1for a in z)সঙ্গে -~max(d(a)for a in z)একটি বাইট সংরক্ষণ (কারণ আপনি আগে স্থান অপসারণ করতে পারেন max)। যা ঠিক তখন -~max(map(d,z))।

— লিন

পাইথন 2 এ স্যুইচ করা আরও পরিবর্তন [p(a,b)for a,b in zip(x,y)]করে যে আপনি রূপান্তর করতে পারেন map(p,x,y)। আপনি এখনও 3 এ এটি করতে পারেন তবে আপনাকে একটি কল যুক্ত করতে হবে list। আমি মনে করি আপনি লিনের পরামর্শটিও উন্নত করতে পারেন z>=[]। সম্পর্কিত নয়, typeকোনও স্থান সাশ্রয়ের জন্য আপনার তুলনা ক্রমের অদলবদল করতেও সক্ষম হওয়া উচিত ।

— FryAmTheEggman

এরর, আমি or`z`>'['অবশ্যই বলতে চাইছিলাম, তবে আমি আর আমার মন্তব্য পরিবর্তন করতে পারি না। তবে প্রকৃতপক্ষে, z>[]আরও খাটো ( ==কেসটি ইতিমধ্যে পরিচালনা করা হয়েছে)!

— লিন

তালিকাগুলি বিভিন্ন আকারের হয় যখন @ ফ্রাইআমTheEggman মানচিত্র কাজ করে না; জিপটি সঠিকভাবে কাটা হয়েছে। আমি তালিকাটি চেক করে আপডেট করব

— ব্লু

3

পাইথন 2, 145 136 বাইট

d=lambda t:t>{}and-~max(map(d,t+[0]))
s=lambda x,y:s(y,x)if d(y)<d(x)else map(s,(x,[x]*len(y))[d(x)<d(y)],y)if d(y)else(x or 0)+(y or 0)

আইডিয়নে এটি পরীক্ষা করুন ।

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

পাইথন 2-এ, সমস্ত সংখ্যার সব অভিধানের চেয়ে কম, তবে সমস্ত তালিকা আরও বড়। ঘ যাও recursively গভীরতা নির্ণয় টি ফিরে 0 পূর্ণসংখ্যার বা তার উপাদান এবং অতল এর বৃদ্ধি সর্বোচ্চ 0 । t+[0]খালি তালিকা বিশেষ-কেসিং এড়ানো।

s পুনরাবৃত্তভাবে x এবং y এর জেলি যোগফলের গণনা করে ।

তাহলে Y এর গভীরতা অতিক্রম করে এক্স এর, s(y,x)কল গুলি আনা আর্গুমেন্ট, নিশ্চিত করুন উপার্জন দিয়ে ঘ (x) এর ≤ ঘ (Y) ।

যদি y এর ইতিবাচক গভীরতা map(s,(x,[x]*len(y))[d(x)<d(y)],y)থাকে তবে নিম্নলিখিতটি করা হয়।

তাহলে এক্স 's এবং Y এর depths এর সাথে মেলে, এটা executes map(s,x,y), ম্যাপিং গুলি সব উপাদানের উপরে এক্স এবং সংশ্লিষ্ট উপাদানের Y ।

বিভিন্ন দৈর্ঘ্যের তালিকার ক্ষেত্রে, মানচিত্র সংক্ষিপ্ত তালিকায় নিখোঁজ উপাদানগুলির জন্য বাম বা ডান যুক্তি হিসাবে কোনওটিকেই পাস করবে না ।
তাহলে এক্স এর গভীরতা কম Y এর, এটা executes map(s,[x]*len(y),y), ম্যাপিং গুলি (এক্স, ·) উপর Y ।

তাহলে Y (এবং তাই এক্স ) গভীরতা রয়েছে 0 , (x or 0)+(y or 0)falsy আর্গুমেন্টগুলি (প্রতিস্থাপন কোনটি বা 0 শূণ্যসমূহ এবং আয় ফলে পূর্ণসংখ্যার যোগফল সহ)।

— ডেনিস
সূত্র

1

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

f=(a,b,g=a=>a.map?1+Math.max(0,...a.map(g)):0)=>g(a)<g(b)?f(b,a):g(b)<g(a)?a.map(e=>f(e,b)):g(a)?a.length<b.length?f(b,a):a.map((e,i)=>f(e,b[i]||0)):a+b
;t=(x,y,z)=>o.textContent+=`
${JSON.stringify(x)}
${JSON.stringify(y)}
${JSON.stringify(z)}
${JSON.stringify(f(x,y))}
`;`
0 + 0                           = 0
[-1, 0, -1] + [1]               = [0, 0, -1]
[] + [0]                        = [0]
[] + 0                          = []
[] + []                         = []
[[], 0] + []                    = [[], []]
[1, 2, 3] + 10                  = [11, 12, 13]
[1, 2, 3] + [10]                = [11, 2, 3]
[1, 2, 3] + [10, [20]]          = [[11, 12, 13], [21, 2, 3]]
[1, 2, 3, []] + [10, [20]]      = [11, [22], 3, []]
[1, [2, [3, [4]]]] + [10, [20]] = [[11, [21]], [[12, [22]], [13, [24]]]]`.slice(1).split`
`.map(l=>t(...l.split(/ [+=] /).map(a=>JSON.parse(a))));

<pre id=o></pre>

স্নিপেট প্রসারিত করুন

— নিল
সূত্র

1

রুবি 2.3, 143 145 148 149 বাইট

zipবিভিন্ন দৈর্ঘ্যের অ্যারে এবং mapমাল্টি-আর্গুমেন্ট ফাংশনগুলির সাথে কীভাবে কাজ করে তা রুবির এই সমস্ত ছোট্ট কৌতুক রয়েছে যা গল্ফকে ডাউন করার জন্য এটি বেশ মজা দেয়।

f=->x,y{d=->a{-~(a.map(&d).max||0)rescue 0}
d[x]<d[y]?y.map{|e|f[x,e]}:d[x]>d[y]?x.map{|e|f[e,y]}:d[x]<1?x+(y||0):[*x.zip(y).map(&f),*y[x.size..-1]]}

— মান কালি
সূত্র

এটি খুব আকর্ষণীয় - এই ফাংশনের জন্য আমি আগে কখনও ত্রুটি দেখিনি। অন্যান্য বাগের কারণে আমি এখনও কিছু জিনিস প্যাচ করেছি, তবে এটি আমার পক্ষে কাজ করে (তবে এখনও আদর্শে ব্যর্থ হয়)। আমি মনে করি এটি আদর্শ কারণ ২.১ রান করে এবং আমার কাছে ২.৩ রয়েছে, সুতরাং সম্ভবত ২.১ টি mapশেষদিকে যেভাবে সেট আপ করে চলেছে কেবল দ্বি-আর্গ ফাংশনটিতে না পারে । এখানে ২.১ এর জন্য সম্পাদিত একটি সংস্করণ রয়েছে যা কাজ mapশেষে কলটিকে টুইট করে works ideone.com/q1jqTA

— মান কালি

1

জুলিয়া, 113 বাইট

~=endof;!t=0t!=0&&1+maximum(!,[t;0])
x::Array+y::Array=(!x,~x)>(!y,~y)?y+x:!x<!y?map(t->x+t,y):~x<~y?[x;0]+y:x.+y

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

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

~=endof

এন্ডোফের জন্য একটি 1 বাইট ওরফে তৈরি করে , যা অ্যারের দৈর্ঘ্য দেয়।

!t=0t!=0&&1+maximum(!,[t;0])

একটি গভীরতা ফাংশন সংজ্ঞায়িত করে। গভীরতা টি শূন্য যদি এবং কেবল যদি হয় 0t == 0 । যদি তা না হয় তবে টি একটি অ্যারে হয় এবং এর গভীরতাটিকে এর উপাদানগুলির গভীরতা এবং 0 এর সর্বাধিক বর্ধিত হিসাবে গণনা করা হয় । [t;0]একটি appends 0 অ্যারেতে টি , এইভাবে বিশেষ-ক্ষেত্রে প্রয়োজন খালি অ্যারে এড়ানো।

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

একজোড়া অ্যারে এর মাধ্যমে আমরা + পুনরায় সংজ্ঞা দিই

x::Array+y::Array=(!x,~x)>(!y,~y)?y+x:!x<!y?map(t->x+t,y):~x<~y?[x;0]+y:x.+y

এটি এর সংজ্ঞাটিকে প্রভাবিত করে না পূর্ণসংখ্যা / পূর্ণসংখ্যা, অ্যারে / পূর্ণসংখ্যা বা পূর্ণসংখ্যা / অ্যারে আর্গুমেন্টের জন্য + ।

(!x,~x)>(!y,~y)ডিক্সোগ্রাফিকভাবে x এবং y উভয়ের গভীরতা এবং দৈর্ঘ্যের জোড়গুলির সাথে তুলনা করে । যদি এক্স এর গভীরতা y এর চেয়ে বেশি হয় , বা যদি তাদের গভীরতার সাথে মেলে এবং x এর দৈর্ঘ্য y এর বেশি হয় , তবে y+xপুনরাবৃত্তি কল করুন + + আনা আর্গুমেন্ট সহ।

অন্যথায়, এক্স এর গভীরতা y এর চেয়ে কম !x<!yহলে পরীক্ষা করে । যদি তা হয় তবে এক্স + maps মানচিত্রmap(t->x+t,y) y এর উপরে ।

যদি গভীরতা মেলে, এক্স y এর চেয়ে কম হয় ~x<~yতবে পরীক্ষা করে । যদি তা হয়, পুনরাবৃত্তভাবে কল +[x;0]+y একটি সংযোজন পর 0 বাম যুক্তি।

অবশেষে, যদি গভীরতা এবং দৈর্ঘ্য উভয়ই অভিন্ন হয় তবে এক্স এর সমস্ত উপাদান এবং y এর সংশ্লিষ্ট উপাদানগুলির চেয়ে x.+yমানচিত্র + ।

— ডেনিস
সূত্র

জাম এর মতো যুক্ত করবেন না

পটভূমি

সংজ্ঞা

কার্য

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

পাইথ, 42 বাইট

এপিএল, 44 বাইট

গণিত, 122 বাইট

হাস্কেল, দেড়শ বাইট

ব্যাখ্যা

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

জাভা, 802 794 754 746 বাইট

পাইথন 2.7, 261 209 202 198 191 185 197 181 বাইট

পাইথন 2, 145 136 বাইট

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

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

রুবি 2.3, 143 145 148 149 বাইট

জুলিয়া, 113 বাইট

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