Выдолбить массив

35

Задание

Эта задача очень проста. Ваш ввод представляет собой прямоугольный двумерный массив целых чисел размером не менее 1 × 1. Это может быть принято в любом разумном формате. Ваш вывод должен быть входным массивом, но со всеми записями не в первой или последней строке или столбце установлено значение 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]]

Leaderboard

Вот фрагмент стека, который генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам. Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

## 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 
— Zgarb
источник

Ответы:

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]

РЕДАКТИРОВАТЬ (12 июня 2016 г.): чтобы адаптироваться к изменениям языка, ссылка ниже _заменена на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, чтобы удалить несколько байтов, но на самом деле я этого не делаю.

— Geobits
источник
Не могли бы вы сэкономить место с помощью Arrays.fill(a[i],1,a[i].length-1,0);? Это всего 36 байтов вместо 37. =)
— corsiKa
@corsiKa Было бы неплохо, но мне пришлось бы импортировать или полностью квалифицировать его: /
— Geobits
Просто из любопытства, почему у вас разные петли? Почему нет for(int i=0,j;++i<a.length-1;)for(j=0;++j<a[i].length-1;)a[i][j]=0;? Он не сохраняет байты, но более согласуется с тем, что оба цикла одинаковы. :)
— Кевин Круйссен
12

Желе, 18 17 15 9 байт

0W&ṖZ
ÇÇ^

Попробуйте онлайн! или проверьте все контрольные примеры .

Задний план

Этот подход основан на ответе Jelly @ Sp3000 , в частности, на его идее использовать векторизованные операции между списками разной длины.

Мы начинаем с получения побитового И 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 . XOR целое число с 0 (или не XORing его вообще) дает то же самое целое число. Это опустошает матрицу.

Как это работает

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

Mathematica, 27 байт

(a=#;a[[2;;-2,2;;-2]]=0;a)&
— alephalpha
источник
2
Впечатляет. Теперь, не могли бы вы объяснить это? Похоже, что вы переназначаете внутренние ячейки на ноль, а -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

Также проверяется тест с двумя столбцами:

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
Хорошая мысль: первая попытка не проходит тест с двумя столбцами и удаляет средний ряд. Я обновлю.
— Джонатан Кэрролл
1
Добро пожаловать в Программирование Пазлов и Code Golf! Мы требуем, чтобы все представления были либо полными программами, либо функциями. В этом случае ваш набранный код является просто фрагментом, поскольку он предполагает, что переменная aсуществует. Чтобы соответствовать нашим правилам, вы можете сделать это функцией, которая принимает матрицу, например, function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]=0;a}для 47 байтов.
— Алекс А.
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 Sed, 31

  • Спасибо @manatwork за сохранение 4 байта.

Версия 4.2.2 или более ранняя, до этого коммита (обсуждение) .

Оценка включает +1 для -rварианта.

Входные строки разделены новой строкой. Элементы в каждой строке разделены одной строкой.

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 байта!
— Цифровая травма
@Ferrybig Добавил еще одну ссылку на обсуждение разработчиков по этой теме .
— Цифровая травма
5

Октава, 34 байта

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

Обратите внимание, что для ввода требуется точка с запятой для разделения строк массива:

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

Объяснение:

Индексы массива Octave (и MATLAB) основаны на 1. Задание диапазона Array(1:end)даст вам все элементы массива (в данном примере одномерного). 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)меньше , чем в начале. В этом случае Octave игнорирует диапазон и ничего не делает. Это аналогично 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;¥€
¬ÇÇ×

Я думаю, что это работает, все еще обнимая мою голову Желе. Попробуйте онлайн!

(Спасибо @Dennis за -2 байта)

Работает путем умножения входного массива на массивы, равные 1 с и 0, которые на одно измерение меньше. Например, для [[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)

Редактировать: 4 байта сохранены благодаря @ user81655. Сохранено еще 2 байта благодаря @ETHproductions.

— Нил
источник
Умная! Вот очень похожий подход, без gкоторого экономится несколько байтов:f=a=>a.map((b,i)=>i&&a[i+1]!=a.x?b.map?f(b):0:b)
— user81655
Хорошая работа! Я считаю 48 байтов (возможно, вы забыли их подсчитать f=), но вы можете уменьшить их до 46:f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)
— ETHproductions
1
@ETHproductions Да, я забыл сосчитать f=. Также я немного удивлен +.5работой, но я вижу, что она добавляет строку в другом вызове.
— Нил
4

Javascript, 62 59 56 байт

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

Этот подход предполагает строку в качестве аргумента. Вы можете увидеть, что делает регулярное выражение здесь: https://regex101.com/r/kC6xA8/3

— удален
источник
4

Mathematica, 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на каждый элемент listв радиусе 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}] } *)

Обратите внимание, что граничные элементы дублируются там, где недостаточно соседей. При listдвухмерном измерении эта функция хорошо работает вместе с тем, 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

Python, 50 байт

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

Принимает список списков и изменяет его на месте. Синтаксис среза Python не является неудобным для этой задачи.

Я узнал, что умножение списка на отрицательное число приводит к пустому списку, который позволяет приведенному выше коду работать с небольшими входами.

— mathmandan
источник
4

Юлия, 50 35 байт

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

Это анонимная функция, которая принимает массив и модифицирует его на месте. Чтобы вызвать его, присвойте его переменной.

Подход здесь довольно прост: для входного массива A размером n на m мы назначаем A ij = 0 для всех i = 2, ..., n -1 и j = 2, ..., m -1 путем построения диапазонов индексов. Диапазоны могут быть пустыми, например, если n или m = 1, в этом случае замена не производится.

Попробуйте онлайн

Благодаря Денису сэкономлено 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вместо этого ...
— Анатолий
sizeof(int) != 4на моей машине: P
— Джош
Бьюсь об заклад, это все еще однозначное число, которое вы можете использовать.
— Анатолий
В тот момент я имел в виду, что мог бы просто решить, что это массив символов, а не целых, поскольку в задаче используются только однозначные числа. Все зависит от того, насколько далеко мы хотим нарушить правила.
— Джош
Благодарность! Теперь я также могу использовать -->оператор aloof ;)
— Джош
3

Perl 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

JavaScript 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на входе и решает, выбрасывать его или нет на основе этих двух индексов. Есть четыре случая, которые нам нужно сохранить:

  • x это 0
  • y это 0
  • x равна длине внутреннего массива, минус 1
  • y равна длине внешнего массива, минус 1

Мы можем позаботиться о первых двух с небольшим умножением: x*yвозвращает, 0если либо xлибо y0, либо в противном случае положительное целое число. Теперь для третьего: мы могли бы проверить, если 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иначе. Вот и все!

— ETHproductions
источник
3

Сетчатка ,31 24 22

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

Сохранено 2 байта благодаря randomra

Попробуйте онлайн!

Вероятно, есть лучший способ сделать это, поскольку это просто довольно простая многострочная замена. По сути, мы находим каждое число, которому предшествует символ новой строки, некоторое количество символов и пробел, за которым сразу же следует пробел, а затем и, в конце концов, символ новой строки. Эти цифры затем заменяются на 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}}

РЕДАКТИРОВАТЬ Сделал ошибку, я думал, что [х, у] был X-й ряд и Y-й столбец. Очевидно, что это должно быть [x] [y], хотя!

РЕДАКТИРОВАТЬ Я забыл проверить код, и мне нужно каждый раз возвращать столбец в ноль +12 байт. : /

— HyperNeutrino
источник
3

Haskell, 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
     )
— Zeta
источник
Вы должны быть в состоянии превратить ++[last y]в :(last y)или:last y
— HEGX64
@ HEGX64: Нет, неправильный тип. x : map f (…)уже имеет тип [a]и last yимеет тип a, тогда как (:) :: a -> [a] -> [a]. Добавление элемента в конец списка в Haskell отстой, так как эти списки являются односвязными форвардными списками.
— Зета
Opps. Я знал, что я должен был попробовать это сам прежде, чем отправлять :)
— HEGX64
1
Вы можете включить kв оператор инфиксной, скажем , #и переворачивать аргументы , чтобы сохранить один байт: [x]#_=..., (x:y)#f=..., f=(#(# \_->0))и вы можете оставить название вашей основной функции, то есть f=еще два байта.
— Ним,
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

Groovy, 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]]
— Дж Аткин
источник
2

R, 71 64 57 байт

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

редактировать -7 байтов, явно работая с <2- строчными или <2-столбцовыми матрицами, явно редактировать 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;
        }
    }
}
— Zeta
источник
Кажитесь как добавление размеров матрицы на вход является стандартной лазейкой
— 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);'
  • Сохраненный байт, предполагая, что строки постоянного размера (thx to manatwork)
  • Сохраненный байт, сделав его анонимной функцией
  • Сохранено 7 байт, используя достоверность следующего элемента массива, предотвращая вызовы count, что является слишком длинным именем для codegolf
— aross
источник
При обработке матрицы все подмассивы должны быть одинаковой длины. Так что во внутреннем forбезопасно всегда повторять до count($z[0])-11 символа.
— manatwork
1

APL, 17 байт 15 байт

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

Как это работает

  • ⍳⍴⍵ генерирует двумерный массив, в котором все ячейки содержат координаты всех ячеек аргумента.
  • 1∊¨ищет в каждой такой ячейке, если есть 1, и возвращает 1, если так, или 0 в противном случае. Это создает матрицу, в которой первая строка и первый столбец равны 1, а все остальные равны 0.
  • (⌽∨⊖) объединяется с логическим «или» двумя вариантами матрицы, одна перевернутая вдоль первой и одна перевернутая вдоль последней оси.
  • ⍵× это стандартное умножение.
— lstefano
источник
Вы можете заменить (⊣∨⊖∘⌽) на (⊖∨⌽), на два байта меньше
— Морис Цукка
Brilliant! Позволь мне сделать это!
— Стефано
0

Perl, 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-данными на графической странице, поэтому сначала копируется массив.

Ой, я думал, что был настолько умен, используя графические команды ... но оказывается, что вызов FILL несколько раз на самом деле короче.

В любом случае, входные данные функции - это массив и ширина / высота (это стандартно в Smilebasic, потому что нет способа проверить размеры массива.)

— 12Me21
источник
0

APL (Dyalog Classic) , 12 байт

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

Попробуйте онлайн!

⍉⌽⍵ обычно вращение (повернуть горизонтально и транспонировать)

здесь мы объединяем его с 0⍪1↓⍵заменой первой строки нулями (отбрасываем одну строку, затем соединяем 0 сверху) в одну последовательность:⍉0⍪1↓⌽

⍣4 повторяется 4 раза

⊢- вычитает из исходной матрицы

— СПП
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.