Соотношение суммы других элементов


23

задача

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

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

Testcases

Входы:

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

счет

Это . Кратчайший ответ в байтах побеждает.

Применяется стандартная лазейка .

Ответы:


16

Желе , 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.

Это умный подход.
Дрянная Монахиня

1
@LeakyNun Это тот же подход, который используют все остальные, только короче: P
ETHproductions

@ETHproductions В значительной степени, да. У Тете только так много способов вычислить паритет ...
Деннис

@ETHproductions использует сложение вместо вычитания ...
Leaky Nun

@LeakyNun Правда, мой ответ на Джапта тоже. В желе это было бы просто_SḂ
ETHproductions

8

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


Отключено 2 байта: c-b&1вместо(c-b)%2
Leaky Nun

Ба! Ты подтолкнул меня на это!
Shaggy

1
Я должен помнить, чтобы использовать eval(a.join`+`)более a.reduce((x,y)=>x+y). Это умно
Cyoce

8

Haskell, 20 байтов

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

Используется Trueдля нечетных значений и Falseдля четных значений.

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

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

fобратился к pointfree также имеет 20 байт: map=<<(odd.).(-).sum.


6

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

6

Алиса , 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.

6

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

Изменяя модуль %_2по GCD i2_, вы можете даже сделать dнеявное изменение кода на mi2-sQ, сохраняя байт. Выходы изменяются на 2 для четного и 1 для нечетного.
К Чжан



4

R, 21 байт

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

читает список из стандартного ввода и возвращает 0 для четного, 1 для нечетного. связывает ввод с переменной nвнутри вызова sumвместо вызова его снаружи, т.е.n=scan();(sum(n)-n)%%2

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



3

Clojure, 30 байтов

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

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

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


3

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



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

2

Perl 5, 31 байт

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

Выходы 1для нечетных и 0для четных.


+1, приятно. Я думаю, что это 28 байтов: perldoc perlsubговорит : «Подпись - это часть тела подпрограммы. Обычно тело подпрограммы - это просто блок кода в скобках».
msh210

@ msh210 Спасибо! Я не думаю, что так оно и работает, хотя объем подпрограммы составляет всего 28 байт, но вы не можете оставить ее, subне нарушив ее.
Крис

Но иногда подпрограмма работает без sub, например , после sortили grepили в качестве аргумента другой подпрограммы. Об этом стоит спросить на Code Golf Meta .
msh210

@ msh210 Подпрограмма работает subтолько в том случае, если она используется в функции-прототипе ( sortи grepболее или менее является прототипом). Но в противном случае subтребуется. Несмотря на это, игра в гольф 3 байта, опуская subне очень интересно.
Дада

2

Clojure (скрипт), 36 байт

Выход trueдля нечетных и falseчетных. И вывод, и ввод являются последовательностями.

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

2

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

1
Вы можете бросить ?:0это ничего не делает. foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;
Кристоф

2

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

2

Сетчатка , 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

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


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

@FryAmTheEggman Вы экономите благодаря менее заметному способу преобразования ваших значений ;обратно в пробелы. Если вы поместите ;в начале, то вы можете сохранить байт, удалив его сразу, а не после того, как он преобразуется в 0.
Нейл

На самом деле, оглянувшись еще раз, почему ваш последний этап не заменяет символы новой строки пробелами? Разве это не сэкономит 2 байта?
FryAmTheEggman

@FryAmTheEggman Да; Я думаю, что у меня было несколько замен на предыдущей итерации.
Нейл




1

Brain-Flak , 94 68 66 байт

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

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

Это кажется немного длинным для задачи. Там может быть более удобный способ сделать это.

объяснение

Сначала мы вычисляем сумму стека с помощью:

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

Мы проходим весь стек, добавляя этот результат к каждому элементу и определяем сопряжение

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

Здесь используется довольно крутой алгоритм мода 2, который я придумал для этой задачи.

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

Это толкает 1 к уменьшению входного значения, пока входное значение не достигнет нуля каждый раз, выполняя 1-n1, которое мы поместили ранее, затем удаляет входное значение.


Вы можете мод 2 в конце. Вам не нужно мод 2 сумма.
Утренняя монахиня

@ LeakyNun Спасибо! Я только что понял это и сделал исправление.
Пшеничный волшебник

1

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

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

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

объяснение

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

:?^:!^:?^!

Это, к сожалению, составляет большую часть кода.


Сначала мы берем сумму XOR стека

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

Затем мы XOR это с каждым элементом и элемент с последним битом обнуляется

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

1

Ява , 81 78 байт

3 байта благодаря Кевину Круассену

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

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

Изменяет массив на месте.



67 байт, если вы используете лямбду: попробуйте онлайн!
Брайан Маккатон

Спасибо, но я не люблю использовать лямбду.
Утренняя монахиня

1

AWK , 64 байта

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

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

Выводит a 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

который имеет тот же счетчик байтов, что и выше, но немного более тупой.


1

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

Проверьте это!


Не знаком со Swift, но на многих языках его можно заменить (x-y)%2наx-y&1
Cyoce

@Cyoce Для меня, после тестирования, это не работает. Побитовые операции не являются сильной стороной Свифта
мистер Xcoder

1

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

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

нет проверки на тип ввода, возможен пересчет суммы "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]]]

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