Завдання

Давши масив додатних цілих чисел, замініть кожен елемент на паритет суми інших елементів. Масив гарантовано містить щонайменше 2 елементи.

Визначення

• Паритет: чи число непарне чи парне.

Приклад

Для масиву [1,2,3,1]:

• Замініть 1на паритет 2+3+1, тобто even.
• Замініть 2на паритет 1+3+1, тобто odd.
• Замініть 3на паритет 1+2+1, тобто even.
• Замініть 1на паритет 1+2+3, тобто even.

Вихід: [even, odd, even, even]

Вхідні дані

Масив додатного цілого числа.

Ви можете сприймати його як власне масив або як рядок, розділений рядком позитивних цілих чисел.

Ви можете припустити, що масив та значення всередині знаходяться в межах можливості обробки вашої мови.

Вихід

Масив з двох послідовних значень , одне представляє odd, одне представляє even.

Ви можете вивести його у вигляді рядка, розділеного рядком, поданого з двох значень.

Тестові шафи

Вхідні дані:

[1, 2, 3, 1]
[1, 2, 3, 2, 1]
[2, 2]
[100, 1001]

Виходи:

[even, odd, even, even]
[even, odd, even, odd, even]
[even, even]
[odd, even]

Примітка. Ви можете вибрати інші послідовні значення, крім oddі even.

Оцінка балів

Це код-гольф . Найкоротша відповідь у байтах виграє.

Застосовується стандартна лазівка .

Желе , 3 байти

+SḂ

Спробуйте в Інтернеті!

Як це працює

+SḂ  Main link. Argument: A (array)

 S   Compute the sum of A.
+    Add the sum to each element of A.
     Using _ (subtraction) or ^ (bitwise XOR) would also work.
  Ḃ  Bit; compute the parity of each resulting integer.

JavaScript (ES6), 38 36 32 байт

a=>a.map(b=>eval(a.join`+`)-b&1)

Використовує 0для парних і 1непарних.

Тест

f=
a=>a.map(b=>eval(a.join`+`)-b&1)
console.log(f([1, 2, 3, 1]))
console.log(f([1, 2, 3, 2, 1]))
console.log(f([100, 1001]))

Haskell, 20 байт

f x=odd.(sum x-)<$>x

Використовується як Trueдля непарних, так і Falseдля парних значень.

Спробуйте в Інтернеті!

Віднімайте кожен елемент із суми списку і перевіряйте, чи він непарний.

fзвернувся до pointfree також має 20 байт: map=<<(odd.).(-).sum.

MATL , 5 , 4 байти

ts-o

Спробуйте в Інтернеті!

Один байт збережено завдяки Деннісу!

Це дає "1" для непарних і "0" для парних. Пояснення:

t       % Duplicate the input
 s      % Get the sum of the input
  -     % Subtract it from the original input
   o    % Get the parity of each element

Аліса , 31 28 байт

/O.HQ\d$K@
\i#\ /d2-&+!w?+2%

Спробуйте в Інтернеті!

Формат введення не має значення, поки цілі числа розділені. Вихідний формат розділений між стрічковими каналами.

Макет, мабуть, ще не є оптимальним, але я ще не знайшов способу скоротити це.

Пояснення

/     Reflect to SE. Switch to Ordinal.
i     Read all input as a string.
      Reflect off bottom boundary. Move to NE.
.     Duplicate the input string.
      Reflect off top boundary. Move to SE.
\     Reflect to N. Switch to Cardinal.
H     Implicitly convert the top copy of the input to the integers it
      contains and take the absolute value of the top-most one. (Taking
      the absolute value doesn't do anything, but we need the implicit
      conversion to integers.)
      The IP wraps back to the second line.
\     Reflect to SE. Switch to Ordinal.
      Immediately reflect off bottom boundary. Move to NE.
Q     Reverse the stack (this converts the integers back to strings but
      that's irrelevant). After this, we end up with all the individual
      integers on the bottom of the stack in reverse order and the other
      copy of the input string with all integers on top.
      Reflect off top boundary. Move to SE.
/     Reflect to E. Switch to Cardinal.
d     Push the stack depth, which is one more than the number of list
      elements (due to the other input string on the stack).
2-    Subtract 2.
&+    Run + that many times, which implicitly converts the second string
      to the integers it contains and then adds up all the list elements.
!     Store the sum on the tape.
w     Push the current IP position to the return address stack. This
      lets us return here repeatedly to implement a loop.

  ?+    Retrieve the input sum from the tape and add it to the current
        element.
  2%    Compute its parity. Other ways to do this are 1A and 0x. 2F would
        also work but it gives 0/2 instead of 0/1.
        The IP wraps the first column of the grid.
  \     Reflect to NE. Switch to Ordinal. The IP bounces diaginally up
        and down until it hits the next \.
  O     Implicitly convert the current parity to a string and print it
        with a trailing linefeed.
  #     Skip the next command (the H).
  \     Reflect to E. Switch to Cardinal.
  d     Push the stack depth. This is zero when we're done.
  $     Skip the next command if the stack depth is indeed zero, which
        exits the loop.

K     Jump to the return address on top of the return address stack without
      popping it (so that the next K will jump there again).

@     Terminate the program.

Pyth, 7 6 байт

mi2-sQ

-1 байт завдяки @KZhang

Виходи 1 для непарних, 2 для парних.

Спробуй це!

Пояснення

m%-sQd2
m      Q    # For each element in the (implicit) input list
   sQ       # Take the sum of all the elements
  -  d      # subtract that element, so that we now have the sum of the other elements
 %    2     # modulo 2; 1=off, 0=even

05AB1E (спадщина) , 4 3 байти

O^È

Спробуйте в Інтернеті!

O   # Sum
 ^  # XOR with (implicit) input
  È # Print 1 for even / 0 for odd

Python 2 , 33 31 байт

^{-2 байти завдяки Leaky Nun}

lambda x:[sum(x)-z&1for z in x]

Спробуйте в Інтернеті!

R, 21 байт

(sum(n<-scan())-n)%%2

читає список з stdin і повертає 0 для парного, 1 для непарного. прив'язує вхід до змінної nвсередині виклику, sumа не викликає її зовні, тобтоn=scan();(sum(n)-n)%%2

Спробуйте в Інтернеті!

Математика, 13 байт

#+Tr@#&/*OddQ

або

OddQ[#+Tr@#]&

Clojure, 30 байт

#(for[i %](odd?(apply - i %)))

Суб'єкти всі значення по черзі, наприклад, із введенням [a b c d]2-го обчисленого значення b - a - b - c - d= -(a + c + d). Вихід є falseдля парного і trueдля непарного.

Але ви також можете використовувати +та обчислювати кожен наступний термін двічі, щоб він не впливав на паритет.

CJam , 10 байт

{_:+f+1f&}

Це анонімний блок (функція), який бере вхід зі стека і замінює його на вихід.

Спробуйте в Інтернеті!

Пояснення

Розглянемо вхід [1 2 3 1].

{         e# Begin block
          e#   STACK: [1 2 3 1]
  _       e#   Duplicate
          e#   STACK: [1 2 3 1], [1 2 3 1]
  :+      e#   Fold addition over the array: compute its sum
          e#   STACK: [1 2 3 1], 7 
  f+      e#   Map addition over the array with extra parameter
          e#   STACK: [8 10 11 8]
  1       e#   Push 1
          e#   STACK: [8 10 11 8], 1
  f&      e#   Map bit-wise "and" over the array with extra parameter
          e#   STACK: [0 0 1 0]
}         e# End block

J , 6 байт

2|]++/

Спробуйте в Інтернеті!

APL (Dyalog Unicode) , 19 7 байт

Завдяки @ Adám у 12 байтах

2|+/-¨⊢

Спробуйте в Інтернеті!

Japt , 7 байт

£x +X&1

Спробуйте в Інтернеті!

Пояснення

 £   x +X&1
 mX{ x +X&1}  // Ungolfed
UmX{Ux +X&1}  // Variable introduction

UmX{       }  // Replace each item in the input array with
         &1   //   the parity of
    Ux        //   the sum of the input array
       +X     //   plus X.
              // Implicit: output result of last expression

Perl 5, 31 байт

sub{map$x+=$_,@_;map$x-$_&1,@_}

Виходи 1для непарних і 0парних.

Clojure (сценарій), 36 байт

Вихід є trueнепарним і falseпарним. І вихід, і вхід - це послідовності.

(fn[l](map #(odd?(-(apply + l)%))l))

PHP, 50 байт

Інтернет-версії

1 для непарних, 0 для парних

Виведіть як розділений рядок з _

<?foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;

PHP, 72 байти

Виведення як використання масиву array_map

<?print_r(array_map(function($v){return array_sum($_GET)-$v&1;},$_GET));

C, 68 62 байт

i;s;f(c,l)int*l;{while(i<c)s+=l[i++];while(i)l[--i]=s-l[i]&1;}

1 для непарних, 0 для парних

Детальна спроба в Інтернеті

f(int c, int * l)
{
    int i = 0, s = 0;

    while(i < c)
    {
        s = s + l[i];
        i = i + 1;
    }

    // assert(i == c)

    while(i > 0)
    {
        i = i - 1;
        l[i] = s - l[i]&1;
    }
}

Сітківка , 40 38 байт

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶
 

Спробуйте в Інтернеті! Виходи 1 для непарних і 0 для парних. Пояснення: Перші два рядки повторюють введення один раз для кожного номера на вході, але без самого елемента. Це створює додатковий порожній рядок, який потім видаляється. Потім вхід перетворюється з десяткового в одинарне, пробіли видаляються і обчислюється паритет. Потім навіть парність перетворюється на нуль, а результати об'єднуються в один рядок. Редагувати: збережено 2 байти завдяки @FryAmTheEggman. Я спробував деякі інші версії, які концептуально приємніші, але для того, щоб виразити занадто багато байтів:

\d\B

T`2468O`00001
T`d`10`^([^1]*1[^1]*1)*[^1]*1[^1]*$

Змінює всі входи на їх паритет, а потім гортає всі їхні паритети, якщо загальний має непарний паритет.

\d+
$*
^.*
$&¶$&
 (?=.*$)

11

\B
0
T`d`10`.*¶1
¶0

Підсумовує дублікат вводу, потім бере парність усього, потім перевертає паритети, якщо сума непарна, а потім видаляє суму знову.

Ом , 4 байти

DΣ-é

Спробуйте в Інтернеті!

В основному це прямий порт відповідей MATL та 05AB1E . Використовує trueдля парних і falseнепарних.

k, 9 байт

{2!x-+/x}

Вихід - це 1для odd, і 0для рівного. Спробуйте в Інтернеті.

Перетворений у псевдокод, це було б:

for number in x:
    yield (number - sum(x)) % 2

Скала , 19 байт

x=>x.map(x.sum-_&1)

Спробуйте в Інтернеті!

Мозг-Флак , 94 68 66 байт

({({}<>)<>})<>{<>(({})<({}<>{}<>(())){({}[()]<([{}])>)}{}>)<>}<>{}

Спробуйте в Інтернеті!

Це здається дещо довгим завданням. Можливо, є більш зручний спосіб зробити це.

Пояснення

Спочатку обчислюємо суму стека за допомогою:

({({}<>)<>})

Ми проходимо весь стек, додаючи цей результат до кожного елемента та визначаючи парність

<>{<>(({})<({}<>{}<>(())){({}[()]<([{}])>)}{}>)<>}<>{}

Тут використовується досить класний алгоритм mod 2, який я придумав для цього завдання.

({}(())){({}[()]<([{}]())>)}{}

Це підштовхує 1 під введеннями входу до тих пір, поки вхід не досягне нуля щоразу, виконуючи 1-nпоказник 1, який ми розмістили раніше, він потім видаляє вхід.

Мудрий , 54 52 байти

::^:??[:!^:?^:!^:?^?]|!::^??[!:?^:><^!:?^:!^:?^?]!&|

Спробуйте в Інтернеті!

Пояснення

Цей код був би набагато коротшим, якби не знадобилося стільки байтів, щоб поміняти два найкращі елементи. Поточний запис є

:?^:!^:?^!

Це, на жаль, становить більшість кодів.

Спочатку беремо суму XOR стека

::^:??[:!^:?^:!^:?^?]|!

Потім ми XOR це з кожним елементом і елемент з ним останній біт нульовий

::^??[!:?^:><^!:?^:!^:?^?]!&|

Java , 81 78 байт

3 байти завдяки Kevin Cruissen

void f(int[]a){int s=0,i=a.length;for(int x:a)s+=x;for(;i-->0;a[i]=s-a[i]&1);}

Спробуйте в Інтернеті!

Змінює масив на місці.

AWK , 64 байти

{for(i=0;++i<=NF;print s[i]%2)for(j=0;++j<=NF;)if(i!=j)s[i]+=$j}

Спробуйте в Інтернеті!

Виводить 0для парних сум і 1для непарних сум, розділених новими рядками. Єдиним, навіть злегка нестандартним мисленням, було розміщення printкоманди всередині forкроку "збільшення". Я спробував кілька "розумних" способів друку, але вони не зберегли байти.

Тільки для хихикань, якщо ви не хочете нових рядків:

{for(i=0;++i<=NF;m=m,s[i]%2)for(j=0;++j<=NF;)if(i!=j)s[i]+=$j}1

який має той самий підрахунок байтів, що і вище, але трохи більш тупий.

Швидкий - 55 байт

^{Нарешті б'є С! Також 0 для парного, 1 для непарного}

func g(a:[Int]){for i in a{print((a.reduce(0,+)-i)%2)}}

Функція з використанням: g(a: [1,2,3,2,1] // => 0 1 0 1 0

Перевір!

Аксіома, 45 байт

f(a)==[(reduce(+,a)-a.j)rem 2 for j in 1..#a]

відсутність перевірки типу введення, можливий перерахунок суми "а" кожного елемента ... тести

(27) -> [[a,f(a)] for a in [[1,2,3,1], [1,2,3,2,1], [2,2], [100, 1001] ]]
   (27)
   [[[1,2,3,1],[0,1,0,0]], [[1,2,3,2,1],[0,1,0,1,0]], [[2,2],[0,0]],
    [[100,1001],[1,0]]]

Джулія 1,0 , 17 байт

x->(sum(x).-x).%2

Спробуйте в Інтернеті!