मेरे माइनस्वीपर टाइल के चारों ओर क्या है?

Question

माइनस्वीपर एक पहेली खेल है जहाँ सभी खानों के स्थान की पहचान करने के लक्ष्य के साथ खानों को नोंडेसस्क्रिप्ट टाइल्स के चारों ओर छिपाया जाता है। एक खदान पर क्लिक करने से खेल खो जाता है, लेकिन किसी भी अन्य टाइल पर क्लिक करने से 0-8 से एक संख्या प्रकट होगी जो यह संकेत देती है कि कितनी खदानें सीधे इसे घेरती हैं।

एक संख्या को देखते हुए, आपको खाली टाइलों और उसके आस-पास की खदानों का एक यादृच्छिक * संभव संयोजन प्रदर्शित करना होगा। यह एक 3x3 सरणी के रूप में होना चाहिए। केंद्र टाइल इनपुट के रूप में ली गई खानों की संख्या होनी चाहिए।

* सभी संयोजनों को होने के लिए एक गैर-शून्य मौका होना चाहिए।

---

उदाहरण

_ = blank square
X = mine

0

___
_0_
___

1

_X_
_1_
___

1

___
_1_
X__

___
_1_
__X

4

_X_
X4X
_X_

4

X_X
_4_
X_X

4

___
X4X
X_X

8

XXX
X8X
XXX

---

इनपुट

• केंद्र टाइल के आसपास की खानों की संख्या (0-8)

---

उत्पादन

• आउटपुट का कोई उचित रूप जो टाइलों के 3x3 सरणी को प्रदर्शित करता है

---

अन्य नियम

• प्रत्येक संयोजन को होने की समान संभावना नहीं होती है। आपके प्रोग्राम को निष्पादित करते समय बस प्रत्येक संयोजन का एक गैर-शून्य मौका होना चाहिए।
• किसी भी 2 पात्रों को खदान और खाली टाइल के लिए चुना जा सकता है।
• यह कोड गोल्फ है, सबसे कम बाइट्स जीतने वाला कार्यक्रम।

Comments

"किसी भी 2 वर्णों को खदान और खाली टाइल के लिए चुना जा सकता है" क्या हम अभी भी उपयोग कर सकते हैं, कह सकते हैं, 1और 0?

— जोनाथन एलन

@JonathanAllan मैं कहूँगा हाँ, 0/1 इनपुट मामले थोड़े भ्रमित करने वाले हो सकते हैं लेकिन मुझे नहीं लगता कि यह एक बड़ी बात है।

— अनामिका

एक फ्लैट, 9-तत्व सूची 'आउटपुट का उचित रूप' है?

— चास ब्राउन

@ChasBrown नहीं, एक फ्लैट सूची वास्तव में समकक्ष नहीं है।

— अनामिका

Answer 1

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

<Ɱ8Ẋs4js3

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

खाली = 1
मेरा =0

ध्यान दें कि 1और 0पूर्णांक हैं।

एक और नोट: यह कुछ हद तक जोनाथन एलन के 10-बाइट के उत्तर के समान है, लेकिन यह वास्तव में किसी भी तरह से इससे प्रभावित नहीं है, और तंत्र, यदि आप करीब से ध्यान देते हैं, तो वास्तव में पहली नज़र में अलग है।

Comments

ऊ आई आई ट्रिक :)

— जोनाथन एलन

@JonathanAllan क्या आपको लगता है कि यह आपके लिए काफी करीब है? प्रत्यय वैसे भी समान है ...

— एरिक द आउटग्राफर

यह थोड़ा अलग है। अगर मैं एक पोस्ट पढ़ता हूं और एक त्वरित गोल्फ पाता हूं तो मैं टिप्पणी करता हूं; अगर मैं सिर्फ चुनौती को हल करने की कोशिश कर रहा हूं, जो मैं पोस्ट करता हूं। मैंने स्वतंत्र रूप से पहले समान कोड पोस्ट किया है।

— जोनाथन एलन

@JonathanAllan मेरा दृष्टिकोण थोड़ा अलग है, अगर मुझे पता चलता है कि मेरा स्वतंत्र समाधान वास्तव में लगभग किसी और के समान है, लेकिन थोड़े अलग तत्व के साथ जो बाइट या दो (व्यक्तिपरक राय) बचाता है, मैं टिप्पणी करता हूं, अन्यथा मैं outgolf। इसलिए मैंने पूछा था, लेकिन आप मुझे इसे यहाँ पोस्ट करना पसंद करते हैं, इसलिए ...

— एरिक द आउटग्राफर

Answer 2

एपीएल (डायलॉग यूनिकोड) , 28 15 बाइट्स

-13 बाइट्स ngn के लिए धन्यवाद!

{3 3⍴5⌽⍵,⍵≥8?8}

स्पष्टीकरण:

{...}एक सीधा कार्य (D-Fn), ⍵इसका सही तर्क है।

8?8 सूची से 8 यादृच्छिक संख्या का सौदा 1..8:

      8?8                         
7 2 1 8 4 6 5 3

⍵≥ उनमें से प्रत्येक के लिए तर्क अधिक या बराबर है ?:

      5 ≥ 7 2 1 8 4 6 5 3   
0 1 1 0 1 0 1 1

⍵, बूलियन सूची में तर्क को प्रस्तुत करें:

      5 , 0 1 1 0 1 0 1 1
5 0 1 1 0 1 0 1 1

5⌽ सूची को 5 स्थिति बाईं ओर घुमाएं, ताकि तर्क केंद्र में हो:

      5 ⌽ 5 0 1 1 0 1 0 1 1
1 0 1 1 5 0 1 1 0

3 3⍴ सूची को 3x3 मैट्रिक्स में फिर से सेट करें:

      3 3 ⍴ 1 0 1 1 5 0 1 1 0
1 0 1
1 5 0
1 1 0

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

जे , 15 बाइट्स

इसके अलावा कई बाइट्स ngn के लिए धन्यवाद!

3 3$5|.],]>8?8:

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

Comments

(8↑1⍴⍨⍵)[8?8]-> ⍵>8?8(मानते हुए ⎕io←0)

— नागिन

3 3⍴1↓,⍵,2 4⍴->3 3⍴5⌽⍵,

— ngn

@ng धन्यवाद! मुझे अपने क्रियात्मक प्रयास से शर्म महसूस होती है ...

— गैलेन इवानोव

शर्म की कोई आवश्यकता नहीं है :) धन्यवाद - इस जवाब ने मुझे कुछ J

— ngn

वह J उत्तर वास्तव में प्यारा है।

— जोनाह

Answer 3

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

@Tsh द्वारा सुझाया गया छोटा संस्करण

खाली स्लॉट हैं 0, खदानें हैं 1।

n=>`___
_${t=9,n}_
___`.replace(/_/g,_=>n-(n-=Math.random()<n/--t))

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

---

मूल परीक्षण और त्रुटि संस्करण, 78 बाइट्स

खाली स्लॉट हैं _, खदानें हैं 7।

f=(n,o=`___
_${k=n}_
___`.replace(/_/g,c=>Math.random()<.5?--k|7:c))=>k?f(n):o

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

टिप्पणी की गई

f = (                         // f = recursive function
  n,                          // n = input
  o = `___\n_${k = n}_\n___`  // o = minesweeper field / k = backup of n
    .replace(/_/g, c =>       // for each underscore character c in o:
      Math.random() < .5 ?    //   random action:
        --k | 7               //     either decrement k and yield 7
      :                       //   or:
        c                     //     let the underscore unchanged
    )                         // end of replace()
) =>                          //
  k ?                         // if k is not equal to 0:
    f(n)                      //   try again
  :                           // else:
    o                         //   stop recursion and return o

Comments

69 बाइट्स ( सँवारना )

— TSH

Answer 4

जेली ,  13  10 बाइट्स

8Ẉ>RẊs4js3

सूचियों की लौटी हुई सूची में क्रमशः 0 और 1s से घिरे केंद्र में प्रदर्शित पूर्णांक होते हैं जो क्रमशः खानों और रिक्त स्थान का प्रतिनिधित्व करते हैं।

इसे ऑनलाइन आज़माएं! (पाद सुंदर सरणी प्रिंट)

कैसे?

8Ẉ>RẊs4js3 - Link: integer, n                   e.g.  3
8          - eight                                    8
 Ẉ         - length of each (implicit range of eight) [1,1,1,1,1,1,1,1]
   R       - range of n                               [1,2,3]
  >        - greater than? (vectorises)               [0,0,0,1,1,1,1,1]
    Ẋ      - shuffle                                  [1,1,1,0,0,1,1,0]
     s4    - split into chunks of 4                   [[1,1,1,0],[0,1,1,0]]
       j   - join (with n)                            [1,1,1,0,3,0,1,1,0]
        s3 - split into chunks of 3                   [[1,1,1],[0,3,0],[1,1,0]]

Comments

छोटे नोट के रूप ŒHमें, के स्थान पर भी काम करता है s4।

— श्री एक्सकोडर

; Jun4s3 भी काम करता है

— dylnan

@dylnan मैं वास्तव में एक टीआईओ के साथ अपने गोल्फ के दौरान एक बिंदु पर एक ही कोड के साथ पोस्ट किया था (लेकिन जल्दी से इसे वापस डाल दिया ताकि मुझे स्पष्टीकरण को फिर से लिखना न पड़े)।

— जोनाथन एलन

Answer 5

पायथ, 16 14 बाइट्स

c3jQc2.S.[d8*N

सहेजे गए 2 बाइट्स isaacg के लिए धन्यवाद।
खानों के लिए सुरक्षित स्थानों और उद्धरणों के लिए रिक्त स्थान का उपयोग करता है।
इसे यहाँ आज़माएँ

व्याख्या

c3jQc2.S.[d8*N
            *NQ     Get (implicit) input number of quotes...
        .[d8        ... and pad to length 8 with spaces.
      .S            Shuffle.
  jQc2              Stick the input in the middle.
c3                  Split into three.

Comments

.[d8के बजाय>8+*8d

— isaacg

Answer 6

Oracle 18 SQL, 230 बाइट्स

गोल्फ की भाषा नहीं बल्कि ...

WITH v(v)AS(SELECT*FROM SYS.ODCINUMBERLIST(0,1))SELECT v.v||b.v||c.v||'
'||d.v||n||e.v||'
'||f.v||g.v||h.v
FROM n,v,v b,v c,v d,v e,v f,v g,v h
WHERE v.v+b.v+c.v+d.v+e.v+f.v+g.v+h.v=n
ORDER BY DBMS_RANDOM.VALUE
FETCH NEXT ROW ONLY

nस्तंभ के साथ तालिका में इनपुट मान है n:

CREATE TABLE n(n) AS
SELECT 7 FROM DUAL;

इसे ऑनलाइन आज़माएं - https://livesql.oracle.com पर लॉग इन करें और इसे वर्कशीट में पेस्ट करें ।

आउटपुट:

V.V||B.V||C.V||''||D.V||N||E.V||''||F.V||G.V||H.V
-------------------------------------------------
101 
171 
111

सभी संभव संयोजनों को प्राप्त करने के लिए (183 बाइट्स):

WITH v(v)AS(SELECT*FROM SYS.ODCINUMBERLIST(0,1))SELECT v.v||b.v||c.v||'
'||d.v||n||e.v||'
'||f.v||g.v||h.v
FROM n,v,v b,v c,v d,v e,v f,v g,v h
WHERE v.v+b.v+c.v+d.v+e.v+f.v+g.v+h.v=n

आउटपुट:

V.V||B.V||C.V||''||D.V||N||E.V||''||F.V||G.V||H.V
-------------------------------------------------
111 
171 
110

111 
171 
101

111 
171 
011

111 
170 
111

111 
071 
111

110 
171 
111

101 
171 
111

011 
171 
111

Answer 7

जाप, 13 बाइट्स

çÊú8 öÊi4U ò3

कोशिश करो

---

व्याख्या

                   :Implicit input of integer U
 Ê                 :"l"
ç                  :Repeat U times
  ú8               :Pad right to length 8
    öÊ             :Random permutation
       i4U         :Insert U at index 4
            ò3     :Split at every 3rd character

Answer 8

QBasic 1.1 , 206 186 बाइट्स

RANDOMIZE TIMER
INPUT N
O=N
Z=8-N
FOR I=0TO 7
IF O*Z THEN
R=RND<.5
O=O+R
Z=Z-1-R
A(I)=-R
ELSEIF O THEN
O=O-1
A(I)=1
ELSE
Z=Z-1
A(I)=0
ENDIF
NEXT I
?A(0)A(1)A(2)
?A(3)N;A(4)
?A(5)A(6)A(7)

-20 डीकोस (नव-तैनात गोल्फिंग चाल) के लिए धन्यवाद ।

खाली = 0
मेरा =1

ध्यान दें कि 0और 1पूर्णांक हैं, लेकिन मैं वैसे भी STDOUT का उपयोग कर रहा हूं, इसलिए ...

आउटपुट इस तरह दिखाई देता है:

 A  B  C
 D  x  E
 F  G  H

जहाँ AH 0/1 है और x इनपुट है।

Comments

अच्छी चाल, QBasic की खदान और खाली टाइल के लिए नंबरों का उपयोग करके बड़ी संख्या में उत्पादन के साथ काम करना!

— DLosc

Answer 9

चारकोल , 19 बाइट्स

Ｗ¬⁼ΣＩＫＡ⁸«Ｅ³⭆³‽²↑↗↖θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। एक खाली जगह के लिए 0, एक खदान के लिए उपयोग करता 1है। स्पष्टीकरण:

     ＫＡ             Peek the entire canvas
    Ｉ               Cast to integer
   Σ                Take the sum
       ⁸            Literal 8
  ⁼                 Equals
 ¬                  Logical Not
Ｗ       «           While
          ³ ³       Literal 3
         Ｅ          Map over implicit range
           ⭆        Map over implicit range and join
              ²     Literal 2
             ‽      Random element of implicit range
                    Implicitly print on separate lines
               ↑↗↖θ Print the original input in the middle

• Peekस्ट्रिंग्स की एक सरणी देता है, जो Sumबस समेटता है, यही वजह है कि हमें पहले पूर्णांक पर कास्ट करना पड़ता है। ( Sum(Sum(PeekAll()))भी काम करता है।)
• SumNoneएक खाली सरणी (पहला लूप) के लिए रिटर्न , इसलिए एकमात्र सुरक्षित तुलना है Not(Equals(...))।
• निलारी Randomहमेशा लौटता है 0, हालांकि इसका प्रलेखन अन्यथा कहता है।

वैकल्पिक समाधान, 19 बाइट्स था, अब चारकोल बगफिक्स के बाद 17 बाइट्स:

θ←9Ｗ⁻ΣＩＫＡ⁸ＵＭＫＭＩ‽²

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। एक खाली जगह के लिए 0, एक खदान के लिए उपयोग करता 1है। स्पष्टीकरण:

θ

मूल इनपुट प्रिंट करें।

←9

एक 9बाईं ओर प्रिंट करें । यह कर्सर को मूल इनपुट पर वापस ले जाता है, और लूप के कम से कम एक पुनरावृत्ति को भी बाध्य करता है (अन्यथा इनपुट 8कुछ नहीं करेगा)।

Ｗ⁻ΣＩＫＡ⁸

कैनवास और 8 पर सभी अंकों के योग के बीच का अंतर है

ＵＭＫＭＩ‽²

आस-पास के प्रत्येक वर्ण को अनियमित रूप से 0या के साथ बदलें 1।

Answer 10

आर , 67 63 62 59 बाइट्स

matrix(c(sample(rep(1:0,c(n<-scan(),8-n))),n),6,5)[2:4,1:3]

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

उपयोग 1और 0। एक n* 1 +(8-n)* 0वेक्टर बनाएँ , इसे फेरबदल करता है, जोड़ता है n, नीचे दिखाए गए बड़े मैट्रिक्स का निर्माण करता है (जहां a...iमूल वेक्टर के तत्वों के लिए खड़ा होता है) और अपरकेस में दिखाए गए उचित उप-मैट्रिक्स को निकालता है:

     [,1] [,2] [,3] [,4] [,5]
[1,] "a"  "g"  "d"  "a"  "g" 
[2,] "B"  "H"  "E"  "b"  "h" 
[3,] "C"  "I"  "F"  "c"  "i" 
[4,] "D"  "A"  "G"  "d"  "a" 
[5,] "e"  "b"  "h"  "e"  "b" 
[6,] "f"  "c"  "i"  "f"  "c"

Comments

एक बाइट छोटी:matrix((c(sample(rep(1:0,c(n<-scan(),8-n))),n))[c(1:4,9:5)],3)

— ग्रेगर

@Gregor आप सही हैं एक सरणी संभवतः एक सरणी प्रदर्शित करने के लिए आउटपुट का एक उचित रूप है :)

— JayCe

Answer 11

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

from random import*
def f(n):a=[1]*n+[0]*(8-n);shuffle(a);a[4:4]=[n];return zip(*[iter(a)]*3)

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

0खाली के लिए; 1एक खदान के लिए; और nस्वयं के लिए।

Comments

का उपयोग iterस्मार्ट है!

— जोनाथन एलन

@ जोनाथन एलन: xnor ने मुझे दिखाया कि बस दूसरे दिन।

— चेस ब्राउन

Answer 12

अटैच , 51 बाइट्स

{[3,3]&Rotate[Sample[{Sum@_=_2}&_\BinBelow@8]'_,4]}

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

व्याख्या

करने के लिए इसी तरह के गैलेन के जम्मू / एपीएल जवाब , बुनियादी तकनीक 1s और खानों की सही संख्या के साथ 0 की एक सरणी उत्पन्न करने के लिए, और अंत तक यह जोड़कर सरणी घूर्णन ऐसी है कि केंद्र में इनपुट झूठ, तब तक इनपुट डालने है 3x3 मैट्रिक्स में पुन: आकार देना।

भाग 1: बाइनरी सरणी उत्पन्न करना

ऐसा करने के बारे में जाने के कई तरीके हैं, लेकिन मैं मुख्य रूप से दो प्रकारों में हुआ: क्रूर बल और चयन।

प्राथमिक जानवर बल विधि इस तरह दिखती है:

NestWhile[{Random[8&2]},0,{Sum@_/=_2}&_]

यह 8 बाइनरी अंकों ( Random[8&2]) के यादृच्छिक सरणियों को उत्पन्न करता है, जबकि उनकी रकम इनपुट के बराबर नहीं होती है {Sum@_/=_2}&_। यह थोड़ा वर्बोज़ है, क्योंकि कोड के निम्नलिखित ज़ोर दिए गए भाग "बस इसे काम करने के लिए" हैं:

NestWhile[{Random[8&2]},0,{Sum@_/=_2}&_]
          ^           ^^^^^        ^^^^

और मैंने विचार त्याग दिया।

चयन अधिक रोचक है। मुख्य अवधारणा का उपयोग करने के लिए है BaseBelow[b, n]निर्मित है, जो सभी base- की एक सूची उत्पन्न bचौड़ाई के पूर्णांक nसे, (अंकों सरणियों के रूप में) 0करने के लिए b^n-1। उदाहरण के लिए, BaseBelow[3, 2]चौड़ाई 2 के सभी टर्नरी पूर्णांक बनाता है:

A> BaseBelow[3, 2]
 0 0
 0 1
 0 2
 1 0
 1 1
 1 2
 2 0
 2 1
 2 2

हम विशेष रूप BaseBelow[2, 8]से चौड़ाई के सभी द्विआधारी पूर्णांक के लिए उपयोग करते हैं। ये सभी लंबाई के सभी संभव खदानों का प्रतिनिधित्व करते हैं। यह पहला चरण हैं।

दूसरा चरण केवल N1s के साथ ऐसे सभी सरणियों का चयन कर रहा है , जहां Nइनपुट है। मेरा पहला विचार इस अंग्रेजी कथन को सीधे अताशे में अनुवाद करना था:

Chunk[SortBy[Sum,BaseBelow[2,8]],Sum]@N@1

हालांकि, न केवल यह उपरोक्त दृष्टिकोण की तुलना में 1 बाइट से अधिक लंबा हो गया है, यह अत्यधिक दोहराव भी है - और यह अभी तक यादृच्छिक नहीं है! ज़रूर, मैं शायद 1 बाइट को बचाने के लिए कह सकता हूं कि BaseBelowइसे कैसे कहा जाता है, लेकिन यह केवल दृष्टिकोण का उपयोग करने के लायक नहीं है।

इसलिए मैंने एक पत्थर से दो पक्षियों को मारने और एक Shuffleआधारित दृष्टिकोण का उपयोग करने का फैसला किया । निम्नलिखित Nयादृच्छिक क्रम में लंबाई के सभी वैध खदान देता है :

{Sum@_=_2}&N\Shuffle[BaseBelow&8!2]

फिर, वह सब करने की ज़रूरत है जो पहले का चयन करना है। लेकिन मैं बेहतर कर सकता हूं - निश्चित रूप से यह केवल Sampleफ़िल्टर किए गए सरणी के लिए बेहतर होगा ? यह दृष्टिकोण कुछ इस प्रकार है:

Sample[{Sum@_=_2}&_\BaseBelow[2,8]]

मुझे BaseBelow&8!2गोल्फ को वापस करना पड़ा क्योंकि \पूर्ववर्तीता बहुत अधिक है। अन्यथा संतुष्ट, मैं एक बाइट काट कर आगे बढ़ा:

Sample[{Sum@_=_2}&_\2&BaseBelow@8]

(मुझे यहां एक डाइएडिक फ़ंक्शन को सफलतापूर्वक कॉल करने का एक और तरीका पता चला है: x&f@yएक उच्च-मिसाल अभिव्यक्ति है जो इसका मूल्यांकन करती है f[x, y])।

हालांकि, इसके बावजूद, मुझे याद है कि, सभी के साथ, 2&BaseBelowअस्तित्व के लिए एक उपनाम BinBelow:। इसलिए मैंने इसका इस्तेमाल किया:

Sample[{Sum@_=_2}&_\BinBelow@8]

यह वांछित माइनफील्ड उत्पन्न करता है। मुझे यकीन है कि यह इष्टतम के पास है।

भाग 2: सरणी का निर्माण

जैसा कि पहले कहा गया था, मैंने जो तकनीक का उपयोग किया वह J / APL उत्तर के समान है, इसलिए मैं बहुत अधिक विस्तार में नहीं जाऊंगा। मान लीजिए MINEFIELDकि अंतिम अनुभाग से परिणाम है। फ़ंक्शन तब बन जाता है:

{[3,3]&Rotate[MINEFIELD'_,4]}

MINEFIELD'_मूल इनपुट के साथ माइनफील्ड को सम्‍मिलित करता है _, हमें ऐसा कुछ देता है:

[1, 0, 0, 0, 1, 0, 0, 1, 3]

फिर, Rotate[MINEFIELD'_,4]इस सूची 4को बाईं ओर घुमाते हुए, केंद्र को रखते हुए:

[1, 0, 0, 1, 3, 1, 0, 0, 0]

अंतिम चरण का उपयोग [3,3]&सूची को 3x3 मैट्रिक्स में फिर से देखने के लिए कर रहा है:

 1 0 0
 1 3 1
 0 0 0

Answer 13

जावा 10, 165 157 141 बाइट्स

n->{var r="___\n_"+n+"_\n___";for(int i;n>0;r=r.charAt(i*=Math.random())>58?r.substring(0*n--,i)+(i>9?0:0+r.substring(i+1)):r)i=11;return r;}

खाली टाइलें हैं _(58 से ऊपर के यूनिकोड मूल्य वाला कोई भी पात्र ठीक है) और खदानें हैं 0।

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

स्पष्टीकरण:

n->{                           // Method with integer parameter and String return-type
  var r="___\n_"+n+"_\n___";   //  Result-String, starting at:
                               //   "___
                               //    _n_
                               //    ___"
  for(int i;n>0                //  Loop as long as `n` isn't 0 yet:
      ;                        //    After every iteration:
       r=r.charAt(i*=Math.random())
                               //     Select a random integer in the range [0,11)
         >58?                  //     And if the character at this random index is a '_':
          r.substring(0*n--,i) //      Set `r` to the first part excluding character `i`,
                               //      (and decrease `n` by 1 in the process)
          +(i>9?0:0+           //      appended with a '0',
           r.substring(i+1))   //      appended with the second part
         :                     //     Else:
          r)                   //      Leave `r` unchanged
     i=11;                     //   Set `i` to 11 so a new random integer can be chosen
  return r;}                   //  Return the result

Answer 14

पॉवरशेल , 77 बाइट्स

param($n)-join(0..7|random -c 8|%{'X_'[$_-ge$n]
$n[++$i-ne4]
'
'*($i-in3,5)})

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

Answer 15

PHP , 135 134 123 117 117 122 बाइट्स

इसके बजाय प्रिंट करने के लिए स्ट्रैप पर लूपिंग 1 बाइट बचाता है

str_split और केंद्र संख्या डालने के लिए निहित 11 बाइट्स बचाता है

$ 6 बाइट्स को सहेजने के लिए स्ट्रिंग को असाइन करने की आवश्यकता नहीं है
हाँ आप करते हैं। वरना हर गूँज के बाद तार कटा हुआ है ...

इको के बाद व्हॉट्सएप को हटाने से 1 बाइट बचती है

Ctual लाइन ब्रेक के साथ "\ n" को बदलने से 1 बाइट बचती है

$n=$argv[1];$s=implode($n,str_split(str_shuffle(str_pad(str_repeat(m,$n),8,n)),4));for(;$i<9;)echo$s[$i].(++$i%3?"":"
");

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

Answer 16

एलिस , 24 बाइट्स

a8E/be?SZ!@
~E-\ita*.o/a

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

खाली स्लॉट हैं 9, और खदानें हैं 0।

मैंने 1खानों के लिए और 0खाली स्लॉट्स के लिए एक 27-बाइट प्रोग्राम भी बनाया :

a8Ea8/be?SZ!@
-E-9:\ita*.o/

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

Answer 17

पॉवरशेल , 91 86 बाइट्स

^{-5 बाइट्स mazzy के लिए धन्यवाद}

param($n)$x=,'X'*$n+,'_'*(8-$n)|random -c 8
-join$x[0..2]
$x[3,4]-join$n
-join$x[5..7]

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

से उत्पन्न स्ट्रिंग (बाईं ओर से प्रतिस्थापित) ________को फेरबदल करता है XXXXXXXX। यह तब कई बार इसके माध्यम से स्लाइस करता है, $nआउटपुट स्ट्रिंग बनाने के लिए, बीच में सम्मिलित करता है। यह अंतिम भाग संभवतः काफी अनुकूलित किया जा सकता है क्योंकि प्रत्येक सूचकांक में न्यूनतम 5 बाइट्स होती हैं।

Comments

अच्छा। 86 बाइट्स

— माज़ी

Answer 18

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

स्ट्रिंग्स की एक सूची देता है (प्रत्येक पंक्ति के लिए एक)।

->n{a=([0]*(8-n)+[1]*n).shuffle;a[4,0]=n;a.join.scan /.../}

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

Answer 19

सी (जीसीसी) , 81 बाइट्स

f(n,i,j,k){for(j=i=8,k=n;--i+5;putchar(i%4?i-2?rand()%j--<k?k--,88:95:48+n:10));}

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

Answer 20

पर्ल 5 -pa , 105 101 बाइट्स

@o=grep!/^....1/&&y/1//=="@F",map{sprintf"%09b",$_}0..2**9-1;$_=$o[rand@o];s/....\K./@F/;s/...\K/\n/g

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

Answer 21

05AB1E , 12 बाइट्स

$×8j.r2äIý3ô

0खानों के लिए उपयोग , रिक्त वर्गों के लिए रिक्त स्थान। लाइनों की एक सूची को आउटपुट करता है, जो न्यूलाइन सीमांकक ( ») के साथ जुड़कर नीचे TIO में बहुत मुद्रित होता है ।

इसे ऑनलाइन आज़माएं या एक बार में कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

$             # Push 0 and the input-digit
 ×            # Repeat the 0 the input-digit amount of times as string
              #  i.e. 4 → "0000"
  8j          # Prepend spaces to make the size 8
              #  → "    0000"
    .r        # Randomly shuffle the characters in this string
              #  i.e. "    0000" → " 00 0  0"
      2ä      # Split it into two equal halves (of 4 characters)
              #  → [" 00 ","0  0"]
        Iý    # Join it with the input-digit
              #  → " 00 40  0"
          3ô  # And then split it into (three) parts of 3 characters
              #  → [" 00"," 40","  0"]
              # (which is output implicitly as result)

12 बाइट्स वैकल्पिक:

8L@.rIš5._3ô

1खानों के लिए, 0खाली वर्गों के लिए उपयोग । एक अंक के मैट्रिक्स को आउटपुट करता है, जो प्रत्येक पंक्ति में शामिल होने से नीचे TIO में बहुत मुद्रित होता है, और फिर इन पंक्तियों को न्यूलाइन सीमांकक ( J») के साथ।

इसे ऑनलाइन आज़माएं या एक बार में कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

8L            # Push the list [1,2,3,4,5,6,7,8]
  @           # Check for each if the (implicit) input-integer is >= it
              # (1 if truthy; 0 if falsey)
              #  i.e. 4 → [1,1,1,1,0,0,0,0]
   .r         # Randomly shuffle this list
              #  i.e. [1,1,1,1,0,0,0,0] → [0,1,1,0,1,0,0,1]
     Iš       # Prepend the input-digit to the list
              #  → [4,0,1,1,0,1,0,0,1]
       5._    # Rotate the list five times towards the left
              #  → [1,0,0,1,4,0,1,1,0]
          3ô  # And then split it into (three) parts of 3 digits each
              #  → [[1,0,0],[1,4,0],[1,1,0]]
              # (which is output implicitly as result)