Nehmen Sie eine Matrix positiver Ganzzahlen als Eingabe und lassen Sie sie explodieren!

Die Art und Weise, wie Sie eine Matrix auflösen, besteht darin, einfach Nullen um jedes Element, einschließlich der äußeren Ränder, hinzuzufügen.

Eingabe- / Ausgabeformate sind wie immer optional!

Testfälle:

1
-----
0 0 0
0 1 0
0 0 0
--------------

1 4
5 2
-----
0 0 0 0 0
0 1 0 4 0
0 0 0 0 0
0 5 0 2 0
0 0 0 0 0
--------------

1 4 7
-----
0 0 0 0 0 0 0
0 1 0 4 0 7 0
0 0 0 0 0 0 0
--------------

6
4
2
-----
0 0 0
0 6 0
0 0 0
0 4 0
0 0 0
0 2 0
0 0 0

Operation Flashpoint- Skriptsprache, 182 Byte

f={t=_this;c=count(t select 0);e=[0];i=0;while{i<c*2}do{e=e+[0];i=i+1};m=[e];i=0;while{i<count t}do{r=+e;j=0;while{j<c}do{r set[j*2+1,(t select i)select j];j=j+1};m=m+[r,e];i=i+1};m}

Ungolfed:

f=
{
  // _this is the input matrix. Let's give it a shorter name to save bytes.
  t = _this;
  c = count (t select 0);

  // Create a row of c*2+1 zeros, where c is the number of columns in the
  // original matrix.
  e = [0];
  i = 0;
  while {i < c*2} do
  {
    e = e + [0];
    i = i + 1
  };

  m = [e]; // The exploded matrix, which starts with a row of zeros.
  i = 0;
  while {i < count t} do
  {
    // Make a copy of the row of zeros, and add to its every other column 
    // the values from the corresponding row of the original matrix.
    r = +e;
    j = 0;
    while {j < c} do
    {
      r set [j*2+1, (t select i) select j];
      j = j + 1
    };

    // Add the new row and a row of zeroes to the exploded matrix.
    m = m + [r, e];
    i = i + 1
  };

  // The last expression is returned.
  m
}

Rufen Sie an mit:

hint format["%1\n\n%2\n\n%3\n\n%4",
    [[1]] call f,
    [[1, 4], [5, 2]] call f,
    [[1, 4, 7]] call f,
    [[6],[4],[2]] call f];

Ausgabe:

Im Geiste der Herausforderung:

Jelly ,  12  11 Bytes

-1 Byte dank Erik the Outgolfer (keine Notwendigkeit, getauschte Argumente für einen Join zu verwenden)

j00,0jµ€Z$⁺

Probieren Sie es online! Oder sehen Sie sich eine Testsuite an .

Ein monadischer Link, der Listen von Listen akzeptiert und zurückgibt.

Wie?

j00,0jµ€Z$⁺ - Link: list of lists, m
          ⁺ - perform the link to the left twice in succession:
         $  -   last two links as a monad
      µ€    -     perform the chain to the left for €ach row in the current matrix:
j0          -       join with zeros                [a,b,...,z] -> [a,0,b,0,...,0,z]
  0,0       -       zero paired with zero = [0,0]
     j      -       join                     [a,0,b,0,...,0,z] -> [0,a,0,b,0,...,0,z,0]
        Z   -     and then transpose the resulting matrix

Haskell , 38 Bytes

a%l=a:(=<<)(:[a])l
f l=(0%)<$>(0<$l)%l

Probieren Sie es online!

MATL , 12 Bytes

FTXdX*0JQt&(

Eingabe ist eine Matrix mit ;als Zeilentrennzeichen.

Probieren Sie es online!

Erläuterung

FT     % Push [0 1]
Xd     % Matrix with that diagonal: gives [0 0; 0 1]
X*     % Implicit input. Kronecker product
0      % Push 0
JQt    % Push 1+j (interpreted as "end+1" index) twice
&(     % Write a 0 at (end+1, end+1), extending the matrix. Implicit display

Japt , 18 Bytes

Ov"y ®î íZ c p0Ã"²

Testen Sie es online! (Verwendet das -QFlag, um die Ausgabe besser zu verstehen.)

Ähnlich wie die Gelee-Antwort, aber viel länger ...

Erläuterung

Der äußere Teil des Codes ist nur eine Problemumgehung, um Jellys zu simulieren ⁺:

  "             "²   Repeat this string twice.
Ov                   Evaluate it as Japt.

Der Code selbst ist:

y ®   î íZ c p0Ã
y mZ{Zî íZ c p0}   Ungolfed
y                  Transpose rows and columns.
  mZ{          }   Map each row Z by this function:
     Zî              Fill Z with (no argument = zeroes).
        íZ           Pair each item in the result with the corresponding item in Z.
           c         Flatten into a single array.
             p0      Append another 0.

Dieser Vorgang wird zweimal wiederholt und liefert die gewünschte Ausgabe. Das Ergebnis wird implizit gedruckt.

Schale , 12 Bytes

₁₁
Tm»o:0:;0

Nimmt ein ganzzahliges 2D-Array auf und gibt es zurück. Probieren Sie es online!

Erläuterung

Dieselbe Idee wie bei vielen anderen Antworten: Fügen Sie jeder Zeile Nullen hinzu und transponieren Sie zweimal. Die Zeilenoperation wird mit einer Falte implementiert.

₁₁         Main function: apply first helper function twice
Tm»o:0:;0  First helper function.
 m         Map over rows:
  »         Fold over row:
   o         Composition of
      :       prepend new value and
    :0        prepend zero,
       ;0    starting from [0].
            This inserts 0s between and around elements.
T          Then transpose.

Mathematica, 39 Bytes

r=Riffle[#,0,{1,-1,2}]&/@Thread@#&;r@*r

Probieren Sie es am Wolfram Sandkasten! Nennen Sie es wie " r=Riffle[#,0,{1,-1,2}]&/@Thread@#&;r@*r@{{1,2},{3,4}}".

Wie bei vielen anderen Antworten funktioniert dies, indem Nullen in jeder Zeile transponiert und gewechselt werden und dann das Gleiche erneut ausgeführt wird. Inspiriert von Jonathan Allans Jelly-Antwort , aber nur, weil ich diese Antwort zufällig zuerst gesehen habe.

Dyalog APL, 24 Bytes

4 Bytes gespart dank @ZacharyT

5 Bytes gespart dank @KritixiLithos

{{⍵↑⍨-1+⍴⍵}⊃⍪/,/2 2∘↑¨⍵}

Probieren Sie es online!

Oktave, 41 Bytes

@(M)resize(kron(M,[0 0;0 1]),2*size(M)+1)

Probieren Sie es online!

Python 3 , 104 101 97 93 86 Bytes

• @Zachary T sparte 3 Bytes: nicht verwendete Variable wentfernt und ein unerwünschter Speicherplatz
• @Zachary T hat weitere 4 Bytes gespeichert: [a,b]als ob er gerade a,ban eine Liste angehängt hätte
• @nore gespart 4 Bytes: Verwendung von Slicing
• Mit @Zachary T und @ovs konnten 7 Bytes gespart werden: Die Anweisungen in der for-Schleife werden komprimiert

def f(a):
 m=[(2*len(a[0])+1)*[0]]
 for i in a:r=m[0][:];r[1::2]=i;m+=r,m[0]
 return m

Probieren Sie es online!

Python 3, 118 Bytes

def a(b):
    z='00'*len(b[0])+'0'
    r=z+'\n'
    for c in b:
        e='0'
        for d in c:e+=str(d)+'0'
        r+=e+'\n'+z+'\n'
    return r

Zum ersten Mal Golf spielen! Nicht das Beste, aber ich bin sehr stolz, wenn ich es selbst sagen kann!

• -17 Bytes aus Weizenkommentaren
• -4 Bytes vom Inlining der zweiten for-Schleife

R, 65 Bytes

Vielen Dank an Jarko Dubbeldam und Giuseppe für sehr wertvolle Kommentare!

Code

f=function(x){a=dim(x);y=array(0,2*a+1);y[2*1:a[1],2*1:a[2]]=x;y}

Die Eingabe für die Funktion muss eine Matrix oder ein zweidimensionales Array sein.

Prüfung

f(matrix(1))
f(matrix(c(1,5,4,2),2))
f(matrix(c(1,4,7),1))
f(matrix(c(6,4,2)))

Ausgabe

> f(matrix(1))
     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    1    0
[3,]    0    0    0
> f(matrix(c(1,5,4,2),2))
     [,1] [,2] [,3] [,4] [,5]
[1,]    0    0    0    0    0
[2,]    0    1    0    4    0
[3,]    0    0    0    0    0
[4,]    0    5    0    2    0
[5,]    0    0    0    0    0
> f(matrix(c(1,4,7),1))
     [,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,]    0    0    0    0    0    0    0
[2,]    0    1    0    4    0    7    0
[3,]    0    0    0    0    0    0    0
> f(matrix(c(6,4,2)))
     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    6    0
[3,]    0    0    0
[4,]    0    4    0
[5,]    0    0    0
[6,]    0    2    0
[7,]    0    0    0

Mathematica, 55 Bytes

(a=ArrayFlatten)@{o={0,0},{0,a@Map[{{#,0},o}&,#,{2}]}}&

PHP , 98 Bytes

Eingabe als 2D-Array, Ausgabe als String

<?foreach($_GET as$v)echo$r=str_pad(0,(count($v)*2+1)*2-1," 0"),"
0 ".join(" 0 ",$v)." 0
";echo$r;

Probieren Sie es online!

PHP , 116 Bytes

Ein- und Ausgabe als 2D-Array

<?foreach($_GET as$v){$r[]=array_fill(0,count($v)*2+1,0);$r[]=str_split("0".join(0,$v)."0");}$r[]=$r[0];print_r($r);

Probieren Sie es online!

Clojure, 91 Bytes

#(for[h[(/ 2)]i(range(- h)(count %)h)](for[j(range(- h)(count(% 0))h)](get(get % i[])j 0)))

Iteriert in Halbschritten über Bereiche.

Perl 6 , 33 Bytes

{map {0,|$_,0},0 xx$_,|$_,0 xx$_}

Probieren Sie es online!

Python 2 , 64 Bytes

lambda l:map(g,*map(g,*l))
g=lambda*l:sum([[x,0]for x in l],[0])

Probieren Sie es online!

Die Funktion setzt gdie Eingabe zwischen Nullen. Die Hauptfunktion transponiert die Eingabe beim Anwenden gund tut dies dann erneut. Vielleicht gibt es eine Möglichkeit, die Wiederholung in der Hauptfunktion zu vermeiden.

JavaScript (ES6), 73 bis 72 Byte

a=>(g=a=>(r=[b],a.map(v=>r.push(v,b)),b=0,r))(a,b=a[0].map(_=>0)).map(g)

Formatiert und kommentiert

Das horizontale und vertikale Einfügen von Nullen ist sehr ähnlich. Die Idee hier ist, die gleiche Funktion g () für beide Schritte zu verwenden.

a =>                            // a = input array
  (g = a =>                     // g = function that takes an array 'a',
    (                           //     builds a new array 'r' where
      r = [b],                  //     'b' is inserted at the beginning
      a.map(v => r.push(v, b)), //     and every two positions,
      b = 0,                    //     sets b = 0 for the next calls
      r                         //     and returns this new array
  ))(a, b = a[0].map(_ => 0))   // we first call 'g' on 'a' with b = row of zeros
  .map(g)                       // we then call 'g' on each row of the new array with b = 0

Testfälle

let f =

a=>(g=a=>(r=[b],a.map(v=>r.push(v,b)),b=0,r))(a,b=a[0].map(_=>0)).map(g)

console.log(JSON.stringify(f([
  [1]
])))

console.log(JSON.stringify(f([
  [1, 4],
  [5, 2]
])))

console.log(JSON.stringify(f([
  [1, 4, 7]
])))

console.log(JSON.stringify(f([
  [6],
  [4],
  [2]
])))

Kohle , 49 Bytes

Ａ⪪θ;αＡ””βＦ⁺¹×²Ｌ§α⁰Ａ⁺β⁰βＡ⁺β¶βＦα«βＡ0δＦιＡ⁺δ⁺κ⁰δ⁺䶻β

Probieren Sie es online!

Die Eingabe ist eine einzelne Zeichenfolge, die die Zeilen durch ein Semikolon trennt.

C ++ 17 + Module, 192 Bytes

Eingabe als Zeichenfolgenreihen von cin , Ausgabe bis cout

import std.core;int main(){using namespace std;int i;auto&x=cout;string s;while(getline(cin,s)){for(int j=i=s.length()*2+1;j--;)x<<0;x<<'\n';for(auto c:s)x<<'0'<<c;x<<"0\n";}for(;i--;)x<<'0';}

C # , 146 Bytes

Daten

• Eingabe Int32[,] m Die zu zerlegende Matrix
• Ausgabe Int32[,] Die aufgelöste Matrix

Golf gespielt

(int[,] m)=>{int X=m.GetLength(0),Y=m.GetLength(1),x,y;var n=new int[X*2+1,Y*2+1];for(x=0;x<X;x++)for(y=0;y<Y;y++)n[x*2+1,y*2+1]=m[x,y];return n;}

Ungolfed

( int[,] m ) => {
    int
        X = m.GetLength( 0 ),
        Y = m.GetLength( 1 ),
        x, y;

    var
        n = new int[ X * 2 + 1, Y * 2 + 1 ];

    for( x = 0; x < X; x++ )
        for( y = 0; y < Y; y++ )
            n[ x * 2 + 1, y * 2 + 1 ] = m[ x, y ];

    return n;
}

Ungolfed lesbar

// Takes an matrix of Int32 objects
( int[,] m ) => {
    // To lessen the byte count, store the matrix size
    int
        X = m.GetLength( 0 ),
        Y = m.GetLength( 1 ),
        x, y;

    // Create the new matrix, with the new size
    var
        n = new int[ X * 2 + 1, Y * 2 + 1 ];

    // Cycle through the matrix, and fill the spots
    for( x = 0; x < X; x++ )
        for( y = 0; y < Y; y++ )
            n[ x * 2 + 1, y * 2 + 1 ] = m[ x, y ];

    // Return the exploded matrix
    return n;
}

Vollständiger Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestBench {
    public static class Program {
        private static Func<Int32[,], Int32[,]> f = ( int[,] m ) => {
            int
                X = m.GetLength( 0 ),
                Y = m.GetLength( 1 ),
                x, y,

                a = X * 2 + 1,
                b = Y * 2 + 1;

            var
                n = new int[ a, b ];

            for( x = 0; x < X; x++ )
                for( y = 0; y < Y; y++ )
                    n[ a, b ] = m[ x, y ];

            return n;
        };

        public static Int32[,] Run( Int32[,] matrix ) {
            Int32[,]
                result = f( matrix );

            Console.WriteLine( "Input" );
            PrintMatrix( matrix );

            Console.WriteLine( "Output" );
            PrintMatrix( result );

            Console.WriteLine("\n\n");

            return result;
        }

        public static void RunTests() {
            Run( new int[,] { { 1 } } );
            Run( new int[,] { { 1, 3, 5 } } );
            Run( new int[,] { { 1 }, { 3 }, { 5 } } );
            Run( new int[,] { { 1, 3, 5 }, { 1, 3, 5 }, { 1, 3, 5 } } );
        }

        static void Main( string[] args ) {
            RunTests();

            Console.ReadLine();
        }

        public static void PrintMatrix<TSource>( TSource[,] array ) {
            PrintMatrix( array, o => o.ToString() );
        }
        public static void PrintMatrix<TSource>( TSource[,] array, Func<TSource, String> valueFetcher ) {
            List<String>
                output = new List<String>();

            for( Int32 xIndex = 0; xIndex < array.GetLength( 0 ); xIndex++ ) {
                List<String>
                    inner = new List<String>();

                for( Int32 yIndex = 0; yIndex < array.GetLength( 1 ); yIndex++ ) {
                    inner.Add( valueFetcher( array[ xIndex, yIndex ] ) );
                }

                output.Add( $"[ {String.Join( ", ", inner )} ]" );
            }

            Console.WriteLine( $"[\n   {String.Join( ",\n   ", output )}\n]" );
        }
    }
}

Releases

• v1.0 - 146 bytes- Anfangslösung.

Anmerkungen

• Keiner

Dyalog APL, 24 Bytes

{{⍵↑⍨¯1-⍴⍵}⊃⍪/,/2 2∘↑¨⍵}

Verbesserungen sind willkommen und erwünscht!

Python 2 , 92 Bytes

n=input()
a=[[0]*(2*len(n[0])+1)for i in[0]+2*n]
for l,v in zip(a[1::2],n):l[1::2]=v
print a

Probieren Sie es online!

Python 3 + Numpy , 87 Bytes

from numpy import*
def f(a):b=zeros((2*len(a)+1,2*len(a[0])+1));b[1::2,1::2]=a;return b

Probieren Sie es online!

JavaScript (ES6), 80 bis 78 Byte

a=>[...a,...a,a[0]].map((b,i)=>[...b,...b,0].map((_,j)=>i&j&1&&a[i>>1][j>>1]))

Pyth, 13 Bytes

uCm+0s,R0dG2Q

Demonstration

Weitere 13:

uC.iL+0m0dG2Q

APL (Dyalog) , 22 Bytes

Fordert zur Eingabe einer Matrix auf und gibt die beigefügte Matrix zurück.

{⍺⍀⍵\a}/⍴∘0 1¨1+2×⍴a←⎕

Probieren Sie es online!

a←⎕ Aufforderung für Matrix und weisen eine

⍴ die Maße von a (Zeilen, Spalten)

2× multiplizieren mit zwei

1+ füge eins hinzu

⍴∘0 1¨ benutze jeden um r die Zahlen Null und Eins (zyklisch) umzugestalten

{… }/ Reduzieren durch Einfügen der folgenden anonymen Funktion zwischen die beiden Zahlen:

 ⍵\a Erweitern Sie * die Spalten von a entsprechend dem richtigen Argument

 ⍺⍀a erweitern Sie * die Zeilen davon gemäß dem linken Argument

* 0 fügt eine Spalte / Zeile mit Nullen ein, 1 fügt eine ursprüngliche Datenspalte / -zeile ein

Java 8, 183 166 162 129 Bytes

m->{int a=m.length,b=m[0].length,x=0,y,r[][]=new int[a*2+1][b*2+1];for(;x<a;x++)for(y=0;y<b;r[x*2+1][y*2+1]=m[x][y++]);return r;}

Ein- und Ausgabe als int[][] .

-33 Bytes durch Erstellen eines Ports mit der C # - Antwort von @auhmaan .

Erläuterung:

Probieren Sie es hier aus.

m->{                                // Method with 2D integer-array as parameter and return-type
  int a=m.length,                   //  Current height
      b=m[0].length,                //  Current width
      x=0,y,                        //  Two temp integers
      r[][]=new int[a*2+1][b*2+1];  //  New 2D integer-array with correct size
  for(;x<a;x++)                     //  Loop (1) over the height
    for(y=0;y<b;                    //   Inner loop (2) over the width
      r[x*2+1][y*2+1]=m[x][y++]     //    Fill the new array with the input digits
    );                              //   End of inner loop (2)
                                    //  End of loop (1) (implicit / single-line body)
  return r;                         //  Return result 2D integer-array
}                                   // End of method

J , 24 Bytes

0,.0,[:,./^:2(0,.~,&0)"0

Probieren Sie es online!

05AB1E , 22 Bytes

"vy0ý0.ø})"©.V€Sø®.Vø»

Probieren Sie es online!

Verwendet tatsächlich das gleiche Stück Code 2x, so dass ich es als Zeichenfolge speichern und Eval für -10 Bytes verwenden kann.