ASCII सीढ़ी बनाएँ

Question

दो पूर्णांक n और m के इनपुट को देखते हुए , लंबाई n और आकार m के ASCII सीढ़ी का उत्पादन किया जाता है ।

यह लंबाई 3 और आकार 3 का ASCII सीढ़ी है:

o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

यह लंबाई 5 और आकार 1 का ASCII सीढ़ी है:

o-o
| |
+-+
| |
+-+
| |
+-+
| |
+-+
| |
o-o

यह लंबाई 2 और आकार 5 का ASCII सीढ़ी है:

o-----o
|     |
|     |
|     |
|     |
|     |
+-----+
|     |
|     |
|     |
|     |
|     |
o-----o

विस्तार से:

• लंबाई ( n ) दर्शाती है कि सीढ़ी कितने वर्गों से बनी है।

• आकार ( एम ) आंतरिक की चौड़ाई और ऊंचाई का प्रतिनिधित्व करता है - अर्थात्, "सीमा" -चेक वर्ग की गिनती नहीं।

• प्रत्येक वर्ग रिक्त स्थान से भरा आंतरिक क्षेत्र से बना है, -जो ऊपर और नीचे, |बाएं और दाएं, और +चारों कोनों पर स्थित है।

• वर्गों के बीच की सीमाएं एक साथ विलीन हो जाती हैं, इसलिए एक पंक्ति में दो रेखाएं एक +--...--+में विलीन हो जाती हैं।

• पूरे सीढ़ी के कोनों को चरित्र के साथ बदल दिया जाता है o।

• आप वैकल्पिक रूप से एक अनुगामी न्यूलाइन का उत्पादन कर सकते हैं।

सीढ़ी की लंबाई ( n ) हमेशा and 2 होगी, और आकार ( m ) हमेशा der 1 होगा।

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

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीतता है।

युक्ति: ऊपर दिए गए उदाहरणों का उपयोग परीक्षण मामलों के रूप में भी किया जा सकता है।

Comments

क्या हमें पहले लंबाई लेनी है, फिर आकार?

— आर.के.

@RK। जो भी अधिक सुविधाजनक हो आप उन्हें ले जा सकते हैं।

— दरवाज़े

क्या कोई अग्रणी न्यूलाइन हो सकती है ?

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

@ C @O'Bʀɪᴇɴ उह ... मैं उस पर नहीं के साथ जा रहा हूँ।

— दरवाज़े

ठीक है: पी यह एक शॉट के लायक था।

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

Answer 1

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

.NjjNm*QTvz*2YjC:M++J"+|o"m"- -"QJ

परीक्षण सूट

STDIN पर अलग किए गए तर्कों को नया रूप देता है।

एक सहायक फ़ंक्शन का उपयोग करता है :, जो तीन वर्णों से प्रत्येक प्रकार के ऊर्ध्वाधर स्ट्रिंग का निर्माण करता है , फिर आवश्यक रूप से प्रतिकृति करता है, नई कहानियों पर स्थानांतरित करता है और जुड़ता है।

Answer 2

रूबी, 71

->m,n{h=0;(?o+?+*(n-1)+?o).chars{|c|puts [?|+' '*m+?|]*h,c+?-*m+c;h=m}}

परीक्षण कार्यक्रम में अपुष्ट

f=->m,n{
  h=0                             #The number of | above the 1st rung is 0
  (?o+?+*(n-1)+?o).chars{|c|      #Make a string of all the rung ends o++...++o and iterate through it
    puts [?|+' '*m+?|]*h,         #draw h vertical segments |  ...  |
      c+?-*m+c                    #and a rung with the correct ends
    h=m                           #The number of | above all rungs except the 1st is m
  }
}


f[gets.to_i,gets.to_i]

Comments

वहाँ गोल्फ संस्करण के साथ मामूली मुद्दों लगता है: के ;बाद की h=0जरूरत है, के बाद अंतरिक्ष की जरूरत है puts। लेकिन आप स्कोर केवल 1 चरित्र के साथ बढ़ता है क्योंकि पहले एक अतिरिक्त स्थान है puts।

— मैनेटवर्क

@manatwork, उफ़, धन्यवाद, निश्चित। मुझे नहीं पता कि यह कैसे हुआ, मेरे पास गोल्फ होना चाहिए और बाद में इसे नहीं चलाना चाहिए।

— लेवल रिवर सेंट

Answer 3

CJam, 43 42 बाइट्स

मैं स्कोर से कम नहीं हूँ। लेकिन मैं डेनिस नहीं हूं, है ना?

q~:Z;'-'o{[\Z*1$N]}:X~['-_'+X\'|XZ*]@*1>1$

इनपुट 2 अंतरिक्ष अलग आइटम है। लंबाई पहले

2 3
o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

व्याख्या

q~:Z;'-'o{[\Z*1$N]}:X~['-_'+X\'|XZ*]@*1>1$
q~                                         e# read input
  :Z;                                      e# Record the size in Z and discard
     '-'o{[\Z*1$N]}:X~                     e# Create the initial line (and final). also creates a shorcut to do this later
           \                               e# Capture two arguments
            Z*                             e# The separator is repeated size times
              1$                           e# Repeat the first argument
                N                          e# Add newline
                                           e# X is a function to create line in a ladder
                      ['-_'+X\'|XZ*]       e# Design the repeating part
                                    @*     e# Repeat the pattern n times
                                      1>   e# Discard the initial
                                        1$ e# Since the final line is same than the initial, we just write it.
                                           e# Implicit printing

Comments

मुझे यह पसंद है कि आपने इसे एक प्रश्न के रूप में कहा है। "मैं डेनिस नहीं हूं ... ठीक है?"

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

Answer 4

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

... दोहराना, दोहराना, दोहराना ...

(n,m,R=x=>x.repeat(m),b=R(`|${R(' ')}|
`),d=`o${c=R('-')}o
`)=>d+R(b+`+${c}+
`,m=n-1)+b+d

परीक्षा

F=(n,m,R=x=>x.repeat(m),b=R(`|${R(' ')}|
`),d=`o${c=R('-')}o
`)=>d+R(b+`+${c}+
`,m=n-1)+b+d

// Less golfed
U=(n,m)=>
{
  var R=x=>x.repeat(m),
      a=R(' '),
      b=R(`|${a}|\n`);
      c=R('-'),
      d=`o${c}o\n`;
  m=n-1;
  return d+R(b+`+${c}+\n`)+b+d
}

function test() {
  var i=I.value.match(/\d+/g)
  if (i) O.textContent=F(+i[0],+i[1])
  console.log(i,I.value)
}  
 
test()

N,M: <input id=I value="3,5" oninput=test()>
<pre id=O></pre>

Comments

मुझे नहीं पता था कि document.getElementById('elem').इसे बदला जा सकता है elem.! इसके लिए +1, लेकिन कृपया, क्या आप इसके बारे में कुछ डॉक्स बता सकते हैं?

— एफ। होरी

@ F.Hauri यह लगभग हर ब्राउज़र में काम करता है, लेकिन इससे बचना चाहिए (सिवाय मौज मस्ती के लिए कोडिंग के)। जानकारी और लिंक stackoverflow.com/questions/3434278/…

— edc65

Answer 5

सी #, 1412 बाइट्स

... मेरा पहला कोडगुल्फ प्रयास, जीतने की संभावना नहीं है लेकिन यह काम करता है इसलिए हम यहां जाते हैं:

using System;

namespace Ascii_Ladders
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = 0;
            int m = 0;

            Console.Write("Please enter Height: ");
            n = int.Parse(Console.ReadLine());
            Console.Write("Please Enter Width: ");
            m = int.Parse(Console.ReadLine());

            Console.Write("o");
            for (int i = 0; i < m; i++)
            {
                Console.Write("-");
            }
            Console.WriteLine("o");

            for (int k = 0; k < n; k++)
            {
                for (int i = 0; i < m; i++)
                {
                    Console.Write("|");
                    for (int j = 0; j < m; j++)
                    {
                        Console.Write(" ");
                    }
                    Console.WriteLine("|");
                }
                if (k != n - 1)
                {
                    Console.Write("+");
                    for (int i = 0; i < m; i++)
                    {
                        Console.Write("-");
                    }
                    Console.WriteLine("+");
                }
            }

            Console.Write("o");
            for (int i = 0; i < m; i++)
            {
                 Console.Write("-");
            }
            Console.WriteLine("o");

            Console.ReadKey();
        }
    }
}

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! आपके पास अपने कोड में बहुत सारे व्हाट्सएप हैं जिन्हें आप अपने कोड को छोटा करने के लिए निकाल सकते हैं, यदि आप अपने कोड को अधिक मदद करना चाहते हैं, तो आप C # में गोल्फ के लिए टिप्स की जांच कर सकते हैं ।

— डाउनगेट

मैं यहाँ @ Do agree से सहमत हूँ। मैं संभावित रूप से इसे केवल 533 बाइट्स में गोल्फ में सक्षम कर पाया हूं । लेकिन यह बेहतर हो सकता है। (चेतावनी: मैं C # में प्रोग्राम नहीं करता।)

— user48538

मैं इसे 314 पर ले गयाusing System;class P{static int m;static void Main(){int n = int.Parse(Console.ReadLine());m = int.Parse(Console.ReadLine());M('o','-');for(int k=0;k<n;k++){for(int i=0;i<m;i++){M('|',' ');}if(k!=n-1){M('+','-');}}M('o','-');Console.ReadKey();}static void M(char x,char y){Console.WriteLine(x+new string(y,m)+x);}}

— RedLaser

कुछ स्थानों को छोड़ दिया तो 310 के साथusing System;class P{static int m;static void Main(){int n=int.Parse(Console.ReadLine());m=int.Parse(Console.ReadLine());M('o','-');for(int k=0;k<n;k++){for(int i=0;i<m;i++){M('|',' ');}if(k!=n-1){M('+','-');}}M('o','-');Console.ReadKey();}static void M(char x,char y){Console.WriteLine(x+new string(y,m)+x);}}

— RedLaser

उपयोग किए गए दृष्टिकोण में बदलाव के बिना 270 तक नीचे using C=System.Console;class P{static void Main(){int i,k,n=int.Parse(C.ReadLine()),m=int.Parse(C.ReadLine());System.Action<char,char> M=(x,y)=>C.WriteLine(x+new string(y,m)+x);M('o','-');for(k=0;k<n;k++){for(i=0;i<m;i++){M('|',' ');}if(k<n-1){M('+','-');}}M('o','-');}}:। यहां सबसे अधिक संभावना है, हालांकि, केवल चीजों को थोड़ा करने के तरीके को बदलकर।

— जॉय

Answer 6

जूलिया, 87 बाइट्स

f(n,m)=(g(x)=(b=x[1:1])x[2:2]^m*b*"\n";(t=g("o-"))join([g("| ")^m for i=1:n],g("+-"))t)

यह एक फ़ंक्शन है जो दो पूर्णांकों को स्वीकार करता है और एक स्ट्रिंग लौटाता है।

Ungolfed:

function f(n::Int, m::Int)
    # Create a function g that takes a string of two characters and
    # constructs a line consisting of the first character, m of the
    # second, and the first again, followed by a newline.
    g(x) = (b = x[1:1]) * x[2:2]^m * b * "\n"

    # Assign t to be the top and bottom lines. Construct an array
    # of length n where each element is a string containing the
    # length-m segment of the interior. Join the array with the
    # ladder rung line. Concatenate all of this and return.
    return (t = g("o-")) * join([g("| ")^m for i = 1:n], g("+-")) * t
end

Answer 7

पीबी - 147 बाइट्स

^t[B]>>[B]vw[T!0]{b[43]<[X]b[43]>w[B=0]{b[45]>}v[X-1]w[B=0]{b[124]^}v[X]t[T-1]}t[111]b[T]<w[X!0]{b[45]<}b[T]w[Y!0]{w[B!0]{^}b[124]^}b[T]^>>[B]vb[T]

यह इस तरह की चुनौती है, अधिकार से, pb को वास्तव में अच्छा होना चाहिए। पात्रों के साथ सरल चित्र बनाना बिल्कुल वही है जो pb के लिए डिज़ाइन किया गया था। काश, यह सिर्फ एक चिंताजनक भाषा है जो मुझे लगता है।

पहले इनपुट लंबाई लेता है, उसके बाद आकार। उदाहरण के लिए, बाइट मान के रूप में इनपुट लेता है:python -c 'print(chr(5) + chr(7))' | ./pbi.py ladder.pb

देखो, एक मजेदार एनीमेशन!

टिप्पणियों के साथ:

^t[B]            # Save length to T
>>[B]v           # Go to X=size+1, Y=0

w[T!0]{          # While T is not 0:
    b[43]            # Write a '+'
    <[X]b[43]        # Write a '+' on the left side as well
    >w[B=0]{b[45]>}  # Travel back to the right '+', writing '-' on the way
    v[X-1]           # Go down by X-1 (== size)
    w[B=0]{b[124]^}  # Travel back up to the '+', writing '|' on the way
    v[X]             # Go down by X (== size + 1, location of next '+')
    t[T-1]           # Decerement T
}

t[111]           # Save 'o' to T (it's used 4 times so putting it
                 # in a variable saves bytes)

b[T]             # Write an 'o' (bottom right)

<w[X!0]{         # While not on X=0:
    b[45]<           # Travel left, writing '-' on the way
}

b[T]             # Write an 'o' (bottom left)

w[Y!0]{          # While not on Y=0:
    w[B!0]{^}        # Skip nonempty spaces
    b[124]           # Write a '|'
    ^                # Travel up
}

b[T]             # Write an 'o' (top left, replaces existing '+')

^>>[B]v          # Go back to where the size is saved and go to X=size+1, Y=0

b[T]             # Write an 'o' (top right, replaces existing '+')

Answer 8

शुद्ध बैश, 132 130 128 127 बाइट्स

हाँ, मैं अंतिम के स्थान पर 1 और बाइट छोड़ सकता हूं ${p% *}, लेकिन मुझे यह पसंद है:

p=printf\ -v;$p a %$1s;$p b %$2s;o="|$a|\n";h=+${a// /-}+\\n v=${a// /$o}
a=${b// /$h$v}${h//+/o};a=${a/+/o};${p% *} "${a/+/o}"

नमूना:

ladders() {
    p=printf\ -v;$p a %$1s;$p b %$2s;o="|$a|\n";h=+${a// /-}+\\n v=${a// /$o}
    a=${b// /$h$v}${h//+/o};a=${a/+/o};${p% *} "${a/+/o}"
}

ladders 3 4
o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

ladders 2 1
o--o
|  |
|  |
o--o

Answer 9

हास्केल, 100 97 बाइट्स

l#s=unlines$t:m++[t]where _:m=[1..l]>>["+"!"-"]++("|"!" "<$u);t="o"!"-";o!i=o++(u>>i)++o;u=[1..s]

उपयोग उदाहरण:

*Main> putStr $ 4 # 3
o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

यह काम किस प्रकार करता है:

l#s=unlines$t:m++[t]         -- concat top line, middle part and end line
                             -- with newlines between every line
  where                      -- where
  _:m=                       -- the middle part is all but the first line of
     [1..l]>>                -- l times
         ["+"!"-"]           --    a plus-dashes-plus line
         ++("|"!" "<$u)      --    followed by s times a bar-spaces-bar line

  t="o"!"-"                  -- very first and last line
  o!i=o++(u>>i)++o           -- helper to build a line
  u=[1..s]

संपादित करें: @ क्रिसियन इरवान को 3 बाइट्स मिले। धन्यवाद!

Comments

के लिए -1 स्कोर Patternmatching m=init$[1..l]>>("|"!" "<$u)++["+"!"-"]=>(_:m)=[1..l]>>["+"!"-"]++("|"!" "<$u)

— Akangka

आश्चर्यजनक रूप से _:m=[1..l]>>["+"!"-"]++("|"!" "<$u)काम करता है

— अकांका

@ChristianIrwan: अच्छी तरह से देखा! धन्यवाद!

— नमि

Answer 10

ब्रेनफक - 334 बाइट्स

,[<+<<<<+>>>>>-]<[[>>]+[<<]>>-]<----[>---<----]--[>[+>>]<<[<<]>++++++]>[+.>>]-[<+>---]<+++++++>>--[<+>++++++]->---[<------->+]++++++++++[<++<]+++++[>[++++++>>]<<[<<]>-]>[-]>.-<<----[>>+++<<----]--[>+<--]>---<<<<++++++++++.,[>[>+>+<<-]>[<+>-]>[<<<<[>>>>>>[.>>]<<[<<]>>-]>>>>>[.>>]<<[<<]>-]<<<<+>-]>>>>[-]----[>---<----]>+.[>]<<<<<[.<<]

मुझे उम्मीद थी कि यह बहुत छोटा होगा।

यह एक "स्ट्रिंग" सेट करता है जो दिखता है | (...) |और जो दिखता है +----(...)----+, प्रत्येक को आवश्यक के रूप में प्रिंट करता है, oऊपर और नीचे के हिस्से के लिए कुछ विशेष आवरण के साथ ।

एक दुभाषिया की आवश्यकता होती है जो 8-बिट कोशिकाओं का उपयोग करता है और आपको सेल 0 से बाएं जाने की अनुमति देता है (नकारात्मक कोशिकाओं या लूपिंग में हो)। मेरे अनुभव में, ये सबसे सामान्य डिफ़ॉल्ट सेटिंग्स हैं।

टिप्पणियों के साथ:

,[<+<<<<+>>>>>-]<[[>>]+[<<]>>-] Get m from input; make a copy
                      Turn it into m cells containing 1 with empty cells between

<----[>---<----]      Put 67 at the beginning (again with an empty cell between)

--[>[+>>]<<[<<]>++++++]  Add 43 to every nonempty cell

>[+.>>]               Add 1 to each cell and print it

-[<+>---]<+++++++    Put 92 after the last 45 (no empty cell!)

>>--[<+>++++++]      Put 43 immediately after the 92

->---[<------->+]    Put 234 after 43

++++++++++           And 10 after that

[<++<]             Add two to the 234; 92; the empty spaces; and left of the 111

+++++[>[++++++>>]<<[<<]>-] Add 30 to each 2; the 94; and the 236

>[-]>.-<<----[>>+++<<----] Erase leftmost 32; Print 111; subtract 68 from it

--[>+<--]>---        Put 124 where the 32 was

<<<<++++++++++.,     Print a newline; override the cell with n from input

[                    n times:

  >[>+>+<<-]>[<+>-]    Make a copy of m

  >[                   m times:

    <<<<                 Look for a flag at a specific cell

    [                    If it's there:

      >>>>>>[.>>]          Go to the 43; print it and every second cell after

      <<[<<]>>-            Clear the flag

    ]

    >>>>>[.>>]           Go to the 124; print it and every second cell after

    <<[<<]>              Go back to the copy of m

  -]

  <<<<+>               Plant the flag

-]

>>>>

[-]----[>---<----]>+ Erase the 124; add 68 to 43

.[>]                 Print it; then head to the end

<<<<<[.<<] Go to the last 45; print it; then print every second cell to the left

Answer 11

पॉवरशेल, S० 80०

param($l,$s)$a='-'*$s
($c="o$a`o")
(($b=,"|$(' '*$s)|"*$s)+"+$a+")*--$l
$b
$c

Comments

77 बाइट्स

— Veskah

Answer 12

जोल्फ, 36 बाइट्स

यहाँ यह कोशिश करो!

ρpi,a+2J+2J"o-| "j"o(.+)o
o.+o'+$1+

व्याख्या

ρpi,a+2J+2J"o-| "j"o(.+)o\no.+o'+$1+
 pi              j                   repeat vertically j times
   ,a+2J+2J"o-| "                    a box with dimensions 2+J
ρ                 "o(.+)p\np.+o'     replace with regex
                                +$1+ with the -...-

Answer 13

पर्ल, 98 बाइट्स

($n,$m)=@ARGV;print$h="o"."-"x$m."o\n",((("|".(" "x$m)."|\n")x$m.$h)x$n)=~s{o(-+)o(?=\n.)}{+$1+}gr

Comments

एक उत्कृष्ट पहला उत्तर। लेकिन मुझे +आपके कोड में कोई संकेत दिखाई नहीं देता है , क्या आपने माना है कि मध्यवर्ती छोरों के +प्रत्येक छोर पर संकेत हैं?

— लेवल रिवर सेंट

बहुत अच्छी तरह से शब्द टिप्पणी के लिए धन्यवाद - मैंने पूरी तरह से प्लस संकेत दिए! मुझे काफी जगह की लागत, भी; अभी भी सोच रहा हूं कि मैं इसे कैसे छोटा कर सकता हूं ... इसके अलावा ($n,$m)=@ARGV;और यह मानकर कि वे पहले से ही सेट हैं - यह सुनिश्चित नहीं है कि आत्मा में है या नहीं। मुझे इसे देखना पड़ेगा।

— ज़िलजार

जब तक अन्यथा प्रश्न में निर्दिष्ट, नियम यहाँ है meta.codegolf.stackexchange.com/a/2422/15599 । आप केवल यह मान नहीं सकते हैं कि चर सेट हैं, लेकिन आप प्रोग्राम की बजाय फ़ंक्शन लिख सकते हैं, यदि यह मदद करता है। मैं पर्ल नहीं करता, लेकिन मुझे लगता है कि आपको बचा सकता है @ARGV। इसके अलावा, किसी को रिप्लाई करते समय @username को शामिल करना याद रखें ताकि उन्हें अलर्ट मिले। मुझे यह करने की आवश्यकता नहीं है क्योंकि यह आपकी पोस्ट है।

— लेवल रिवर सेंट

Answer 14

सी, 122 बाइट्स

f(int m,int n,char*s){int i=0,w=3+m++;for(;i<w*m*n+w;++i)*s++=i%w>m?10:" |-+-o"[!(i/w%m)*2+!(i%w%m)+!(i/w%(m*n))*2];*s=0;}

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

Answer 15

Tcl, 187 बाइट्स

lassign $argv n w
set c 0
while { $c < [expr {($w * $n) + ($n + 2)}]} {if {[expr {$c % ($n + 1)}] == 0} {puts "o[string repeat "-" $w ]o"} else {puts "|[string repeat " " $w ]|"}
incr c}

यह कोड कमांड लाइन पर तर्कों के इनपुट वाली फाइल में डालने के लिए बनाया गया है। उस क्रम में बक्से और चौड़ाई की संख्या प्रदान करें।

Answer 16

PHP, 81bytes

पीएचपी कमांड को सीधे कॉल करते समय 2 तर्क दिए गए। पहला एक आकार है और दूसरा चरण चरणों की संख्या है।

$R=str_repeat;echo$P="o{$R('-',$W=$argv[1])}o
",$R("|{$R(' ',$W)}|
$P",$argv[2]);

कुछ सुधार की आवश्यकता हो सकती है।

Answer 17

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

def F(n,m):a,b,c,d='o|+-';r=[a+d*m+a]+([b+' '*m+b]*m+[c+d*m+c])*n;r[-1]=r[0];print'\n'.join(r)

'Ungolfed':

def F(n,m):
 # 'o---o'
 r = ['o'+'-'*m+'o']
 # ('|   |'*m+'+---+') n times
 r += (['|'+' '*m+'|']*m+['+'+'-'*m+'+'])*n
 # replace last +---+ with o---o
 r[-1] = r[0]
 print '\n'.join(r)

Answer 18

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

$_='|'.$"x$F[1].'|';push@a,y/| /+-/r,($_)x$F[1]while$F[0]--;$a[0]=y/| /o-/r;say for@a,$a[0]

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

Answer 19

पिप -l , 35 बाइट्स

(^YsXbRLaJW'-)XbWR^('|XbRLaJ'+)WR'o

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

व्याख्या

(^YsXbRLaJW'-)XbWR^('|XbRLaJ'+)WR'o
                                     a is length, b is size, s is space (implicit)
   sXb                               String containing b spaces
      RLa                            List containing a copies of that string
         JW'-                        Join on "-" and wrap the result in "-" as well
  Y                                  Necessary for operator precedence reasons
 ^                                   Split into a list of characters
(            )Xb                     String-repeat each character in the list b times
                                     This list represents the central columns of the ladder

                    '|Xb             String containing b pipe characters
                        RLa          List containing a copies of that string
                           J'+       Join on "+"
                   (          )WR'o  Wrap in "o"
                  ^                  Split into a list of characters
                                     This list represents the outer columns of the ladder

                WR                   Wrap the left list in the right list, vectorizing

कुछ अन्य संस्करण

मैंने पायथ को पकड़ने के लिए कई अलग-अलग तरीकों की कोशिश की ...

[Y'-XbWR'o;@>(sXbWR'|RLbPE'-XbWR'+RL:a)y]  41
Y^(t**b.1*:t**bX--a.1)" --"@yXbWR"|o+"@y   40
Y'|XbRLaJ'+YyWR'o;Z:sXbRLaJW'-RLbPEyAEy    39
t**:b(" |-o-+"<>2)@_@^t.1M$*Y[ttXa-1].1    39
J*Z:sXbRLaJW'-RLbWR:^('|XbRLaJ'+)WR'o      37
Y^$*Y[t**:btXa-1].1" --"@yXbWR"|o+"@y      37

मैं विशेष रूप से t**bलोगों का शौकीन हूं , जो सीढ़ी के ऊर्ध्वाधर पैटर्न को उत्पन्न करने के लिए गणित का उपयोग करते हैं:

        b           Size; e.g. 3
    t               Preset variable for 10
     **:            Set t to t**b (e.g. 1000)
           a        Length; e.g. 3
            -1      2
         tX         String-repeat (the new value of) t 2 times: 10001000
   [          ]     Put t and the above into a list: [1000; 10001000]
               .1   Append 1 to both of them: [10001; 100010001]
$*(              )  Fold on multiplication: 1000200020001

1000200020001तो पैटर्न उत्पन्न करने के लिए इस्तेमाल किया जा सकता o|||+|||+|||oहै और - - - -, जो सीढ़ी बनाते हैं। दुर्भाग्य से, मैं इस दृष्टिकोण में शामिल होने / लपेटने के दृष्टिकोण से छोटा नहीं हो सका।