Évider un tableau

35

La tâche

Ce défi est très simple. Votre entrée est un tableau 2D entier d’entiers, d’une taille minimale de 1 × 1. Il peut être pris dans n’importe quel format raisonnable. Votre sortie doit être le tableau en entrée, mais avec toutes les entrées non définies sur la première ou la dernière ligne ou colonne 0. Il doit être au même format que l’entrée.

Par exemple, si le tableau d'entrée est

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

alors la sortie correcte est

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

Règles et notation

Vous pouvez écrire un programme complet ou une fonction, et les fonctions sont autorisées à modifier l'entrée en place au lieu de la renvoyer. Le nombre d'octets le plus faible gagne et les failles standard sont interdites.

Cas de test

Celles-ci sont formatées en tant que listes imbriquées pour faciliter le copier-coller.

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

Classement

Voici un extrait de pile permettant de générer un classement régulier et un aperçu des gagnants par langue. Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

Si vous souhaitez inclure plusieurs numéros (par exemple, parce que vous avez amélioré votre score ou si vous souhaitez répertorier les indicateurs d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Afficher l'extrait de code

code-golf  array-manipulation 
— Zgarb
source

Réponses:

13

MATL , 9 octets

0HJ_ht4$(

L'entrée est au format

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

EDIT (12 juin 2016): pour s'adapter aux changements de langue, le lien ci-dessous a été _remplacé parq .

Essayez-le en ligne !

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
source
2
Agréable! Je savais que MATL serait dans la course. : D
— becher
12

Java 7, en tant que fonction entièrement nommée: 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;}

Vous pouvez lambda dans Java 8 pour supprimer quelques octets, mais je ne le fais pas vraiment.

— Géobits
source
Pourriez-vous économiser de l'espace en utilisant Arrays.fill(a[i],1,a[i].length-1,0);? C'est seulement 36 octets au lieu de 37. =)
— corsiKa
@corsiKa Ce serait bien, mais je devrais l'importer ou le qualifier complètement: /
— Geobits
Juste par curiosité, pourquoi avez-vous des boucles différentes? Pourquoi ne pas for(int i=0,j;++i<a.length-1;)for(j=0;++j<a[i].length-1;)a[i][j]=0;? Cela ne sauvegarde aucun octet, mais il est plus cohérent, les deux boucles étant identiques. :)
— Kevin Cruijssen
12

Jelly, 18 17 15 9 octets

0W&ṖZ
ÇÇ^

Essayez-le en ligne! ou vérifier tous les cas de test .

Contexte

Cette approche est basée sur la réponse Jelly de @ Sp3000 , plus précisément sur son idée de tirer parti des opérations vectorisées entre des listes de longueurs différentes.

Nous commençons par prendre l'ET au niveau du bit AND de 0 et chaque entier de la première ligne de l'entrée. En raison de la vectorisation automatique, ceci peut être réalisé en prenant l'ET au niveau du bit AND de [0] et l'entrée sans sa dernière ligne. 0 est associé à la première ligne, ce qui donne une ligne de zéros. Comme les lignes restantes n'ont pas d'équivalent dans [0] , elles ne sont pas modifiées.

Maintenant, nous transposons le résultat, appliquons à nouveau la transformation ci-dessus (en supprimant effectivement la dernière colonne et en mettant à zéro la première) et en transposant à nouveau.

Pour l'entrée

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

cela se traduit par

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

Maintenant, prenons le bit XOR de ce résultat et la matrice originale. XORing un entier avec lui-même donne 0 . XORing un entier avec 0 (ou pas du tout) donne le même entier. Cela creuse la matrice.

Comment ça marche

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

Mathematica, 27 octets

(a=#;a[[2;;-2,2;;-2]]=0;a)&
— Alephalpha
source
2
Impressionnant. Maintenant, voudriez-vous s'il vous plaît expliquer? Il semble que vous réaffectiez les cellules internes à zéro et le -2s indique en deuxième l’avant dernière colonne ou ligne.
— DavidC
Comme c'est simple!
— njpipeorgan
7

R , 33 48 octets

Je sais que R n'est pas fait pour le golf. Mais il est fait pour l'indexation positionnelle ... Chargement d'un exemple;

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

Remplacez la valeur à n’importe quelle position, pas sur la ligne ou la colonne du bord, par 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

Vérification également d'un test à 2 colonnes:

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

Postérité: tentative précédente

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

Test de tous les exemples:

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
source
Que se passe-t-il avec une matrice de 1 ou 2 rangées ou de colonnes?
— Mnel
Bon point, la première tentative échoue le test à 2 colonnes et supprime la ligne du milieu. Je mettrai à jour.
— Jonathan Carroll
1
Bienvenue dans Programming Puzzles & Code Golf! Nous exigeons que toutes les soumissions soient des programmes complets ou des fonctions. Dans ce cas, votre code scanné est juste un extrait, car il suppose que la variable aexiste. Pour respecter nos règles, vous pouvez en faire une fonction prenant une matrice, comme function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]=0;a}pour 47 octets.
— Alex A.
6

Mathematica 81 76 octets

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

Comment ça marche

Supposons que le tableau d’entrée soit stocké dans m. Les dimensions de msont {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

Chaque cellule du tableau suivant a, est définie sur True si la cellule figure dans la première ou ||dans la dernière ligne ( ) ou dans la première ou la dernière colonne; sinon c'est Faux.

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

vrai

L'application de la fonction Booleau tableau convertit True en 1 et False en 0.

b = Boole[a]

boole

Multipliez la matrice mpar b. Ceci multiplie chaque cellule en m par la cellule correspondante en b.

m b

matrice creuse

— DavidC
source
Vous pouvez utiliser ||votre OU pour sauvegarder quelques octets, et je peux voir quelques autres octets que vous pouvez également sauvegarder!
— Un Simmons
A Simmons, Merci pour la suggestion.
— DavidC
# -Unitize @ ArrayFilter [Det, Array [Liste @ *, Dimensions @ #], 1] # &
— njpipeorgan
@njpipeorgan, je vous suggère de le soumettre. (Et j'espère expliquer comment ça marche!)
— DavidC
@DavidC J'ai posté ma réponse
— njpipeorgan le
6

GNU Sed, 31

  • Merci à @manatwork pour la sauvegarde de 4 octets.

Version 4.2.2 ou antérieure, antérieure à cette validation (discussion) .

Le score inclut +1 pour l' -roption.

Les lignes d'entrée sont séparées par une nouvelle ligne. Les éléments de chaque ligne sont séparés par une seule ligne.

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

Explication

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`

Essayez-le en ligne.

— Trauma numérique
source
1
Oh, je vois, c’est un moyen "élégant" de se déplacer sans se perdre, et merci!
— andlrc
1
Trop de accolades: 1n;$n;:;s/ -?\w+ / : /;t;y/:/0/.
— manatwork
1
Pouvez-vous inclure les informations sur le commit qui permet à votre réponse de fonctionner dans un bloc quote, le site est vraiment lent et prend 1 minute pour être entièrement chargé
— Ferrybig
@manatwork Merci - 4 octets sauvegardés!
— Digital Trauma
@Ferrybig Ajout d'un autre lien vers la discussion du développeur sur ce sujet .
— Digital Trauma
5

Octave, 34 octets

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

Notez que l'entrée nécessite des points-virgules pour séparer les lignes d'un tableau:

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

Explication:

Les indices de tableau Octave (et MATLAB) sont basés sur 1. Spécifier une plage de Array(1:end)vous donnera tous les éléments du tableau (unidimensionnel, dans cet exemple). Array(2:end-1)vous donnera tous les éléments sauf le premier et le dernier.

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

définit 0tous les éléments qui ne figurent pas dans la première ou la dernière ligne ou colonne:

>> 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 l'une des dimensions est inférieure ou égale à 2, la plage end-1est inférieure à 2; la fin de la plage (2:end-1)est donc inférieure au début. Dans ce cas, Octave ignore la plage et ne fait rien. Ceci est analogue à la forboucle:

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

La condition d'arrêt est vraie à la première itération, nous tombons donc hors de la boucle.

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

    6    7
    8    9
   10   11

>> h(A)
M =

    6    7
    8    9
   10   11
— gobelet
source
5

Gelée , 12 octets

ZṖṖ1;¥€
¬ÇÇ×

Je pense que cela fonctionne, enveloppant toujours ma tête autour de Jelly. Essayez-le en ligne!

(Merci à @Dennis pour -2 octets)

Fonctionne en multipliant le tableau d'entrée par des tableaux de 1 et de 0 une dimension plus petite dans chaque sens. Par exemple, [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]]nous multiplions élément par élément

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

Explication complète

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

ES6, 52 48 46 octets

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

Edit: 4 octets sauvegardés grâce à @ user81655. Sauvegardé 2 octets supplémentaires grâce à @ETHproductions.

— Neil
source
Intelligent! Voici une approche très similaire sans gqui permet d'économiser quelques octets:f=a=>a.map((b,i)=>i&&a[i+1]!=a.x?b.map?f(b):0:b)
— user81655
Bon travail! Je compte 48 octets (vous avez peut-être oublié de compter le nombre f=), mais vous pouvez le réduire à 46:f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)
— ETHproductions
1
@ETHproductions Oui, j'ai oublié de compter le f=. Aussi, je suis un peu surpris des +.5travaux mais je vois qu'il ajoute une chaîne dans l'autre appel.
— Neil
4

Javascript, 62 59 56 octets

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

Cette approche attend une chaîne comme argument. Vous pouvez voir ce que font les regex ici: https://regex101.com/r/kC6xA8/3

— enlevé
source
4

Mathematica, 55 octets

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

Cas de test

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

Explication

L'idée principale de cette réponse est la même que celle de DavidC (commencez par construire une matrice de masque, puis multipliez-la par la matrice d'origine), mais la construction de la matrice de masque est différente.

ArrayFilter[f,list,r]mappe fsur chaque élément de listdans un rayon 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}] } *)

Notez que les éléments de frontière sont dupliqués lorsque les voisins sont insuffisants. Quand listest de 2 dimensions, cette fonctionnalité fonctionne bien Detpour donner le résultat souhaité, puisque les colonnes ou les lignes dupliquées sur quatre limites effacent les déterminants.

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

où Power~Array~{4,4}garantit que les déterminants des positions internes sont non nuls. Et

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

donne la matrice de masque.

— njpipeorgan
source
4

Python, 50 octets

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

Accepte une liste de listes et la modifie sur place. La syntaxe de slice de Python n’est pas gênante pour cette tâche.

J'ai appris que multiplier une liste par un nombre négatif donne une liste vide, ce qui permet au code ci-dessus de fonctionner avec de petites entrées.

— Mathmandan
source
4

Julia, 50 35 octets

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

C'est une fonction anonyme qui accepte un tableau et le modifie sur place. Pour l'appeler, assignez-le à une variable.

L’approche ici est assez simple: pour le tableau d’entrée A n par m , nous assignons A ij = 0 pour tout i = 2, ..., n -1 et j = 2, ..., m -1 en construisant des plages des indices. Les plages peuvent être vides, comme si n ou m = 1, auquel cas aucun remplacement n’est effectué.

Essayez-le en ligne

Sauvegardé 15 octets grâce à Dennis!

— Alex A.
source
4

C, 62 octets

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

J'espère que ça va de prendre en longueur de tableau / largeur en tant que paramètres. Je me suis un peu amusé avec memset / bzero, mais sa multiplication a sizeof(int)considérablement augmenté la taille du code.

EDIT: 55 octets si nous pouvons continuer à plier les règles et stocker notre tableau sous forme de caractères puisque l’entrée n’est composée que d’un seul chiffre.

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

EDIT: Merci Washington Guedes pour le tuyau!

— Josh
source
Avez-vous littéralement essayé de multiplier par sizeof(int)? Vous pourriez utiliser à la 4place ...
— Anatolyg
sizeof(int) != 4sur ma machine: P
— Josh
Je parie que c'est toujours un nombre à un chiffre, que vous pouvez utiliser.
— Anatolyg
Je voulais dire qu'à ce moment-là, je pourrais simplement décider que c'est un tableau de caractères plutôt que d'ints, car le problème utilise uniquement des nombres à un chiffre. Tout dépend à quel point nous voulons contourner les règles.
— Josh
Merci! Maintenant, je peux aussi utiliser l' -->opérateur distant ;)
— Josh
3

Perl 6 , 28 octets

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

Ceci modifie l'entrée en place

Usage

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
source
{.[1..*-2]»[1..*-2]X=0}enregistre 2 octets
— raiph
@raiph cela ne semble pas fonctionner pour les deux derniers cas
— Brad Gilbert b2gills
3

JavaScript ES6, 69 66 57 octets

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

Comment ça marche

Cette solution est mappée sur chaque index y yet x-index xde l'entrée et décide de le supprimer ou non en fonction de ces deux index. Il y a quatre cas que nous devons garder:

  • x est 0
  • y est 0
  • x est égal à la longueur de la matrice interne, moins 1
  • y est égal à la longueur de la matrice externe, moins 1

Nous pouvons nous occuper des deux premiers avec un peu de multiplication: x*yrenvoie 0si xou yest égal à 0, et un entier positif sinon. Passons maintenant à la troisième: nous pourrions vérifier si X.length>x+1, mais cela prend beaucoup d'octets. Une autre façon de procéder consiste à vérifier si l'élément à venir est faux, à savoir undefinedce que vous obtenez lorsque vous essayez d'accéder à un élément inexistant. Cependant, cela correspond également si l'élément suivant est 0, nous ajoutons donc 0.5 pour nous assurer que cela ne se produise pas:

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

Enfin, quatrième point: puisque le tableau extérieur ne contient que des tableaux et que tout tableau est véridique, nous pouvons simplement vérifier Y[y+1]. Maintenant, avec ?0:N, nous le convertissons en 0si tout ce qui précède se révélait être la vérité; Nautrement. Et c'est tout!

— ETHproductions
source
3

La rétine ,31 24 22

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

2 octets sauvés grâce à randomra

Essayez-le en ligne!

Il y a probablement une meilleure façon de le faire, car il s'agit simplement d'un remplacement de base multiligne. Nous trouvons essentiellement chaque numéro précédé d’une nouvelle ligne, d’un certain nombre de caractères et d’un espace, suivi immédiatement par une espace, puis d’une nouvelle ligne. Ces chiffres sont alors tous remplacés par 0.

Cela ne préservera pas le remplissage des colonnes, mais je ne pense pas que ce soit un problème.

— FryAmTheEggman
source
3

Java 8, en tant que fonction lambda: 82 83 95 caractères / octets

Signature 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 Fait une erreur, je pensais qu'un [x, y] était le xième rang et le yt col. Clairement, cela devrait être un [x] [y] cependant!

EDIT J'ai oublié de tester le code et je dois remettre la colonne à zéro à chaque fois dans la boucle, +12 octets. : /

— HyperNeutrino
source
3

Haskell, 59 58 octets

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

Étendu

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
source
Vous devriez être capable de tourner ++[last y]dans :(last y)ou:last y
— HEGX64
@ HEGX64: Non, type incorrect. x : map f (…)est déjà de type [a]et last ya le type a, alors que (:) :: a -> [a] -> [a]. L'ajout d'un élément à la fin d'une liste dans Haskell est un peu dommage, car ces listes sont des listes de renvoi simples.
— Zeta
Opps. Je savais que j'aurais dû l'essayer moi-même avant de poster :)
— HEGX64
1
Vous pouvez transformer ken un opérateur infixe, nous allons dire #et retourner les arguments pour sauver un octet: [x]#_=..., (x:y)#f=..., f=(#(# \_->0))et vous pouvez laisser tomber le nom de votre fonction principale, à savoir f=pour deux octets.
— Nimi
2

Pyth, 18 octets

Qjbm:dSttld0P.Qe.Q

Explication

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

Les tableaux d'entrée sont séparés par des nouvelles lignes

Essayez-le ici

— Bleu
source
2

Groovy, 70 octets

Ce n'est pas très créatif, mais c'est court!

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

Explication

Fermeture avec un argument

g={a->

Itérer sur le tableau interne, en ignorant les premier et dernier éléments

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

Itérer sur les éléments du milieu de la matrice interne

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

Définir les éléments 0et revenira

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

Des 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
source
2

R, 71 64 57 octets

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

edit -7 octets en traitant explicitement avec les matrices <2 lignes ou <2 colonnes explicitement edit2 -7 octets en affectant les dimensions de la matrice tout en vérifiant la taille

— couloir
source
1

C ++, 80 79 octets

Attend le tableau comme int**avec les tailles données net 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;}

Une alternative qui fonctionne pour tout type qui a size()et value_type & operator[](int)(98 octets):

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

Version élargie

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
source
On dirait que l’ajout de dimensions de matrice à l’entrée est une faille standard
— aross
1

PHP, 82 81 80 71 octets

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

Courez comme ça:

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);'
  • Sauvegardé d'un octet en supposant des rangées de taille constante (merci à manatwork)
  • Sauvegardé un octet en en faisant une fonction anonyme
  • Enregistré 7 octets en utilisantuthyness de l'élément de tableau suivant, empêchant les appels à count, nom trop long pour codegolf
— aross
source
Lors du traitement d'une matrice, tous les sous-tableaux doivent avoir la même longueur. Donc, à l'intérieur, il forest sûr de toujours parcourir jusqu'à count($z[0])-1épargner 1 caractère.
— Manatwork
1

APL, 17 octets 15 octets

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

Comment ça marche

  • ⍳⍴⍵ génère un tableau 2D où toutes les cellules contiennent les coordonnées de toutes les cellules de l'argument.
  • 1∊¨cherche dans chacune de ces cellules s'il y a un 1 et retourne un 1 si c'est le cas ou 0 sinon. Cela crée une matrice où la première ligne et la première colonne sont des 1 et tout le reste est 0.
  • (⌽∨⊖) combine avec "ou" deux versions logiques de la matrice, une inversée le long de la première et une inversée le long du dernier axe.
  • ⍵× est la multiplication standard.
— lefefano
source
Vous pouvez remplacer (⊣∨⊖∘⌽) par (⊖∨⌽), deux octets de moins
— Moris Zucca
Brillant! Laisse moi faire ça!
— lstefano
0

Perl, 34 + 2 = 36 octets

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

Nécessite le -pdrapeau:

$ 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

Comment ça marche:

# '-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
source
0

Lua, 69 octets

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

Si seulement j'avais des accolades au lieu de dos et se termine ...

— Jaser
source
0

SmileBASIC, 69 51 octets

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

Remplir une zone 2D dans un tableau nécessiterait généralement d'utiliser FILL dans une boucle. Mais il est beaucoup plus facile de travailler avec des données 2D sur la page graphique. Le tableau y est donc d'abord copié.

Aww je pensais être si intelligent en utilisant des commandes graphiques ... mais il s'avère qu'appeler REMPLIR un tas de fois est en réalité plus court.

Quoi qu'il en soit, les entrées de fonction sont le tableau et la largeur / hauteur (ceci est standard dans Smilebasic car il n’ya aucun moyen de vérifier les dimensions d’un tableau.)

— 12Me21
source
0

APL (Dyalog Classic) , 12 octets

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

Essayez-le en ligne!

⍉⌽⍵ est normalement en rotation (inverser horizontalement et transposer)

nous la combinons ici pour 0⍪1↓⍵remplacer la première ligne par des zéros (déposer une ligne, puis concaténer 0 en haut) en un seul train:⍉0⍪1↓⌽

⍣4 répète 4 fois

⊢- soustrait de la matrice d'origine

— ngn
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.