Tất cả chúng ta thường nghe thành ngữ "đi qua mảng" có nghĩa là "ánh xạ hàm qua mảng sau". Tuy nhiên, tôi cần nó được thực hiện (ngay bây giờ!), Vì vậy tôi muốn bạn chạy qua mảng.

Làm thế nào để tôi chạy?

_{Hãy tưởng tượng có một bầy sói hoang đằng sau bạn}

Chạy qua một mảng giống như đi qua một mảng, ngoại trừ bạn có thể bỏ qua các phần tử. Vâng, đôi khi nó lộn xộn, nhưng nó (nói chung) hoạt động. "Những yếu tố nào bị bỏ qua?", Bạn có thể hỏi. Vâng, điều này được thực hiện ngẫu nhiên. Hãy đi bộ chạy qua mảng!

1. Hãy elà yếu tố hiện tại.
2. Hãy randomtạo một float ngẫu nhiên trong [0,1). Nếu random() < 0.5, sau đó bạn chuyển phần tử tiếp theo và sau đó đến bước 1. (Bạn có thể tạo số bằng các phương tiện khác, miễn là chúng có cơ hội (lý tưởng) bằng nhau bỏ qua và còn lại. Ví dụ: bạn có thể sử dụng chọn một phần tử từ một thiết lập hai thành viên và thực hiện hành động dựa trên kết quả.)
3. Nếu không, bạn thực hiện chức năng ftrên e.

Mục tiêu

Đưa ra một mảng / danh sách / chuỗi như một Avà một số K, chạy qua mảng, thêm Kvào từng thành viên được truy cập. Đầu ra / trả về mảng này. Asẽ chỉ chứa các số nguyên không âm và Ksẽ chỉ là một số nguyên không âm. Đây là một môn đánh gôn , vì vậy chương trình ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm (ví dụ)

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]

Bình 7, 7

m+*O2vz

Hãy thử nó ở đây

Sử dụng một lựa chọn ngẫu nhiên thay vì so sánh dấu phẩy động, nhưng không thể phân biệt được.

Sự bành trướng:

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]

Sử dụng dấu phẩy động:

m+*<.5O0vz

Hãy thử nó ở đây

Clojure, 41 37 byte

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

Đã loại bỏ một vài byte bằng cách nhân 0 hoặc 1 và bỏ "nếu". Tín dụng cho hầu hết tất cả các đệ trình khác!

Thạch, 9 8 7 byte

Từ 8để 7nhờ @FryAmTheEggman .

+2X’¤¡€

Hãy thử trực tuyến!

Giải trình

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

tZy1$rEki*+

Sử dụng số ngẫu nhiên dấu phẩy động.

Hãy thử trực tuyến!

Giải trình

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 byte

®+V*Mq

Kiểm tra nó

Giải trình

Đầu vào ngầm định của mảng Uvà số nguyên V. Ánh xạ ( ®) qua mảng và, với mỗi phần tử, thêm Vnhân với Mq, tạo ngẫu nhiên 0hoặc 1. Ngõ ra ngầm định của mảng kết quả.

Ruby, 28 byte

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

Julia, 33 29 27 byte

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

Đây là một hàm ẩn danh chấp nhận một mảng với một hàm ẩn danh bên trong chấp nhận một số nguyên và trả về một mảng. Để gọi nó, gán nó cho một biến và gọi như thế f(x)(k).

Chúng tôi tạo ra một mảng có cùng độ dài với mảng đầu vào bao gồm các số 0 và các mảng được chọn ngẫu nhiên với xác suất bằng nhau. Chúng tôi nhân số này với số nguyên đầu vào và thêm nó vào mảng đầu vào.

Hãy thử trực tuyến!

Đã lưu 2 byte nhờ Dennis!

Python 2, 60 58 byte

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

Chương trình này hóa ra rất đơn giản. Không có nhiều thủ thuật đánh gôn trong đó, ngoài "" rõ ràng from module import*, sử dụng lambda thay vì chức năng thông thường và thiếu khoảng trắng nói chung. Khác hơn là nó thực sự khá thành ngữ. Nếu tôi viết nó thực sự có lẽ tôi sẽ làm nó theo một cách rất giống nhau:

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

Hoặc có lẽ một cái gì đó lạ mắt hơn:

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

Nhưng thế là đủ thể hiện rồi :)

Đây là phiên bản cũ, 60 byte từ khi sử dụng float cho ngẫu nhiên được yêu cầu:

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

Đối với mỗi yếu tố của danh sách, thêm k*(random()<.5). Booleans Python đánh giá 0 và 1, vì vậy điều này thêm 0 vào bất kỳ phần tử nào mà điều kiện không đúng.

random.random()Lợi nhuận của Python trôi nổi [0, 1), vì vậy tôi không phải lo lắng về điều đó.

JavaScript (ES6), 38 byte

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 byte

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

Lấy đầu vào $avà $k, mảng và int tương ứng. Sau đó, chúng tôi lặp qua mảng và mỗi lần lặp lặp lại xuất ra phần tử hiện tại cộng với số $klần (random 2)sẽ thực thi Get-Random -Maximum 2(nghĩa là a 0hoặc a 1). Tất cả đều còn lại trên đường ống và đầu ra dưới dạng một mảng ẩn.

CJam, 10 byte

{f{2mr*+}}

Yêu cầu mảng và số trên đầu ngăn xếp theo thứ tự đó và thay thế chúng bằng mảng mới.

Kiểm tra nó ở đây.

php 71 byte

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

k (12 byte)

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

ví dụ

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

Tổng quát hơn, nơi fcó thể được chuyển qua làm đối số cho 16 ký tự

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

ví dụ

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

Trăn 3 152 110 98 byte

Đây là giải pháp golf mã đầu tiên của tôi vì vậy tôi không biết bất kỳ thủ thuật nào. Tôi đã thử nghiệm điều này bằng cách sử dụng một chức năng chính với các trường hợp thử nghiệm. Kích thước tập tin chỉ có chức năng này.

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

Cảm ơn @ Cᴏɴᴏʀ O'Bʀɪᴇɴ vì lời khuyên về việc xóa khoảng trắng. Thêm lời khen ngợi cho @undergroundmonorail cho lời khuyên đã lưu 12 byte.

Clojure, 32 byte

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

Cảm ơn bạn David cho rand-intý tưởng, chắc chắn ngắn hơn so với if(>(rand)0.5)cách tiếp cận. Đây fornhịp đập map.

Octave, 28 byte

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

Mẫu chạy trên ideone .

05AB1E , 10 byte

Mã số:

vždɲ*y+})

Hãy thử trực tuyến! .

Java, 84 byte

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

Ung dung

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

Ghi chú

• Suy nghĩ của vòng lặp cũng có thể là cơ thể, không có sự khác biệt về kích thước.
• Mảng đầu vào được sửa đổi nhưng câu lệnh không chứa một hạn chế liên quan đến vấn đề này. Nếu bạn tính mảng đã sửa đổi là một dạng "Đầu ra / trả lại", bạn có thể loại bỏ 9 byte khác bằng cách xóa return A;. Loại trả về sẽ cần phải được thay đổi từ int[]thành void. Tuy nhiên, điều này không lưu các byte bổ sung do cần một không gian bổ sung giữa voidvà r.

Phiên bản ngắn hơn (Như đã đề cập trong ghi chú), 75 byte

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

Đầu ra

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

Không có số byte chính thức như giao thức đếm Mathcad chưa được quyết định.

Java 108 107 85 82 byte

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

14 byte được lưu nhờ @TimmyD

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

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

Hãy thử trực tuyến!