Вечеринка по модулю паритета

15

Вам дан массив A из n строго положительных целых чисел с n ≥ 2 .

Ваша задача - сопоставить каждую запись A i с:

  • 1, если A j mod A i нечетно для каждого j такого, что 1 ≤ j ≤ n и j ≠ i
  • 2, если A j mod A i четно для каждого j такого, что 1 ≤ j ≤ n и j ≠ i
  • 0 иначе (смешанные паритеты)

пример

Для A = [73, 50, 61] имеем:

  • 50 мод 73 = 50 , 61 мод 73 = 61 → смешанный
  • 73 мод 50 = 23 , 61 мод 50 = 11 → все нечетно
  • 73 мод 61 = 12 , 50 мод 61 = 50 → все четные

Следовательно, ожидаемый результат равен [0, 1, 2] .

правила

  • Вы можете использовать любые три различных значения (любого типа) вместо 0 , 1 и 2, если они согласованы. Пожалуйста, укажите ваше сопоставление, если вы не используете тот, который описан в конкурсе.
  • Если есть какие-либо сомнения по этому поводу, ноль является четным .
  • Это код-гольф , поэтому выигрывает самый короткий ответ в байтах!

Контрольные примеры

[ 1, 2 ] --> [ 2, 1 ]
[ 3, 4 ] --> [ 1, 1 ]
[ 1, 2, 3 ] --> [ 2, 1, 0 ]
[ 4, 4, 4 ] --> [ 2, 2, 2 ]
[ 73, 50, 61 ] --> [ 0, 1, 2 ]
[ 941, 459, 533 ] --> [ 1, 0, 0 ]
[ 817, 19, 928, 177 ] --> [ 1, 2, 1, 1 ]
[ 312, 463, 336, 729, 513 ] --> [ 0, 2, 0, 0, 0 ]
[ 53, 47, 33, 87, 81, 3, 17 ] --> [ 0, 0, 0, 1, 0, 2, 0 ]
code-golf array-manipulation number-theory Arnauld
источник
Связано
Арнаулд
Есть ли выходные значения должны быть целыми числами или бы [1], [0, 1]и [1, 1]работу?
Деннис
@ Денис Любые постоянные значения в порядке. Так что да, это будет работать!
Арно

Ответы:

9

Python 2 , 68 67 66 байт

-1 байт благодаря Mr. Xcoder
-1 байт благодаря ovs

x=input()
for j in x:k=sum(i%j%2for i in x);print(k<len(x)-1)+0**k

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

Возвращает 1,0,2вместо 0,1,2.

прут
источник
заменить (k<1)с 0**kна -1 байт.
овс
4

Желе , 9 байт

%þœ-€0Ḃ‘Ṭ

Возвращает [1, 1], [0, 1], [1] вместо 0, 1, 2 .

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

Как это устроено

%þœ-€0Ḃ‘Ṭ  Main link. Argument: A (array)

%þ           Build the modulus table.
  œ-€0       Remove one 0 from each list of moduli.
      Ḃ      Take the last bit of each.
       ‘     Increment, mapping 0 and 1 to 1 and 2.
        Ṭ    Untruth; map each array to an aray of 1's at the specified indices.
             This yields:
                 [1] if the array contains only 1's (all even).
                 [0, 1] if the array contains only 2's (all odd).
                 [1, 1] if the array contains 1's and 2's.
Деннис
источник
Не могли бы вы заменить ‘ṬUḄсQ€Ḅ , чтобы сохранить байты?
Джонатан Аллан
К сожалению нет. Q€может вернуться [0, 1]или[1, 0] .
Деннис
О верно. Я думаю [1], [1,1]и [0,1]три различных значения, поэтому %þœ-€0Ḃ‘Ṭдолжны быть приемлемы для 9. РЕДАКТИРОВАТЬ - ах, я вижу, вы задали этот точный вопрос :)
Джонатан Аллан
Еще одна 9-байтовая альтернатива¹-Ƥ%"%2‘Ṭ
мили
3

MATL , 12 байт

!G\o~tAws1=-

При этом используется 0, -1, 1вместо того 0, 1, 2соответственно.

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

объяснение

!    % Implicit input: row vector. Transpose into a column
G    % Push input again
\    % Modulus, element-wise with broadcast. Gives a square matrix
o    % Parity: gives 1 for odd, 0 for even
~    % Logical negate: 0 for odd, 1 for even
t    % Duplicate
A    % All: gives 1 for columns that contain only 1
w    % Swap
s    % Sum of each column
1    % Push 1
=    % Is equal? Gives 1 if the column sum was 1, 0 otherwise
-    % Subtract, element-wise. Implicit display
Луис Мендо
источник
3

C (gcc) , 118 114 97 92 91 байт

  • Спасибо Peter Cordes за исправление ошибок.
  • Сохранено четыре двадцать один байт благодаря Петру Кордесу ; предложение использовать другое отображение выходного значения; [0 1 2] ~ [3 2 1],
  • Сохранено пять байтов; используя еще одно отображение; [0 1 2] ~ [  ],
  • Сохраненный байт; golfed for(i=0;i<n;i++,putchar...к for(i=~0;++i<n;putchar....
i,j,r;f(A,n)int*A;{for(i=~0;++i<n;putchar(r)){for(j=r=0;j<n;j++)j-i&&(r|=1<<A[j]%A[i]%2);}}

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

Джонатан Фрех
источник
Ваши тестовые функции на TIO не передают достаточно аргументов, и это неопределенное поведение приводит к делению на ноль (SIGFPE) из последнего тестового примера. f(I,7)перезаписывает первый элемент I[]( A[]в f ()) одним из аргументов, которые вы используете в качестве локальных. f()предполагается, что arg был передан в стеке вызывающей стороной, но вызывающая сторона этого не знала, и что в действительности находится в стеке выше адреса возврата A[0]. (т.е. этот UB вызвал tи A[0]иметь тот же адрес). В любом случае, это только UB в вашей тестовой функции на TIO.
Питер Кордес
И кстати, я не мог воспроизвести сбой локально, поэтому мне пришлось добавить execlp("/usr/bin/objdump", "objdump", "-drwC", "-Mintel", argv[0], 0);в main, чтобы получить ассемблер от gcc 7.2.1 TIO, который не совсем соответствовал моему Arch Linux gcc 7.2.1. Превратив эту разборку обратно в asm-источник для вызывающей функции, я мог бы воспроизвести ее локально внутри gdb и точно подтвердить, что происходит.
Питер Кордес
Вы можете сохранить байты, используя другое отображение, например, 1 для четного, 2 для нечетного, 3 для смешанного, так что вы можете o|=1<<(A[j]%A[i]%2)без необходимости какого-либо необычного декодирования для o.
Питер Кордес
@PeterCordes Спасибо, что заметили, хотя я до сих пор не до конца понимаю, почему первая запись в массиве перезаписывается. Теперь я решил использовать глобальные переменные вместо локальных, удаляя неопределенное поведение.
Джонатан Фрех
@PeterCordes Я также принял ваше предложение по игре в гольф и сумел сэкономить четыре байта. Тем не менее, я не знаю, действительно ли это было то, что вы предлагали, как вы написали o|=1<<...вместо чего-то вроде o|=1<<(t=....
Джонатан Фрех
3

Mathematica, 57 49 48 байт

(s=#;And@@#.Or@@#&@OddQ@Rest@Sort[s~Mod~#]&)/@#&

Это возвращает:

  • False.Trueдля 0 (смешанный)
  • True.Trueза 1 (все нечетно)
  • False.Falseна 2 (все ровно)

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

Вот немного более длинная альтернатива (49 байтов):

Sign[(s=#;Tr@Mod[s~Mod~#,2]&)/@#/.Tr[1^#]-1->-1]&

Этот возвращает:

  • 1для 0 (смешанный)
  • -1за 1 (все нечетно)
  • 0на 2 (все ровно)

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

Дэвид Беван
источник
2

Красный , 101 байт

g: func[b][foreach n b[a: copy[]foreach m b[append a m % n % 2]sort a a: copy next a print unique a]]

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

Возвращает 1 0для смешанного, 1для нечетного и 0для четного

g: func[b] [
    foreach n b [
        a: copy []
        foreach m b [
            append a m % n % 2
        ]
        sort a
        a: copy next a
        print unique a
    ]
]
Гален Иванов
источник
2

JavaScript (ES6), 46 байт

a=>a.map(A=>a.map(B=>d+=B%A%2,d=0)|!a[d+1]-!d)

Возвращает -1 (четное), 1 (нечетное) и 0 (смешанное).

Как это устроено:

dАккумулятор будет:

  1. Ноль, если все даже модули. ( !a[d+1]== false, !d== 1, false - 1== -1 )
  2. На один * меньше длины массива, если все нечетные модули. ( * Аккумулятор включает в себя элемент, модулируемый против самого себя, что приводит к одному четному модулю.) ( !a[d+1]== true, !d== 0, true - 0== 1 )
  3. Два или более меньше, чем длина массива, если смесь. ( !a[d+1]== false, !d== 0, false - 0== 0 )

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

Показать фрагмент кода

Рик Хичкок
источник
1

J , 27 20 байт

[:<@~.@}:@\:"1~2||/~

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

Использует [1 0] [1] [0] вместо 0 1 2

Объяснение:

|/~ - составляет стол с остатками:

  |/~ 73 50 61 
 0 50 61
23  0 11
12 50  0

2|нечетный или четный? :

   2||/~ 73 50 61 
0 0 1
1 0 1
0 0 0

<@~.@}:@\:"1 - отсортировать, отбросить последний элемент (всегда ноль), сохранить элементы iquenique и пометить каждую строку:

   <@~.@}:@\:"1~2||/~ 73 50 61 
┌───┬─┬─┐
│1 0│1│0│
└───┴─┴─┘
Гален Иванов
источник
1
16 байтов с 2/:~@:|"1]|1]\.]возвратом списка пар.
миль
@ миль спасибо! Является ли этот вывод приемлемым?
Гален Иванов
На самом деле нет, я пропустил ту часть о различных ценностях. Я вернусь к этому немного позже.
миль
1

Рубин , 58 56 байт

->r{r.map{m=r.shift;s=r.map{|e|e%m%2}.uniq.sort;r<<m;s}}

Возвращает [0, 1], [1], [0] вместо 0, 1, 2 (то есть [0] для всех четных, [1] для всех нечетных и [0, 1] для смешанных).

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

Восстановить Монику - нотайнард
источник
1

Perl, 38 байт

Включает +3в себя-p

#!/usr/bin/perl -p
s/\d+/$@|=$_%$&%2+1for<$`$'>;$@/gee

Выходы 1 для всех четных, 2 для всех нечетных, 3 для смешанных

Тон Хоспел
источник
1

Чисто , 95 65 63 байта

import StdEnv


\l=[sum(removeDup[-1^(j rem i)\\j<-l|j<>i])\\i<-l]

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

Как лямбда, взяв [Int]и вернувшись [Int], сопоставляя:

  • 0: смешанный
  • 1: все даже
  • -1: все странно
Οurous
источник
1

Java 8, 91 89 байт

a->{for(int z:a){int s=1;for(int y:a)s+=y%z%2;System.out.print(" "+(s<a.length)+(s<2));}}
  • С помощью truetrue вместо 2даже
  • С помощью falsefalse вместо 1нечетных
  • Использование truefalseвместо 0смешанного

Объяснение:

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

a->{                      // Method with integer-array parameter and no return-type
  for(int z:a){           //  Loop over the array
    int s=1;              //   Sum-integer, starting at 1
    for(int y:a)          //   Inner loop over the array again
      s+=y%z%2;           //    Increase the sum by `y` modulo-`z` modulo-2
    System.out.print(" "  //   Print a space
      +(s<a.length)       //    + "true" if the sum is smaller than the length of the array
                          //      (this means there is at least one even)
      +(s<2));}}          //    + "true" if the sum is still 1
                          //      (this means all are even)
Кевин Круйссен
источник
0

Clojure, 82 байта

#(for[R[(range(count %))]i R](set(for[j R :when(not= i j)](odd?(mod(% j)(% i))))))

Полный пример с выходным преобразованием:

(def f #(for[R[(range(count %))]i R](set(for[j R :when(not= i j)](odd?(mod(% j)(% i)))))))
(->> [ 53, 47, 33, 87, 81, 3, 17] f
     (map {#{true} 1, #{false} 2, #{true false} 0}))
; (0 0 0 1 0 2 0)
NikoNyrh
источник