您将获得两个浮点数数组。您的任务是将两个数组的相应元素配对，并获取每对的最大值。但是，如果两个对应的元素相等，则必须取它们的总和。

例如，给定列表[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具有将数字加一个的内置功能！

Kotlin，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 * 2”替换“ a + b [i]”

-4通过用“ zip”替换“ mapIndexed”方法（感谢@AnonymousReality Swift解决方案）

-5通过在条件时替换“ Math.max”方法

条件变更时-1

-6通过toList（）更改为toFloatArray（）

Python 2 2，45个字节

我最初的解决方案和@ovs'的混合。

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

在线尝试！

Python 2 2，49个字节

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

在线尝试！

Python 2 2，46个字节

@ovs建议此方法节省3个字节。

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

在线尝试！

怎么样？

首先，我们使用*或配对相应的元素zip()。这使我们可以通过使用地图或列表理解来进一步打高尔夫球。

这个答案中最酷的把戏是这一部分：max(x,y)*-~(x==y)。这是如何运作的？-好吧，正如您所知，Python在算术运算中使用布尔值时会将它们自动转换为整数。因此，如果满足条件，则被(x==y)评估为1。但是，如果两个值不相等，它将返回0。然后，按位运算-~将布尔值返回的值增加1，从而得到2或1。max(a,b)给出该对的最大值，并将其*乘以上面返回的值（因此，2仅当它们相等时才乘以，在这种情况下，max()返回两者的值）。

这是基于这样一个事实，即两个相等的数字之和实际上是其中一个都加倍了，并且“滥用” Python的bool类是int的子类。

JavaScript（ES6），53 49 45 43字节

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

• 向Xcoder先生借了一个把戏，节省了4个字节。
• 感谢Arnauld，节省了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=>

匿名函数，使用参数a和b，以currying语法（即，使用f(a)(b)

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

映射到第一个数组，将每个元素传递给一个函数，该函数x是当前元素和y当前索引。

(y=b[y])

获取y第二个数组中index处的元素，并将其分配为的新值y。

>x?y

检查是否y大于x，如果大于，则返回y。

:y<x?x

否则，检查是否y小于x，如果小于，则返回x

:x+y

否则，返回的总和x及y。（对于相同的字节数，在这里乘以2 x或y2也可以。）

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 获取两个（或更多）数组的并行最大值（根据需要循环使用较短的数组）。

我在看Luis Mendo的评论时，很明显地我意识到该方法也适用于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)

在线尝试！

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

一个替代方法是此monadic链接采用两个列表的列表，也为6个字节：

+»⁼?"/

*我认为我以前从未创建过测试套件页脚几乎是代码字节数的三倍！

05AB1E，5个字节

øεMÃO

在线尝试！

-1感谢Emigna。

MATL, 7 bytes

X>tG=s*

Input is a two-row matrix, where each row is one of the arrays.

Try it online!

Explanation

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 bytes

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

Modifies the second input-array instead or returning a new float-array to save bytes.

-11 bytes by taking the length as additional integer-input, which is allowed according to the challenge rules.
-5 bytes thanks to @OliverGrégoire (one byte at a time.. xD)
-1 byte indirectly thanks to @Shaggy's JS answer, by using a[l]*2 instead of a[l]+b[l].

Explanation:

Try it here.

(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 bytes

m*eSdhnd{dC

Try it here!

Pyth, 12 bytes

m*eSdhqhdedC

Try it here!

or

m*eSdh!tl{dC

Try it here!

05AB1E, 9 8 7 bytes

Saved a byte as Erik the Outgolfer pointed out that a list of lists is valid input.

øεMsËi·

Try it online!

Explanation

ø          # 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 bytes

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

J, 7 bytes

>.`+@.=

Try it online!

Takes one list as the left argument and the other as the right.

Luckily, equality is a rank zero operation.

Explanation

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

@. isn't really an if statement, but in this case it functions as one (it indexes into the gerund >.`+ based on the result of its right argument and applies that to the input).

Ruby, 42 bytes

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

Try it online!

The spaceship operator is great.

TI-Basic, 23 21 bytes

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

Too bad lists take up two bytes each...

Octave, 36 Byte

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

Pyth, 7 bytes

ms.MZdC

Try it here.

Python 3, 49 46 45 bytes

3 bytes removed thanks to @Mr.Xcoder (splat instead of two arguments), and 1 byte thanks to @ovs (map instead of list comprehension)

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

Try it online!

Common Lisp, 60 59 bytes

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

Try it online!

-1 byte thanks to @Zacharý!

Python with numpy, 28 bytes

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

Assumes input is given as two numpy arrays.

C# (.NET Core), using Linq 47+18=65 bytes

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

Try it online!

C# (.NET Core), 82 bytes

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

Try it online!

Perl 6, 34 28 bytes

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

Try it online!

Swift 3, 81 79 Bytes

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

Swift has an interesting property in that an Int isn't directly castable to a Double, so you have to specify any arrays as being arrays of Doubles before passing them to the function.

(e.g.) var k:[Double] = [1,2,3,4,5,5,7,8,9,10]

Edit: -2 bytes thanks to @EriktheOutgolfer

C, 76 75 bytes

Thanks to @Kevin Cruijssen for saving a byte!

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

Try it online!

Japt, 13 bytes

íV,È¥Y Ä *XwY

Try it online! with the -Q flag to format the output array.

Rust, 107 97 bytes

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

Try it online!

Saved 8 bytes thanks to @mgc

Swift 4, 41 bytes

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

Test cases:

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!")
}