Scavare una matrice

35

L'obiettivo

Questa sfida è molto semplice. Il tuo input è un array 2D rettangolare di numeri interi, delle dimensioni di almeno 1 × 1. Può essere preso in qualsiasi formato ragionevole. L'output deve essere l'array di input, ma con tutte le voci non nella prima o nell'ultima riga o colonna impostate su 0. Deve essere nello stesso formato dell'input.

Ad esempio, se l'array di input è

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

quindi l'output corretto è

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

Regole e punteggio

È possibile scrivere un programma completo o una funzione e le funzioni sono autorizzate a modificare l'input invece di restituirlo. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Casi test

Questi sono formattati come elenchi nidificati per facilitare il copia-incolla.

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

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua. Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

Se vuoi includere più numeri (ad es. Perché hai migliorato il tuo punteggio o vuoi elencare i flag dell'interprete separatamente), assicurati che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Mostra snippet di codice

code-golf  array-manipulation 
— Zgarb
fonte

Risposte:

13

MATL , 9 byte

0HJ_ht4$(

L'input è nel formato

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

EDIT (12 giugno 2016): per adattarsi ai cambiamenti nella lingua, il link seguente è stato _sostituito daq .

Provalo 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
fonte
2
Bello! Sapevo che MATL sarebbe stato in corsa. : D
— becher
12

Java 7, come funzione con nome completo: 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;}

Potresti risolvere questo problema in Java 8 per rimuovere alcuni byte, ma non lo faccio davvero.

— Geobits
fonte
Potresti risparmiare spazio usando Arrays.fill(a[i],1,a[i].length-1,0);? Sono solo 36 byte anziché 37. =)
— corsiKa
@corsiKa Sarebbe bello, ma dovrei importarlo o qualificarlo completamente: /
— Geobits
Solo per curiosità, perché hai entrambi i loop diversi? Perché no for(int i=0,j;++i<a.length-1;)for(j=0;++j<a[i].length-1;)a[i][j]=0;? Non salva alcun byte, ma è più coerente con entrambi i loop uguali. :)
— Kevin Cruijssen
12

Gelatina, 18 17 15 9 byte

0W&ṖZ
ÇÇ^

Provalo online! o verifica tutti i casi di test .

sfondo

Questo approccio si basa sulla risposta Jelly di @ Sp3000 , in particolare sulla sua idea di sfruttare le operazioni vettoriali tra elenchi di diverse lunghezze.

Iniziamo prendendo l'AND bit a bit di 0 e ogni numero intero nella prima riga dell'input. Grazie alla vettorializzazione automatica, questo può essere ottenuto prendendo AND bit a bit di [0] e l'input senza la sua ultima riga. 0 è associato alla prima riga, risultante in una riga di zero. Poiché le righe rimanenti non hanno una controparte in [0] , rimangono invariate.

Ora trasponiamo il risultato, applichiamo di nuovo la trasformazione precedente (rimuovendo efficacemente l'ultima colonna e azzerando la prima) e trasponendo nuovamente.

Per l'input

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

questo risulta in

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

Ora prendiamo lo XOR bit per bit di questo risultato e la matrice originale. XORing produce un intero con se stesso 0 . XORing un numero intero con 0 (o non XORing affatto) produce lo stesso numero intero. Questo svuota la matrice.

Come funziona

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
fonte
8

Mathematica, 27 byte

(a=#;a[[2;;-2,2;;-2]]=0;a)&
— alephalpha
fonte
2
Impressionante. Ora, potresti spiegarlo per favore? Sembra che tu stia riassegnando le celle interne a zero e la -2s indica la penultima colonna o riga.
— DavidC,
Com'è semplice!
— njpipeorgan,
7

R , 33 48 byte

Lo so, R non è fatto per il golf. Ma è fatto per l'indicizzazione posizionale ... Caricamento di un esempio;

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

Sostituisci il valore in qualsiasi posizione non sulla riga o colonna del bordo, con 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

Controllando anche un test a 2 colonne:

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

Posterità: tentativo precedente

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

Test di tutti gli esempi:

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
fonte
Cosa succede con una matrice di 1 o 2 righe o colonne?
— Mnel
Buon punto, il primo tentativo fallisce il test a 2 colonne ed elimina la riga centrale. Aggiornerò.
— Jonathan Carroll,
1
Benvenuto in Programmazione di puzzle e codice golf! Richiediamo che tutti gli invii siano programmi o funzioni completi. In questo caso, il tuo codice segnato è solo uno snippet, poiché si presume che la variabile aesista. Per essere conforme alle nostre regole, potresti renderlo una funzione che accetta una matrice, come function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]=0;a}per 47 byte.
— Alex A.
6

Mathematica 81 76 byte

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

Come funziona

Supponiamo che l'array di input sia archiviato m. Le dimensioni di msono {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

Ogni cella nel seguente array, aè True se la cella è nella prima o ( ||) nell'ultima riga o nella prima o nell'ultima colonna; altrimenti è falso.

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

true

L'applicazione della funzione Booleall'array converte True in 1 e False in 0.

b = Boole[a]

boole

Moltiplica la matrice mper b. Questo moltiplica ogni cella in m per la cella corrispondente in b.

m b

hollow matrix

— DavidC
fonte
Puoi usare ||come OR per salvare un paio di byte, e posso vedere alcuni altri byte che puoi salvare anche tu!
— A Simmons,
A Simmons, grazie per il suggerimento.
— DavidC,
# -Unitize @ ArrayFilter [Det, Array [Norm @ * List, Dimensions @ #], 1] # &
— njpipeorgan
@njpipeorgan, ti suggerisco di inviarlo. (E spero di spiegare come funziona!)
— DavidC,
@DavidC Ho pubblicato la mia risposta
— njpipeorgan il
6

GNU Sed, 31

  • Grazie a @manatwork per aver salvato 4 byte.

Versione 4.2.2 o precedente, prima di questo commit (discussione) .

Il punteggio include +1 per l' -ropzione.

Le righe di input sono separate da una nuova riga. Gli elementi su ciascuna riga sono separati da una riga.

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

Spiegazione

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`

Provalo online.

— Trauma digitale
fonte
1
Oh capisco, è un modo "stravagante" per aggirare nessuno sguardo, e grazie!
— Andlrc,
1
Troppi bretelle: 1n;$n;:;s/ -?\w+ / : /;t;y/:/0/.
— arte
1
Puoi includere le informazioni sul commit che fanno funzionare la tua risposta in un blocco di preventivi, il sito è molto lento e richiede 1 minuto per caricarsi completamente
— Ferrybig,
@manatwork Grazie - salvato 4 byte!
— Trauma digitale
@Ferrybig Aggiunto un altro link alla discussione degli sviluppatori su questo argomento .
— Trauma digitale
5

Ottava, 34 byte

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

Si noti che l'input richiede punti e virgola per separare le righe dell'array:

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

Spiegazione:

Gli indici di array di ottava (e MATLAB) sono basati su 1. Se si specifica un intervallo di, si Array(1:end)otterranno tutti gli elementi dell'array (unidimensionale, in questo esempio). Array(2:end-1)ti darà tutti gli elementi tranne il primo e l'ultimo.

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

imposta su 0tutti gli elementi non presenti nella prima o nell'ultima riga o colonna:

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

Se una delle dimensioni è inferiore o uguale a 2, l'intervallo end-1è inferiore a 2, quindi la fine dell'intervallo (2:end-1)è inferiore all'inizio. In questo caso, Octave ignora l'intervallo e non fa nulla. Questo è analogo al forloop:

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

La condizione di arresto è vera alla prima iterazione, quindi cadiamo fuori dal ciclo.

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

    6    7
    8    9
   10   11

>> h(A)
M =

    6    7
    8    9
   10   11
— coppa
fonte
5

Gelatina , 12 byte

ZṖṖ1;¥€
¬ÇÇ×

Penso che funzioni, avvolgendo ancora la testa attorno a Jelly. Provalo online!

(Grazie a @Dennis per -2 byte)

Funziona moltiplicando l'array di input per un array di 1 e 0 una dimensione più piccola in ogni modo. Ad esempio, poiché [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]]moltiplichiamo per elemento

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

Spiegazione completa

[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
fonte
5

ES6, 52 48 46 byte

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

Modifica: salvato 4 byte grazie a @ user81655. Risparmiato altri 2 byte grazie a @ETHproductions.

— Neil
fonte
Intelligente! Ecco un approccio molto simile senza il gquale salva qualche byte:f=a=>a.map((b,i)=>i&&a[i+1]!=a.x?b.map?f(b):0:b)
— user81655
Bel lavoro! Conto 48 byte (forse ti sei dimenticato di contare f=), ma puoi arrivare a 46:f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)
— ETHproductions
1
@ETHproductions Sì, ho dimenticato di contare f=. Inoltre sono un po 'sorpreso di +.5lavorare ma vedo che fa un'aggiunta di stringa nell'altra chiamata.
— Neil,
4

Javascript, 62 59 56 byte

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

Questo approccio prevede una stringa come argomento. Puoi vedere cosa fanno i regex qui: https://regex101.com/r/kC6xA8/3

— rimosso
fonte
4

Mathematica, 55 byte

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

Caso di prova

%[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}}
*)

Spiegazione

L'idea principale di questa risposta è la stessa della risposta di DavidC (prima costruisci una matrice di maschere e poi moltiplicala per la matrice originale), ma la costruzione della matrice di maschere è diversa.

ArrayFilter[f,list,r]mappa fsu ogni elemento listall'interno di un raggio di 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}] } *)

Si noti che gli elementi di confine vengono duplicati in presenza di vicini insufficienti. Quando listè di 2 dimensioni, questa funzione funziona bene insieme Detper dare il risultato desiderato, poiché colonne o righe duplicate su quattro contorni svaniscono i determinanti.

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

dove Power~Array~{4,4}garantisce che i determinanti sulle posizioni interne siano diversi da zero. E

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

dà la matrice maschera.

— njpipeorgan
fonte
4

Python, 50 byte

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

Accetta un elenco di elenchi e lo modifica in posizione. La sintassi della slice di Python non è scomoda per questa attività.

Ho imparato che moltiplicando un elenco per un numero negativo si ottiene un elenco vuoto, che consente al codice sopra riportato di funzionare su input di piccole dimensioni.

— mathmandan
fonte
4

Julia, 50 35 byte

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

Questa è una funzione anonima che accetta un array e lo modifica in posizione. Per chiamarlo, assegnarlo a una variabile.

L'approccio qui è abbastanza semplice: per l' array di input n per m A , assegniamo A ij = 0 per tutti i = 2, ..., n -1 e j = 2, ..., m -1 costruendo intervalli di indici. Gli intervalli possono essere vuoti, come se n o m = 1, nel qual caso non viene effettuata alcuna sostituzione.

Provalo online

Risparmiato 15 byte grazie a Dennis!

— Alex A.
fonte
4

C, 62 byte

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

Spero che sia ok prendere la lunghezza / larghezza dell'array come parametri. Ho giocato un po 'con memset / bzero, ma moltiplicando persizeof(int) aumentando drasticamente la dimensione del codice.

EDIT: 55 byte se possiamo ulteriormente piegare le regole e memorizzare il nostro array come caratteri poiché l'input è solo una singola cifra ciascuno.

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

EDIT: Grazie Washington Guedes per l'informazione!

— Josh
fonte
Hai letteralmente provato a moltiplicare per sizeof(int)? Potresti usare 4invece ...
— Anatolyg
sizeof(int) != 4sulla mia macchina: P
— Josh,
Scommetto che è ancora un numero a una cifra, che puoi usare.
— Anatolyg
Intendevo a quel punto che potevo semplicemente decidere che si tratta di una serie di caratteri piuttosto che di interi, poiché il problema utilizza solo numeri a una cifra. Dipende solo da quanto vogliamo piegare le regole.
— Josh,
Grazie! Adesso uso anche l' -->operatore distaccato ;)
— Josh,
3

Perl 6 , 28 byte

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

Questo modifica l'ingresso sul posto

uso

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
fonte
{.[1..*-2]»[1..*-2]X=0}salva 2 byte
— raiph,
@raiph non sembra funzionare negli ultimi due casi
— Brad Gilbert b2gills
3

JavaScript ES6, 69 66 57 byte

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

Come funziona

Questa soluzione esegue il mapping di ciascun indice y e indice yx xnell'input e decide se eliminarlo o meno in base a questi due indici. Ci sono quattro casi che dobbiamo tenere:

  • x è 0
  • y è 0
  • x è uguale alla lunghezza dell'array interno, meno 1
  • y è uguale alla lunghezza dell'array esterno, meno 1

Possiamo occuparci dei primi due con una piccola moltiplicazione: x*yrestituisce 0iff xo ysono 0 e un numero intero positivo altrimenti. Ora per il terzo: potremmo verificare se X.length>x+1, ma ci vogliono molti byte. Un altro modo per farlo è verificare se l'articolo davanti è falso, vale a dire undefined, che è quello che ottieni quando cerchi di accedere a un oggetto inesistente. Tuttavia, questo corrisponde anche se l'elemento successivo è 0, quindi aggiungiamo 0,5 per assicurarci che ciò non accada:

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

Infine, il quarto punto: poiché l'array esterno ha solo array all'interno e qualsiasi array è vero, possiamo semplicemente verificare Y[y+1]. Ora con ?0:N, lo convertiamo in 0se tutto quanto sopra risultasse vero; Naltrimenti. E questo è tutto!

— ETHproductions
fonte
3

Retina ,31 24 22

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

Salvato 2 byte grazie a randomra

Provalo online!

Probabilmente esiste un modo migliore per farlo, in quanto si tratta solo di una sostituzione multilinea piuttosto semplice. In sostanza troviamo ogni numero preceduto da una nuova riga, un certo numero di caratteri e uno spazio, seguito immediatamente da uno spazio e quindi seguito da una nuova riga. Questi numeri vengono quindi sostituiti con 0.

Ciò non preserverà il riempimento delle colonne, ma non credo che sia un problema.

— FryAmTheEggman
fonte
3

Java 8, come funzione lambda: 82 83 95 caratteri / byte

Firma Lambda: int[][] -> (void)(es. 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}}

EDIT Ha fatto un errore, ho pensato che una [x, y] fosse la x riga e il quinto col. Chiaramente dovrebbe essere un [x] [y] però!

EDIT Ho dimenticato di testare il codice e devo riportare la colonna a zero ogni volta all'interno del ciclo, +12 byte. : /

— HyperNeutrino
fonte
3

Haskell, 59 58 byte

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

allargato

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
fonte
Dovreste essere in grado di trasformare ++[last y]in :(last y)o:last y
— HEGX64
@ HEGX64: No, tipo sbagliato. x : map f (…)è già di tipo [a]e last yha tipo a, mentre (:) :: a -> [a] -> [a]. L'aggiunta di un elemento alla fine di un elenco nel tipo di Haskell fa schifo, dal momento che tali elenchi sono elenchi forward a collegamento singolo.
— Zeta,
Opps. Sapevo che avrei dovuto
— provarlo
1
È possibile trasformare kin un operatore infisso, diciamo #e capovolgere gli argomenti per salvare un byte: [x]#_=..., (x:y)#f=..., f=(#(# \_->0))e si può cadere il nome della funzione principale, vale a dire f=per altri due byte.
— nimi,
2

Pyth, 18 byte

Qjbm:dSttld0P.Qe.Q

Spiegazione

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

Le matrici di input sono separate da newline

Provalo qui

— Blu
fonte
2

Groovy, 70 byte

Questo non è molto creativo, ma è breve!

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

Spiegazione

Chiusura con un arg

g={a->

Scorrere sull'array interno, saltando il primo e l'ultimo elemento

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

Scorrere gli elementi intermedi nella matrice interna

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

Impostare gli elementi su 0 e tornarea

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

test

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
fonte
2

R, 71 64 57 byte

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

modifica -7 byte trattando esplicitamente le matrici <2 righe o <2 colonne esplicitamente modifica2 -7 byte assegnando le dimensioni della matrice controllando la dimensione

— mnel
fonte
1

C ++, 80 79 byte

Si aspetta l'array come int**con le dimensioni indicate ne 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;}

Un'alternativa che funziona per qualsiasi tipo che ha size()e value_type & operator[](int)(98 byte):

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

Versione estesa

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
fonte
Sembra che l'aggiunta di dimensioni di matrice all'input sia una scappatoia standard
— avvenuta l'
1

PHP, 82 81 80 71 byte

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

Esegui in questo modo:

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);'
  • Salvataggio di un byte assumendo righe di dimensioni costanti (grazie a manatwork)
  • Ho salvato un byte rendendolo una funzione anonima
  • Salvato 7 byte usando la verità del prossimo elemento dell'array, impedendo le chiamate a count, che è un nome troppo lungo per codegolf
— aross
fonte
Come elaborando una matrice, tutti i sotto-array dovrebbero avere la stessa lunghezza. Quindi al suo interno forè sicuro iterare sempre fino count($z[0])-1a risparmiare 1 personaggio.
— arte
1

APL, 17 byte 15 byte

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

Come funziona

  • ⍳⍴⍵ genera un array 2D in cui tutte le celle contengono le coordinate di tutte le celle dell'argomento.
  • 1∊¨cerca in ciascuna di queste celle se c'è un 1 e restituisce un 1 in tal caso, o 0 in caso contrario. Questo crea una matrice in cui la prima riga e la prima colonna sono 1s e tutto il resto sono 0.
  • (⌽∨⊖) si combina con la logica "o" due versioni della matrice, una invertita lungo la prima e una invertita lungo l'ultimo asse.
  • ⍵× è la moltiplicazione standard.
— lstefano
fonte
Puoi sostituire (⊣∨⊖∘⌽) con (⊖∨⌽), due byte in meno
— Moris Zucca
Brillante! Lasciami fare questo!
— lstefano,
0

Perl, 34 + 2 = 36 byte

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

Richiede la -pbandiera:

$ 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

Come funziona:

# '-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
— andlrc
fonte
0

Lua, 69 byte

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

Se solo avessi delle parentesi graffe invece di dos e fine ...

— spifferare
fonte
0

SmileBASIC, 69 51 byte

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

Riempire un'area 2D in un array di solito richiederebbe l'uso di FILL in un ciclo. Ma è molto più facile lavorare con i dati 2D sulla pagina grafica, quindi prima l'array viene copiato lì.

Aww Pensavo di essere così intelligente usando i comandi grafici ... ma si scopre che chiamare FILL un sacco di volte è in realtà più breve.

Ad ogni modo, gli input di funzione sono l'array e la larghezza / altezza (questo è standard in Smilebasic perché non c'è modo di controllare le dimensioni di un array).

— 12Me21
fonte
0

APL (Dyalog Classic) , 12 byte

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

Provalo online!

⍉⌽⍵ è normalmente rotazione (inversione orizzontale e trasposizione)

qui lo combiniamo con il 0⍪1↓⍵quale sostituisce la prima riga con zero (rilascia una riga, quindi concatena 0 in alto) in un singolo treno:⍉0⍪1↓⌽

⍣4 si ripete 4 volte

⊢- sottrae dalla matrice originale

— NGN
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.