Thử thách

Đưa ra pha của mặt trăng, vẽ nó bằng nghệ thuật ASCII.

Chương trình của bạn phải xử lý mặt trăng mới, lưỡi liềm sáp, quý đầu tiên, vượn sáp, trăng tròn, vượn suy yếu, quý cuối cùng và lưỡi liềm waning. Đầu vào của bạn sẽ là một số nguyên.

0 -> new moon
1 -> waxing crescent
2 -> first quarter
3 -> waxing gibbous
4 -> full moon
5 -> waning gibbous
6 -> last quarter
7 -> waning crescent

Tất cả nghệ thuật ASCII được đặt trên lưới 16x8 (vì tỷ lệ kích thước ký tự). Bạn có thể thay thế .bằng bất kỳ ký tự nào và #bằng bất kỳ ký tự không phải khoảng trắng nào khác.

Đầu ra cho mặt trăng mới phải là:

................
................
................
................
................
................
................
................

Đối với lưỡi liềm sáp:

..........######
............####
.............###
.............###
.............###
.............###
............####
..........######

Trong quý đầu tiên:

........########
........########
........########
........########
........########
........########
........########
........########

Đối với vượn sáp:

......##########
....############
...#############
...#############
...#############
...#############
....############
......##########

Và cho trăng tròn:

################
################
################
################
################
################
################
################

Lưỡi liềm waning chỉ là lưỡi liềm sáp với mỗi dòng đảo ngược, như với vượn waning và vượn sáp, và quý đầu tiên và cuối cùng.

Quy tắc

• Áp dụng sơ hở tiêu chuẩn
• Bạn có thể chọn đầu ra sáp / suy yếu theo hướng ngược lại nếu bạn muốn, mặc dù điều đó sẽ không có gì khác biệt (đồ họa hiển thị trong câu hỏi này là dành cho bán cầu bắc)
• Đầu ra của bạn phải chính xác như được chỉ định. Dòng mới của bạn có thể là bất kỳ dấu phân cách dòng hợp lý nào và bạn có thể có một dòng mới theo dõi nếu bạn muốn.

Thạch ,  43 32 byte

-7 byte chuyển từ mặt nạ bit sang mặt nạ so sánh
-2 byte với một số cải tiến lập trình ngầm
-1 byte di chuyển đến bán cầu nam
-1 byte - sử dụng trình ɓphân tách chuỗi hoàn toàn mới ... lần đầu tiên sử dụng!

“>,##‘m0Dm€0ż@€4Ḷ¤Œṙɓ%4>C¹⁸:4¤?Y

Sử dụng các ký tự 0cho .và 1cho #.

Tất cả các trường hợp trong một bộ thử nghiệm tại Dùng thử trực tuyến!

Làm sao?

Xây dựng mặt nạ bắt bốn pha đầu tiên và thay vì đảo ngược các dòng bổ sung cho các giá trị kết quả của kết quả pha modulo-4 khi pha div-4 khác không.

Tôi ban đầu được xây dựng một mặt nạ bit, nhưng các giá trị mặt nạ là 0, 8, 12, và 14- 0000, 1000, 1100, và 1110- đây có phasenhững người lãnh đạo - do đó, một so sánh mặt nạ có thể được sử dụng để thay thế.

“>,##‘m0Dm€0ż@€4Ḷ¤Œṙɓ%4>C¹⁸:4¤?Y - Main link 1: number phase
“>,##‘                           - code-page index literal [62,44,35,35]
      m0                         - reflect -> [62,44,35,35,35,35,44,62]
        D                        - decimalise -> [[6,2],[4,4],[3,5],[3,5],[3,5],[3,5],[4,4],[6,2]]
         m€0                     - reflect €ach -> [[6,2,2,6],[4,4,4,4],[3,5,5,3],[3,5,5,3],[3,5,5,3],[3,5,5,3],[4,4,4,4],[6,2,2,6]]
                 ¤               - nilad and link(s) as a nilad:
               4                 -   literal 4
                Ḷ                -   lowered range -> [0,1,2,3]
            ż@€                  - zip (reverse @rguments) for €ach -> [[[0,6],[1,2],[2,2],[3,6]],[[0,4],[1,4],[2,4],[3,4]],[[0,3],[1,5],[2,5],[3,3]],[[0,3],[1,5],[2,5],[3,3]],[[0,3],[1,5],[2,5],[3,3]],[[0,3],[1,5],[2,5],[3,3]],[[0,4],[1,4],[2,4],[3,4]],[[0,6],[1,2],[2,2],[3,6]]]
                  Œṙ             - run-length decode -> [[0,0,0,0,0,0,1,1,2,2,3,3,3,3,3,3],[0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3],[0,0,0,1,1,1,1,1,2,2,2,2,2,3,3,3],[0,0,0,1,1,1,1,1,2,2,2,2,2,3,3,3],[0,0,0,1,1,1,1,1,2,2,2,2,2,3,3,3],[0,0,0,1,1,1,1,1,2,2,2,2,2,3,3,3],[0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3],[0,0,0,0,0,0,1,1,2,2,3,3,3,3,3,3]]
                                    -   i.e.: 0000001122333333  -
                                              0000111122223333  - Marking out the separate
                                              0001111122222333  - regions as filled up by
                                              0001111122222333  - the phases of the moon in
                                              0001111122222333  - the southern hemisphere.
                                              0001111122222333  -
                                              0000111122223333  -
                                              0000001122333333  -
                    ɓ            - dyadic chain separation & swap arguments, call that m
                     %4          - phase mod 4
                       >         - greater than? (vectorises across m) 1 if so 0 if not
                              ?  - if:
                             ¤   -   nilad followed by link(s) as a nilad:
                          ⁸      -     link's left argument, phase
                           :4    -     integer divide by 4
                        C        - then: complement
                         ¹       - else: identity (do nothing)
                               Y - join with newlines
                                 - implicit print

JavaScript (ES6), 121 ... 103 92 byte

f=(n,i=128)=>i--?f(n,i)+(i%16?'':`
`)+'.#.'[i%16+4*n-~-'31000013'[n&1?i>>4:1]*~-(n&2)>>4]:''

Bản giới thiệu

f=(n,i=128)=>i--?f(n,i)+(i%16?'':`
`)+'.#.'[i%16+4*n-~-'31000013'[n&1?i>>4:1]*~-(n&2)>>4]:''

o.innerHTML=f(0)

<input type="range" oninput="o.innerHTML=f(this.value)" value=0 min=0 max=7><pre id=o>

Haskell , 98 90 byte

f i=do{a<-[3,1,0,0,0,0,1,3];[".#."!!div(i*4+x+[0,a-1,0,1-a]!!mod i 4)16|x<-[0..15]]++"\n"}

Nó lặp qua các hàng và cột bằng cách sử dụng danh sách đơn vị (một dokhối cho các hàng và hiểu danh sách cho các cột) và xác định ký tự nào cho mỗi ô bằng cách sử dụng biểu thức của đầu vào ( i), giá trị offset cho hàng ( a) và chỉ mục cột ( x).

Đã lưu 8 byte bằng cách đơn giản hóa biểu thức con cho phần bù thực.

Python 2 , 144 142 127 byte

i=input()
a,b='#.'[::i/4*2-1]
i%=4
for x in range(8):y=(int(abs(x-3.5))or 1)+2;y=[y,16-y][i>2];y=[i*4,y][i%2];print(16-y)*a+b*y

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

Chắc chắn có thể được đánh gôn hơn nữa, lời khuyên được đánh giá cao :)

Chơi hết 1 byte nhờ vào ngầm!

Đánh bại nhiều byte nhờ ovi và Mego vì tôi là một kẻ ngốc quên không sử dụng 4 khoảng trắng cho codegolf :)

PHP, 105 byte

for(;$i++<8;)echo($p=str_pad)($p("",[16,16-$b=_64333346[$i],8,$b][3&$a=$argn],_M[$a/4]),16,M_[$a/4])."
";

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

Toán học, 125 byte

s=Switch;Grid@If[1<#<6,#&,1-#&][s[m=#~Mod~4,0,0,2,1,_,1-{3.4,5}~DiskMatrix~{8,16}]s[m,1,h=Table[Boole[i>8],8,{i,16}],_,1-h]]&

Trả về một lưới sử dụng 1và 0thay vì .và #tương ứng.

Nó hoạt động bằng cách sử dụng hai mặt nạ, một mặt tròn và một nửa bóng mờ và kết hợp một cách hợp lý chúng để có được hình dạng phù hợp.

Hai mặt nạ được làm 1-{3.4,5}~DiskMatrix~{8,16}cho cho một vòng tròn, và Table[Boole[i>8],8,{i,16}]cho một nửa. Logic như sau:

output = f(a AND b)

where f, a and b are:

n | f    a  b
--+-----------
0 | NOT  F  ◨ 
1 | NOT  ○  ◧ 
2 | 1    T  ◨
3 | 1    ○  ◨
4 | 1    F  ◨ 
5 | 1    ○  ◧ 
6 | NOT  T  ◨ 
7 | NOT  ○  ◨

Logic được mô phỏng với 1s và 0s bằng cách sử dụng phép nhân cho ANDvà x -> 1-xchoNOT .

Một giải pháp phần thưởng (không phải ASCII), cho 28 byte: IconData["MoonPhase",#/4-1]&