Einführung

Gestern habe ich ein Geburtstagsrätsel gesehen . Glückwunsch!!

Auch diese Woche habe ich eine Folge der Fernsehsendung Bones gesehen, in der eine Leiche unter einem Baum begraben gefunden wurde. Um den Zeitpunkt des Todes zu berechnen, zählten sie die Baumringe.

Baumringe entstehen, weil Bäume im Winter langsamer und im Sommer schneller wachsen. So können Sie das Alter des Baumes durch Zählen der Ringe berechnen. Sie können auch natürliche Ereignisse wie Regen- oder Trockenzeiten beobachten.

Herausforderung

n >= 1Schreiben Sie mit einer Ganzzahl als Eingabe ein vollständiges Programm, um die Altersringe des Baums auszugeben.

Da sich die Form von Ringen ändern kann, verwenden Sie drei verschiedene Zeichen ('0', '*', '+'), um die Klimazyklen anzuzeigen.

Alter 1

0

Alter 2

***
*0*
***

Alter 3

+++++
+***+
+*0*+
+***+
+++++

Alter 4

0000000
0+++++0
0+***+0
0+*0*+0
0+***+0
0+++++0
0000000

Die Größe des Baumes ist ein Quadrat von Seiten 2*n - 1

Gewinnen

Kürzester Code in Bytes gewinnt.

K5, 27 30 26 25 22 Bytes

"0"{4(|+y,)/x}/"0*+"3!1_!

Dieser Ansatz "umschließt" iterativ einen Kern (beginnend mit "0") auf allen vier Seiten mit einem anderen Zeichen ( {4(|+y,)/x}). Die Reihenfolge der saisonalen Umhüllungen wird durch eine Modulo-3 ( 3!) -Sequenz bestimmt. Es ist etwas umständlich, den Basisfall genau richtig auszurichten.

bearbeiten:

"0*+"3!u|\:u:t,1_|t:|!

Diese Alternative erstellt das gesamte rechteckige Array auf einmal aus dem angegebenen exklusiven Bereich ( !), der umgekehrt und nach dem Ablegen eines Elements ( t,1_|t:|) mit sich selbst verbunden wird . Wir nehmen dann das kartesische Produktmaximum ( u|\:u:), nehmen die gesamte Matrix Modulo 3 ( 3!) und indexieren das Array von Zeichen.

In Aktion:

  "0*+"3!u|\:u:t,1_|t:|!1
,,"0"

  "0*+"3!u|\:u:t,1_|t:|!3
("+++++"
 "+***+"
 "+*0*+"
 "+***+"
 "+++++")

  "0*+"3!u|\:u:t,1_|t:|!5
("*********"
 "*0000000*"
 "*0+++++0*"
 "*0+***+0*"
 "*0+*0*+0*"
 "*0+***+0*"
 "*0+++++0*"
 "*0000000*"
 "*********")

BBC Basic, 93 Bytes

1I.r:r=r-1:F.i=-r TOr:F.j=-r TOr:p=ABS(i):q=ABS(j):IFp<q TH.p=q
2V.48-(p MOD3)*6MOD7:N.:P.:N.

Die abgekürzten Stichwörter helfen hier sehr. In Zeile 2 verwende ich den VDUBefehl (entspricht C putchar()), um jedes Zeichen zu drucken. Das ist viel effizienter als P.MID$("0*+",p MOD3+1,1).

Hier läuft es in BeebEm3 auf einem Mac:

CJam, 25 Bytes

q~,_1>W%\+_ff{e>"0*+"=}N*

Teste es hier.

Erläuterung

q~,       e# Read input N, turn into range [0 1 ... N-1]
_1>       e# Duplicate and cut off the zero.
W%        e# Reverse.
\+        e# Prepend to original range to give [N-1 ... 1 0 1 ... N-1]
_         e# Duplicate
ff{       e# Nested map for each pair of elements in that array.
  e>      e# Take the maximum, i.e. chessboard distance from the centre.
  "0*+"=  e# Select the right character using cyclic indexing into this string.
}
N*        e# Join the lines with line feeds.

Matlab, 63 Bytes

n=input('')-1;x='0*+';t=abs(-n:n);x(mod(bsxfun(@max,t,t'),3)+1)

Beispiel:

>> n=input('')-1;x='0*+';t=abs(-n:n);x(mod(bsxfun(@max,t,t'),3)+1)
5
ans =
*********
*0000000*
*0+++++0*
*0+***+0*
*0+*0*+0*
*0+***+0*
*0+++++0*
*0000000*
*********

Python 2, 83 Bytes

I=n=input()
while I+n-1:I-=1;i=abs(I);w=("O*+"*n)[i:n];print w[::-1]+w[0]*2*i+w[1:]

Druckt zeilenweise. Jede Zeile ist in drei Teile geteilt:

• Der linke Teil des Fahrrads, einschließlich des ersten wiederholten Zeichens.
• Der sich wiederholende Mittelteil
• Der richtige Radteil.

Für n=4:

0    000000    
0+    ++++    0
0+*    **    +0
0+*0        *+0
0+*    **    +0
0+    ++++    0
0    000000    

Wir generieren den linken Teil in umgekehrter Reihenfolge, indem wir die wletzten Zeichen klonen 2*iund dann die Originalversion ohne das erste Zeichen hinzufügen.

Python 2, 83 Bytes

n=input()
R=range(1-n,n)
for i in R:print''.join('0*+'[max(i,-i,j,-j)%3]for j in R)

Wenn wir uns den Baum als Koordinatengitter vorstellen, wird das Symbol at (i,j)durch max(abs(i),abs(j))%3oder gleichwertig bestimmt max(i,-i,j,-j)%3. Für jede Zeile verbinden iwir die Symbole in dieser Zeile und drucken sie aus.

Pyth, 23 Bytes

VK+_StQUQsm@"0*+"eS,dNK

Probieren Sie es online aus: Demonstration

Erläuterung:

VK+_StQUQsm@"0*+"eS,dNK   implicit: Q = input number
    StQ                   the list [1, 2, ..., Q-1]
   _                      reverse it [Q-1, ..., 2, 1]
       UQ                 the list [0, 1, ..., Q-1]
  +                       combine them [Q-1, ..., 1, 0, 1, ..., Q-1]
 K                        and store in K
VK                        for each N in K:
          m           K      map each element d in K to:
                 eS,dN          the maximum of d and N
           @"0*+"               and pick the corresponded char (modulo 3)
         s                   join the chars to a string and print

MATLAB, 80 78 73 Bytes

Danke Luis Mendo, dass du mir geholfen hast, 5 Bytes zu rasieren!

A=eye(2*input('')-1);a='0*+';a(mod(bwdist(A.*rot90(A),'chessboard'),3)+1)

Beispiel

>> A=eye(2*input('')-1);a='0*+';a(mod(bwdist(A.*rot90(A),'chessboard'),3)+1)

5

ans =

*********
*0000000*
*0+++++0*
*0+***+0*
*0+*0*+0*
*0+***+0*
*0+++++0*
*0000000*
*********

Ungolfed und Code Erklärung

%// Accepts an integer n from the user and creates a 2*n - 1 x 2*n - 1 identity matrix
A=eye(2*input('')-1);

%// Creates an array of three characters to print each level of the ring
a='0*+';

%// By taking the identity matrix and element-wise multiplying with its 90 degree rotated 
%// version of itself, this creates a zero matrix except for the centre most
%// value, which is 1
%// This takes the distance transform via the chessboard / Chebyshev distance
%// from the centre element
%// This mirrors what "level" each square would be at
%// 1: https://en.wikipedia.org/wiki/Distance_transform
%// 2: https://en.wikipedia.org/wiki/Chebyshev_distance
b = bwdist(A.*rot90(A),'chessboard');

%// Because each level cycles through each of the characters in the
%// character array a, we need to perform a mod operation so that
%// all of the values cycle from 1 to 3
%// This changes the distance transform output so that we range
%// from 1 to 3 instead
c = mod(b,3) + 1;

%// The values in the matrix c correspond exactly to the locations
%// we need to sample from the array a and we display our result
a(c)

Kleinere Anmerkung

bwdistist eine Funktion, die Teil der Bildverarbeitungs-Toolbox ist und nur in MATLAB ausgeführt werden kann. Octave (IIRC) ist noch nicht bwdistimplementiert, daher kann dies nicht in Octave ausgeführt werden.

Python 2, 134 Bytes

def l(x,c=1):
 p="\n\x1b[%d"%c;d=p+";%dH"%c
 if x:s=x*2-1;d+=(p+"G").join(["0*+"[(x+1)%3]*s]*s)+l(x-1,c+1)
 return d
print l(input())

Perl, 118 Bytes

Mehr zu tun, aber vorerst eine Basisversion. Jetzt mit leckerer Extra-Spezifikation.

for$i(0..($-=<>-1)){substr$a[$_],$i,$}=2*($--$i)+1,(0,'*','+')[($--$i)%3]x$}for$i..$-}$,=$/;print@a,reverse@a[0..$--1]

Verwendung:

perl -e 'for$i(0..($-=<>-1)){substr$a[$_],$i,$}=2*($--$i)+1,(0,'*','+')[($--$i)%3]x$}for$i..$-}$,=$/;print@a,reverse@a[0..$--1]' <<< 9

+++++++++++++++++
+***************+
+*0000000000000*+
+*0+++++++++++0*+
+*0+*********+0*+
+*0+*0000000*+0*+
+*0+*0+++++0*+0*+
+*0+*0+***+0*+0*+
+*0+*0+*0*+0*+0*+
+*0+*0+***+0*+0*+
+*0+*0+++++0*+0*+
+*0+*0000000*+0*+
+*0+*********+0*+
+*0+++++++++++0*+
+*0000000000000*+
+***************+
+++++++++++++++++

Matlab 92

input('')-1;x=ones(2*n+1,1)*abs(-n:n);z=mod(max(x,x'),3);z(z>1)=2;z(z<1)=7;disp([z+41,''])

Sed, 277 252 Zeichen

(251 Zeichen Code + 1 Zeichen Befehlszeilenoption.)

Erwartet Eingaben im unären Format.

:m
s/1/0/
s/1/*/
s/1/+/
tm
h
s/^/:/
:r
s/(.*):(.)/\2\1:/
tr
s/://
G
s/\n.//
h
:
/^(.)\1*$/ba
s/(.)(.)(\2*)\1/\1:\2\3:\1/
:c
s/(:_*)[^_](.*:)/\1_\2/
tc
:u
s/(.)(:\1*)_/\1\2\1/
tu
s/://g
H
b
:a
g
s/[^\n]+/:/
:f
s/(.*):(\n[^\n]+)/\2\1:/
tf
s/://
G
s/\n//

Probelauf:

bash-4.3$ sed -rf treering.sed <<< 1
0

bash-4.3$ sed -rf treering.sed <<< 11
***
*0*
***

bash-4.3$ sed -rf treering.sed <<< 111
+++++
+***+
+*0*+
+***+
+++++

bash-4.3$ sed -rf treering.sed <<< 1111
0000000
0+++++0
0+***+0
0+*0*+0
0+***+0
0+++++0
0000000

JavaScript (ES6), 114

Verwenden der Warnung für die Ausgabe - schlechte proportionale Schriftart und das Ergebnis ist hässlich. Im folgenden Snippet wird die Warnung an den ausgeschnittenen Körper weitergeleitet, um ein besseres Ergebnis zu erzielen. Der Zeilenvorschub innerhalb der Backticks ist signifikant und wird gezählt.

Testen Sie das Snippet in Firefox.

/* Redefine alert for testing purpose */ alert=x=>O.innerHTML=x;

[...'*+0'.repeat(n=prompt()-1)].map((c,i)=>i<n?b=[z=c.repeat(i-~i),...b,z].map(r=>c+r+c):0,b=[0]);alert(b.join`
`)

<pre id=O></pre>

Ruby, 85 Zeichen

puts (m=0..(n=gets.to_i-1)*2).map{|i|m.map{|j|"0*+"[[(i-n).abs,(j-n).abs].max%3]}*""}

Probelauf:

bash-4.3$ ruby -e 'puts (m=0..(n=gets.to_i-1)*2).map{|i|m.map{|j|"0*+"[[(i-n).abs,(j-n).abs].max%3]}*""}' <<< 4
0000000
0+++++0
0+***+0
0+*0*+0
0+***+0
0+++++0
0000000

Mondschrift - 104 Bytes

m=io.read!
n=2*m-1
for y=1,n
 io.write ({'0','*','+'})[(math.max y-m,x-m,m-y,m-x)%3+1]for x=1,n
 print!

C 138 Bytes

j,k,l;t(i){l=2*i;char*c=calloc(l,l);memset(c,10,l*(l-2));for(;k<i;++k)for(j=k;j<l-1-k;)memset(c+j++*l+k,"+0*"[(i-k)%3],l-2*k-1);puts(c);}

Funktion tmit einem ganzzahligen Parameter - dem Alter.

Ungolfed (mit der mainFunktion, die oben genannten einfach auszuführen):

#include "stdlib.h" /* calloc - only necessary for 64-bit system */
j,k,l;t(i)
{
    l=2*i;
    char*c=calloc(l,l);
    memset(c,10,l*(l-2)); /* fill with '\n' */
    for(;k<i;++k)for(j=k;j<l-1-k;)memset(c+j++*l+k,"+0*"[(i-k)%3],l-2*k-1);
    puts(c);
}

main(int c,char**v)
{
    t(atoi(v[1]));
}

Das stdlib.hkann auf manchen Systemen notwendig sein, da ohne es der Rückgabetyp der nicht deklarierten Funktion callocstandardmäßig auf würde int. Da intund müssen char*nicht unbedingt gleich groß sein, könnte ein ungültiger Zeiger eingeschrieben werden c. In den meisten 32-Bit - Systemen beide char*und inthaben die gleiche Größe, aber das ist nicht wahr für 64-Bit - Systeme.