Otrzymasz dwie tablice liczb zmiennoprzecinkowych. Twoim zadaniem jest sparowanie odpowiednich elementów dwóch tablic i uzyskanie maksimum każdej pary. Jednakże , jeśli dwa odpowiednie elementy są równe, trzeba wziąć ich sumę w zamian.

Na przykład, biorąc pod uwagę listy [1, 3, 3.2, 2.3]i [3, 1, 3.2, 2.6], musisz wykonać następujące czynności:

• Powiązać elementy (lub ZIP): [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]].

• Przejść przez każdą parą i zastosować proces powyżej: [3, 3, 6.4, 2.6].

Okular

• Tablice / listy zawsze będą miały równą długość. Mogą być jednak puste.

• Zawarte w nich liczby zawsze będą pasować do możliwości Twojego języka, o ile tego nie wykorzystasz. Mogą być dodatnie, zerowe lub ujemne, musisz obsługiwać wszystkie typy.

• Jeśli to pomaga zmniejszyć liczbę bajtów, to może również przyjąć długość list jako wejście.

Zasady

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
• Obowiązują standardowe reguły wejścia i wyjścia . Możesz pobierać dane wejściowe (i wyjściowe) w dowolnym rozsądnym formacie.
• Domyślne luki są zabronione.

Przypadki testowe

Array_1, Array_2 -> Dane wyjściowe

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

Galaretka, 4 bajty

=‘×»

Wypróbuj online!

To używa dokładnie tego samego podejścia, co moja odpowiedź APL , z tym że Jelly ma wbudowane dodawanie jednego do liczby!

Kotlin, 78 75 71 66 65 59 bajtów

To moja pierwsza próba, bądź spokojny: D

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

TIO nie działa z tym rozwiązaniem (i nie wiem dlaczego), kod źródłowy do testowania poniżej

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

EDYTOWAĆ:

-3 przez „a + b [i]” na „a * 2”

-4 przez zastąpienie metody „mapIndexed” przez „zip” (dzięki rozwiązaniu @AnonymousReality Swift)

-5 przez zastąpienie metody „Math.max” przez kiedy warunek

-1 przez zmianę przy zamówieniu warunku

-6 przez zmianę toFloatArray () przez toList ()

Python 2 , 45 bajtów

Mieszanka mojego początkowego rozwiązania i @ovs .

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

Wypróbuj online!

Python 2 , 49 bajtów

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

Wypróbuj online!

Python 2 , 46 bajtów

@ovs zaproponował tę metodę, aby zaoszczędzić 3 bajty.

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

Wypróbuj online!

W jaki sposób?

Po pierwsze, łączymy odpowiednie elementy za pomocą *lub zip(). To pozwala nam dalej grać w golfa, pracując z mapą lub listą.

Fajne sztuczki w tej odpowiedzi jest to część: max(x,y)*-~(x==y). Jak to działa? - Cóż, jak większość z was już wie, Python automatycznie konwertuje wartości bool na liczby całkowite, gdy są używane w operacjach arytmetycznych. Stąd (x==y)jest oceniany jako 1, jeśli warunek jest spełniony. Jeśli jednak dwie wartości nie są równe, zwraca wartość 0. Następnie operacji bitowej -~przyrosty wartość zwracana z bool przez 1, dając nam albo 2albo 1. max(a,b)daje maksymalną wartość pary i *mnoży ją przez wartość zwróconą powyżej (więc zostaje pomnożona 2tylko wtedy, gdy są równe, w którym to przypadku max()zwraca wartość obu).

Opiera się to na tym, że suma dwóch równych liczb jest w rzeczywistości podwojona, a rodzaj „nadużycia” klasy bool Pythona jest podklasą int.

JavaScript (ES6), 53 49 45 43 bajtów

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

• 4 bajty zaoszczędzone dzięki pożyczeniu sztuczki od pana Xcodera.
• 2 bajty zapisane dzięki Arnauldowi.

Spróbuj

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>

Wyjaśnienie

a=>b=>

Anonimowa funkcja przyjmująca 2 tablice jako argumenty za pomocą parametrów aoraz bw składni curry (tj. Wywołuje za pomocąf(a)(b)

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

Odwzoruj na pierwszej tablicy, przepuszczając każdy element przez funkcję, w której xjest bieżącym elementem i ybieżącym indeksem.

(y=b[y])

Uzyskaj element o indeksie yw drugiej tablicy i przypisz go jako nową wartość y.

>x?y

Sprawdź, czy yjest większy niż, xa jeśli tak, zwróć y.

:y<x?x

W przeciwnym razie sprawdź, czy yjest mniejszy, xa jeśli tak, wróćx

:x+y

W przeciwnym razie zwróć sumę xi y. (Mnożenie xlub yprzez 2 również by działało tutaj, dla tej samej liczby bajtów.)

Haskell, 34 bajty

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

Wypróbuj online.

R , 31 29 bajtów

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

pmax przyjmuje równoległe maksimum z dwóch (lub więcej) tablic (recykling krótszy w razie potrzeby).

Szukałem w komentarzu Luis Mendo za i oczywiście ja sobie sprawę, że podejście może pracować dla R, jak również. Że mnie do 30 bajtów, ale potem zacząłem zabawy z różnych sposobów na uzyskanie wskaźników zamiast poprawić mój oryginalny odpowiedź, i natknęliśmy się !a-bjak TRUE, gdzie a==bi FALSEinaczej, równoważne a==b. Jednak z jakiegokolwiek powodu R nie wymaga nawiasów wokół, !a-bjak to robi a==b, co pozwoliło mi zaoszczędzić dwa bajty.

Jak wspomniano w komentarzach JDL , działa to, ponieważ !(negacja) ma niższy priorytet niż operator binarny -w R, co jest dziwne.

Wypróbuj online! (Nowa wersja)

Wypróbuj online! (oryginalny)

Python 3 , 48 46 44 bajtów

-2 bajty dzięki @nwellnhof

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

Wypróbuj online!

Dyalog APL, 5 bajtów

⌈×1+=

Wypróbuj online!

W jaki sposób?

• ⌈, elementarne maksimum argumentów
• ×, mnożąc element
• 1+=, 1 dodane do elementarnej równości argumentów

Działa to, ponieważ jeśli liczby są nierówne, 1+=będzie to 1, które pomnożone przez maksimum, będzie maksimum. Gdy liczby są równe, 1+=wróci 2, gdy pomnożone przez maksimum, otrzymamy dwukrotność maksimum lub maksimum dodane do siebie.

Galaretka , 6 bajtów

żSṀE?€

Dyadyczny link pobierający listę liczb z każdej strony i zwracający wynikową listę.

Wypróbuj online! lub zobacz pakiet testowy *.

W jaki sposób?

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

Alternatywą jest monadyczny link zawierający listę dwóch list, również 6 bajtów :

+»⁼?"/

* Nie sądzę, że kiedykolwiek wcześniej tworzyłem stopkę zestawu testów prawie trzy razy większą niż liczba bajtów kodu!

05AB1E , 5 bajtów

øεMÃO

Wypróbuj online!

-1 dzięki Emignie .

MATL , 7 bajtów

X>tG=s*

Dane wejściowe to macierz dwurzędowa, gdzie każdy wiersz jest jedną z tablic.

Wypróbuj online!

Wyjaśnienie

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 bajty

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

Zamiast tego modyfikuje drugą tablicę wejściową lub zwraca nową tablicę zmiennoprzecinkową, aby zapisać bajty.

-11 bajtów, przyjmując długość jako dodatkowe wejście liczb całkowitych, co jest dozwolone zgodnie z regułami wyzwania.
-5 bajty dzięki @ OliverGrégoire (jeden bajt w czasie .. xD)
-1 bajt pośrednio dzięki @Shaggy jest JS odpowiedzi przez zastosowanie a[l]*2zamiast a[l]+b[l].

Wyjaśnienie:

Wypróbuj tutaj.

(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 bajtów

m*eSdhnd{dC

Wypróbuj tutaj!

Pyth , 12 bajtów

m*eSdhqhdedC

Wypróbuj tutaj!

lub

m*eSdh!tl{dC

Wypróbuj tutaj!

05AB1E , 9 8 7 bajtów

Zapisany bajt, ponieważ Erik the Outgolfer wskazał, że lista list jest poprawnym wejściem.

øεMsËi·

Wypróbuj online!

Wyjaśnienie

ø          # 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 bajtów

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

J, 7 bajtów

>.`+@.=

Wypróbuj online!

Traktuje jedną listę jako lewy argument, a drugą jako prawy.

Na szczęście równość jest operacją na poziomie zero.

Wyjaśnienie

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

@.tak naprawdę nie jest instrukcją if, ale w tym przypadku działa jako jedna (indeksuje do gerunda >.`+na podstawie wyniku jego właściwego argumentu i stosuje to do danych wejściowych).

Rubin , 42 bajty

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

Wypróbuj online!

Operator statku kosmicznego jest świetny.

TI-Basic, 23 21 bajtów

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

Szkoda, że ​​listy zajmują po dwa bajty ...

Oktawa, 36 bajtów

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

Pyth, 7 bajtów

ms.MZdC

Wypróbuj tutaj.

Python 3 , 49 46 45 bajtów

3 bajty usunięte dzięki @ Mr.Xcoder (ikona zamiast dwóch argumentów) i 1 bajt dzięki @ovs (mapa zamiast zrozumienia listy)

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

Wypróbuj online!

Common Lisp, 60 59 bajtów

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

Wypróbuj online!

-1 bajt dzięki @ Zacharý!

Python z numpy, 28 bajtów

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

Zakłada, że ​​dane wejściowe są podawane jako dwie tablice numpy.

C # (.NET Core) , używając Linq 47 + 18 = 65 bajtów

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

Wypróbuj online!

C # (.NET Core), 82 bajty

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

Wypróbuj online!

Perl 6 , 34 28 bajtów

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

Wypróbuj online!

Swift 3, 81 79 bajtów

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

Swift ma interesującą właściwość polegającą na tym, że Int nie może być bezpośrednio rzucany na a Double, więc musisz podać dowolne tablice jako tablice Doubles przed przekazaniem ich do funkcji.

(na przykład) var k:[Double] = [1,2,3,4,5,5,7,8,9,10]

Edycja: -2 bajty dzięki @EriktheOutgolfer

DO, 76 75 bajtów

Dzięki @Kevin Cruijssen za uratowanie bajtu!

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

Wypróbuj online!

Japt , 13 bajtów

íV,È¥Y Ä *XwY

Wypróbuj online! z -Qflagą, aby sformatować tablicę wyjściową.

Rdza , 107 97 bajtów

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

Wypróbuj online!

Zaoszczędź 8 bajtów dzięki @mgc

Swift 4 , 41 bajtów

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

Przypadki testowe:

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