Array aushöhlen

35

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

Code-Snippet anzeigen

code-golf  array-manipulation 
— Zgarb
quelle

Antworten:

13

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
— Luis Mendo
quelle
2
Nett! Ich wusste, dass MATL im Rennen sein würde. : D
— Becher
12

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.

— Geobits
quelle
Könnten Sie mit Platz sparen Arrays.fill(a[i],1,a[i].length-1,0);? Es ist nur 36 Bytes anstelle von 37. =)
— CorsiKa
@ CorsiKa Es wäre schön, aber ich müsste es importieren oder voll qualifizieren: /
— Geobits
Warum habt ihr beide aus Neugier unterschiedliche Loops? Warum nicht for(int i=0,j;++i<a.length-1;)for(j=0;++j<a[i].length-1;)a[i][j]=0;? Es werden keine Bytes gespeichert, aber es ist konsistenter, wenn beide Schleifen gleich sind. :)
— Kevin Cruijssen
12

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.
— Dennis
quelle
8

Mathematica, 27 Bytes

(a=#;a[[2;;-2,2;;-2]]=0;a)&
— Alephalpha
quelle
2
Beeindruckend. Würden Sie das bitte erklären? Es sieht so aus, als würden Sie die inneren Zellen wieder auf Null setzen, und das -2s steht für die vorletzte Spalte oder Zeile.
— DavidC
Wie einfach ist das!
— njpipeorgan
7

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
— Jonathan Carroll
quelle
Was passiert mit einer 1- oder 2-Zeilen- oder Spaltenmatrix?
— 10.
Guter Punkt, der erste Versuch besteht den 2-Spalten-Test nicht und löscht die mittlere Zeile. Ich werde aktualisieren.
— Jonathan Carroll
1
Willkommen bei Programming Puzzles & Code Golf! Wir fordern, dass alle Einsendungen entweder vollständige Programme oder Funktionen sind. In diesem Fall ist Ihr bewerteter Code nur ein Ausschnitt, da davon ausgegangen wird, dass die Variable avorhanden ist. Um unseren Regeln zu entsprechen, können Sie eine Funktion festlegen, die eine Matrix function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]=0;a}für 47 Bytes annimmt .
— Alex A.
6

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

m

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

wahr

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

b = Boole[a]

Boole

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

m b

hohle Matrix

— DavidC
quelle
Sie können ||als OP ein paar Bytes speichern, und ich sehe ein paar andere Bytes, die Sie auch speichern können!
— Ein Simmons
A Simmons, Danke für den Vorschlag.
— DavidC
# -Unitize @ ArrayFilter [Det, Array [Norm @ * List, Dimensions @ #], 1] # &
— njpipeorgan
@njpipeorgan, ich schlage vor, Sie senden es. (Und hoffentlich erklären, wie es funktioniert!)
— DavidC
@ DavidC Ich habe meine Antwort
— njpipeorgan
6

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.

— Digitales Trauma
quelle
1
Oh, ich verstehe, es ist eine "ausgefallene" Art, keine Lookaheads zu umgehen, und danke!
— andlrc
1
Zu viele Klammern: 1n;$n;:;s/ -?\w+ / : /;t;y/:/0/.
— Manatwork
1
Können Sie die Informationen über das Commit, mit dem Ihre Antwort funktioniert, in einen Angebotsblock aufnehmen, ist die Website sehr langsam und benötigt 1 Minute, um vollständig geladen zu werden
— Ferrybig
@manatwork Danke - 4 Bytes gespart!
— Digital Trauma
@Ferrybig Ein weiterer Link zur Entwicklerdiskussion zu diesem Thema wurde hinzugefügt .
— Digitales Trauma
5

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
— Becherglas
quelle
5

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
— Sp3000
quelle
5

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.

— Neil
quelle
Klug! Hier ist ein sehr ähnlicher Ansatz, ohne gden ein paar Bytes gespart werden:f=a=>a.map((b,i)=>i&&a[i+1]!=a.x?b.map?f(b):0:b)
— user81655
Gute Arbeit! Ich zähle 48 Bytes (vielleicht hast du vergessen das zu zählen f=), aber du kannst es auf 46 bringen:f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)
— ETHproductions
1
@ETHproductions Ja, ich habe vergessen das zu zählen f=. Ich bin auch ein wenig überrascht, +.5aber ich sehe, dass es beim anderen Aufruf eine Zeichenfolge hinzufügt.
— Neil
4

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.

— njpipeorgan
quelle
4

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.

— mathmandan
quelle
4

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!

— Alex A.
quelle
4

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!

— Josh
quelle
Haben Sie buchstäblich versucht, mit zu multiplizieren sizeof(int)? Sie könnten 4stattdessen verwenden ...
— Anatolyg
sizeof(int) != 4auf meinem Computer: P
— Josh
Ich wette, es ist immer noch eine einstellige Zahl, die Sie verwenden können.
— Anatolyg
Ich meinte zu diesem Zeitpunkt, ich könnte einfach entscheiden, dass es sich um ein Array von Zeichen und nicht um Ints handelt, da das Problem nur einstellige Zahlen verwendet. Kommt nur drauf an, wie weit wir die Regeln biegen wollen.
— Josh
Vielen Dank! Jetzt kann ich auch den -->Operator aloof verwenden ;)
— Josh
3

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 -
— Brad Gilbert b2gills
quelle
{.[1..*-2]»[1..*-2]X=0}speichert 2 Bytes
— Raiph
@raiph es scheint nicht für die letzten beiden Fälle zu funktionieren
— Brad Gilbert b2gills
3

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!

— ETHproductions
quelle
3

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.

— FryAmTheEggman
quelle
3

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. : /

— HyperNeutrino
quelle
3

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
     )
— Zeta
quelle
Sie sollten in der Lage sein, sich ++[last y]in :(last y)oder:last y
— HEGX64 10.02.16 um 12.08
@ HEGX64: Nein, falscher Typ. x : map f (…)ist bereits vom Typ [a]und last yhat Typ a, wohingegen (:) :: a -> [a] -> [a]. Das Hinzufügen eines Elements am Ende einer Liste in Haskell ist ein Kinderspiel, da es sich bei diesen Listen um einfach verknüpfte Weiterleitungslisten handelt.
— Zeta
Opps. Ich wusste, dass ich es selbst hätte versuchen sollen, bevor ich etwas
— poste
1
Sie können drehen kin einen Infixoperator, sagen wir , #und die Argumente Flip ein Byte speichern: [x]#_=..., (x:y)#f=..., f=(#(# \_->0))und Sie können den Namen Ihrer Hauptfunktion, dh fallen f=für weitere zwei Bytes.
— nimi
2

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

— Blau
quelle
2

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]]
— J Atkin
quelle
2

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

— mnel
quelle
1

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;
        }
    }
}
— Zeta
quelle
Das Hinzufügen von Matrixdimensionen zur Eingabe
— scheint
1

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
— aross
quelle
Bei der Verarbeitung einer Matrix sollten alle Sub-Arrays dieselbe Länge haben. Im Inneren forist es also sicher, immer zu iterieren count($z[0])-1, um 1 Zeichen zu sparen .
— Manatwork
1

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.
— lstefano
quelle
Sie können (⊣∨⊖∘⌽) durch (⊖∨⌽) ersetzen, zwei Bytes weniger
— Moris Zucca
Brillant! Lass mich das tun!
— lstefano
0

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
— undlrc
quelle
0

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

— Ausplaudern
quelle
0

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.)

— 12Me21
quelle
0

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

— ngn
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.