Se le darán dos matrices de números de punto flotante. Su tarea es emparejar los elementos correspondientes de las dos matrices y obtener el máximo de cada par. Sin embargo , si los dos elementos correspondientes son iguales, debe tomar su suma en su lugar.

Por ejemplo, dadas las listas [1, 3, 3.2, 2.3]y [3, 1, 3.2, 2.6], debe hacer lo siguiente:

• Par de los elementos (o CP): [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]].

• Ir a través de cada par y aplicar el proceso anterior: [3, 3, 6.4, 2.6].

Especificaciones

• Las matrices / listas siempre tendrán la misma longitud. Sin embargo, pueden estar vacíos.

• Los números que contienen siempre se adaptarán a las capacidades de su idioma, siempre y cuando no abuse de eso. Pueden ser positivos, cero o negativos, debe manejar todos los tipos.

• Si le ayuda a reducir el recuento de bytes, también puede tomar la longitud de las listas como entrada.

Reglas

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
• Se aplican las reglas estándar de entrada y salida . Puede tomar entrada (y salida) en cualquier formato razonable.
• Las lagunas predeterminadas están prohibidas.

Casos de prueba

Array_1, Array_2 -> Salida

[], [] -> []
[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]

Jalea, 4 bytes

=‘×»

Pruébalo en línea!

Esto usa exactamente el mismo enfoque que mi respuesta APL , ¡excepto que Jelly tiene un incorporado para agregar uno a un número!

Kotlin, 78 75 71 66 65 59 bytes

Es mi primer intento, sé genial: D

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

TIO no funciona con esta solución (y no sé por qué), el código fuente para probar a continuación

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

EDITAR:

-3 por reemplazar "a + b [i]" por "a * 2"

-4 por reemplazar el método "mapIndexed" por "zip" (Gracias a la solución @AnonymousReality Swift)

-5 reemplazando el método "Math.max" cuando la condición

-1 por cambio cuando el orden de la condición

-6 por cambio aFloatArray () por toList ()

Python 2 , 45 bytes

Una mezcla de mi solución inicial y @ovs ' .

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

Pruébalo en línea!

Python 2 , 49 bytes

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

Pruébalo en línea!

Python 2 , 46 bytes

@ovs sugirió este método para guardar 3 bytes.

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

Pruébalo en línea!

¿Cómo?

En primer lugar, emparejamos los elementos correspondientes, utilizando *o zip(). Eso nos permite seguir jugando al golf trabajando con un mapa o una lista de comprensión.

El truco fresco en esta respuesta es esta parte: max(x,y)*-~(x==y). ¿Cómo funciona? - Bueno, como la mayoría de ustedes ya saben, Python convierte automáticamente los valores bool a enteros cuando se usan en operaciones aritméticas. Por lo tanto, (x==y)se evalúa como 1, si se cumple la condición. Sin embargo, si los dos valores no son iguales, regresa en su 0lugar. Luego, la operación bit a bit -~incrementa el valor devuelto por bool 1, dándonos ya sea 2o 1. max(a,b)da el valor máximo del par y lo *multiplica por el valor devuelto anteriormente (por lo que se multiplica por 2solo si son iguales, en cuyo caso max()devuelve el valor de ambos).

Esto se basa en el hecho de que la suma de dos números iguales es, de hecho, cualquiera de ellos duplicado, y el tipo de "abusos" de la clase booleana de Python es una subclase de int.

JavaScript (ES6), 53 49 45 43 bytes

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

• 4 bytes guardados tomando prestado un truco del Sr. Xcoder.
• 2 bytes guardados gracias a Arnauld.

Intentalo

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>

Explicación

a=>b=>

Función anónima que toma las 2 matrices como argumentos a través de parámetros ay b, al cursar la sintaxis (es decir, llamar conf(a)(b)

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

Asigne sobre la primera matriz, pasando cada elemento a través de una función donde x está el elemento actual y yel índice actual.

(y=b[y])

Obtener el elemento en el índice y en la segunda matriz y asígnelo como el nuevo valor de y.

>x?y

Compruebe si yes mayor quex y, de ser así, regrese y.

:y<x?x

De lo contrario, verifique si y es menor xy, de ser así, regresex

:x+y

De lo contrario, devuelve la suma de xy y. (Multiplicar xo ypor 2 también funcionaría aquí, para la misma cantidad de bytes).

Haskell, 34 bytes

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

Pruébalo en línea.

R , 31 29 bytes

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

pmax toma el máximo paralelo de los dos (o más) arreglos (reciclando el más corto según sea necesario).

Estaba mirando el comentario de Luis Mendo y obviamente me di cuenta de que el enfoque también podría funcionar para R. Eso me llevó a 30 bytes, pero luego empecé a jugar con diferentes maneras de conseguir índices en lugar de mejorar mi respuesta original, y tropezamos !a-bcomo TRUEdonde a==by FALSEde lo contrario, lo que equivale a a==b. Sin embargo, por cualquier razón, R no requiere paréntesis !a-bcomo lo hace a==b, lo que me ahorró dos bytes.

Como mencionó JDL en los comentarios , esto funciona porque! (la negación) tiene menor prioridad que el operador binario -en R, lo cual es extraño.

Pruébalo en línea! (nueva versión)

Pruébalo en línea! (original)

Python 3 , 48 46 44 bytes

-2 bytes gracias a @nwellnhof

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

Pruébalo en línea!

Dyalog APL, 5 bytes

⌈×1+=

Pruébalo en línea!

¿Cómo?

• ⌈, máximo en cuanto a elementos de los argumentos
• ×, elemento sabio multiplicar
• 1+=, 1 agregado a la igualdad de elementos de los argumentos

Esto funciona porque si los números son desiguales, 1+=será 1, que cuando se multiplica por el máximo, es el máximo. Cuando los números son iguales, 1+=volverá 2, cuando eso se multiplique por el máximo, obtenemos el doble o el máximo agregado a sí mismo.

Jalea , 6 bytes

żSṀE?€

Un enlace diádico que toma una lista de números en cada lado y devuelve la lista resultante.

Pruébalo en línea! o ver un conjunto de pruebas *.

¿Cómo?

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

Una alternativa es este enlace monádico que toma una lista de las dos listas, también 6 bytes :

+»⁼?"/

* ¡No creo haber creado un pie de página de prueba casi tres veces el número de bytes del código antes!

05AB1E , 5 bytes

øεMÃO

Pruébalo en línea!

-1 gracias a Emigna .

MATL , 7 bytes

X>tG=s*

La entrada es una matriz de dos filas, donde cada fila es una de las matrices.

Pruébalo en línea!

Explicación

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

En su lugar, modifica la segunda matriz de entrada o devuelve una nueva matriz flotante para guardar bytes.

-11 bytes tomando la longitud como entrada de enteros adicional, que se permite de acuerdo con las reglas de desafío.
-5 bytes gracias a @ OliverGrégoire (un byte a la vez ... xD)
-1 byte indirectamente gracias a la respuesta JS de @Shaggy , utilizando en a[l]*2lugar dea[l]+b[l] .

Explicación:

Pruébalo aquí

(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

Pruébalo aquí!

Pyth , 12 bytes

m*eSdhqhdedC

Pruébalo aquí!

o

m*eSdh!tl{dC

Pruébalo aquí!

05AB1E , 9 8 7 bytes

Guardado un byte como Erik the Outgolfer señaló que una lista de listas es una entrada válida.

øεMsËi·

Pruébalo en línea!

Explicación

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

>.`+@.=

Pruébalo en línea!

Toma una lista como argumento de la izquierda y la otra como la derecha.

Afortunadamente, la igualdad es una operación de rango cero.

Explicación

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

@.no es realmente una declaración if, pero en este caso funciona como uno (indexa en el gerundio en >.`+función del resultado de su argumento correcto y lo aplica a la entrada).

Ruby , 42 bytes

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

Pruébalo en línea!

El operador de la nave espacial es genial.

TI-Basic, 23 21 bytes

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

Lástima que las listas ocupan dos bytes cada una ...

Octava, 36 Byte

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

Pyth, 7 bytes

ms.MZdC

Pruébalo aquí

Python 3 , 49 46 45 bytes

3 bytes eliminados gracias a @ Mr.Xcoder (splat en lugar de dos argumentos), y 1 byte gracias a @ovs (mapa en lugar de comprensión de la lista)

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

Pruébalo en línea!

Lisp común, 60 59 bytes

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

Pruébalo en línea!

-1 byte gracias a @ Zacharý!

Python con numpy, 28 bytes

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

Asume que la entrada se da como dos matrices numpy.

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

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

Pruébalo en línea!

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

Pruébalo en línea!

Perl 6 , 34 28 bytes

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

Pruébalo en línea!

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 tiene una propiedad interesante en el sentido de que un Int no se puede convertir directamente en a Double, por lo que debe especificar las matrices como matrices de Doubles antes de pasarlas a la función.

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

Editar: -2 bytes gracias a @EriktheOutgolfer

C, 76 75 bytes

¡Gracias a @Kevin Cruijssen por guardar un byte!

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

Pruébalo en línea!

Japt , 13 bytes

íV,È¥Y Ä *XwY

Pruébalo en línea!con la -Qbandera para formatear la matriz de salida.

Óxido , 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>;

Pruébalo en línea!

Guardado 8 bytes gracias a @mgc

Swift 4 , 41 bytes

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

Casos de prueba:

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