Die Aufgabe

Diese Herausforderung ist sehr einfach. Ihre Eingabe ist ein rechteckiges 2D-Array von Ganzzahlen mit einer Größe von mindestens 1 × 1. Es kann in jedem vernünftigen Format aufgenommen werden. Ihre Ausgabe soll das Eingabearray sein, wobei jedoch nicht alle Einträge in der ersten oder letzten Zeile oder Spalte auf gesetzt sind 0. Es muss dasselbe Format wie die Eingabe haben.

Zum Beispiel, wenn das Eingabearray ist

67  4 -8  5 13
 9 13 42  4 -7
 1  1  3 -9 29
16 99  8 77  0

dann ist die richtige Ausgabe

67  4 -8  5 13
 9  0  0  0 -7
 1  0  0  0 29
16 99  8 77  0

Regeln und Wertung

Sie können ein vollständiges Programm oder eine Funktion schreiben, und Funktionen können die Eingabe ändern, anstatt sie zurückzugeben. Die niedrigste Byteanzahl gewinnt, und Standardlücken sind nicht zulässig.

Testfälle

Diese werden als verschachtelte Listen formatiert, um das Einfügen von Kopien zu vereinfachen.

[[3]] -> [[3]]
[[7,2,8]] -> [[7,2,8]]
[[3],[5],[12],[-6]] -> [[3],[5],[12],[-6]]
[[99,98,97],[88,87,86]] -> [[99,98,97],[88,87,86]]
[[6,7],[8,9],[10,11]] -> [[6,7],[8,9],[10,11]]
[[-1,-2,-3],[1,2,3],[5,5,5]] -> [[-1,-2,-3],[1,0,3],[5,5,5]]
[[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]] -> [[67,4,-8,5,13],[9,0,0,0,-7],[1,0,0,0,29],[16,99,8,77,0]]
[[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0]] -> [[0,1,0,1,0],[1,0,0,0,1],[0,0,0,0,0],[1,0,0,0,1],[0,1,0,1,0]]

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren. Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wenn Sie mehrere Zahlen einfügen möchten (z. B. weil Sie Ihre Punktzahl verbessert haben oder Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

## Perl, <s>50</s> 43 + 2 (-p flag) = 45 bytes

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=71591,OVERRIDE_USER=32014;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

MATL , 9 Bytes

0HJ_ht4$(

Die Eingabe erfolgt im Format

[67  4 -8  5 13;  9 13 42  4 -7;  1  1  3 -9 29; 16 99  8 77  0]

BEARBEITEN (12. Juni 2016): Um sich an Änderungen in der Sprache anzupassen, wurde der Link unten durch _ersetztq .

Probieren Sie es online !

0           % Push a 0: value that will be assigned into the array
HJ_h        % Vector [2, -1j]: this corresponds to index 2:end-1 for rows
t           % Duplicate: same index for columns
4$(         % Assignment indexing with 4 inputs: array, new value, row and col indices
            % Since the first input (array) to this function is currently missing, it's
            % implicitly taken at this point from stdin
            % Implicitly display stack contents, which is the modified array

Java 7 als vollständig benannte Funktion: 85

void f(int[][]a){for(int i=0,j;++i<a.length-1;)for(j=1;j<a[i].length-1;)a[i][j++]=0;}

Sie könnten dies in Java 8 nach unten lambda, um ein paar Bytes zu entfernen, aber das mache ich nicht wirklich.

Jelly, 18 17 15 9 Bytes

0W&ṖZ
ÇÇ^

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Hintergrund

Dieser Ansatz basiert auf der Antwort von @ Sp3000 Jelly , insbesondere auf seiner Idee, vektorisierte Operationen zwischen Listen unterschiedlicher Länge zu nutzen.

Wir beginnen mit dem bitweisen UND von 0 und jeder ganzen Zahl in der ersten Zeile der Eingabe. Aufgrund der automatischen Vektorisierung kann dies erreicht werden, indem das bitweise UND von [0] und die Eingabe ohne die letzte Zeile verwendet werden. 0 wird mit der ersten Reihe gepaart, was zu einer Reihe von Nullen führt. Da die verbleibenden Zeilen kein Gegenstück in [0] haben , bleiben sie unberührt.

Jetzt transponieren wir das Ergebnis, wenden die obige Transformation erneut an (effektiv entfernen wir die letzte Spalte und setzen die erste auf Null) und transponieren erneut.

Für die Eingabe

 67   4  -8   5  13
  9  13  42   4  -7
  1   1   3  -9  29
 16  99   8  77   0

das führt zu

  0   0   0   0
  0  13  42   4
  0   1   3  -9

Nun nehmen wir das bitweise XOR dieses Ergebnisses und die ursprüngliche Matrix. XOR-Verknüpfung einer Ganzzahl mit sich selbst ergibt 0 . Das XOR-Verknüpfen einer Ganzzahl mit 0 (oder das XOR-Verknüpfen überhaupt nicht) ergibt dieselbe Ganzzahl. Dadurch wird die Matrix ausgehöhlt.

Wie es funktioniert

0W&ṖZ    Helper link. Argument: M (matrix)

0W       Yield [0].
   Ṗ     Yield M, without its last row.
  &      Take the bitwise AND of both.
    Z    Zip the result.

ÇÇ^      Main link. Input: A (matrix)

Ç        Call the helper link on A.
 Ç       Call the helper link on the result.
  ^      Take the bitwise XOR of the result and A.

Mathematica, 27 Bytes

(a=#;a[[2;;-2,2;;-2]]=0;a)&

R , 33 48 Bytes

Ich weiß, R ist nicht zum Golfen gemacht. Aber es ist für die Positionsindizierung gemacht ... Laden Sie ein Beispiel hoch;

a <- matrix(c(67,4,-8,5,13,9,13,42,4,-7,1,1,3,-9,29,16,99,8,77,0), ncol=5, byrow=TRUE)
a
#      [,1] [,2] [,3] [,4] [,5]
# [1,]   67    4   -8    5   13
# [2,]    9   13   42    4   -7
# [3,]    1    1    3   -9   29
# [4,]   16   99    8   77    0

Ersetzen Sie den Wert an einer beliebigen Position, die sich nicht in der Randzeile oder -spalte befindet, durch 0:

x <- function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]<-0;a}

x(a)
#      [,1] [,2] [,3] [,4] [,5]
# [1,]   67    4   -8    5   13
# [2,]    9    0    0    0   -7
# [3,]    1    0    0    0   29
# [4,]   16   99    8   77    0

Überprüfen Sie auch einen 2-Spalten-Test:

b <- matrix(c(99,98,97,88,87,86), ncol=2, byrow=TRUE)
b
#     [,1] [,2]
#[1,]   99   98
#[2,]   97   88
#[3,]   87   86

x(b)
#     [,1] [,2]
#[1,]   99   98
#[2,]   97   88
#[3,]   87   86

Nachwelt: vorheriger Versuch

# a[2:(nrow(a)-1),2:(ncol(a)-1)]<-0 # previous attempt

Testen Sie alle Beispiele:

tests <- read.table(text="[[3]] -> [[3]]
                          [[7,2,8]] -> [[7,2,8]]
                          [[3],[5],[12],[-6]] -> [[3],[5],[12],[-6]]
                          [[99,98,97],[88,87,86]] -> [[99,98,97],[88,87,86]]
                          [[6,7],[8,9],[10,11]] -> [[6,7],[8,9],[10,11]]
                          [[-1,-2,-3],[1,2,3],[5,5,5]] -> [[-1,-2,-3],[1,0,3],[5,5,5]]
                          [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]] -> [[67,4,-8,5,13],[9,0,0,0,-7],[1,0,0,0,29],[16,99,8,77,0]]
                          [[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0]] -> [[0,1,0,1,0],[1,0,0,0,1],[0,0,0,0,0],[1,0,0,0,1],[0,1,0,1,0]]")
tests$cols <- c(1,3,1,3,2,3,5,5)
tests$V1 <- gsub("\\[|\\]","",tests$V1)
tests$V1 <- paste0("c(",tests$V1,")")
tests$V3 <- gsub("\\[|\\]","",tests$V3)
tests$V3 <- paste0("c(",tests$V3,")")

testfn <- function(testno) {
  intest <- matrix(eval(parse(text=tests$V1[testno])), ncol=tests$cols[testno], byrow=TRUE)
  intest <- x(intest)
  outtest <- matrix(eval(parse(text=tests$V3[testno])), ncol=tests$cols[testno], byrow=TRUE)
  return(identical(intest, outtest))
}

sapply(seq_len(nrow(tests)), testfn)
# [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

Mathematica 81 76 Bytes

(d=Dimensions@m;q=MemberQ;m Boole@Array[{1,d[[1]]}~q~#||{1,d[[2]]}~q~#2&,d])&

Wie es funktioniert

Angenommen, das Eingabearray ist in gespeichert m. Die Maße von msind {4,5} `

(m={{67,4,-8,5,13}, {9,13,42,4,-7}, {1,1,3,-9,29}, {16,99,8,77,0}})//MatrixForm

Jede Zelle im folgenden Array aist True, wenn sich die Zelle entweder in der ersten oder ( ||) in der letzten Zeile oder in der ersten oder letzten Spalte befindet. sonst ist es falsch.

(d=Dimensions@m;a=Array[MemberQ[{1,d[[1]]},#]||MemberQ[{1,d[[2]]},#2]&,d])&[m]//MatrixForm

Wenn Sie die Funktion Booleauf das Array anwenden, wird True in 1 und False in 0 konvertiert.

b = Boole[a]

Multiplizieren Sie die Matrix mmit b. Dies multipliziert jede Zelle in m mit der entsprechenden Zelle in b.

m b

GNU Sed, 31

• Vielen Dank an @manatwork für das Speichern von 4 Bytes.

Version 4.2.2 oder früher vor diesem Commit (Diskussion) .

Die Punktzahl enthält +1 für die -rOption.

Eingabezeilen werden durch Zeilenvorschub getrennt. Elemente in jeder Zeile sind einzeilig getrennt.

1n
$n
:
s/ -?\w+ / : /
t
y/:/0/

Erläuterung

1n                   # 1st line: print unchanged, then load next line
$n                   # last line: print unchanged, then load next line (i.e. EOF and stop)
:                    # unnamed label
s/ -?\w+ / : /       # substitute a number in spaces with a `:` in spaces
t                    # If the above matched, jump back to the label and try again
y/:/0/;              # transliterate `:` to `0`

Probieren Sie es online aus.

Oktave, 34 Bytes

function h(M) M(2:end-1,2:end-1)=0

Beachten Sie, dass für die Eingabe Semikolons zum Trennen von Arrayzeilen erforderlich sind:

h([[3];[5];[12];[-6]])

Erläuterung:

Octave- (und MATLAB-) Array-Indizes basieren auf 1. Wenn Sie einen Bereich von angeben, Array(1:end)werden alle Elemente des (in diesem Beispiel eindimensionalen) Arrays angezeigt . Array(2:end-1)gibt Ihnen alle Elemente außer dem ersten und dem letzten.

M(2:end-1,2:end-1)=0

Setzt auf 0alle Elemente, die nicht in der ersten oder letzten Zeile oder Spalte enthalten sind:

>> A = [[-1,-2,-3];[1,2,3];[5,5,5]]
A =

  -1  -2  -3
   1   2   3
   5   5   5

>> h(A)
M =

  -1  -2  -3
   1   0   3
   5   5   5

Wenn eine der Abmessungen kleiner als oder gleich 2, wobei der Bereich end-1ist weniger als 2 ist , damit das Ende des Bereichs (2:end-1)geringer ist als am Anfang. In diesem Fall ignoriert Octave den Bereich und tut nichts. Dies ist analog zur forSchleife:

for (int i=2; i < 2; i++) {...}

Die Stoppbedingung ist bei der ersten Iteration wahr, sodass wir aus der Schleife herausfallen.

>> A = [[6,7];[8,9];[10,11]]
A =

    6    7
    8    9
   10   11

>> h(A)
M =

    6    7
    8    9
   10   11

Gelee , 12 Bytes

ZṖṖ1;¥€
¬ÇÇ×

Ich denke, das funktioniert, ich wickle meinen Kopf immer noch um Jelly. Probieren Sie es online!

(Danke an @Dennis für -2 Bytes)

Arbeitet durch Multiplizieren des Eingabearrays mit einem Array von 1s und 0s um jeweils eine Dimension kleiner. Zum Beispiel für [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]]multiplizieren wir elementweise durch

1 1 1 1
1 0 0 0
1 0 0 0

Vollständige Erklärung

[Helper link - argument is a matrix]
Z           Zip
 ṖṖ         Pop last two elements, or [:-2]
   1;¥€     Append a 1 in front of every row

[Main link]
¬           Not, turning 0s to 1s and everything else to 0s. Even though some zeroes
            turn into 1s, it's fine because we multiply element-wise at the end,
            and 0*1 = 0
 ÇÇ         Perform helper link twice
   ×        Multiply element-wise

ES6, 52 48 46 Bytes

f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)

Bearbeiten: 4 Bytes dank @ user81655 gespeichert. Weitere 2 Bytes dank @ETHproductions eingespart.

Javascript, 62 59 56 Bytes

s=>s.replace(/(^.*|\n\s*\S+)|\S+(?= .*\n)/g,(a,b)=>b||0)

Dieser Ansatz erwartet einen String als Argument. Sie können hier sehen, was der Regex macht: https://regex101.com/r/kC6xA8/3

Mathematica, 55 Bytes

#-Unitize@ArrayFilter[Det,Power~Array~Dimensions@#,1]#&

Testfall

%[RandomInteger[9,{5,5}]]
(*
  {{8,8,3,6,5},
   {7,0,0,0,4},
   {2,0,0,0,7},
   {3,0,0,0,5},
   {8,6,1,0,8}}
*)

Erläuterung

Die Hauptidee dieser Antwort ist die gleiche wie die von DavidC (erst eine Maskenmatrix konstruieren und dann mit der Originalmatrix multiplizieren), aber die Konstruktion der Maskenmatrix ist anders.

ArrayFilter[f,list,r]Karten fauf jedes Element listin einem Radius von r.

ArrayFilter[f,{1,2,3,4,5},1]
(* { f[{1,1,2}], f[{1,2,3}], f[{2,3,4}], f[{3,4,5}], f[{4,5,5}] } *)

Beachten Sie, dass Begrenzungselemente dupliziert werden, wenn nicht genügend Nachbarn vorhanden sind. Wenn listes sich um eine zweidimensionale Funktion handelt, funktioniert diese Funktion gut zusammen Det, um das gewünschte Ergebnis zu erzielen, da doppelte Spalten oder Zeilen an vier Grenzen die Determinanten verschwinden lassen.

ArrayFilter[Det,Power~Array~{4,4},1]
(*
  {{0, 0,  0,    0},
   {0, 12, 72,   0},
   {0, 48, 1152, 0},
   {0, 0,  0,    0}}
*)

Dabei wird Power~Array~{4,4}garantiert, dass die Determinanten für innere Positionen nicht Null sind. Und

1-Unitize@%
(*
  {{1,1,1,1},
   {1,0,0,1},
   {1,0,0,1},
   {1,1,1,1}}
*)

gibt die Maskenmatrix an.

Python, 50 Bytes

def f(a):
 for l in a[1:-1]:l[1:-1]=[0]*(len(l)-2)

Akzeptiert eine Liste von Listen und ändert sie an Ort und Stelle. Pythons Slice-Syntax ist für diese Aufgabe nicht unpraktisch.

Ich habe gelernt, dass das Multiplizieren einer Liste mit einer negativen Zahl zu einer leeren Liste führt, die es dem obigen Code ermöglicht, mit kleinen Eingaben zu arbeiten.

Julia, 50 35 Bytes

A->A[2:size(A,1)-1,2:size(A,2)-1]=0

Dies ist eine anonyme Funktion, die ein Array akzeptiert und an Ort und Stelle ändert. Um es aufzurufen, weisen Sie es einer Variablen zu.

Der Ansatz hier ist ganz einfach: Für das n × m- Eingangsarray A weisen wir A _ij = 0 für alle i = 2, ..., n –1 und j = 2, ..., m –1 zu, indem wir Bereiche konstruieren von Indizes. Die Bereiche können leer sein, z. B. wenn n oder m = 1. In diesem Fall wird kein Austausch durchgeführt.

Probieren Sie es online aus

Dank Dennis 15 Bytes gespart!

C 62 Bytes

y;f(a,b,c)int **a;{for(b--;b-->1;)for(y=1;y<c-1;)a[b][y++]=0;}

Hoffe, es ist in Ordnung, Länge / Breite des Arrays als Parameter zu übernehmen. Ich habe ein bisschen mit memset / bzero herumgespielt, aber mit multipliziertsizeof(int) die Codegröße drastisch erhöht.

BEARBEITEN: 55 Bytes, wenn wir die Regeln weiter verbiegen und unser Array als Zeichen speichern können, da die Eingabe jeweils nur aus einer einzelnen Ziffer besteht.

x;
#define f(a,b,c) for(x=1;x<b-1;)bzero(a[x++]+1,c-2);

EDIT: Danke Washington Guedes für den Tipp!

Perl 6 , 28 Bytes

{.[1..*-2]»[1..*-2] »=»0}

Dadurch wird die Eingabe direkt geändert

Verwendung

my @test-cases = (
  [[3],] => [[3],],
  [[7,2,8],] => [[7,2,8],],
  [[3],[5],[12],[-6]] => [[3],[5],[12],[-6]],
  [[99,98,97],[88,87,86]] => [[99,98,97],[88,87,86]],
  [[6,7],[8,9],[10,11]] => [[6,7],[8,9],[10,11]],
  [[ -1,-2,-3],[1,2,3],[5,5,5]] => [[ -1,-2,-3],[1,0,3],[5,5,5]],
  [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]] => [[67,4,-8,5,13],[9,0,0,0,-7],[1,0,0,0,29],[16,99,8,77,0]],
  [[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0]] => [[0,1,0,1,0],[1,0,0,0,1],[0,0,0,0,0],[1,0,0,0,1],[0,1,0,1,0]],
);

use Test;
plan +@test-cases;

for @test-cases {
  my $k = .key;
  {.[1..*-2]»[1..*-2] »=»0}( $k ); # <==
  ok $k eqv .value
}

1..8
ok 1 - 
ok 2 - 
ok 3 - 
ok 4 - 
ok 5 - 
ok 6 - 
ok 7 - 
ok 8 - 

JavaScript ES6, 69 66 57 Bytes

Y=>Y.map((X,y)=>X.map((N,x)=>x*y&&X[x+1]+.5&&Y[y+1]?0:N))

Wie es funktioniert

Diese Lösung bildet jeden y-Index yund x-Index xin der Eingabe ab und entscheidet anhand dieser beiden Indizes, ob sie verworfen werden sollen oder nicht. Es gibt vier Fälle, die wir aufbewahren müssen:

• x ist 0
• y ist 0
• x ist gleich der Länge des inneren Arrays minus 1
• y entspricht der Länge des äußeren Arrays minus 1

Wir können uns mit ein wenig Multiplikation um die ersten beiden kümmern: x*yGibt 0iff entweder xoder ysind 0 und andernfalls eine positive ganze Zahl. Nun zum dritten: Wir könnten prüfen, ob X.length>x+1, aber das braucht eine Menge Bytes. Eine andere Möglichkeit, dies zu tun, besteht darin, zu überprüfen, ob der vorausliegende Artikel falsch ist, und zwar genau dann, undefinedwenn Sie versuchen, auf einen nicht vorhandenen Artikel zuzugreifen. Dies gilt jedoch auch 0für den Fall, dass das nächste Element ist . Wir addieren also 0,5, um sicherzustellen, dass dies nicht passiert:

1 + 0.5 = 1.5 (truthy)
0 + 0.5 = 0.5 (truthy)
-1 + 0.5 = -0.5 (truthy)
undefined + 0.5 = NaN (falsy)

Zum Schluss der vierte Punkt: Da das äußere Array nur Arrays enthält und jedes Array wahr ist, können wir nur überprüfen Y[y+1]. Jetzt ?0:Nkonvertieren wir es zu, 0wenn sich alle oben genannten Tatsachen als wahr herausstellen. NAndernfalls. Und das ist es!

Netzhaut ,31 24 22

(?<=¶.+ )\S+(?= .*¶)
0

2 Bytes dank randomra gespeichert

Probieren Sie es online!

Es gibt wahrscheinlich einen besseren Weg, dies zu tun, da dies nur ein ziemlich einfacher Ersatz für mehrere Leitungen ist. Im Wesentlichen finden wir jede Zahl, der eine neue Zeile, eine bestimmte Anzahl von Zeichen und ein Leerzeichen vorangestellt sind, und unmittelbar gefolgt von einem Leerzeichen und dann und schließlich gefolgt von einer neuen Zeile. Diese Nummern werden dann alle durch ersetzt 0.

Dadurch wird der Spaltenabstand nicht beibehalten, aber ich denke nicht, dass dies ein Problem ist.

Java 8 als Lambda-Funktion: 82 83 95 Zeichen / Byte

Lambda-Unterschrift: int[][] -> (void)(ie Consumer<int[][]>)

(a)->{int[]v={1,1};while(++v[0]<a.length){while(++v[1]<a[0].length)a[v[0]-1][v[1]-1]=0;v[1]=1}}

BEARBEITEN Einen Fehler gemacht, ich dachte, dass a [x, y] die x-te Zeile und die y-te Spalte ist. Natürlich sollte es ein [x] [y] sein!

BEARBEITEN Ich habe vergessen, den Code zu testen, und ich muss die Spalte jedes Mal innerhalb der Schleife auf Null zurücksetzen, +12 Bytes. : /

Haskell, 59 58 Bytes

k _[x]=[x]
k f(x:y)=x:(f<$>init y)++[last y]
f=k(k(\_->0))

Erweitert

onInner :: (a -> a) -> [a] -> [a]
onInner _ [x]    = [x]
onInner f (x:xs) = x : map f (init xs) ++ [last xs]

hollowOut :: [[Int]] -> [[Int]]
hollowOut = 
   onInner       -- leave first and last line alone 
     (onInner    -- leave first and last entry per line 
       (const 0) -- replace entries by 0
     )

Pyth, 18 Bytes

Qjbm:dSttld0P.Qe.Q

Erläuterung

                   - autoassign Q=eval(input())
                   - autoassign .Q = map(eval, rest_of_input)
Q                  - imp_print(Q)
   m        P.Q    -  [V for d in .Q[:-1]]
      Sttld        -     range(1, len(d)-2+1)
    :d     0       -    assign_indexes(d, ^, 0)
 jb                - "\n".join(^)
               e.Q - imp_print(.Q[-1])

Eingabearrays werden durch Zeilenumbrüche getrennt

Probieren Sie es hier aus

Groovy, 70 Bytes

Das ist nicht sehr kreativ, aber es ist kurz!

g={a->for(i=1;i<a.size()-1;i++)for(j=1;j<a[i].size()-1;)a[i][j++]=0;a}

Erläuterung

Schluss mit einem arg

g={a-> 

Iterieren Sie über das innere Array und überspringen Sie das erste und das letzte Element

for(i=1;i<a.size()-1;i++)

Iterieren Sie über die mittleren Elemente im inneren Array

for(j=1;j<a[i].size()-1;)

Setze die Elemente auf 0und kehre zurücka

a[i][j++]=0;a}

Tests

assert g([[3]]) == [[3]]
assert g([[7, 2, 8]]) == [[7, 2, 8]]
assert g([[3], [5], [12], [-6]]) == [[3], [5], [12], [-6]]
assert g([[99, 98, 97], [88, 87, 86]]) == [[99, 98, 97], [88, 87, 86]]
assert g([[6, 7], [8, 9], [10, 11]]) == [[6, 7], [8, 9], [10, 11]]
assert g([[-1, -2, -3], [1, 2, 3], [5, 5, 5]]) == [[-1, -2, -3], [1, 0, 3], [5, 5, 5]]
assert g([[67, 4, -8, 5, 13], [9, 13, 42, 4, -7], [1, 1, 3, -9, 29], [16, 99, 8, 77, 0]]) == [[67, 4, -8, 5, 13], [9, 0, 0, 0, -7], [1, 0, 0, 0, 29], [16, 99, 8, 77, 0]]
assert g([[0, 1, 0, 1, 0], [1, 0, 1, 0, 1], [0, 1, 0, 1, 0], [1, 0, 1, 0, 1], [0, 1, 0, 1, 0]]) == [[0, 1, 0, 1, 0], [1, 0, 0, 0, 1], [0, 0, 0, 0, 0], [1, 0, 0, 0, 1], [0, 1, 0, 1, 0]]

R, 71 64 57 Bytes

function(m){if(all((y<-dim(m)-1)>1))m[2:y[1],2:y[2]]=0;m}

Bearbeiten Sie -7 Bytes, indem Sie sich explizit mit <2-Zeilen- oder <2-Spalten-Matrizen befassen. Bearbeiten Sie 2 -7 Bytes explizit, indem Sie Dimensionen der Matrix zuweisen, während Sie die Größe überprüfen

C ++, 80 79 Bytes

Erwartet das Array wie int**bei vorgegebenen Größen nund k:

void p(int**c,int n,int k){for(int j,i=1;1+i<n;++i)for(j=1;j+1<k;)c[i][j++]=0;}

Eine Alternative, die für jeden Typ mit size()und value_type & operator[](int)(98 Byte) funktioniert :

template<class C>void p(C&c){for(int j,i=1;1+i<c.size();++i)for(j=1;j+1<c[i].size();)c[i][j++]=0;}

Erweiterte Version

template <class Container>
void hollowOut(Container & ctn){
    const auto size = ctn.size();

    for(typename Container::size_type i = 1; i + 1 < size; ++i) {
        const auto inner_size = ctn[i].size();

        for(decltype(inner_size) j = 1; j + 1 < inner_size; ++j) {
            ctn[i][j] = 0;
        }
    }
}

PHP, 82 81 80 71 Bytes

function(&$z){for(;$z[++$i+1];)for(;0 .$z[0][++$$i+1];)$z[$i][$$i]=0;};

Laufen Sie wie folgt:

php -r '$f = function(&$z){for(;$z[++$i+1];)for(;0 .$z[0][++$$i+1];)$z[$i][$$i]=0;};   $z=[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]; $f($z); print_r($z);'

• Ein Byte wurde gespeichert, indem Zeilen mit konstanter Größe angenommen wurden (danke an manatwork)
• Ein Byte wurde gespeichert, indem es zu einer anonymen Funktion gemacht wurde
• 7 Bytes gespart, indem die Richtigkeit des nächsten Array-Elements verwendet wurde, um Aufrufe von zu verhindern count, was für Codegolf ein viel zu langer Name ist

APL, 17 Bytes, 15 Bytes

{⍵×(⌽∨⊖)1∊¨⍳⍴⍵}

Wie es funktioniert

• ⍳⍴⍵ generiert ein 2D-Array, in dem alle Zellen die Koordinaten aller Zellen des Arguments enthalten.
• 1∊¨Sucht in jeder dieser Zellen, wenn eine 1 vorhanden ist, und gibt eine 1 zurück, wenn dies der Fall ist, oder ansonsten eine 0. Dadurch wird eine Matrix erstellt, in der die erste Zeile und die erste Spalte 1 sind und alle anderen 0 sind.
• (⌽∨⊖) kombiniert mit logischen "oder" zwei Versionen der Matrix, eine umgekehrt entlang der ersten und eine umgekehrt entlang der letzten Achse.
• ⍵× ist die Standardmultiplikation.

Perl, 34 + 2 = 36 Bytes

next if$.==1||eof;s/ .+?(?= )/ 0/g

Benötigt die -pFlagge:

$ perl -pE'next if$.==1||eof;s/ .+?(?= )/ 0/g' <<< $'1 2 3\n4 5 6\n7 8 9'
1 2 3
4 0 6
7 8 9

Wie es funktioniert:

# '-p' Read each line into `$_` and auto prints
next if$.==1||eof; # `$.` is set to to the current line in file (1, 2, ..., n)
                   # and `eof` is true if its the last line
s/ .+?(?= )/ 0/g

Lua, 69 Bytes

function f(a)for i=2,#a-1 do
for o=2,#a[i]-1 do
a[i][o]=0
end
end end

Wenn ich statt Dos und Ends nur geschweifte Klammern hätte ...

SmileBASIC, 69 51 Bytes

DEF H A,W,H
FOR I=1TO H-2FILL A,0,W*I+1,W-2NEXT
END

Das Ausfüllen eines 2D-Bereichs in einem Array erfordert normalerweise die Verwendung von FILL in einer Schleife. Es ist jedoch viel einfacher, mit 2D-Daten auf der Grafikseite zu arbeiten, sodass das Array zuerst dort kopiert wird.

Oh, ich dachte, ich wäre so schlau beim Verwenden von Grafikbefehlen ... aber es stellt sich heraus, dass das Aufrufen von FILL ein paar Mal kürzer ist.

Wie auch immer, Funktionseingaben sind das Array und Breite / Höhe (Dies ist in Smilebasic Standard, da es keine Möglichkeit gibt, die Abmessungen eines Arrays zu überprüfen.)

APL (Dyalog Classic) , 12 Byte

⊢-(⍉0⍪1↓⌽)⍣4

Probieren Sie es online!

⍉⌽⍵ ist normalerweise Rotation (horizontal umkehren und transponieren)

hier kombinieren wir es mit dem, 0⍪1↓⍵was die erste Zeile durch Nullen ersetzt (eine Zeile fallen lassen, dann 0 oben verketten) in einen einzigen Zug:⍉0⍪1↓⌽

⍣4 wiederholt sich 4 mal

⊢- subtrahiert von der ursprünglichen Matrix