Você receberá duas matrizes de números de ponto flutuante. Sua tarefa é emparelhar os elementos correspondentes das duas matrizes e obter o máximo de cada par. No entanto , se os dois elementos correspondentes forem iguais, você deverá obter a soma deles.

Por exemplo, dadas as listas [1, 3, 3.2, 2.3]e [3, 1, 3.2, 2.6], você deve fazer o seguinte:

• Emparelhar os elementos (ou ZIP): [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]].

• Ir através de cada par e aplicar o processo acima: [3, 3, 6.4, 2.6].

Especificações

• As matrizes / listas sempre terão o mesmo comprimento. No entanto, eles podem estar vazios.

• Os números que eles contêm sempre se ajustam aos recursos do seu idioma, desde que você não abuse disso. Eles podem ser positivos, zero ou negativos, você deve lidar com todos os tipos.

• Se isso ajudar a reduzir sua contagem de bytes, você também pode usar o comprimento das listas como entrada.

Regras

• Isso é código-golfe , então a resposta mais curta em bytes vence.
• Regras de entrada e saída padrão se aplicam. Você pode receber entrada (e saída) em qualquer formato razoável.
• As brechas padrão são proibidas.

Casos de teste

Matriz_1, Matriz_2 -> Saída

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

Gelatina, 4 bytes

=‘×»

Experimente online!

Isso usa exatamente a mesma abordagem da minha resposta do APL , exceto que o Jelly tem um builtin para adicionar um a um número!

Kotlin, 78 75 71 66 65 59 bytes

É a minha primeira tentativa, seja legal: D

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

O TIO não funciona com esta solução (e não sei por que), código fonte para testes abaixo

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 substitua "a + b [i]" por "a * 2"

-4 por substituir o método "mapIndexed" por "zip" (Graças à solução @AnonymousReality Swift)

-5 substitua o método "Math.max" por quando a condição

-1 por alteração quando a ordem da condição

-6 por alteração toFloatArray () por toList ()

Python 2 , 45 bytes

Uma mistura da minha solução inicial e @ovs ' .

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

Experimente online!

Python 2 , 49 bytes

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

Experimente online!

Python 2 , 46 bytes

@ovs sugeriu este método para economizar 3 bytes.

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

Experimente online!

Quão?

Primeiro, emparelhamos os elementos correspondentes, usando *ou zip(). Isso nos permite fazer mais golfe trabalhando com um mapa ou com uma lista de compreensão.

O truque legal nesta resposta é esta parte: max(x,y)*-~(x==y). Como isso funciona? - Bem, como muitos de vocês já sabem, o Python converte automaticamente valores bool em números inteiros quando são usados ​​em operações aritméticas. Portanto, (x==y)é avaliado como 1se a condição for atendida. No entanto, se os dois valores não forem iguais, ele retornará 0. Em seguida, a operação bit a bit -~incrementa o valor retornado do bool 1, fornecendo-nos 2ou 1. max(a,b)fornece o valor máximo do par e o *multiplica pelo valor retornado acima (para que seja multiplicado 2apenas se forem iguais; nesse caso, max()retornará o valor de ambos).

Isso se baseia no fato de que a soma de dois números iguais é de fato um deles duplicado e o tipo de "abuso" da classe bool do Python é uma subclasse 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 salvos emprestando um truque do Sr. Xcoder.
• 2 bytes economizados graças ao Arnauld.

Tente

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>

Explicação

a=>b=>

Função anônima que toma as 2 matrizes como argumentos por meio de parâmetros ae b, ao currying sintaxe (ou seja, chama comf(a)(b)

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

Mapeie a primeira matriz, passando cada elemento por uma função em que xé o elemento atual e yo índice atual.

(y=b[y])

Obtenha o elemento no índice yna segunda matriz e atribua-o como o novo valor de y.

>x?y

Verifique se yé maior que xe, em caso afirmativo, retorne y.

:y<x?x

Senão, verifique se yé menor que xe, se sim, retornex

:x+y

Senão, retorne a soma de xe y. (Multiplicar xou ypor 2 também funcionaria aqui, para o mesmo número de bytes.)

Haskell, 34 bytes

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

Experimente online.

R , 31 29 bytes

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

pmax toma o máximo paralelo das duas (ou mais) matrizes (reciclando a mais curta, conforme necessário).

Eu estava olhando o comentário de Luis Mendo e, obviamente, percebi que a abordagem poderia funcionar para R também. Isso me levou a 30 bytes, mas depois comecei a brincar com diferentes formas de obtenção de índices em vez de melhorar a minha resposta original, e tropeçou em !a-bcomo TRUE, onde a==be FALSEde outra forma, equivalente a a==b. No entanto, por qualquer motivo, R não exige parênteses, !a-bcomo isso significa a==b, o que me salvou em dois bytes.

Como mencionado por JDL nos comentários , isso funciona porque !(negação) tem precedência menor do que o operador binário -em R, o que é estranho.

Experimente online! (nova versão)

Experimente online! (original)

Python 3 , 48 46 44 bytes

-2 bytes graças a @nwellnhof

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

Experimente online!

Dyalog APL, 5 bytes

⌈×1+=

Experimente online!

Quão?

• ⌈, máximo em elementos dos argumentos
• ×multiplicar por elementos
• 1+=, 1 adicionado à igualdade entre elementos dos argumentos

Isso funciona porque, se os números forem desiguais, 1+=será 1, o que, quando multiplicado pelo máximo, é o máximo. Quando os números forem iguais, 1+=retornará 2, quando multiplicado pelo máximo, obteremos o dobro do máximo ou o máximo adicionado a ele mesmo.

Gelatina , 6 bytes

żSṀE?€

Um link diádico obtendo uma lista de números de cada lado e retornando a lista resultante.

Experimente online! ou veja uma suíte de testes *.

Quão?

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

Uma alternativa é esse link monádico, com uma lista das duas listas, também com 6 bytes :

+»⁼?"/

* Acho que nunca criei um rodapé da suíte de testes quase três vezes a contagem de bytes do código antes!

05AB1E , 5 bytes

øεMÃO

Experimente online!

-1 graças a Emigna .

MATL , 7 bytes

X>tG=s*

Entrada é uma matriz de duas linhas, em que cada linha é uma das matrizes.

Experimente online!

Explicação

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

Modifica a segunda matriz de entrada ou retorna uma nova matriz flutuante para salvar bytes.

-11 bytes, assumindo o comprimento como entrada inteira adicional, o que é permitido de acordo com as regras de desafio.
-5 bytes graças a @ OliverGrégoire (um byte de cada vez .. xD)
-1 byte indiretamente, graças à resposta JS de @Shaggy , usando em a[l]*2vez de a[l]+b[l].

Explicação:

Experimente aqui.

(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

Pitão , 11 bytes

m*eSdhnd{dC

Experimente aqui!

Pitão , 12 bytes

m*eSdhqhdedC

Experimente aqui!

ou

m*eSdh!tl{dC

Experimente aqui!

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

Oitava, 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!

Lisp comum, 60 59 bytes

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

Experimente online!

-1 byte graças a @ Zacharý!

Python com numpy, 28 bytes

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

Assume que a entrada é fornecida como duas matrizes numpy.

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

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

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

Experimente online!

Perl 6 , 34 28 bytes

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

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

O Swift tem uma propriedade interessante, pois um Int não pode ser convertido diretamente para a Double, então você deve especificar quaisquer matrizes como sendo matrizes deDouble s antes de passá-las para a função.

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

Edit: -2 bytes graças a @EriktheOutgolfer

C, 76 75 bytes

Agradecemos a @Kevin Cruijssen por salvar um byte!

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

Experimente online!

Japonês , 13 bytes

íV,È¥Y Ä *XwY

Experimente online! com o -Qsinalizador para formatar a matriz de saída.

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

Experimente online!

Guardado 8 bytes graças a @mgc

Swift 4 , 41 bytes

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

Casos de teste:

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