Ich kann den Wald vor lauter Bäumen nicht sehen

29

Schreiben Sie ein Programm oder eine Funktion, die einen Baum zeichnet und so einen Wald baut.

Die Bäume sind gezeichnet wie ein Pyramidenstapel. Die erste (obere) Zeile enthält einen 1Baum, die nächste Zeile enthält 2(insgesamt 3), die nächste enthält 3(insgesamt 6) und so weiter. Wenn nicht genügend Bäume vorhanden sind, um eine ganze Reihe zu vervollständigen, füllen Sie sie links aus und lassen Sie die Felder rechts leer. Darüber hinaus überlappen Bäume der unteren Ebene Bäume der oberen Ebene aufgrund ihrer Platzierung geringfügig.

Dies ist ein Wald von Größe 1

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

Dies ist ein Wald von Größe 2

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

Dies ist ein Wald von Größe 3

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

Dies ist ein Wald von Größe 4

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

Dies ist ein Wald von Größe 5(beachten Sie, dass die Spitze des fünften Baums den Stamm des ersten Baums bedeckt)

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

(überspringe ein paar)
Dies ist ein Wald von Größe 8(Erweiterung des Musters)

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

und so weiter.

Eingang

Eine einzelne positive ganze Zahl in jedem geeigneten Format , n > 0.

Ausgabe

Eine ASCII-artige Darstellung der Gesamtstruktur gemäß den obigen Regeln. Führende / nachfolgende Zeilenumbrüche oder andere Leerzeichen sind optional, vorausgesetzt, die Bäume sind alle richtig ausgerichtet.

Regeln

  • Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
  • Standardlücken sind verboten.
  • Dies ist daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.
AdmBorkBork
quelle
Ich bin nicht sicher, wie das Muster in Bezug auf die Reihenfolge aussieht, in der die Bäume gezeichnet werden. Das heißt, nwie sind die Positionen der Bäume?
Luis Mendo
@ LuisMendo Wie ich verstehe, sind sie in Lesereihenfolge ausgefüllt. Also wird jede Reihe der Reihe nach gefüllt, und wenn nicht genügend Bäume für die gesamte Reihe vorhanden sind, wird der Rest so weit wie möglich links in dieser Reihe platziert.
Xnor
@ LuisMendo xnor hat es richtig. Wenn ich das noch einmal umformulieren kann, um es klarer zu machen, schicke mich bitte im Chat an.
AdmBorkBork
@xnor Danke, es ist mir jetzt völlig klar
Luis Mendo
@Adm Eigentlich wurde es genau dort in der Challenge geschrieben. Anscheinend kann ich nicht lesen :-)
Luis Mendo

Antworten:

5

Haskell 310 Bytes

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

Nennen Sie es w 5zum Beispiel mit.

Hier der unkomprimierte Code:

-- 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
Gerhard
quelle
Willkommen bei PPCG!
AdmBorkBork
4

JavaScript (ES6), 357 297 276 Byte

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>

Bearbeiten: 21 Bytes dank @KritixiLithos gespeichert.

Neil
quelle
Zum repeateinen können Sie blah.repeat(val)zu blah[w="repeat"](val) wechseln und dann die nachfolgenden Vorkommen von repeatzu ändern [w](val), um nur Bytes zu sparen
Kritixi Lithos
@KritixiLithos Das kann ich nicht ganz, weil der erste repeatin der forSchleife ist und nicht läuft n=1, aber ich konnte trotzdem 21 Bytes sparen.
Neil
4

C ++ (unter Windows), 330 312 308 304 303 Byte

#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;}}

Rufen Sie an mit:

int main()
{
    f(8);
}
Steadybox
quelle
0

C (unter Windows): 297 295 294 Byte

#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);}}

Ähnlich wie meine C ++ - Antwort, aber ich habe dies gepostet, weil es in C etwas kürzer ist.

Steadybox
quelle
@DLosc It's C. #importist eine (veraltete) GCC-Erweiterung. Fit zum Golfen.
Steadybox
Interessant. Jetzt sehe ich, dass es dafür einen Tipp gibt . Sie könnten das in Ihrer Antwort erwähnen.
DLosc
@DLosc Vielleicht, aber ich denke, es wird beim Golfen ziemlich häufig verwendet, zusammen mit einigen anderen GCC-Erweiterungen (die jedoch nicht auf GCC beschränkt sind), wie das Weglassen <stdio.h>und automatische Annehmen einer globalen Variablen intoder einer Funktion, die zurückgegeben werden soll int.
Steadybox
0

Javascript 418 377 Bytes

Vielen Dank an @Kritixi Lithos für die Unterstützung beim Golfspielen bei 39 Byte

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):''}

Probieren Sie es online

fəˈnəˈtɪk
quelle
2
Zum ersten repeatkönnen Sie ändern , blah.repeat(val)auf blah[w="repeat"](val)und dann können Sie die nachfolgenden Vorkommen ändern , repeatum nur [w](val)statt zu speichern Bytes
Kritixi Lithos