Todos nós sempre ouvimos o idioma "percorrer a matriz" para significar "mapear a função sobre a matriz a seguir". No entanto, eu preciso fazê-lo (agora!), Então quero que você execute a matriz.

Como eu corro?

_{Imagine que há um bando selvagem de lobos atrás de você}

Percorrer uma matriz é como percorrer uma, exceto que você pode pular os elementos. Sim, às vezes é confuso, mas (geralmente) funciona. "Quais elementos foram ignorados?", Você pode perguntar. Bem, isso é feito aleatoriamente. Vamos percorrer a matriz!

1. Let eSer o elemento atual.
2. Vamos randomgerar uma flutuação aleatória [0,1). E serandom() < 0.5 você for para o próximo elemento e depois para a etapa 1. (Você pode gerar um número por outros meios, desde que seja uma chance (idealmente) igual de pular e permanecer. Por exemplo, você pode escolher um elemento conjunto de dois membros e execute a ação com base no resultado.)
3. Caso contrário, você executar a função fno e.

Objetivo

Dado um array / lista / string como um Ae um número K, percorra o array, adicionando Ka cada membro acessado. Saída / retorno desta matriz. Aconterá apenas números inteiros não negativos e Ksempre serão números inteiros não negativos. Este é um código de golfe , portanto o programa mais curto em bytes vence.

Casos de teste (exemplos)

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]

Pitão, 7

m+*O2vz

Experimente aqui

Usa uma escolha aleatória em vez de comparação de ponto flutuante, mas deve ser indistinguível.

Expansão:

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 ponto flutuante:

m+*<.5O0vz

Experimente aqui

Clojure, 41 37 bytes

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

Bateu alguns bytes multiplicando por 0 ou 1 e soltando o "se". Crédito para a maioria dos outros remetentes!

Geléia, 9 8 7 bytes

A partir 8de 7graças a @FryAmTheEggman .

+2X’¤¡€

Experimente online!

Explicação

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

Usa números aleatórios de ponto flutuante.

Experimente online!

Explicação

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

Japonês, 6 bytes

®+V*Mq

Teste-o

Explicação

Entrada implícita de matriz Ue número inteiro V. Mapeie ( ®) sobre a matriz e, para cada elemento, adicione Vmultiplicado por Mq, que gera aleatoriamente um 0ou 1. Saída implícita da matriz resultante.

Ruby, 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 é uma função anônima que aceita uma matriz com uma função anônima interna que aceita um número inteiro e retorna uma matriz. Para chamá-lo, atribua-o a uma variável e chame comof(x)(k) .

Geramos uma matriz com o mesmo comprimento que a matriz de entrada composta por zeros e aqueles escolhidos aleatoriamente com igual probabilidade. Nós multiplicamos isso pelo número inteiro de entrada e o adicionamos à matriz de entrada.

Experimente online!

Economizou 2 bytes graças a Dennis!

Python 2, 60 58 bytes

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

Este programa acabou realmente simples. Não há muitos truques de golfe lá, além do óbvio " from module import*", usando um lambda em vez de uma função regular e a falta geral de espaço em branco. Fora isso, é realmente bastante idiomático. Se eu estivesse escrevendo isso de verdade, provavelmente faria de uma maneira muito semelhante:

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

Ou talvez algo mais chique:

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

Mas isso é o suficiente para mostrar :)

Esta é a versão antiga de 60 bytes de quando era necessário usar um float para aleatoriedade:

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

Para cada elemento da lista, adicione k*(random()<.5). Os booleanos Python são avaliados como 0 e 1, portanto, adiciona 0 a qualquer elemento cuja condição não seja verdadeira.

Os random.random()retornos do Python flutuam [0, 1), então eu não precisava me preocupar com isso.

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

Pega entrada $ae $k, a matriz e o int respectivamente. Em seguida, passamos pela matriz e cada iteração de loop gera o elemento atual mais os $ktempos (random 2)que serão executados Get-Random -Maximum 2(ou seja, a 0ou a 1). Tudo isso é deixado no pipeline e a saída é implícita.

CJam, 10 bytes

{f{2mr*+}}

Espera a matriz e o número no topo da pilha nessa ordem e os substitui pela nova matriz.

Teste aqui.

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}

por exemplo

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

De maneira mais geral, onde fpode ser passado como argumento para 16 caracteres

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

por exemplo

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

Python 3 152 110 98 bytes

Esta é a minha primeira solução de código de golfe, então não conheço nenhum truque. Eu testei isso usando uma função principal com casos de teste. O tamanho do arquivo é apenas essa função.

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

Obrigado a @ Cᴏɴᴏʀ O'Bʀɪᴇɴ pelo conselho sobre a remoção de espaços em branco. Elogios adicionais a @undergroundmonorail por conselhos que salvaram 12 bytes.

Clojure, 32 bytes

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

Obrigado David pela rand-intideia, definitivamente mais curto que a if(>(rand)0.5)abordagem. Aqui forbatemap .

Oitava, 28 bytes

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

Amostra executada em ideone .

05AB1E , 10 bytes

Código:

vždɲ*y+})

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

Notas

• A reflexão tardia do loop também pode ser seu corpo, não há diferença de tamanho.
• A matriz de entrada é modificada, mas a instrução não contém uma restrição sobre esse problema. Se você contar a matriz modificada como uma forma de "Saída / retorno", poderá remover outros 9 bytes removendo return A;. O tipo de retorno precisaria ser alterado de int[]para void. No entanto, isso não salva bytes adicionais, pois é necessário um espaço adicional entre voide r.

Versão mais curta (conforme mencionado na nota), 75 bytes

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

Resultado

[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

Ainda não há uma contagem formal de bytes como protocolo de contagem do Mathcad a ser decidido.

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 salvos graças a @TimmyD

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

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

Experimente online!