Вам будет дано два массива чисел с плавающей точкой. Ваша задача состоит в том, чтобы соединить соответствующие элементы двух массивов и получить максимум для каждой пары. Однако , если два соответствующих элемента равны, вы должны взять их сумму вместо.

Например, учитывая списки [1, 3, 3.2, 2.3]и [3, 1, 3.2, 2.6], вы должны сделать следующее:

• Пара элементов (или ZIP): [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]].

• Пройдите через каждую пару и применить описанную выше процедуру: [3, 3, 6.4, 2.6].

Спекуляции

• Массивы / списки всегда будут иметь одинаковую длину. Однако они могут быть пустыми.

• Числа, которые они содержат, всегда будут соответствовать возможностям вашего языка, если вы ими не злоупотребляете. Они могут быть положительными, нулевыми или отрицательными, вы должны обрабатывать все типы.

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

правила

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

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

Array_1, Array_2 -> Выход

[], [] -> []
[1, 2, 3], [1, 3, 2] -> [2, 3, 3]
[1, 3, 3.2, 2.3], [3, 1, 3.2, 2.6] -> [3, 3, 6.4, 2.6]
[1,2,3,4,5,5,7,8,9,10], [10,9,8,7,6,5,4,3,2,1] -> [10, 9, 8, 7, 6, 10, 7, 8, 9, 10]
[-3,2, -3,2, -2,4, 7, -10,1], [100, -3,2, 2,4, -7, -10,1] -> [100, -6,4, 2,4, 7, -20,2]

Желе, 4 байта

=‘×»

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

При этом используется тот же подход, что и в моем ответе на APL , за исключением того, что у Jelly есть встроенная функция для добавления одного к номеру!

Котлин, 78 75 71 66 65 59 байт

Это моя первая попытка, будь крут: D

a.zip(b).map{(a,b)->when{b>a->b;a>b->a;else->a*2}}.toList()

TIO не работает с этим решением (и я не знаю почему), исходный код для тестирования ниже

fun main(args: Array<String>) {
    bestOfTwo(floatArrayOf(), floatArrayOf()).print()
    bestOfTwo(floatArrayOf(0F), floatArrayOf(0F)).print()
    bestOfTwo(floatArrayOf(1F,2F,3F), floatArrayOf(1F,3F,2F)).print()
    bestOfTwo(floatArrayOf(1F,3F,3.2F,2.3F), floatArrayOf(3F,1F,3.2F,2.6F)).print()
    bestOfTwo(floatArrayOf(1F,2F,3F,4F,5F,5F,7F,8F,9F,10F), floatArrayOf(10F,9F,8F,7F,6F,5F,4F,3F,2F,1F)).print()
    bestOfTwo(floatArrayOf(-3.2F,-3.2F,-2.4F,7F,-10.1F), floatArrayOf(100F,-3.2F,2.4F,-7F,-10.1F)).print()
}


fun bestOfTwo(a :FloatArray, b :FloatArray): List<Float> =
    a.zip(b).map{(a,b)->when{b>a->b;a>b->a;else->a*2}}.toList()


fun List<Float>.print() {
    this.forEach { print("$it, ") }; println("")
}

РЕДАКТИРОВАТЬ:

-3 заменить "a + b [i]" на "a * 2"

-4 путем замены метода «mapIndexed» на «zip» (благодаря решению @AnonymousReality Swift)

-5 путем замены метода "Math.max" на условие

-1 при изменении условия заказа

-6 изменением toFloatArray () на toList ()

Python 2 , 45 байт

Смесь моего первоначального решения и @ovs ' .

lambda*a:map(lambda x,y:max(x,y)*-~(x==y),*a)

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

Python 2 , 49 байт

lambda x,y:[max(a,b)*-~(a==b)for a,b in zip(x,y)]

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

Python 2 , 46 байт

@ovs предложил этот метод для экономии 3 байтов.

lambda*x:[max(a,b)*-~(a==b)for a,b in zip(*x)]

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

Как?

Во- первых, мы пару соответствующих элементов, либо с помощью *или zip(). Это позволяет нам продолжать играть в гольф, работая с картой или списком.

Крутой трюк в этом ответе заключается в следующем max(x,y)*-~(x==y). Как это работает? - Ну, как многие из вас уже знают, Python автоматически преобразует значения bool в целые числа, когда они используются в арифметических операциях. Следовательно, (x==y)оценивается как 1, если условие выполнено. Однако, если эти два значения не равны, он возвращает 0вместо этого. Затем операция побитовые -~приращения значения , возвращаемые из BOOL путем 1, давая нам либо 2или 1. max(a,b)дает максимальное значение пары и *умножает его на значение, возвращенное выше (таким образом, оно умножается, 2только если они равны, и в этом случае max()возвращает значение обоих).

Это основано на том факте, что сумма двух равных чисел на самом деле либо удваивается, либо как бы «злоупотребляет» классом bool Python, являющимся подклассом int.

JavaScript (ES6), 53 49 45 43 байта

a=>b=>a.map((x,y)=>(y=b[y])>x?y:y<x?x:x+y)

• 4 байта сохранены, позаимствовав трюк у мистера Xcoder.
• 2 байта сохранены благодаря Арно.

Попытайся

o.innerText=(f=

a=>b=>a.map((x,y)=>(y=b[y])>x?y:y<x?x:x+y)

)(i.value=[1,3,3.2,2.3])(j.value=[3,1,3.2,2.6]);oninput=_=>o.innerText=f(i.value.split`,`.map(eval))(j.value.split`,`.map(eval))

<input id=i><input id=j><pre id=o>

объяснение

a=>b=>

Анонимная функция, принимающая 2 массива в качестве аргументов через параметры aи bв синтаксисе каррирования (то есть вызов сf(a)(b)

a.map((x,y)=>                      )

Сопоставьте первый массив, передавая каждый элемент через функцию, в которой xнаходится текущий элемент и yтекущий индекс.

(y=b[y])

Получите элемент по индексу yво втором массиве и присвойте ему новое значение y.

>x?y

Проверьте, yбольше ли, xи если да, верните y.

:y<x?x

Иначе, проверьте, если yменьше чем xи, если так, возвратитеx

:x+y

Иначе верните сумму xи y. (Умножение xили yна 2 также будет работать здесь для того же количества байтов.)

Haskell, 34 байта

x!y|x>y=x|x<y=y|1<2=x+y
zipWith(!)

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

R , 31 29 байт

function(a,b)pmax(a,b)+a*!a-b

pmax берет параллельный максимум двух (или более) массивов (рециркулируя более короткий по мере необходимости).

Я смотрел на комментарий Луиса Мендо и, очевидно, понял, что этот подход может сработать и для R. Это заставило меня до 30 байт, но потом я начал играть с различными способами получения индексов вместо того, чтобы улучшить мой первоначальный ответ, и наткнулся , !a-bкак , TRUEгде a==bи в FALSEпротивном случае, что эквивалентно a==b. Однако, по какой-то причине, R не требует круглых скобок, !a-bкак это было a==b, что позволило мне сэкономить два байта.

Как упомянуто JDL в комментариях , это работает, потому что !(отрицание) имеет более низкий приоритет, чем бинарный оператор -в R, что странно.

Попробуйте онлайн! (новая версия)

Попробуйте онлайн! (Оригинал)

Python 3 , 48 46 44 байта

-2 байта благодаря @nwellnhof

lambda*a:map(lambda*x:max(x)*2/len({*x}),*a)

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

Дьялог АПЛ, 5 байт

⌈×1+=

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

Как?

• ⌈поэлементный максимум аргументов
• ×поэлементное умножение
• 1+=1 добавлено к поэлементному равенству аргументов

Это работает, потому что, если числа неравны, 1+=будет 1, который при умножении на максимум является максимумом. Когда числа равны, 1+=вернется 2, когда это умножится на максимум, мы получим вдвое больше максимума, или максимум, добавленный к себе.

Желе , 6 байт

żSṀE?€

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

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

Как?

żSṀE?€ - Link: list of numbers L, list of numbers R   e.g. [1,3,3.2,2.3], [3,1,3.2,2.6]
ż      - zip - interleave L & R                       [[1,3],[3,1],[3.2,3.2],[2.3,2.6]]
     € - for each pair:
    ?  - { if:
   E   -   ...condition: equal                          0      0       1         0
 S     -   ...then: sum                                               6.4
  Ṁ    -   ...else: maximum                             3      3                2.6
       - }                                    ... ->   [3     ,3     ,6.4      ,2.6]

Альтернативой является эта монадическая ссылка , содержащая список из двух списков, также по 6 байтов :

+»⁼?"/

* Я не думаю, что когда-либо создавал нижний колонтитул тестового набора, почти в три раза превышающий счетчик кода!

05AB1E , 5 байтов

øεMÃO

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

-1 спасибо Эмигне .

MATL , 7 байт

X>tG=s*

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

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

объяснение

X>   % Implicit input. Maximum of each column
t    % Duplicate
G    % Push input
=    % Is equal? Element-wise with broadcast. Gives a two-row matrix
s    % Sum of each column. Gives a row vector containing 1 and 2
*    % Multiply, element-wise. Implicit display

Java 8, 80 69 67 66 65 64 63 байта

(a,b,l)->{for(;l-->0;)if(a[l]>=b[l])b[l]=a[l]*(a[l]>b[l]?1:2);}

Вместо этого изменяет второй массив ввода или возвращает новый массив float для сохранения байтов.

-11 байт, принимая длину в качестве дополнительного целочисленного ввода, что разрешено в соответствии с правилами вызова.
-5 байт благодаря @ OliverGrégoire (по одному байту за раз .. xD)
-1 байт косвенно благодаря ответу @Shaggy 's JS с использованием a[l]*2вместо a[l]+b[l].

Объяснение:

Попробуй это здесь.

(a,b,l)->{          // Method with 2 float-array and integer parameters and no return-type
  for(;l-->0;)      //  Loop over the array
    if(a[l]>=b[l])  //   If the current value in `a` is larger or equal to `b`:
      b[l]=         //   Modify the second input-array:
       a[l]*        //    Use `a` multiplied by:
        (a[l]>b[l]? //     If the current value in `a` is larger than `b`:
          1         //      Multiply by 1
         :          //     Else (`a` is smaller of equal to `b`):
          2)        //      Multiply by 2
                    //  End of loop (implicit / single-line body)
}                   // End of method

Pyth , 11 байт

m*eSdhnd{dC

Попробуй это здесь!

Pyth , 12 байт

m*eSdhqhdedC

Попробуй это здесь!

или

m*eSdh!tl{dC

Попробуй это здесь!

05AB1E , 9 8 7 байт

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

øεMsËi·

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

объяснение

ø          # zip the lists
 ε         # apply to each pair
  M        # get max
   s       # swap the top 2 elements on the stack
    Ëi     # if all elements are equal
      ·    # double the max

Mathematica, 31 байт

MapThread[If[#==#2,2#,Max@##]&]

J 7 байт

>.`+@.=

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

Принимает один список в качестве левого аргумента, а другой - в качестве правого.

К счастью, равенство является операцией ранга ноль.

объяснение

>.`+@.=
      =  Compare equality pairwise
    @.   If equal
   +       Sum
>.       (Else) take greater value

@.на самом деле это не оператор if, но в этом случае он функционирует как единое целое (он индексирует в gerund >.`+на основе результата своего правильного аргумента и применяет его к входным данным).

Рубин , 42 байта

->a,b{a.zip(b).map{|x,y|[x+y,x,y][x<=>y]}}

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

Оператор космического корабля великолепен.

TI-Basic, 23 21 байт

Prompt A,B
(ʟA=ʟB)ʟA+max(ʟA,ʟB

Слишком плохие списки занимают два байта каждый ...

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

@(a,b)a.*(a>b)+b.*(b>a)+2.*a.*(a==b)

Pyth, 7 байт

ms.MZdC

Попробуй это здесь.

Python 3 , 49 46 45 байт

3 байта удалены благодаря @ Mr.Xcoder (вместо двух аргументов) и 1 байт благодаря @ovs (карта вместо понимания списка)

lambda*x:map(lambda a,b:a*(a>=b)+b*(b>=a),*x)

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

Common Lisp, 60 59 байт

(mapcar(lambda(x y)(*(max x y)(if(= x y)2 1)))(read)(read))

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

-1 байт благодаря @ Zacharý!

Питон с NumPy, 28 байт

lambda a,b:a*(a>=b)+b*(b>=a)

Предполагается, что входные данные представлены в виде двух массивов.

C # (.NET Core) , используя Linq 47 + 18 = 65 байт

x=>y=>x.Zip(y,(a,b)=>a>b?a:b>a?b:b+a).ToArray()

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

C # (.NET Core), 82 байта

x=>y=>l=>{for(int i=0;i<l;i++)x[i]=x[i]>y[i]?x[i]:y[i]>x[i]?y[i]:y[i]*2;return x;}

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

Perl 6 , 34 28 байт

{map {.max*2/set $_},[Z] $_}

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

Swift 3, 81 79 байт

func n(a:[Double],b:[Double]){for(x,y)in zip(a,b){print((x==y) ?x+y:max(x,y))}}

У Swift есть интересное свойство, заключающееся в том, что Int не может быть напрямую преобразовано в a Double, поэтому вы должны указать любые массивы как массивы Doubles, прежде чем передавать их в функцию.

(например) var k:[Double] = [1,2,3,4,5,5,7,8,9,10]

Редактировать: -2 байта благодаря @EriktheOutgolfer

C, 76 75 байтов

Спасибо @Kevin Cruijssen за сохранение байта!

f(a,b,n)float*a,*b;{for(;n--;++a,++b)printf("%f ",*a>*b?*a:*b>*a?*b:*a*2);}

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

Japt , 13 байт

íV,È¥Y Ä *XwY

Попробуйте онлайн! с -Qфлагом для форматирования выходного массива.

Ржавчина , 107 97 байт

|a:V,b:V|a.iter().zip(b).map(|(&x,y)|if x==y{x+y}else{x.max(y)}).collect::<V>();
type V=Vec<f32>;

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

Сохранено 8 байт благодаря @mgc

Swift 4 , 41 байт

{zip($0,$1).map{$0==$1 ?2*$0:max($0,$1)}}

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

let f: ([Float], [Float]) -> [Float]
    = {zip($0,$1).map{$0==$1 ?2*$0:max($0,$1)}}

let testcases: [(inputA: [Float], inputB: [Float], expected: [Float])] = [
    (
        inputA: [],
        inputB: [],
        expected: []
    ),
    (
        inputA: [1, 2, 3],
        inputB: [1, 3, 2],
        expected: [2, 3, 3]
    ),
    (
        inputA: [1, 3, 3.2, 2.3],
        inputB:  [3, 1, 3.2, 2.6],
        expected: [3, 3, 6.4, 2.6]
    ),
    (
        inputA: [1,2,3,4,5,5,7,8,9,10],
        inputB:  [10,9,8,7,6,5,4,3,2,1],
        expected: [10, 9, 8, 7, 6, 10, 7, 8, 9, 10]
    ),
    (
        inputA: [-3.2, -3.2, -2.4, 7, -10.1],
        inputB:  [100, -3.2, 2.4, -7, -10.1],
        expected: [100, -6.4, 2.4, 7, -20.2]
    ),
]

for (caseNumber, testcase) in testcases.enumerated() {
    let actual = f(testcase.inputA, testcase.inputB)
    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \((testcase.inputA, testcase.inputB)) failed. Got \(actual), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}