कारखाने के कर्मचारी

18

चुनौती

कारखाने के श्रमिक आमतौर पर बहुत मेहनती होते हैं। हालांकि, उनके काम को अब मशीनों से बदल दिया जा रहा है।

आपको एक प्रोग्राम लिखना है जो एक नंबर को इनपुट के रूप में लेता है। यह 10 श्रमिकों के कारखाने को 10 बार प्रिंट करेगा। हर बार, प्रत्येक कार्यकर्ता के पास 1/input'फायर' होने और मशीन द्वारा प्रतिस्थापित करने का मौका होता है।

इनपुट

एक पूर्णांक, STDIN या एक फ़ंक्शन कॉल से आता है।

उत्पादन

कारखाने के 10 मामले, आमतौर पर अधिक श्रमिकों के साथ प्रत्येक को निकाल दिया गया।

आउटपुट प्रारूप - कारखाने को कैसे प्रिंट किया जाए

एक कारखाना इस तरह दिखता है:

|0000000000| या |0000011001|

एक पाइप दीवारों का प्रतिनिधित्व करता है, एक 0 एक कार्यकर्ता का प्रतिनिधित्व करता है, और 1 एक मशीन का प्रतिनिधित्व करता है, इसलिए कारखाने का पहला प्रिंट हमेशा रहेगा |0000000000|।

उदाहरण

इनपुट: १०

आउटपुट:

|0000000000| //always start off with this
|0000000010| //a 1/10 chance means that this worker lost his job
|0000010010|
|0010010010|
|1010010010|
|1010110010|
|1010110011|
|1010111011|
|1010111111|
|1110111111|

इनपुट: ५

आउटपुट:

|0000000000| //always start here
|0000001001| //a 1/5 chance means that 2 workers got fired
|1000101001|
|1000101111|
|1101101111|
|1111111111| //after achieving all machinery, the machines continue to be printed
|1111111111|
|1111111111|
|1111111111|
|1111111111|

ध्यान दें

निकाल दिए गए श्रमिकों की संख्या RANDOM है - मेरे उदाहरणों में 1/5 chanceहमेशा के लिए 2 श्रमिकों को निकाल दिया जाएगा, लेकिन आपके कार्यक्रम को यह बेतरतीब ढंग से करना है - कभी-कभी 1 और कभी-कभी 3 - उनके पास गोलीबारी होने का सिर्फ 1/5 मौका है।

code-golf  ascii-art  random 
— lolad
स्रोत
1
इससे कोई फर्क नहीं पड़ता - कार्यकर्ता को बहुत भाग्यशाली माना जा सकता है;)
— 19
2
क्या 10 के इनपुट का मतलब है कि प्रत्येक कार्यकर्ता के पास हर बार अपनी नौकरी खोने का 1/10 मौका है, या कि 1/10 वीं श्रमिकों को हर बार निकाल दिया जाएगा?
— 12M2121 19:18
1
नोट में निर्दिष्ट पूर्व (कभी-कभी 1 कभी-कभी 3)
— वीजुन झोउ
1
@ 12Me21 इसका मतलब है कि प्रत्येक कार्यकर्ता को अपनी नौकरी खोने का 1/10 मौका है, बाद का नहीं।
— लोलद
6
@ एरियल नहीं, मेरा मतलब है =)
— लोलद

जवाबों:

7

जाप -R , 22 21 20 19 18 बाइट

AÆP=®|!UöêAçTÃû|C

कोशिश करो

व्याख्या

AÆP=®|!UöêAçTÃû|C     :Implicit input of integer U
A                      :10
 Æ                     :Map the range [0,A)
  P=                   :  Assign to P (initially the empty string)
    ®                  :    Map P
     |                 :      Bitwise OR with
      !                :      The negation of
       Uö              :      A random integer in the range [0,U)
         Ã             :    End Map
          ª            :    OR, for the first element when the above will still be an empty string (falsey)
           Aç          :    Ten times repeat
             T         :      Zero
              Ã        :End Map
               û|      :Centre pad each element with "|"
                 C     :  To length 12
                       :Implicitly join with newlines and output
— झबरा
स्रोत
7

आर , 92 89 बाइट्स

cat(t(cbind("|",apply("[<-"(matrix(runif(100)<1/scan(),10),1,,0),2,cummax),"|
")),sep="")

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

Ungolfed: 

m <- matrix(runif(100)<1/n,10,10)   #10x10 matrix of TRUE with probability 1/n
                                    #and FALSE with probability 1-1/n
m[1,] <- 0                          #set first row to 0
m <- apply(m,2,cummax)              #take the column cumulative maxima
m <- cbind("|",m,"|\n")             #put "|" as the first and last columns
m <- t(m)                           #transpose m for the write function
cat(m,sep="")                       #print m to stdout, separated by ""

— ग्यूसेप
स्रोत
1
मैंने इस दोपहर को सफलता के बिना replicateऔर कार्यान्वयन के विभिन्न कार्यान्वयनों का उपयोग करते हुए 92 को हराने की कोशिश में काफी समय बिताया for, लेकिन आपके सुझावों के साथ Do-while loops, मुझे आखिरकार पता चल गया है कि यह कितना अपमानजनक है {। मैंने इस दुरुपयोग को for()92 बाइट्स समाधान के लिए एक उदाहरण के साथ बढ़ाया है । हो सकता है कि आपको पहले ही {गाली के निहितार्थ का एहसास हो जाए जब आपने वह टिप पोस्ट लिखी थी, लेकिन मुझे अभी पता चला है। tio.run/##K/r/…
— Vlo
@ क्या यह सही TIO लिंक है? फिर भी, ऐसा लगता है कि आपने मुझे एक फ़ंक्शन के साथ पीटा है! मैंने आपको 82 बाइट्स के
— Giuseppe
मुझे एक आर चैटरूम शुरू करना चाहिए ... मुझे लगता "for"है कि लगभग हमेशा इससे बेहतर नहीं होता है for, और यह कभी-कभी बदतर होता है !
— ग्यूसेप
हा, बेशक pmaxइस्तेमाल किया जा सकता है। यहाँ {ऑपरेटर के बारे में मेरा पहले वाला बिंदु है । tio.run/##PZDBasNADETv@xVDfKhNjcGHXAKl5OJTT2l/…
— Vlo
6

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

n=>[...s=2e9+''].map(j=>`|${s=s.replace(/./g,i=>i&1|Math.random()*n<!+j)}|`).join`
`

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

पुनरावर्ती संस्करण, 88 बाइट्स

n=>(g=k=>k?`|${s=s.replace(/./g,i=>i%5|Math.random()*n<(s!=k))}|
`+g(k>>3):'')(s=5e9+'')

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

कैसे?

हम k = s = '5000000000' से शुरू करते हैं ।

प्रत्येक पुनरावृत्ति पर:

  • हम हर किरदार के लिए मजबूर मैं की रों एक नंबर, के लिए गणना मैं सापेक्ष 5 - तो अग्रणी है कि 5 एक की तरह व्यवहार किया जाता है 0 - और बेतरतीब ढंग से एक बिटवाइज़ प्रदर्शन या साथ 1 की उम्मीद संभावना के साथ 1 / n , पहली यात्रा पर सिवाय ।

  • काउंटर k को 3 बिट्स द्वारा राइट-शिफ्ट किया गया है। हम k = 0 जैसे ही पुनरावृत्ति को रोकते हैं , जो 10 पुनरावृत्तियाँ देता है।

    यह ध्यान रखना महत्वपूर्ण है कि 5000000000 एक 32-बिट पूर्णांक से थोड़ा बड़ा है, इसलिए यह पहली बिट बिट शिफ्ट होने से ठीक पहले 5000000000 और 0xFFFFFFFF = 705032704 में परिवर्तित हो जाता है। इसलिए निम्नलिखित कदम:

     step | k
------+-----------
   0  | 705032704
   1  | 88129088
   2  | 11016136
   3  | 1377017
   4  | 172127
   5  | 21515
   6  | 2689
   7  | 336
   8  | 42
   9  | 5
  10  | 0
— Arnauld
स्रोत
4

एपीएल (डायलॉग) , 37 बाइट्स

⎕{⎕←' '~⍨⍕'|'⍵'|'⋄×⍵+⍺=?10⍴⍺}⍣10⊢10⍴0

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

कैसे?

10⍴0 - 10 शून्य से शुरू करें।

⎕←' '~⍨⍕'|'⍵'|' - हर बार स्वरूपित सरणी प्रिंट करें,

?10⍴⍺- 1इनपुट के मान के साथ एक यादृच्छिक सरणी उत्पन्न करें ,

⍺=- इनपुट के साथ तत्व-वार तुलना। हर बार 1एक 1/ एक इनपुट देते हुए तत्वों का चिह्न / इनपुट करना चाहिए ,

⍵+ - सरणी में जोड़ें,

×- सिग्नम। शून्य शून्य रहता है, एक से अधिक कुछ भी एक में वापस आता है।

⍣10 - 10 बार दोहराएं।

— Uriel
स्रोत
उलझन में मैं हूँ, +1 =)
— lolad
3

रेटिना , 30 बाइट्स

.+
|¶10*$(*0¶
.-10+0\%0<@`\d
1

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

मुझे रेटिना ^ में यादृच्छिकता के साथ बहुत मज़ा आ रहा है

व्याख्या

पहला चरण उस स्ट्रिंग को सेट करता है जिसके साथ हम काम करेंगे:

.+
|¶10*$(*0¶

यह पूरे इनपुट को |एक नई लाइन के साथ बदल देता है , और फिर 10 लाइनों से युक्त होता है, 0जैसा कि इनपुट कहता है। प्रत्येक लाइन पर पहला चरित्र कारखाने के एक कार्यकर्ता का प्रतिनिधित्व करेगा।

निम्न चरण का अर्थ है:

.                     Disable automatic printing at the end of the program
 -10+                 Do the following exactly 10 times:
       %                For each line:
        0<                Print the first character, then
          @`\d            Pick a random digit and
1 (on the next line)      replace it with a 1
     0\                 Then print the first character of the whole string
                        followed by a newline

वर्किंग स्ट्रिंग की पहली पंक्ति में केवल एक होता है |, जो लूप के प्रत्येक पुनरावृत्ति द्वारा मुद्रित पहला वर्ण होगा (पहली पंक्ति का पहला वर्ण होने के नाते), और प्रत्येक पुनरावृत्ति के अंत में भी मुद्रित किया जाएगा (पहली होने के नाते) पूरे स्ट्रिंग का चरित्र)। इस लाइन पर प्रतिस्थापन का कभी कोई प्रभाव नहीं पड़ेगा क्योंकि इसमें कोई अंक नहीं है।

प्रत्येक दूसरी पंक्ति में nअंक होते हैं , इसलिए पंक्ति nके पहले वर्ण को बदलने के लिए 1 में मौका होता है (जो कि केवल एक सार्थक है) a 1।

— सिंह
स्रोत
3

पॉवरशेल , 82 80 69 बाइट्स

param($x)($a=,0*10)|%{"|$(-join$a)|";$a=$a|%{$_-bor!(Random -ma $x)}}

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

इनपुट लेता है $x। सभी शून्य की एक सरणी बनाता है, उस में बचत करता है $aऔर फिर कई बार लूप करता है। आसानी से, कारखाने के रूप में व्यापक रूप में यह पुनरावृत्तियों के लायक है। प्रत्येक पुनरावृत्ति, हम अपने वर्तमान कारखाने का उत्पादन करते हैं "|$(-join$a)|", फिर प्रत्येक तत्व के माध्यम से लूप करते हैं $a।

हम वर्तमान तत्व चयन किए जाने वाले के अंदर $_है कि कर दिया गया है -binary- orसाथ एड या तो 1के आधार पर Randomइनपुट के आधार पर मौका $x। उदाहरण के लिए, निवेश के लिए 10, Get-Random -max 10के बीच है जाएगा 0और 9और हो 0लगभग 1 / समय की 10 वीं। इस प्रकार, एक !(...)रैपिंग के साथ Random, हमें 1लगभग एक 1/inputसमय की राशि मिलेगी , और दूसरी 1-1/inputबार हम प्राप्त करेंगे $_। हां, इसका अर्थ कभी-कभी होता है कि हम 1दूसरे के साथ ओवरराइट कर रहे हैं 1, लेकिन यह ठीक है।

इसके परिणामस्वरूप सरणी को $aअगले गो-राउंड के लिए वापस संग्रहीत किया जाता है । परिणामी तार के सभी पाइप लाइन पर छोड़ दिए जाते हैं, और Write-Outputकार्यक्रम पूरा होने पर निहित हमें मुफ्त में नए अंक देता है।

-2 बाइट्स Veskah के लिए धन्यवाद।
-11 बाइट्स ASCII- केवल के लिए धन्यवाद।

— AdmBorkBork
स्रोत
— विस्कह
@Veskah हाँ, यह अच्छी तरह से काम करेगा। धन्यवाद!
— AdmBorkBork
— केवल
— केवल
@ ASCII- केवल ओह यकीन है, $aजब हम पहले से ही इसके माध्यम से लूप कर रहे हैं, तो हम पुन: अनुक्रमण क्यों कर रहे हैं? योग्य और वह एक चतुर चाल है -bor। धन्यवाद!
— AdmBorkBork
2

पर्ल 6 , 58 बाइट्स

{say "|$_|" for 0 x 10,|[\~|] ([~] +(1>$_*rand)xx 10)xx 9}

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

+(1 > $_ * rand)1एस की आवश्यक आवृत्ति के साथ एक एकल बिट उत्पन्न करता है । xx 10उस अभिव्यक्ति को दस बार बिट्स की सूची के रूप में एक एकल कारखाना उदाहरण बनाने के लिए दोहराता है, और [~]उस सूची को एक स्ट्रिंग में जोड़ता है। xx 9उस फैक्ट्री-स्ट्रिंग-जनरेटिंग एक्सप्रेशन को नौ बार दोहराता है, और फिर [\~|]एक त्रिभुजाकार कमी (जिसे कुछ अन्य भाषाएं "स्कैन" कहती हैं) को स्ट्रीकवाइज़ या ऑपरेटर के साथ जोड़ देती हैं ~|, जिससे कि पहले के पुनरावृत्ति में निकाल दिया गया श्रमिक बाद के वाले में निकाल दिया जाता है।

— शॉन
स्रोत
1
अच्छा लगा। आप पहले स्थान को हटा सकते हैं for। संख्या-आधारित समाधान को {say "|{.join}|"for [\<<+|>>] (?$++X*!<<^$_).roll(10)xx 10}मैं दो बाइट्स पर काम कर रहा था। इसके साथ [\Z+|]56 बाइट्स होंगे, लेकिन यह किसी कारण से काम नहीं करता है।
— nwellnhof
1
आप के $_*randसाथ भी बदल सकते हैं .rand। जिस तरह से मैं नियमों की व्याख्या करता हूं, "कारखाने" तार की सूची को वापस करना भी ठीक होना चाहिए।
— nwellnhof
2

पायथन 2 , 104 103 बाइट्स

from random import*
x='0'*10;i=input()
exec"print'|%s|'%''.join(x);x=[choice('1'+n*~-i)for n in x];"*10

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

— छड़ी
स्रोत
क्षमा करें, आपको आउटपुट का प्रारूप तैयार करने की आवश्यकता है
— lolad
@ लोलड तय c:
— रॉड
अच्छी तरह से किया, +1 =)
— 21:18 पर लोलद
2

जेली , 22 बाइट्स

ẋ⁵ẋ€⁵¬1¦X€€=1o\j@€⁾||Y

पूर्ण प्रोग्राम को पूर्णांक को कमांड लाइन इनपुट के रूप में स्वीकार करते हुए आउटपुट को STDOUT में प्रिंट करता है।
(एक राक्षसी लिंक के रूप में यह पात्रों और पूर्णांकों की सूची देता है।)

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

कैसे?

प्रत्येक चरण में प्रभावी ढंग से निर्णय लेता है यदि प्रत्येक कार्यकर्ता (किसी भी मशीन सहित) अपनी नौकरी खो देता है (एन मौका में एक के साथ), हालांकि मशीनों को मशीनों (तार्किक-या का उपयोग करके) द्वारा प्रतिस्थापित किया जाता है।

ẋ⁵ẋ€⁵¬1¦X€€=1o\j@€⁾||Y - Main link: integer, N
 ⁵                     - literal ten
ẋ                      - repeat -> [N,N,N,N,N,N,N,N,N,N]
    ⁵                  - literal ten
  ẋ€                   - repeat €ach -> [[N,N,N,N,N,N,N,N,N,N],...,[N,N,N,N,N,N,N,N,N,N]]
       ¦               - sparse application...
      1                - ...to indices: [1]
     ¬                 - ...do: logical-NOT -> [[0,0,0,0,0,0,0,0,0,0],[N,N,...],...]
        X€€            - random integer for €ach for €ach
                       -   (0s stay as 0s; Ns become random integers in [1,N])
           =1          - equals one? (vectorises)
             o\        - cumulative reduce with logical-OR
                  ⁾||  - literal list of characters = ['|','|']
               j@€     - join with sw@pped arguments for €ach
                     Y - join with line feeds
                       - implicit print
— जोनाथन एलन
स्रोत
2

MATL , 26 बाइट्स

'|'it10th&Yr=0lY(Y>48+y&Yc

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

(लंबी) व्याख्या

उदाहरण स्टैक सामग्री को रास्ते में दिखाया गया है। प्रत्येक चरण पर, स्टैक सामग्री को नीचे से ऊपर तक दिखाया गया है।

'|'    % Push this character
       % STACK: '|'
it     % Take input. Duplicate
       % STACK: '|'
                5
                5
10th   % Push [10 10]
       % STACK: '|'
                5
                5
                [10 10]
&Yr    % Random 10×10 matrix of integers from 1 to input number
       % STACK: '|'
                 5
                 [4 5 4 4 5 5 2 1 2 3
                  3 4 3 3 1 4 4 3 1 5
                  5 1 4 5 4 4 5 2 3 2
                  3 4 5 2 1 3 2 5 3 4
                  4 1 2 2 4 1 1 5 1 1
                  4 5 3 1 5 3 5 2 4 1
                  2 1 4 3 3 1 3 5 3 5
                  1 2 2 1 2 2 4 3 5 3
                  4 5 4 1 2 2 5 3 2 4
                  4 1 2 5 5 5 4 3 5 1]
=      % Is equal? Element-wise
       % STACK: '|'
                [0 1 0 0 1 1 0 0 0 0
                 0 0 0 0 0 0 0 0 0 1
                 1 0 0 1 0 0 1 0 0 0
                 0 0 1 0 0 0 0 1 0 0
                 0 0 0 0 0 0 0 1 0 0
                 0 1 0 0 1 0 1 0 0 0
                 0 0 0 0 0 0 0 1 0 1
                 0 0 0 0 0 0 0 0 1 0
                 0 1 0 0 0 0 1 0 0 0
                 0 0 0 1 1 1 0 0 1 0]
0lY(   % Write 0 in the first row
       % STACK: '|'
                [0 0 0 0 0 0 0 0 0 0
                 0 0 0 0 0 0 0 0 0 1
                 1 0 0 1 0 0 1 0 0 0
                 0 0 1 0 0 0 0 1 0 0
                 0 0 0 0 0 0 0 1 0 0
                 0 1 0 0 1 0 1 0 0 0
                 0 0 0 0 0 0 0 1 0 1
                 0 0 0 0 0 0 0 0 1 0
                 0 1 0 0 0 0 1 0 0 0
                 0 0 0 1 1 1 0 0 1 0]
Y>     % Cumulative maximum down each column
       % STACK: '|'
                [0 0 0 0 0 0 0 0 0 0
                 0 0 0 0 0 0 0 0 0 1
                 1 0 0 1 0 0 1 0 0 1
                 1 0 1 1 0 0 1 1 0 1
                 1 0 1 1 0 0 1 1 0 1
                 1 1 1 1 1 0 1 1 0 1
                 1 1 1 1 1 0 1 1 0 1
                 1 1 1 1 1 0 1 1 1 1
                 1 1 1 1 1 0 1 1 1 1
                 1 1 1 1 1 1 1 1 1 1]
48+    % Add 48, element-wise. This transforms each number into the
       % ASCII code of its character representation
       % STACK: '|'
                [48 48 48 48 48 48 48 48 48 48
                 48 48 48 48 48 48 48 48 48 49
                 49 48 48 49 48 48 49 48 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 49 49 49 49 49]
y      % Duplicate from below
       % STACK: '|'
                [48 48 48 48 48 48 48 48 48 48
                 48 48 48 48 48 48 48 48 48 49
                 49 48 48 49 48 48 49 48 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 49 49 49 49 49]
                 '|'
&Yc    % Horizontally concatenate all stack contents as char arrays.
       % 1-row arrays are implicitly replicated along first dimension
       % STACK: ['|0000000000|'
                 '|0000000001|'
                 '|1001001001|'
                 '|1011001101|'
                 '|1011001101|'
                 '|1111101101|'
                 '|1111101101|'
                 '|1111101111|'
                 '|1111101111|'
                 '|1111111111|']
       % Implicitly display
— लुइस मेंडो
स्रोत
2

जावास्क्रिप्ट (Node.js) , 105 93 90 बाइट्स

x=>w.map(a=>(`|${w=w.map(j=>j|Math.random()<1/x),w.join``}|
`)).join``,w=Array(10).fill(0)

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

फंक्शन के अंदर एरे लगाने के लिए +2 बाइट्स, जो बाहर इशारा करने के लिए @ शागी को धन्यवाद देते हैं

(x,w=Array(10).fill(0))=>w.map(a=>(`|${w=w.map(j=>j|Math.random()<1/x),w.join``}|
`)).join``

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

— जोस्ट के
स्रोत
1
ध्यान दें कि कार्यों को यहां पुन: प्रयोज्य करने की आवश्यकता है, इसलिए आपके फ़ंक्शन के भीतरw घोषित करने की आवश्यकता होगी ।
— शैगी
@ शैगी, धन्यवाद मैंने इसे संपादित किया। दुर्भाग्य से इसने 2 बाइट्स जोड़े
— जोस्ट के
2

सी (जीसीसी) , 110 106 बाइट्स

-4 बाइट्स @ceilingcat से

char l[]="|0000000000|",i,j;f(n){for(srand(time(i=0));i++<10;)for(j=!puts(l);j++<10;)rand()%n||(l[j]=49);}

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

प्रतिस्थापन के प्रत्येक दौर के लिए वर्णों की एक सूची के माध्यम से Iterates।

Ungolfed:

f(n)
{
    //start with a fresh factory
    char l[]="|0000000000|";

    //init rng
    srand(time(0));

    //print 11 lines
    for(int i = 0; i < 11; i++)
    {
        //print current factory
        puts(l);

        //iterate through the workers. start at index 1 to skip the '|'
        for(int j = 1; j < 11; j++)
        {
            //the expression (rand()%n) has n possible values in the range [0,n-1],
            //so the value 0 has 1/n chance of being the result and thus the worker
            //has 1/n chance of being replaced
            if(rand()%n == 0)
            {
                l[j] = '1';
            }
        }
    }
}
— vazt
स्रोत
मुझे लगता है कि आप 1 बहुत अधिक कारखानों को मुद्रित करते हैं। उदाहरण 10 दिखाता है, लेकिन आपका TIO लिंक 11 दिखाता है।
— ब्रायन जे
हम्म तुम सही हो। मैंने इसे 11 में बदल दिया, किसी और के समाधान पर एक टिप्पणी पढ़ने के बाद उन्हें बताया कि यह 11 माना जाता है, लेकिन मैंने वास्तव में चुनौती से उदाहरण का सत्यापन नहीं किया। धन्यवाद
— vazt
1

स्माइलबासिक, 75 बाइट्स

INPUT N
FOR J=0TO 9?"|";BIN$(F,10);"|
FOR I=0TO 9F=F OR!RND(N)<<I
NEXT
NEXT
— 12Me21
स्रोत
1

05AB1E , 22 बाइट्स

TÅ0TFDJ'|.ø=sITи€L€ΩΘ~

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

गोल्फिंग के लिए कुछ और कमरे होने चाहिए।

  • TÅ0 - 10 जीरो की सूची पुश करें।
  • TF... - ऐसा 10 बार करें:
    • DJ - वर्तमान आइटम को डुप्लिकेट करें और इसमें शामिल हों।
    • '|.ø= - इसे दो से घेरें | एस से घेरें और STDOUT पर प्रिंट करें।
    • ITи - 10 बार इनपुट दोहराएं।
    • €L€Ω- और प्रत्येक घटना के लिए, एक यादृच्छिक तत्व प्राप्त करें [1 ... N] । (इसमें एक बिल्ट-इन हो सकता है जो मैंने अभी तक नहीं देखा है)
    • Θ- पुश 05AB1E सत्यवादी ™। प्रत्येक के लिए, जांचें कि क्या यह 1 के बराबर है ।
    • s...~ - तार्किक या वर्तमान आइटम द्वारा परिणाम।
— मिस्टर एक्सकोडर
स्रोत
1

जावास्क्रिप्ट, 83 बाइट्स

f=(n,t=9,s=`|0000000000|
`)=>t?s+f(n,t-1,s.replace(/0/g,v=>+(Math.random()<1/n))):s

कोड स्निपेट दिखाएं

— TSH
स्रोत
— झबरा
1

जावा 10, 153 152 131 बाइट्स

n->{for(int j=10,a[]=new int[j],i;j-->0;){var s="|";for(i=0;i<10;a[i++]|=Math.random()*n<1?1:0)s+=a[i];System.out.println(s+"|");}}

-18 बाइट्स @ OlivierGrégoire को धन्यवाद , और जावा 8 को जावा 10 में परिवर्तित करके -3 बाइट्स।

स्पष्टीकरण:

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

n->{                             // Method with integer parameter and no return-type
  for(int j=10,a[]=new int[j],i; //  Create the array with 10 workers (0s)
      j-->0;){                   //  Loop 10 times

    var s="|";                   //  Start a String with a wall
    for(i=0;i<10;                //  Loop `i` from 0 to 10 (exclusive)
        a[i++]                   //    After every iteration, change the current item to:
         |=                      //     If it's a 0:
           Math.random()*n<1?    //      If the random value [0:1) is below 1/n
            1                    //       Change the worker to a machine
           :                     //      Else:
            0;                   //       It remains a worker
                                 //     Else (it already is a machine)
                                 //      It remains a machine
      s+=a[i];                   //   Append the current item to the String
    System.out.println(s+"|");}} //   Print the String, with a trailing wall and new-line
— केविन क्रूज़सेन
स्रोत
1
131 बाइट्स । बदलें varद्वारा Stringजावा 9 के लिए और नीचे और एक अतिरिक्त 3 बाइट्स के लिए। मैंने मूल रूप से आपके पास दो छोरों को मिला दिया है।
— ओलिवियर ग्राएगोइरे
1

चारकोल , 30 29 27 बाइट्स

⊞υ×χ0Ｆχ⊞υ⭆§υ±¹‽⁺1×κ⊖θＥυ⪫||ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

⊞υ×χ0

0खाली सूची में 10 एस की एक स्ट्रिंग पुश करें u।

Ｆχ

अगले आदेश को 10 बार दोहराएं।

⊞υ⭆§υ±¹‽⁺1×κ⊖θ

अंतिम स्ट्रिंग के प्रत्येक चरित्र के लिए, इसे n-1बार-बार दोहराएं , एक जोड़ें 1, और स्ट्रिंग से एक यादृच्छिक चरित्र चुनें। इससे 1/nचरित्र को बदलने का मौका मिलता है 1। परिणाम को धक्का दिया है u।

Ｅυ⪫||ι

तार की सूची पर नक्शा, प्रत्येक के साथ आसपास है |, तो स्पष्ट रूप से प्रत्येक अपनी लाइन पर मुद्रित करें।

— नील
स्रोत
0

एपीएल + विन, 30 40 35 बाइट्स

कोई रिक्त स्थान के बारे में थोड़ा याद किया; (- तय किया और उरेल के लिए -3 बाइट्स के लिए धन्यवाद

नंबर के स्क्रीन इनपुट के लिए संकेत

'|',(⍕0⍪×+⍀n=?9 10⍴n←⎕)[;2×⍳10],'|'

उरीएल के समान स्पष्टीकरण:

?9 10⍴n create a 9x10 matrix of numbers selected at random between 1 and number

×+⍀n= compare elements of matrix to number, cumulatively sum columns and signum

[;2×⍳10] take non-space columns

'|',(⍕0⍪.......,'|' concatenate a row of zeros and front and back columns of |
— ग्राहम
स्रोत
9 10⍴?90⍴5→ ?9 10⍴5। आपको रिक्त स्थान को भी खत्म करने की आवश्यकता है
— यूरिल
@ 3 बाइट्स के लिए एरियल धन्यवाद और मैंने कोई स्पेस नियम नहीं छोड़ा था।
— ग्राहम
0

VBA, 144 बाइट्स

Sub f(i)
Dim w(9) As Long
For x = 0 To 9
s = "|"
For y = 0 To 9
s = s & w(y)
If i * Rnd() < 1 Then w(y) = 1
Next
Debug.Print s; "|"
Next
End Sub

आसान पढ़ने के लिए प्रस्तुत:

Sub f(i)
    Dim w(9) As Long
    For x = 0 To 9
        s = "|"
        For y = 0 To 9
            s = s & w(y)
            If i * Rnd() < 1 Then w(y) = 1
        Next
        Debug.Print s; "|"
    Next
End Sub

2 अंकों का लाभ उठाता है: VBA Arrays बेस 0 के लिए डिफ़ॉल्ट होगा (इसलिए w(9)यह उसी तरह हैw(0 to 9) ) और एक लॉन्ग के रूप में एरे का निर्माण करना स्वचालित रूप से इसे 0 से प्रारंभ करेगा।

( आमतौर पर , 20 बाइट्स ऑटो-स्वरूपण हैं जो VBA जोड़ता है लेकिन वास्तव में आवश्यक नहीं है - 19 रिक्त स्थान और एक अर्ध-उपनिवेश)

— Chronocidal
स्रोत
0

मुझे रूबी का उत्तर अभी तक नहीं मिला, इसलिए:

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

n=gets.to_i
z='0'*x=10
x.times do
puts'|'+z+'|'
x.times do|s|
z[s]='1' if rand(n)==0
end
end

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

— Turophile
स्रोत
के rand(n)<1बजाय का उपयोग करके एक बाइट बचाओ rand(n)==0, और के {..}बजाय का उपयोग करके कुछ बचा do..end, जैसेx.times{puts'|'+z...}
— Piccolo
0

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

->n{f=[0]*10;10.times{p"|#{f.join}|";f.map!{|l|rand>(1.0/n)?l:?1}}}

मुझे लगता है कि मैंने यहां कुछ चीजों को धोखा दिया है। सबसे पहले, यह फ़ंक्शन आउटपुट को प्रत्येक पंक्ति के आसपास उद्धरण के साथ प्रिंट करता है, जैसे:

pry(main)> ->n{f=[0]*10;10.times{p"|#{f.join}|";f.map!{|l|rand>(1.0/n)?l:?1}}}[5]
"|0000000000|"
"|0100100000|"
"|0100100000|"
"|0100100000|"
"|0100100100|"
"|0100110100|"
"|0101110100|"
"|0111110100|"
"|1111110110|"
"|1111110110|"
=> 10

यदि यह अस्वीकार्य है (यह देखते हुए कि यह आस्की-कला है , तो शायद यही मामला है), यहाँ एक समाधान है जो 70 बाइट्स के उद्धरण के बिना प्रिंट करता है :

->n{f=[0]*10;10.times{puts"|#{f.join}|";f.map!{|l|rand>(1.0/n)?l:?1}}}

स्पष्टीकरण:

->n{                                                              } # defines anonymous lambda
    f=[0]*10;                                                       # initializes f to [0,0,0,...] (10)
             10.times{                                           }  # main loop
                      p"|#{f.join}|";                               # joins f and prints | before and after
                                     f.map!{|l|                 }   # maps each element of f
                                               rand>(1.0/n)? :      # if rand is greater than 1.0/n
                                                            l ?1    # keep current element or replace with '1'
— छोटा पियानो
स्रोत
0

PHP, 71 70 बाइट्स

मर्जिंग लूप्स 5 बाइट्स (फिर से) को बचाया:

for(;$k<91;$v|=!rand(0,$argn-1)<<$k++%10)$k%10||printf("|%010b|
",$v);

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

1 संपादित करें: निश्चित प्रारूप और पहला आउटपुट (अतिरिक्त गोल्फिंग के लिए बाइट गिनती में कोई परिवर्तन नहीं)
संपादित करें 2: एक और बाइट : अंतिम मुद्रण के बाद, किसी को फायर करने की कोई अधिक आवश्यकता नहीं है।

— टाइटस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.