Obtenga lo mejor de dos matrices

19

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


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]

fuente
Usted dice que los números siempre encajarán "dentro de las" capacidades "de su idioma. Siempre y cuando no" abuse "de eso. ¿Solo se consideraría un abuso el uso de números enteros en un idioma que no tenga flotantes? La pregunta dice coma flotante pero realmente no veo una razón por la que tiene que ser flotantes. El mismo proceso se puede hacer en enteros. Me gustaría resolver esto en Brain-Flak pero Brain-flak solo admite ints.
Wheat Wizard
@WheatWizard Puedo hacer una excepción para eso. Anímate y publica tu respuesta y menciona que permití evitar confusiones.

Respuestas:

8

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!

Zacharý
fuente
Odio ser un spoilsport, pero ¿algunos de esos personajes no tienen más de un byte en cada codificación sensible?
Cedric Knight
Esto usa la página de códigos de gelatina .
Zacharý
¡Finalmente gané contra la competencia!
Zacharý
2
@ Zachary un hombre, 4 btytes ESTE VERANO ... ... ... Usted se ... SER ... JALEA DE ÉL ... nominal J de la jalea .
Magic Octopus Urn
11

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

Valentin Michalak
fuente
10
Bienvenido a PPCG! Por favor, no se desanime por el voto negativo (¡es el resultado de una ligera peculiaridad del sistema que ocurre cuando la primera publicación de un nuevo usuario se marca automáticamente por su calidad y luego mejora dicha publicación!)
Jonathan Allan
2
La peor "característica" jamás ... por cierto, no te sientas mal por eso.
Erik the Outgolfer
10

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.

Sr. Xcoder
fuente
Wow, eso fue muy rápido!
más sencillo, el mismo número de bytes:lambda*a:map(lambda x,y:(x<=y)*y+(x>=y)*x,*a)
jferard
@jferard De hecho, esa ya es la solución de Luis.
Sr. Xcoder
@ Mr.Xcoder ¡Vaya! No leí toda la página ...
jferard
Nunca diga "arriba", ya que el orden puede cambiar (no veo su solución arriba)
Zacharý
8

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

Lanudo
fuente
j.value.split`,`.map(eval)o eval('['+j.value+']')? También x+yse vería más ordenado en mi humilde opinión.
Neil
@Neil: 1) Me parece más fácil escribir el primero. Además, tengo un par de plantillas de fragmentos en una de mis máquinas; es más fácil simplemente atacarlos .map(eval). 2) De acuerdo, se editará momentáneamente.
Shaggy
7

Haskell, 34 bytes

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

Pruébalo en línea.

Cristian Lupascu
fuente
2
Misma cuenta de bytes: x!y=max x y+sum[x|x==y].
nimi
7

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)

Giuseppe
fuente
Resulta que ese unario "!" tiene menor precedencia en R que "-" binario, lo cual creo que es bastante inusual (¡y no me había dado cuenta hasta que leí esta respuesta!)
JDL
@JDL, sí, casi siempre tengo que abrir la página de sintaxis R mientras jugaba golf en caso de peculiaridades extrañas como esta ... y también porque nunca puedo recordar la precedencia de :cuando interactúo con la aritmética.
Giuseppe
6

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.

Zacharý
fuente
5

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!

Jonathan Allan
fuente
Outgolfed! . +1 para la interpretación prácticamente literal de la pregunta.
Zacharý
... y he quedado atrapado olvidando que »vectoriza antes!
Jonathan Allan
¿Qué más haría, tomar la matriz máxima de alguna manera enrevesada?
Zacharý
Python no necesita ninguna definición complicada, por ejemplo max([1,1,0],[1,0,3]) -> [1,1,0](no [1,1,3]).
Jonathan Allan
Entonces, ¿básicamente base infinita?
Zacharý
5

05AB1E , 5 bytes

øεMÃO

Pruébalo en línea!

-1 gracias a Emigna .

Erik el Outgolfer
fuente
Buena idea usando γ!
Emigna
@Emigna Realmente quería "elementos máximos", y {γθprobablemente sea lo más corto que pueda llegar para eso.
Erik the Outgolfer
¿Qué tal øεMÃO?
Emigna
@Emigna Cool, gracias! (duh, ¿por qué no pensé en ) yay ahora tengo la delantera: p por cierto øεZÃOtambién funcionaría
Erik the Outgolfer
4

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
Luis Mendo
fuente
4

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
Kevin Cruijssen
fuente
2
"Si le ayuda a reducir su recuento de bytes, también puede tomar la longitud de las listas como entrada". Definitivamente reducirá su conteo de bytes;)
Olivier Grégoire
1
Además, 2 bytes más cortos: a->b->l->{float A,B;for(;l-->0;b[l]=(A=a[l])<B?B:A>B?A:A+B)B=b[l];}
Olivier Grégoire
Y puede guardar un byte más poniendo float A, Bla forinicialización.
Olivier Grégoire
1
O esto: (a,b,l)->{for(;l-->0;)if(a[l]>=b[l])b[l]=a[l]*(a[l]>b[l]?1:2);}(63 bytes)
Olivier Grégoire
3
@ OlivierGrégoire Lol ... con jugar al golf cada byte ayuda, pero eso no significa que necesite jugar un byte a la vez. ;pag
Kevin Cruijssen
3

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
Emigna
fuente
Wow, eso fue muy rápido!
Puede guardar un byte eliminando e ingresando como un par de una lista y una lista.
Erik the Outgolfer
@EriktheOutgolfer: Cierto. Asumí que no se nos permitía, pero veo que el desafío especifica las reglas estándar de E / S. Gracias por notificar :)
Emigna
1
@Emigna Consejo: no hagas reglas fuera de tu mente;)
Erik the Outgolfer
1
@EriktheOutgolfer: Sí, realmente necesito dejar de hacer eso. Especialmente las reglas que hacen que mis programas sean más largos;)
Emigna
3

Mathematica, 31 bytes

MapThread[If[#==#2,2#,Max@##]&]
alephalpha
fuente
3

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

col
fuente
Buen trabajo, sé que no podría hacer esto, a pesar de que mi traducción de mi APL te ha superado . > _ <
Zacharý
J realmente brilla aquí
Jonah
@ Ratas Zacharý, bien golfizadas, no obstante.
cole
3

TI-Basic, 23 21 bytes

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

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

Timtech
fuente
Puede guardar dos bytes solicitando Xy Y, luego, utilizando ʟXy ʟYpara acceder a ellos, es decir, " Prompt X,Y:ʟX(ʟX=ʟY)+max(ʟ1,ʟ2".
Scott Milner
Además, esto no es válido actualmente, ya que L1(L1=L2)intenta obtener el elemento L1en una lista, lo que arroja un error. Para arreglar eso, cambie el orden, es decir (L1=L2)L1.
Scott Milner
@ScottMilner Gracias por señalar a ambos.
Timtech
2

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!

Luis Mendo
fuente
1
46 Bytes: lambda*c:[a*(a>=b)+b*(b>=a)for a,b in zip(*c)]. Resulta que esto también es bastante bueno :) - Lástima que no haya lugar para más golf
Sr. Xcoder
@ Mr.Xcoder Gracias! ¡Buena idea!
Luis Mendo
45 bytes usando el mapa en lugar de zip.
ovs
2

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ý!

Renzo
fuente
59 Bytes: (mapcar(lambda(x y)(*(max x y)(if(= x y)2 1)))(read)(read)).
Zacharý
De nada, no lo sé bien, solo traduje mis otras respuestas a Lisp, lo que terminó guardando un byte.
Zacharý
2

Python con numpy, 28 bytes

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

Asume que la entrada se da como dos matrices numpy.


fuente
Si estamos usando numpy, entonces esta es mi peor solución:lambda a,b:n.fmax(a,b)*((a==b)+1)
Erich
@Erich Me gusta la idea, pero para hacerlo tendría que hacerlo import numpy as n. Me salgo sin él aquí porque está implícito en la entrada.
Supongo que soy un poco inestable en el conteo explícito de bytes, a menudo las respuestas de Python son simplemente lambdas, cuando una implementación real de una respuesta requeriría asignarla a algo. Por esta razón, me pregunto si también es posible salirse con una declaración de importación implícita.
Erich
@Erich En general, solo puede hacer referencia a una variable nsi ha definido nen su código, por lo que las importaciones deben ser explícitas. Por defecto, permitimos funciones o programas completos como respuestas, que incluye funciones anónimas.
1
Bueno, esto solo necesita entrada como matrices numpy, en lugar de importar numpy. ¿Pero esto incluso funciona sin usar return?
Zacharý
2

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!

Dennis.Verweij
fuente
Puede soltar la respuesta LINQ por unos pocos bytes cambiando el espacio de nombres System.LINQ para usar System.LINQ
jkelm
@jkelm sí, me he estado preguntando si el 'uso del sistema' se incluirá o no de esa manera, supongo que no. Lo
limpiaré
System.Linq se incluye en el "Compilador interactivo de Visual C #". No estoy totalmente seguro de regresar Arrayvs IListvs IEnumerable, pero si todos son elegibles, entonces puede obtener el recuento de bytes a 37 - tio.run/##Sy7WTS7O/…
dana
1

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

Realidad anónima
fuente
¿Necesitas espacios alrededor (x,y)y antes ??
Erik the Outgolfer
@EriktheOutgolfer El anterior ? necesita el anterior porque Swift los trataría como tipos opcionales en lugar de terrarios (que no lo son). Los otros no lo son. Aparte de eso, esto se puede jugar drásticamente.
@EriktheOutgolfer - TheIOSCoder ya te ha respondido en parte, pero tienes razón, no necesitas las del bucle for, ¡interesante!
AnonymousReality
73 bytes: func n(a:[Float],b:[Float]){print(zip(a,b).map{$0==$1 ?2*$0:max($0,$1)})} (las imprecisiones flotantes no necesitan ser manejadas por defecto)
Sr. Xcoder
O 74 bytes:func n(a:[Float],b:[Float]){print(zip(a,b).map{($0==$1 ?2:1)*max($0,$1)})}
Sr. Xcoder
1

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!

Steadybox
fuente
1

Japt , 13 bytes

íV,È¥Y Ä *XwY

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

Justin Mariner
fuente
Bien hecho. Hice 2 intentos en esto anteriormente con ambos saliendo en 17 bytes. Había olvidado que ípodría tomar una función como un segundo argumento.
Shaggy
1

Ó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

jferard
fuente
1
Supongo que puede guardar 8 bytes utilizando la inferencia de tipos en el recopilado Vecy utilizando el maxmétodo de f32s:|a:Vec<f32>,b:Vec<f32>|a.iter().zip(b).map(|(&x,y)|if x==y{x+y}else{x.max(y)}).collect::<Vec<_>>();
mgc
1
@mgc Gracias! La inferencia de tipos fue una buena idea, pero en este caso el alias de tipo es aún más corto.
jferard
1

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!")
}
Alexander - Restablece a Monica
fuente