Vous recevrez deux tableaux de nombres à virgule flottante. Votre tâche consiste à associer les éléments correspondants des deux tableaux et à obtenir le maximum de chaque paire. Cependant , si les deux éléments correspondants sont égaux, vous devez plutôt prendre leur somme.

Par exemple, étant donné les listes [1, 3, 3.2, 2.3]et [3, 1, 3.2, 2.6], vous devez effectuer les opérations suivantes:

• Coupler les éléments (ou zip): [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]].

• Passez par chaque paire et appliquer le processus ci - dessus: [3, 3, 6.4, 2.6].

Spécifications

• Les tableaux / listes auront toujours la même longueur. Ils peuvent cependant être vides.

• Les chiffres qu'ils contiennent s'adapteront toujours aux capacités de votre langue, tant que vous n'en abusez pas. Ils peuvent être positifs, nuls ou négatifs, vous devez gérer tous les types.

• Si cela vous aide à réduire votre nombre d'octets, vous pouvez également prendre la longueur des listes en entrée.

Règles

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
• Des règles d'entrée et de sortie standard s'appliquent. Vous pouvez prendre des entrées (et des sorties) dans n'importe quel format raisonnable.
• Les failles par défaut sont interdites.

Cas de test

Array_1, Array_2 -> Sortie

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

Gelée, 4 octets

=‘×»

Essayez-le en ligne!

Cela utilise exactement la même approche que ma réponse APL , sauf que Jelly a une fonction intégrée pour en ajouter un à un nombre!

Kotlin, 78 75 71 66 65 59 octets

C'est ma première tentative, sois cool: D

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

TIO ne fonctionne pas avec cette solution (et je ne sais pas pourquoi), code source pour les tests ci-dessous

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

ÉDITER:

-3 en remplaçant "a + b [i]" par "a * 2"

-4 par remplacer la méthode "mapIndexed" par "zip" (Merci à la solution @AnonymousReality Swift)

-5 en remplaçant la méthode "Math.max" par quand la condition

-1 par changement lors de la commande de condition

-6 en modifiant toFloatArray () par toList ()

Python 2 , 45 octets

Un mélange de ma solution initiale et @ovs ' .

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

Essayez-le en ligne!

Python 2 , 49 octets

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

Essayez-le en ligne!

Python 2 , 46 octets

@ovs a suggéré cette méthode pour économiser 3 octets.

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

Essayez-le en ligne!

Comment?

Tout d'abord, nous appairons les éléments correspondants, en utilisant soit *ou zip(). Cela nous permet de continuer notre golf en travaillant soit avec une carte, soit avec une liste de compréhension.

L'astuce de frais dans cette réponse est cette partie: max(x,y)*-~(x==y). Comment ça marche? - Eh bien, comme la plupart d'entre vous le savent déjà, Python convertit automatiquement les valeurs booléennes en entiers lorsqu'elles sont utilisées dans des opérations arithmétiques. Par conséquent, (x==y)est évalué comme 1si la condition est remplie. Cependant, si les deux valeurs ne sont pas égales, elle renvoie à la 0place. Ensuite, l'opération au niveau du bit -~incrémente la valeur renvoyée par le booléen en 1nous donnant soit 2ou 1. max(a,b)donne la valeur maximale de la paire et la *multiplie par la valeur renvoyée ci-dessus (elle 2n'est donc multipliée que si elles sont égales, auquel cas max()renvoie la valeur des deux).

Ceci est basé sur le fait que la somme de deux nombres égaux est en fait l'un ou l'autre doublée, et que le type de "booléen" classe bool de Python est une sous-classe d'int.

JavaScript (ES6), 53 49 45 43 octets

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

• 4 octets économisés en empruntant une astuce à M. Xcoder.
• 2 octets enregistrés grâce à Arnauld.

Essayez-le

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>

Explication

a=>b=>

Fonction anonyme prenant les 2 tableaux comme arguments via des paramètres aet b, en curryant la syntaxe (ie, appel avecf(a)(b)

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

Mappez sur le premier tableau, en passant chaque élément à travers une fonction où xest l'élément en cours et yl'index en cours.

(y=b[y])

Obtenez l'élément à index ydans le deuxième tableau et affectez-le comme nouvelle valeur de y.

>x?y

Vérifiez si yest supérieur à xet, si oui, revenez y.

:y<x?x

Sinon, vérifiez si yest inférieur à, xet si oui, retournezx

:x+y

Sinon, retournez la somme de xet y. (La multiplication xou ypar 2 fonctionnerait également ici, pour le même nombre d'octets.)

Haskell, 34 octets

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

Essayez-le en ligne.

R , 31 29 octets

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

pmax prend le maximum parallèle des deux tableaux (ou plus) (en recyclant le plus court au besoin).

Je regardais le commentaire de Luis Mendo et, évidemment, j'ai réalisé que l'approche pouvait également fonctionner pour R. Cela m'a fait 30 octets, mais j'ai commencé à jouer avec différentes façons d'obtenir des indices plutôt que d'améliorer ma réponse initiale, et sommes tombés sur !a-bcomme TRUEoù a==bet par FALSEailleurs, soit a==b. Cependant, pour une raison quelconque, R ne nécessite pas de parenthèses !a-bcomme il le fait a==b, ce qui m'a fait économiser deux octets.

Comme mentionné par JDL dans les commentaires , cela fonctionne car !(la négation) a une priorité inférieure à celle de l'opérateur binaire -dans R, ce qui est étrange.

Essayez-le en ligne! (nouvelle version)

Essayez-le en ligne! (original)

Python 3 , 48 46 44 octets

-2 octets grâce à @nwellnhof

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

Essayez-le en ligne!

Dyalog APL, 5 octets

⌈×1+=

Essayez-le en ligne!

Comment?

• ⌈, maximum par élément des arguments
• ×, multiplier par élément
• 1+=, 1 ajouté à l'égalité élémentaire des arguments

Cela fonctionne parce que si les nombres sont inégaux, ce 1+=sera le cas 1, multiplié par le maximum. Lorsque les nombres sont égaux, 1+=reviendra 2, lorsque cela est multiplié par le maximum, nous obtenons le double du maximum, ou le maximum ajouté à lui-même.

Gelée , 6 octets

żSṀE?€

Un lien dyadique prenant une liste de numéros de chaque côté et renvoyant la liste résultante.

Essayez-le en ligne! ou consultez une suite de tests *.

Comment?

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

Une alternative est ce lien monadique prenant une liste des deux listes, également 6 octets :

+»⁼?"/

* Je ne pense pas avoir déjà créé un pied de page de suite de tests près de trois fois le nombre d'octets du code!

05AB1E , 5 octets

øεMÃO

Essayez-le en ligne!

-1 merci à Emigna .

MATL , 7 octets

X>tG=s*

L'entrée est une matrice à deux lignes, où chaque ligne est l'un des tableaux.

Essayez-le en ligne!

Explication

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 octets

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

Modifie le deuxième tableau d'entrée à la place ou renvoie un nouveau tableau flottant pour enregistrer les octets.

-11 octets en prenant la longueur comme entrée entière supplémentaire, ce qui est autorisé selon les règles de défi.
-5 octets grâce à @ OliverGrégoire (un octet à la fois .. xD)
-1 octet indirectement grâce à la réponse JS de @Shaggy , en utilisant à la a[l]*2place de a[l]+b[l].

Explication:

Essayez-le ici.

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

m*eSdhnd{dC

Essayez-le ici!

Pyth , 12 octets

m*eSdhqhdedC

Essayez-le ici!

ou

m*eSdh!tl{dC

Essayez-le ici!

05AB1E , 9 8 7 octets

Enregistré un octet comme Erik l'Outgolfer a souligné qu'une liste de listes est une entrée valide.

øεMsËi·

Essayez-le en ligne!

Explication

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

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

J, 7 octets

>.`+@.=

Essayez-le en ligne!

Prend une liste comme argument de gauche et l'autre comme droite.

Heureusement, l'égalité est une opération de rang zéro.

Explication

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

@.n'est pas vraiment une instruction if, mais dans ce cas, elle fonctionne comme une seule instruction (elle indexe le gérondif en >.`+fonction du résultat de son argument de droite et l'applique à l'entrée).

Rubis , 42 octets

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

Essayez-le en ligne!

L'opérateur de vaisseau spatial est génial.

TI-Basic, 23 21 octets

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

Dommage que les listes prennent deux octets chacune ...

Octave, 36 octets

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

Pyth, 7 octets

ms.MZdC

Essayez-le ici.

Python 3 , 49 46 45 octets

3 octets supprimés grâce à @ Mr.Xcoder (splat au lieu de deux arguments), et 1 octet grâce à @ovs (carte au lieu de la liste de compréhension)

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

Essayez-le en ligne!

Lisp commun, 60 59 octets

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

Essayez-le en ligne!

-1 octet grâce à @ Zacharý!

Python avec numpy, 28 octets

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

Suppose que l'entrée est donnée sous forme de deux tableaux numpy.

C # (.NET Core) , en utilisant Linq 47 + 18 = 65 octets

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

Essayez-le en ligne!

C # (.NET Core), 82 octets

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

Essayez-le en ligne!

Perl 6 , 34 28 octets

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

Essayez-le en ligne!

Swift 3, 81 79 octets

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

Swift a une propriété intéressante dans la mesure où un Int n'est pas directement transposable en a Double, vous devez donc spécifier tous les tableaux comme étant des tableaux de Doubles avant de les passer à la fonction.

(par exemple) var k:[Double] = [1,2,3,4,5,5,7,8,9,10]

Edit: -2 octets grâce à @EriktheOutgolfer

C, 76 75 octets

Merci à @Kevin Cruijssen d'avoir enregistré un octet!

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

Essayez-le en ligne!

Japt , 13 octets

íV,È¥Y Ä *XwY

Essayez-le en ligne! avec l' -Qindicateur pour formater le tableau de sortie.

Rouille , 107 97 octets

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

Essayez-le en ligne!

8 octets enregistrés grâce à @mgc

Swift 4 , 41 octets

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

Cas de test:

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