Viết chương trình hoặc hàm lấy số nguyên dương N và in hoặc trả về chuỗi nghệ thuật NII N ASCII có nửa trên là hình bán nguyệt được làm bằng (và nửa dưới của nó là một hình tam giác hướng xuống được làm bằng V, với không gian được sử dụng như đệm.

Nói cách khác, tạo một hình nón kem ASCII: (đầu ra cho N = 17)

      (((((      
    (((((((((    
  (((((((((((((  
  (((((((((((((  
 ((((((((((((((( 
 ((((((((((((((( 
(((((((((((((((((
(((((((((((((((((
VVVVVVVVVVVVVVVVV
 VVVVVVVVVVVVVVV 
  VVVVVVVVVVVVV  
   VVVVVVVVVVV   
    VVVVVVVVV    
     VVVVVVV     
      VVVVV      
       VVV       
        V        

Ví dụ

Dưới đây là các đầu ra cho N = 1 đến 5. Lưu ý rằng đối với N lẻ, tam giác luôn phải là nửa lớn hơn.

V

((
VV

(((
VVV
 V 

 (( 
((((
VVVV
 VV 

 ((( 
(((((
VVVVV
 VVV 
  V  

Đây là một N = 101 pastebin.

Và đây là một triển khai tham chiếu Python 3 vô căn cứ:

N = int(input())
ic = [[' '] * N for _ in range(N)]
for y in range(N//2):
    for x in range(N):
        if (x - (N - 1) / 2)**2 + (y - (N - 1) / 2)**2 < (N / 2)**2:
            ic[y][x] = '('
for y in range(N//2, N):
    for x in range(y - N//2, N - (y - N//2)):
        ic[y][x] = 'V'
for line in ic:
    print(''.join(line))

Chi tiết

• Lấy đầu vào từ stdin, dòng lệnh hoặc làm đối số hàm. Xuất ra thiết bị xuất chuẩn hoặc tương tự, hoặc bạn có thể trả về chuỗi nếu bạn viết hàm.
• Phần hình nón phải khớp chính xác với việc thực hiện tham chiếu cho tất cả N.
• Phần kem không cần phải khớp chính xác với việc triển khai tham chiếu miễn là nó rõ ràng có hình bán nguyệt cho tất cả N. (Điều này là do đó bạn không phải lo lắng về sự khác biệt nhỏ trong hình bán nguyệt do lỗi vòng tròn .)
• Không nên có bất kỳ không gian hàng đầu không cần thiết nào nhưng có thể có những khoảng trống không cần thiết.
• Đầu ra có thể tùy ý chứa một dòng mới.
• Bạn có thể tùy chọn sử dụng bất kỳ 3 biệt khác ASCII in ký tự thay (, Vvà không gian.

Chấm điểm

Đệ trình ngắn nhất tính bằng byte thắng. Tiebreaker đi đến trình cũ nhất.

CJam, 46 byte

Hãy thử trực tuyến.

{:Z{Z{Z(2./:R-zYR<):P#YR-zP#+Z2./P#>SP?}/N}fY}

Tôi tin rằng điều này hiện đang bắt chước chính xác đặc điểm kỹ thuật ban đầu, được yêu cầu khi tôi bắt đầu tạo ra câu trả lời này. Có thể có khả năng lưu một vài byte bằng cách làm cho phép toán kém chính xác hơn so với thông số ban đầu, nhưng cho đến khi tôi thấy một cách để lưu nhiều hơn một hoặc hai byte, tôi sẽ để nguyên như vậy.

Giải trình

{               "Begin block";
  :Z{             "For each y from 0 to input-1";
    Z{              "For each x from 0 to input-1";
      Z(2./:R         "Calculate the radius as (input-1)/2.0";
      -z              "Calculate the horizontal distance from the center";
      YR<):P          "Calculate the power to raise distances to: (y<radius)+1
                       (This results in Euclidean distance being calculated for
                        the ice cream and Manhattan distance being calculated
                        for the cone)";
      #               "Raise the horizontal distance to the determined power";
      YR-zP#          "Calculate the vertical distance from the center and
                       raise it to the determined power";
      +               "Add the horizontal and vertical distances";
      Z2./P#          "Calculate the solid distance threshold and raise it to
                       the determined power";
      >SP?            "If the solid threshold is exceeded, produce a space;
                       otherwise, produce the determined power digit
                       (This results in ice cream being represented by the
                        digit '2' and the cone by the digit '1')";
    }/              "End x loop";
    N               "Produce a new line";
  }fY             "End y loop";
}               "End block";

inca2 129 123 121 111 107

Điều này chủ yếu sử dụng các công thức từ ví dụ python, nhưng sử dụng jot-dot và iotas thay vì lặp đôi. Các ichức năng thực hiện việc kiểm tra hình tròn cho jchức năng mà gọi jot-rải rác trên nó. Và khàm thực hiện kiểm tra tam giác cho lhàm. Các cchức năng catenates kết quả jvà lvà reshapes nó đến N × N.

chỉnh sửa: -6 kết hợp 2 bản đồ thành 1.
chỉnh sửa: -2 loại bỏ các ravels vô dụng.
chỉnh sửa: bản thảo đẹp hơn.
chỉnh sửa: -10 áp dụng lặp lại biểu thức mảng khôn ngoan.
chỉnh sửa: -4 yếu tố ra biểu thức lặp lại như là một hàm.
chỉnh sửa: bình luận từng dòng.

q:y-(n-1)%2
i:[((n%2)^2)>+/(qx y)^2
j:(~[y%2)i.(~y)
k:2*[x>[|qy
l:(@1+~]y%2)k.(~y)
c:y y#((jn<y),ly){' (V' 

Chi tiết hơn, điểm vào là chàm lấy một đối số được đặt tên ngầm y.

c:y y#((jn<y),ly){' (V' 
         n<y            } assign y to 'n'
        jn<y            } call j(y)
              ly        } call l(y)
      ((    ),  )       } catenate the results
      (         ){' (V' } map 0 1 2 to ' ' '(' 'V'
  y y#                  } reshape to NxN

Các jchức năng nhận giá trị đầu vào tương tự như của ytham số.

j:(~[y%2)i.(~y)
     y%2         } y divided by 2
    [            } floor
   ~             } iota. this generates the row indices 0..y/2
            ~y   } iota y. this generates the column indices 0..y
  (     )i.(  )  } jot-dot with the function i

Dấu chấm ở đây thực hiện vòng lặp kép. Nó gọi ihàm với mọi sự kết hợp của các phần tử từ mảng bên trái và bên phải (0..n / 2 và 0..n). Vì vậy, các ichức năng nhận như xcác y chỉ số của bảng, và nó nhận được như ycác x index. Các tên có một chút ngược ở đây :).

i:[((n%2)^2)>+/(qx y)^2
     n%2                 } n divided by 2
    (n%2)^2              } squared
                 x y     } make a 2-element array (x,y)
                qx y     } call q on this array

nơi qnào

q:y-(n-1)%2
     n-1    } n minus 1
         %2 } divided by 2
  y-        } y minus that

Quay lại i

i:[((n%2)^2)>+/(qx y)^2
               (    )^2  } square the result from q(x,y)
             +/          } sum the two numbers
            >            } compare the left side (above) with the right (=> 0/1)
  [                      } floor

Sàn không cần thiết. Nhưng rõ ràng có một lỗi trong trình thông dịch.

Các lchức năng hoạt động tương tự với jchức năng, sử dụng một jot-dot.

l:(@1+~]y%2)k.(~y)
        y%2         } y divided by 2
       ]            } ceiling
      ~             } iota 0..ceil(y/2)-1
    1+              } add 1 => 1..ceil(y/2)
   @                } reverse => ceil(y/2)..1
               ~y   } iota y  0..y-1
  (        )k.(  )  } jot-dot using k

Các kchức năng mang lại một boolean nhân theo tỷ lệ 2 để các giá trị có thể được phân biệt với các giá trị kem sau này, trong bản đồ.

k:2*[x>[|qy
     x       } k's left arg
         qy  } y-(n-1)%2
        |    } abs
       [     } floor
     x       } left-hand-side again
      >      } compare 
    [        } floor (should be unnecessary)
  2*         } scale by 2

Trong hành động (chuyển qua trđể xóa các ký tự tab là dấu nhắc của REPL):

josh@Z1 ~/inca
$ ./inca2 <icecream | tr -d '\t'

c1
V

c2
((
VV

c3
(((
VVV
 V 

c4
 (( 
((((
VVVV
 VV 

c5
 ((( 
(((((
VVVVV
 VVV 
  V  

josh@Z1 ~/inca
$ 

Con trăn 2, 193 192

Không sử dụng chuỗi, chỉ toán

N=input()
R=(N+1)/2;r=range(R)
s=lambda L,U:(10**U-10**L)/9
f=lambda N,m:s(0,N)+s(m,N-m)
g=lambda N,m:s(0,N)+s(m,N-m)*6
for i in r[1:]:print f(N,int(R-(2*R*i-i*i)**.5))
for i in r:print g(N,i)

s(L,U)trả về một số dạng " Usố có các Lsố 0 bên phải và các số còn lại"
f(N,m)trả về một số có chữ số N với phần bên trong 2và đường viền rộng m 1ở mỗi bên
g(N,m)cũng như vậy, nhưng sử dụng 7cho 'màu' của phần bên trong vì nó phù hợp với kết cấu của hình nón chặt chẽ hơn

Đầu ra

N=8         N=9
11122111    112222211
12222221    122222221
22222222    222222222
22222222    222222222
77777777    777777777
17777771    177777771
11777711    117777711
11177111    111777111
            111171111

Perl 6, 175

Thực hiện khá đơn giản mà không cần chơi gôn nhiều, chỉ cần loại bỏ khoảng trắng / dấu chấm câu bên ngoài:

sub MAIN($d){my$r=($d/2).Int;for 1..$r ->$n
{my$y=$n-$r;my$h=sqrt($r*$r-$y*$y).Int;my$w=2*$h+$d%2;say
' 'x($r-$h)~'('x$w};for 1..($d-$r) ->$y {say ' 'x($y-1)~'V'x($d-2*$y+2)}}