Nhiệm vụ

Thử thách này rất đơn giản. Đầu vào của bạn là một mảng số nguyên 2D hình chữ nhật, có kích thước tối thiểu 1 × 1. Nó có thể được thực hiện trong bất kỳ định dạng hợp lý. Đầu ra của bạn sẽ là mảng đầu vào, nhưng với tất cả các mục không nằm trên hàng hoặc cột đầu tiên hoặc cuối cùng được đặt thành 0. Nó phải có cùng định dạng với đầu vào.

Ví dụ: nếu mảng đầu vào là

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

thì đầu ra đúng là

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

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng và các chức năng được phép sửa đổi đầu vào tại chỗ thay vì trả lại nó. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Các trường hợp thử nghiệm

Chúng được định dạng như các danh sách lồng nhau để làm cho việc sao chép dễ dàng hơn.

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

Bảng xếp hạng

Dưới đây là Stack Snippet để tạo cả bảng xếp hạng thông thường và tổng quan về người chiến thắng theo ngôn ngữ. Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

## Language Name, N bytes

Nếu bạn muốn bao gồm nhiều số (ví dụ: vì bạn đã cải thiện điểm số của mình hoặc bạn muốn liệt kê riêng các cờ phiên dịch), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

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

Bạn cũng có thể đặt tên ngôn ngữ thành một liên kết mà sau đó sẽ hiển thị trong đoạn trích bảng xếp hạng:

## [><>](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 byte

0HJ_ht4$(

Đầu vào ở định dạng

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

EDIT (ngày 12 tháng 6 năm 2016): để thích ứng với những thay đổi trong ngôn ngữ, liên kết dưới đây đã được _thay thế bằngq .

Hãy thử trực tuyến !

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, là một hàm được đặt tên đầy đủ: 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;}

Bạn có thể lambda điều này trong Java 8 để loại bỏ một vài byte, nhưng tôi không thực sự làm điều đó.

Thạch, 18 17 15 9 byte

0W&ṖZ
ÇÇ^

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Lý lịch

Cách tiếp cận này dựa trên câu trả lời Jelly của @ Sp3000 , cụ thể là dựa trên ý tưởng của anh ấy để tận dụng các hoạt động được vector hóa giữa các danh sách có độ dài khác nhau.

Chúng tôi bắt đầu bằng cách lấy bit AND của 0 và mọi số nguyên trong hàng đầu tiên của đầu vào. Do vector hóa tự động, điều này có thể đạt được bằng cách lấy bit AND của [0] và đầu vào không có hàng cuối cùng. 0 được ghép với hàng đầu tiên, dẫn đến một hàng số không. Vì các hàng còn lại không có đối tác trong [0] , nên chúng không bị ảnh hưởng.

Bây giờ chúng ta hoán chuyển kết quả, áp dụng phép biến đổi ở trên một lần nữa (loại bỏ hiệu quả cột cuối cùng và loại bỏ cột đầu tiên) và chuyển đổi lại.

Đối với đầu vào

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

kết quả này trong

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

Bây giờ, chúng ta lấy XOR bitwise của kết quả này và ma trận gốc. XOR một số nguyên với chính nó mang lại 0 . XORing một số nguyên có 0 (hoặc hoàn toàn không XORing nó) mang lại cùng một số nguyên. Điều này làm rỗng ma trận ra.

Làm thế nào nó hoạt động

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.

Toán học, 27 byte

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

R , 33 48 byte

Tôi biết, R không được làm cho chơi gôn. Nhưng nó được tạo ra để lập chỉ mục theo vị trí ... Đang tải lên một ví dụ;

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

Thay thế giá trị tại bất kỳ vị trí nào không nằm trên hàng hoặc cột cạnh, bằng 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

Đồng thời kiểm tra bài kiểm tra 2 cột:

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

Hậu thế: lần thử trước

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

Kiểm tra tất cả các ví dụ:

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

Toán học 81 76 byte

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

Làm thế nào nó hoạt động

Giả sử rằng mảng đầu vào được lưu trữ trong m. Kích thước của m{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ỗi ô trong mảng sau a, là True nếu ô nằm ở đầu tiên hoặc ( ||) ở hàng cuối hoặc trong cột đầu tiên hoặc cuối cùng; nếu không thì là Sai.

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

Áp dụng hàm Boolecho mảng chuyển đổi True thành 1 và Sai thành 0.

b = Boole[a]

Nhân ma trận mvới b. Điều này nhân mỗi ô trong m với ô tương ứng trong b.

m b

GNU Sed, 31

• Cảm ơn @manatwork đã lưu 4 byte.

Phiên bản 4.2.2 trở về trước, trước khi cam kết này (thảo luận) .

Điểm bao gồm +1 cho -rtùy chọn.

Các hàng đầu vào được phân tách dòng mới. Các phần tử trên mỗi hàng được phân tách một dòng.

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

Giải trình

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`

Hãy thử trực tuyến.

Octave, 34 byte

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

Lưu ý rằng đầu vào yêu cầu dấu chấm phẩy để phân tách các hàng mảng:

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

Giải trình:

Các chỉ số mảng Octave (và MATLAB) là 1 dựa trên. Chỉ định một phạm vi Array(1:end)sẽ cung cấp cho bạn tất cả các yếu tố của mảng (một chiều, trong ví dụ này). Array(2:end-1)sẽ cung cấp cho bạn tất cả các yếu tố ngoại trừ đầu tiên và cuối cùng.

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

đặt cho 0tất cả các thành phần không nằm trong hàng hoặc cột đầu tiên hoặc cuối cùng:

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

Nếu một trong các kích thước nhỏ hơn hoặc bằng 2, phạm vi end-1là ít hơn 2, do đó cuối của dãy núi này (2:end-1)là ít hơn đầu. Trong trường hợp này, Octave bỏ qua phạm vi và không làm gì cả. Điều này tương tự như forvòng lặp:

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

Điều kiện dừng là đúng trong lần lặp đầu tiên, vì vậy chúng ta rơi ra khỏi vòng lặp.

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

    6    7
    8    9
   10   11

>> h(A)
M =

    6    7
    8    9
   10   11

Thạch , 12 byte

ZṖṖ1;¥€
¬ÇÇ×

Tôi nghĩ rằng điều này hoạt động, vẫn quấn đầu tôi xung quanh Jelly. Hãy thử trực tuyến!

(Cảm ơn @Dennis cho -2 byte)

Hoạt động bằng cách nhân mảng đầu vào với một mảng 1s và 0 một chiều nhỏ hơn mỗi chiều. Ví dụ: đối với [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]]chúng tôi nhân phần tử khôn ngoan với

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

Giải thích đầy đủ

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

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

Chỉnh sửa: Đã lưu 4 byte nhờ @ user81655. Đã lưu thêm 2 byte nhờ @ETHproductions.

Javascript, 62 59 56 byte

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

Cách tiếp cận này mong đợi một chuỗi như là đối số. Bạn có thể xem regex làm gì ở đây: https://regex101.com/r/kC6xA8/3

Toán học, 55 byte

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

Trường hợp thử nghiệm

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

Giải trình

Ý tưởng chính của câu trả lời này giống như câu trả lời của DavidC (đầu tiên xây dựng ma trận mặt nạ, sau đó nhân nó với ma trận gốc), nhưng việc xây dựng ma trận mặt nạ thì khác.

ArrayFilter[f,list,r]ánh xạ fvào mọi phần tử listtrong bán kính 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}] } *)

Lưu ý rằng các yếu tố ranh giới được nhân đôi khi không có hàng xóm. Khi listcó 2 chiều, tính năng này hoạt động tốt cùng với Detđể mang lại kết quả mong muốn, vì các cột hoặc hàng trùng lặp trên bốn ranh giới sẽ biến mất các yếu tố quyết định.

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

trong đó Power~Array~{4,4}đảm bảo các yếu tố quyết định ở các vị trí bên trong là khác không. Và

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

đưa ra ma trận mặt nạ.

Python, 50 byte

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

Chấp nhận một danh sách các danh sách và sửa đổi nó tại chỗ. Cú pháp lát của Python không bất tiện cho tác vụ này.

Tôi đã học được rằng nhân một danh sách với một số âm sẽ dẫn đến một danh sách trống, cho phép mã trên hoạt động trên các đầu vào nhỏ.

Julia, 50 35 byte

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

Đây là một hàm ẩn danh chấp nhận một mảng và sửa đổi nó tại chỗ. Để gọi nó, gán nó cho một biến.

Cách tiếp cận ở đây là khá đơn giản: Đối với n bằng m đầu vào mảng A , chúng ta assign Một _ij = 0 cho tất cả i = 2, ..., n -1 và j = 2, ..., m -1 bằng cách xây dựng các dãy của các chỉ số. Phạm vi có thể trống, như nếu n hoặc m = 1, trong trường hợp đó không có sự thay thế nào được thực hiện.

Dùng thử trực tuyến

Đã lưu 15 byte nhờ Dennis!

C, 62 byte

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

Hy vọng sẽ ổn khi lấy chiều dài / chiều rộng của mảng làm tham số. Tôi đã chơi xung quanh với memset / bzero một chút, nhưng nhân lên bằng sizeof(int)cách tăng mạnh kích thước mã.

EDIT: 55 byte nếu chúng ta có thể bẻ cong thêm các quy tắc và lưu trữ mảng của chúng ta dưới dạng các ký tự vì đầu vào chỉ có một chữ số duy nhất.

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

EDIT: Cảm ơn Washington Guedes cho tiền boa!

Perl 6 , 28 byte

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

Điều này sửa đổi đầu vào tại chỗ

Sử dụng

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 byte

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

Làm thế nào nó hoạt động

Giải pháp này ánh xạ qua từng chỉ số y và chỉ số yx xtrong đầu vào và quyết định có loại bỏ nó hay không dựa trên hai chỉ số này. Có bốn trường hợp chúng ta cần giữ:

• x là 0
• y là 0
• x bằng chiều dài của mảng bên trong, trừ đi 1
• y bằng chiều dài của mảng ngoài, trừ 1

Chúng tôi có thể chăm sóc hai người đầu tiên với một nhân nhỏ: x*ylợi nhuận 0IFF một trong hai xhoặc ylà 0, và một số nguyên dương khác. Bây giờ là thứ ba: chúng ta có thể kiểm tra xem X.length>x+1, nhưng điều đó cần rất nhiều byte. Một cách khác để làm điều này là kiểm tra xem mục phía trước có sai hay không undefined, đó là những gì bạn nhận được khi cố gắng truy cập vào một mục không tồn tại. Tuy nhiên, điều này cũng phù hợp nếu mục tiếp theo là 0, vì vậy chúng tôi thêm 0,5 để đảm bảo điều đó không xảy ra:

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

Cuối cùng, điểm thứ tư: vì mảng bên ngoài chỉ có các mảng bên trong và bất kỳ mảng nào là trung thực, chúng ta chỉ cần kiểm tra Y[y+1]. Bây giờ với ?0:N, chúng tôi chuyển đổi nó thành 0nếu tất cả những điều trên trở thành sự thật; Nnếu không thì. Và đó là nó!

Võng mạc ,31 24 22

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

Đã lưu 2 byte nhờ Randomra

Hãy thử trực tuyến!

Có lẽ có một cách tốt hơn để làm điều đó, vì đây chỉ là một sự thay thế đa dòng khá cơ bản. Về cơ bản, chúng tôi tìm thấy mỗi số đứng trước một dòng mới, một số ký tự và khoảng trắng và ngay lập tức được theo sau bởi một khoảng trắng và sau đó được theo sau bởi một dòng mới. Những con số này sau đó được thay thế bằng 0.

Điều này sẽ không bảo vệ phần đệm cột, nhưng tôi không nghĩ đó là một vấn đề.

Java 8, dưới dạng hàm lambda: 82 83 95 ký tự / byte

Chữ ký Lambda: int[][] -> (void)(tức là 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 đã phạm sai lầm, tôi nghĩ rằng một [x, y] là hàng thứ x và col thứ y. Rõ ràng nó phải là một [x] [y]!

EDIT Tôi quên kiểm tra mã và tôi cần đặt cột trở về 0 mỗi lần trong vòng lặp, +12 byte. : /

Haskell, 59 58 byte

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

Mở rộng

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
     )

Bình thường, 18 byte

Qjbm:dSttld0P.Qe.Q

Giải trình

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

Mảng đầu vào được phân tách bằng dòng mới

Hãy thử nó ở đây

Groovy, 70 byte

Điều này không phải là rất sáng tạo, nhưng nó ngắn!

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

Giải trình

Đóng cửa với một arg

g={a-> 

Lặp lại mảng bên trong, bỏ qua các phần tử đầu tiên và cuối cùng

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

Lặp lại các mục ở giữa trong mảng bên trong

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

Đặt các yếu tố thành 0và trả vềa

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

Xét nghiệm

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 byte

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

chỉnh sửa -7 byte bằng cách xử lý rõ ràng với ma trận <2 hàng hoặc <2 cột rõ ràng chỉnh sửa2 -7 byte bằng cách gán kích thước của ma trận trong khi kiểm tra kích thước

C ++ 80 79 byte

Yêu cầu mảng như int**với kích thước đã cho nvà 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;}

Một thay thế hoạt động cho bất kỳ loại nào có size()và value_type & operator[](int)(98 byte):

template<class C>void p(C&c){for(int j,i=1;1+i<c.size();++i)for(j=1;j+1<c[i].size();)c[i][j++]=0;}

Phiên bản mở rộng

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 byte

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

Chạy như thế này:

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);'

• Đã lưu một byte bằng cách giả sử các hàng có kích thước không đổi (thx cho manatwork)
• Đã lưu một byte bằng cách biến nó thành một hàm ẩn danh
• Đã lưu 7 byte bằng cách sử dụng tính trung thực của mục mảng tiếp theo, ngăn chặn các cuộc gọi đến count, đó là một tên quá dài cho codegolf

APL, 17 byte 15 byte

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

Làm thế nào nó hoạt động

• ⍳⍴⍵ tạo ra một mảng 2D trong đó tất cả các ô chứa tọa độ của tất cả các ô của đối số.
• 1∊¨tìm kiếm trong mỗi ô như vậy nếu có 1 và trả về 1 nếu có hoặc 0 nếu không. Điều này xây dựng một ma trận trong đó hàng đầu tiên và cột đầu tiên là 1s và tất cả phần còn lại là 0.
• (⌽∨⊖) kết hợp với logic "hoặc" hai phiên bản của ma trận, một phiên bản đảo ngược dọc theo phiên bản đầu tiên và một phiên bản đảo ngược dọc theo trục cuối cùng.
• ⍵× là phép nhân chuẩn.

Perl, 34 + 2 = 36 byte

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

Yêu cầu -pcờ:

$ 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

Làm thế nào nó hoạt động:

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

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

Giá như tôi có niềng răng xoăn thay vì dos và kết thúc ...

SmileBASIC, 69 51 byte

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

Việc lấp đầy một khu vực 2D trong một mảng thường sẽ yêu cầu sử dụng FILL trong một vòng lặp. Nhưng làm việc với dữ liệu 2D trên trang đồ họa dễ dàng hơn nhiều, vì vậy trước tiên, mảng được sao chép ở đó.

À tôi nghĩ rằng tôi rất thông minh khi sử dụng các lệnh đồ họa ... nhưng hóa ra việc gọi FILL một loạt lần thực sự ngắn hơn.

Dù sao, đầu vào hàm là mảng và chiều rộng / chiều cao (Đây là tiêu chuẩn trong Smilebasic vì không có cách nào để kiểm tra kích thước của một mảng.)

APL (Dyalog Classic) , 12 byte

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

Hãy thử trực tuyến!

⍉⌽⍵ là xoay bình thường (đảo ngược theo chiều ngang và chuyển vị)

ở đây chúng tôi kết hợp nó với hàng 0⍪1↓⍵thay thế hàng đầu tiên bằng số 0 (thả một hàng, sau đó ghép 0 trên đầu) vào một chuyến tàu duy nhất:⍉0⍪1↓⌽

⍣4 lặp lại 4 lần

⊢- trừ khỏi ma trận gốc