Todos a menudo escuchamos el modismo "caminar a través de la matriz" que significa "asignar la función sobre la siguiente matriz". Sin embargo, lo necesito hecho (¡ahora!), Así que quiero que ejecutes la matriz.

¿Cómo corro?

_{Imagina que hay una jauría salvaje de lobos detrás de ti}

Correr a través de una matriz es como caminar a través de una, excepto que puede saltear elementos. Sí, a veces es desordenado, pero (en general) funciona. "¿Qué elementos se omiten?", Puede preguntar. Bueno, esto se hace al azar. ¡Caminemos corriendo por la matriz!

1. Dejar eser el elemento actual.
2. Deje randomgenerar un flotador aleatorio [0,1). Si random() < 0.5, entonces va al siguiente elemento y luego al paso 1. (Puede generar un número por otros medios, siempre que sea (idealmente) la misma posibilidad de saltar y permanecer. Por ejemplo, puede usar elegir un elemento de un conjunto de dos miembros y realizar la acción en función del resultado).
3. De lo contrario, realiza la función fen e.

Objetivo

Dada una matriz / lista / cadena como cualquiera Ay un número K, ejecute la matriz, agregando Ka cada miembro accedido. Salida / retorno de esta matriz. Asolo contendrá enteros no negativos, y Ksolo serán enteros no negativos. Este es un código de golf , por lo que gana el programa más corto en bytes.

Casos de prueba (ejemplos)

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

Pruébalo aquí

Utiliza una elección aleatoria en lugar de una comparación de punto flotante, pero no debe distinguirse.

Expansión:

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]

Usando coma flotante:

m+*<.5O0vz

Pruébalo aquí

Clojure, 41 37 bytes

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

Eliminó un par de bytes multiplicando por 0 o 1 y soltando el "si". ¡Crédito a la mayoría de todos los otros remitentes!

Jalea, 9 8 7 bytes

De 8a 7gracias a @FryAmTheEggman .

+2X’¤¡€

Pruébalo en línea!

Explicación

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

tZy1$rEki*+

Utiliza números aleatorios de coma flotante.

Pruébalo en línea!

Explicación

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 bytes

®+V*Mq

Pruébalo

Explicación

Entrada implícita de matriz Uy entero V. Map ( ®) sobre la matriz y, a cada elemento, suma Vmultiplicado por Mq, que genera aleatoriamente uno 0o 1. Salida implícita de la matriz resultante.

Rubí, 28 bytes.

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

Julia, 33 29 27 bytes

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

Esta es una función anónima que acepta una matriz con una función anónima interna que acepta un entero y devuelve una matriz. Para llamarlo, asígnelo a una variable y llame comof(x)(k) .

Generamos una matriz con la misma longitud que la matriz de entrada que consta de ceros y unos elegidos al azar con igual probabilidad. Multiplicamos esto por el entero de entrada y lo agregamos a la matriz de entrada.

Pruébalo en línea!

¡Ahorré 2 bytes gracias a Dennis!

Python 2, 60 58 bytes

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

Este programa resultó realmente simple. No hay muchos trucos de golf allí, aparte del obvio " from module import*", usando una lambda en lugar de una función regular y la falta general de espacios en blanco. Aparte de eso, en realidad es bastante idiomático. Si estuviera escribiendo esto de verdad, probablemente lo haría de una manera muy similar:

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

O tal vez algo más elegante:

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

Pero eso es suficiente para presumir :)

Esta es la versión anterior de 60 bytes de cuando se requería usar un flotante para aleatoriedad:

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

Para cada elemento de la lista, agregue k*(random()<.5). Los booleanos de Python evalúan a 0 y 1, por lo que esto agrega 0 a cualquier elemento para el que la condición no sea verdadera.

El random.random()regreso de Python flota [0, 1), así que no tuve que preocuparme por eso.

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

Toma entrada $ay $k, la matriz y el int respectivamente. Luego recorremos la matriz y cada iteración del ciclo genera el elemento actual más las $kveces (random 2)que se ejecutará Get-Random -Maximum 2(es decir, a 0o a 1). Todos estos quedan en la tubería y la salida como una matriz está implícita.

CJam, 10 bytes

{f{2mr*+}}

Espera la matriz y el número en la parte superior de la pila en ese orden y los reemplaza con la nueva matriz.

Pruébalo aquí.

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}

p.ej

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

De manera más general, ¿dónde fse puede pasar como argumento para 16 caracteres?

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

p.ej

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

Python 3 152 110 98 bytes

Esta es mi primera solución de código de golf, así que no conozco ningún truco. Probé esto usando una función principal con casos de prueba. El tamaño del archivo es solo esta función.

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

Gracias a @ Cᴏɴᴏʀ O'Bʀɪᴇɴ por los consejos para eliminar espacios en blanco. Elogios adicionales a @undergroundmonorail por consejos que ahorraron 12 bytes.

Clojure, 32 bytes

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

Gracias David por la rand-intidea, definitivamente más corta que el if(>(rand)0.5)enfoque. Aquí forlate map.

Octava, 28 bytes

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

Ejecución de muestra en ideone .

05AB1E , 10 bytes

Código:

vždɲ*y+})

Pruébalo en línea! .

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

Sin golf

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

Notas

• La idea de último momento del bucle también podría ser su cuerpo, no hay diferencia de tamaño.
• La matriz de entrada se modifica pero la declaración no contiene una restricción con respecto a este problema. Si contara la matriz modificada como una forma de "Salida / retorno", podría eliminar otros 9 bytes eliminando return A;. El tipo de retorno necesitaría ser cambiado de int[]a void. Sin embargo, esto no ahorra bytes adicionales ya que se necesita un espacio adicional entre voidy r.

Versión más corta (como se menciona en la nota), 75 bytes

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

Salida

[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

Aún no se ha decidido el recuento de bytes formal como protocolo de recuento de Mathcad

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 guardados gracias a @TimmyD

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

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

Pruébalo en línea!