Найдите все (анти) диагонали с дублированными значениями


17

Вызов:

Исходя из матрицы входных данных, определите количество диагоналей и антидиагоналей с дублированными числами.
Так что, если у нас есть такая матрица:

[[aa,ab,ac,ad,ae,af],
 [ba,bb,bc,bd,be,bf],
 [ca,cb,cc,cd,ce,cf],
 [da,db,dc,dd,de,df]]

Все диагонали и антидиагоналы будут:

[[aa],[ab,ba],[ac,bb,ca],[ad,bc,cb,da],[ae,bd,cc,db],[af,be,cd,dc],[bf,ce,dd],[cf,de],[df],
 [af],[ae,bf],[ad,be,cf],[ac,bd,ce,df],[ab,bc,cd,de],[aa,bb,cc,dd],[ba,cb,dc],[ca,db],[da]]

Пример:

[[1,2,1,2,1,2],
 [1,2,3,4,5,6],
 [6,5,4,3,2,1],
 [2,1,2,1,2,1]]

Все диагонали и антидиагоналы будут:

[[1],[2,1],[1,2,6],[2,3,5,2],[1,4,4,1],[2,5,3,2],[6,2,1],[1,2],[1],
 [2],[1,6],[2,5,1],[1,4,2,1],[2,3,3,2],[1,2,4,1],[1,5,2],[6,1],[2]]

Удаление всех диагоналей и антидиагоналей, содержащих только уникальные номера:

[[2,3,5,2],[1,4,4,1],[2,5,3,2],[1,4,2,1],[2,3,3,2],[1,2,4,1]]

Таким образом, на выходе получается количество диагоналей и антидиагоналей, содержащих повторяющиеся числа:

6

Правила соревнований:

  • Если входная матрица пуста, содержит только 1 число или содержит только уникальные числа по всей матрице, вывод всегда будет 0.
  • Входные данные гарантированно содержат только положительные цифры [1,9](если только они не полностью пусты).
  • Матрица всегда будет прямоугольной (т.е. все строки имеют одинаковую длину).
  • Ввод / вывод является гибким. Входные данные могут быть приняты в виде списка целых чисел, или двумерного массива целых чисел, или объекта Matrix, в виде строки и т. Д. И т. Д. Вам также разрешено использовать одно или оба измерения матрицы в качестве дополнительного ввода если бы это сэкономило байты на выбранном вами языке.

Основные правила:

  • Это , поэтому выигрывает самый короткий ответ в байтах.
    Не позволяйте языкам кода-гольфа отговаривать вас от публикации ответов на языках, не относящихся к кодексу. Попробуйте придумать как можно более короткий ответ для «любого» языка программирования.
  • Стандартные правила применяются к вашему ответу с правилами ввода / вывода по умолчанию , поэтому вам разрешено использовать STDIN / STDOUT, функции / метод с правильными параметрами и типом возврата, полные программы. Ваш звонок.
  • По умолчанию лазейки запрещены.
  • Если возможно, добавьте ссылку с тестом для вашего кода (например, TIO ).
  • Кроме того, добавление объяснения для вашего ответа настоятельно рекомендуется.

Тестовые случаи:

Input:                     Output:

[[1,2,1,2,1,2],            6
 [1,2,3,4,5,6],
 [6,5,4,3,2,1],
 [2,1,2,1,2,1]]

[[]]                       0

[[1,2],                    0
 [3,4]]

[[1,1],                    2
 [1,1]]

[[9,9,9],                  6
 [9,9,9],
 [9,9,9]]

[[7,7,7,7],                8
 [7,7,7,7],
 [7,7,7,7]]

[[1,1,1],                  1
 [2,3,4],
 [2,5,1]]

[[1,8,4,2,9,4,4,4],        12
 [5,1,2,7,7,4,2,3],
 [1,4,5,2,4,2,3,8],
 [8,5,4,2,3,4,1,5]]

[[1,2,3,4],                4
 [5,6,6,7],
 [8,6,6,9],
 [8,7,6,5]]

Ответы:



10

R , 92 86 82 78 байт

function(m,x=row(m),y=col(m),`|`=split,`^`=Map)sum(max^table^c(m|x-y,m|x+y)>1)

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

объяснение

ИксY

Икс-Y

0 -1 -2 -3 1 0 -1 -2 2 1 0 -1 3 2 1 0

Икс+Y

2 3 4 5 3 4 5 6 4 5 6 7 5 6 7 8

Теперь split(m, x-y)и split(m, x+y)составьте актуальные списки диагоналей и антидиагоналей, которые мы объединяем.

Наконец, мы подсчитываем записи в результирующем списке, где присутствуют дубликаты.

Спасибо за сохраненные байты:

-4 от преступно-
вульгарно -4 от digEmAll


1
Думаю, я могу добавить rowи colв мой список «чрезвычайно ситуативных функций». Действительно умное решение.
Преступно-

1
Я думаю, что вы можете перейти c(m|x-y,m|x+y)прямо в Саппи, удалить l=часть. Я не вижу никаких неудачных тестов. Попробуйте онлайн!
Преступно-

Да, это правильно, я просто пропустил, что после моего первого гольфа остался только один lэкземпляр.
Кирилл Л.

1
Они должны быть добавлены rowи columnфункция R этим утром, потому что я никогда не слышал о них.
19

5

J , 21 20 байт

-1 байт благодаря Ионе!

1#.|.,&((~:&#~.)/.)]

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

Объяснение:

1#.                   find the sum of the  
     ,                concatenation of
       (          )   the result of the verb in the parentheses applied to
                   ]  the input
      &               and
   |.                 the reversed input
        (      )/.    for each diagonal
         ~:&#~.       check if all elements are unique and negate the result 

1
это отчасти сумасшествие, что вы не можете добиться большего успеха, чем (-.@-:~.)«уникальные предметы не совпадают» в J, но я сталкивался с этим также много раз, и я не думаю, что вы можете ... у нас есть, =и ~:, с одной стороны рука, и -:и <this is missing>.
Иона

Собственно, удалось побрить еще 1 байт 1#.|.,&((~:&#~.)/.)]. Попробуйте онлайн!
Иона

@Jonah: классное использование &, спасибо!
Гален Иванов

5

Japt , 31 байт

ËcUî
ËéEÃÕc¡XéYnÃÕ mf fÊk_eZâÃl

Попробуйте все тестовые случаи

Объяснение:

Ëc                            #Pad each row...
  Uî                          #With a number of 0s equal to the number of rows

ËéEÃÕ                         #Get the anti-diagonals:
ËéEÃ                          # Rotate each row right a number of times equal to the row's index
    Õ                         # Get the resulting columns
     c                        #Add to that...
      ¡XéYnÃÕ                 #The diagonals:
      ¡XéYnà                  # Rotate each row left a number of times equal to the row's index
            Õ                 # Get the resulting columns
              mf              #Remove the 0s from each diagonal
                 fÊ           #Remove the all-0 diagonals
                   k_   Ã     #Remove the ones where:
                     eZâ      # The list contains no duplicates
                         l    #Return the number of remaining diagonals

Я также попробовал версию, основанную на ответе Кирилла Л. на Haskell, но не смог найти хороший способ «сгруппировать по функциям индексов X и Y», и найденная мною альтернатива была недостаточно хороша.



4

JavaScript (ES6),  107 105 101  98 байт

f=(m,d=s=1)=>(m+0)[s-=~d/2]?m.some(o=(r,y)=>!r.every((v,x)=>x+d*y+m.length-s?1:o[v]^=1))+f(m,-d):0

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

Заметка

При использовании этого кода антидиагональность, состоящая из единственной левой нижней ячейки, никогда не проверялась. Это нормально, потому что он не может содержать повторяющиеся значения.

комментарии

f = (                    // f = recursive function taking:
  m,                     //   m[] = input matrix
  d =                    //   d   = direction (1 for anti-diagonal or -1 for diagonal)
  s = 1                  //   s   = expected diagonal ID, which is defined as either the sum
) =>                     //         or the difference of x and y + the length of a row
  (m + 0)[               //
    s -= ~d / 2          // increment s if d = -1 or leave it unchanged otherwise
  ] ?                    // if s is less than twice the total number of cells:
    m.some(o =           //   o = object used to store encountered values in this diagonal
    (r, y) =>            //   for each row r[] at position y in m[]:
      !r.every((v, x) => //     for each cell of value v at position x in r[]:
        x + d * y +      //       x + d * y + m.length is the ID of the diagonal
        m.length - s ?   //       if it's not equal to the one we're looking for:
          1              //         yield 1
        :                //       else:
          o[v] ^= 1      //         toggle o[v]; if it's equal to 0, v is a duplicate and
                         //         every() fails which -- in turn -- makes some() succeed
      )                  //     end of every()
    )                    //   end of some()
    + f(m, -d)           //   add the result of a recursive call in the opposite direction
  :                      // else:
    0                    //   stop recursion

4

05AB1E , 25 байтов

í‚εεygÅ0«NFÁ]€ø`«ʒ0KDÙÊ}g

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

объяснение

í                          # reverse each row in input
 ‚                         # and pair with the input
  ε                        # for each matrix
   ε                       # for each row in the matrix
    ygÅ0«                  # append len(row) zeroes
         NFÁ               # and rotate it index(row) elements to the right
            ]              # end loops
             €ø            # transpose each matrix
               `«          # append them together
                 ʒ     }   # filter, keep only rows that
                  0K       # when zeroes are removed
                    DÙÊ    # are not equal to themselves without duplicate values                           
                        g  # push length of the result

Я чувствую, что что-то здесь упустил.
Нужно попробовать это в гольф позже.


1
Не помогает вообще, но rotate N leftбудет N._сейчас. Так í‚εεygÅ0«N._]же и работает. Можно также удалить сглаживание с помощью этого нового изменения ... все еще нет экономии байтов, хотя:í‚vyεygÅ0«N._}ø}«ʒ0KDÙÊ}g
Волшебная урна с осьминогом

1
@MagicOctopusUrn: Интересно. Я пропустил эту команду. Только слева, хотя. Это странно.
Эминья

1
@Emigna Вы можете пойти правильно, N(._я думаю, но у вас NFÁ}такая же длина, и даже короче в этом случае из-за ]закрытия цикла и карт одновременно. В целом, использование ._полезно только при переходе влево для сохранения 1 байта по сравнению с NFÀ}.
Кевин Круйссен

@KevinCruijssen: Ах, круто. Хотя, как вы говорите, не очень полезно.
Эминья


3

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

@(A)nnz([(q=@(Q)arrayfun(@(n)nnz(z=diag(Q,n))-nnz(unique(z)),-([m,n]=size(Q)):n))(A),q(rot90(A))])

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


1
Действительно ли массивы - это весело? ; p
Кевин Круйссен

И спасибо за подготовку тестов в формате Octave!
Луис Мендо

2
@KevinCruijssen Не только массивы! Можно и cellfunтоже, и для мазохиста structfun. В Octave это либо цикл, либо наличие fun!
Sanchises

И не забывайте, б-ш-веселье!
Луис Мендо

3

Haskell, 118 112 байтов

import Data.List
r#(a:b)=sum[1|(/=)=<<nub$[h|h:_<-a:r]]+[t|_:t<-a:r]#b
[]#_=0
a#_=a#[[]]
h x=[]#x+[]#(reverse x)

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

r#(a:b)                      -- function '#' calculates the ant-diagonals of a matrix
                             -- where 'a' is the first row and 'b' all the others
                             -- as we recursively walk down the rows of the matrix,
                             -- 'r' holds the rows from before with the respective
                             -- head dropped
                             --
          [h|h:_<-a:r]       -- if the heads of the the current row and the rows
                             -- before
       (/=)=<<nub$           -- contain duplicates
    [1|                ]     -- make a singleton list [1] (else the empty list)
 sum                         -- and take the sum thereof
      +                      -- and add
             #               -- a recursive call with
 [t|_:t<-a:r]                -- the tails of the current row and the rows before
              b              -- and the rows below
                             --
[]#_=0                       -- base case if there aren't any tails anymore, return 0
a#_=a#[[]]                   -- if there are tails, but no further rows below,
                             -- continue with tails

h x=[]#x+[]#(reverse x)      -- main function, call '#' with input matrix 'x'
                             -- and the reverse of it to get the number of diagonals
                             -- and anti-diagonals. Recursion starts with no
                             -- rows before the 1st row.

-- example trace of function '#'
-- input matrix:
--   [[1,2,3,4],
--    [5,6,7,8],
--    [9,9,9,9]]
--
--  | r         a          b              a:r          heads   tails (r of next call)
-- -+----------------------------------------------------------------------------------
-- 1| []        [1,2,3,4]  [[5,6,7,8],    [[1,2,3,4]]  [1]     [[2,3,4]]
--  |                       [9,9,9,9]]
--  | 
-- 2| [[2,3,4]]  [5,6,7,8]  [[9,9,9,9]]   [[5,6,7,8],  [5,2]   [[6,7,8],
--  |                                      [2,3,4  ]]           [3,4  ]]
--  |
-- 3| [[6,7,8],  [9,9,9,9]  []            [[9,9,9,9],  [9,6,3] [[9,9,9],
--  |  [3,4  ]]                            [6,7,8  ],           [7,8  ]
--  |                                      [3,4    ],           [4    ]
--  |
--  | ....

2

Древесный уголь , 61 56 53 байта

F²FLθFL§θ⁰F⟦⁻κ×⊖⊗ιλ⟧⊞υ⊞O⎇∧λ﹪⁺μιLθ⊟υ⟦⟧§§θμλILΦυ⊙ι‹⌕ιλμ

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

F²

Зациклите переднюю и обратную диагонали; i=0представляет прямые диагонали, в то время как i=1представляет обратные диагонали.

FLθ

Цикл по каждой строке индекса. Это представляет индекс начала диагонали.

FL§θ⁰«

Цикл по каждому индексу столбца.

F⟦⁻κ×⊖⊗ιλ⟧

Рассчитайте индекс строки диагонали по этому индексу столбца. Я использую forцикл над одноэлементным массивом вместо присваивания, так как это избавляет от необходимости заключать присваивание в блок с помощью следующего оператора, тем самым сохраняя байт.

⎇∧λ﹪⁺μιLθ

Проверьте, является ли это первый столбец или диагональ собирается обернуть между нижней и верхней.

⊟υ

Если это не так, вытолкните последний список из списка списков.

⟦⟧

если это так, то начните новый пустой список.

⊞O...§§θμλ

Добавьте текущую диагональную запись в этот список.

⊞υ

И нажмите этот список (обратно) к списку списков.

ILΦυ⊙ι‹⌕ιλμ

Подсчитайте количество списков, которые содержат дубликаты.

Давайте рассмотрим пример, когда i=0и k=1. Это означает, что мы уже собрали две диагонали [[1,1,5,2],[9,4,3,5]]. Вот наш вклад:

 1 8 4 2 9 4 4 4
[5]1 2 7 7 4 2 3
 1 4 5 2 4 2 3 8
 8 5 4 2 3 4 1 5

Затем мы переходим lот 0к 7. Это увеличивает строку и столбец на 1 каждый раз:

 1 8 4 2 9 4 4 4
[5]1 2 7 7 4 2 3
 1[4]5 2 4 2 3 8
 8 5[4]2 3 4 1 5

Список сейчас [[1,1,5,2],[9,4,3,5],[5,4,4]]. Однако, когда lесть 3, мы k+l=4кратны высоте массива. Это означает , что мы должны начать новый список: [[1,1,5,2],[9,4,3,5],[5,4,4],[]]. Затем мы продолжаем собирать диагональные элементы:

 1 8 4[2]9 4 4 4
[5]1 2 7[7]4 2 3
 1[4]5 2 4[2]3 8
 8 5[4]2 3 4[1]5

Список сейчас [[1,1,5,2],[9,4,3,5],[5,4,4],[2,7,2,1]]. Теперь, когда lесть 7, у нас есть k+l=8еще одно кратное высоты массива. Это означает , что мы должны начать новый список, который заканчивается с последним элементом , который по диагонали: [[1,1,5,2],[9,4,3,5],[5,4,4],[2,7,2,1],[4]].

 1 8 4[2]9 4 4[4]
[5]1 2 7[7]4 2 3
 1[4]5 2 4[2]3 8
 8 5[4]2 3 4[1]5

Собирая диагонали обтекания, начиная с первого элемента каждого ряда, мы в конечном итоге накапливаем все диагонали массива.



1

APL + WIN, 69 байт

Запрашивает 2d матрицу вида 4 6⍴1 2 1 2 1 2 1 2 3 4 5 6 6 5 4 3 2 1 2 1 2 1 2 1

Это дает:

1 2 1 2 1 2
1 2 3 4 5 6
6 5 4 3 2 1
2 1 2 1 2 1

+/~(v⍳¨v)≡¨⍳¨⍴¨v←(v←⊂[1](⌽0,⍳1↓n)⌽(n⍴0),m,((n←0 ¯1+↑⍴m)⍴0),⌽m←⎕)~¨0

Попробуйте онлайн! Предоставлено Dyalog Classic

Объяснение:

(⌽0,⍳1↓n)⌽(n⍴0),m pad m with zeros to isolate diagonals

((n←0 ¯1+↑⍴m)⍴0),⌽m pad rotated m with zeros to isolate anti-diagonals

Урожайность:

1 2 1 2 1 2 0 0 0 2 1 2 1 2 1 0 0 0
0 1 2 3 4 5 6 0 0 0 6 5 4 3 2 1 0 0
0 0 6 5 4 3 2 1 0 0 0 1 2 3 4 5 6 0
0 0 0 2 1 2 1 2 1 0 0 0 1 2 1 2 1 2

v←(v←⊂[1](.....)~¨0 enclose the diagonals as a nested vector with padded zeros removed

+/~(v⍳¨v)≡¨⍳¨⍴¨v identify diagnols with duplicate entries and sum


1

TSQL, 140 128 байт

Нашел путь в гольф 12 персонажей. Это больше не самое длинное решение.

Golfed:

SELECT sum(iif(y+x=j+i,1,0)+iif(y-x=j-i,1,0))FROM
@,(SELECT x i,y j,max(y)over()m,v w
FROM @)d WHERE(x*y=0or m=y)and v=w and x<i

Ungolfed:

DECLARE @ table(v int,x int,y int)
-- v = value
-- x = row 
-- y = column
INSERT @ values
(1,0,0),(2,0,1),(1,0,2),(2,0,3),(1,0,4),(2,0,5),
(1,1,0),(2,1,1),(3,1,2),(4,1,3),(5,1,4),(6,1,5),
(6,2,0),(5,2,1),(4,2,2),(3,2,3),(2,2,4),(1,2,5),
(2,3,0),(1,3,1),(2,3,2),(1,3,3),(2,3,4),(1,3,5)


SELECT sum(iif(y+x=j+i,1,0)+iif(y-x=j-i,1,0))
FROM @,(SELECT x i,y j,max(y)over()m,v w FROM @)d
WHERE
  (x*y=0or m=y)
  and v=w
  and x<i

Попробуйте это

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