ผลรวมในแต่ละมิติ


20

คุณได้รับอาร์เรย์จำนวนเต็มหลายมิติ แต่ละมิติมีขนาดคงที่ (เพื่อให้เป็นรูปสี่เหลี่ยมผืนผ้าเสมอถ้าเป็น 2D) โปรแกรมของคุณควรคำนวณผลรวมในแต่ละมิติและเพิ่มผลรวมเป็นรายการสุดท้ายใหม่ในมิตินั้น

สมมติอินพุตและเอาต์พุตอาร์เรย์ A และ B และขนาดของมิติฉันของเป็น n ฉัน B จะมีขนาดเท่ากับ A และขนาดของมิติที่ฉันจะเป็น n i +1 B j 1 , j 2 , ... , j mคือผลรวมของ A k 1 , k 2 , ... , k mโดยที่:

  • k i = j iหาก j i <= n i
  • 0 <k i <= n ฉันถ้า j i = n ฉัน +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 ไบต์ของ APL หรือไม่ ถ้าคุณไม่ทำฉันจะได้ไหม
เดนนิส

@Dennis คุณควรโพสต์มัน
jimmy23013

คำตอบ:


9

J, 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|:],+/)^:(#@$)แต่ใช้คำวิเศษณ์ที่ผู้ใช้กำหนดเพื่อบันทึก parens

คำอธิบายสำหรับโค้ดหลังจากขวาไปซ้าย:

  • ^:(#@$)ทำซ้ำ^:สำหรับจำนวน#มิติ$:

    • ],+/ต่อ,อาร์กิวเมนต์เข้า]กับผลรวมของมันในมิติสุดท้าย+/
    • 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

Python 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

ฉันสะดุดข้าม 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

APL, 16 15 ไบต์

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

ขอบคุณ @ user23013 สำหรับการเล่นกอล์ฟ 3 ไบต์และหารูปแบบอินพุตที่เหมาะสม

ตรวจสอบกรณีทดสอบออนไลน์ด้วยTryAPL TryAPL

ความคิด

ความคิดทั่วไปนั้นเหมือนกับในการส่ง CJam ของฉันซึ่ง APL อนุญาตให้มีการใช้งานที่สั้นกว่ามาก ประกอบด้วยเพียงสองขั้นตอน:

  1. รวมอาเรย์ในมิติด้านนอกสุด

  2. ทำซ้ำขั้นตอนที่ 1 สำหรับแต่ละ subarray

รหัส

{             } ⍝ 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

Pip , 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]]

ความคิดนั้นเหมือนกับAPL ของ Dennisแม้ว่าจะได้มาโดยอิสระ โดยเฉพาะอย่างยิ่ง:

{             }  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

วิธีนี้ใช้ได้เพราะ+(พร้อมกับตัวดำเนินการอื่น ๆ ) ทำหน้าที่ item-wise ในรายการใน Pip - คุณสมบัติที่ได้รับแรงบันดาลใจจากภาษาการเขียนโปรแกรมอาเรย์เช่น APL ดังนั้นเมื่อคุณ$+ต้องการรายการ[[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)นำไปสู่ข้อความผิดพลาดที่แปลกประหลาด อย่างไรก็ตามอาร์กิวเมนต์กลางของผู้ประกอบการที่สามสามารถแสดงออกใด ๆของความสำคัญใด ๆ ที่ไม่จำเป็นต้องใช้วงเล็บ ดังนั้นโดยการทำรายการกรณีความจริงฉันสามารถบันทึกสองไบต์เหล่านั้น

2
นั่นเป็นภาษาที่น่าสนใจที่คุณไปถึงที่นั่น ตัวดำเนินการตามรายการคือสิ่งที่ขาดหายไปใน CJam และ Pyth
Dennis

@ เดนนิสขอบคุณ! มันยังคงเป็นงานที่อยู่ระหว่างดำเนินการ แต่มีงานบางอย่างที่ทำได้ค่อนข้างดี
DLosc

5

APL (25)

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

อาร์เรย์ของ APL มีขนาดในตัวดังนั้นนี่คือฟังก์ชันที่ใช้อาร์เรย์n -dimensional แล้วจึงสรุปตามแต่ละมิติ

      {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
@Dennis: คุณต้องผ่านฟังก์ชั่นอาร์เรย์หลายมิติ สิ่งที่↑(1 2 3)(4 5 6)จะทำคือเพียงแค่การสร้างอาร์เรย์ 2 มิติจาก 2 คน 1 มิติโดยใช้ มันไม่ได้เป็นสัญลักษณ์ในตัวและมันก็ไม่ได้พูดในแบบที่คุณคิด วิธีที่เป็นที่ยอมรับในการสร้าง 3 และอาร์เรย์ที่ 4 จะเป็น1 4 1⍴1 1 1 0และ1 1 1 1⍴¯1แต่มันก็ยังเป็นไปได้ที่จะสร้างโดยไม่ได้หมายถึงขนาดเช่นอาร์เรย์ที่สามนอกจากนี้ยังสามารถสร้างขึ้นด้วยที่สี่หนึ่งสามารถสร้างด้วย↑⍉⍪(,1)(,1)(,1)(,0) ↑⍪⊂⍪¯1
marinus

ตกลงนั่นอธิบายทุกอย่าง การใช้วิธีเรียกซ้ำแบบไร้สาระของฉันทำงานได้ดีสำหรับสิ่งที่ฉันคิดว่าเป็นอาร์เรย์ (เช่นf←{0=≡⍵:⍵⋄f¨⍵,+/⍵}⋄f((1 2)(3 4))((5 6)(7 8))) แต่ดูเหมือนว่าเวกเตอร์และอาร์เรย์ที่ซ้อนกันจะแตกต่างกันและอดีตไม่ได้แยกสเกลาร์จากซิงเกิล ...
Dennis

2
@Dennis {×≡⍵:∇¨⍵,+/⍵⋄⍵}((1 2)(3 4))((5 6)(7 8))แข็งแรงเล่นกอล์ฟ: คงที่: {×⍴⍴⍵:∇↓⍵,+/⍵⋄⍵}1 4 1⍴1 1 1 0. มันสั้นกว่า Mathematica ทันที ...
jimmy23013

3

CJam, 36 ไบต์

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

นี่คือฟังก์ชั่นที่เรียกชื่อซ้ำที่ปรากฏอาร์เรย์จากสแต็กและปล่อยหนึ่งในผลตอบแทน

ลองกรณีทดสอบในล่าม CJam

ความคิด

น่าเศร้าที่ CJam ไม่มีโอเปอเรเตอร์อัตโนมัติบางตัวที่อนุญาตให้เพิ่มอาร์เรย์ที่ซ้อนกันโดยพลการดังนั้นเราจึงต้องใช้มันเอง โชคดีที่มันใช้สองตัวดำเนินการมัด:(ลด) และ. (เวกเตอร์) ที่จะพิสูจน์ได้ว่ามีประโยชน์สำหรับงานนี้

ขั้นตอนที่หนึ่งคือการคำนวณจำนวนมิติ นี่เป็นเรื่องง่าย: แปลงอาร์เรย์เป็นตัวแทนสตริงและนับจำนวนนำ[ 's

ตอนนี้เพื่อลดอาร์เรย์ของมิติเดียวคุณมักจะดำเนินการ:+:

[1 2] :+ e# Pushes 3.

สำหรับอาร์เรย์สองมิติ+จะทำการเรียงต่อกันแทนการเพิ่มดังนั้นเราต้อง vectorize มัน:

[[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ที่คำนวณมิติ (และไม่ทำอะไรเลยถ้ามันเป็นศูนย์) ทำการหาผลรวมตามที่ระบุไว้ข้างต้นและในที่สุดก็นำไปใช้กับองค์ประกอบของอาร์เรย์

รหัส

{                                }: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


และในความเป็นจริงคุณสามารถเขียนฟังก์ชันที่ยอมรับอาร์เรย์ที่แยกวิเคราะห์แล้วส่งกลับอาร์เรย์และนับเฉพาะ 95 ไบต์สำหรับdคำตอบนี้
jimmy23013

2

Java, 669 ไบต์

ไม่ต้องโกหกฉันภูมิใจในตัวเองมากสำหรับอันนี้: p

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 สำหรับเวอร์ชันที่ขยายเพิ่มบรรทัด: Array.set (ผลลัพธ์, x, ผลรวม (Array.get (arrayA, x), Array.get (arrayB, x ++))) ในเมธอด _sum (... ) ควรมีชื่อ _sum (... ) ไม่ใช่ sum (... ) เลวของฉัน
Jack Ammo
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.