ASCII का महान पिरामिड

25

परिचय

यह 2600 ईसा पूर्व का है और लोग अब पिरामिड बना रहे हैं। उन्होंने पहले से ही पिरामिड का आधार बनाया लेकिन पता नहीं कैसे जारी रहे। इसलिए, उन्होंने आपको मदद के लिए बुलाया।

पिरामिड बनाने के नियम काफी सरल हैं। पिछली परत के ऊपर की परत के लिए, आपको बस इस चरण-दर-चरण हाथ गाइड का पालन करना होगा:

  1. पिछली परत से किनारों को काटें।

  2. /चरित्र के ऊपर , एक \चरित्र होना चाहिए और इसके विपरीत। यह किनारों को छोड़कर हर चरित्र पर लागू होता है ।

  3. सबसे बाईं ओर का चरित्र हमेशा एक होता है /और सबसे सही वर्ण हमेशा होता है \।

आइए पिरामिड के लिए आधार का एक उदाहरण लें:

//\/\/\\

हमने किनारों को काट दिया, जिससे:

 /\/\/\

हम पिछड़े स्लैश के साथ आगे के स्लैश को बदलते हैं और इसके विपरीत:

 \/\/\/

सबसे बाएं वर्ण हमेशा एक होता है /और सबसे दाहिना वर्ण हमेशा एक होता है \, इसलिए हम इसे बदलते हैं:

 //\/\\

हम इस परत को पिछली परत पर रखते हैं:

 //\/\\
//\/\/\\

हम तब तक जारी रखते हैं जब तक कि शीर्ष नहीं पहुंच जाता (जो दिखता है /\)। तो, अंततः हम प्राप्त करते हैं:

   /\
  //\\
 //\/\\
//\/\/\\

यह वही है जो आपको आउटपुट करने की आवश्यकता है।

काम

एक पिरामिड के आधार को देखते हुए (3 से अधिक की लंबाई के साथ), पूर्ण पिरामिड का उत्पादन करता है। आप सुरक्षित रूप से मान सकते हैं कि सबसे बाईं ओर का चरित्र है /और सबसे सही चरित्र है \। आप यह भी मान सकते हैं कि आधार की लंबाई हमेशा सम है । अनुगामी रिक्त स्थान के उपयोग की अनुमति है। प्रमुख स्थानों के उपयोग की भी अनुमति है, जब तक कि पिरामिड जगह पर रहता है। 1 अनुगामी और 1 अग्रणी न्यूलाइन्स के उपयोग की अनुमति है।

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

Input: /\\\
Output:
 /\
/\\\

Input: //\\///\/\
Output:
    /\
   /\\\
  /\///\
 ///\\\/\
//\\///\/\

Input: /////////////\
Output:
      /\
     /\\\
    /////\
   /\\\\\\\
  /////////\
 /\\\\\\\\\\\ 
/////////////\

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ जमा करना!

code-golf  string  ascii-art 
— अदनान
स्रोत
एक प्राथमिक सेलुलर ऑटोमेटन की याद दिलाता है । शायद यह एक दिलचस्प भविष्य की चुनौती बना देगा?
— DoctorHeckle

जवाबों:

9

जेली ,२ २६ २५24 बाइट्स

QṚ,QyḊḊṖṖj@QµÐĿµJ’⁶ẋ⁸żYṚ

-4 बाइट्स डेनिस की बदौलत

विधि:

QṚ,QyḊḊṖṖj@QµÐĿµJ’⁶ẋ⁸żYṚ - one argument: input()
Q  Q       Q             - set of Left=input(): "/\"
 Ṛ                       - reverse Left: "\/"
  ,                      - Left-pair-Right: ["\/","/\"]
     ḊḊṖṖ                - dequeue Left twice, then pop twice: input()[2:-2]
    y                    - translate Right with mapping in Left: swaps internal slashes
         j@              - join Right with separator Left (@ swaps operands)
            µ  µ         - chain separators to form a 1,1,1 chain of chains
             ÐĿ          - loop while results are unique and collect them
                J        - yield [1,...,len(Left=input())]
                 ’       - decrement: [0,....len(input())-1]
                  ⁶      - " "
                   ẋ     - repeat Left Right times: ["", " ", ...]
                    ⁸ż   - zip Right and Left (⁸ is the link's Left argument):
                                ...pads the loop results
                      Y  - joins Left with line-feeds
                       Ṛ - reverse Left

(नींबू पानी के साथ परोसें, वो पिरामिड प्यासे मजदूरों के लिए हैं)

TryItOnline पर अपने खुद के स्लैश पिरामिड को कुक करें , या सभी ओपी के सुझाए गए टस्टर्स को आज़माएं

— जोनाथन एलन
स्रोत
11

पायथ - 27 26 बाइट्स

ओपी में दिए गए ऑपरेशन द्वारा दोहराए जाने तक कम हो जाता है, जो कि रिक्त लाइन के लिए मामला है।

j_.e+*kdb.ujXtPtPNK"\/")_K

टेस्ट सूट ।

— Maltysen
स्रोत
8

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

f=lambda s,p='\n':(s[2:]and f('/%s\\'%s.translate('/\\'*128)[2:-2],p+' '))+p+s

एक पुनरावर्ती फ़ंक्शन जो एक स्ट्रिंग को आउटपुट करता है। पिरामिड की प्रत्येक परत को इसके ऊपर की परत के साथ पुनरावर्ती कॉल में जोड़ा जाता है। उपसर्गp , जो एक नए वर्ण के रूप में शुरू होता है, त्रिकोण बनाने के लिए एक और स्थान प्राप्त करता है। अगली परत स्लैश स्वैपिंग, पहले और आखिरी दो प्रतीकों को काटकर और इसे एक बाएं और दाएं स्लैश के अंदर सैंडविच करके बनाई जाती है।

अजगर 3 करके एक बाइट बचा सकता है *99में translate, के रूप में लंबाई-256 आवश्यकता हटा दिया गया था।

— XNOR
स्रोत
चालाक अनुवाद का उपयोग करता है, लेकिन क्या हमें प्रिंट नहीं करना है?
— जोनाथन एलन
@JonathanAllan डिफ़ॉल्ट रूप से नहीं , आपको केवल चुनौती के अनुसार आउटपुट देना होगा।
— xnor
6

हास्केल, 98 94 90 85 बाइट्स

q=init.tail
s '/'='\\'
s _='/'
t#""=t++"\\\n"
t#l=(' ':t)#(s<$>q l)++t++l#""
("/"#).q

उदाहरण का उदाहरण (नोट: शाब्दिक तार के भीतर हास्केल बैकस्लैश में बचना होगा \\):

*Main> putStr $ (("/"#).q) "//\\\\///\\/\\"
    /\
   /\\\
  /\///\
 ///\\\/\
//\\///\/\

सरल पुनरावृत्ति दृष्टिकोण: #मानचित्रण द्वारा कार्य करता है s, जो आंतरिक तत्वों पर /और \, फ़्लिप करता है। अतिरिक्त पैरामीटर tइंडिकेशन स्तर का ट्रैक रखता है और प्रत्येक पुनरावर्ती कॉल पर एक स्थान द्वारा विस्तारित किया जाता है।

नोट: #(-> l#"") की दूसरी पुनरावर्ती कॉल सीधे आधार के मामले में कूदती है और जोड़ने के लिए सिर्फ एक छोटा तरीका है l, \और एक नई लाइन, यानी यह बदल देती है ++l++"\\\n"।

संपादित करें: @xnor ने 5 बाइट्स बचाए। धन्यवाद!

— nimi
स्रोत
l++"\\\n"जैसा दिखता है l#""।
— xnor
1
एक स्ट्रिंग में दो पात्रों को स्वैप करने का एक दिलचस्प तरीका sहै [c|x<-s,c<-"ab",c/=x]।
— xnor
@ xnor: मैंने दूसरे से छुटकारा पाने के लिए कई चीजों की कोशिश की है ++"\\\n", लेकिन यह एक चूक हो गई। धन्यवाद!
— नीमी
6

पायथन 3, 108 104 101 94 91 89 88 बाइट्स

b,f='\/';p=lambda t,n='\n':(t[2:]and p(f+''.join(map({f:b,b:f}.get,t[2:-2]))+b,n+' '))+n+t

-7 बाइट्स (दे मुझे पता है कि हम मुद्रित करने के लिए नहीं है!) XNOR करने के लिए धन्यवाद
-3 XNOR करने के लिए धन्यवाद बाइट्स (समारोह घोषणा की घोषणा के बाहर [डी 'ओह] लेने)
-1 डेनिस को बाइट धन्यवाद (की जगह f,b='/\\'के साथ b,f='\/')

इसे आइडोन पर टेस्ट करें । नोट: डबल बैकस्लैश के लिए समायोजित इनपुट (यहां तक ​​कि कच्चे तार काम नहीं करेंगे अगर वे एक विषम संख्या में समाप्त हो जाएं)।

— जोनाथन एलन
स्रोत
आप f,b='/\\'फ़ंक्शन के बाहर संयुक्त रूप से घोषित कर सकते हैं ।
— xnor
@xnor धन्यवाद, मैं ^ ^
— जोनाथन एलन
5

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

f=
(s,t=`
`)=>s[2]?f(`/${s.slice(2,-2).replace(/./g,c=>c>`/`?`/`:`\\`)}\\`,t+` `)+t+s:t+s
;
<input placeholder=Basis oninput=o.textContent=f(this.value)><pre id=o>
स्निपेट का विस्तार करें

आउटपुट में एक प्रमुख न्यूलाइन वर्ण शामिल है।

— नील
स्रोत
3

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

f=->s{s[-3]>?!&&f[" "+s.gsub(/^( *\/).|.(.$)?/){$1||$2||($&>?/??/:?\\)}]
puts s}

Ungolfed

f = ->s{
  s[-3] > ?! &&
    f[" " + s.gsub(/^( *\/).|.(.$)?/) {
      $1 || $2 || ($& > ?/ ? ?/ : ?\\)
    }]
  puts s
}

इसे आइडोन पर देखें: http://ideone.com/HN0l0Y

— जॉर्डन
स्रोत
मेरा बुरा, fशरीर में नहीं देखा कि
— 15
3

बैच, 137 बाइट्स

@echo off
if %1==/\ goto g
set s=%1
set s=\%s:~2,-2%/
set s=%s:/=-%
set s=%s:\=/%
set s=%s:-=\%
call %0 %s% "%~2 "
:g
echo %~2%1

आसानी से मेरे उपयोग %~2और %1इसका मतलब है कि मैं बाइट खर्च करने से बचता हूं setlocal। स्पष्टीकरण: चूंकि बैच खाली स्ट्रिंग पर प्रतिस्थापन नहीं करेगा, इसलिए हमें "गलत" किनारों के साथ अगली परत स्थापित करनी होगी, जिसे बाद में स्ट्रिंग प्रतिस्थापन के भाग के रूप में ठीक किया जाएगा।

— नील
स्रोत
2

BASH (sed + सॉर्ट) 71 66 बाइट्स

sed -rne':l;p;y|\\|1|;y|/|\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort   
sed -rne':l;p;y|\\/|1\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort

इनपुट स्टड से आता है।
उदाहरण:

echo '//\\' |sed -rne':l;p;y|\\|1|;y|/|\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort

 /\
/\\\

स्पष्टीकरण:
-n- दबाने ऑटो प्रिंट
:l- और tlशाखा वापस शुरुआत करने के लिए करता है, तो इस लाइन से कुछ अन्य था /\
p - इस लाइन प्रिंट
y|\\/|1\\|;y|1|/|की जगह - \साथ 1, /साथ \, और फिर 1साथ /
th;:h- परीक्षण और एक ही जगह कूद, ताकि केवल अगले प्रतिस्थापन का परीक्षण किया जाता है बाद में
s|\\.(.*)./| /\1\\|- बाहर की ओर दो स्लैश को प्रत्येक तरफ से बदल दें {space}/और \
sort- spaceइससे पहले आता है /ताकि यह सब कुछ सही क्रम में रखे

— रिले
स्रोत
2

05AB1E, 42 38 36 बाइट्स

Dg;<FÐgÍ©£R®ÍN-£„/\‡'/ðN>׫«R'\«}r»

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

स्पष्टीकरण:

# Read the input to the stack, loop for 0 .. len(input) / 2 - 1
Dg;<F
# Save the layer by pushing a copy on the stack, then push
# len(layer) - 2 to both the top of the stack and register_c
     ÐgÍ©
# a = pop(); b = pop(); push(b[0:a].reverse())
# This removes the last 2 characters and reverses
         £R
# push(register_c - 2 - N)
           ®ÍN-
# a = pop(); b = pop(); push(b[0:a])
# This removes the leading spaces and the first two slashes
               £
# Push "/\" and "\/" to the stack.
                 „/\Â
# Transliterate the slashes
                     ‡
# Add N+1 spaces and a / to the end of the (reversed) current layer
                      '/ðN>׫«
# Reverse the layer and add a \ to the end.
                              R'\«
# End the loop
                                  }
# Reverse the stack and join it with newlines. It is implicitly printed.
                                   r»

( यह इंगित करने के लिए एमिग्ना का धन्यवाद DD -> Ðऔर DR -> Â)।

— Ruds
स्रोत
Dg;GDðK¦¦¨¨„/\‡'\«R'/«ðN׫R}r»7 बाइट्स बचाता है।
— इमिग्ना
यह मेरे लिए काफी अलग है कि मुझे लगता है कि आपको अपना जवाब जोड़ना चाहिए :)।
— 17
1

जाओ, 300 276 बाइट्स

package main
import(."regexp";."os")
func p(b string)string{
s:=MustCompile(`((\s*.)(\S*)(\S))`).FindStringSubmatch(b)
if s[3]!=""{r:=""
for _,c:=range s[3][1:len(s[3])-1]{r+=`\/`[c/64:c/46]}
return p(" "+s[2]+r+`\`)+s[1]+"\n"}
return s[1]+"\n"}
func main(){print(p(Args[1]))}

दीर्घ संस्करण:

package main

import (
    "regexp"
    "os"
)

func pyramid(base string) string {
    m := regexp.MustCompile(`^((\s*\S)(\S*)(\S))\s*`).FindStringSubmatch(base)
    if len(m[3]) > 0 {
        reversed := ""
        for _, c := range m[3][1:len(m[3]) - 1] {
            if c == '/' {
                reversed += `\`
            } else {
                reversed += `/`
            }
        }
        return pyramid(" " + m[2] + reversed + m[4]) + m[1] + "\n"
    }
    return m[1] + "\n"
}

func main() {
    print(pyramid(os.Args[1]))
}
— रोलैंड इलिग
स्रोत
import(."regexp";."os")2 बाइट्स बचाता है
— सेफा
@ सिफा थैंक्स, मैंने इसमें से एक और 22 बाइट्स निचोड़ लिए।
— रोलैंड इलिग
1

पर्ल, 53 52 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट के साथ चलाएं, जैसे

./pyramid.pl <<< '//\\///\/\'

pyramid.pl:

#!/usr/bin/perl -p
s%^( *)/.(.*)..%"$1 \\$2/
"=~y|\\/|/\\|r.$&%e&&redo
— टन हास्पेल
स्रोत
1

05AB1E , 31 बाइट्स

Dg;GDðK¦¦¨¨„/\‡'\«R'/«ðN׫R}r»

व्याख्या

Dg;G                        }    # for N in [1..len(input)/2-1]
    D                            # make a copy of previous layer
     ðK                          # remove all spaces
       ¦¦¨¨                      # remove first 2 and last 2 chars
           „/\‡                 # replace '/' with '\' and vice versa
                '\«              # add a backslash at the end
                   R             # reverse
                    '/«          # ad a slash at the end
                       ðN׫      # add N spaces
                           R     # reverse back
                             r»  # reverse stack and join on newline
                                 # implicitly print

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

— Emigna
स्रोत
1

> <> , 186 179 175 171 बाइट्स

0&v &+1&<
  >i:0)?^~&2,:&v
v'/'~v?:-1<  }0<
o    >84*o^-$;?=@:&:&}:~<
\&::&{:@+$}1+[{l1-$-2*:&1+{
>}1-:?!v$:l2%?!vo
^o'/'v?~e  (*5a<
^o'\'< &   >~]a'\'oo{1+:^
  {$1- >:?!^

ऊह यार यह निश्चित रूप से मेरा सबसे बड़ा> <> जवाब है।

अभी भी कुछ गोल्फिंग बाकी है (नीचे का क्षेत्र बहुत बेकार है)

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

— torcado
स्रोत
0

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

function s($s){if($s.Trim()-eq'/\'){return $s}
$n=$s-replace'\\','#'-replace'/','\'-replace'#','/'-replace'\\.(.*)./',' /$1\'
(s($n))+"`n$s"
}
— ओलिवर राहनर
स्रोत
0

सी #, 250 बाइट्स

s=>{int j=s.Length/2,i=0;var l=new string[j];l[j-1]=s;while(++i<j){var n=l[j-i].Trim().Substring(1,l[j-i].Trim().Length-2);l[j-i-1]=new string(' ',i)+"/"+n.Replace("/","#").Replace(@"\","/").Replace("#",@"\").Substring(1,n.Length-2)+@"\";}return l;};

निश्चित रूप से आगे गोल्फ हो सकता है लेकिन मेरा दिमाग मृत हो गया इसलिए मैंने इसे छोड़ने का फैसला किया क्योंकि यह इस समय है।

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