Moja żona jest bardzo, powiedzmy, szczególnie, jeśli chodzi o nakładanie ozdób na naszą choinkę. Dajmy jej kod, który pomoże jej w tym trudnym czasie.

Wkład

Biorąc pod uwagę 2 < n < 10wysokość drzewa i 0 < k < nwyraźną liczbę ozdób.

Zadanie

Udekoruj drzewo, zaczynając od 1i zwiększając k, owijając ozdoby wokół drzewa. Jeśli dotrzemy ki będziemy mieć więcej gałęzi do dekoracji, zacznij od nowa 1.

Nie ma problemu, jeśli na drzewie nie ma takiej samej liczby ozdób, o ile wzór jest spełniony.

Ozdoby powinny pojawiać się nad każdą gałęzią, ^z wyjątkiem górnego rzędu.

Drzewo ma strukturę zaczynającą się od jednej gałęzi, następnie następny poziom ma + 1 gałęzie ze spacją między nimi, przesuniętą od góry jak:

 ^
^ ^

W trzecim rzędzie dodajesz jeszcze jedną gałąź i ustawiasz je ponownie tak, aby żadna gałąź nie była w tej samej kolumnie (jeśli myślisz o niej jak o siatce).

  ^
 ^ ^
^ ^ ^

Wydajność

Wyjmij ozdobione drzewo.

Przykłady

1.

n = 3, k = 2

  ^      //Height is 3
 ^ ^
^ ^ ^

Teraz dekorujemy każdą gałąź zaczynając od 1 i zwiększając do k:

  ^
 1 2
 ^ ^
1 2 1
^ ^ ^

2)

n = 6, k = 5

     ^    //Non-Decorated
    ^ ^
   ^ ^ ^
  ^ ^ ^ ^
 ^ ^ ^ ^ ^
^ ^ ^ ^ ^ ^

     ^    //Decorated
    1 2
    ^ ^
   3 4 5
   ^ ^ ^
  1 2 3 4
  ^ ^ ^ ^
 5 1 2 3 4
 ^ ^ ^ ^ ^
5 1 2 3 4 5
^ ^ ^ ^ ^ ^

3)

n = 5, k = 1

    ^
   ^ ^
  ^ ^ ^
 ^ ^ ^ ^
^ ^ ^ ^ ^

    ^
   1 1
   ^ ^
  1 1 1
  ^ ^ ^
 1 1 1 1
 ^ ^ ^ ^
1 1 1 1 1
^ ^ ^ ^ ^

To jest golf golfowy, więc wygrywa najkrótszy kod! Baw się dobrze i powodzenia!

C # 226 221 bajtów

Zaoszczędź 5 bajtów dzięki @Mukul Kumar i @aloisdg

Gra w golfa:

string C(int n,int k){string o="",x;int j=1,i=1,m;for(;i<=n;i++){o+=string.Concat(Enumerable.Repeat("^ ",i)).PadLeft(n+i)+"\n";m=0;x="";if(i<n){while(m<i+1){if(j>k)j=1;x+=j+++" ";m++;}o+=x.PadLeft(n+i+1)+"\n";}}return o;}

Nie golfowany:

public string C(int n, int k, WifeMode wifeMode = WifeMode.Maniacal)
{
  string o = "",x;
  int j = 1,i=1,m;

  for (; i <= n; i++)
  {
    o += string.Concat(Enumerable.Repeat("^ ", i)).PadLeft(n+i) + "\n";

    m = 0;
    x = "";

    if (i < n)
    {
      while (m < i + 1)
      {
        if (j > k) j = 1;
        x += j++ + " ";
        m++;
      }

      o += x.PadLeft(n + i + 1) + "\n";
    }
  }

  return o;
}

Testowanie:

Console.Write(new ChristmasTreeDecorating().C(20, 9));

                   ^ 
                  1 2 
                  ^ ^ 
                 3 4 5 
                 ^ ^ ^ 
                6 7 8 9 
                ^ ^ ^ ^ 
               1 2 3 4 5 
               ^ ^ ^ ^ ^ 
              6 7 8 9 1 2 
              ^ ^ ^ ^ ^ ^ 
             3 4 5 6 7 8 9 
             ^ ^ ^ ^ ^ ^ ^ 
            1 2 3 4 5 6 7 8 
            ^ ^ ^ ^ ^ ^ ^ ^ 
           9 1 2 3 4 5 6 7 8 
           ^ ^ ^ ^ ^ ^ ^ ^ ^ 
          9 1 2 3 4 5 6 7 8 9 
          ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 
         1 2 3 4 5 6 7 8 9 1 2 
         ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 
        3 4 5 6 7 8 9 1 2 3 4 5 
        ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 
       6 7 8 9 1 2 3 4 5 6 7 8 9 
       ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 
      1 2 3 4 5 6 7 8 9 1 2 3 4 5 
      ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 
     6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 
     ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 
    3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 
    ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 
   1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 
   ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 
  9 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 
  ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 
 9 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 
 ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ 
1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 
^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^

Edycja: Miałem casting intdo ConsoleColor... Tegorocznego sezonu :)

MerryChristmas.gif

05AB1E ,29 27 24 bajty

Zaoszczędzono trzy bajty dzięki Adnan!

>GN„^ ×NÝNLO<+²%>ðý}\».c

>G                       For N in [1, ..., input[0]]
  N„^ ×                  Push a string of "^ " N times
       NÝ                Push [0, ..., N]
         NLO<            Compute the decoration offset, sum([1, ..., N])-1
             +           Add the offset value to each array cell
              ²%         Modulo input[1]
                >        Add 1 so that it is in range [1, k] instead of [0, k-1]
                 ðý      Join with spaces, now we have a string with the full decoration for the current layer
                   }     End for
                    \    Remove the last decoration
                     »   Join everything with newlines
                      .c Center all and implicitly display

Wypróbuj online!

JavaScript (ES6), 97 bajtów

Wygląda na to, że twoja żona naprawdę jest maniakalna, więc nie obejmuje to żadnej wiodącej lub końcowej nowej linii ani żadnej wiodącej lub końcowej przestrzeni. :-)

f=(n,k,x,s=`^
`)=>n--?(p=' '.repeat(n)+s,x?p.replace(/\^/g,_=>x++%k+1)+p:p)+f(n,k,x||k,'^ '+s):''

Próbny

f=(n,k,x,s=`^
`)=>n--?(p=' '.repeat(n)+s,x?p.replace(/\^/g,_=>x++%k+1)+p:p)+f(n,k,x||k,'^ '+s):''

console.log(f(6, 5))

C ++ 214–13–3–1–1–10 = 186 bajtów

grał w golfa

#define s std::cout<<
int f(int n,int k){int N=++n,K=0,i=0,I;for(;i<n;i++,N--){for(I=N;I--;)s' ';for(I=0;I++<i&&i-1;)s' '<<(K++%k)+1;s'\n';for(I=N;I--;)s' ';for(I=0;I++<i;)s" ^";s'\n';}}  

Dzięki @ cyoce za uratowanie 1 bajtu.
Dzięki @ Conor do krojenia w dół do 186!

Ungolfed + kopiuj i kompiluj

#include<iostream>
#include<conio.h>

#define s(a) std::cout<<a;

int main()
{
    int n,N,k,K=0,i,I;
    std::cin>>n>>k;
    N=++n;
    for(i=0;i<n;i++,N--)
    {
        for(I=N;I--;)

            s(' ')

        for(I=0;I<i&&i-1;I++)

            s(' '<<(K++%k)+1)

        s('\n')

        for(I=N;I;I--)

            s(' ')

        for(I=0;I<i;I++)

            s(" ^")

        s('\n')

    }
    getch();//or any func to pause the console
}  

Python 2, 133 bajty

n,k=input()
d=-1
j=' '.join
for i in range(1,n+1):s=' '*(n-i);print(['',s+j(`x%k+1`for x in range(d,d+i))+'\n'][i>1]+s+j('^'*i));d+=i

Clojure, 223 bajty

Moja pierwsza gra w golfa z Clojure:

(let[r repeat](defn d[n k](apply str(concat(r(dec n)\ )"^\n"(flatten(for[i(range 2(inc n))m[nil true]](concat(r(- n i)\ )(butlast(interleave(if m(r\^)(rest(iterate #(inc(mod % k))(dec(/(* i(dec i))2)))))(r i\ )))"\n")))))))

Po wywołaniu jak (println (str "\n" (d 6 5)))nowa linia sprawia, że ​​jest przyjemniej na REPL:

     ^
    1 2
    ^ ^
   3 4 5
   ^ ^ ^
  1 2 3 4
  ^ ^ ^ ^
 5 1 2 3 4
 ^ ^ ^ ^ ^
5 1 2 3 4 5
^ ^ ^ ^ ^ ^

Bez golfa:

(defn tree-row [n k index mode]
  (concat
    (repeat (- n index) \ ) ; Left padding
    (butlast ; Removing trailing space
      (interleave
        ; Either printing carets or numbers...
        (if mode
          (repeat \^)
          ; Using "rest" as the iteration starts from a large value
          ; from which the modulo has not been calculated yet.
          (rest (iterate #(inc (mod % k)) (dec (/ (* index (dec index)) 2)))))
        ; ...and interleaved with spaces
        (repeat index \ )))
    "\n"))

(defn decorate [n k]
  (apply str (concat
               (repeat (dec n) \ ) "^\n"
               (flatten (for [index (range 2 (inc n)) mode [nil true]]
                          (tree-row n k index mode))))))

Miałem pewne problemy z leniwymi sekwencjami i zagnieżdżonymi listami, ale byłem w stanie zapisać niektóre znaki, nie powtarzając repeat;) i używając \^znaków zamiast "^"ciągów znaków. Mogłem też pominąć zaskakująco wiele miejsc.

Ruby 107 bajtów

t=->(n,k){d=[*1..k]*n*n;o=0;(1..n).each{|b|s=' '*(n-b);b>1&&(puts(s+d[o,b].join(' '));o+=b);puts s+'^ '*b}}

Tak się nazywa

t.call(5,4)

Wydajność:

    ^
   1 2
   ^ ^
  3 4 1
  ^ ^ ^
 2 3 4 1
 ^ ^ ^ ^
2 3 4 1 2
^ ^ ^ ^ ^

C, 170 bajtów

i=0;d,j,l;t(n,k){char s[20],r[20];d=k-2;l=n;for(;i++<n;){for(j=0;j<l;++j)s[j]=r[j]=32;for(j=n-i;j<l;j+=2){s[j]=94;r[j]=(++d%k)+49;}s[l]=r[l++]=0;if(i-1)puts(r);puts(s);}}

Zadzwoń z:

int main()
{
   t(5,4);
}

Jako bonus, oto 4-bitowa wersja binarna:

m=0;b(n,k){char*a="000100100011010001010110011110001001";char s[20],r[20];d=k*4-2;l=n;for(;m++<n;){for(j=0;j<l;++j)s[j]=r[j]=32;for(j=n-m;j<l;j+=2){s[j]=94;r[j]=a[++d%(k*4)];}s[l]=r[l++]=0;if(m-1)puts(r);puts(s);}}