Für jede Zeile und Spalte einer Matrix können wir einen zusätzlichen Eintrag mit der Summe der letzten beiden Einträge in dieser Zeile oder Spalte hinzufügen. Zum Beispiel mit der folgenden Eingabematrix:

[ 1 1 1 ]
[ 2 3 4 ]

Die resultierende Matrix wäre:

[ 1 1 1 2 ]
[ 2 3 4 7 ]
[ 3 4 5 9 ]

Führen Sie bei einer Eingabe einer Ganzzahl N und einer Matrix [X, Y] mit einer Größe von mindestens 2x2 die obige Erweiterung N-mal durch und geben Sie das Ergebnis aus. Die resultierende Matrix hat immer die Größe [X + N, Y + N].

Beispiele:

Input:                     Output:

2, [ 0 0 ]                 [ 0 0 0 0 ]
   [ 0 0 ]                 [ 0 0 0 0 ]
                           [ 0 0 0 0 ]
                           [ 0 0 0 0 ]


3, [ 1 1 1 ]               [ 1  1  1  2  3  5 ]
   [ 2 3 4 ]               [ 2  3  4  7 11 18 ]
                           [ 3  4  5  9 14 23 ]
                           [ 5  7  9 16 25 41 ]
                           [ 8 11 14 25 39 64 ]

MATL , 13 14 15 16 20 21 Bytes

2*:"!tP2:Y)sv

Danke @Zgarb für das Entfernen von 1 Byte!

Probieren Sie es online!

2*         % implicitly input number N and multiply by 2
:          % create vector [1,2,...,2*N]
"          % for loop: do this 2*N times
  !        %   transpose. Implicitly input matrix in the first iteration
  tP       %   duplicate and flip vertically
  2:       %   vector [1,2]
  Y)       %   pick submatrix formed by the first two rows
  s        %   sum of each column
  v        %   append as a new row
           % end for
           % implicit display

J, 19 Bytes

(v"1@v=.,[+&{:}:)^:

Dies definiert ein Adverb, das die Zahl links nimmt und ein Verb erzeugt, das die Matrix rechts nimmt. Für das zweite Beispiel gibt es

  3 ((v"1@v=.,[+&{:}:)^:) 2 3 $ 1 1 1 2 3 4
1  1  1  2  3  5
2  3  4  7 11 18
3  4  5  9 14 23
5  7  9 16 25 41
8 11 14 25 39 64

Erläuterung

(v"1@v=.,[+&{:}:)^:  Left argument x, right argument y
(               )^:  Repeat x times:
     v=.               Bind the following verb to v, and apply to y:
         [    }:         y and y-without-last-item
          +&{:           Sum of their last items
        ,                Append that to y
                       (v automatically threads to rows)
 v"1@                  then apply v to columns

K, 23 Bytes

{x(2({x,+/-2#x}'+)/)/y}

In Aktion:

  {x(2({x,+/-2#x}'+)/)/y}[3;(1 1 1;2 3 4)]
(1 1 1 2 3 5
 2 3 4 7 11 18
 3 4 5 9 14 23
 5 7 9 16 25 41
 8 11 14 25 39 64)

Probieren Sie es hier aus .

Jelly, 15 13 12 Bytes

-1 Byte von @Dennis

ṫ-S;@"Z
ÇḤ}¡

Wie bei der MATL-Antwort von @ LuisMendo wird das Array transponiert, bevor die Transformation entlang einer Achse ausgeführt wird. Daher müssen wir die Funktion 2 * n mal aufrufen.

ṫ-S;@"Z       Helper link. Input: x (2D array)
 -              Numeric literal: -1
ṫ               Get x[-1:], i.e. last two rows in x
  S             Sum
   ;@"          Append each to x. " is 'zipWith'; @ switches argument order.
      Z         Transpose the array.
ÇḤ}¡          Main link. Input: a, n
Ç               Call the last link on a
 Ḥ}             2n
   ¡            times.

Probieren Sie es hier aus .

ES6, 134 Bytes

(n,a)=>[...a.map(b=>[...b,...Array(n)].map(c=>(c<1/0?0:c=a+d,d=a,a=c))),...Array(n)].map(b=>(b?0:b=[...a].map((c,j)=>c+d[j]),d=a,a=b))

Erläuterung:

(n,a)=> // arguments n is number to expand, a is original array
    [...
        a.map(b=> // for each row in a
            [...b,...Array(n)] // append n elements to the row
            .map(c=>(c<1/0?0:c=a+d,d=a,a=c))) // scan the elements and fill the new ones by summing the previous two
        ,...Array(n)] // append n rows
    .map(b=>(b?0:b=[...a].map((c,j)=>c+d[j]),d=a,a=b)) // scan the rows and fill the new rows by summing the previous two rows

Haskell, 67 Bytes

o%m=m++[o(+)(last m)$last$init m]
(!!).iterate(map(id%).(zipWith%))

Anwendungsbeispiel:

*Main> ( (!!).iterate(map(id%).(zipWith%)) ) [[1,1,1],[2,3,4]] 3
[[1,1,1,2,3,5],[2,3,4,7,11,18],[3,4,5,9,14,23],[5,7,9,16,25,41],[8,11,14,25,39,64]]

Wie es funktioniert:

(!!).iterate(    ...         )  -- repeatedly apply ... to the first agrument and
                                -- pick the iteration defined by the second arg
                   (zipWith%)   -- for one iteration add a new row and
          map(id%)              -- then a new element at the end of each each row

o%m                             -- add row or element at the end of a row resp.
                                -- argument o is a "modify function"
                                --          m the whole matrix or a row
 m++[    (last m)(last$init m)] -- take m and append the result of combining the
                                -- last and 2nd last element of m
     o(+)                       -- with a modified version of (+)
                                -- modification is none (aka. id) when adding an
                                -- element to the end of a row and
                                -- zipping elementwise (zipWith) when adding a row

CJam, 17 16 Bytes

q~2*{~_2$.+]z}*p

Das Eingabeformat ist zuerst die Matrix (als 2D-Array im CJam-Stil) und danach die Anzahl der Iterationen.

Teste es hier.

Erläuterung

Es stellt sich heraus, dass dies die gleiche Lösung ist wie die aller anderen:

q~      e# Read and evaluate input.
2*      e# Double the iteration count.
{       e# Run this block that many times...
  ~     e#   Dump all rows on the stack.
  _     e#   Copy the last row.
  2$    e#   Copy the penultimate row.
  .+    e#   Vectorised addition.
  ]     e#   Wrap all rows in a new array.
  z     e#   Transpose such that the next iteration processes the other dimension.
}*
p       e#   Pretty-print.

Im Ernst, 20 Bytes

,,τ"┬`;d@d@X+@q`M"£n

Übernimmt dann die Eingabe der Matrix (als 2D-Liste) N. Gibt eine 2D-Liste aus.

Diese Version funktioniert aus irgendeinem Grund nicht mit dem Online-Interpreter, funktioniert jedoch mit diesem Pre-Challenge-Commit .

Eine online funktionierende Version für 23 Bytes:

,τ",┬`;d@d@X+@q`M"nkΣ£ƒ

Nimmt die Eingabe in umgekehrter Reihenfolge vor ( Ndann Matrix).

Probieren Sie es online!

Ich werde eine Erklärung hinzufügen, nachdem ich eine Weile geschlafen habe. Das Umgehen von Interpreter-Fehlern macht niemals Spaß.

Pyth, 13 12 Bytes

u+Rs>2dCGyEQ

Probieren Sie es online aus. Testsuite.

Verwendet den gleichen Algorithmus für die meisten Antworten. Nimmt als Eingabe die Matrix als 2D-Array in der ersten Zeile und nin der zweiten Zeile.

Erläuterung

u        yEQ     do 2*N times, starting with input matrix:
       CG          transpose
 +R                append to each row:
   s                 sum of
    >2d              last 2 elements of row

Matlab, 60 Bytes

Ich habe zuerst mit Matlabs ausgefallenen Indizierungsmethoden rumgespielt, A(end+1,:)=sum...bevor ich herausgefunden habe, dass in diesem seltenen Fall eine einfache Verkettung in Matlab tatsächlich günstiger ist. Schade, dass ich dies in eine tatsächliche Funktion umwandeln musste. Sollte auch mit Octave funktionieren.

function A=f(A,n)
for i=1:2*n
A=[A;sum(A(end-1:end,:))]';end

Ich nehme an, dies ist ein hervorragendes Beispiel dafür, wie man keine Algorithmen erstellt. Für A = 2x2, n = 1000 dauert dieser Algorithmus auf meinem Laptop bereits 5 Sekunden, n = 2000 sind es fast 50 Sekunden! (oder ungefähr 30s, wenn A ein gpuArrayDank an meinen vertrauenswürdigen Quadro 1000M ist)

Java, 2179 Bytes

Es ist einfach geklappt: - Dieser Code ist in Java-Sprache.

import java.util.Scanner;

public class FebonnaciMatrix {
        static Scanner scan=new Scanner(System.in);

        public static void main(String[] args) {

        int x,y;
        System.out.println("For the Array to Work Upon:- ");

        System.out.println("Enter the Row:- ");
        int row=scan.nextInt();
        System.out.println("Enter the Column:- ");
        int col=scan.nextInt();

        int inpArr[][]=new int[row][col];

        System.out.println("Enter the values");
        inpArr=inpValues(row,col);

        System.out.println("The Input Array is:- ");
        display(inpArr,row,col);

        System.out.println("Input the Array size of Febonacci Array ");

        System.out.println("Enter the Row");
        int frow=scan.nextInt();
        System.out.println("Enter the Column");
        int fcol=scan.nextInt();

        int febArr[][]=new int[frow][fcol];
        febArr=copyValue(inpArr,febArr,row,col);

        for(x=0;x<row;x++)
        {
            for(y=col;y<fcol;y++)
                febArr[x][y]=febArr[x][y-2]+febArr[x][y-1];
        }

        for(x=row;x<frow;x++)
        {
            for(y=0;y<fcol;y++)
                febArr[x][y]=febArr[x-2][y]+febArr[x-1][y];
        }

        System.out.println();
        System.out.println("The Febonacci Array:-");
        display(febArr,frow,fcol);
    }

    static void display(int[][] arr,int row,int col)
    {
        int x,y;
        for(x=0;x<row;x++)
        {
            for(y=0;y<col;y++)
                System.out.print(arr[x][y]+"\t");
            System.out.println();
        }
    }

    static int[][] inpValues(int row,int col)
    {
        int arr[][]=new int[row][col];
        int x,y;
        for(x=0;x<row;x++)
        {
            for(y=0;y<col;y++)
            {
                System.out.print("Enter the value:- ");
                arr[x][y]=scan.nextInt();
            }
        }
        return arr;
    }

    static int[][] copyValue(int[][] old, int[][] ne, int row,int col)
    {
        int x,y;    
        for(x=0;x<row;x++)
        {
            for(y=0;y<col;y++)
                ne[x][y]=old[x][y];

        }
        return ne;
    }

}

Python, 103 105 Bytes

f=lambda n,L:f(n-1,[l+[sum(l[-2:])]for l in L])if n else L
lambda n,L:zip(*f(n,map(list,zip(*f(n,L)))))

Die anonyme Funktion übernimmt die Liste der Listen und übergibt sie an die rekursive Funktion f. Die Ausgabe wird transponiert und dann an übergebenf erneut weitergeleitet. Anschließend wird die Ausgabe des zweiten Durchgangs erneut transponiert. Die Ausgabe ist eine Liste von Tupeln

Zwei Bytes dank Bakuriu gespeichert

APL (Dyalog Classic) , 17 Byte

{⍉⍵,⊢/2+/⍵}⍣2⍣⎕⊢⎕

Probieren Sie es online!

Perl 6 ,  87 73  71 Bytes

->\c,\m{for ^c {.[+*]=[+] .[*X-1,2]for m;m.push: [map {[+] m[*X-1,2;$_]},m[0].keys]};m}
->\c,\m{for ^c {.[+*]=[+] .[*X-1,2]for m;m[+*]=[m[*-2;*] »+«m[*-1]]};m}
->\c,\m{for ^c {.[+*]=[+] .[*X-1,2]for m;m[+*]=[m[*-2;*]Z+m[*-1;*]]};m}

-> \c, \m {
  for ^c { # 0 ..^ c

    # each row
    .[+*]                            # new column at the end of row ($_)
          = [+] .[ * X- 1,2 ]        # add up the last two entries in row ($_)
                              for m; # for every row

    # too bad this was longer than the above code
    # m[*;+*]=map *+*,m[*;*-2,*-1]

    # each column
    m[ +* ]                 # add new row
            = [             # make it an Array rather than a List
                m[ *-2; * ] # the second to last row
                »+«         # added columnwise with
                m[ *-1 ]    # the last row
              ]
  };

  m # return the result
}

Verwendung:

use v6.c;
# give it a lexical name
my &code = ->\c,\m{ … }

my @return = code 3,[[1,1,1],[2,3,4]];

put '[ ', $_».fmt('%2d'), ' ]' for @return;

put '';

put @return.perl ~~ {S:g/' '//};

[  1  1  1  2  3  5 ]
[  2  3  4  7 11 18 ]
[  3  4  5  9 14 23 ]
[  5  7  9 16 25 41 ]
[  8 11 14 25 39 64 ]

[[1,1,1,2,3,5],[2,3,4,7,11,18],[3,4,5,9,14,23],[5,7,9,16,25,41],[8,11,14,25,39,64]]