Mach mir einen umgedrehten Weihnachtsbaum!

15

Herausforderung

Wir alle wissen um normale Weihnachtsbaum - aber wie etwa einen Upside-Down - Weihnachtsbaum ! Dies ist eine ziemlich einfache, weihnachtliche Herausforderung. Das Ziel dieser Herausforderung ist es, mich zu einem verkehrten ASCII-Weihnachtsbaum zu machen. Hier sind die Regeln für diese Herausforderung:

  1. Akzeptiere eine ungerade, positive ganze Zahl. Sie können davon ausgehen, dass es immer zwischen 7und liegen wird 51.

  2. Die Basis des Baumes besteht aus den Zeichen:

    ___
\ /
 |

  3. Die Spitze des Baumes (der Stern) besteht aus einem einzigen *.

  4. Jede Zeile des Baums wird mit dem Format erstellt, <?>in dem ?eine beliebige Anzahl von -s angegeben ist. Wenn Sie beispielsweise eine Linie mit einer Länge 5erstellen, sollte diese Linie so sein <--->. Oder wenn Sie eine Linie von Länge machen 8, sollte die Linie sein <------>.

  5. So sollte der Körper des Baumes aufgebaut sein:

    1. Nehmen Sie die ungerade Zahl nals Eingabe und erstellen Sie eine Linie mit dieser Länge.

    2. Subtrahiert 4aus nund eine Linie des Baumes, die Länge erstellen.

    3. Subtrahiert 2aus nund eine Linie des Baumes, die Länge erstellen.

    4. Dekrement nvon 2. Fahren Sie danach, sofern nicht ngleich5 , mit Schritt 2 fort.

  6. Die Basis (siehe Schritt 2.), der Stern (siehe Schritt 3.) und jede Zeile des Baums (siehe Schritte 4. und 5.) sollten alle mit der ursprünglichen ungeraden Zahleneingabe (siehe Schritt 1.) als Maximum zentriert werden Breite.

Beispiele / Testfälle

odd number inputed: 7
  ___
  \ /
   |
<----->      line length -> 7
  <->        line length -> 7 - 4 = 3
 <--->       line length -> 7 - 2 = 5
   *


odd number inputed: 13
     ___
     \ /
      |
<----------->      line length -> 13
  <------->        line length -> 13 - 4 = 9
 <--------->       line length -> 13 - 2 = 11
   <----->         line length -> 11 - 4 = 7
  <------->        line length -> 11 - 2 = 9
    <--->          line length -> 9 - 4 = 5
   <----->         line length -> 9 - 2 = 7
     <->           line length -> 7 - 4 = 3 
    <--->          line length -> 7 - 2 = 5
      *


odd number inputed: 9
   ___
   \ /
    |
<------->      line length -> 9
  <--->        line length -> 9 - 4 = 5
 <----->       line length -> 9 - 2 = 7
   <->         line length -> 7 - 4 = 3
  <--->        line length -> 7 - 2 = 5
    *


odd number inputed: 17
       ___
       \ /
        |
<--------------->      line length -> 17
  <----------->        line length -> 17 - 4 = 13
 <------------->       line length -> 17 - 2 = 15
   <--------->         line length -> 15 - 4 = 11
  <----------->        line length -> 15 - 2 = 13
    <------->          line length -> 13 - 4 = 9
   <--------->         line length -> 13 - 2 = 11
     <----->           line length -> 11 - 4 = 7
    <------->          line length -> 11 - 2 = 9
      <--->            line length -> 9 - 4 = 5
     <----->           line length -> 9 - 2 = 7
       <->             line length -> 7 - 4 = 3
      <--->            line length -> 7 - 2 = 5
        *

Regeln

code-golf  string  ascii-art 
— Christian Dean
quelle
3
Da die Eingabe garantiert eine ungerade Zahl ist, können wir ihren Index in der Reihenfolge der ungeraden Zahlen nehmen?
— FlipTack
Auch - repeat the above steps until the odd number minus 2 equals 5- in der ersten Eingabe ist die ungerade Zahl 7 und 7-2 = 5, daher sollte der Baum sofort enden (ich weiß, was Sie meinen, aber es muss umformuliert werden)
— FlipTack
@FlipTack Ich weiß nicht genau, was du meinst. Wenn die ungerade Zahl 7die minimale Eingabe ist, würden Sie zuerst die drei Baumlinien erstellen (Unterschritte .1.1, .1.2, .1.3), dann2 von der ungeraden Zahl subtrahieren und testen, ob sie gleich ist 5. Die Anweisung, zu überprüfen, ob die "ungerade Zahl minus 2 gleich 5" ist, ist am Ende, die anderen drei Schritte sollten zuerst ausgeführt werden. Aber um Ihren ersten Kommentar zu beantworten, wäre das in Ordnung.
— Christian Dean
1
@FlipTack Ich denke, er fragt, ob Sie 7als Eingabe akzeptieren müssen oder ob Sie akzeptieren können 4, wie in der vierten ungeraden Zahl (oder 3ob es 0-indiziert ist).
— DonielF
4
Aus dem Titel: "Ok, du bist jetzt ein umgedrehter Weihnachtsbaum."
— Dkudriavtsev

Antworten:

10

Python 3 , 127 121 105 103 100 98 Bytes

Dies ist eine unbenannte Lambda-Funktion, die eine Liste von Zeilen zurückgibt:

lambda o:[s.center(o)for s in['___','\ /','|',*[f'<{"-"*(o-i+2-i%2*3)}>'for i in range(4,o)],'*']]

Probieren Sie es online!

Der Hauptteil dieser Antwort besteht darin (o-i+2-i%2*3), die Anzahl der Striche in einer Zeile zu ermitteln. Der Rest der Antwort besteht einfach darin, dies in die gewünschte ASCII-Kunst umzuwandeln.

Vielen Dank an Herrn Xcoder für das Rasieren von 6 Bytes und das Besprechen von Golfspielen mit mir im Chat.

Vielen Dank auch an Lynn für Bemerken , das 3*(i%2)sein kann i%2*3, 2 Bytes kürzer!

— FlipTack
quelle
— Mr. Xcoder
2
Wann immer ich eine Python-Antwort poste, egal zu welcher Tageszeit oder an welchem ​​Ort, @ Mr.Xcoder hat Golf zu spielen :)
— FlipTack
Welp , das schlägt meine 250 Bytes + Python-Lösung leicht. Gut gemacht! +1
— Christian Dean
o-i+2-i%2*3spart zwei Bytes.
— Lynn
@Lynn Guter Ort, aktualisiert.
— FlipTack
7

C 163 Bytes

#define P;printf(
i;g(l){P"%*c",1+i-l--/2,60);for(;--l P"-"))P">\n");}f(n){i=n/2 P"%*c__\n%*c /\n%*c|\n",i,95,i,92,i,32);for(g(n);n>5;g(n-=2))g(n-4)P" %*c",i,42);}

Probieren Sie es online!

Abgerollt:

#define P;printf(

i;
g(l)
{
    P"%*c", 1+i-l--/2, 60);
    for (; --l P"-"))
    P">\n");
}

f(n)
{
    i=n/2
    P"%*c__\n%*c /\n%*c|\n", i, 95, i, 92, i, 32);

    for(g(n); n>5; g(n-=2))
        g(n-4)

    P" %*c", i, 42);
}
— Steadybox
quelle
6

Proton , 83 Bytes

Vielen Dank an FlipTack für das Speichern von 4 Bytes und für die Zusammenarbeit im Chat (wir bilden tatsächlich ein großartiges Team). Indirekt 2 Bytes dank Lynn gespeichert .

o=>[s.center(o)for s:['___','\ /','|']+['<'+"-"*(o-i+2-i%2*3)+'>'for i:4..o]+['*']]

Probieren Sie es online!

— Mr. Xcoder
quelle
5

Kohle , 28 Bytes

__⸿ /⸿|Ｆ⮌…¹⊘Ｎ«⸿⊕ι>⸿⊖ι>»‖Ｂ← *

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

__⸿ /⸿|

Drucken Sie die Basis.

Ｆ⮌…¹⊘Ｎ«

Schleife von der Hälfte der eingegebenen Nummer auf 1 ab.

⸿⊕ι>⸿⊖ι>»

Drucken Sie zwei Zeilen, die erste mit einer Zeile mehr -als dem Schleifenindex, die zweite mit einer Zeile weniger.

‖Ｂ←

Spiegeln, um den Baum zu vervollständigen.

 *

Platziere den Stern.

— Neil
quelle
3

Netzhaut , 89 Bytes

.+
$*->
^--
<
+`( *<)----(-+>)$
$&¶  $1$2¶ $1--$2
s`.*¶( +)<->.*
$1___¶$1\ /¶$1 |¶$&¶$1 *

Probieren Sie es online! Erläuterung: In der ersten Stufe wird die Eingabe in unär umgewandelt und a angehängt >. Die zweite Stufe ersetzt zwei -s durch a <, um die Leitungslänge zu korrigieren. Die dritte Stufe repliziert dann den Zweig, ist jedoch jedes Mal etwas kürzer, bis der Zweig nicht mehr weiter gekürzt werden kann. Die letzte Stufe fügt die Basis und den Stern hinzu.

— Neil
quelle
2

Javascript 506 Bytes

Golf-Version:

function tree(i){const mid=(i+1)/2;const leg1=' '.repeat((mid-2))+`___
`;const leg2=' '.repeat((mid-2))+`\\ \/
`;const leg3=' '.repeat((mid-1))+`|
`;let xmasTree=leg1+leg2+leg3;for(let j=0;j<(i-4);j++){if(j%2===0){let v=j/2;let t=i-2*v-2;let body1=" ".repeat(j/2)+"<"+"-".repeat(t)+">"+`
`;xmasTree=xmasTree+body1}else{let k=1+Math.ceil(j/2);let h=i-2*k-2;let body2=' '.repeat(k)+'<'+'-'.repeat(h)+">"+`
`;xmasTree=xmasTree+body2}}
const head=' '.repeat((mid-1))+'*'
xmasTree=xmasTree+head;return xmasTree}

Ungolf-Version:

function tree(i){
  const mid = (i+1)/2;
  const leg1 = ' '.repeat((mid-2)) + `___
`;
  const leg2 = ' '.repeat((mid-2)) + `\\ \/
`;
  const leg3 = ' '.repeat((mid-1)) + `|
`;
  let xmasTree = leg1 + leg2 + leg3;
  for (let j = 0; j<(i-4); j++) {
    if (j%2===0) {
      let v = j/2;
      let t = i-2*v-2;
      let body1 = " ".repeat(j/2)+"<"+"-".repeat(t) +">"+`
`;
      xmasTree = xmasTree + body1;
    } else {
      let k = 1 + Math.ceil(j/2);
      let h = i-2*k-2;
      let body2 = ' '.repeat(k)+ '<'+ '-'.repeat(h) + ">"+`
`;
      xmasTree = xmasTree + body2;
    }
  }
  const head = ' '.repeat((mid-1)) + '*'
  xmasTree = xmasTree + head;
  return xmasTree;
}

Verwendung: console.log(tree(13)), console.log(tree(17)),

ES6 165 Bytes (von meinem Freund)

Golf-Version:

p=n=>{l=_=>console.log(`${' '.repeat((n-_.length)/2)}${_}`);t=_=>_==1?'*':'<'+'-'.repeat(_-2)+'>';x=n;l('___');l('\\ /');l('|');for(;x!==3;){l(t(x));l(t(x-4));x-=2}}

Ungolf-Version:

p = n => {
  l = _ => console.log(`${' '.repeat((n-_.length)/2)}${_}`);
  t = _ => _ == 1 ? '*' : '<' + '-'.repeat(_-2)+'>';
  x = n;
  l('___');l('\\ /');l('|');
  for(;x!==3;) {
    l(t(x)); l(t(x-4));x-=2;
  }
}

Verwendung: p(31); p(17);

— NTCG
quelle
1
Sie könnten dies viel Golf spielen, indem Sie nur 1-Buchstaben-Variablennamen verwenden, constStichwörter entfernen usw.
— FlipTack
1

PowerShell , 131 Byte

$i=2;$x="$args"..5|%{' '*($j=if($_%2){$i-2}else{($i++)})+'<'+'-'*($_-(5,2)[$_%2])+'>'};($y=' '*++$j)+"___";"$y\ /";"$y |";$x;"$y *"

Probieren Sie es online!

Nun, das ist ein richtiges Durcheinander für alle, die nicht mit PowerShell vertraut sind. Mal sehen, wie gut ich erklären kann, wie es funktioniert.

Für die Erklärung werde ich verwenden input = 17.

Wir beginnen ganz einfach mit dem Setzen der Hilfsvariablen $i=2und dem Setzen von $xauf <something>, wobei der <something>Start als Bereich von der Eingabe $argsbis zur Eingabe 5erfolgt 17,16,15,...,6,5. Dieser Bereich wird in eine for-Schleife gepumpt.

Bei jeder Iteration setzen wir die Hilfsvariable $jals Ergebnis einer ifAnweisung if($_%2){$i-2}else{($i++)}. Wenn es seltsam ist $j=$i-2, sonst $j=($i++). Dies, verbunden mit $i=2am Anfang, gibt uns die Reihenfolge, 0, 2, 1, 3, 2, 4, 3, 5...die genau der Anzahl der Leerzeichen entspricht, die wir unserer Baumgrenze voranstellen müssen. ;-) Wir nehmen ' 'und multiplizieren es mit dieser Zahl.

Als nächstes brauchen wir unsere Filialen. Dies geschieht mit '<'plus dem Mittelteil '-'multipliziert mit dem Ende '>'. Die Multiplikation erfolgt durch Erkennen der -Alternative in einem 2, 5, 2, 5, 2...Muster basierend auf der eingegebenen Nummer $_, sodass wir aus einem Pseudoternär basierend auf diesem Muster auswählen.

Zur weiteren Verdeutlichung sind hier die ersten Begriffe in jedem Abschnitt:

$_ = 17 16 15 14 13 12 11 10
$j =  0  2  1  3  2  4  3  5
mid=  2  5  2  5  2  5  2  5
'-'= 15 11 13  9 11  7  9  5

Also haben wir jetzt festgelegt $x, dass es sich um ein Array von Zweigen (dh Zeichenfolgen) handelt. Außerhalb der Schleife bauen wir nun unseren Baum "oben" mit der entsprechenden Anzahl von Feldern auf $y, zeigen dann unsere Zweige $xan und dann den Baum "unten" mit dem *. Jedes dieser Elemente verbleibt in der Pipeline und die Ausgabe erfolgt implizit mit einem Zeilenumbruch zwischen den Elementen.

— AdmBorkBork
quelle
1

JavaScript (ES6), 150 bis 147 Byte

N=>{for(s=' '[r='repeat'](N/2-1),s+=`___
${s}\\ /
${s} |
`,n=N,l=n=>' '[r](N/2-n/2)+(n-1?`<${'-'[r](n-2)}>
`:'*');n-3;n-=2)s+=l(n)+l(n-4)
return s}

Code-Snippet anzeigen

— darrylyeo
quelle
0 
N=>{for(s=' '[r='repeat'](N/2-1),s+=`___
${s}\\ /
${s} |
`,l=n=>' '[r](N/2-n/2)+n-1?`<${'-'[r](n-2)}>
`:'*');N-=2;s+=l(N)+l(N-4);return s}

Mein Versuch bei JS ESGoogoltriplex.

Code-Snippet anzeigen

— user75200
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.