Ottieni il meglio da due array

19

Ti verranno dati due array di numeri in virgola mobile. Il tuo compito è accoppiare gli elementi corrispondenti dei due array e ottenere il massimo di ciascuna coppia. Tuttavia , se i due elementi corrispondenti sono uguali, devi invece prendere la loro somma.

Ad esempio, dati gli elenchi [1, 3, 3.2, 2.3]e [3, 1, 3.2, 2.6], è necessario effettuare le seguenti operazioni:

  • Associare gli elementi (o ZIP): [[1, 3], [3, 1], [3.2, 3.2], [2.3, 2.6]].

  • Passare attraverso ogni coppia e applicare il processo di cui sopra: [3, 3, 6.4, 2.6].

Specifiche

  • Le matrici / liste avranno sempre la stessa lunghezza. Possono tuttavia essere vuoti.

  • I numeri che contengono si adatteranno sempre alle capacità della tua lingua, purché tu non l'abuso. Possono essere positivi, zero o negativi, è necessario gestire tutti i tipi.

  • Se aiuta a ridurre il numero di byte, si può anche prendere la lunghezza delle liste come input.

Regole

Casi test

Array_1, Array_2 -> Output

[], [] -> []
[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]
code-golf  math  number  array-manipulation 
Dici che i numeri si adatteranno sempre "alle" capacità "della tua lingua. Fintanto che non lo" abusi ". Il supporto di numeri interi in una lingua che non ha float sarà considerato un abuso? La domanda dice in virgola mobile ma non vedo davvero un motivo per cui debba essere float. Lo stesso processo può essere fatto su numeri interi. Vorrei risolverlo in Brain-Flak ma Brain-flak supporta solo gli ints
— Wheat Wizard
@WheatWizard Posso fare un'eccezione per questo. Vai avanti e pubblica la tua risposta e menziona che ho permesso di evitare confusione.

Risposte:

8

Gelatina, 4 byte

=‘×»

Provalo online!

Questo utilizza lo stesso identico approccio della mia risposta APL , tranne per il fatto che Jelly ha un metodo integrato per aggiungerne uno a un numero!

— Zaccaria
fonte
Odio essere un guastafeste, ma alcuni di questi caratteri non sono più di un byte ciascuno in una codifica sensata?
— Cedric Knight il
Questo utilizza la tabella codici gelatina .
— Zacharý,
Finalmente ho vinto contro la concorrenza!
— Zacharý,
2
@ ZACHARY un uomo, 4 btytes ... QUESTA ESTATE ... Tu ... sarà ... ESSERE ... PAPPA DI LUI ... nominale J per Jelly .
— Magic Octopus Urn,
11

Kotlin, 78 75 71 66 65 59 byte

È il mio primo tentativo, sii calmo: D

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

TIO non funziona con questa soluzione (e non so perché), codice sorgente per i test di seguito

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

MODIFICARE:

-3 sostituendo "a + b [i]" con "a * 2"

-4 sostituendo il metodo "mapIndexed" con "zip" (grazie alla soluzione @AnonymousReality Swift)

-5 sostituendo il metodo "Math.max" con quando la condizione

-1 per modifica quando l'ordine delle condizioni

-6 mediante modifica a FloatArray () di toList ()

— Valentin Michalak
fonte
10
Benvenuti in PPCG! Si prega di non essere scoraggiati dal downvote (è il risultato di una leggera stranezza del sistema che si verifica quando il primo post di un nuovo utente viene contrassegnato automaticamente per qualità e quindi migliorano detto post !!)
— Jonathan Allan,
2
La peggior "caratteristica" di sempre ... a proposito non mi dispiace.
— Erik the Outgolfer,
10

Python 2 , 45 byte

Un mix tra la mia soluzione iniziale e @ovs ' .

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

Provalo online!

Python 2 , 49 byte

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

Provalo online!

Python 2 , 46 byte

@ovs ha suggerito questo metodo per salvare 3 byte.

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

Provalo online!

Come?

Prima di tutto, accoppiamo gli elementi corrispondenti usando *ozip() . Ciò ci consente di continuare a giocare a golf lavorando con una mappa o una comprensione dell'elenco.

Il trucco fresco in questa risposta è questa parte: max(x,y)*-~(x==y). Come funziona? - Bene, come molti di voi già sanno, Python converte automaticamente i valori boolici in numeri interi quando vengono utilizzati in operazioni aritmetiche. Quindi, (x==y)viene valutato come 1se la condizione è soddisfatta. Tuttavia, se i due valori non sono uguali, restituisce 0invece. Quindi, l'operazione bit a bit -~incrementa il valore restituito dal bool di 1, dandoci o 2o 1. max(a,b)dà il valore massimo della coppia e lo *moltiplica per il valore restituito sopra (quindi viene moltiplicato 2solo se sono uguali, nel qual caso max()restituisce il valore di entrambi).

Questo si basa sul fatto che la somma di due numeri uguali è in realtà uno dei due raddoppiati e che il tipo di "abusi" della classe bool di Python è una sottoclasse di int.

— Mr. Xcoder
fonte
Wow, è stato davvero veloce!
più semplice, stesso numero di byte:lambda*a:map(lambda x,y:(x<=y)*y+(x>=y)*x,*a)
— jferard,
@jferard In effetti, questa è già la soluzione di Luis.
— Mr. Xcoder,
@ Mr.Xcoder Oops! Non ho letto l'intera pagina ...
— jferard,
Non dire mai "sopra", poiché l'ordinamento può cambiare (non vedo la tua soluzione sopra)
— Zacharý
8

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 salvati prendendo in prestito un trucco dal signor Xcoder.
  • 2 byte salvati grazie ad Arnauld.

Provalo

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>
Espandi frammento

Spiegazione

a=>b=>

Funzione anonima che accetta i 2 array come argomenti tramite parametri ae b, nella sintassi del curry (cioè, chiama conf(a)(b)

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

Mappa sopra il primo array, passando ciascun elemento attraverso una funzione in cui xè l'elemento corrente ed yè l'indice corrente.

(y=b[y])

Ottieni l'elemento all'indice ynel secondo array e assegnalo come nuovo valore di y.

>x?y

Controlla se yè maggiore di xe, in tal caso, ritorna y.

:y<x?x

Altrimenti, controlla se yè inferiore xe, in tal caso, ritornax

:x+y

Altrimenti, restituisce la somma di xe y. (Anche qui moltiplicare xo yper 2 funzionerebbe, per lo stesso numero di byte.)

— ispido
fonte
j.value.split`,`.map(eval)o eval('['+j.value+']')? Inoltre x+ysembrerebbe più pulito IMHO.
— Neil,
@Neil: 1) Trovo il primo più facile da scrivere. Inoltre, ho un paio di modelli di frammenti su una delle mie macchine; è più facile attaccarli .map(eval). 2) Concordato, modificherà momentaneamente.
— Shaggy,
7

R , 31 29 byte

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

pmax prende il massimo parallelo dei due (o più) array (riciclando il più corto secondo necessità).

Stavo guardando il commento di Luis Mendo e ovviamente mi sono reso conto che l'approccio poteva funzionare anche per R. Questo mi ha fatto a 30 byte, ma poi ho iniziato a suonare in giro con diversi modi di ottenere indici, invece di migliorare la mia risposta originale, e inciampato su !a-bcome TRUE, dove a==be FALSEin caso contrario, equivalente a a==b. Tuttavia, per qualsiasi motivo, R non richiede parentesi !a-bcome fa a==b, il che mi ha salvato due byte.

Come menzionato da JDL nei commenti , questo funziona perché !(negazione) ha una precedenza inferiore rispetto all'operatore binario -in R, il che è strano.

Provalo online! (nuova versione)

Provalo online! (originale)

— Giuseppe
fonte
Si scopre che unario "!" ha una precedenza inferiore in R rispetto al binario "-", che penso sia abbastanza insolito (e non me ne ero reso conto fino a quando non ho letto questa risposta!)
— JDL
@JDL sì, quasi sempre devo aprire la pagina Sintassi R mentre gioco a golf in caso di strane stranezze come questa ... e anche perché non riesco mai a ricordare la precedenza di :quando interagisco con l'aritmetica.
— Giuseppe,
6

Dyalog APL, 5 byte

⌈×1+=

Provalo online!

Come?

  • ⌈, massimo elemento degli argomenti
  • ×, moltiplicare gli elementi
  • 1+=, 1 aggiunto alla parità di elementi degli argomenti

Questo funziona perché se i numeri non sono uguali, 1+=sarà 1, che quando moltiplicato per il massimo, è il massimo. Quando i numeri sono uguali, 1+=tornerà 2, quando questo viene moltiplicato per il massimo, otteniamo il doppio del massimo o il massimo aggiunto a se stesso.

— Zaccaria
fonte
5

Gelatina , 6 byte

żSṀE?€

Un collegamento diadico che prende un elenco di numeri su ciascun lato e restituisce l'elenco risultante.

Provalo online! o vedi una suite di test *.

Come?

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

Un'alternativa è questo collegamento monadico che prende un elenco dei due elenchi, anche 6 byte :

+»⁼?"/

* Non credo di aver mai creato un piè di pagina della suite di test quasi tre volte il conteggio dei byte del codice prima!

— Jonathan Allan
fonte
Outgolfed! . +1 per l'interpretazione praticamente letterale della domanda.
— Zacharý,
... e sono stato sorpreso a dimenticare che i »vettori prima!
— Jonathan Allan,
Cos'altro farebbe, prendere l'array massimo in qualche modo contorto?
— Zacharý,
Non sono necessarie definizioni contorte, Python gestisce, ad esempio max([1,1,0],[1,0,3]) -> [1,1,0](non [1,1,3]).
— Jonathan Allan,
Quindi, praticamente una base infinita?
— Zacharý,
4

MATL , 7 byte

X>tG=s*

L'input è una matrice a due righe, in cui ogni riga è una delle matrici.

Provalo online!

Spiegazione

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
— Luis Mendo
fonte
4

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

Modifica invece il secondo array di input o restituisce un nuovo array float per salvare byte.

-11 byte prendendo la lunghezza come input intero aggiuntivo, che è consentito secondo le regole di sfida.
-5 byte grazie a @ OliverGrégoire (un byte alla volta .. xD)
-1 byte indirettamente grazie alla risposta JS di @Shaggy , usando a[l]*2invece di a[l]+b[l].

Spiegazione:

Provalo qui.

(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
— Kevin Cruijssen
fonte
2
"Se ti aiuta a ridurre il conteggio dei byte, puoi anche prendere la lunghezza degli elenchi come input." Ridurrà sicuramente il numero di byte;)
— Olivier Grégoire,
1
Inoltre, 2 byte in meno:a->b->l->{float A,B;for(;l-->0;b[l]=(A=a[l])<B?B:A>B?A:A+B)B=b[l];}
— Olivier Grégoire il
E puoi salvare un altro byte inserendo float A, Bl' forinizializzazione.
— Olivier Grégoire,
1
O questo: (a,b,l)->{for(;l-->0;)if(a[l]>=b[l])b[l]=a[l]*(a[l]>b[l]?1:2);}(63 byte)
— Olivier Grégoire,
3
@ OlivierGrégoire Lol .. con il golf ogni byte aiuta, ma ciò non significa che devi golf un byte alla volta. ; p
— Kevin Cruijssen,
3

05AB1E , 9 8 7 byte

Salvato un byte come Erik Outgolfer ha sottolineato che un elenco di elenchi è un input valido.

øεMsËi·

Provalo online!

Spiegazione

ø          # 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
— Emigna
fonte
Wow, è stato davvero veloce!
È possibile salvare un byte rimuovendo ‚e inserendo come coppia di un elenco e un elenco.
— Erik the Outgolfer,
@EriktheOutgolfer: True. Ho pensato che non ci fosse permesso, ma vedo che la sfida specifica le regole I / O standard. Grazie per aver avvisato :)
— Emigna,
1
@Emigna Tip: non impazzire dalle regole;)
— Erik the Outgolfer,
1
@EriktheOutgolfer: Sì, ho davvero bisogno di smettere di farlo. Soprattutto le regole che allungano i miei programmi;)
— Emigna,
3

J, 7 byte

>.`+@.=

Provalo online!

Accetta un elenco come argomento sinistro e l'altro come diritto.

Fortunatamente, l'uguaglianza è un'operazione di grado zero.

Spiegazione

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

@.non è in realtà un'istruzione if, ma in questo caso funziona come tale (si indicizza nel gerundio in >.`+base al risultato del suo giusto argomento e lo applica all'input).

— ravizzone
fonte
Nice job, I know I couldn't do this, even though you have beenoutgolfed by my translation of my APL. >_<
— Zacharý
J really shines here
— Jonah
@Zacharý rats, well-golfed nonetheless.
— cole
3

TI-Basic, 23 21 bytes

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

Too bad lists take up two bytes each...

— Timtech
fonte
You can save two bytes by prompting for X and Y, then using ʟX and ʟY to access them, i.e. "Prompt X,Y:ʟX(ʟX=ʟY)+max(ʟ1,ʟ2".
— Scott Milner
Also, this is currently invalid, since L1(L1=L2) attempts to get the element of L1 at a list, which throws an error. To fix that, swap the order, i.e. (L1=L2)L1.
— Scott Milner
@ScottMilner Thanks for pointing both of those out.
— Timtech
2

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ý!

— Renzo
fonte
59 bytes: (mapcar(lambda(x y)(*(max x y)(if(= x y)2 1)))(read)(read)).
— Zacharý
You're welcome, I don't know lisp that well, I just translated my other answers into Lisp which ended up saving a byte.
— Zacharý
2

Python with numpy, 28 bytes

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

Assumes input is given as two numpy arrays.

If we are using numpy then here is my worse solution: lambda a,b:n.fmax(a,b)*((a==b)+1)
— Erich
@Erich I like the idea, but to do that I would need to import numpy as n. I get away without it here because it's implicit in the input.
I guess i'm a bit shaky on the explicit byte counting, often python answers are simply lambdas, when an actual implementation of an answer would require assigning it to something. for this reason I wonder if it is allowable to get away with an implicit import statement as well?
— Erich
@Erich In general, you can only refer to a variable n if you've defined n in your code, so imports must be explicit. By default, we allow functions or full programs as answers, which includes anonymous functions.
1
Well, this only needs input as numpy arrays, rather than importing numpy. But does this even work without using return?
— Zacharý
2

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!

— Dennis.Verweij
fonte
You can drop the LINQ answer by a few bytes by changing namespace System.LINQ to using System.LINQ
— jkelm
@jkelm yeah, I've been wondering if the 'using System;` is to be included or not like that, I guess not. I'll clean it up
— Dennis.Verweij
System.Linq is included in the "Visual C# Interactive Compiler". I am not totally sure about returning Array vs IList vs IEnumerable, but if all are eligible then you can get the byte count to 37 - tio.run/##Sy7WTS7O/…
— dana
1

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

— AnonymousReality
fonte
Do you need spaces around (x,y) and before ??
— Erik the Outgolfer
@EriktheOutgolfer The one before ? is needed because Swift would treat them as optional types instead of ternaries (which they aren't). The others aren't. Apart from that, this can be drastically golfed.
@EriktheOutgolfer - TheIOSCoder has already answered you partly, but you're right, you don't need the ones in the for loop, interesting!
— AnonymousReality
73 bytes: func n(a:[Float],b:[Float]){print(zip(a,b).map{$0==$1 ?2*$0:max($0,$1)})} (the float inaccuracies need not to be handled by default)
— Mr. Xcoder
Or 74 bytes: func n(a:[Float],b:[Float]){print(zip(a,b).map{($0==$1 ?2:1)*max($0,$1)})}
— Mr. Xcoder
1

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!

— Steadybox
fonte
1

Japt, 13 bytes

íV,È¥Y Ä *XwY

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

— Justin Mariner
fonte
Nicely done. I made 2 attempts at this earlier with both coming out at 17 bytes. I'd forgotten í could take a function as a second argument.
— Shaggy
1

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

— jferard
fonte
1
I guess you can save 8 bytes by using type inference on the collected Vec and by using the max method of f32s: |a:Vec<f32>,b:Vec<f32>|a.iter().zip(b).map(|(&x,y)|if x==y{x+y}else{x.max(y)}).collect::<Vec<_>>();
— mgc
1
@mgc Thanks! Type inference was a good idea, but in this case type alias is even shorter.
— jferard
1

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!")
}
— Alexander - Reinstate Monica
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.