Sentiamo spesso il linguaggio "camminare attraverso l'array" per indicare "mappare la funzione sull'array seguente". Tuttavia, ne ho bisogno (ora!), Quindi voglio che eseguiate l'array.

Come corro?

_{Immagina che ci sia un branco selvaggio di lupi dietro di te}

Correre in un array è come percorrerne uno, tranne che è possibile saltare elementi. Sì, a volte è disordinato, ma (in genere) funziona. "Quali elementi vengono ignorati?", Potresti chiedere. Bene, questo è fatto a caso. Camminiamo correndo attraverso l'array!

1. Lascia che esia l'elemento corrente.
2. Lascia randomgenerare un float casuale in [0,1). Se random() < 0.5, quindi vai all'elemento successivo e poi al passaggio 1. (Puoi generare un numero con altri mezzi, purché la loro sia (idealmente) uguale possibilità di saltare e rimanere. Ad esempio, puoi usare scegliere un elemento da un set di due membri ed eseguire l'azione in base al risultato.)
3. Altrimenti, si esegue la funzione fsu e.

Obbiettivo

Dato un array / list / string come uno Ae un numero K, eseguire l'array, aggiungendo Ka ciascun membro a cui si accede. Emette / restituisce questo array. Aconterrà solo numeri interi non negativi e Ksarà sempre e comunque numeri interi non negativi. Questo è un codice-golf , quindi vince il programma più breve in byte.

Casi di prova (esempi)

K, A => possible K'
[1, 2, 3, 4], 0 => [1, 2, 3, 4]
[1, 2, 3, 4], 1 => [1, 3, 3, 5]
[0, 0, 0, 0], 2 => [2, 0, 0, 2]

Pyth, 7

m+*O2vz

Provalo qui

Utilizza una scelta casuale invece del confronto in virgola mobile, ma dovrebbe essere indistinguibile.

Espansione:

m+*O2vz     ## implicitly, a d and Q are added to the end of the program
m+*O2vzdQ   ## Q = eval(input()), z= input()
m           ## map over each element d of Q
 +     d    ## add to d
  *O2vz     ## the product of eval(z) and a random number chosen from [0, 1]

Utilizzo in virgola mobile:

m+*<.5O0vz

Provalo qui

Clojure, 41 37 byte

(fn[a k](map #(+(*(rand-int 2)k)%)a))

Ha eliminato un paio di byte moltiplicando per 0 o 1 e rilasciando il "if". Ringraziamo la maggior parte degli altri utenti!

Gelatina, 9 8 7 byte

Da 8a 7grazie a @FryAmTheEggman .

+2X’¤¡€

Provalo online!

Spiegazione

+2X’¤¡€
      €   Map over each argument...
 2X           Choose a random number from {1,2}
   ’          Minus 1
    ¤                (grammar stuff)
     ¡        Repeat that number of times...
+                 Add the second input (to the argument being mapped over).

MATL , 11 byte

tZy1$rEki*+

Utilizza numeri casuali in virgola mobile.

Provalo online!

Spiegazione

t      % implicit input (array). Duplicate
Zy     % size (array specifying number of rows and columns)
1$r    % random vector between 0 and 1 with that size
Ek     % duplicate, round down: gives 0 or 1 with the same probability
i      % input (number K to be added)
*      % multiply: gives either 0 or K for each element
+      % add element-wise

Japt, 6 byte

®+V*Mq

Provalo

Spiegazione

Input implicito di array Ue numero intero V. Mappa ( ®) sull'array e, a ciascun elemento, aggiungi Vmoltiplicato per Mq, che genera casualmente uno 0o 1. Output implicito dell'array risultante.

Rubino, 28 byte

->a,k{a.map{|e|e+k*rand(2)}}

Julia, 33 29 27 byte

x->k->x+rand(0:1,endof(x))k

Questa è una funzione anonima che accetta un array con una funzione anonima interna che accetta un numero intero e restituisce un array. Per chiamarlo, assegnalo a una variabile e chiama come f(x)(k).

Generiamo un array con la stessa lunghezza dell'array di input costituito da zeri e quelli scelti a caso con uguale probabilità. Moltiplichiamo questo per il numero intero di input e lo aggiungiamo all'array di input.

Provalo online!

Salvato 2 byte grazie a Dennis!

Python 2, 60 58 byte

from random import*
lambda a,k:[e+choice([0,k])for e in a]

Questo programma si è rivelato davvero semplice. Non ci sono molti trucchi da golf lì dentro, a parte l'ovvio " from module import*", usando un lambda invece di una funzione regolare e la generale mancanza di spazi bianchi. Diverso da quello che è in realtà abbastanza idiomatico. Se stavo scrivendo questo per davvero, probabilmente lo farei in un modo molto simile:

import random
def running_addition(seq, k):
    return [e + random.choice([0, k]) for e in seq]

O forse qualcosa di più fantasioso:

import random
import operator
import functools

def run_through(seq, func):
    def random_func(arg):
        if random.randint(0, 1):
            return func(arg)
        return arg

    return [random_func(e) for e in seq]

def running_addition(seq, k):
    return run_through(seq, functools.partial(operator.add, k))

Ma è abbastanza in mostra :)

Questa è la vecchia versione a 60 byte di quando era richiesto l'uso di un float per casualità:

from random import*
lambda a,k:[e+k*(random()<.5)for e in a]

Per ogni elemento dell'elenco, aggiungi k*(random()<.5). I booleani di Python valutano a 0 e 1, quindi questo aggiunge 0 a tutti gli elementi per i quali la condizione non è vera.

I random.random()ritorni di Python fluttuano dentro [0, 1), quindi non dovevo preoccuparmene.

JavaScript (ES6), 38 byte

solution=

a=>k=>a.map(n=>Math.random()<.5?n:n+k)

document.write("<pre>"+
[ [[1,2,3,4], 0], [[1,2,3,4], 1], [[0,0,0,0], 2], [[4,22,65,32,91,46,18], 42] ]
.map(c=>"["+c[0]+"],"+c[1]+": "+solution(c[0])(c[1])).join`\n`)

PowerShell v2 +, 34 byte

param($a,$k)$a|%{$_+$k*(random 2)}

Prende in ingresso $ae $kla matrice e l'int rispettivamente. Quindi eseguiamo il loop nell'array e ogni iterazione del loop restituisce l'elemento corrente più i $ktempi (random 2)che verranno eseguiti Get-Random -Maximum 2(ovvero a 0o a 1). Questi sono tutti lasciati sulla pipeline e l'output come un array è implicito.

CJam, 10 byte

{f{2mr*+}}

Si aspetta l'array e il numero in cima allo stack in quell'ordine e li sostituisce con il nuovo array.

Provalo qui.

php 71 byte

function f($s,$k){foreach($s as $v){$v+=rand(0,2)==0?k:0;echo $v.",";}}

k (12 byte)

{x+y*(#x)?2}

per esempio

k){x+y*(#x)?2}[0 0 0 0;2]
2 2 2 0

Più in generale, dove fpuò essere passato come argomento per 16 caratteri

{@[x;&(#x)?2;y]}

per esempio

k){@[x;&(#x)?2;y]}[0 0 0 0;2+]
0 0 2 0

Python 3 152 110 98 byte

Questa è la mia prima soluzione di golf in codice quindi non conosco alcun trucco. Ho provato questo usando una funzione principale con casi di test. La dimensione del file è solo questa funzione.

from random import*
def a(x,y):
 p=0
 for z in x:
  if random()>.5:x[p]=z+y
  p+=1
 print(x)

Grazie a @ Cᴏɴᴏʀ O'Bʀɪᴇɴ per i consigli sulla rimozione degli spazi bianchi. Ulteriori elogi a @undergroundmonorail per un consiglio che ha salvato 12 byte.

Clojure, 32 byte

#(for[i %](+(*(rand-int 2)%2)i))

Grazie David per l' rand-intidea, decisamente più breve if(>(rand)0.5)dell'approccio. Qui forbatte map.

Ottava, 28 byte

@(A,R)R*(rand(size(A))<.5)+A

Esempio eseguito su ideone .

05AB1E , 10 byte

Codice:

vždɲ*y+})

Provalo online! .

Java, 84 byte

int[]r(int[]A,int K){for(int i=0;i<A.length;A[i++]+=Math.random()>.5?0:K);return A;}

Ungolfed

int[] r(int[] A, int K) {
    for (int i = 0; 
         i < A.length; 
         A[i++] += Math.random() > .5 ? 0 : K);
    return A;
}

Appunti

• Il ripensamento del loop potrebbe anche essere il suo corpo, non c'è differenza di dimensioni.
• L'array di input viene modificato ma l'istruzione non contiene una limitazione relativa a questo problema. Se si contasse l'array modificato come una forma di "Output / return", è possibile rimuovere altri 9 byte rimuovendolo return A;. Il tipo restituito dovrebbe essere modificato da int[]a void. Questo, tuttavia, non salva byte aggiuntivi poiché è necessario uno spazio aggiuntivo tra voide r.

Versione più breve (come menzionato nella nota), 75 byte

void r(int[]A,int K){for(int i=0;i<A.length;)A[i++]+=Math.random()>.5?0:K;}

Produzione

[1, 2, 3, 4], 0 => [1, 2, 3, 4]
[1, 2, 3, 4], 1 => [1, 3, 3, 4]
[1, 2, 3, 4], 2 => [3, 2, 3, 4]
[1, 2, 3, 4], 3 => [4, 5, 3, 7]
[1, 2, 3, 4], 4 => [5, 2, 3, 8]
[1, 2, 3, 4], 5 => [6, 2, 8, 9]

Mathcad, byte

Nessun byte formale conta come protocollo di conteggio Mathcad ancora da decidere.

Java 108 107 85 82 byte

void f(int[]s,int k){for(int i:s)System.out.print((i+=Math.random()<.5?k:0)+";");}

14 byte salvati grazie a @TimmyD

Perl 5 , 30 + 1 (-a) = 31 byte

$,=<>;say.5>rand?$_:$_+$,for@F

Provalo online!