Escavar uma matriz

35

A tarefa

Esse desafio é muito simples. Sua entrada é uma matriz 2D retangular de números inteiros, dimensionada pelo menos 1 × 1. Pode ser tomado em qualquer formato razoável. Sua saída deve ser a matriz de entrada, mas com todas as entradas que não estiverem na primeira ou na última linha ou coluna configuradas como 0. Ele deve estar no mesmo formato da entrada.

Por exemplo, se a matriz de entrada for

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

então a saída correta é

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

Regras e pontuação

Você pode escrever um programa completo ou uma função, e as funções têm permissão para modificar a entrada no lugar em vez de devolvê-la. A menor contagem de bytes vence e as brechas padrão não são permitidas.

Casos de teste

Eles são formatados como listas aninhadas para facilitar a colagem de cópias.

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

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma. Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

## Language Name, N bytes

Se você deseja incluir vários números (por exemplo, porque você melhorou sua pontuação ou deseja listar sinalizadores de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

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

Mostrar snippet de código

code-golf array-manipulation Zgarb
fonte

Respostas:

13

MATL , 9 bytes

0HJ_ht4$(

A entrada está no formato

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

EDIT (12 de junho de 2016): para se adaptar às mudanças no idioma, o link abaixo foi _substituído porq .

Experimente 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
Agradável! Eu sabia que o MATL estaria na corrida. : D
copo
12

Java 7, como uma função totalmente nomeada: 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;}

Você pode lambda isso no Java 8 para remover alguns bytes, mas eu realmente não faço isso.

Geobits
fonte
Você poderia economizar espaço usando Arrays.fill(a[i],1,a[i].length-1,0);? É somente 36 bytes em vez de 37. =)
corsiKa
@corsiKa Seria bom, mas eu teria que importá-lo ou qualificá-lo completamente: /
Geobits
Por curiosidade, por que os dois loops são diferentes? Por que não for(int i=0,j;++i<a.length-1;)for(j=0;++j<a[i].length-1;)a[i][j]=0;? Ele não salva bytes, mas é mais consistente com os dois loops iguais. :)
Kevin Cruijssen
12

Geléia, 18 17 15 9 bytes

0W&ṖZ
ÇÇ^

Experimente online! ou verifique todos os casos de teste .

fundo

Essa abordagem é baseada na resposta Jelly do @ Sp3000 , especificamente em sua idéia de aproveitar as operações vetorizadas entre listas de diferentes comprimentos.

Começamos pegando o AND bit a bit de 0 e todo número inteiro na primeira linha da entrada. Devido à vetorização automática, isso pode ser conseguido tomando o AND bit a bit de [0] e a entrada sem sua última linha. 0 é emparelhado com a primeira linha, resultando em uma linha de zeros. Como as linhas restantes não têm contrapartida em [0] , elas permanecem intocadas.

Agora, transpomos o resultado, aplique a transformação acima mais uma vez (efetivamente removendo a última coluna e zerando a primeira) e transponha novamente.

Para a entrada

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

isto resulta em

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

Agora, tomamos o XOR bit a bit desse resultado e a matriz original. XORing um número inteiro em si produz 0 . XORing um número inteiro com 0 (ou nenhum XORing) gera o mesmo número inteiro. Isso esvazia a matriz.

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

Mathematica, 27 bytes

(a=#;a[[2;;-2,2;;-2]]=0;a)&
alefalpha
fonte
2
Impressionante. Agora, você poderia explicar isso? Parece que você está redesignando células internas para zero e os -2s indicam a segunda e a última coluna ou linha.
DavidC
Como é simples!
Njpipeorgan 11/02
7

R , 33 48 bytes

Eu sei, R não é feito para jogar golfe. Mas é feito para indexação posicional ... Carregando um exemplo;

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

Substitua o valor em qualquer posição que não esteja na linha ou coluna da borda, com 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

Também verificando um teste de duas colunas:

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

Posteridade: tentativa anterior

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

Testando todos os exemplos:

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
O que acontece com uma matriz de 1 ou 2 linhas ou colunas?
mnel
Bom ponto, a primeira tentativa falha no teste de 2 colunas e exclui a linha do meio. Eu vou atualizar.
Jonathan Carroll
11
Bem-vindo à programação de quebra-cabeças e código de golfe! Exigimos que todos os envios sejam programas ou funções completos. Nesse caso, seu código pontuado é apenas um trecho, pois assume que a variável aexiste. Para estar em conformidade com nossas regras, você pode transformá-lo em uma função que requer uma matriz, como function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]=0;a}por 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])&

Como funciona

Suponha que a matriz de entrada esteja armazenada m. As dimensões de msão {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

Cada célula na matriz a seguir a, é True se a célula estiver na primeira ou ( ||) na última linha ou na primeira ou na última coluna; caso contrário, é falso.

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

verdade

A aplicação da função Booleà matriz converte True em 1 e False em 0.

b = Boole[a]

boole

Multiplique a matriz mpor b. Isso multiplica cada célula em m pela célula correspondente em b.

m b

matriz oca

DavidC
fonte
Você pode usar ||como seu OR para salvar alguns bytes, e eu posso ver alguns outros bytes que você também pode salvar!
Um Simmons
A Simmons, Obrigado pela sugestão.
DavidC
# -Unitize @ ArrayFilter [Det, Array [Norm @ * Lista, Dimensões @ #], 1] # &
njpipeorgan
@njpipeorgan, sugiro que você a envie. (E espero que explique como ele funciona!) #
1160
@DavidC Eu postei minha resposta
njpipeorgan
6

GNU Sed, 31

  • Agradecemos a @manatwork por salvar 4 bytes.

Versão 4.2.2 ou anterior, antes deste commit (discussão) .

A pontuação inclui +1 para a -ropção.

As linhas de entrada são separadas por nova linha. Os elementos em cada linha são separados por linha única.

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

Explicação

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`

Experimente online.

Trauma Digital
fonte
11
Ah, entendo, é uma maneira "chique" de se locomover sem olhares e obrigado!
9136 Andlrc
11
Muitas chaves: 1n;$n;:;s/ -?\w+ / : /;t;y/:/0/.
manatwork
11
Você pode incluir informações sobre a cometer que faz com que a sua resposta de trabalho em um bloco de citação, o local é muito lento e leva 1 minuto para a plena carga
Ferrybig
@manatwork Obrigado - salvou 4 bytes!
Digital Trauma
@Ferrybig Adicionado outro link para a discussão sobre desenvolvimento sobre este tópico .
Digital Trauma
5

Oitava, 34 bytes

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

Observe que a entrada requer ponto e vírgula para separar as linhas da matriz:

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

Explicação:

Os índices de matriz de oitava (e MATLAB) são baseados em 1. A especificação de um intervalo de Array(1:end)fornecerá todos os elementos da matriz (unidimensional, neste exemplo). Array(2:end-1)fornecerá todos os elementos, exceto o primeiro e o último.

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

define para 0todos os elementos que não estão na primeira ou na última linha ou coluna:

>> 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 uma das dimensões for menor ou igual a 2, o intervalo end-1será menor que 2, portanto, o final do intervalo (2:end-1)será menor que o início. Nesse caso, o Octave ignora o intervalo e não faz nada. Isso é análogo ao forloop:

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

A condição de parada é verdadeira na primeira iteração, então caímos fora do loop.

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

    6    7
    8    9
   10   11

>> h(A)
M =

    6    7
    8    9
   10   11
taça
fonte
5

Gelatina , 12 bytes

ZṖṖ1;¥€
¬ÇÇ×

Eu acho que isso funciona, ainda envolvendo minha cabeça em volta de Jelly. Experimente online!

(Obrigado a @Dennis por -2 bytes)

Funciona multiplicando a matriz de entrada por matrizes de 1s e 0s, uma dimensão menor em cada sentido. Por exemplo, porque [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]]multiplicamos em elementos por

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

Explicação 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 bytes

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

Editar: salvou 4 bytes graças a @ user81655. Economizou mais 2 bytes graças a @ETHproductions.

Neil
fonte
Inteligente! Aqui está uma abordagem muito semelhante sem a gqual salva alguns bytes:f=a=>a.map((b,i)=>i&&a[i+1]!=a.x?b.map?f(b):0:b)
user81655 10/10
Bom trabalho! Eu conto 48 bytes (talvez você tenha esquecido de contar o f=), mas você pode f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)
reduzi
11
@ETHproductions Sim, eu esqueci de contar o f=. Também estou um pouco surpreso com os +.5trabalhos, mas vejo que ele adiciona uma string na outra chamada.
Neil
4

Javascript, 62 59 56 bytes

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

Essa abordagem espera uma string como argumento. Você pode ver o que a regex faz aqui: https://regex101.com/r/kC6xA8/3

removido
fonte
4

Mathematica, 55 bytes

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

Caso de teste

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

Explicação

A idéia principal desta resposta é a mesma que a resposta de DavidC (primeiro construa uma matriz de máscara e depois multiplique-a pela matriz original), mas a construção da matriz de máscara é diferente.

ArrayFilter[f,list,r]mapeia ftodos os elementos listdentro de um raio 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}] } *)

Observe que os elementos de limite são duplicados quando há vizinhos insuficientes. Quando listé de duas dimensões, esse recurso funciona bem em conjunto Detpara fornecer o resultado desejado, pois colunas ou linhas duplicadas em quatro limites desaparecem os determinantes.

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

onde Power~Array~{4,4}garante que os determinantes nas posições internas sejam diferentes de zero. E

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

dá a matriz da máscara.

njpipeorgan
fonte
4

Python, 50 bytes

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

Aceita uma lista de listas e a modifica no local. A sintaxe de fatia do Python não é inconveniente para esta tarefa.

Aprendi que multiplicar uma lista por um número negativo resulta em uma lista vazia, o que permite que o código acima funcione em pequenas entradas.

mathmandan
fonte
4

Julia, 50 35 bytes

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

Esta é uma função anônima que aceita uma matriz e a modifica no local. Para chamá-lo, atribua-o a uma variável.

A abordagem aqui é bastante simples: para a matriz de entrada n por m A , atribuímos A ij = 0 para todos i = 2, ..., n -1 ej = 2, ..., m -1 construindo intervalos de índices. Os intervalos podem estar vazios, como se n ou m = 1, caso em que nenhuma substituição é feita.

Experimente online

Economizou 15 bytes graças a Dennis!

Alex A.
fonte
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 seja bom considerar o comprimento / largura da matriz como parâmetros. Eu brinquei um pouco com o memset / bzero, mas a multiplicação sizeof(int)aumentou drasticamente o tamanho do código.

EDIT: 55 bytes se pudermos dobrar ainda mais as regras e armazenar nossa matriz como caracteres, pois a entrada é apenas um dígito cada.

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

EDIT: Obrigado Washington Guedes pela dica!

Josh
fonte
Você literalmente tentou se multiplicar sizeof(int)? Você poderia usar 4...
anatolyg
sizeof(int) != 4na minha máquina: P
Josh
Aposto que ainda é um número de um dígito, que você pode usar.
Anatolyg
Eu quis dizer que naquele momento eu poderia apenas decidir que é uma matriz de caracteres em vez de ints, já que o problema usa apenas números de um dígito. Depende de quão longe queremos dobrar as regras.
21413 Josh
Obrigado! Agora eu também terá de usar o distante -->operador;)
Josh
3

Perl 6 , 28 bytes

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

Isso modifica a entrada no local

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 bytes
raiph
@raiph ele não aparece para trabalhar para os dois últimos 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))

Como funciona

Essa solução mapeia cada índice y e índice yx xna entrada e decide se deve ou não descartá-lo com base nesses dois índices. Há quatro casos que precisamos manter:

  • x é 0
  • y é 0
  • x é igual ao comprimento da matriz interna, menos 1
  • y é igual ao comprimento da matriz externa, menos 1

Podemos cuidar dos dois primeiros com um pouco de multiplicação: x*yretorna 0se xou yé 0 e um número inteiro positivo, caso contrário. Agora, o terceiro: poderíamos verificar se X.length>x+1, mas isso leva muitos bytes. Outra maneira de fazer isso é verificar se o item à frente é falso, ou seja undefined, o que você obtém ao tentar acessar um item inexistente. No entanto, isso também corresponde se o próximo item for 0, portanto, adicionamos 0,5 para garantir que isso não aconteça:

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

Finalmente, o quarto ponto: como a matriz externa possui apenas matrizes internas e qualquer matriz é verdadeira, podemos apenas verificar Y[y+1]. Agora com ?0:N, nós o convertemos para 0se todas as opções acima resultassem verdadeiras; Nde outra forma. E é isso!

ETHproductions
fonte
3

Retina ,31 24 22

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

Guardado 2 bytes graças a randomra

Experimente online!

Provavelmente existe uma maneira melhor de fazê-lo, pois essa é apenas uma substituição de várias linhas bastante básica. Essencialmente, encontramos cada número que é precedido por uma nova linha, algum número de caracteres e um espaço, e é imediatamente seguido por um espaço e, em seguida, e eventualmente seguido por uma nova linha. Esses números são todos substituídos por 0.

Isso não preservará o preenchimento da coluna, mas não acho que seja um problema.

FryAmTheEggman
fonte
3

Java 8, como uma função lambda: 82 83 95 caracteres / bytes

Assinatura Lambda: 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}}

EDIT Cometi um erro, eu pensei que a [x, y] era a décima linha e a ya coluna. Claramente, deve ser um [x] [y]!

EDIT Esqueci de testar o código e preciso definir a coluna de volta a zero todas as vezes dentro do loop, +12 bytes. : /

HyperNeutrino
fonte
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
fonte
Você deve ser capaz de se transformar ++[last y]em :(last y)ou:last y
HEGX64 10/10
@ HEGX64: Não, tipo errado. x : map f (…)já é do tipo [a]e last ytem tipo a, enquanto (:) :: a -> [a] -> [a]. A adição de um elemento no final de uma lista no tipo Haskell é uma porcaria, pois essas listas são listas de encaminhamento vinculadas por um único.
Zeta
Opps. Eu sabia que deveria ter tentado eu mesmo antes de postar :) #
305 HEGX64
11
Você pode se transformar kem um operador infix, vamos dizer #e virar os argumentos para salvar um byte: [x]#_=..., (x:y)#f=..., f=(#(# \_->0))e você pode soltar o nome da sua função principal, ou seja, f=por mais dois bytes.
nimi
2

Pitão, 18 bytes

Qjbm:dSttld0P.Qe.Q

Explicação

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

Matrizes de entrada são separadas por novas linhas

Experimente aqui

Azul
fonte
2

Groovy, 70 bytes

Isso não é muito criativo, mas é curto!

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

Explicação

Encerramento com um argumento

g={a->

Iterar sobre a matriz interna, pulando o primeiro e o último elementos

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

Iterar sobre itens do meio na matriz interna

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

Defina os elementos para 0e retornea

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

Testes

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 bytes

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

edite -7 bytes lidando explicitamente com matrizes <2 linhas ou <2 colunas edite explicitamente 2-7 bytes atribuindo dimensões da matriz enquanto verifica o tamanho

mnel
fonte
1

C ++, 80 79 bytes

Espera a matriz como int**em determinados tamanhos 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;}

Uma alternativa que funciona para qualquer tipo que tenha size()e 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;}

Versão expandida

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
Parecem como a adição de dimensões da matriz para a entrada é uma brecha padrão
aross
1

PHP, 82 81 80 71 bytes

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

Execute assim:

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);'
  • Salva um byte assumindo linhas de tamanho constante (thx para manatwork)
  • Salvou um byte, tornando-o uma função anônima
  • Economizou 7 bytes usando a truthyness do próximo item da matriz, impedindo chamadas para count, que é um nome muito longo para codegolf
aross
fonte
Ao processar uma matriz, todas as sub-matrizes devem ter o mesmo comprimento. Portanto, no interior foré seguro iterar sempre até count($z[0])-1poupar 1 caractere.
manatwork
1

APL, 17 bytes 15 bytes

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

Como funciona

  • ⍳⍴⍵ gera uma matriz 2D em que todas as células contêm as coordenadas de todas as células do argumento.
  • 1∊¨procura em cada célula se houver 1 e retorna 1 se houver, ou 0 caso contrário. Isso cria uma matriz em que a primeira linha e a primeira coluna são 1s e o restante é 0.
  • (⌽∨⊖) combina com "ou" duas versões lógicas da matriz, uma invertida ao longo da primeira e outra invertida ao longo do último eixo.
  • ⍵× é a multiplicação padrão.
lstefano
fonte
Você pode substituir (⊣∨⊖∘⌽) com (⊖∨⌽), dois bytes menos
Moris Zucca
Brilhante! Deixe-me fazer isso!
Lstefano
0

Perl, 34 + 2 = 36 bytes

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

Requer a -pbandeira:

$ 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

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

Se ao menos eu tivesse aparelho em vez de dos e termina ...

Blab
fonte
0

SmileBASIC, 69 51 bytes

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

O preenchimento de uma área 2D em uma matriz geralmente exigiria o preenchimento de um loop. Mas é muito mais fácil trabalhar com dados 2D na página de gráficos; primeiro, o array é copiado para lá.

Aww, eu pensei que era tão inteligente usando comandos gráficos ... mas acontece que chamar FILL várias vezes é realmente mais curto.

De qualquer forma, as entradas de função são a matriz e a largura / altura (isso é padrão no Smilebasic porque não há como verificar as dimensões de uma matriz).

12Me21
fonte
0

APL (Dyalog Classic) , 12 bytes

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

Experimente online!

⍉⌽⍵ é normalmente rotação (inverter horizontalmente e transpor)

aqui nós o combinamos com o 0⍪1↓⍵que substitui a primeira linha por zeros (solte uma linha e concatene 0 no topo) em um único trem:⍉0⍪1↓⌽

⍣4 repete 4 vezes

⊢- subtrai da matriz original

ngn
fonte