अराजकता एक ASCII सीढ़ी है

Question

आप कुछ भी नहीं जानते हैं कि " अराजकता एक सीढ़ी है " के लिए जो चीजें मैं करता हूं वह टेलीविजन श्रृंखला गेम ऑफ थ्रोन्स की एक यादगार रेखा है।

इस चुनौती का उद्देश्य ASCII कला में अराजकता से एक सीढ़ी का निर्माण करना है।

चुनौती

इनपुट

• सीढ़ी की चौड़ाई, W >= 3(पूर्णांक)
• चरण ऊंचाई, H >= 2(पूर्णांक)
• रुंगों की संख्या, N >= 2(पूर्णांक)।

उत्पादन

एक क्षैतिज सीढ़ी और ऊर्ध्वाधर रेल के साथ एक सीढ़ी , सभी 1 वर्ण चौड़ी है। सीढ़ी की चौड़ाई ( W) में दो रेलें शामिल हैं, और चरण ऊंचाई ( H) में संगत रग शामिल है।

ऊपरवाले और सबसे निचले हिस्से सहित सभी जंगों में, H-1ऊपर और नीचे सीधे लम्बाई के लम्बे रेल का एक टुकड़ा होगा । उदाहरण से यह स्पष्ट हो जाएगा।

सीढ़ी के प्रयास किए जाएंगे प्रिंट करने योग्य, गैर-सफ़ेद ASCII वर्ण , कि है, से समावेशी रेंज !(कोड बिंदु 33करने के लिए) ~(कोड बिंदु 126) व्याप्ति वास्तविक पात्रों का चयन किया जाएगा बेतरतीब ढंग से । इनपुट्स को देखते हुए, वर्णों के प्रत्येक यादृच्छिक विकल्प में नॉनज़रो प्रायिकता होनी चाहिए। इसके अलावा, संभावना वितरण मनमाना है।

व्हाट्सएप के प्रमुख या अनुगामी या तो क्षैतिज या ऊर्ध्वाधर होने की अनुमति है।

उदाहरण

यह देखते हुए W=5, H=3, N=2, एक संभावित आउटपुट निम्नानुसार है।

x   :
g   h
q$UO{
t   T
6   <
bUZXP
8   T
5   g

ध्यान दें कि कुल ऊंचाई है H*(N+1)-1, क्योंकि वहाँ खंड Nऔर N+1ऊर्ध्वाधर खंड हैं।

सशर्त नियम

• इनपुट के साधन और प्रारूप हमेशा की तरह लचीले होते हैं । उदाहरण के लिए, आप किसी भी क्रम में तीन संख्याओं को इनपुट कर सकते हैं, या उन्हें युक्त कर सकते हैं।

• आउटपुट STDOUT या एक फ़ंक्शन द्वारा लौटाए गए तर्क के माध्यम से हो सकता है। इस मामले में यह newlines, एक 2D चरित्र सरणी या तार की एक सरणी के साथ एक स्ट्रिंग हो सकता है।

• एक कार्यक्रम या एक समारोह प्रदान किया जा सकता है।

• मानक खामियों को मना किया जाता है।

• बाइट्स में सबसे छोटा कोड जीतता है।

परीक्षण के मामलों

प्रत्येक के लिए W, H, Nएक संभावित आउटपुट दिखाया गया है।

W=5, H=3, N=2:

\   ~
:   K
ke:[E
5   u
0   _
8Fr.D
#   r
7   X


W=3, H=2, N=2:

$ X
Mb)
0 ]
(T}
j 9


W=12, H=4, N=5:

d          Y
P          `
5          3
p$t$Ow7~kcNX
D          x
`          O
*          H
LB|QX1'.[:[F
p          p
x          (
2          ^
ic%KL^z:KI"^
C          p
(          7
7          h
TSj^E!tI&TN8
|          [
<          >
=          Q
ffl`^,tBHk?~
O          +
p          e
n          j


W=20, H=5, N=3:

G                  %
o                  y
%                  3
-                  7
U'F?Vml&rVch7{).fLDF
o                  }
U                  I
h                  y
a                  g
;W.58bl'.iHm\8v?bIn&
,                  U
N                  S
4                  c
5                  r
F3(R|<BP}C'$=}xK$F]^
'                  h
h                  u
x                  $
6                  5    

Comments

क्या आप अस्सी वर्णों के लिए (संख्यात्मक) सीमा जोड़ सकते हैं?

— रॉड

@ अच्छा विचार है। हो गया

— लुइस मेंडो

यादृच्छिकता की गुणवत्ता पर किस तरह की निचली सीमा है? मुझे लगता है कि एक यादृच्छिक बिंदु पर शुरू होता है और आसन्न मूल्यों के बीच स्पष्ट संबंध के कारण मोडुलो (126-33) बढ़ाना संभव नहीं होगा। या क्या यह हर संभव अनुक्रम का निर्माण करने में सक्षम होना चाहिए? (तो एक 8-बिट रैखिक बधाई जनरेटर काम नहीं करेगा, क्योंकि एक चरित्र विशिष्ट रूप से अगले चरित्र को निर्धारित करता है?)

— पीटर कॉर्ड्स

@PeterCordes कुछ सहसंबंध होने के साथ कोई समस्या नहीं है , जब तक कि हर संभव संयोजन हो सकता है। आपके द्वारा वर्णित दृष्टिकोण है, जैसा कि आप कहते हैं, मान्य नहीं है क्योंकि यह विभिन्न पदों पर वर्णों के बीच बहुत मजबूत सांख्यिकीय निर्भरता का परिचय देता है, जिससे कुछ संयोजन असंभव हो जाते हैं

— लुइस मेंडो

@PeterCordes हां, मेरा मतलब सैद्धांतिक रूप से था। RNG ताकत के बारे में चिंता मत करो; आप मान सकते हैं कि RNG आदर्श है। इस बारे में कुछ मेटा सर्वसम्मति है। मैंने सोचा था कि कुछ और विशिष्ट है, लेकिन मुझे जो कुछ भी मिला वह यह था और यह

— लुइस मेंडू

Answer 1

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

«þỊoU$ẋ⁵‘¤Ḋ×94X€€+32ỌY

एक पूर्ण कार्यक्रम तीन तर्कों लेने W, H, Nऔर परिणाम मुद्रण।

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

कैसे?

नीचे एकल पग और उसके ऊर्ध्वाधर खंडों के 2d सरणी मास्क का निर्माण करता है, इसे N+1बार-बार दोहराता है और शीर्ष क्रम को हटाता है और फिर मुखौटे के मूल्य के आधार पर यादृच्छिक वर्ण या रिक्त स्थान रखता है।

«þỊoU$ẋ⁵‘¤Ḋ×94X€€+32ỌY - Main link: W, H (N is third input / 5th command line argument)
 þ                     - outer product (build a table using):
«                      -  minimum
                       -  ...note: þ implicitly builds ranges of W and H prior
  Ị                    - insignificant? (abs(z)<=1) - yields a W by H 2-d array,
                       -   all zeros except the left and top edges which are 1s
     $                 - last two links as a monad:
    U                  -   upend (reverse each row)
   o                   -   or (vectorises) - giving us our |‾| shape of 1s
         ¤             - nilad followed by link(s) as a nilad:
       ⁵               -   5th command line argument, N
        ‘              -   increment -> N+1
      ẋ                - repeat list - giving us our ladder-mask plus a top rung)
          Ḋ            - dequeue - remove the top rung
            94         - literal ninety-four
           ×           - multiply (vectorises) - replace the 1s with 94s
              X€€      - random for €ach for €ach - 0 -> 0; 94 -> random integer in [1,94]
                  32   - literal thirty-two
                 +     - add (vectorises) - 0 -> 32; random integers now from [33,126]
                    Ọ  - character from ordinal (vectorises)
                     Y - join with newlines
                       - implicit print

Answer 2

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 643 624 बाइट्स

f={l=["""","!","#","$","%","&","'","(",")","*","+",",","-",".","/","0","1","2","3","4","5","6","7","8","9",":",";","<","=",">","?","@","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","[","\","]","^","_","`","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","{","|","}","~"];t=_this;w=t select 0;r={l select random 92};v="";s=v;i=2;while{i<w}do{i=i+1;v=v+" "};p={i=1;while{i<t select 1}do{i=i+1;s=s+call r+v+call r+"\n"}};k=0;call p;while{k<t select 2}do{k=k+1;i=0;while{i<w}do{i=i+1;s=s+call r};s=s+"\n";call p};s}

हास्यास्पद रूप से लंबा है क्योंकि वर्ण कोड से वर्ण बनाने का कोई तरीका नहीं है।

के साथ बुलाना:

hint ([5, 3, 2] call f)

आउटपुट:

सीढ़ी अतिरिक्त अराजक है, क्योंकि फ़ॉन्ट मोनोपोज़ नहीं है।

unrolled:

f =
{
    l = ["""","!","#","$","%","&","'","(",")","*","+",",","-",".","/","0","1","2","3","4","5","6","7","8","9",":",";","<","=",">","?","@","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","[","\","]","^","_","`","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","{","|","}","~"];

    t = _this;
    w = t select 0;

    r =
    {
        l select random 92
    };

    v = "";
    s = v;

    i = 2;
    while {i < w} do 
    {
        i = i + 1;
        v = v + " "
    };

    p =
    {
        i = 1;
        while {i < t select 1} do 
        {
            i = i + 1;
            s = s + call r + v + call r + "\n"
        }
    };

    k = 0;
    call p;
    while {k < t select 2} do 
    {
        k = k + 1;

        i = 0;
        while {i < w} do
        {
            i = i + 1;
            s = s + call r
        };
        s = s + "\n";

        call p
    };

    s
}

Comments

यह "\n"काम करता है के रूप में लगता है , "\xa3"कुछ पाने के लिए £काम नहीं करता है? यदि आप यूनिकोड से बच सकते हैं तो आप उस सरणी को ट्रिम कर सकते हैं।

— सुचालका

मैं इसे खुद कैसे चला सकता हूं? : D

— Geeky I

यह सिर्फ एक स्क्रिप्ट की तरह लग रहा था और रिक्त स्थान और नए अंक हटा दिए गए थे। क्या यह केवल एक सीढ़ी की छवि के कारण बढ़ रहा है या मैंने कुछ चतुर गोल्फ को याद किया है?

— जोनाथन एलन

@steadybox जब आप उस एक प्रश्न xD पर एक गैर-घास के मैदान स्क्रीनशॉट का अनुरोध करने के बाद अब प्रासंगिक स्क्रीनशॉट का उपयोग कर रहे हैं?

— मैजिक ऑक्टोपस Urn

@Tsllllacka \nही एकमात्र मान्यता है जो मान्यता प्राप्त है। (और ""एक का प्रतिनिधित्व करने के लिए उद्धरण के अंदर ")

— स्टेडीबॉक्स

Answer 3

05AB1E , 29 बाइट्स

आदेश में इनपुट लिया गया N, H, W

>*GNUžQ¦©.RIÍFð®.R«X²Öè}®.RJ,

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

व्याख्या

>*G                              # for N in [1 ... (N+1)*H)-1] do:
   NU                            # store N in variable X
     žQ                          # push a string of printable ascii
       ¦©                        # remove the first (space) and save a copy in register
         .R                      # pick a random character
           IÍF                   # W-2 times do:
              ð                  # push a space
               ®.R               # push a random ascii character
                  «              # concatenate
                   X²Ö           # push X % H == 0
                      è          # index into the string of <space><random_char> with this
                       }         # end inner loop
                        ®.R      # push a random ascii character
                           J,    # join everything to a string and print

Comments

यह थोड़ा धोखा है।

— vdegenne

@ user544262772 ऐसा क्यों?

— जोनाथन एलन

क्या आप इसे थोड़ा समझा सकते हैं?

— मिशा

@MischaBehrend: निश्चित रूप से, मैंने अब एक स्पष्टीकरण जोड़ा है।

— एमिग्ना

@ user544262772 यह एक गोल्फ की भाषा में एक अच्छी तरह से गोल्फ का जवाब देने के लिए काफी चुनौतीपूर्ण हो सकता है, मेरा विश्वास करो, वे गोल्फिंग के लिए डिज़ाइन किए गए हैं, लेकिन उनका उपयोग करने के लिए आमतौर पर कुछ विचार की आवश्यकता होती है (जब तक कि यह सिर्फ यहाँ एक अंतर्निहित नहीं है, ठीक वैसा ही जैसा आप चाहते हैं ")।

— जोनाथन एलन

Answer 4

सी, 95 बाइट्स

f(w,h,n,i){++w;for(i=0;i++<w*~(h*~n);)putchar(i%w?~-i%w%(w-2)*((i/w+1)%h)?32:33+rand()%94:10);}

Answer 5

आर , 138 129 111 98 93 बाइट्स

-13 बाइट्स नील फुल्टेज को धन्यवाद!

रॉबिन राइडर को -1 बाइट धन्यवाद

function(W,H,N){m=matrix(intToUtf8(32+sample(94,W*(h=H*N+H-1),T),T),h)
m[-H*1:N,3:W-1]=" "
m}

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

अनाम फ़ंक्शन; मैट्रिक्स के रूप में परिणाम देता है।

उस वर्ड ग्रिड सवाल के लिए धन्यवाद , मैं सामान्य से बहुत अधिक मैट्रिसेस के बारे में सोच रहा हूं। मैंने देखा कि रुंग्स उन मैट्रिक्स पंक्तियों में होते हैं जो कि स्टेप हाइट के कई गुणक होते हैं H(R-1-indexed), और यह कि रेल पहले और अंतिम कॉलम हैं, 1और W। इसलिए मैं यादृच्छिक ASCII वर्णों का एक मैट्रिक्स बनाता हूं, और उन पत्रों को प्रतिस्थापित करता हूं जो रिक्त स्थान के साथ उन मानदंडों से मेल नहीं खाते हैं, और मैट्रिक्स को वापस करते हैं। TIO लिंक इसे अच्छी तरह से प्रिंट करता है।

नील फ़ुल्ट्ज़ ने अंतरिक्ष वर्णों के लिए एक अलग अनुक्रमणिका का सुझाव दिया [-H*(1:N),3:W-1], जो सभी वर्णों को छोड़कर उन सभी को गुणकों की पंक्तियों में छोड़ देता है H: -H*(1:N)और किनारे पर नहीं, 3:W-1<==> 2:(W-1)।

आर , 121 बाइट्स

function(W,H,N)for(i in 1:(H*N+H-1)){for(j in 1:W)cat("if"(!(i%%H&j-1&j-W),sample(intToUtf8(33:126,T),1)," "))
cat("\n")}

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

मेरे द्वारा शुरू किए गए मूल मैट्रिक्स-आधारित दृष्टिकोण पर सुधार; यह एक ही एल्गोरिथ्म है, लेकिन forलूप एक मैट्रिक्स के निर्माण और मुद्रण से छोटे हैं (लेकिन अगर मैं इसे प्रिंट नहीं करता हूं!)

Comments

m[-H*(1:N),3:W-1]=" "थोड़ा छोटा लगता है - आप हमेशा परीक्षण को बदल सकते हैं rowऔर col2-डी स्लाइस के साथ।

— नील फुल्ट्ज

@NealFultz वाह, यह काफी उत्कृष्ट है! धन्यवाद!

— ग्यूसेप

के sample(33:126,...)साथ प्रतिस्थापित करके -1 बाइट 32+sample(94,...)।

— रॉबिन राइडर

Answer 6

पर्ल 5 , 81 बाइट्स

80 बाइट्स कोड + 1 के लिए -p।

/ \d+ /;$_=(($}=(_.$"x($`-2)._.$/)x($&-1))._ x$`.$/)x$'.$};s/_/chr 33+rand 94/ge

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

Comments

लालची मैच के कारण \

— _

Answer 7

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

Ｅ…¹×⁺¹ＮＮ⪫ＥＩζ⎇∧﹪ιＩη﹪λ⁻Ｉζ¹ §⮌γ‽⁹⁴ω

इसे ऑनलाइन आज़माएं! आदेश एन, एच, डब्ल्यू। वर्बोस सन्निकटन में इनपुट लेता है ( Plus(InputNumber(), 1)वर्तमान में टीआईओ पर टूट गया है)। स्पष्टीकरण:

Ｅ…¹×⁺¹ＮＮ

सीमा पर नक्शा 1..H*(N+1)। इसका मतलब यह है कि जब iएक से अधिक होते हैं तो रूंग दिखाई देते हैं H।

⪫

के परिणाम में शामिल हों:

ＥＩζ

अंतर्निहित सीमा पर मैपिंग 0..W:

⎇∧﹪ιＩη﹪λ⁻Ｉζ¹ 

यदि स्तंभ है 0या नहीं है W-1और पंक्ति एक से अधिक नहीं है Hतो एक स्थान आउटपुट करें;

§⮌γ‽⁹⁴

अन्यथा, पूर्वनिर्धारित ASCII वर्ण चर लें, इसे उल्टा करें (स्थान को 94 वें स्थान पर रखकर), और अब जो पहले 94 है उससे एक यादृच्छिक वर्ण मुद्रित करें। (क्योंकि Sliceबेकार है।)

ω

खाली स्ट्रिंग का उपयोग करके जुड़ें। अंतिम परिणाम स्पष्ट रूप से मुद्रित होता है।

Comments

यकीन नहीं होता कि यह मददगार है, लेकिन आप सीढ़ी को खींच सकते हैं और फिर मुझे लगता है कि यादृच्छिक प्रिंट करने योग्य है? संपादित करें यह टूटा हुआ प्रतीत होता है। उफ़।

— एएससीआईआई-केवल

मैं इसे ठीक करने की कोशिश करूँगा (बहुत यकीन है कि यह पहले काम कर रहा था) लेकिन मैं थोड़ा व्यस्त रहा हूं इसलिए इसमें थोड़ा समय लग सकता है

— ASCII-only

@ ASCII- केवल मुझे लगता है कि आप सोच रहे हैं ＮθＧＨ↓θ→Ｎ↑θ*‖Ｏ↓Ｆ⁻Ｎ¹Ｃ⁰θ¿ＥＫＡ§⮌γ‽⁹⁴«? खैर, मैंने a0a6316इसे काट दिया और इसे तोड़ दिया।

— नील

@ ASCII- केवल वास्तव में यह बिल्कुल सच नहीं है, एक असंबंधित बग था Mapजहां इसका उपयोग not is_commandतब किया गया था जब इसका मतलब था is_command। तो आप ＮθＧＨ↓θ→Ｎ↑θ*‖Ｏ↓Ｆ⁻Ｎ¹Ｃ⁰θＵＭＫＡ§⮌γ‽⁹⁴यह लिखना चाहते थे कि क्या यह उस बग के लिए नहीं था।

— नील

Answer 8

C (gcc) , 141 131 114 109 107 बाइट्स

यह थोड़ा नीचे गोल्फ में सक्षम होना चाहिए ...

i,j,c;f(w,h,n){for(i=1;i<h*n+h;i+=j==w)printf(i%h?i++,j=0,"%c%*c\n":"%c",++j^w?c^8:10,w-2,c=33+rand()%94);}

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

Comments

क्या हम i=1वैश्विक घोषणा में संपादित कर सकते हैं ?

— मुकुल कुमार

Answer 9

पर्ल 6 , 76 73 बाइट्स

->\h,\n,\w{map {chrs (roll(w,1..94)Z*1,|($_%%h xx w-2),1)X+32},1..^h*n+h}

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

तर्क के रूप में (एच, एन, डब्ल्यू) लेता है। तार की सूची लौटाता है।

स्पष्टीकरण:

-> \h, \n, \w {  # Block taking arguments h, n, w
    map {
        # String from codepoints
        chrs
             # Generate w random numbers between 1 and 94
             (roll(w, 1..94)
              # Set inner numbers on non-rungs to zero
              Z* 1, |($_%%h xx w-2), 1)
             # Add 32 to numbers
             X+ 32
    }
    # Map h*n+h-1 row numbers (1-indexed)
    1..^h*n+h
}

Comments

इसके बजाय वैकल्पिक 73 बटर का उपयोग करना xxऔर । हो सकता है कि आप किसी भी बाइट को बंद करने के लिए एक जगह पा सकते हैं? ++$map

— जो किंग

Answer 10

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

param($w,$h,$n)-join([char[]]((($a=('#'+' '*($w-2)+"#`n")*--$h)+'#'*$w+"`n")*$n+$a)|%{($_,[char](33..126|Random))[$_-eq35]})

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

हम केवल #पहली ( उदाहरण ) से बनी एक सीढ़ी का निर्माण करते हैं , फिर |%{...}प्रत्येक चरित्र के माध्यम से लूप करते हैं और ifयह -equal है 35, हम एक नए Randomचरित्र को उचित सीमा से बाहर निकालते हैं । अन्यथा हम आउटपुट (यानी, या तो स्पेस या न्यूलाइन)।

Answer 11

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

एक पुनरावर्ती कार्य चरित्र द्वारा उत्पादन चरित्र का निर्माण करता है।

"मा देखो, कोई शाब्दिक पंक्ति-फ़ीड नहीं!"

(w,h,n)=>(g=x=>y<h*n+h-1?String.fromCharCode(x++<w?x%w>1&&-~y%h?32:Math.random()*94+33|0:10)+g(x>w?!++y:x):'')(y=0)

डेमो

let f =

(w,h,n)=>(g=x=>y<h*n+h-1?String.fromCharCode(x++<w?x%w>1&&-~y%h?32:Math.random()*94+33|0:10)+g(x>w?!++y:x):'')(y=0)

O.innerText = f(5,3,4)

<pre id=O></pre>

Comments

लानत है! जब मैंने यह देखा तो मैं उसे अपने नीचे से गुदवाने की प्रक्रिया में था । :\ आप फिर से जीत गए! : पी

— झबरा

मैंने नीचे (अभी के लिए) गोल्फिंग पूरी कर ली है - मैंने सभी टर्नरी को आगे बढ़ाने के लिए लाइन खींची String.fromCharCode, क्योंकि मैं ईमानदारी से यह नहीं कह सकता था कि मैं इसे देखने के बाद खुद के साथ आऊंगा । मुझे पता है कि क्या आपको लगता है कि मेरा अब भी आपके समान है।

— शैगी

@ शगुन कोई चिंता नहीं! (वास्तव में, मैंने आपका जवाब मुझे पोस्ट करने के बाद ही देखा। अगर मैंने इसे पहले देखा होता, तो शायद मैं

— अरनुल्द

आह, यह खेल की प्रकृति है! :) हमारे समाधान के संयोजन से 113 बाइट्स मिलते हैं ,

— Shaggy

Answer 12

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

lambda w,h,n,e=lambda:chr(randint(33,126)):[e()+[eval(("e()+"*(w-2))[:-1])," "*(w-2)][-~i%h>0]+e()for i in range(h*-~n-1)]
from random import*

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

अंडा को धन्यवाद बाइट्स बचा लिया!

Comments

@LuisMendo मुझे लगता है कि मैंने इसे अब ठीक कर दिया है।

— बजे मिस्टर एक्सकोडर

@LuisMendo यह ध्यान से जाँच नहीं करने के लिए मेरी गलती है।

— श्री Xcoder

42 बाइट्स

— ओव्स सेप

@ नो थैंक्स! आप 1सामने वाले को भूल गए हालांकि> _>

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

Answer 13

पायथ, 33 बाइट्स

VhEjtW!Nmsm?&d}kr1tQ\ Or\!C127Qvz

इसे ऑनलाइन आज़माएँ: प्रदर्शन

Answer 14

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

lambda w,h,n:[[chr(32+randint(1,94)*(x%~-w*(y%h)<1))for x in range(w)]for y in range(1,h*-~n)]
from random import*

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

Answer 15

SOGL V0.12 , 32 31 बाइट्स

 ~ΔkψR
I{e{R}¶bH{Re⁾⌡@R¶}}¹∑e⌡k

यह कोशिश करो!

आदेश एन, डब्ल्यू, एच में इनपुट।

स्पष्टीकरण:

 ~ΔkψR

     R  a function named "R", pushes a random character:
 ~       push "~"
  Δ      get the charasters from " " to "~"
   k     remove the 1st character
    ψ    choose a random character from that

I{e{R}¶bH{Re⁾⌡@R¶}}¹∑e⌡k  main program

I                         increase the 1st input - N
 {                }       N times do
  e                         push the variable e, which is here initialised to the next input - W
   { }                      E times do
    R                         execute R
      ¶                     push a newline
       bH                   push b-1, where b is initialised to the next input - H
         {       }          B-1 times do
          R                   execute R
           e⁾                 push e-2 aka width-2
             ⌡@               push that many spaces
               R              execute R
                ¶             push a newline
                   ¹∑     join the stack together
                     e⌡k  remove the first width characters

यादृच्छिक पात्रों के बिना 18 बाइट्स : /

Answer 16

जावा 8, 203 188 168 133 132 130 128 126 बाइट्स

W->H->N->{for(double i=0,j,q;++i<H*N+H;)for(j=W,q=10;j-->=0;q=i%H*j<1|j>W-2?33+Math.random()*94:32)System.out.print((char)q);}

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

Comments

133 बाइट्स:W->H->N->{for(int i=0,j;i++<H*N+H-1;){char c=10;for(j=W;j-->0;c=i%H<1|j>W-2|j<2?(char)(Math.random()*94+33):32)System.out.print(c);}}

— नेवई

आप वर्तमान में परिणाम के लिए प्रिंट कर रहे हैं W-1, आंतरिक लूप को एक अतिरिक्त चलना ( >=0+1 बाइट) करना है।

— नेवई

132 बाइट्स:W->H->N->{for(int i=0,j;i++<H*N+H-1;){char c=10;for(j=W;j-->=0;c=i%H*j<1|j>W-2?(char)(Math.random()*94+33):32)System.out.print(c);}}

— नेवई

;++i<H*N+H;: -2 बाइट्स।

— ओलिवियर ग्रेजायर

Answer 17

हास्केल , 226 220 211 190 बाइट्स

import System.Random
a=mapM id
b=(putStr.unlines=<<).a
c=randomRIO('!','~')
r w=a$c<$[1..w]
s w=a$c:(return ' '<$[3..w])++[c]
(w#h)0=b$s w<$[2..h]
(w#h)n=do{b$(s w<$[2..h])++[r w];(w#h)$n-1}

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

लाकोनी के लिए धन्यवाद 9 बाइट्स बचाए

21 बाइट्स wchargin के लिए धन्यवाद बचा लिया

गोल्फ होना चाहिए ( b$(s w)<$[2..h]और b$((s w)<$[2..h])++[r w])। मैं IO और गोल्फ के साथ सहज महसूस नहीं करता।

Comments

आप के लिए इन्फ़िक्स संकेतन का उपयोग कर सकते हैं t w h n= ...: (w#h)n= ...। pureके बजाय इस्तेमाल किया जा सकता है return। आप कोष्ठक को चारों ओर छोड़ सकते हैं (d ' ')<$और (s w)<$।

— लकोनी

@ लिकोनी मैं अगली बार इन्फिक्स नोटेशन नहीं भूलूंगा! धन्यवाद।

— जफरार्ड

साथ बाइट्स का एक गुच्छा सहेजें c=randomRIO('!','~'), जो आपको इनलाइन भी देता है d=return। इसके अलावा, mapM idएक बाइट से भी छोटा है sequence।

— वचगिन १gin

@wchargin धन्यवाद। मैंने आज कुछ सीखा!

— 16

Answer 18

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

(w,h,n)=>Array(n+1).fill(("#".padEnd(w-1)+`#
`).repeat(h-1)).join("#".repeat(w)+`
`).replace(/#/g,_=>String.fromCharCode(33+Math.random()*94|0))

#पात्रों से बाहर सीढ़ी बनाता है फिर हर एक को एक यादृच्छिक ASCII चार के साथ बदलता है।

टेस्ट स्निपेट

let f=
(w,h,n)=>Array(n+1).fill(("#".padEnd(w-1)+`#
`).repeat(h-1)).join("#".repeat(w)+`
`).replace(/#/g,_=>String.fromCharCode(33+Math.random()*94|0))

;(W.oninput=H.oninput=N.oninput=B.onclick=_=>{let vals=[W.value,H.value,N.value].map(eval);D.innerText=vals.join`, `;O.innerText=f(...vals);})()

W: <input id=W type=range min=3 max=25 value=12><br>
H: <input id=H type=range min=2 max=25 value=5><br>
N: <input id=N type=range min=2 max=10 value=2><br>
<button id=B>Rerun</button> <code id=D></code>
<pre id=O></pre>

Comments

String.fromCharCodeऔर Math.randomएक समाधान में - जावास्क्रिप्ट हमसे नफरत क्यों करता है ?! के साथ आया था इस 137 बाइट्स, जो से मिलता-जुलता है, बस सरणी के बिना के लिए। मुझे आश्चर्य है कि अगर एक पुनरावर्ती समाधान अभी भी कम हो सकता है; बाद में जांच करेंगे।

— झबरा

एक और बाइट दस्तक दी

— झबरा

Answer 19

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

दुर्भाग्य से, जब मैं इसे नीचे ले जाने की प्रक्रिया में था, तब अरनुल्ड ने मुझे एक समान लेकिन छोटे समाधान से हराया । हमारे 2 समाधानों को मिलाकर, यह 113 बाइट्स हो सकता है

एक अनुगामी न्यूलाइन शामिल है।

(w,h,n)=>(g=c=>l?(c++<w?c%w>1&&l%h?` `:String.fromCharCode(94*Math.random()+33|0):`
`)+g(c>w?!--l:c):``)(0,l=h*++n-1)

---

कोशिश करो

o.innerText=(f=
(w,h,n)=>(g=c=>l?(c++<w?c%w>1&&l%h?` `:String.fromCharCode(94*Math.random()+33|0):`
`)+g(c>w?!--l:c):``)(0,l=h*++n-1)
)(i.value=5,j.value=3,k.value=2);oninput=_=>o.innerText=f(+i.value,+j.value,+k.value)

label,input{font-family:sans-serif;font-size:14px;height:20px;line-height:20px;vertical-align:middle}input{margin:0 5px 0 0;padding:0 0 0 5px;width:100px;}

<label for=i>W: </label><input id=i min=3 type=number><label for=j>H: </label><input id=j min=2 type=number><label for=k>N: </label><input id=k min=2 type=number><pre id=o>

Answer 20

जाप -R , 42 41 40 37 34 28 25 बाइट्स

आदेश में इनपुट लेता है H,W,N।

;*°WÉ ÆJ²ùVXgJùU¹r,@EÅöÃé

कोशिश करो

Answer 21

QBIC , 76 बाइट्स

[:*:+b-1|G=chr$(_r33,126|)~a%b\[:-2|G=G+@ `]][e|G=G+chr$(_r33,126|)]?_sG,1,e

व्याख्या

[                       FOR a = 1 TO
 :                         input 1 (Height, now in var b)
  *                        times
   :                       input 2 (# of rungs, now in var c)
    +b-1|                  plus one bottom rung without crossbar
G=chr$(_r33,126|)       Assign to G a random char (_r is the RAND() function, chr$() is BASIC's num-to-char)
~a%b|                   IF we are not at a crossbar (the modulo returns anything but 0), 
  [:-2|G=G+@ `            add to G x spaces, where x is width (input 3, now 'e') - 2
                        Note that G is now either 'X' or 'X   '  (for rnd char X and W=5)
]]                      Close the spacing FOR, close the IF 
[e|                     FOR f = 1 to width
  G=G+chr$(_r33,126|)]     Append to G a rnd char
                        G is now either 'XXXXXX'  or 'X   XXXXX' (for rnd char X and W=5)
?_sG,1,e                PRINT the first w characters of G, and on to the next line

नमूना चला

Command line: 3 2 5
N   F
M   `
Bj#=y
!   (
S   N
q(.Ho
%   7
g   ,

Answer 22

MATL , 63 50 बाइट्स

-13 बाइट्स लुइस मेंडो की बदौलत

Q*qXJ*6Y2HY)wT3$ZrJ3G3$eJ3G&Ol5LZ(J:HG\~3GTX"!+g*c

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

मैं अभी भी MATL में गोल्फ के लिए नया हूं (और मैं उस मामले के लिए MATLAB में सुपर अच्छा नहीं हूं), इसलिए मुझे पता है कि यह शायद इष्टतम के करीब नहीं है। सुझावों का स्वागत है। आदेश में इनपुट लेता है N,H,W।

ये रहा:

Q*qXJ                     # compute H*(N+1)-1, store as J
     *                    # multiply by W
      6Y2HY)              # push printable ASCII
            wT3$Zr        # sample uniformly with replacement
                  J3G3$e  # reshape to make a matrix of the appropriate shape.

अब हमारे पास यादृच्छिक चार का एक मैट्रिक्स है।

J3G                       # push J,W
   &O                     # zero matrix, J x W
     l5LZ(                # assign 1 to first and last columns

अब रेल के लिए एक तार्किक मैट्रिक्स भी है।

J:                        # push J, range, so 1...J
  HG                      # take second input (H)
    \~                    # mod and bool negate (so it's 1 for rows of multiples of H)
      3GTX"!              # repmat and transpose so we have 1's for rungs

अब हमारे पास स्टैक पर 3 मेट्रिस हैं:

• टॉप: 0 नॉन-रूंग के लिए, 1 अन्यथा
• मध्य: गैर-रेल के लिए 0, 1 अन्यथा
• नीचे: यादृच्छिक वर्ण, -20

तो हम निम्नलिखित करते हैं:

+                         # add the top two matrices.
 g                        # convert to logical so 0->0, nonzero->1
   *                      # elementwise multiply
    c                     # convert to char, implicit output (0 -> space).

Comments

यहां कुछ त्वरित सुझाव हैं: X"है 3$डिफ़ॉल्ट रूप से। 6Y2के बजाय काम हो सकता है 13:106... 20+। ~~है g। J3G&Ol5LZ(के बजाय इस्तेमाल किया जा सकता है1F3G2-Y"h1hJT3$X"

— लुइस मेंडो

@LuisMendo आह, मैंने इसे सभी डॉक्स के माध्यम से नहीं बनाया है या मुझे इसके बारे में पता चला होगा X"। कि पिछले टिप में, 5Lहै [1 0], लेकिन मैं नहीं कर रहा हूँ यकीन है कि कैसे उस के साथ संयोजन के रूप में प्रयोग किया जाता है Z(- मुझे लगता है कि यह निर्धारित कर रहा है पाने के 1प्रथम और अंतिम कॉलम के लिए, लेकिन मैं कैसे नहीं मिलता है 5LZ(कि पूरा करता है। मैं शायद कुछ समय बाद इस बारे में MATL CHATL में आपको पिंग करूंगा ताकि अब इसके बारे में चिंता न करें।

— Giuseppe

इंडेक्सिंग मॉड्यूलर है, इसलिए 0"एंड" के समान है। Z(स्तंभों को असाइन करता है। बेशक, मुझे चैट में पिंग करने के लिए स्वतंत्र महसूस करें!

— लुइस मेंडो

Answer 23

पॉवर्सशैल, 102 बाइट्स

param($w,$h,$n)1..(++$n*$h-1)|%{$l=$_%$h
-join(1..$w|%{[char](32,(33..126|Random))[!$l-or$_-in1,$w]})}

कम गोल्फ परीक्षण स्क्रिप्ट:

$f = {

param($w,$h,$n)
1..(++$n*$h-1)|%{       # for each lines of the ladder
    $l=$_%$h            # line number in a step
    -join(1..$w|%{      # make a line
        [char](32,(33..126|Random))[!$l-or$_-in1,$w]
    })                  # a random character if the line number in a step is a rung line or char position is 1 or width
                        # otherwise a space
}

}

&$f 5 3 2
&$f 3 2 2
&$f 12 4 5
&$f 20 5 3

आउटपुट:

0   {
H   S
']UxR
G   ]
3   t
q^R8O
q   y
t   J
U h
YQZ
_ i
3#D
I #
=          m
&          <
]          6
8nmuyw2'Y7%+
o          l
;          !
D          M
Fn[zGfT";RYt
@          B
$          e
z          @
@J[1|:-IS~y<
(          L
:          [
|          q
zBow0T0FnY8)
/          *
e          B
R          p
9{d2(RacBdRj
u          ~
`          l
J          h
v                  t
T                  -
v                  H
'                  Y
IS7{bx2&k@u7]o}>[Vq?
F                  U
?                  U
|                  Q
}                  T
:wv1wEfc6cS;430sigF|
<                  L
:                  }
*                  `
H                  =
L8k5Q/DQ=0XIUujK|c6|
j                  =
!                  p
V                  :
#                  w

Answer 24

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

संपादित करें: ओह, मैंने सोचा कि टाइपो लोल को ठीक करने के लिए हाल ही में संपादित किए जाने के कारण यह एक नई चुनौती थी। मैं अभी भी इसे छोड़ रहा हूं, क्योंकि अभी तक इसके लिए कोई रूबी का जवाब नहीं है।

->w,h,n{(1..h*-~n-1).map{|i|[*?!..?~].sample(x=i%h>0?2:w)*(' '*(w-x))}}

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