Bài tập

Cho hai số nguyên dương:

1. Vẽ hình chữ nhật với kích thước được chỉ định bởi hai số nguyên.
2. Lặp lại Bước 3 cho đến khi không còn chỗ trống.
3. Vẽ và điền vào hình vuông lớn nhất chạm vào ba cạnh của hình chữ nhật (còn lại).
4. Xuất hình chữ nhật kết quả.

Thí dụ

Ví dụ, đầu vào của chúng tôi là 6và 10.

Chúng tôi vẽ hình chữ nhật rỗng có kích thước 6 x 10:

xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx

Sau khi liên tục điền vào các ô vuông, đây là những gì chúng ta sẽ có được:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

Có 4 hình vuông ở đây ( a, b, c, d), mỗi chiều dài bên 6, 4, 2, 2tương ứng.

Quy tắc và tự do

1. Bạn phải sử dụng một chữ cái khác nhau cho mỗi hình vuông.
2. Bạn có thể chọn những chữ cái để hỗ trợ, miễn là các chữ cái được hỗ trợ đều là các ký tự có thể in được và có ít nhất các 10ký tự được hỗ trợ.
3. Trong mỗi lần lặp của Bước 3 ở trên, bạn có hai lựa chọn (ngoại trừ ở lần lặp cuối cùng, trong đó bạn chỉ có một lựa chọn). Cả hai lựa chọn đều hợp lệ.
4. Số lượng hình vuông cần thiết sẽ không vượt quá số lượng chữ bạn hỗ trợ.
5. Bạn có thể điền vào các ô vuông với các chữ cái bạn hỗ trợ theo bất kỳ thứ tự nào .

Tủ thử

Đầu vào: 6, 10

Đầu ra:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

hoặc là

aaaaaaccdd
aaaaaaccdd
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb

hoặc là

bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
ccddaaaaaa
ccddaaaaaa

hoặc là

ccddaaaaaa
ccddaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa

hoặc là

ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddbbcc
ddddddbbcc

Đầu vào: 1,1

Đầu ra:

a

Đầu vào: 1,10

Đầu ra:

abcdefghij

Đầu vào: 10,1

Đầu ra:

a
b
c
d
e
f
g
h
i
j

Lưu ý rằng có nhiều khả năng hơn tôi có thể bao gồm cho các thử nghiệm ở trên.

Chấm điểm

Đây là môn đánh gôn . Câu trả lời ngắn nhất trong byte thắng.

Tiêu chuẩn áp dụng.

Than , 30 byte

ＮδＮγＦβ¿×γδ«ＵＯγδι¿‹γδＡ⁻δγδＡ⁻γδγ

Hãy thử trực tuyến! Giải trình:

Ｎδ      Input d
Ｎγ      Input g
Ｆβ      For i In ['a' ... 'z']
 ¿×γδ«   If g * d
  ＵＯγδι   Oblong g, d, i
  ¿‹γδ    If g < d
   Ａ⁻δγδ   d = d - g
   Ａ⁻γδγ   Else g = g - d

Lệnh Oblong của Annoyingly Char than sẽ không mất 0một kích thước, làm tôi mất 4 byte. Cách tiếp cận khác sẽ là lặp trong khig * d , nhưng sau đó tôi không thể tìm ra cách lặp lại b(được xác định trước cho các chữ cái viết thường).

Bình thường , 34 byte

M?*GH?<HGCgHG+*G]jk*G]~hZgG-HGYjgF

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

Haskell , 90 byte

(['a'..]!)
a?x=a<$[1..x]
((a:b)!y)x|x*y<1=""?y|x>y=map(a?y++)$b!y$x-y|z<-y-x=a?x?x++(b!z)x

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

Thạch , 32 byte

Ṁ,ạ/y
³,⁴ÇÐĿp/€Fs2
pµ¢ṣLµ€+95ỌsY

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

Ṁ,ạ/ybạn muốn một lời giải thích? Nó đây rồi

Ṁ,ạ/y          - perform one step of the Euclidean Algorithm, input 2-element list
 ,             - pair of the following two:
Ṁ              -  maximum of the the input list
  ạ/           -  absolute difference of the two elements
    y          - use this as a mapping on the input.

³,⁴ÇÐĿp/€Fs2   - apply Euclidean Algorithm
³,⁴            - start with the pair [input 1, input 2]
   Ç           - apply a step of the Euclidean Algorithm
    ÐĿ         - repetitively until the results repeat
      p/€      - take the Cartesian product of each step
         Fs2   - flatten and split into all coordinate pairs of letters

pµ¢ṣLµ€+95ỌsY
p              - Cartesian product of inputs: provides all possible coordinate pairs.
 µ   µ€       - for each coordinate
   ṣL         - find the number of times it is included in
  ¢           - the above list of covered coordinates.
       +95Ọ   - convert number of times to letters
           s  - split into rows
            Y - join by newlines.

Tôi có thể chơi golf nhiều hơn một chút bằng cách sử dụng các đối số ngầm thay vì ³,⁴.

Haskell , 181 byte

import Data.List
(['!'..'~']&)
a#[]=a
a#b=zipWith(++)a$transpose b
(s&a)b|b<1=[]|b>a=transpose$s&b$a|n<-div a b,(t,u)<-splitAt n s=foldl1(#)((<$[1..b]).(<$[1..b])<$>t)#(u&b$mod a b)

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

Để 10có thêm byte, bạn có được một vòng xoắn đẹp thay thế :)

!!!!!!!!!!!!!$$$#####
!!!!!!!!!!!!!$$$#####
!!!!!!!!!!!!!$$$#####
!!!!!!!!!!!!!%%'#####
!!!!!!!!!!!!!%%&#####
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""

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

Ung dung

Các (#)puts điều hành hai ma trận bên cạnh nhau, nhưng transposes một trong những quyền, ví dụ như:

!!!                !!!"
!!! # "#$    ->    !!!#
!!!                !!!$

a # [] = a
a # b  = zipWith (++) a $ transpose b

Về cơ bản, đây là phiên bản đệ quy của thuật toán Euclid, nhưng thay vì quên các ước số và phần dư và trả lại gcd, nó xây dựng các hình vuông từ nó và tích lũy chúng với (#). Các sbiến là những nhân vật còn lại mà chúng ta có thể sử dụng:

(s & a) b
  | b == 0 = []                     -- Base case
  | b > a = transpose $ (s & b) a   -- In this case we can just flip the arguments and rotate the result by 90 degrees
  | n <- div a b                    -- set n to the number of squares we need
  , (t,u) <- splitAt n s =          -- take n characters, ..
               ((<$[1..b]).(<$[1..b]) <$> t)                     -- .. build squares from them and ..
    foldl1 (#)                                                   -- put them next to each other
                                             (u & b $ mod a b)   -- recursively build the smaller squares with the remaining characters..
                                            #                    -- .. flip them and put them next to the previous one(s)

Hàm thực tế chỉ gọi hàm từ phía trên với một chuỗi gồm tất cả các ký tự có thể in:

(['!'..'~']&)