Ahuecar una matriz

35

La tarea

Este desafío es muy simple. Su entrada es una matriz rectangular 2D de enteros, con un tamaño de al menos 1 × 1. Se puede tomar en cualquier formato razonable. Su salida será la matriz de entrada, pero con todas las entradas que no estén en la primera o última fila o columna configuradas en 0. Debe estar en el mismo formato que la entrada.

Por ejemplo, si la matriz de entrada es

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

entonces la salida correcta es

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

Reglas y puntaje

Puede escribir un programa completo o una función, y las funciones pueden modificar la entrada en su lugar en lugar de devolverla. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Casos de prueba

Estos están formateados como listas anidadas para facilitar el pegado de copias.

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

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma. Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

## Language Name, N bytes

Si desea incluir varios números (por ejemplo, porque ha mejorado su puntaje o desea enumerar las banderas de intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Mostrar fragmento de código

code-golf array-manipulation Zgarb
fuente

Respuestas:

13

MATL , 9 bytes

0HJ_ht4$(

La entrada está en el formato

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

EDITAR (12 de junio de 2016): para adaptarse a los cambios en el idioma, el siguiente enlace ha sido _reemplazado porq .

Pruébalo en línea !

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
fuente
2
¡Agradable! Sabía que MATL estaría en la carrera. : D
vaso
12

Java 7, como una función con nombre 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;}

Podrías incluir esto en Java 8 para eliminar algunos bytes, pero realmente no hago eso.

Geobits
fuente
¿Podría ahorrar espacio usando Arrays.fill(a[i],1,a[i].length-1,0);? Son solo 36 bytes en lugar de 37. =)
corsiKa
@corsiKa Sería bueno, pero tendría que importarlo o calificarlo por completo: /
Geobits
Solo por curiosidad, ¿por qué tienes ambos bucles diferentes? ¿Por qué no for(int i=0,j;++i<a.length-1;)for(j=0;++j<a[i].length-1;)a[i][j]=0;? No guarda ningún byte, pero es más consistente con que ambos bucles sean iguales. :)
Kevin Cruijssen
12

Jalea, 18 17 15 9 bytes

0W&ṖZ
ÇÇ^

Pruébalo en línea! o verificar todos los casos de prueba .

Fondo

Este enfoque se basa en la respuesta Jelly de @ Sp3000 , específicamente en su idea de aprovechar las operaciones vectorizadas entre listas de diferentes longitudes.

Comenzamos tomando el AND bit a bit de 0 y cada número entero en la primera fila de la entrada. Debido a la vectorización automática, esto se puede lograr tomando el AND bit a bit de [0] y la entrada sin su última fila. 0 se empareja con la primera fila, lo que resulta en una fila de ceros. Como las filas restantes no tienen contrapartida en [0] , se dejan intactas.

Ahora transponemos el resultado, aplicamos la transformación anterior una vez más (eliminando efectivamente la última columna y poniendo a cero la primera), y volvemos a transponer.

Para la entrada

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

esto resulta en

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

Ahora, tomamos el XOR bit a bit de este resultado y la matriz original. XORing un entero consigo mismo produce 0 . XORing un entero con 0 (o no XORing en absoluto) produce el mismo entero. Esto ahueca la matriz.

Cómo funciona

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

Mathematica, 27 bytes

(a=#;a[[2;;-2,2;;-2]]=0;a)&
alephalpha
fuente
2
Impresionante. Ahora, ¿podrías explicarlo? Parece que está reasignando las celdas internas a cero y la -2s indica en segundo lugar la penúltima columna o fila.
DavidC
¡Qué simple es!
njpipeorgan
7

R , 33 48 bytes

Lo sé, R no está hecho para jugar al golf. Pero está hecho para indexación posicional ... Cargando un ejemplo;

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

Reemplace el valor en cualquier posición que no esté en la fila o columna del borde, 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

También verificando una prueba de 2 columnas:

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

Posteridad: intento previo

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

Prueba de todos los ejemplos:

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
fuente
¿Qué sucede con una matriz de 1 o 2 filas o columnas?
mnel
Buen punto, el primer intento falla la prueba de 2 columnas y elimina la fila del medio. Voy a actualizar
Jonathan Carroll
1
¡Bienvenido a Programming Puzzles & Code Golf! Requerimos que todos los envíos sean programas completos o funciones. En este caso, su código puntuado es solo un fragmento, ya que supone que la variable aexiste. Para cumplir con nuestras reglas, puede convertirlo en una función que tome una matriz, como function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]=0;a}47 bytes.
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])&

Cómo funciona

Suponga que la matriz de entrada está almacenada en m. Las dimensiones de mson {4,5} `

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

metro

Cada celda en la siguiente matriz, aes True si la celda está en la primera o ( ||) en la última fila o en la primera o última columna; de lo contrario es falso.

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

cierto

La aplicación de la función Boolea la matriz convierte True a 1 y False a 0.

b = Boole[a]

boole

Multiplica la matriz mpor b. Esto multiplica cada celda en m por la celda correspondiente en b.

m b

matriz hueca

DavidC
fuente
¡Puede usarlo ||como OR para guardar un par de bytes, y puedo ver algunos otros bytes que también puede guardar!
Un Simmons
A Simmons, gracias por la sugerencia.
DavidC
# -Unitize @ ArrayFilter [Det, Array [Norm @ * List, Dimensions @ #], 1] # &
njpipeorgan
@njpipeorgan, le sugiero que lo envíe. (¡Y espero que explique cómo funciona!)
DavidC
@DavidC He publicado mi respuesta
njpipeorgan
6

GNU Sed, 31

  • Gracias a @manatwork por guardar 4 bytes.

Versión 4.2.2 o anterior, antes de esta confirmación (discusión) .

La puntuación incluye +1 para la -ropción.

Las filas de entrada están separadas por una nueva línea. Los elementos en cada fila están separados por una sola línea.

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

Explicación

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`

Pruébalo en línea.

Trauma digital
fuente
1
Ah, ya veo, es una forma "elegante" de evitar miradas, ¡y gracias!
andlrc
1
Demasiados apoyos: 1n;$n;:;s/ -?\w+ / : /;t;y/:/0/.
manatwork
1
¿Puede incluir la información sobre la confirmación que hace que su respuesta funcione en un bloque de presupuesto? El sitio es realmente lento y tarda 1 minuto en cargarse por completo
Ferrybig
@manatwork Gracias, ¡ahorré 4 bytes!
Trauma digital
@Ferrybig Agregó otro enlace a la discusión de desarrollo sobre este tema .
Trauma digital
5

Octava, 34 bytes

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

Tenga en cuenta que la entrada requiere punto y coma para separar las filas de la matriz:

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

Explicación:

Los índices de matriz de octava (y MATLAB) están basados ​​en 1. Especificar un rango de Array(1:end)le dará todos los elementos de la matriz (unidimensional, en este ejemplo). Array(2:end-1)le dará todos los elementos, excepto el primero y el último.

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

se establece en 0todos los elementos que no están en la primera o última fila o columna:

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

Si una de las dimensiones es menor o igual que 2, el rango end-1es menor que 2, por lo tanto, el final del rango (2:end-1)es menor que el principio. En este caso, Octave ignora el rango y no hace nada. Esto es análogo al forbucle:

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

La condición de detención es verdadera en la primera iteración, por lo que nos salimos del ciclo.

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

    6    7
    8    9
   10   11

>> h(A)
M =

    6    7
    8    9
   10   11
cubilete
fuente
5

Jalea , 12 bytes

ZṖṖ1;¥€
¬ÇÇ×

Creo que esto funciona, todavía envolviendo mi cabeza alrededor de Jelly. Pruébalo en línea!

(Gracias a @Dennis por -2 bytes)

Funciona multiplicando la matriz de entrada por una matriz de 1s y 0s una dimensión más pequeña en cada sentido. Por ejemplo, porque [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]]multiplicamos elementos sabios por

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

Explicación 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
fuente
5

ES6, 52 48 46 bytes

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

Editar: Guardado 4 bytes gracias a @ user81655. Ahorré otros 2 bytes gracias a @ETHproductions.

Neil
fuente
¡Inteligente! Aquí hay un enfoque muy similar sin el gcual ahorra unos pocos bytes:f=a=>a.map((b,i)=>i&&a[i+1]!=a.x?b.map?f(b):0:b)
user81655
¡Buen trabajo! Cuento 48 bytes (tal vez se te olvidó contar f=), pero puedes f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)
reducirlo
1
@ETHproductions Sí, olvidé contar el f=. También estoy un poco sorprendido de que +.5funcione, pero veo que agrega una cadena en la otra llamada.
Neil
4

Javascript, 62 59 56 bytes

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

Este enfoque espera una cadena como argumento. Puedes ver lo que hace la expresión regular aquí: https://regex101.com/r/kC6xA8/3

remoto
fuente
4

Mathematica, 55 bytes

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

Caso de prueba

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

Explicación

La idea principal de esta respuesta es la misma que la respuesta de DavidC (primero construya una matriz de máscara, y luego multiplíquela por la matriz original), pero la construcción de la matriz de máscara es diferente.

ArrayFilter[f,list,r]asigna fa cada elemento listdentro de un radio de 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}] } *)

Tenga en cuenta que los elementos de límite se duplican cuando no hay suficientes vecinos. Cuando listes de 2 dimensiones, esta característica funciona bien Detpara dar el resultado deseado, ya que las columnas o filas duplicadas en cuatro límites desvanecen los determinantes.

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

donde Power~Array~{4,4}garantiza que los determinantes en las posiciones internas sean distintos de cero. Y

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

da la matriz de la máscara.

njpipeorgan
fuente
4

Python, 50 bytes

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

Acepta una lista de listas y la modifica en su lugar. La sintaxis de corte de Python no es inconveniente para esta tarea.

Aprendí que multiplicar una lista por un número negativo da como resultado una lista vacía, lo que permite que el código anterior funcione en entradas pequeñas.

Mathmandan
fuente
4

Julia, 50 35 bytes

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

Esta es una función anónima que acepta una matriz y la modifica en su lugar. Para llamarlo, asígnelo a una variable.

El enfoque aquí es bastante simple: para la matriz de entrada n por m A , asignamos A ij = 0 para todo i = 2, ..., n -1 y j = 2, ..., m -1 construyendo rangos de índices. Los rangos pueden estar vacíos, como si n o m = 1, en cuyo caso no se realiza ningún reemplazo.

Pruébalo en línea

¡Ahorró 15 bytes gracias a Dennis!

Alex A.
fuente
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;}

Espero que esté bien tomar la longitud / ancho de la matriz como parámetros. Jugué un poco con memset / bzero un poco, pero multiplicarlo sizeof(int)aumentó drásticamente el tamaño del código.

EDITAR: 55 bytes si podemos seguir doblando las reglas y almacenar nuestra matriz como caracteres, ya que la entrada es de un solo dígito cada uno.

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

EDITAR: ¡Gracias Washington Guedes por el dato!

Josh
fuente
¿Intentaste literalmente multiplicar por sizeof(int)? En su 4lugar, podría usar ...
anatolyg
sizeof(int) != 4en mi máquina: P
Josh
Apuesto a que sigue siendo un número de un solo dígito, que puedes usar.
anatolyg
Me refería a que en ese momento podría decidir que es un conjunto de caracteres en lugar de caracteres, ya que el problema solo usa números de un solo dígito. Solo depende de hasta qué punto queremos doblar las reglas.
Josh
¡Gracias! Ahora también puedo usar el -->operador distante ;)
Josh
3

Perl 6 , 28 bytes

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

Esto modifica la entrada en el lugar

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
fuente
{.[1..*-2]»[1..*-2]X=0}ahorra 2 bytes
raiph
@raiph no parece funcionar para los últimos dos casos
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))

Cómo funciona

Esta solución se asigna a través de cada índice yy índice yx xen la entrada y decide si se descarta o no en función de estos dos índices. Hay cuatro casos que debemos mantener:

  • x es 0
  • y es 0
  • x es igual a la longitud de la matriz interna, menos 1
  • y es igual a la longitud de la matriz externa, menos 1

Podemos ocuparnos de los dos primeros con una pequeña multiplicación: x*ydevuelve 0iff xo yson 0, y un entero positivo de lo contrario. Ahora para el tercero: podríamos verificar si X.length>x+1, pero eso requiere muchos bytes. Otra forma de hacer esto es verificar si el elemento que está por delante es falso, es decir undefined, qué es lo que obtienes cuando intentas acceder a un elemento inexistente. Sin embargo, esto también coincide si el siguiente elemento es 0, por lo que agregamos 0.5 para asegurarnos de que eso no suceda:

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

Finalmente, el cuarto punto: dado que la matriz externa solo tiene matrices en el interior, y cualquier matriz es verdadera, podemos verificar Y[y+1]. Ahora con ?0:N, lo convertimos a 0si todo lo anterior resultó verdadero; Nde otra manera. ¡Y eso es!

ETHproducciones
fuente
3

Retina ,31 24 22

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

Guardado 2 bytes gracias a randomra

Pruébalo en línea!

Probablemente haya una mejor manera de hacerlo, ya que este es solo un reemplazo de varias líneas bastante básico. Esencialmente, encontramos cada número precedido por una nueva línea, una cierta cantidad de caracteres y un espacio, y es seguido inmediatamente por un espacio y luego, y finalmente es seguido por una nueva línea. Estos números se reemplazan todos con 0.

Esto no preservará el relleno de la columna, pero no creo que sea un problema.

FryAmTheEggman
fuente
3

Java 8, como una función lambda: 82 83 95 caracteres / bytes

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

EDITAR Cometí un error, pensé que a [x, y] era la fila x y la columna y. ¡Claramente debería ser un [x] [y] sin embargo!

EDITAR Olvidé probar el código, y necesito volver a poner la columna a cero cada vez dentro del bucle, +12 bytes. : /

Hiperneutrino
fuente
3

Haskell 59 58 bytes

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

Expandido

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
fuente
Debería poder convertirse ++[last y]en :(last y)o:last y
HEGX64
@ HEGX64: No, tipo incorrecto. x : map f (…)ya es de tipo [a]y last ytiene tipo a, mientras que (:) :: a -> [a] -> [a]. Agregar un elemento al final de una lista en Haskell es una mierda, ya que esas listas son listas de reenvío de enlace único.
Zeta
Opps. Sabía que debería haberlo probado yo mismo antes de publicar :)
HEGX64
1
Usted puede convertir ken un operador infijo, digamos #y voltear los argumentos para salvar un byte: [x]#_=..., (x:y)#f=..., f=(#(# \_->0))y que puede caer el nombre de su función principal, es decir, f=hasta dentro de dos bytes.
nimi
2

Pyth, 18 bytes

Qjbm:dSttld0P.Qe.Q

Explicación

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

Las matrices de entrada están separadas por líneas nuevas

Pruébalo aquí

Azul
fuente
2

Groovy, 70 bytes

¡Esto no es muy creativo, pero es corto!

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

Explicación

Cierre con un argumento

g={a->

Iterar sobre la matriz interna, omitiendo el primer y el último elemento

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

Iterar sobre elementos intermedios en la matriz interna

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

Establezca los elementos ay 0regresea

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

Pruebas

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

R, 71 64 57 bytes

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

edite -7 bytes tratando explícitamente las matrices de <2 filas o <2 columnas edite explícitamente de 2 a 7 bytes asignando dimensiones de matriz mientras verifica el tamaño

mnel
fuente
1

C ++, 80 79 bytes

Espera la matriz como int**con los tamaños dados ny 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;}

Una alternativa que funciona para cualquier tipo que tenga size()y value_type & operator[](int)(98 bytes):

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

Versión ampliada

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
fuente
Parece que agregar dimensiones matriciales a la entrada es una escapatoria estándar
aross
1

PHP, 82 81 80 71 bytes

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

Corre así:

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);'
  • Guardado un byte asumiendo filas de tamaño constante (thx a manatwork)
  • Guardado un byte convirtiéndolo en una función anónima
  • Ahorró 7 bytes usando la veracidad del siguiente elemento de la matriz, evitando llamadas a count, que es un nombre demasiado largo para codegolf
aross
fuente
Al procesar una matriz, todas las sub-matrices deben tener la misma longitud. Por lo tanto, en el interior fores seguro iterar siempre count($z[0])-1para ahorrar 1 carácter.
manatwork
1

APL, 17 bytes 15 bytes

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

Cómo funciona

  • ⍳⍴⍵ genera una matriz 2D donde todas las celdas contienen las coordenadas de todas las celdas del argumento.
  • 1∊¨busca en cada celda si hay un 1 y devuelve un 1 si es así, o 0 en caso contrario. Esto construye una matriz donde la primera fila y la primera columna son 1s y el resto son 0.
  • (⌽∨⊖) se combina con la versión lógica "o" dos de la matriz, una invertida a lo largo de la primera y otra invertida a lo largo del último eje.
  • ⍵× es la multiplicación estándar
lstefano
fuente
Puede sustituir (⊣∨⊖∘⌽) con (⊖∨⌽), dos bytes menos
Moris Zucca
¡Brillante! ¡Dejame hacer eso!
lstefano
0

Perl, 34 + 2 = 36 bytes

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

Requiere el -p bandera:

$ 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

Cómo funciona:

# '-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
fuente
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

Si solo tuviera llaves en lugar de dos y termina ...

Cotilla
fuente
0

SmileBASIC, 69 51 bytes

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

Llenar un área 2D en una matriz generalmente requeriría usar FILL en un bucle. Pero es mucho más fácil trabajar con datos 2D en la página de gráficos, por lo que primero se copia la matriz allí.

Aww, pensé que era muy inteligente usando comandos gráficos ... pero resulta que llamar a FILL varias veces es más corto.

De todos modos, las entradas de función son la matriz y el ancho / alto (esto es estándar en Smilebasic porque no hay forma de verificar las dimensiones de una matriz).

12Me21
fuente
0

APL (Dyalog Classic) , 12 bytes

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

Pruébalo en línea!

⍉⌽⍵ es normalmente rotación (invertir horizontalmente y transponer)

aquí lo combinamos con el 0⍪1↓⍵que reemplaza la primera fila con ceros (suelte una fila, luego concatene 0 en la parte superior) en un solo tren:⍉0⍪1↓⌽

⍣4 se repite 4 veces

⊢- resta de la matriz original

ngn
fuente