एक सरणी के माध्यम से चलाएँ

Question

हम सभी अक्सर मुहावरे को "सरणी के माध्यम से चलते हैं" सुनते हैं, जिसका अर्थ है "निम्न सरणी पर फ़ंक्शन को मैप करें"। हालांकि, मुझे इसकी आवश्यकता है (अब!), इसलिए मैं चाहता हूं कि आप सरणी के माध्यम से चलाएं ।

मैं कैसे चलाऊं?

_{कल्पना कीजिए कि आपके पीछे भेड़ियों का एक जंगली पैकेट है}

एक सरणी से भागना एक के माध्यम से चलने जैसा है, सिवाय इसके कि आप तत्वों को छोड़ सकते हैं। हां, यह कभी-कभी गड़बड़ होता है, लेकिन यह (आम तौर पर) काम करता है। "कौन से तत्व छोड़े गए हैं?", आप पूछ सकते हैं। खैर, यह यादृच्छिक पर किया जाता है। चलो सरणी के माध्यम से चल रहा है!

1. आज्ञा देना eवर्तमान तत्व है।
2. में randomएक यादृच्छिक फ्लोट उत्पन्न करते हैं [0,1)। यदि random() < 0.5, तो आप अगले तत्व पर जाते हैं और फिर चरण 1 पर जाते हैं (आप अन्य साधनों द्वारा एक संख्या उत्पन्न कर सकते हैं, इसलिए जब तक उनका एक (आदर्श रूप से) लंघन और शेष होने की समान संभावना है। जैसे, आप किसी तत्व का चयन कर सकते हैं। दो सदस्यीय सेट और परिणाम के आधार पर कार्रवाई करते हैं।)
3. अन्यथा, आप fपर कार्य करते हैं e।

उद्देश्य

किसी सरणी / सूची / स्ट्रिंग को या तो Aऔर एक संख्या को देखते हुए, सरणी के Kमाध्यम से चलाएं, Kप्रत्येक सदस्य तक पहुंच को जोड़ते हुए । इस सरणी को आउटपुट / वापस करें। Aकेवल गैर-नकारात्मक पूर्णांक होंगे, और Kकेवल एक गैर-नकारात्मक पूर्णांक होंगे। यह एक कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।

परीक्षण के मामले (उदाहरण)

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]

Comments

[0,1)लेखन त्रुटि है? 2 और जाने के लिए ...

— बाल्ड बंता

क्या यादृच्छिक विकल्प को फ्लोट तुलना द्वारा निर्धारित किया जाना है या हम यादृच्छिक पर चुन सकते हैं?

— एलेक्स ए।

क्या मैं एक कार्यक्रम पोस्ट कर सकता हूं, या यह एक फ़ंक्शन हो सकता है? यह जावा में एक बहुत ही डिस्टिब्यूशिबल डिफाइबर बनाता है।

— बैलिंट

@epicTCK इसका मतलब है कि एक आधा खुला अंतराल, यानी एक वास्तविक संख्या xऐसी है कि 0 ≤ x < 1।

— मार्टिन एंडर

@ बैलिंट दोनों ही धारणाएँ मौजूद हैं।

— मार्टिन एंडर

Answer 1

अजगर,,

m+*O2vz

इसे यहाँ आज़माएँ

फ्लोटिंग पॉइंट तुलना के बजाय एक यादृच्छिक विकल्प का उपयोग करता है, लेकिन अप्रभेद्य होना चाहिए।

विस्तार:

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]

फ्लोटिंग पॉइंट का उपयोग करना:

m+*<.5O0vz

इसे यहाँ आज़माएँ

Comments

फ़्लोटिंग पॉइंट फ़्लोटिंग पॉइंट> :(

— लीकी नून

@ केनीलाऊ परिवर्तन तुच्छ है, यह सिर्फ गोल्फ था। मुझे नहीं लगा कि इसका मतलब यह है कि यह आवश्यक था, बस यह व्यवहार समान है। मैं fp के साथ एक संस्करण जोड़ूंगा और ओपी से पूछूंगा।

— FryAmTheEggman

@ केनीलाऊ फ़्लोटिंग पॉइंट्स के बिना भाषाओं के बारे में क्या?

— वेन

@FryAmTheEggman हां, यह सिर्फ एक उदाहरण था - समान संभावना ठीक है।

— कॉनर ओ'ब्रायन

@ केनीलाउ ओपी ने पुष्टि की है कि फ्लोटिंग पॉइंट आवश्यक नहीं है।

— एलेक्स ए।

Answer 2

क्लोजर, 41 37 बाइट्स

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

बाइट्स के एक जोड़े को 0 या 1 से गुणा करके और "यदि" को गिरा दिया। अन्य सभी प्रस्तुतकर्ताओं को सबसे अधिक श्रेय!

Comments

एक अनाम फ़ंक्शन इस मामले में पर्याप्त होगा, लेकिन अच्छा जवाब; PPCG में आपका स्वागत है!

— बिल्ली

कई बार इससे forछोटा होता है map, संदर्भ के लिए मेरा उत्तर देखें :) इसके अलावा यह (fn[a k]आपके द्वारा उपयोग किए जाने वाले कोड को शुरू करने के बजाय एक आंतरिक अनाम फ़ंक्शन होने से बचता है #(।

— निकोइरिन्ह

Answer 3

जेली, 9 8 7 बाइट्स

से 8करने के लिए 7करने के लिए धन्यवाद @FryAmTheEggman ।

+2X’¤¡€

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Comments

कैसे वह डबल-एल में आप इस भाषा में सफलतापूर्वक कीबोर्ड करते हैं ?!

— मंकीज़ियस

@MonkeyZeus डेनिस ने कहा, यह सामान्य कीबोर्ड का उपयोग करके लिनक्स पर दर्ज किया जा सकता है।

— बैलिंट

@ बैलिंट प्लॉट को मोटा करता है, डेनिस कौन है? lol

— मंकीज़ियस

@MonkeyZeus अहम

— डेनिस

@ डेनिस की भविष्यवाणी पूरी हो गई है ennis (⊙ .┛) e

— मंकीज़ेउस

Answer 4

MATL , 11 बाइट्स

tZy1$rEki*+

अस्थायी बिंदु यादृच्छिक संख्या का उपयोग करता है।

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Comments

फोन से टाइप किया गया। स्पष्टीकरण बाद में

— लुइस मेंडो

@CatsAreFluffy :-) हो गया!

— लुइस मेंडू

Answer 5

जाप, 6 बाइट्स

®+V*Mq

झसे आज़माओ

---

व्याख्या

सरणी Uऔर पूर्णांक का निहित इनपुट V। (नक्शा ®) सरणी पर और, प्रत्येक तत्व के लिए, जोड़ें Vसे गुणा Mqहै, जो अनियमित या तो उत्पन्न करता है 0या 1। परिणामी सरणी का निहित उत्पादन।

Answer 6

रूबी, 28 बाइट्स

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

Answer 7

जूलिया, 33 29 27 बाइट्स

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

यह एक अनाम फ़ंक्शन है जो किसी आंतरिक अनाम फ़ंक्शन के साथ एक सरणी को स्वीकार करता है जो एक पूर्णांक को स्वीकार करता है और एक सरणी देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें और जैसे कॉल करें f(x)(k)।

हम एक ही लंबाई के साथ एक सरणी उत्पन्न करते हैं जिसमें इनपुट सरणी शून्य और समान समरूपता के साथ यादृच्छिक पर चुने गए हैं। हम इसे इनपुट पूर्णांक से गुणा करते हैं और इनपुट सरणी में जोड़ते हैं।

इसे ऑनलाइन आज़माएं!

डेनिस के लिए धन्यवाद 2 बाइट्स सहेजे गए!

Answer 8

पायथन 2, 60 58 बाइट्स

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

यह कार्यक्रम वास्तव में सरल था। वहाँ कई गोल्फ चाल नहीं हैं, स्पष्ट " from module import*" के अलावा, एक नियमित समारोह और व्हॉट्सएप की सामान्य कमी के बजाय एक लैम्ब्डा का उपयोग कर रहे हैं। इसके अलावा यह वास्तव में काफी मुहावरेदार है। अगर मैं इसे असली के लिए लिख रहा था तो मैं शायद इसे उसी तरह से करूंगा:

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

या शायद कुछ और अधिक फैंसी:

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

लेकिन यह पर्याप्त दिखावा है :)

यादृच्छिकता के लिए एक फ्लोट का उपयोग करते समय यह पुराना, 60 बाइट संस्करण है:

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

सूची के प्रत्येक तत्व के लिए, जोड़ें k*(random()<.5)। पायथन बूलियन 0 और 1 का मूल्यांकन करते हैं, इसलिए यह किसी भी तत्व में 0 जोड़ता है जिसके लिए स्थिति सही नहीं है।

पायथन का random.random()रिटर्न तैरता है [0, 1), इसलिए मुझे इस बारे में चिंता करने की जरूरत नहीं है।

Comments

@FryAmTheEggman यदि फ्लोटिंग पॉइंट आवश्यकता को गिरा दिया जाता है, तो सबसे अच्छा मैं समझ सकता हूं कि गुणन की चाल को पूरी तरह से भूल जाएं और करेंe+choice([0,k])

— अंडरग्राउंडोरेल

आह काफी सही है, गुणा करने से बचने का अच्छा तरीका। कहा कि फ़्लोटिंग पॉइंट आवश्यकता को हटा दिया गया था ताकि आप इसके बजाय अपना उत्तर बदल सकें।

— FryAmTheEggman 22

@FryAmTheEggman ओह हाहा, मैंने ध्यान नहीं दिया। अब मैं वह करूँगा, धन्यवाद :)

— भूमिगत

Answer 9

जावास्क्रिप्ट (ईएस 6), 38 बाइट्स

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

Comments

मैं एक चुनौती में भाग लेना चाहता हूं और ... जावास्क्रिप्ट ली गई है। गंभीरता से, मैं एकात्मक सीखूंगा।

— बैलिंट

@ बैलिंट मुझे पूरा यकीन है कि एकता यादृच्छिक फ़्लोट्स पैदा नहीं कर सकती है

— भूमिगत

@undergroundmonorail मैंने इसे इसलिए कहा क्योंकि कोई भी इसका उपयोग नहीं करता है (स्पष्ट कारणों के लिए, जैसे कि इसे यहां पोस्ट नहीं किया जा सकता क्योंकि यह बहुत लंबा हो जाता है)

— Bálint

Answer 10

PowerShell v2 +, 34 बाइट्स

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

क्रमशः इनपुट $aऔर $k, सरणी और int लेता है। फिर हम सरणी के माध्यम से लूप करते हैं और प्रत्येक लूप पुनरावृत्ति वर्तमान तत्व को $kकई बार आउटपुट करता है (random 2)जो निष्पादित करेगा Get-Random -Maximum 2(यानी, या तो 0एक 1)। ये सभी पाइप लाइन पर छोड़ दिए गए हैं और एक सरणी निहित है।

Answer 11

सीजेएम, 10 बाइट्स

{f{2mr*+}}

उस क्रम में ढेर के ऊपर स्थित सरणी और संख्या की अपेक्षा करता है और उन्हें नए सरणी से बदल देता है।

इसका परीक्षण यहां करें।

Answer 12

php 71 बाइट्स

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

Answer 13

k (12 बाइट्स)

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

जैसे

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

अधिक सामान्यतः, जहां f16 वर्णों के तर्क के रूप में पारित किया जा सकता है

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

जैसे

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

Comments

एक सामान्य संस्करण सहित अच्छा लगा!

— कॉनर ओ'ब्रायन

Answer 14

अजगर 3 152 110 98 बाइट्स

यह मेरा पहला कोड गोल्फ समाधान है, इसलिए मुझे कोई गुर नहीं मालूम है। मैंने परीक्षण मामलों के साथ एक मुख्य कार्य का उपयोग करके इसका परीक्षण किया। फ़ाइल का आकार केवल यह फ़ंक्शन है।

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 wh O'Bʀɪᴇɴ को धन्यवाद। 12 बाइट्स बचाने वाली सलाह के लिए @undergroundmonorail की अतिरिक्त प्रशंसा।

Comments

मैं 145 बाइट्स गिनता हूं। आप अनावश्यक व्हाट्सएप को हटाकर इसे गोल्फ कर सकते हैं, जैसे कि import *, के बीच में a(x, y), x[ptr]=z+yआदि। आप 4 जगहों को एक सिंगल स्पेस से भी बदल सकते हैं

— कॉनर ओ'ब्रायन

आप व्हॉट्सएप के 3 बाइट्स को बचाने के x[ptr]=z+yलिए उसी लाइन पर रख सकते हैं if random()>0.5। अजगर 2 में एक बाइट को बचाने के लिए 0.5लिखा जा सकता है .5, मुझे नहीं पता कि क्या अजगर 3 में सच है। यदि आप का नाम बदला ptrहै pतो आप सभी में 6 बाइट्स बचाएंगे। इसके अलावा, आप विंडोज पर हैं? विंडोज दो बाइट्स के रूप में नईलाइन्स संग्रहीत करता है, लेकिन चूंकि पायथन परवाह नहीं करता है यदि न्यूलाइन एक बाइट या दो है तो आप इसे 1 के रूप में गिन सकते हैं, जो आपके वर्तमान समाधान को केवल 103 बाइट्स बनाता है। वैसे, PPCG में आपका स्वागत है :)

— भूमिगत

Answer 15

क्लोजर, 32 बाइट्स

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

धन्यवाद डेविड rand-intविचार के लिए, निश्चित रूप से कम if(>(rand)0.5)दृष्टिकोण से। यहाँ forधड़कता है map।

Answer 16

ऑक्टेव, 28 बाइट्स

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

नमूना विचारधारा पर चलता है ।

Answer 17

05AB1E , 10 बाइट्स

कोड:

vždɲ*y+})

इसे ऑनलाइन आज़माएं! ।

Answer 18

जावा, 84 बाइट्स

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

टिप्पणियाँ

• लूप के बाद भी यह शरीर हो सकता है, आकार में कोई अंतर नहीं है।
• इनपुट ऐरे को संशोधित किया गया है, लेकिन इस मुद्दे के संबंध में बयान में कोई प्रतिबंध नहीं है। यदि आप संशोधित सरणी को "आउटपुट / रिटर्न" के रूप में गिनते हैं, तो आप हटाकर एक और 9 बाइट्स काट सकते हैं return A;। वापसी प्रकार से परिवर्तित करने की आवश्यकता होगी int[]करने के लिए void। हालाँकि यह अतिरिक्त बाइट्स को नहीं बचाता है क्योंकि एक अतिरिक्त स्थान voidऔर के बीच की आवश्यकता होती है r।

छोटा संस्करण (जैसा कि नोट में बताया गया है), 75 बाइट्स

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

उत्पादन

[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]

Comments

आपका दूसरा संस्करण मान्य नहीं है, यह आउटपुट नहीं करता है और न ही कुछ लौटाता है।

— बैलिंट

कृपया मेरी पोस्ट पढ़ें ...

— Marv

Answer 19

मठकड़, बाइट्स

---

अभी तक कोई भी औपचारिक बाइट की गिनती मथकड काउंटिंग प्रोटोकॉल के रूप में नहीं की गई है।

Answer 20

जावा 108 107 85 82 बाइट्स

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

14 बाइट्स @TimmyD की बदौलत बच गए

Comments

@TimmyD नियम कहता है कि आपको इसका उत्पादन करने की आवश्यकता है। और यह नियम ऐसा नहीं था, जब मैंने उत्तर लिखा था

— बैलिंट

मेरा मानना है कि आप के बाद अंतरिक्ष निकाल सकते हैं main, String[], int[], और बदल कर एक और कुछ बाइट्स बचाने nextFloat()>0.5के लिए next(1)==0।

— निधि मोनिका का मुकदमा

@QPaysTaxes मैं पहले से ही बदलने new java.util.Random().nextFloat()के लिए Math.random(), के रूप में यह बहुत बहुत कम है।

— बैलिंट

@TimmyD ने यह नहीं देखा कि, धन्यवाद

— Bálint

यह वर्तमान स्थिति में काम नहीं करता है। आप संशोधित नहीं करते हैं s, केवल iविधि वापस आ गई है, voidलेकिन आप लौटने की कोशिश कर रहे हैं int[]। इसके बाद एक अर्धविराम गायब हो जाता है return s।

— मार्व

Answer 21

पर्ल 5 , 30 + 1 (-ए) = 31 बाइट्स

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

इसे ऑनलाइन आज़माएं!