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

var QUESTION_ID=71591,OVERRIDE_USER=32014;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

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

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.

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.

Mathematica, 27 octets

(a=#;a[[2;;-2,2;;-2]]=0;a)&

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

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

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

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

b = Boole[a]

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

m b

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.

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

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

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.

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

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.

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.

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!

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!

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 - 

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!

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.

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

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
     )

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

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

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

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

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

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.

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

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

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

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