İki kayan noktalı sayı dizisi verilecektir. Göreviniz iki dizinin karşılık gelen öğelerini eşleştirmek ve her bir çiftten maksimum değeri elde etmektir. Ancak , karşılık gelen iki öğe eşitse, toplamlarını almalısınız.

Örneğin, listeleri verilmiş [1, 3, 3.2, 2.3]ve [3, 1, 3.2, 2.6]aşağıdakileri yapmanız gerekir:

• Elemanları (ya da fermuar) eşleme: [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]].

• Her çift üzerinden gidin ve yukarıdaki işlemi uygulayın: [3, 3, 6.4, 2.6].

gözlük

• Diziler / listeler her zaman eşit uzunlukta olacaktır. Ancak bunlar boş olabilir.

• İçerdikleri sayılar, bunu kötüye kullanmadığınız sürece dilinizin yeteneklerine uyacaktır. Pozitif, sıfır veya negatif olabilirler, tüm türleri ele almalısınız.

• Eğer sizin bayt sayısını azaltmaya yardımcı oluyorsa olabilir ayrıca girdi olarak listelerin uzunluğunu alır.

kurallar

• Bu kod golf , bayt en kısa cevap kazanır.
• Standart giriş ve çıkış kuralları geçerlidir. Girdileri (ve çıktıları) makul herhangi bir biçimde alabilirsiniz.
• Varsayılan Loopholes yasaktır.

Test Durumları

Dizi_1, Dizi_2 -> Çıktı

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

Jöle, 4 bayt

=‘×»

Çevrimiçi deneyin!

Bu, APL cevabımla tamamen aynı yaklaşımı kullanır , ancak Jelly, bir sayıya bir tane eklemek için yerleşiktir!

Kotlin, 78 75 71 66 65 59 bayt

Bu benim ilk denemem, sakin ol: D

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

TIO bu çözüm ile çalışmıyor (ve nedenini bilmiyorum), aşağıdaki test için kaynak kodu

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

DÜZENLE:

-3 "a + b [i]" yerine "a * 2" yazarak

-4 "zip" ile "mapIndexed" yöntemini değiştirerek (@AnonymousReality Swift çözümü sayesinde)

-5 "Math.max" yöntemini koşuluna göre değiştirerek

-1 sipariş değiştiğinde değişiklik

-6 toFloatArray () ile toList () değiştirilerek

Python 2 , 45 bayt

Benim ilk çözüm ve @ovs ' bir karışımı .

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

Çevrimiçi deneyin!

Python 2 , 49 bayt

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

Çevrimiçi deneyin!

Python 2 , 46 bayt

@ovs bu yöntemi 3 bayt kaydetmek için önerdi.

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

Çevrimiçi deneyin!

Nasıl?

İlk önce, karşılık gelen öğeleri, * veyazip() . Bu, bir harita veya liste kavrayışı ile çalışarak daha fazla golf oynamamızı sağlar.

Bu cevap serin hüner bu kısmıdır: max(x,y)*-~(x==y). Bu nasıl çalışıyor? - Pek çoğunuzun zaten bildiği gibi, Python aritmetik işlemlerde kullanıldığında bool değerlerini tamsayılara otomatik olarak dönüştürür. Bu nedenle, koşulun karşılanması durumunda (x==y)değerlendirilir 1. Ancak, iki değer eşit değilse, bunun 0yerine geri döner . Daha sonra bitsel işlem , bize veya -~değerini 1vererek , bool'den döndürülen değeri artırır . çiftin maksimum değerini verir ve yukarıda döndürülen değerle çarpar (böylece21max(a,b)*2 yalnızca eşit olduklarında , bu durumda max()her ikisinin de değerini döndürür).

Bu, iki eşit sayının toplamının ya ikisinin ikiye katlanması ve Python'un bool sınıfının int'in bir alt sınıfı olması gibi bir çeşit "istismar" gerçeğine dayanmaktadır.

JavaScript (ES6), 53 49 45 43 bayt

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

• Bay Xcoder'dan bir numara ödünç alarak 4 bayt tasarruf etti.
• Arnauld sayesinde 2 bayt kurtardı.

Dene

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>

açıklama

a=>b=>

Anonim işlev, 2 diziyi parametrelerle ave bsözdiziminde (örn.f(a)(b)

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

Her öğeyi xgeçerli öğe ve ygeçerli dizin olan bir işlevden geçirerek ilk dizi üzerinden eşleyin.

(y=b[y])

yİkinci dizideki dizindeki öğeyi alın ve bunu yeni değeri olarak atayın y.

>x?y

Olmadığını kontrol edin ybüyükse xeğer öyleyse, iade ve y.

:y<x?x

Başka, ydaha küçük olup olmadığını kontrol edin xve eğer öyleyse, geri dönünx

:x+y

Aksi takdirde, xve öğelerinin toplamını döndürün y. ( Aynı sayıda bayt için burada çarpma xveya y2 ile çalışma işe yarar.)

Haskell, 34 bayt

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

Çevrimiçi deneyin.

R , 31 29 bayt

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

pmax iki (veya daha fazla) dizinin paralel maksimumunu alır (gerekirse daha kısa geri dönüşüm).

Luis Mendo'nun yorumuna bakıyordum ve açıkça yaklaşımın R için de işe yarayabileceğini fark ettim. Bu beni 30 bayta indirdi, ama sonra orijinal cevabımı iyileştirmek için endeksleri almanın farklı yollarıyla oynamaya başladım ve nerede ve aksi halde eşdeğer !a-bolarak tökezledim . Ancak, her ne sebeple olursa olsun, R, olduğu gibi parantez gerektirmez , bu da beni iki bayt kurtardı.TRUEa==bFALSEa==b!a-ba==b

JDL'nin yorumlarda belirtildiği gibi , bu işe yarar çünkü !(olumsuzluk) -garip olan R'deki ikili operatörden daha düşük önceliğe sahiptir .

Çevrimiçi deneyin! (Yeni sürüm)

Çevrimiçi deneyin! (Orijinal)

Python 3 , 48 46 44 bayt

@Nwellnhof sayesinde -2 bayt

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

Çevrimiçi deneyin!

Dyalog APL, 5 bayt

⌈×1+=

Çevrimiçi deneyin!

Nasıl?

• ⌈, bağımsız değişkenler için öğe bazında maksimum
• ×, element-wise çarpma
• 1+=, 1 argümanların element-eşitliğine eklendi

Sayılar eşit değilse, çünkü bu işler 1+=olacak 1maksimum ile çarpılarak zaman, maksimum sayıdan. Sayılar eşit olduğunda 1+=, geri döner 2, bu maksimumla çarpıldığında, maksimumun iki katı veya maksimumun kendisine eklenir.

Jöle , 6 bayt

żSṀE?€

Her iki taraftaki numaraların listesini alan ve sonuçta oluşan listeyi döndüren ikili bir bağlantı.

Çevrimiçi deneyin! veya bir test takımına bakın *.

Nasıl?

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

Bir alternatif, bu iki bağlantının , ayrıca 6 baytlık bir listeyi alan monadik bağlantıdır :

+»⁼?"/

* Daha önce kodun bayt sayısının neredeyse üç katı kadar bir test paketi altbilgisi oluşturduğumu sanmıyorum!

05AB1E , 5 bayt

øεMÃO

Çevrimiçi deneyin!

Emigna sayesinde -1 .

MATL , 7 bayt

X>tG=s*

Girdi, her satırın dizilerden biri olduğu iki sıralı bir matristir.

Çevrimiçi deneyin!

açıklama

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 bayt

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

Modifies the second input-array instead or returning a new float-array to save bytes.

Zorluk kurallarına göre izin verilen ek tamsayı girişi olarak uzunluğu alarak -11 bayt.
-5 sayesinde bayt @ OliverGrégoire (her seferinde .. xD bir bayt)
-1 bayt dolaylı sayesinde @Shaggy sitesindeki JS yanıt kullanarak a[l]*2yerinea[l]+b[l].

Açıklama:

Burada deneyin.

(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

Try it here!

Pyth, 12 bytes

m*eSdhqhdedC

Try it here!

or

m*eSdh!tl{dC

Try it here!

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

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

Common Lisp, 60 59 bytes

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

Try it online!

-1 byte thanks to @Zacharý!

Python with numpy, 28 bytes

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

Assumes input is given as two numpy arrays.

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

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

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

Try it online!

Perl 6, 34 28 bytes

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

Try it 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))}}

Swift has an interesting property in that an Int isn't directly castable to a Double, so you have to specify any arrays as being arrays of Doubles before passing them to the function.

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

Edit: -2 bytes thanks to @EriktheOutgolfer

C, 76 75 bytes

Thanks to @Kevin Cruijssen for saving a byte!

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

Try it online!

Japt, 13 bytes

íV,È¥Y Ä *XwY

Try it online! with the -Q flag to format the output array.

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

Try it online!

Saved 8 bytes thanks to @mgc

Swift 4, 41 bytes

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

Test cases:

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