Introducción

Ayer vi un rompecabezas de cumpleaños . Felicidades !!

También esta semana vi un episodio del programa de televisión Bones donde se encontró un cadáver enterrado debajo de un árbol. Para calcular el momento de la muerte, contaron los anillos de los árboles.

Los anillos de los árboles se forman porque los árboles crecen más lentamente durante el invierno y más rápido durante el verano. Por lo tanto, puede calcular la edad del árbol contando los anillos. También puedes ver eventos naturales como estaciones lluviosas o secas.

Reto

Dado un número entero n >= 1como entrada, escriba un programa completo para generar los anillos de edad del árbol.

Debido a que los anillos pueden cambiar de forma, use tres caracteres diferentes ('0', '*', '+') para mostrar los ciclos climáticos.

Edad 1

0

Edad 2

***
*0*
***

3 años

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

4 años

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

El tamaño del árbol es un cuadrado de lados. 2*n - 1

Victorioso

El código más corto en bytes gana.

K5, 27 30 26 25 22 bytes

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

Este enfoque iterativamente "envuelve" un núcleo (comenzando con "0") en los cuatro lados usando algún otro carácter ( {4(|+y,)/x}). La secuencia de envolturas estacionales está determinada por una 3!secuencia de módulo 3 ( ). Es un poco complicado lograr que el caso base se alinee a la perfección.

editar:

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

Esta alternativa construye toda la matriz rectangular a la vez a partir del rango exclusivo provisto ( !) invertido y unido consigo mismo después de soltar un elemento ( t,1_|t:|). Luego tomamos el producto cartesiano máximo ( u|\:u:), tomamos toda la matriz módulo 3 ( 3!) e indexamos en la matriz de caracteres.

En acción:

  "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.

Las palabras clave abreviadas ayudan mucho aquí. En la línea 2, estoy usando el VDUcomando (equivalente a C putchar()) para imprimir cada carácter. Esto es mucho más eficiente que P.MID$("0*+",p MOD3+1,1).

Aquí se está ejecutando en BeebEm3 en una Mac:

CJam, 25 bytes

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

Pruébalo aquí.

Explicación

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)

Ejemplo:

>> 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:]

Imprime línea por línea. Cada línea se corta en tres partes:

• La parte de ciclismo izquierda, incluido el primer char repetido.
• La parte central que se repite
• La parte de ciclismo correcta.

Para n=4:

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

Generamos la parte izquierda en reversa como w, clonamos sus últimos 2*itiempos de carácter , luego agregamos la versión original sin el primer carácter.

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)

Si pensamos en el árbol como una cuadrícula de coordenadas, el símbolo en (i,j)está determinado por max(abs(i),abs(j))%3, o de manera equivalente max(i,-i,j,-j)%3. Para cada fila i, unimos e imprimimos los símbolos en esa fila.

Pyth, 23 bytes

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

Pruébelo en línea: demostración

Explicación:

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

¡Gracias Luis Mendo por ayudarme a afeitarme 5 bytes!

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

Ejemplo

>> 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*
*********

Sin Golf y Explicación del Código

%// 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)

Nota menor

bwdistes una función que forma parte de la caja de herramientas de procesamiento de imágenes y solo se puede ejecutar en MATLAB. Octave (IIRC) aún no se ha bwdistimplementado, por lo que no se puede ejecutar en Octave.

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

Más por hacer, pero una versión básica por ahora. Ahora con una deliciosa adherencia a las especificaciones adicionales.

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

Uso:

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, 277252 caracteres

(Código de 251 caracteres + opción de línea de comando de 1 carácter).

Espera entrada en formato unario .

: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//

Ejecución de muestra:

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

Uso de alerta para salida: fuente proporcional incorrecta y el resultado es feo. En el fragmento debajo de la alerta se redirige al cuerpo cortado, dando un mejor resultado. La nueva línea dentro de los backticks es significativa y contada.

Prueba a ejecutar el fragmento en 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 caracteres

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

Ejecución de muestra:

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

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

Función t toma un parámetro entero: la edad.

Sin golf (con mainfunción para ejecutar fácilmente el anterior):

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

El stdlib.hpuede ser necesario en algunos sistemas, ya que sin ella el tipo de retorno de la función no declarada callocdejaría de pagar a int. Debido a que inty char*no son necesariamente del mismo tamaño, se podría escribir un puntero no válido c. En la mayoría de sistemas de 32 bits tanto char*y inttienen el mismo tamaño, pero esto no es cierto para sistemas de 64 bits.