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

Наприклад, з урахуванням списків [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 шляхом зміни наFloatArray () від 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в синтаксисі currying (тобто дзвінок з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 також буде працювати тут, на однакову кількість байтів.)

Хаскелл, 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)

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

Діалог APL, 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 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

Піт , 11 байт

m*eSdhnd{dC

Спробуйте тут!

Піт , 12 байт

m*eSdhqhdedC

Спробуйте тут!

або

m*eSdh!tl{dC

Спробуйте тут!

05AB1E , 9 8 7 байт

Збережений байт, коли Ерік Виконавець вказав, що список списків є вхідним.

øε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

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

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

J, 7 байт

>.`+@.=

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

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

На щастя, рівність - це операція нульового рангу.

Пояснення

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

@.НЕ дійсно , якщо заяву, але в цьому випадку він функціонує як один (він індексує в герундий >.`+на підставі результату його правого аргумент і застосовується , що до входу).

Рубін , 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 (splat замість двох аргументів), і 1 байт завдяки @ovs (карта замість розуміння списку)

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

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

Лисп звичайний, 60 59 байт

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

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

-1 байт завдяки @ Zacharý!

Python з 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 не може бути безпосередньо підданий а Double, тому вам потрібно вказати будь-які масиви як масивиDouble s, перш ніж передати їх у функцію.

(наприклад) 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

Швидкий 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!")
}