배열 중공

35

작업

이 도전은 매우 간단합니다. 입력 값은 최소 1 × 1 크기의 정수로 구성된 직사각형 2D 배열입니다. 합리적인 형식으로 가져올 수 있습니다. 출력은 입력 배열이지만 첫 번째 또는 마지막 행 또는 열에 없는 모든 항목 은로 설정됩니다 0. 입력과 동일한 형식이어야합니다.

예를 들어 입력 배열이

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

규칙과 득점

전체 프로그램 또는 함수를 작성할 수 있으며 함수는 입력을 리턴하는 대신 입력을 수정할 수 있습니다. 가장 낮은 바이트 수가 이기고 표준 허점은 허용되지 않습니다.

테스트 사례

복사 붙여 넣기를 쉽게하기 위해 중첩 된 목록으로 형식화됩니다.

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

리더 보드

다음은 일반 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다. 답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

## Language Name, N bytes

여러 개의 숫자를 포함 시키려면 (예 : 점수를 향상 시켰거나 통역사 플래그를 별도로 나열하려는 경우) 실제 점수가 헤더 의 마지막 숫자 인지 확인하십시오 .

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

언어 이름을 링크로 만들어 리더 보드 스 니펫에 표시 될 수도 있습니다.

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

코드 스 니펫 표시

code-golf  array-manipulation 
— 자브
소스

답변:

13

MATL , 9 바이트

0HJ_ht4$(

입력 형식입니다

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

편집 (2016 년 6 월 12 일) : 언어 변경에 적응하기 위해 아래 링크가 _로 바뀌 었습니다q .

온라인으로 사용해보십시오 !

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
— 루이스 멘도
소스
2
좋은! MATL이 실행 중임을 알았습니다. : D
— 비커
12

완전한 이름의 함수로서의 Java 7 ,: 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;}

Java 8에서 이것을 램핑하여 몇 바이트를 제거 할 수는 있지만 실제로는하지 않습니다.

— 지오 비트
소스
Arrays.fill(a[i],1,a[i].length-1,0);? 를 사용하여 공간을 절약 할 수 있습니까? 37이 아닌 36 바이트에 불과합니다. =)
— corsiKa
@corsiKa 좋겠지 만, 가져 오거나 완전히 정규화해야합니다 : /
— Geobits
호기심 때문에 두 루프가 다른 이유는 무엇입니까? 왜 안돼 for(int i=0,j;++i<a.length-1;)for(j=0;++j<a[i].length-1;)a[i][j]=0;? 바이트를 저장하지 않지만 두 루프가 동일하면 더 일관성이 있습니다. :)
— Kevin Cruijssen
12

젤리, 18 17 15 9 바이트

0W&ṖZ
ÇÇ^

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

배경

이 접근 방식은 @ Sp3000의 Jelly 답변 , 특히 길이가 다른 목록 사이에서 벡터화 된 연산을 활용하려는 그의 아이디어를 기반으로 합니다.

우리는 비트 단위 AND의 0 과 입력의 첫 번째 행에있는 모든 정수를 사용하여 시작합니다. 자동 벡터화로 인해 [0] 의 비트 AND와 마지막 행없이 입력 을 가져 와서이를 달성 할 수 있습니다 . 0 은 첫 번째 행과 짝을 이루어 행 0을 만듭니다. 나머지 행은 [0]에 대응되지 않으므로 그대로 유지됩니다.

이제 결과를 전치하고 위 변환을 다시 한 번 적용하고 (마지막 열을 효과적으로 제거하고 첫 번째 열을 0으로 설정) 다시 조옮김합니다.

입력

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

이 결과

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

이제이 결과의 비트 XOR과 원래 행렬을 가져옵니다. 자체적으로 정수를 XOR하면 0이 됩니다. 0 으로 정수를 XOR (또는 전혀 XOR하지 않음)하면 동일한 정수가 생성됩니다. 이것은 매트릭스를 속이 비게합니다.

작동 원리

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.
— 데니스
소스
8

수학, 27 바이트

(a=#;a[[2;;-2,2;;-2]]=0;a)&
— 알레프 알파
소스
2
인상적입니다. 이제 설명해 주시겠습니까? 내부 셀을 0으로 다시 할당하고 -2s는 두 번째로 마지막 열 또는 행을 나타내는 것처럼 보입니다 .
— DavidC
얼마나 간단합니다!
— njpipeorgan
7

R , 33 48 바이트

R은 골프 용이 아닙니다. 그러나 위치 인덱싱을 위해 만들어졌습니다 ... 예제로드;

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

가장자리 행 또는 열이 아닌 위치의 값을 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

2 열 테스트도 확인하십시오.

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

후손 : 이전 시도

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

모든 예제 테스트 :

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
— 조나단 캐롤
소스
1 또는 2 행 또는 열 행렬은 어떻게됩니까?
— mnel
좋은 지적, 첫 번째 시도는 2 열 테스트에 실패하고 가운데 행을 삭제합니다. 업데이트하겠습니다.
— Jonathan Carroll
1
프로그래밍 퍼즐 및 코드 골프에 오신 것을 환영합니다! 모든 제출물은 완전한 프로그램 또는 기능이어야합니다. 이 경우 점수가 매겨진 코드는 변수 a가 존재 한다고 가정하기 때문에 스 니펫 입니다. 규칙을 준수 function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]=0;a}하기 위해 47 바이트 와 같은 행렬을 취하는 함수로 만들 수 있습니다 .
— Alex A.
6

Mathematica 81 76 바이트

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

작동 원리

입력 배열이에 있다고 가정합니다 m. 치수 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

엠

a셀이 첫 번째 ||행 또는 ( ) 마지막 행 또는 첫 번째 또는 마지막 열에 있으면 다음 배열의 각 셀 은 True입니다 . 그렇지 않으면 거짓입니다.

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

참된

함수 Boole를 배열에 적용하면 True는 1로, False는 0으로 변환됩니다.

b = Boole[a]

부울

행렬 곱 m에 의해이 b. m의 각 셀에 b의 해당 셀을 곱합니다.

m b

중공 매트릭스

— DavidC
소스
당신은 사용할 수 있습니다 ||바이트의 몇을 저장 또는에, 나는 당신이 너무 저장할 수있는 몇 가지 다른 바이트를 볼 수 있습니다!
— 시몬스
시몬스, 제안 해 주셔서 감사합니다.
— DavidC
# -Unitize @ ArrayFilter [Det, Array [Norm @ * List, Dimensions @ #], 1] # &
— njpipeorgan
@njpipeorgan, 나는 당신이 그것을 제출하는 것이 좋습니다. (그리고 그것이 어떻게 작동하는지 희망적으로 설명해주세요!)
— DavidC
@DavidC 나는 내 답변
— njpipeorgan
6

GNU 세드, 31

  • 4 바이트를 절약 해 준 @manatwork에게 감사합니다.

이 커밋 (토론) 이전의 버전 4.2.2 이하 .

점수는 -r옵션에 +1을 포함 합니다.

입력 행은 개행으로 구분됩니다. 각 행의 요소는 한 줄로 구분됩니다.

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

설명

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`

온라인으로 사용해보십시오.

— 디지털 외상
소스
1
오, 알다시피, 그것은 예견하지 않고 돌아 다닐 수있는 "멋진"방법이며, 감사합니다!
— andlrc
1
괄호가 너무 많습니다 : 1n;$n;:;s/ -?\w+ / : /;t;y/:/0/.
— manatwork
1
답변을 인용 블록에 적용하는 커밋에 대한 정보를 포함시킬 수 있습니까? 사이트는 실제로 느리고 완전히로드하는 데 1 분이 걸립니다
— Ferrybig
@manatwork 감사합니다-4 바이트를 절약했습니다!
— Digital Trauma
@Ferrybig 이 주제에 대한 개발자 토론에 다른 링크를 추가했습니다 .
— Digital Trauma
5

옥타브, 34 바이트

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

배열 행을 분리하려면 입력에 세미콜론이 필요합니다.

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

설명:

옥타브 (및 MATLAB) 배열 인덱스는 1을 기준으로합니다. 범위를 지정 Array(1:end)하면 (이 예제에서는 1 차원) 배열의 모든 요소가 제공됩니다. 첫 번째와 마지막을 제외한Array(2:end-1) 모든 요소를 ​​제공합니다 .

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

0첫 번째 또는 마지막 행 또는 열에없는 모든 요소로 설정합니다 .

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

차원 중 하나가 2보다 작거나 같은 경우 범위 end-1는 2 보다 작으므로 범위의 끝은 (2:end-1)시작보다 작습니다. 이 경우 옥타브는 범위를 무시하고 아무것도하지 않습니다. 이것은 for루프와 유사합니다 .

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

중지 조건은 첫 번째 반복에서 참이므로 루프에서 벗어납니다.

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

    6    7
    8    9
   10   11

>> h(A)
M =

    6    7
    8    9
   10   11
— 굽 ​​달린 큰 컵
소스
5

젤리 , 12 바이트

ZṖṖ1;¥€
¬ÇÇ×

나는 이것이 젤리 주위에 여전히 내 머리를 감싸면서 이것이 효과가 있다고 생각합니다. 온라인으로 사용해보십시오!

(-2 바이트에 @Dennis에게 감사드립니다)

입력 배열에 1과 0의 배열을 각 방법으로 1 차원 작게 곱하여 작동합니다. 예를 들어 [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]]요소 별을 곱하면

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

전체 설명

[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
소스
5

ES6, 52 48 46 바이트

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

편집 : @ user81655 덕분에 4 바이트가 절약되었습니다. @ETHproductions 덕분에 2 바이트를 더 절약했습니다.

— 닐
소스
영리한! 여기에없는 비슷한 접근법이 있습니다g 은 몇 바이트를 절약 할 수 .f=a=>a.map((b,i)=>i&&a[i+1]!=a.x?b.map?f(b):0:b)
— user81655
좋은 작업! 나는 48 바이트를 센다 (아마도 당신 f=f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)
— 은를
1
@ETHproductions 그렇습니다 f=. 또한 나는 약간의 +.5작품에 놀랐지 만 다른 전화에서 문자열 추가를하는 것을 보았습니다.
— Neil
4

자바 스크립트, 62 59 56 바이트

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

이 접근법은 문자열을 인수로 예상합니다. 정규식이 무엇을하는지 볼 수 있습니다 : https://regex101.com/r/kC6xA8/3

— 제거
소스
4

수학, 55 바이트

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

테스트 사례

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

설명

이 답변의 주요 아이디어는 DavidC의 답변 과 같지만 (먼저 마스크 매트릭스를 구성한 다음 원래 매트릭스에 곱함) 마스크 매트릭스의 구성은 다릅니다.

ArrayFilter[f,list,r]반경 내에있는 f모든 요소에 매핑 됩니다 .listr

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

이웃이 불충분 한 경우 경계 요소가 복제됩니다. 언제list 2 차원이며,이 기능은 잘 함께 작동 Det네 경계에 중복 된 열 또는 행이 결정을 사라지고 있기 때문에, 원하는 결과를 제공 할 수 있습니다.

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

어디 Power~Array~{4,4} 내측에 위치 보장 결정 요인은 비 - 제로한다. 과

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

마스크 매트릭스를 제공합니다.

— njpipeorgan
소스
4

파이썬, 50 바이트

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

목록의 목록을 승인하고 수정합니다. 파이썬의 슬라이스 구문은이 작업에 불편하지 않습니다.

목록에 음수를 곱하면 빈 목록이 생겨 위의 코드가 작은 입력에서 작동 할 수 있습니다.

— 매튜 먼
소스
4

줄리아, 50 35 바이트

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

이것은 익명의 함수로, 배열을 받아서 수정합니다. 호출하려면 변수에 지정하십시오.

여기서의 접근 방식은 매우 간단합니다 .n by m 입력 배열 A의 경우 범위를 구성 하여 모든 i = 2, ..., n -1 및 j = 2, ..., m -1에 대해 A ij = 0을 할당 합니다 지수. n 또는 m = 1 과 같이 범위가 비어 있으면 교체가 수행되지 않습니다.

온라인으로 사용해보십시오

Dennis 덕분에 15 바이트를 절약했습니다!

— 알렉스 에이
소스
4

C, 62 바이트

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

배열 길이 / 너비를 매개 변수로 사용하는 것이 좋습니다. 나는 memset / bzero로 약간 놀았 지 만sizeof(int) , 코드 크기를 크게 늘리면됩니다.

편집 : 입력이 각각 한 자릿수이므로 규칙을 더 구부리고 배열을 문자로 저장할 수있는 경우 55 바이트.

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

편집 : 팁에 대한 워싱턴 Guedes 감사합니다!

— 조롱
소스
말 그대로 곱하려고 했습니까 sizeof(int)? 당신은 4대신 사용할 수 있습니다 ...
— anatolyg
sizeof(int) != 4내 컴퓨터에서 : P
— Josh
나는 여전히 당신이 사용할 수있는 한 자리 숫자입니다.
— anatolyg
그 시점에서 문제가 한 자리 숫자 만 사용하기 때문에 정수가 아닌 문자 배열이라고 결정할 수 있습니다. 규칙을 얼마나 멀리 굽히고 싶은지에 달려 있습니다.
— Josh
감사! 이제 aloof -->연산자 를 사용할 수 있습니다;)
— Josh
3

펄 6 , 28 바이트

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

이것은 입력을 그 자리에서 수정합니다

용법

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 -
— 브래드 길버트 b2gills
소스
{.[1..*-2]»[1..*-2]X=0}2 바이트를 절약
— raiph
@raiph이 마지막 두 경우에 작업에 표시되지 않습니다
— 브래드 길버트는 b2gills
3

자바 스크립트 ES6, 69 66 57 바이트

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

작동 원리

이 솔루션 은 입력의 각 y- 인덱스 y및 x- 인덱스를 통해 매핑 x하고이 두 지수를 기반으로이를 버릴지 여부를 결정합니다. 우리가 지켜야 할 4 가지 경우가 있습니다 :

  • x 0입니다
  • y 0입니다
  • x 내부 배열의 길이에서 1을 뺀 값과 같습니다.
  • y 외부 배열의 길이에서 1을 뺀 값과 같습니다.

우리는 약간의 곱셈과 처음 두 돌볼 수 : x*y리턴 0하나 있으면를 x또는 y0이고, 양의 정수 그렇지. 이제 세 번째 : if 경우 확인할 수 X.length>x+1있지만 많은 바이트가 필요합니다. 이를 수행하는 또 다른 방법은 앞에있는 항목이 잘못된 지 확인하는 것입니다. 즉 undefined, 존재하지 않는 항목에 액세스하려고 할 때 얻는 것입니다. 그러나 다음 항목이 0인 경우에도 일치 하므로 0.5가 추가되어 해당 항목이 발생하지 않도록합니다.

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

마지막으로, 네 번째 요점 : 외부 배열에는 내부 배열 만 있고 모든 배열이 사실이므로 확인 만하면 Y[y+1]됩니다. 이제 위의 모든 내용이 진실로 밝혀지면 ?0:N로 변환합니다 0. N그렇지 않으면. 그리고 그게 다야!

— ETH 프로덕션
소스
3

망막 ,31 24 22

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

randomra 덕분에 2 바이트 절약

온라인으로 사용해보십시오!

이것은 꽤 기본적인 멀티 라인 교체이기 때문에 더 좋은 방법이있을 것입니다. 본질적으로 우리는 개행, 문자 및 공백이 앞에 오는 각 숫자를 찾고, 공백 뒤에 바로 다음에 개행 문자가옵니다. 그런 다음이 숫자는 모두로 바뀝니다 0.

이것은 열 패딩을 유지하지는 않지만 그것이 문제라고 생각하지 않습니다.

— FryAmTheEggman
소스
3

람다 함수 인 Java 8 : 82 83 95 문자 / 바이트

람다 서명 : int[][] -> (void)(즉 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}}

편집 실수를했는데, 나는 a [x, y]가 x 번째 행과 y 번째 열이라고 생각했습니다. 분명히 그것은 [x] [y]이어야합니다!

편집 코드를 테스트하는 것을 잊어 버렸고 루프 내에서 +12 바이트마다 열을 0으로 다시 설정해야합니다. : /

— 하이퍼 뉴트리노
소스
3

하스켈, 59 58 바이트

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

넓히는

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
     )
— 제타
소스
당신은 회전 할 수 있어야 ++[last y]로 :(last y)또는:last y
— HEGX64
@ HEGX64 : 아니요, 잘못된 유형입니다. x : map f (…)는 이미 유형 [a]이고 last y유형 a이있는 반면 (:) :: a -> [a] -> [a]. Haskell 종류의 목록에서 목록 끝에 요소를 추가하는 것은 해당 목록이 단일 연결된 정방향 목록이기 때문입니다.
— Zeta
죄송합니다. 게시하기 전에 직접 시도해야한다는 것을 알았습니다. :)
— HEGX64
1
당신은 돌릴 수 있습니다 k 의 말을하자, 중위 연산자로 #한 바이트를 저장하기 위해 인수를 플립 : [x]#_=..., (x:y)#f=..., f=(#(# \_->0))당신은 당신의 주요 기능, 즉의 이름을 삭제할 수 있습니다 f=또 다른 2 바이트.
— nimi
2

Pyth, 18 바이트

Qjbm:dSttld0P.Qe.Q

설명

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

입력 배열은 개행으로 분리됩니다

여기 사용해보십시오

— 푸른
소스
2

그루비, 70 바이트

이것은 독창적이지는 않지만 짧습니다!

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

설명

하나의 인수로 폐쇄

g={a->

첫 번째 요소와 마지막 요소를 건너 뛰고 내부 배열을 반복합니다.

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

내부 배열에서 중간 항목을 반복

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

요소를 설정 0하고 반환a

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

테스트

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 앳킨
소스
2

R, 71 64 57 바이트

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

<2 행 또는 <2 열 행렬을 명시 적으로 처리하여 -7 바이트 편집 크기를 확인하면서 행렬의 차원을 지정하여 2-7 바이트를 명시 적으로 편집

— mnel
소스
1

C ++, 80 79 바이트

int**주어진 크기 n와 같이 배열을 기대합니다 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;}

size()및 value_type & operator[](int)(98 바이트) 가있는 모든 유형에 적합한 대안 :

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

확장 버전

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;
        }
    }
}
— 제타
소스
상기 입력에 매트릭스 크기를 첨가하면 보일 것이다 표준 허점
— aross
1

PHP, 82 81 80 71 바이트

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

다음과 같이 실행하십시오.

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);'
  • 일정한 크기의 행을 가정하여 바이트를 절약했습니다 (x ~ manatwork)
  • 익명 함수로 바이트를 저장했습니다.
  • 다음 배열 항목의 진실성을 사용하여 7 바이트를 절약하여 코드 호출에 count너무 긴 이름 인에 대한 호출을 방지합니다.
— 심한
소스
행렬을 처리 할 때 모든 하위 배열의 길이는 같아야합니다. 따라서 내부 for는 항상 count($z[0])-11 자 까지 늘릴 수 있습니다.
— manatwork
1

APL, 17 바이트 15 바이트

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

작동 원리

  • ⍳⍴⍵ 모든 셀에 인수의 모든 셀의 좌표가 포함 된 2D 배열을 생성합니다.
  • 1∊¨1이있는 경우 각 셀을 검색하고 있으면 1을 반환하고 그렇지 않으면 0을 반환합니다. 첫 번째 행과 첫 번째 열이 1이고 나머지는 모두 0 인 행렬을 만듭니다.
  • (⌽∨⊖) 논리 "또는"두 버전의 매트릭스와 결합합니다. 하나는 첫 번째 축을 따라 반전되고 다른 하나는 마지막 축을 따라 반전됩니다.
  • ⍵× 표준 곱셈입니다.
— lstefano
소스
(bytes∘⌽)를 2 바이트 적은 (⊖∨⌽)로 대체 할 수 있습니다.
— Moris Zucca
훌륭한! 그렇게하겠습니다!
— lstefano
0

펄, 34 + 2 = 36 바이트

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

-p플래그가 필요합니다 :

$ 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

작동 방식 :

# '-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
소스
0

루아, 69 바이트

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

내가하고 끝내는 대신 중괄호 만 가지고 있다면 ...

— 수다
소스
0

SmileBASIC, 69 51 바이트

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

배열에서 2D 영역을 채우려면 일반적으로 루프에서 FILL을 사용해야합니다. 그러나 그래픽 페이지에서 2D 데이터로 작업하는 것이 훨씬 쉬우므로 먼저 배열을 복사합니다.

Aww 그래픽 명령을 사용하는 것이 현명하다고 생각했지만 FILL을 여러 번 호출하면 실제로 짧습니다.

어쨌든, 함수 입력은 배열과 너비 / 높이입니다 (이것은 배열의 크기를 확인할 방법이 없기 때문에 Smilebasic의 표준입니다.)

— 12Me21
소스
0

APL (Dyalog Classic) , 12 바이트

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

온라인으로 사용해보십시오!

⍉⌽⍵ 일반적으로 회전 (수평으로 뒤집고 조옮김)

여기서 우리는 0⍪1↓⍵첫 번째 행을 0으로 바꾸는 것과 결합합니다 (하나의 행을 버린 다음 0을 상단에 연결).⍉0⍪1↓⌽

⍣4 4 번 반복

⊢- 원래 행렬에서 빼기

— ngn
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.