Nous entendons tous souvent l'idiome "parcourir le tableau" pour signifier "mapper la fonction sur le tableau suivant". Cependant, j'en ai besoin (maintenant!), Donc je veux que vous parcouriez le tableau.

Comment courir?

_{Imaginez qu'il y a une meute sauvage de loups derrière vous}

Parcourir un tableau revient à en parcourir un, sauf que vous pouvez ignorer les éléments. Oui, c'est parfois salissant, mais cela fonctionne (généralement). "Quels éléments sont ignorés?", Vous pouvez vous demander. Eh bien, cela se fait au hasard. Passons en revue le tableau!

1. Soit el'élément courant.
2. Soit randomgénérer un flottant aléatoire dans[0,1) . Si random() < 0.5, alors vous passez à l'élément suivant, puis à l'étape 1. (Vous pouvez générer un nombre par d'autres moyens, tant que leur est (idéalement) une chance égale de sauter et de rester. Par exemple, vous pouvez utiliser choisir un élément dans un ensemble de deux membres et effectuez l'action en fonction du résultat.)
3. Dans le cas contraire, vous effectuez la fonction fsur e.

Objectif

Étant donné un tableau / liste / chaîne comme l'un Aet l' autre et un nombre K, parcourez le tableau, en ajoutant Kà chaque membre accédé. Sortez / retournez ce tableau. Ane contiendra que des entiers non négatifs et Kne sera jamais qu'un entier non négatif. Ceci est un code-golf , donc le programme le plus court en octets l'emporte.

Cas de test (exemples)

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

Essayez-le ici

Utilise un choix aléatoire au lieu d'une comparaison à virgule flottante, mais ne doit pas être distingué.

Expansion:

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]

Utilisation de virgule flottante:

m+*<.5O0vz

Essayez-le ici

Clojure, 41 37 octets

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

Supprimé quelques octets en multipliant par 0 ou 1 et en supprimant le "si". Nous remercions la plupart des autres soumissionnaires!

Gelée, 9 8 7 octets

De 8à 7merci à @FryAmTheEggman .

+2X’¤¡€

Essayez-le en ligne!

Explication

+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 octets

tZy1$rEki*+

Utilise des nombres aléatoires à virgule flottante.

Essayez-le en ligne!

Explication

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 octets

®+V*Mq

Essaye-le

Explication

Entrée implicite de tableau Uet d'entier V. Map ( ®) sur le tableau et, à chaque élément, ajoutez Vmultiplié par Mq, ce qui génère aléatoirement soit 0ou 1. Sortie implicite du tableau résultant.

Rubis, 28 octets

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

Julia, 33 29 27 octets

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

Il s'agit d'une fonction anonyme qui accepte un tableau avec une fonction anonyme interne qui accepte un entier et renvoie un tableau. Pour l'appeler, affectez-le à une variable et appelez comme f(x)(k).

Nous générons un tableau de la même longueur que le tableau d'entrée composé de zéros et de ceux choisis au hasard avec une probabilité égale. Nous multiplions cela par l'entier d'entrée et l'ajoutons au tableau d'entrée.

Essayez-le en ligne!

Enregistré 2 octets grâce à Dennis!

Python 2, 60 58 octets

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

Ce programme s'est avéré très simple. Il n'y a pas beaucoup de trucs de golf là-dedans, à part l'évident " from module import*", en utilisant un lambda au lieu d'une fonction régulière et le manque général d'espaces. A part ça, c'est en fait assez idiomatique. Si j'écrivais cela pour de vrai, je le ferais probablement de manière très similaire:

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

Ou peut-être quelque chose de plus sophistiqué:

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

Mais ça suffit de montrer :)

Il s'agit de l'ancienne version de 60 octets lorsque l'utilisation d'un flotteur pour l'aléatoire était requise:

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

Pour chaque élément de la liste, ajoutez k*(random()<.5). Les booléens Python sont évalués à 0 et 1, ce qui ajoute 0 à tous les éléments pour lesquels la condition n'est pas vraie.

Les random.random()retours de Python flottent [0, 1), donc je n'ai pas eu à m'en soucier.

JavaScript (ES6), 38 octets

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 octets

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

Prend respectivement l'entrée $aet $kle tableau et l'int. Nous parcourons ensuite le tableau et chaque itération de boucle génère l'élément courant plus les $ktemps (random 2)qui s'exécuteront Get-Random -Maximum 2(c'est-à-dire, a 0ou a 1). Ceux-ci sont tous laissés sur le pipeline et la sortie sous forme de tableau est implicite.

CJam, 10 octets

{f{2mr*+}}

Attend le tableau et le numéro en haut de la pile dans cet ordre et les remplace par le nouveau tableau.

Testez-le ici.

php 71 octets

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

k (12 octets)

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

par exemple

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

Plus généralement, où fpeut être passé comme argument pour 16 caractères

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

par exemple

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

Python 3152 110 98 octets

Ceci est ma première solution de golf de code, donc je ne connais aucun truc. J'ai testé cela en utilisant une fonction principale avec des cas de test. La taille du fichier est uniquement cette fonction.

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

Merci à @ Cᴏɴᴏʀ O'Bʀɪᴇɴ pour les conseils sur la suppression des espaces blancs. Félicitations supplémentaires à @undergroundmonorail pour des conseils qui ont permis d'économiser 12 octets.

Clojure, 32 octets

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

Merci David pour l' rand-intidée, définitivement plus courte que l' if(>(rand)0.5)approche. Ici forbat map.

Octave, 28 bytes

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

Sample run on ideone.

05AB1E, 10 bytes

Code:

vždɲ*y+})

Try it online!.

Java, 84 bytes

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

Notes

• The afterthought of the loop could also be it's body, there is no difference in size.
• The input array is modified but the statement does not contain a restriction regarding this issue. If you would count the modified array as a form of "Output/return", you could shave off another 9 bytes by removing return A;. The return type would need to be changed from int[] to void. This however does not save additional bytes since an additional space is needed between void and r.

Shorter version (As mentioned in the note), 75 bytes

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

Output

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

No formal byte count as Mathcad counting protocol yet to be decided.

Java 108 107 85 82 bytes

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

14 bytes saved thanks to @TimmyD

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

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

Try it online!