Bạn sẽ được cung cấp hai mảng số dấu phẩy động. Nhiệm vụ của bạn là ghép các phần tử tương ứng của hai mảng và lấy tối đa của mỗi cặp. Tuy nhiên , nếu hai yếu tố tương ứng bằng nhau, bạn phải lấy tổng của chúng thay thế.

Ví dụ, đưa ra các danh sách [1, 3, 3.2, 2.3]và [3, 1, 3.2, 2.6], bạn phải làm như sau:

• Ghép nối các yếu tố (hoặc zip) : [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]].

• Đi qua từng cặp và áp dụng quy trình trên : [3, 3, 6.4, 2.6].

Thông số kỹ thuật

• Các mảng / danh sách sẽ luôn có độ dài bằng nhau. Họ có thể trống.

• Các số họ chứa sẽ luôn phù hợp với khả năng ngôn ngữ của bạn, miễn là bạn không lạm dụng điều đó. Chúng có thể là dương, bằng 0 hoặc âm, bạn phải xử lý tất cả các loại.

• Nếu nó giúp bạn giảm số byte của bạn, bạn cũng có thể lấy độ dài của danh sách làm đầu vào.

Quy tắc

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
• Quy tắc đầu vào và đầu ra tiêu chuẩn được áp dụng. Bạn có thể lấy đầu vào (và đầu ra) ở bất kỳ định dạng hợp lý nào.
• Lỗ hổng mặc định bị cấm.

Các trường hợp thử nghiệm

Mảng_1, Mảng_2 -> Đầu ra

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

Thạch, 4 byte

=‘×»

Hãy thử trực tuyến!

Điều này sử dụng cách tiếp cận chính xác như câu trả lời APL của tôi , ngoại trừ Jelly có tích hợp để thêm một vào một số!

Kotlin, 78 75 71 66 65 59 byte

Đó là nỗ lực đầu tiên của tôi, thật tuyệt: D

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

TIO không hoạt động với giải pháp này (và tôi không biết tại sao), mã nguồn để thử nghiệm bên dưới

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

CHỈNH SỬA:

-3 bằng cách thay thế "a + b [i]" bằng "a * 2"

-4 bằng cách thay thế phương thức "mapIndexed" bằng "zip" (Nhờ giải pháp @AnonymousReality Swift)

-5 bằng cách thay thế phương thức "Math.max" bằng khi có điều kiện

-1 bằng cách thay đổi khi thứ tự điều kiện

-6 bằng cách thay đổi thànhFloatArray () bởi toList ()

Python 2 , 45 byte

Một kết hợp của giải pháp ban đầu của tôi và @ovs ' .

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

Hãy thử trực tuyến!

Python 2 , 49 byte

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

Hãy thử trực tuyến!

Python 2 , 46 byte

@ovs đề xuất phương pháp này để tiết kiệm 3 byte.

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

Hãy thử trực tuyến!

Làm sao?

Trước hết, chúng tôi ghép các phần tử tương ứng, bằng cách sử dụng *hoặc zip(). Điều đó cho phép chúng tôi chơi gôn hơn nữa bằng cách làm việc với bản đồ hoặc hiểu danh sách.

Thủ thuật hay trong câu trả lời này là phần này : max(x,y)*-~(x==y). Làm thế nào mà làm việc? - Vâng, như hầu hết các bạn đã biết, Python tự động chuyển đổi các giá trị bool thành số nguyên khi chúng được sử dụng trong các phép toán số học. Do đó, (x==y)được đánh giá là 1, nếu điều kiện được đáp ứng. Tuy nhiên, nếu hai giá trị không bằng nhau, nó sẽ trả về 0. Sau đó, hoạt động bitwise -~tăng giá trị được trả về từ bool bằng cách 1, cho chúng ta 2hoặc 1. max(a,b)đưa ra giá trị tối đa của cặp và *nhân nó với giá trị được trả về ở trên (để nó được nhân với 2chỉ khi chúng bằng nhau, trong trường hợp này max()trả về giá trị của cả hai).

Điều này dựa trên thực tế là tổng của hai số bằng nhau trên thực tế là một trong số chúng nhân đôi và loại "lạm dụng" lớp bool của Python là một lớp con của int.

JavaScript (ES6), 53 49 45 43 byte

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

• 4 byte được lưu bằng cách mượn một mẹo từ ông Xcoder.
• 2 byte được lưu nhờ Arnauld.

Thử nó

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>

Giải trình

a=>b=>

Hàm ẩn danh lấy 2 mảng làm đối số thông qua các tham số avà b, theo cú pháp currying (nghĩa là gọi vớif(a)(b)

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

Ánh xạ qua mảng đầu tiên, chuyển từng phần tử qua một hàm trong đó xlà phần tử hiện tại và ylà chỉ mục hiện tại.

(y=b[y])

Lấy phần tử tại chỉ mục ytrong mảng thứ hai và gán nó làm giá trị mới của y.

>x?y

Kiểm tra nếu ylớn hơn xvà, nếu vậy, trở lại y.

:y<x?x

Khác, kiểm tra nếu yít hơn xvà, nếu vậy, trở lạix

:x+y

Khác, trả lại tổng của xvà y. (Nhân xhoặc ybằng 2 cũng sẽ hoạt động ở đây, với cùng số byte.)

Haskell, 34 byte

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

Hãy thử trực tuyến.

R , 31 29 byte

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

pmax lấy tối đa song song của hai (hoặc nhiều) mảng (tái chế ngắn hơn nếu cần).

Tôi đã xem xét nhận xét của Luis Mendo và rõ ràng tôi nhận ra cách tiếp cận cũng có thể hiệu quả với R. Đó đã cho tôi tới 30 byte, nhưng sau đó tôi bắt đầu chơi xung quanh với nhiều cách khác nhau để nhận được các chỉ số thay vì để cải thiện câu trả lời ban đầu của tôi, và tình cờ gặp !a-bnhư TRUEnơi a==bvà FALSEbằng cách khác, tương đương với a==b. Tuy nhiên, vì bất kỳ lý do gì, R không yêu cầu dấu ngoặc đơn !a-bnhư vậy a==b, điều này giúp tôi tiết kiệm được hai byte.

Như JDL đã đề cập trong các bình luận , điều này hoạt động vì !(phủ định) có độ ưu tiên thấp hơn toán tử nhị phân -trong R, điều này là lạ.

Hãy thử trực tuyến! (phiên bản mới)

Hãy thử trực tuyến! (nguyên)

Python 3 , 48 46 44 byte

-2 byte nhờ @nwellnhof

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

Hãy thử trực tuyến!

APL Dyalog, 5 byte

⌈×1+=

Hãy thử trực tuyến!

Làm sao?

• ⌈, tối đa yếu tố khôn ngoan của các đối số
• ×, nhân phần tử khôn ngoan
• 1+=, 1 được thêm vào tính bằng nhau của phần tử

Điều này hoạt động bởi vì nếu các số là không bằng nhau, 1+=sẽ được 1, khi nhân với tối đa, là tối đa. Khi các số bằng nhau, 1+=sẽ trả về 2, khi số đó được nhân với mức tối đa, chúng tôi nhận được gấp đôi mức tối đa hoặc tối đa được thêm vào chính nó.

Thạch , 6 byte

żSṀE?€

Một liên kết dyadic lấy một danh sách các số ở mỗi bên và trả về danh sách kết quả.

Hãy thử trực tuyến! hoặc xem một bộ thử nghiệm *.

Làm sao?

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

Một cách khác là liên kết đơn âm này lấy một danh sách gồm hai danh sách, cũng có 6 byte :

+»⁼?"/

* Tôi không nghĩ rằng tôi đã từng tạo một chân trang của bộ thử nghiệm gần gấp ba lần số byte của mã trước đó!

05AB1E , 5 byte

øεMÃO

Hãy thử trực tuyến!

-1 cảm ơn Emigna .

MATL , 7 byte

X>tG=s*

Đầu vào là một ma trận hai hàng, trong đó mỗi hàng là một trong các mảng.

Hãy thử trực tuyến!

Giải trình

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 byte

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

Thay đổi mảng đầu vào thứ hai thay vào đó hoặc trả về một mảng float mới để lưu byte.

-11 byte bằng cách lấy độ dài làm đầu vào số nguyên bổ sung, được phép theo quy tắc thách thức.
-5 byte nhờ @ OliverGrégoire (một byte mỗi lần .. xD)
-1 byte gián tiếp nhờ vào câu trả lời JS của @Shaggy , bằng cách sử dụng a[l]*2thay vì a[l]+b[l].

Giải trình:

Hãy thử nó ở đây.

(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

Bình thường , 11 byte

m*eSdhnd{dC

Hãy thử nó ở đây!

Bình thường , 12 byte

m*eSdhqhdedC

Hãy thử nó ở đây!

hoặc là

m*eSdh!tl{dC

Hãy thử nó ở đây!

05AB1E , 9 8 7 byte

Đã lưu một byte khi Erik Outgolfer chỉ ra rằng một danh sách các danh sách là đầu vào hợp lệ.

øεMsËi·

Hãy thử trực tuyến!

Giải trình

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

Toán học, 31 byte

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

J, 7 byte

>.`+@.=

Hãy thử trực tuyến!

Lấy một danh sách làm đối số bên trái và danh sách còn lại là bên phải.

May mắn thay, bình đẳng là một hoạt động không có thứ hạng.

Giải trình

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

@.không thực sự là một câu lệnh if, nhưng trong trường hợp này, nó hoạt động như một câu lệnh (nó lập chỉ mục vào gerund >.`+dựa trên kết quả của đối số đúng của nó và áp dụng điều đó cho đầu vào).

Ruby , 42 byte

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

Hãy thử trực tuyến!

Các nhà điều hành tàu vũ trụ là tuyệt vời.

TI-Basic, 23 21 byte

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

Danh sách quá xấu chiếm hai byte mỗi ...

Octave, 36 Byte

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

Bình thường, 7 byte

ms.MZdC

Hãy thử nó ở đây.

Trăn 3 , 49 46 45 byte

3 byte bị xóa nhờ @ Mr.Xcoder (splat thay vì hai đối số) và 1 byte nhờ @ovs (ánh xạ thay vì hiểu danh sách)

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

Hãy thử trực tuyến!

Lisp thường gặp, 60 59 byte

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

Hãy thử trực tuyến!

-1 byte nhờ @ Zacharý!

Python với numpy, 28 byte

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

Giả sử đầu vào được đưa ra dưới dạng hai mảng numpy.

C # (.NET Core) , sử dụng Linq 47 + 18 = 65 byte

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

Hãy thử trực tuyến!

C # (.NET Core), 82 byte

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

Hãy thử trực tuyến!

Perl 6 , 34 28 byte

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

Hãy thử trực tuyến!

Swift 3, 81 79 byte

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

Swift có một thuộc tính thú vị ở chỗ một Int không thể truyền trực tiếp đến a Double, vì vậy bạn phải chỉ định bất kỳ mảng nào là mảng của Doubles trước khi chuyển chúng vào hàm.

(ví dụ) var k:[Double] = [1,2,3,4,5,5,7,8,9,10]

Chỉnh sửa: -2 byte nhờ @EriktheOutgolfer

C, 76 75 byte

Cảm ơn @Kevin Cruijssen vì đã tiết kiệm một byte!

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

Hãy thử trực tuyến!

Japt , 13 byte

íV,È¥Y Ä *XwY

Hãy thử trực tuyến!với -Qcờ để định dạng mảng đầu ra.

Rust , 107 97 byte

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

Hãy thử trực tuyến!

Đã lưu 8 byte nhờ @mgc

Swift 4 , 41 byte

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

Các trường hợp thử nghiệm:

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