Hepimiz sık sık "dizi üzerinden yürümek" deyimi "fonksiyonu aşağıdaki dizi üzerinden eşlemek" demek duyuyoruz. Ancak, ben (şimdi!) Yapılması gerekir, bu yüzden dizi üzerinden çalıştırmak istiyorum .

Nasıl koşarım?

_{Arkanda vahşi bir kurt sürüsü olduğunu hayal et}

Bir dizi boyunca koşmak, bir öğe üzerinde yürümek gibidir, ancak öğeleri atlayabilirsiniz. Evet, bazen dağınık, ama (genellikle) işe yarıyor. “Hangi elemanlar atlanıyor?” Diye sorabilirsiniz. Bu rastgele yapılır. Dizide koşarak yürüyelim!

1. Izin vermek egeçerli eleman olsun.
2. Let randomrastgele bir şamandıra üretmek [0,1). Eğer bir random() < 0.5sonraki öğeye giderseniz ve sonra 1. adıma gidersiniz. (Başka bir yolla bir sayı üretebilirsiniz, ancak (ideal olarak) eşit atlama ve kalma şansı olduğu sürece. Örneğin, bir iki üyeli eylemi sonuca göre ayarlar ve gerçekleştirir.)
3. Aksi takdirde, işlevi façık olarak gerçekleştirirsiniz e.

Amaç

Herhangi bir dizi / liste / dize Ave bir sayı Kverildiğinde, Kerişilen her üyeye ekleyerek dizi boyunca ilerleyin . Bu diziyi çıktılar / döndürür. Ayalnızca negatif olmayan tamsayılar içerir ve Kyalnızca negatif olmayan bir tamsayı olur. Bu bir kod golfü , bu yüzden bayttaki en kısa program kazanıyor.

Test senaryoları (örnekler)

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

Burada deneyin

Kayan nokta karşılaştırması yerine rastgele bir seçim kullanır, ancak ayırt edilemez olmalıdır.

Genişleme:

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]

Kayan noktayı kullanma:

m+*<.5O0vz

Burada deneyin

Clojure, 41 37 bayt

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

0 veya 1 ile çarpıp "if" i bırakarak birkaç bayt çaldı. Diğer tüm gönderenlerin çoğuna kredi!

Jöle, 9 8 7 bayt

Gönderen 8etmek 7sayesinde @FryAmTheEggman .

+2X’¤¡€

Çevrimiçi deneyin!

açıklama

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

tZy1$rEki*+

Kayan nokta rasgele sayıları kullanır.

Çevrimiçi deneyin!

açıklama

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 bayt

®+V*Mq

Dene

açıklama

Örtülü dizi Uve tamsayı girişi V. ®Dizi ( ) öğesini dizinin üzerinde eşleştirin ve her öğeye, Vçarparak ekleyin Mq, bu da rastgele birini 0veya oluşturur 1. Ortaya çıkan dizinin örtük çıktısı.

Ruby, 28 bayt

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

Julia, 33 29 27 bayt

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

Bu, bir tamsayı kabul eden ve bir dizi döndüren iç anonim işlevli bir diziyi kabul eden anonim bir işlevdir. Onu çağırmak için bir değişkene atayın ve şöyle çağırın f(x)(k).

Sıfırlarla ve eşit olasılıkla rastgele seçilenlerden oluşan giriş dizisiyle aynı uzunlukta bir dizi üretiyoruz. Bunu girdi tamsayı ile çarpar ve girdi dizisine ekleriz.

Çevrimiçi deneyin!

Dennis sayesinde 2 bayt tasarruf!

Python 2, 60 58 bayt

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

Bu program gerçekten basit çıktı. Orada pek çok golf hilesi, dışında bariz " from module import*", yerine bir lambda kullanarak düzenli bir işlev ve genel boşluk eksikliği. Bunun dışında aslında oldukça deyimsel. Bunu gerçek için yazsaydım, muhtemelen çok benzer bir şekilde yapardım:

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

Ya da belki daha süslü bir şey:

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

Ama bu gösteriş için yeterli :)

Bu, rasgelelik için bir şamandıra kullanıldığında gelen eski, 60 baytlık sürümdür:

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

Listenin her öğesi için ekleyin k*(random()<.5). Python booleans 0 ve 1 olarak değerlendirilir, böylece bu durumun doğru olmadığı herhangi bir öğeye 0 ekler.

Python'un random.random()geri dönüşleri yüzer [0, 1), bu yüzden bunun için endişelenmem gerekmiyordu.

JavaScript (ES6), 38 bayt

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 bayt

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

Girdi $ave $ksırasıyla dizi ve int alır. Daha sonra dizi boyunca döngü yaparız ve her döngü yinelemesi geçerli öğeyi artı yürütecek $ksüreleri (yani, a veya a ) çıkarır . Bunların tümü boru hattında bırakılır ve bir dizi örtük olarak çıktılanır.(random 2)Get-Random -Maximum 201

CJam, 10 bayt

{f{2mr*+}}

Diziyi ve yığının üstündeki sayıyı bu sırayla bekler ve bunları yeni diziyle değiştirir.

Burada test edin.

php 71 bayt

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

k (12 bayt)

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

Örneğin

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

Daha genel olarak, f16 karakter için argüman olarak geçilebilir

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

Örneğin

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

Python 3 152 110 98 bayt

Bu benim ilk kod golf çözümü bu yüzden hile bilmiyorum. Bunu test senaryolarıyla bir ana işlev kullanarak test ettim. Dosya boyutu sadece bu işlevdir.

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

Boşluğu kaldırmayla ilgili tavsiyeler için @ Cᴏɴᴏʀ O'Bʀɪᴇɴ'ye teşekkürler. 12 bayt tasarruf tavsiye için @ undergroundmonorail ek övgü.

Clojure, 32 bayt

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

David'e rand-intfikir için teşekkürler , if(>(rand)0.5)yaklaşımdan kesinlikle daha kısa . İşte foratıyor map.

Oktav, 28 bayt

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

İdeone üzerinde örnek çalışma .

05AB1E , 10 bayt

Kod:

vždɲ*y+})

Çevrimiçi deneyin! .

Java, 84 bayt

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

notlar

• Döngünün sonradan düşünülmesi de vücudu olabilir, boyutta bir fark yoktur.
• Girdi dizisi değiştirildi, ancak ifade bu sorunla ilgili bir kısıtlama içermiyor. Değiştirilmiş diziyi bir "Çıktı / dönüş" biçimi olarak sayarsanız, kaldırarak başka bir 9 bayt tıraş edebilirsiniz return A;. Dönüş türü değiştirilebilir gerekir int[]için void. Ancak bu, voidve arasında ek bir alan gerektiğinden ek bayt tasarrufu yapmaz r.

Daha kısa versiyon (Notta belirtildiği gibi), 75 bayt

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

Çıktı

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

Mathcad sayma protokolü olarak henüz resmi bir bayt sayımına karar verilmemiştir.

Java 108 107 85 82 bayt

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

@TimmyD sayesinde 14 bayt kaydedildi

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

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

Çevrimiçi deneyin!