Jelly, 9 8 7 bytes

From 8 to 7 thanks to @FryAmTheEggman.

+2X’¤¡€

Try it online!

Explanation

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

Clojure, 41 37 bytes

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

Knocked off a couple of bytes by multiplying by 0 or 1 and dropping the "if". Credit to most all of the other submitters!

MATL, 11 bytes

tZy1$rEki*+

Uses floating point random numbers.

Try it online!

Explanation

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

Python 2, 60 bytes

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

For each element of the list, add k*(random()<.5). Python booleans evaluate to 0 and 1, so this adds 0 to any elements for which the condition isn't true.

Python's random.random() returns floats in [0, 1), so I didn't have to worry about that.

Pyth, 7

m+*O2vz

Try it here

Uses a random choice instead of floating point comparison, but should be indistinguishable.

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]

Using floating point:

m+*<.5O0vz

Try it here

Julia, 33 29 27 bytes

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

This is an anonymous function that accepts an array with an inner anonymous function that accepts an integer and returns an array. To call it, assign it to a variable and call like f(x)(k).

We generate an array with the same length as the input array consisting of zeros and ones chosen at random with equal probability. We multiply this by the input integer and add that to the input array.

Try it online!

Saved 2 bytes thanks to Dennis!

JavaScript (ES6), 38 bytes

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 bytes

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

Takes input $a and $k, the array and the int respectively. We then loop through the array and each loop iteration output the current element plus $k times (random 2) which will execute Get-Random -Maximum 2 (i.e., either a 0 or a 1). These are all left on the pipeline and output as an array is implicit.

CJam, 10 bytes

{f{2mr*+}}

Expects the array and the number on top of the stack in that order and replaces them with the new array.

Test it here.

Ruby, 28 bytes

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

php 71 bytes

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

k (12 bytes)

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

e.g.

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

More generally, where f can be passed as an argument for 16 characters

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

e.g.

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

Python 3 152 110 98 bytes

This is my first code golf solution so I don't know any tricks. I tested this using a main function with test cases. The file size is only this function.

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

Thanks to @Cᴏɴᴏʀ O'Bʀɪᴇɴ for the advice on removing whitespace. Additional praise to @undergroundmonorail for advice that saved 12 bytes.

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