부동 소수점 숫자로 구성된 두 개의 배열이 제공됩니다. 당신의 임무는 두 배열의 해당 요소를 페어링하고 각 쌍의 최대 값을 얻는 것입니다. 그러나 두 개의 해당 요소가 같으면 대신 합계를 가져와야합니다.

예를 들어, 목록을 제공 [1, 3, 3.2, 2.3]하고 [3, 1, 3.2, 2.6]당신이 다음을 수행해야합니다 :

• 요소 (또는 zip)를 페어링하십시오 [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]].

• 각 쌍을 살펴보고 위의 프로세스를 적용하십시오 [3, 3, 6.4, 2.6].

명세서

• 배열 / 목록의 길이는 항상 같습니다. 그러나 비어있을 수 있습니다.

• 그들이 포함하는 숫자는 당신이 그것을 남용하지 않는 한, 당신의 언어 능력에 항상 맞을 것입니다. 그들은 양수, 제로 또는 음수 일 수 있습니다. 모든 유형을 처리해야합니다.

• 바이트 수를 줄이는 데 도움이 되는 경우 목록의 길이를 입력으로 사용할 수도 있습니다.

규칙

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
• 표준 입력 및 출력 규칙이 적용됩니다. 합리적인 형식으로 입력 및 출력 할 수 있습니다.
• 기본 허점 은 금지되어 있습니다.

테스트 사례

Array_1, Array_2-> 출력

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

젤리, 4 바이트

=‘×»

온라인으로 사용해보십시오!

이것은 젤리가 숫자에 1을 더하기위한 내장 기능이 있다는 것을 제외하고 는 내 APL 답변 과 똑같은 접근법을 사용합니다 !

코 틀린, 78 75 71 66 65 59 바이트

내 첫 번째 시도, 멋지다 : D

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

TIO는이 솔루션에서 작동하지 않으며 (및 이유를 모르겠습니다) 아래 테스트 소스 코드

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

편집하다:

"a + b [i]"를 "a * 2"로 바꾸면 -3

"mapIndexed"메소드를 "zip"으로 바꾸면 -4 (@AnonymousReality Swift 솔루션 덕분)

조건에 따라 "Math.max"방법을 대체하여 -5

조건 순서 변경시 -1

toList ()에 의해 FloatArray ()로 변경하여 -6

파이썬 2 , 45 바이트

내 초기 솔루션과 @ovs ' 의 혼합 .

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

온라인으로 사용해보십시오!

파이썬 2 , 49 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 46 바이트

@ovs 는이 방법을 제안하여 3 바이트를 절약했습니다.

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

온라인으로 사용해보십시오!

어떻게?

먼저 *또는 중 하나를 사용하여 해당 요소를 페어링합니다 zip(). 이를 통해지도 또는 목록 이해력으로 작업하여 추가 골프를 할 수 있습니다.

이 답변의 멋진 요령은이 부분 max(x,y)*-~(x==y)입니다. 어떻게 작동합니까? -대부분의 아시다시피, 파이썬은 부울 값을 산술 연산에 사용될 때 정수로 자동 변환합니다. 따라서 조건이 충족 (x==y)되면로 평가됩니다 1. 그러나 두 값이 같지 않으면 0대신 반환 됩니다. 그런 다음, 비트 연산의 -~단위는 값으로 부울에서 반환 1하거나 우리를주고, 2또는 1. max(a,b)쌍의 최대 값을 제공하고 *위에 리턴 된 값을 곱합니다 (따라서 2동일한 경우에만 곱함 ,이 경우 max()둘 다의 값을 리턴 함).

이것은 두 개의 동일한 숫자의 합이 실제로 두 배가되고, 파이썬의 부울 클래스가 int의 서브 클래스 인 "거품"이라는 사실에 근거합니다.

자바 스크립트 (ES6), 53 49 45 43 바이트

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

• Mr. Xcoder의 트릭을 빌려 4 바이트가 절약되었습니다.
• Arnauld 덕분에 2 바이트가 절약되었습니다.

시도 해봐

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=>b=>

익명 함수 매개 변수를 통해 인수로 두 배열을 복용 a하고 b, 즉, 호출 (구문을 무두질에,f(a)(b)

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

첫 번째 배열에 맵핑 x하여 현재 요소와 y현재 색인 인 함수를 통해 각 요소를 전달 하십시오.

(y=b[y])

y두 번째 배열의 인덱스 에 있는 요소를 가져 와서 새 값으로 할당하십시오 y.

>x?y

y보다 큰지 확인 x하고, 더 큰 경우를 반환하십시오 y.

:y<x?x

그 밖에, 체크하면 y미만이며 x, 반환하고, 만약 그렇다면x

:x+y

그렇지 않으면 x및 의 합을 구하십시오 y. ( 동일한 바이트 수에 대해 x또는 y2를 곱해 도 여기에서 작동합니다.)

하스켈, 34 바이트

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

온라인으로 사용해보십시오.

R , 31 29 바이트

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

pmax 두 개 이상의 어레이의 병렬 최대 값을 가져옵니다 (필요에 따라 더 짧게 재활용).

나는 Luis Mendo의 의견 을보고 있었고 분명히 R에 대해서도 접근 방식이 효과적이라는 것을 깨달았습니다. 30 바이트로 저를 얻었으나, 나는 내 원래 대답을 개선하기 위해 대신 인덱스를 얻기의 다른 방법으로 주위를 연주하기 시작하고, 우연히 그 !a-b와 같은 TRUE곳 a==b과 FALSE에, 그렇지 않으면 해당 a==b. 그러나 어떤 이유로 든 R은와 !a-b같이 괄호를 필요로하지 않으므로 a==b2 바이트가 절약되었습니다.

주석에서 JDL이 언급했듯이 !(음수)는 -R 의 이진 연산자보다 우선 순위가 낮기 때문에 작동합니다 .

온라인으로 사용해보십시오! (새로운 버전)

온라인으로 사용해보십시오! (기발한)

파이썬 3 , 48 46 44 바이트

@nwellnhof 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

Dyalog APL, 5 바이트

⌈×1+=

온라인으로 사용해보십시오!

어떻게?

• ⌈, 요소 별 최대 인수
• ×, 요소 별 곱셈
• 1+=, 1 인수의 요소 별 같음에 추가

숫자가 동일하지 않은 경우, 때문에이 작동 1+=될 것입니다 1최대 곱하면, 최대이다. 숫자가 같으면1+=2 최대 값을 곱한 값을 반환 하여 최대 값의 두 배 또는 최대 값을 얻습니다.

젤리 , 6 바이트

żSṀE?€

각 측면의 숫자 목록을 가져와 결과 목록을 반환하는 2 진 링크.

온라인으로 사용해보십시오! 또는 참조 테스트 슈트 *를 .

어떻게?

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

다른 방법으로는이 모나 딕 링크 가 두 목록의 목록 ( 6 바이트)을 가져 오는 것입니다 .

+»⁼?"/

* 테스트 바이트 바닥 글을 코드 바이트 수의 거의 3 배로 만든 적이 없다고 생각합니다!

05AB1E , 5 바이트

øεMÃO

온라인으로 사용해보십시오!

Emigna 에게 -1 감사합니다 .

MATL , 7 바이트

X>tG=s*

입력은 2 행 행렬로, 각 행은 배열 중 하나입니다.

온라인으로 사용해보십시오!

설명

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

자바 8, 80 69 67 66 65 64 63 바이트

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

대신 두 번째 입력 배열을 수정하거나 새 float 배열을 반환하여 바이트를 저장합니다.

챌린지 규칙에 따라 허용되는 추가 정수 입력으로 길이를 가져 와서 -11 바이트.
-5 덕분 바이트 @ OliverGrégoire (한 번에 하나의 xD .. 바이트)
-1 바이트 간접적 확실히 @Shaggy 의 JS 응답 하여, a[l]*2대신a[l]+b[l] .

설명:

여기에서 시도하십시오.

(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 바이트

m*eSdhnd{dC

여기 사용해보십시오!

Pyth , 12 바이트

m*eSdhqhdedC

여기 사용해보십시오!

또는

m*eSdh!tl{dC

여기 사용해보십시오!

05AB1E , 9 8 7 바이트

Outgolfer Erik이 목록 목록이 유효한 입력 임을 지적하면서 바이트를 저장했습니다 .

øεMsËi·

온라인으로 사용해보십시오!

설명

ø          # 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 바이트

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

J, 7 바이트

>.`+@.=

온라인으로 사용해보십시오!

한 목록은 왼쪽 인수로, 다른 목록은 오른쪽 인수로 사용합니다.

다행히 평등은 랭크 제로 연산입니다.

설명

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

@.아닌 정말 if 문하지만이 경우에는 한 (동명사로 지수 함수로 >.`+오른쪽 인수의 결과를 기초로하고 그 입력에 적용).

루비 , 42 바이트

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

온라인으로 사용해보십시오!

우주선 연산자는 훌륭합니다.

TI 기본, 23 21 바이트

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

너무 나쁜 목록은 각각 2 바이트를 차지합니다 ...

옥타브, 36 바이트

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

Pyth, 7 바이트

ms.MZdC

여기에서 시도하십시오.

파이썬 3 , 49 46 45 바이트

@ Mr.Xcoder로 인해 3 바이트가 제거되고 (두 개의 인수 대신 표시) @ovs로 인해 1 바이트가 제거됨 (목록 이해 대신 맵)

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

온라인으로 사용해보십시오!

일반적인 Lisp, 60 59 바이트

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

온라인으로 사용해보십시오!

@ Zacharý 덕분에 -1 바이트!

numpy, 28 바이트의 Python

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

입력이 두 개의 numpy 배열로 주어진다고 가정합니다.

Linq 47 + 18 = 65 바이트를 사용하는 C # (. NET Core)

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

온라인으로 사용해보십시오!

C # (. NET 코어), 82 바이트

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

온라인으로 사용해보십시오!

펄 6 , 34 28 바이트

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

온라인으로 사용해보십시오!

스위프트 3, 81 79 바이트

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

Swift는 Int를로 직접 캐스트 할 수 없다는 흥미로운 속성 Double을 가지고 있으므로 배열을 배열로 지정해야합니다.Double 함수로 전달하기 전에 s .

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

편집 : @EriktheOutgolfer 덕분에 -2 바이트

C, 76 75 바이트

바이트를 저장해 준 @Kevin Cruijssen에게 감사합니다!

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

온라인으로 사용해보십시오!

apt , 13 바이트

íV,È¥Y Ä *XwY

온라인으로 사용해보십시오! -Q출력 배열을 형식화 하는 플래그 와 함께 .

녹 , 107 97 바이트

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

온라인으로 사용해보십시오!

@mgc 덕분에 8 바이트 절약

스위프트 4 , 41 바이트

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

테스트 사례 :

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