पेड़ों के लिए जंगल नहीं देख सकते

Question

एक कार्यक्रम या फ़ंक्शन लिखें जो पेड़ों के एक पेड़ को खींचता है, इस प्रकार एक जंगल का निर्माण होता है।

पेड़ों को एक पिरामिड के ढेर की तरह खींचा जाता है। पहली (शीर्ष) पंक्ति में 1वृक्ष होता है, अगली पंक्ति नीचे होती है 2(कुल के लिए 3), अगली में 3(कुल के लिए 6) होती है, और इसी तरह। यदि एक पूरी पंक्ति को पूरा करने के लिए पर्याप्त पेड़ नहीं हैं, तो इसे बाईं ओर भरें और दाईं ओर स्थित स्थानों को छोड़ दें। इसके अतिरिक्त, निचले स्तर के पेड़ अपने स्थान के कारण ऊपरी स्तर के पेड़ों को थोड़ा ओवरलैप करते हैं।

यह आकार का एक जंगल है 1

  /\
 //\\
///\\\
  ||
  ||

यह आकार का एक जंगल है 2

      /\
     //\\
  /\///\\\
 //\\ ||
///\\\||
  ||
  ||

यह आकार का एक जंगल है 3

      /\
     //\\
  /\///\\\/\
 //\\ || //\\
///\\\||///\\\
  ||      ||
  ||      ||

यह आकार का एक जंगल है 4

          /\
         //\\
      /\///\\\/\
     //\\ || //\\
  /\///\\\||///\\\
 //\\ ||      ||
///\\\||      ||
  ||
  ||

यह आकार का एक जंगल है 5(ध्यान दें कि पांचवें पेड़ का शीर्ष पहले पेड़ के तने को कवर कर रहा है)

          /\
         //\\
      /\///\\\/\
     //\\ || //\\
  /\///\\\/\///\\\
 //\\ || //\\ ||
///\\\||///\\\||
  ||      ||
  ||      ||

(कुछ को छोड़ें)
यह आकार का एक जंगल है 8(पैटर्न का विस्तार)

              /\
             //\\
          /\///\\\/\
         //\\ || //\\
      /\///\\\/\///\\\/\
     //\\ || //\\ || //\\
  /\///\\\/\///\\\||///\\\
 //\\ || //\\ ||      ||
///\\\||///\\\||      ||
  ||      ||
  ||      ||

और इसी तरह।

इनपुट

एक एकल सकारात्मक पूर्णांक किसी भी सुविधाजनक प्रारूप में , n > 0।

उत्पादन

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

नियम

• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

मुझे यकीन नहीं है कि पैटर्न उस क्रम के बारे में है जिसमें पेड़ खींचे जाते हैं। अर्थात्, दिया गया n, पेड़ों की स्थिति क्या है?

— लुइस मेंडो

@LuisMendo जैसा कि मैं समझता हूं, वे पढ़ने के क्रम में भरे हुए हैं। इसलिए, प्रत्येक पंक्ति को बारी-बारी से भरा जाता है, और यदि पूरी पंक्ति के लिए पर्याप्त पेड़ नहीं हैं, तो शेष को उस पंक्ति में यथासंभव छोड़ दिया जाता है।

— xnor

@LuisMendo xnor के पास यह अधिकार है। अगर मैं इसे और अधिक स्पष्ट करने के लिए फिर से शब्द दे सकता हूं, तो कृपया मुझे चैट में पिंग करें।

— AdMBorkBork

@ एक्सनॉर धन्यवाद, यह मेरे लिए अब पूरी तरह से स्पष्ट है

— लुइस मेंडो

@ एएमडी वास्तव में इसे चुनौती में वहीं लिखा गया था। जाहिरा तौर पर मैं :-)

— लुइस मेंडो

Answer 1

हास्केल 310 बाइट्स

w i=putStr$unlines$reverse$b i 0 0[][]
b 0 _ _ w r=e w r
b c l 0 w r=b c(l+1)l(e w r)[]
b c l p w r=b(c-1)l(p-1)w(n(++)["  ||    ","  ||    ","///\\\\\\  "," //\\\\   ","  /\\    "]r)
e w r=t++n(n d)(map(\t->"    "++t)w)c where(t,c)=splitAt 2 r
n f(a:c)(b:d)=f a b:n f c d
n _ a[]=a
n _ _ a=a
d d ' '=d
d _ d=d

w 5उदाहरण के लिए, इसके साथ कॉल करें ।

यहाँ असम्पीडित कोड:

-- TreeTree
-- by Gerhard
-- 12 February 2017

module TreeTree (wood,test) where

type Tree = [String]

-- Test cases
test = do
 wood 0
 wood 1
 wood 2
 wood 3
 wood 4
 wood 5

-- build wood
wood :: Int -> IO ()
wood i = printTree $ buildWood i 0 0 [] []

-- Prints the trees
printTree :: Tree -> IO ()
printTree = putStr . unlines . reverse

-- build wood
buildWood :: Int -> Int -> Int -> Tree -> Tree -> Tree
buildWood 0 _ _ w r = concatTree w r 
buildWood c l 0 w r = buildWood c (l+1) l (concatTree w r) []
buildWood c l p w r = buildWood (c-1) l (p-1) w (addTree r)

-- indent definition
space :: String
space = "    "

-- tree definition
tree :: Tree
tree = reverse [
 "  /\\    ",
 " //\\\\   ",
 "///\\\\\\  ",
 "  ||    ",
 "  ||    "]

-- Add a Tree on the left side
addTree :: Tree -> Tree
addTree = match (++) tree

-- add tree row at the bottom of the wood
concatTree :: Tree -> Tree -> Tree
concatTree w r = trunk ++ matched
 where
  wood = grow w
  (trunk, crown) = splitAt 2 r 
  matched = matchTree wood crown

-- elnarge forrest on the left side to match next tree line
grow :: Tree -> Tree
grow = map (\t -> space ++ t)

-- match
match :: (a -> a -> a) -> [a] -> [a] -> [a]
match f (a:az) (b:bz) = f a b : match f az bz
match _ a [] = a
match _ _ a  = a

-- match trees
matchTree :: Tree -> Tree -> Tree
matchTree = match matchLine

-- match lines
matchLine :: String -> String -> String
matchLine = match matchChar

-- match chars
matchChar :: Char -> Char -> Char
matchChar c ' ' = c
matchChar _ c   = c

-- End

Comments

PPCG में आपका स्वागत है!

— AdmBorkBork

Answer 2

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

f=
n=>{a=`  /\\`;d=`///\\\\\\`;b=d+`/\\`;c=` //\\\\ ||`;d+=`||`;e=`
`;r=`repeat`;s=``;for(i=1;n>i;n-=i++)s=(s+a+b[r](i-1)+e+c[r](i)).replace(/^/gm,`    `)+e;return(s+a+b[r](n-1)+d[r](i-=n)+e+c[r](n)+(s=`      ||`[r](i))+e+d[r](n)+s+(s=e+`  ||    `[r](n))+s).replace(/\|.$/gm,``)}

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

संपादित करें: @KritiiLithos की बदौलत 21 बाइट्स सहेजे गए।

Comments

पहले के लिए repeat, आप बदल सकते हैं blah.repeat(val)करने के लिए blah[w="repeat"](वैल) और फिर आप के बाद आवृत्तियां बदल सकते हैं repeatबस के [w](val)बजाय बाइट्स बचाने के लिए

— Kritixi lithos

@KritiiLithos मैं ऐसा नहीं कर सकता क्योंकि पहला लूप के repeatअंदर है forऔर इसके लिए नहीं चलेगा n=1, लेकिन मैं अभी भी 21 बाइट बचाने में सक्षम था।

— नील

Answer 3

C ++ (विंडोज पर), 330 312 308 304 303 बाइट्स

#import<cstdio>
#import<windows.h>
#define P(x,y,s)SetConsoleCursorPosition(GetStdHandle(-11),{X+x,Y+y});puts(s);
int X,Y,R,r,c;t(){P(2,-2,"/\\")P(1,-1,"//\\\\")P(0,0,"///\\\\\\")P(2,1,"||")P(2,2,"||")}f(int n){for(c=R=r=1;c<n;c+=++R);for(;r;r++)for(c=0;++c<r+1;){X=(R-r-2)*4+c*8;Y=r*2;t();r=--n?r:-1;}}

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

int main()
{
    f(8);
}

Answer 4

सी (विंडोज पर), 297 295 294 बाइट्स

#import<windows.h>
#define P(x,y,s)C.X=X+x;C.Y=Y+y;SetConsoleCursorPosition(GetStdHandle(-11),C);puts(s);
COORD C;X,Y,R,r,c;t(){P(2,-2,"/\\")P(1,-1,"//\\\\")P(0,0,"///\\\\\\")P(2,1,"||")P(2,2,"||")}f(n){for(c=R=r=1;c<n;c+=++R);for(;r;r++)for(c=0;++c<r+1;){X=(R-r-2)*4+c*8;Y=r*2;t(r=--n?r:-1);}}

मेरे C ++ उत्तर के समान, लेकिन मैंने इसे पोस्ट किया क्योंकि यह C में कुछ छोटा है।

Comments

@ डलॉक इट्स सी। #importएक (पदावनत) जीसीसी विस्तार है। गोल्फ के लिए फिट, यद्यपि।

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

हुह, दिलचस्प है। अब मैं देख रहा हूं कि इसके लिए एक टिप है। आप अपने उत्तर में इसका उल्लेख कर सकते हैं।

— १२:३३ पर DLosc

@ डलास शायद, लेकिन मुझे लगता है कि इसे गोल्फ में काफी व्यापक रूप से इस्तेमाल किया जाता है, साथ ही कुछ अन्य जीसीसी (हालांकि जीसीसी तक सीमित नहीं) एक्सटेंशन को छोड़ देना <stdio.h>और स्वचालित रूप से एक वैश्विक चर मान लेना intया वापस आने के लिए एक फ़ंक्शन int।

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

Answer 5

जावास्क्रिप्ट 418 377 बाइट्स

39 बाइट से गोल्फ की मदद के लिए @Kritii Lithos को धन्यवाद

x=>{s='';for(t=0;++t<x;x-=t);q='//\\\\';z="///\\\\\\";h="/\\";t--;for(i=0;i<t;i++){a=4*(t-i)+1;s+=" "[w="repeat"](a+1)+h+(z+h)[w](i)+`
`+" "[w](a)+q+(" || "+q)[w](i)+`
`}c=t-x+1>0?t-x+1:0;return x?s+"  "+(h+z)[w](--x)+h+(c?(z+"||")[w](c-1)+z:'')+`
 `+q+(" || "+q)[w](x)+" ||     "[w](c)+`
`+(z+"||")[w](x)+z+(c?"||"+"      ||"[w](c-1):'')+`
`+("  ||    "[w](x+1)+`
`)[w](2):''}

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

Comments

पहले के लिए repeat, आप बदल सकते हैं blah.repeat(val)करने के लिए blah[w="repeat"](val)और फिर आप के बाद आवृत्तियां बदल सकते हैं repeatबस के [w](val)बजाय बाइट्स बचाने के लिए

— Kritixi lithos