pengantar

Kemarin saya melihat puzzle ulang tahun . Selamat !!

Juga minggu ini saya menonton sebuah episode acara TV Bones di mana mayat ditemukan terkubur di bawah pohon. Untuk menghitung waktu kematian, mereka menghitung cincin pohon.

Lingkaran pohon terbentuk karena pohon tumbuh lebih lambat selama musim dingin dan lebih cepat selama musim panas. Dengan demikian Anda dapat menghitung usia pohon dengan menghitung cincin. Anda juga dapat melihat peristiwa alam seperti musim hujan atau kemarau.

Tantangan

Diberikan bilangan bulat n >= 1sebagai input, tulis program lengkap untuk menampilkan cincin usia pohon.

Karena cincin dapat berubah bentuk menggunakan tiga karakter yang berbeda ('0', '*', '+') untuk menunjukkan siklus iklim.

Usia 1

0

Usia 2

***
*0*
***

Umur 3 tahun

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

Usia 4

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

Ukuran pohon adalah kuadrat sisi 2*n - 1

Kemenangan

Kode terpendek dalam byte menang.

K5, 27 30 26 25 22 byte

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

Pendekatan ini secara iteratif "membungkus" inti (dimulai dengan "0") di keempat sisi menggunakan beberapa karakter lain ( {4(|+y,)/x}). Urutan pembungkus musiman ditentukan oleh 3!urutan modulo 3 ( ). Agak sulit untuk membuat alasnya berbaris tepat.

edit:

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

Alternatif ini membangun seluruh array persegi panjang sekaligus dari rentang eksklusif yang disediakan ( !) terbalik dan bergabung dengan dirinya sendiri setelah menjatuhkan item ( t,1_|t:|). Kami kemudian mengambil maksimum produk kartesius ( u|\:u:), mengambil seluruh modulo matriks 3 ( 3!) dan indeks ke dalam array karakter.

Beraksi:

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

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.

Kata kunci yang disingkat sangat membantu di sini. Pada baris 2, saya menggunakan VDUperintah (setara dengan C putchar()) untuk mencetak setiap karakter. Ini jauh lebih efisien daripada P.MID$("0*+",p MOD3+1,1).

Ini sedang berjalan di BeebEm3 pada Mac:

CJam, 25 byte

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

Uji di sini.

Penjelasan

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 byte

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

Contoh:

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

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

Mencetak baris demi baris. Setiap baris dipotong menjadi tiga bagian:

• Bagian bersepeda kiri, termasuk arang berulang yang pertama.
• Bagian tengah berulang
• Bagian bersepeda yang tepat.

Untuk n=4:

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

Kami menghasilkan bagian kiri secara terbalik sebagai w, mengkloning 2*iwaktu karakter terakhirnya , lalu menambahkan versi asli tanpa karakter pertama.

Python 2, 83 byte

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

Jika kita menganggap pohon sebagai kisi koordinat, simbol di (i,j)ditentukan oleh max(abs(i),abs(j))%3, atau setara max(i,-i,j,-j)%3. Untuk setiap baris i, kami bergabung dan mencetak simbol di baris itu.

Pyth, 23 byte

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

Cobalah online: Demonstrasi

Penjelasan:

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 byte

Terima kasih Luis Mendo karena membantu saya mencukur 5 byte!

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

Contoh

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

Penjelasan Tidak Disatukan dan Kode

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

Catatan Kecil

bwdistadalah fungsi yang merupakan bagian dari kotak alat pemrosesan gambar, dan hanya dapat dijalankan di MATLAB. Oktaf (IIRC) belum bwdistdiimplementasikan sehingga ini tidak dapat dijalankan dalam Oktaf.

Python 2, 134 byte

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 byte

Lebih banyak yang harus dilakukan, tetapi versi dasar untuk saat ini. Sekarang dengan kepatuhan spesifikasi ekstra yang lezat.

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

Pemakaian:

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 karakter

(251 kode karakter + 1 opsi baris perintah karakter.)

Diharapkan input dalam format unary .

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

Contoh dijalankan:

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

Menggunakan lansiran untuk keluaran - font proporsional buruk dan hasilnya jelek. Dalam cuplikan di bawah ini lansiran dialihkan ke badan yang terpotong, memberikan hasil yang lebih baik. Baris baru di dalam backticks signifikan dan diperhitungkan.

Tes menjalankan cuplikan di 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 karakter

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

Contoh dijalankan:

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 byte

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 byte

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

Fungsi tmengambil satu parameter integer - usia.

Tidak disatukan (dengan mainfungsi untuk dengan mudah menjalankan yang di atas):

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

The stdlib.hmungkin diperlukan pada beberapa sistem, karena tanpa itu jenis kembalinya fungsi dideklarasikan callocakan default ke int. Karena intdan char*tidak harus memiliki ukuran yang sama, pointer yang tidak valid dapat ditulis c. Dalam kebanyakan sistem 32-bit keduanya char*dan intmemiliki ukuran yang sama, tetapi ini tidak berlaku untuk sistem 64-bit.