각 차원의 합계


20

다차원 정수 배열이 제공됩니다. 각 치수의 크기는 고정되어 있으므로 2D이면 항상 직사각형이됩니다. 프로그램은 각 차원의 합계를 계산하고 해당 차원의 새로운 마지막 항목으로 합계를 추가해야합니다.

입력 및 출력 배열이 A 및 B이고 A의 차원 i 의 크기 가 n i라고 가정 합니다. B의 치수는 A와 동일하며 치수 i 의 크기는 n i +1입니다. B j 1 , j 2 , ..., j m 은 A k 1 , k 2 , ..., k m 의 합입니다 .

  • 케이 J =을 나는 경우 J I <= N I
  • 0 <k i <= n i j i = 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 바이트 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|:],+/)^:(#@$)하지만 사용자 정의 부사를 ​​사용하여 파 렌스를 저장합니다.

후자의 코드에 대한 설명은 오른쪽에서 왼쪽입니다.

  • ^:(#@$)차원 ^:#에 대해 반복 하십시오 $.

    • ],+/마지막 차원에서 그 합으로 ,인수에 연결]+/
    • 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를 사용하여 합계를 연결하여 각 차원을 반복합니다.

나는 NumPy 's를 우연히 발견했습니다 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 바이트

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

3 바이트를 골라 내고 올바른 입력 형식을 알아 낸 @ user23013 덕분입니다.

TryAPL로 온라인으로 테스트 사례를 확인하십시오 .

생각

일반적인 아이디어는 CJPL 제출과 동일하며 APL이 훨씬 짧은 구현을 허용합니다. 두 단계만으로 구성됩니다.

  1. 가장 바깥 쪽 차원에서 배열을 합산합니다.

  2. 각 하위 배열에 대해 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 : 그래서 내 코드가 작동했습니다! 입력 형식이 실제 코드보다 이해하기 어려운 프로그래밍 언어를 좋아해야합니다.
Dennis

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

아이디어는 기본적으로 Dennis의 APL 과 동일 하지만 독립적으로 파생됩니다. 더 구체적으로:

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

이 방법은 +많은 다른 연산자와 함께 PIP의 목록에서 항목별로 작동하기 때문에 작동합니다.이 기능은 APL과 같은 배열 프로그래밍 언어에서 영감을 얻은 기능입니다. 따라서 $+와 같은 목록을 만들면 원하는 [[1 2 3] [4 5 6]]결과가 나타납니다 [5 7 9]. 또한 list-or-scalar 테스트에서 사용됩니다 : [1 2 3] - [1 2 3]gives [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

@Dennis 감사합니다! 여전히 진행중인 작업이지만 여전히 잘하는 작업이 있습니다.
DLosc

5

APL (25)

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

APL의 배열에는 차원이 내장되어 있으므로 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에서 1까지의 각 숫자에 대해 ⍴⍴N:
    • +/[⍵]N: N차원을 따라 합
    • N,[⍵]←: 결과를 N해당 차원에 결합
  • N: 마지막으로을 반환 N합니다.

배열에 싱글 톤이 포함되어 있으면이 작업을 수행 할 수 없습니다. 세 번째 또는 네 번째 테스트 사례에 대해이 함수를 어떻게 호출 하시겠습니까?
Dennis

3
@Dennis : 함수에 다차원 배열을 전달해야합니다. 무엇을 ↑(1 2 3)(4 5 6)하고있는 것은 단순히 사용이 1 차원들에서 2 차원 배열을 건설하고있다 . 내장 표기법이 아니며 생각하는 방식을 일반화하지 않습니다. 정식 방법은 3를 구성하고 4 배열 될 1 4 1⍴1 1 1 01 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 Golfed : {×≡⍵:∇¨⍵,+/⍵⋄⍵}((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에는 임의로 중첩 된 배열을 추가 할 수있는 자동 연산자가 없으므로 직접 구현해야합니다. 운 좋게도이 작업에 도움 이되는 두 개의 삽입 연산자 :(감소)와 .(벡터화)를 수행합니다.

1 단계는 차원 수를 계산하는 것입니다. 이것은 쉽다 : 배열을 문자열 표현으로 변환하고 선행 [ ]의 수를 센다 .

이제 한 차원의 배열을 줄이려면 일반적으로 다음을 실행하십시오 :+.

[1 2] :+ e# Pushes 3.

2 차원 배열의 경우 +더하기 대신 연결을 수행하므로 벡터화해야합니다.

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

이제 3 차원 .+배열의 경우 2 차원 배열에서 작동하고 다시 연결을 수행합니다. 이번에는 벡터화해야합니다 .+.

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

일반적인 경우, 차원 D 의 배열은 하나 :, D-1 . 과 1을 연결해야 +합니다.

물론 이것은 가장 바깥 쪽 차원에 대해서만 배열을 합산합니다. 우리는 차원을 계산하고 (0이면 아무 것도하지 않는) 함수 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으로 전달되었다고 가정합니다.


실제로 구문 분석 된 배열을 수락하고 배열을 반환하는 함수를 작성 d하고이 대답에서 95 바이트 만 계산할 수 있습니다.
jimmy23013

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 행 : Array.set (result, x, sum (Array.get (arrayA, x), Array.get (arrayB, x ++))); _sum (...) 메소드에서 sum (...)이 아니라 _sum (...)을 호출해야합니다. 나의 나쁜
Jack Ammo
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.