প্রতিটি মাত্রায় যোগফল


20

আপনাকে পূর্ণসংখ্যার একটি বহুমাত্রিক অ্যারে দেওয়া হয়। প্রতিটি মাত্রার একটি নির্দিষ্ট আকার থাকে (যাতে এটি 2 ডি হলে সর্বদা আয়তক্ষেত্রাকার হবে)। আপনার প্রোগ্রামটির প্রতিটি মাত্রায় অঙ্কগুলি গণনা করা উচিত এবং সেই পরিমাণের নতুন শেষ আইটেম হিসাবে যোগফলগুলি যুক্ত করা উচিত।

ধরুন ইনপুট এবং আউটপুট অ্যারেগুলি হ'ল A এবং B, এবং A এর মাত্রা i এর আকার n i । বি এর A এর সমান সংখ্যক মাত্রা এবং মাত্রার আকার আমি n i +1 হব । বি জে 1 , জে 2 , ..., জে এম হ'ল A কে 1 , কে 2 , ..., কে এম এর যোগফল যেখানে:

  • k i = j i if j i <= n i
  • 0 <কে আই <= n আমি যদি জে i = এন আই +1

ইনপুট জন্য:

[[1 2 3]
 [4 5 6]]

আপনার প্রোগ্রাম (বা ফাংশন) এর আউটপুট করা উচিত:

[[1 2 3 6]
 [4 5 6 15]
 [5 7 9 21]]

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

ইনপুটটির কমপক্ষে 1 টি মাত্রা রয়েছে এবং অ্যারেতে কমপক্ষে 1 টি আইটেম রয়েছে।

এটি কোড-গল্ফ। সংক্ষিপ্ততম কোড জিতেছে।

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

Input:
[5 2 3]
Output:
[5 2 3 10]

Input:
[[1 2 3] [4 5 6]]
Outputs:
[[1 2 3 6] [4 5 6 15] [5 7 9 21]]

Input:
[[[1] [1] [1] [0]]]
Output:
[[[1 1] [1 1] [1 1] [0 0] [3 3]] [[1 1] [1 1] [1 1] [0 0] [3 3]]]

Input:
[[[[-1]]]]
Output:
[[[[-1 -1] [-1 -1]] [[-1 -1] [-1 -1]]] [[[-1 -1] [-1 -1]] [[-1 -1] [-1 -1]]]]

আপনি কি 16 বাইট এপিএল সমাধান পোস্ট করবেন? আপনি যদি না করেন, আমি কি করতে পারি?
ডেনিস

@ ডেনিস আপনি এটি পোস্ট করা উচিত।
jimmy23013

উত্তর:


9

জে, 14 বাইট

#@$(0|:],+/^:)

ব্যবহার:

   ]a=.i.2 3
0 1 2
3 4 5

   (#@$(0|:],+/^:)) a    NB. parens are optional
0 1 2  3
3 4 5 12
3 5 7 15

ফাংশনটি নিম্নলিখিতগুলির সমতুল্য (0|:],+/)^:(#@$)তবে প্যারেন্স সংরক্ষণ করতে একটি ব্যবহারকারী-সংজ্ঞায়িত অ্যাডভারব ব্যবহার করে।

ডান থেকে বামে পরবর্তী কোডটির ব্যাখ্যা:

  • ^:(#@$)মাত্রা ^:সংখ্যার জন্য পুনরাবৃত্তি :#$

    • ],+/শেষ মাত্রায় এর যোগফলের সাথে ,যুক্তির ]সাথে একমত হন+/
    • 0|:মাত্রা-তালিকার শেষে |:প্রথমটিকে রেখে ডাইমেনশনগুলি ঘোরান0
  • উপরোক্ত পদ্ধতিটি করার পরে আমরা সমস্ত মাত্রার অঙ্কগুলি দিয়ে মূল ইনপুটটি ফিরে পাই।

আমার পুরানো সমাধানের জন্য পুনর্বিবেচনার ইতিহাস পরীক্ষা করুন।

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


15

গণিত, 32 20 বাইট

#/.List->({##,+##}&)&

উদাহরণ:

In[1]:= #/.List->({##,+##}&)&[{{1, 2, 3}, {4, 5, 6}}]

Out[1]= {{1, 2, 3, 6}, {4, 5, 6, 15}, {5, 7, 9, 21}}

ব্যাখ্যা:

এর সম্পূর্ণ ফর্মটি {{1, 2, 3}, {4, 5, 6}}হ'ল List[List[1, 2, 3], List[4, 5, 6]]। তারপরে Listক্রিয়াকলাপের সাথে এক্সপ্রেশনটিতে সমস্ত গুলি প্রতিস্থাপন করুন ({##,+##}&)


10

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

from numpy import*
a=copy(input())
for d in r_[:a.ndim]:a=r_[`d`,a,sum(a,d,keepdims=1)]
print a

এটি প্রতিটি মাত্রার উপর পুনরাবৃত্তি করে NumPy ব্যবহার করে এর যোগফলগুলি যুক্ত করে।

আমি নম্পপি'র কাছে হোঁচট খেয়েছি r_, যা গল্ফ করার পক্ষে দুর্দান্ত। r_[:n]এর চেয়ে খাটো range(n)এবং অনেক বেশি শক্তিশালী (যেমন r_[:4, 7, 8, 10:100:10])। এটি একটি স্বতন্ত্র অক্ষ বরাবর কনট্যাকটেশন এর মতো অন্যান্য জিনিসও করতে পারে।

ব্যবহারের উদাহরণ:

$ python sum.py
[[1, 2, 3], [4, 5, 6]]
[[ 1  2  3  6]
 [ 4  5  6 15]
 [ 5  7  9 21]]

7

এপিএল, 16 15 বাইট

{×≡⍵:∇¨⍵,+/⍵⋄⍵}

3 বাইট বন্ধ করে সঠিক ইনপুট ফর্ম্যাটটি বের করার জন্য @ ইউজার 23013 কে ধন্যবাদ।

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

ধারণা

সাধারণ ধারণাটি আমার সিজেএম জমা দেওয়ার মতোই, যার জন্য এপিএল অনেক খাটো বাস্তবায়ন করতে দেয়। এটি মাত্র দুটি পদক্ষেপ নিয়ে গঠিত:

  1. এর বাহ্যিক মাত্রা জুড়ে অ্যারে যোগ করুন।

  2. প্রতিটি subarray জন্য পদক্ষেপ 1 পুনরাবৃত্তি।

কোড

{             } ⍝ Define a monadic function with argument ⍵ and reference ∇.
 ×≡⍵:           ⍝ If the depth of ⍵ is positive:
     ∇          ⍝   Apply this function...
      ¨         ⍝   to each element of...
       ⍵,       ⍝   the concatenation of ⍵...
         +/⍵    ⍝   and the sum across ⍵.
            ⋄⍵  ⍝  Else, return ⍵.

আপনার মূল কোডটির জন্য যথাক্রমে ইনপুট ফর্ম্যাটটি বের করা হয়েছে: ,⊂(,1)(,1)(,1)(,0)এবং ,⊂,⊂,⊂,¯1যথাক্রমে। সুতরাং আপনি অন্য একটি চরিত্র মুছে ফেলতে পারেন।
jimmy23013

2
@ user23013: সুতরাং আমার কোডটি কাজ করেছে! আপনাকে এমন একটি প্রোগ্রামিং ভাষা পছন্দ করতে হবে যেখানে আসল কোডের চেয়ে ইনপুট ফর্ম্যাটটি পাওয়া ঠিক আরও কঠিন ...
ডেনিস

6

পিপ , 18 15 বাইট

{a-a?fMaAE$+aa}

এটি একটি বেনামে ফাংশন, যা অ্যারেটিকে আর্গুমেন্ট হিসাবে গ্রহণ করে এবং ফলাফলটি ফেরত দেয়। নমুনা প্রার্থনা, -pপাঠযোগ্য আউটপুট পেতে পতাকা ব্যবহার করে :

C:\> pip.py -pe "( {a-a?fMaAE$+aa} [[1 2 3] [4 5 6]] )"
[[1;2;3;6];[4;5;6;15];[5;7;9;21]]

ধারণাটি মূলত ডেনিসের এপিএলের মতো , যদিও স্বাধীনভাবে প্রাপ্ত। আরো নির্দিষ্টভাবে:

{             }  Define a lambda function with parameter a
 a-a?            Shortest way I could find to test whether the argument is a list
                 or scalar: subtracting a number from itself gives 0 (falsy);
                 subtracting a list from itself gives a list of zeros (truthy!)
     fM          If truthy, it's a list, so map the same function (f) recursively to:
       aAE         Argument, with appended element...
          $+a      ...sum of argument (fold on +)
             a   If falsy, it's a scalar, so just return it

এই পদ্ধতিটি কাজ করে কারণ +(অন্যান্য অনেক অপারেটর সহ) পিপ-এর তালিকাগুলিতে আইটেম-ভিত্তিতে ফাংশন করে - এপিএলের মতো অ্যারে-প্রোগ্রামিং ভাষার দ্বারা অনুপ্রাণিত একটি বৈশিষ্ট্য। সুতরাং আপনি যখন $+একটি তালিকা [[1 2 3] [4 5 6]], ফলাফল [5 7 9]পছন্দসই হিসাবে। তালিকা-বা-স্কেলার পরীক্ষায়ও ব্যবহৃত হয়: [1 2 3] - [1 2 3]দেয় [0 0 0]যা সত্যবাদী (খালি তালিকা ব্যতীত সমস্ত তালিকার মতো)।

পূর্ববর্তী 18-বাইট সংস্করণ:

{Ja=a?a(fMaAE$+a)}

পরিবর্তন করুন:

  1. স্কেলার-বা-তালিকা পরীক্ষায় একটি বাইট সংরক্ষণ করা - পূর্ববর্তী পদ্ধতিটি ছিল যুক্তির সাথে যুক্ত হওয়া (খালি স্ট্রিংয়ে) এবং এটির সাথে যুক্ত হওয়া স্বের সমান কিনা তা পরীক্ষা করা (কারণ কাজ করে [1 2 3] != 123);
  2. প্রথম বন্ধনী মুছে ফেলা হয়েছে। এগুলি মূলতে প্রয়োজনীয় কারণ Mতুলনায় নিম্নতর অগ্রাধিকার ?(যদিও আমি সম্ভবত এটি পরিবর্তন করতে চলেছি, বিশেষত এখন): এগুলি ছাড়া কোডটি বিশ্লেষণ (Ja=a?af)M(aAE$+a)করে উদ্ভট ত্রুটি বার্তাগুলির দিকে নিয়ে যায়। যাইহোক, একটি ত্রিনিরি অপারেটরের মাঝের আর্গুমেন্টটি যে কোনও নজির হতে পারে , কোনও বন্ধনীগুলির প্রয়োজন নেই of সুতরাং তালিকাটি সত্যবাদী কেস তৈরি করে আমি সেই দুটি বাইট সংরক্ষণ করতে পারি।

2
এটি একটি আকর্ষণীয় ভাষা যা আপনি সেখানে পেয়েছেন। আইটেমওয়্যার অপারেটরগুলি সিজেম এবং পাইথের মধ্যে কী অনুপস্থিত রয়েছে।
ডেনিস

@ ডেনিস ধন্যবাদ! এটি এখনও অনেক বেশি কাজ চলছে, তবে কিছু কাজ রয়েছে যা এটির সাথে বেশ কার্যকর।
ডিএলসাস

5

এপিএল (25)

{N⊣{N,[⍵]←+/[⍵]N}¨⍳⍴⍴N←⍵}

এপিএলের অ্যারেগুলিতে অন্তর্নির্মিত মাত্রা রয়েছে, সুতরাং এটি এমন একটি ফাংশন যা এন- ডাইমেনশনাল অ্যারে নেয় এবং তারপরে প্রতিটি মাত্রা বরাবর যোগফল যোগ করে।

      {N⊣{N,[⍵]←+/[⍵]N}¨⍳⍴⍴N←⍵} ↑(1 2 3)(4 5 6)
1 2 3  6
4 5 6 15
5 7 9 21

ব্যাখ্যা:

  • N←⍵: অ্যারে সংরক্ষণ করুন N
  • ⍴⍴N: মাত্রা পরিমাণ আছে পেতে N। ( মাত্রা দেয়, যেমন ⍴↑(1 2 3)(4 5 6)দেয় 2 3, তাই ⍴⍴মাত্রার মাত্রা দেয়))
  • {... }¨⍳: প্রতিটি সংখ্যার জন্য 1 থেকে ⍴⍴N:
    • +/[⍵]N: Nমাত্রা বরাবর যোগফল
    • N,[⍵]←: Nসেই মাত্রায় ফলাফলটিতে যোগ দিন
  • N: অবশেষে, ফিরে N

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

3
@ ডেনিস: আপনাকে একটি বহুমাত্রিক অ্যারেটি পাস করতে হবে pass কি ↑(1 2 3)(4 5 6)করছে কেবল ব্যবহার 2 1-মাত্রিক বেশী থেকে একটি 2-মাত্রিক অ্যারে নির্মাণ করছে । এটি একটি অন্তর্নির্মিত স্বরলিপি নয় এবং এটি আপনার ভাবার উপায়টিকে সাধারণীকরণ করে না। তৃতীয় এবং চতুর্থ অ্যারেগুলি নির্মাণের ক্যানোনিকাল উপায়টি ছিল 1 4 1⍴1 1 1 0এবং 1 1 1 1⍴¯1তবে এটিগুলির আকারগুলি উল্লেখ না করেই এটি নির্মাণ করা সম্ভব যেমন, তৃতীয় অ্যারেটিও নির্মিত হতে পারে ↑⍉⍪(,1)(,1)(,1)(,0), চতুর্থটি দিয়ে নির্মিত যেতে পারে ↑⍪⊂⍪¯1
মেরিনাস

ঠিক আছে, যা সবকিছু ব্যাখ্যা করে। আমার পুনরাবৃত্তির পদ্ধতির নির্মোহ প্রয়োগ বাস্তবায়িত হয়েছিল যা আমি ভেবেছিলাম যে অ্যারেগুলি ছিল (উদাহরণস্বরূপ f←{0=≡⍵:⍵⋄f¨⍵,+/⍵}⋄f((1 2)(3 4))((5 6)(7 8))), তবে মনে হয় নেস্টেড ভেক্টর এবং অ্যারেগুলি পৃথক এবং প্রাক্তন এককজন থেকে স্কেলারকে আলাদা করে না ...
ডেনিস

2
@Dennis Golfed: {×≡⍵:∇¨⍵,+/⍵⋄⍵}((1 2)(3 4))((5 6)(7 8))। ফিক্সড: {×⍴⍴⍵:∇↓⍵,+/⍵⋄⍵}1 4 1⍴1 1 1 0। এটি এখন ম্যাথমেটিকার চেয়ে ছোট ...
jimmy23013

3

সিজেম, 36 বাইট

{_`{'[<}#:D{_":"D'.e]'++~a+{S}%}&}:S

এটি একটি পুনরাবৃত্ত নামক ফাংশন যা স্ট্যাক থেকে একটি অ্যারে পপ করে এবং বিনিময়ে একটি ছেড়ে দেয়।

সিজেএম ইন্টারপ্রেটারে পরীক্ষার কেসগুলি চেষ্টা করে দেখুন ।

ধারণা

দুঃখের বিষয়, সিজেমে কিছু অটোমেজিকাল অপারেটর নেই যা নির্বিচারে নেস্টেড অ্যারে যুক্ত করতে দেয়, তাই আমাদের এটি নিজেরাই প্রয়োগ করতে হবে। ভাগ্যক্রমে, এটি এমন দুটি ইনফিক্স অপারেটর, :(হ্রাস) এবং .(ভেক্টরাইজ) করবে যা এই কাজের জন্য সহায়ক হিসাবে প্রমাণিত হবে।

প্রথম ধাপটি মাত্রার সংখ্যা গণনা করছে। এটি সহজ: অ্যারেটিকে তার স্ট্রিং উপস্থাপনায় রূপান্তর করুন এবং শীর্ষস্থানীয় [ এর এর সংখ্যা গণনা করুন ।

এখন, একটি মাত্রার অ্যারে হ্রাস করতে, আপনি সাধারণত কেবল চালান :+:

[1 2] :+ e# Pushes 3.

দুটি মাত্রার অ্যারের জন্য, +সংযোজনের পরিবর্তে সংক্ষেপণ সম্পাদন করবে, সুতরাং আমাদের এটি ভেক্টরাইজ করতে হবে:

[[1 2][3 4]] :.+ Pushes [4 6].

এখন, তিন মাত্রার অ্যারের জন্য, .+দুটি মাত্রার অ্যারেগুলিতে পরিচালনা করবে এবং আরও একবার কনট্যাকটেশন করবে। এবার, আমাদের ভেক্টরাইজ করতে হবে .+:

[[[1 2][3 4]][[5 6][7 8]]] :..+ e# Pushes [[[6 8] [10 12]]].

সাধারণ ক্ষেত্রে, মাত্রা D এর অ্যারে , আমাদের এক :, D - 1 . এর এবং একটি চেইন করতে হয় +

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

কোড

{                                }:S e# Define S:
 _`                                  e#   Push a string representation of a the array.
   {'[<}#                            e#   Find the index of the first non-bracket.
         :D                          e#   Save it in D.
           {                   }&    e#   If D is positive:
            _                        e#     Push a copy of the array.
             ":"D'.e]                e#     Pad ":" with "."s to a string of length D.
                     '++~            e#     Add a "+" to the string and evaluate.
                         a+          e#     Wrap the result in a array and concatenate.
                           {S}%      e#     Apply S to the elements of the array.

2

রুবি ( 181 139 119 108 বাইট)

def d a;a.push a[0].to_s['[']?a.map{|x|d x}.transpose.map{|x|x.reduce:+}:a.reduce(:+)end
p d eval ARGF.read

ধরে নিই ইনপুটটি JSON হিসাবে পাস হয়েছে।


এবং প্রকৃতপক্ষে আপনি কেবল একটি পার্সড অ্যারে গ্রহণ করে একটি ফাংশন লিখতে পারেন এবং একটি অ্যারের ফিরিয়ে দেন dএবং এই উত্তরের জন্য কেবল 95 বাইটগুলি গণনা করতে পারেন ।
জিমি 23013

2

জাভা, 669 বাইট

মিথ্যা বলব না, আমি এইটার জন্য নিজেকে নিয়ে বেশ গর্বিত: পি

import java.lang.reflect.Array;enum S{D;<A>A s(A a){int l=Array.getLength(a),x=0;Class t=a.getClass();Class c=t.getComponentType();A r=(A)Array.newInstance(c,l+1);System.arraycopy(a,0,r,0,l);if(t==int[].class)for(;x<l;)((int[])r)[l]=((int[])r)[l]+((int[])r)[x++];else{for(;x<l;)Array.set(r,x,S.this.s(Array.get(r,x++)));Object o=Array.get(r,0);for(;--x>0;)o=s(o,Array.get(r,x));Array.set(r,l,o);}return r;}<A>A s(A a,A b){int l=Array.getLength(a),x=0;Class t=a.getClass();A r=(A)Array.newInstance(t.getComponentType(),l);if(int[].class==t)for(;x<l;)((int[])r)[x]=((int[])a)[x]+((int[])b)[x++];else for(;x<l;)Array.set(r,x,s(Array.get(a,x),Array.get(b,x++)));return r;}}

পরীক্ষার সাথে প্রসারিত:

import java.lang.reflect.Array;
import java.util.Arrays;

public enum SumOf{
    Dimensions;

    <A>A sum(A array){ //call this method to solve the challenge
        int length=Array.getLength(array),x=0;
        Class arrayType=array.getClass();
        Class componentType=arrayType.getComponentType();
        //grow the array to include the sum element
        A result=(A)Array.newInstance(componentType,length+1);
        System.arraycopy(array,0,result,0,length);
        if(arrayType==int[].class) //one-dimensional array needs to be handled separately
            for(;x<length;) //find the sum
                ((int[])result)[length]=((int[])result)[length]+((int[])result)[x++];        
        else{ //multi-dimensional array
            for(;x<length;) //find the sum for each element in this dimension's array
                Array.set(result,x,sum(Array.get(result,x++)));
            //find the total sum for this dimension's array
            Object s=Array.get(result,0);
            for(;--x>0;)
                s=_sum(s,Array.get(result,x)); //add the 2 elements together
            Array.set(result,length,s);
        }
        return result;
    }

    <A>A _sum(A arrayA,A arrayB){ //this method is used by the previous method
        int length=Array.getLength(arrayA),x=0;
        Class arrayType=arrayA.getClass();
        A result=(A)Array.newInstance(arrayType.getComponentType(),length);
        if(int[].class==arrayType) //one-dimensional array needs to be handled separately
            for(;x<length;) //find the sum of both arrays
                ((int[])result)[x]=((int[])arrayA)[x]+((int[])arrayB)[x++];
        else
            for(;x<length;) //find the sum of both arrays
                Array.set(result,x,sum(Array.get(arrayA,x),Array.get(arrayB,x++)));
            return result;
        }

    static int[] intArray( int firstElement, int...array ) {
        if( array == null ) array = new int[0];
        array = Arrays.copyOf( array, array.length + 1 );
        System.arraycopy( array, 0, array, 1, array.length - 1 );
        array[0] = firstElement;
        return array;
    }

    static <E> E[] arrayArray( E firstElement, E...array ) {
        if( array == null ) array = (E[]) Array.newInstance( firstElement.getClass(), 0 );
        array = Arrays.copyOf( array, array.length + 1 );
        System.arraycopy( array, 0, array, 1, array.length - 1 );
        array[0] = firstElement;
        return array;
    }

    static void printIntArray( int[]array ){
        System.out.print("[ ");
        for( int x = 0; x < array.length; x++ )
            System.out.print( array[x] + " " );
        System.out.print("] ");
    }

    static < A > void printArray( A array ) {
        if( array.getClass() == int[].class ){
            printIntArray( (int[]) array );
        }
        else {
            System.out.print("[ ");
            int length = Array.getLength( array );
            for( int x = 0; x < length; x++ )
                printArray( Array.get( array, x ) );
            System.out.print("] ");
        }
    }

    public static void main(String[]s){
        int[] test01 = intArray( 5, 2, 3 );
        System.out.print("Input: ");
        printArray( test01 );
        System.out.print("\nOutput: ");
        printArray( SumOf.Dimensions.sum( test01 ) );
        System.out.println();

        int[][] test02 = arrayArray( intArray( 1, 2, 3 ), intArray( 4, 5, 6 ) );
        System.out.print("\nInput: ");
        printArray( test02 );
        System.out.print("\nOutput: ");
        printArray( SumOf.Dimensions.sum( test02 ) );
        System.out.println();

        int[][][] test03 = arrayArray( arrayArray( intArray( 1 ), intArray( 1 ), intArray( 1 ), intArray( 0 ) ) );
        System.out.print("\nInput: ");
        printArray( test03 );
        System.out.print("\nOutput: ");
        printArray( SumOf.Dimensions.sum( test03 ) );
        System.out.println();

        int[][][][] test04 = arrayArray( arrayArray( arrayArray( intArray( -1 ) ) ) );
        System.out.print("\nInput: ");
        printArray( test04 );
        System.out.print("\nOutput: ");
        printArray( SumOf.Dimensions.sum( test04 ) );
        System.out.println();

        int[][][] test05 = arrayArray( arrayArray( intArray( 1, 2, 3 ), intArray( 4, 5, 6 ), intArray( 7, 8, 9 ) ), arrayArray( intArray( 11, 12, 13 ), intArray( 14, 15, 16 ), intArray( 17, 18, 19 ) ), arrayArray( intArray( 21, 22, 23 ), intArray( 24, 25, 26 ), intArray( 27, 28, 29 ) ) );
        System.out.print("\nInput: ");
        printArray( test05 );
        System.out.print("\nOutput: ");
        printArray( SumOf.Dimensions.sum( test05 ) );
        System.out.println();
    }

}

প্রসারিত পরীক্ষার সংস্করণটি চালিত করে এটি প্রিন্ট করে:

Input: [ 5 2 3 ] 
Output: [ 5 2 3 10 ] 

Input: [ [ 1 2 3 ] [ 4 5 6 ] ] 
Output: [ [ 1 2 3 6 ] [ 4 5 6 15 ] [ 5 7 9 21 ] ] 

Input: [ [ [ 1 ] [ 1 ] [ 1 ] [ 0 ] ] ] 
Output: [ [ [ 1 1 ] [ 1 1 ] [ 1 1 ] [ 0 0 ] [ 3 3 ] ] [ [ 1 1 ] [ 1 1 ] [ 1 1 ] [ 0 0 ] [ 3 3 ] ] ] 

Input: [ [ [ [ -1 ] ] ] ] 
Output: [ [ [ [ -1 -1 ] [ -1 -1 ] ] [ [ -1 -1 ] [ -1 -1 ] ] ] [ [ [ -1 -1 ] [ -1 -1 ] ] [ [ -1 -1 ] [ -1 -1 ] ] ] ] 

Input: [ [ [ 1 2 3 ] [ 4 5 6 ] [ 7 8 9 ] ] [ [ 11 12 13 ] [ 14 15 16 ] [ 17 18 19 ] ] [ [ 21 22 23 ] [ 24 25 26 ] [ 27 28 29 ] ] ] 
Output: [ [ [ 1 2 3 6 ] [ 4 5 6 15 ] [ 7 8 9 24 ] [ 12 15 18 45 ] ] [ [ 11 12 13 36 ] [ 14 15 16 45 ] [ 17 18 19 54 ] [ 42 45 48 135 ] ] [ [ 21 22 23 66 ] [ 24 25 26 75 ] [ 27 28 29 84 ] [ 72 75 78 225 ] ] [ [ 33 36 39 108 ] [ 42 45 48 135 ] [ 51 54 57 162 ] [ 126 135 144 405 ] ] ] 

প্রসারিত সংস্করণ, রেখাটির জন্য erm _সুম (...) পদ্ধতিতে _সুম (...) বলা উচিত, যোগফল (...) নয়। আমার খারাপ
জ্যাক আম্মো
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.