Cho hai số nguyên dương X và Y, xuất ra bất kỳ sự kết hợp nào của ba động vật nghệ thuật ASCII sau đây sao cho đầu ra chứa chính xác dấu phẩy X ( ,) và Y ( .), nếu có thể.

1. Koala: 1 dấu phẩy, 2 tiết

   <.,.>
   

2. Cua: 2 dấu phẩy, 2 tiết

   ,<..>,
   

3. Dấu phẩy: 3 dấu phẩy trở lên, 1 dấu chấm

   <,,,.>
   

   hay <,,,,.>hay <,,,,,.>hay <,,,,,,.>hay <,,,,,,,.>, vv

Nếu không có sự kết hợp nào của những con vật này có thể tạo ra chính xác dấu phẩy X và dấu phẩy Y, hãy tạo ra một dấu phẩy đơn, người sẽ ngụy trang cho sự thất bại:

~<.,,>~~

Các động vật đầu ra có thể ở bất kỳ số lượng và bất kỳ thứ tự. Chúng có thể nằm trong một chuỗi, không gian hoặc dòng mới được phân tách hoặc khác trong danh sách mà mỗi động vật là một yếu tố.

Ví dụ: với X = 7, Y = 5, tất cả sẽ là các đầu ra hợp lệ (được phân tách bằng các dòng trống):

<.,.> <.,.> <,,,,,.>

<.,.>
<,,,,,.>
<.,.>

,<..>, <.,.> <,,,,.>

<,,,,.>
,<..>,
<.,.>

,<..>, <,,,.> ,<..>,

[",<..>,", ",<..>,", "<,,,.>"] (list syntax depends on language)

Lưu ý rằng (ít nhất là trong ví dụ này) có nhiều bộ động vật hơn có thể hoạt động. Nhưng hãy nhớ rằng bạn chỉ cần xuất bất kỳ một giải pháp hợp lệ, nếu một giải pháp tồn tại. Số lượng động vật hoặc số lượng động vật riêng biệt không quan trọng.

Đối với các đầu vào như X = 3, Y = 3 hoặc X = 1, Y = 5 khi không có giải pháp, đầu ra sẽ luôn là

~<.,,>~~

có lẽ trong một danh sách đơn yếu tố.

Mã ngắn nhất tính bằng byte thắng.

Ruby, 139 byte

Hàm Lambda, lấy x và y làm đối số và trả về một chuỗi

->x,y{c=y-2*n=y-(x>y ?1:0)>>1
x+=-c/2*s=[x-n,c*3].max
x<n||x>n*2?'~<.,,>~~':',<..>, '*(x-n)+'<.,.> '*(2*n-x)+"<%s.> "*c%[?,*s-=c/2*3,?,*3]}

Nếu một giải pháp tồn tại, nó có thể được thực hiện với tất cả gấu túi + commapillar hoặc tất cả gấu túi + cua.

Nguyên tắc là sử dụng tối thiểu các commapillar. Nếu số là số lẻ, chúng tôi sử dụng 1 commapillar. nếu thậm chí chúng ta sử dụng 0 dấu phẩy, trừ khi có nhiều dấu phẩy hơn dấu chấm, trong trường hợp đó chúng ta sử dụng 2 dấu phẩy.

Số lượng thời gian được sử dụng trong noncommapillar (cua + koalas) là nhất thiết phải chẵn, và số lượng noncommapillar là một nửa (number of periods)-(number of commapillars). Nếu không có đủ dấu phẩy cho tất cả gấu túi, hoặc quá nhiều cho tất cả cua, không có giải pháp nào khả thi. Nếu không, chúng tôi trả lại một giải pháp.

Nhận xét trong chương trình thử nghiệm

sử dụng "fail" thay vì tắc kè hoa cho rõ ràng

f=->x,y{c=y-2*n=y-(x>y ?1:0)>>1
#n=noncommapillars=y>>1 as they have 2 periods. c=commapillars=y-2*n, 1 for odd y, 0 for even y.
#if x>y there are too many commas to have 0 commapillars for even y. noncommapillars= y-1 >> 1, so 2 commapillars

x+=-c/2*s=[x-n,c*3].max
# s=number of commas allocated to commapillars. x-n to allow all noncommapillars to be koalas, but at least 3 per commapillar.
#-c/2 == -1 if there are commapillars, 0 if not (Ruby truncates toward -inf). Subtract commas for commapillars from x if necessary

x<n||x>n*2?'fail':',<..>, '*(x-n)+'<.,.> '*(2*n-x)+"<%s.> "*c%[?,*s-=c/2*3,?,*3]}
#if x<n (insufficient commas for all koalas) or x>n*2 (too many for all crabs) return fail. Else...
#return string off crabs, koalas, and (using % operator like sprintf) c commapillars (0..2), the second with 3 commas (if present) and the first with the rest.  



10.times{|j|10.times{|i|puts "%-20s %s"%[?.*j+?,*i,f[i,j]]}}
#all x,y from 0..9

Đầu ra

,                    fail
,,                   fail
,,,                  fail
,,,,                 fail
,,,,,                fail
,,,,,,               fail
,,,,,,,              fail
,,,,,,,,             fail
,,,,,,,,,            fail
.                    fail
.,                   fail
.,,                  fail
.,,,                 <,,,.>
.,,,,                <,,,,.>
.,,,,,               <,,,,,.>
.,,,,,,              <,,,,,,.>
.,,,,,,,             <,,,,,,,.>
.,,,,,,,,            <,,,,,,,,.>
.,,,,,,,,,           <,,,,,,,,,.>
..                   fail
..,                  <.,.>
..,,                 ,<..>,
..,,,                fail
..,,,,               fail
..,,,,,              fail
..,,,,,,             <,,,.> <,,,.>
..,,,,,,,            <,,,,.> <,,,.>
..,,,,,,,,           <,,,,,.> <,,,.>
..,,,,,,,,,          <,,,,,,.> <,,,.>
...                  fail
...,                 fail
...,,                fail
...,,,               fail
...,,,,              <.,.> <,,,.>
...,,,,,             <.,.> <,,,,.>
...,,,,,,            <.,.> <,,,,,.>
...,,,,,,,           <.,.> <,,,,,,.>
...,,,,,,,,          <.,.> <,,,,,,,.>
...,,,,,,,,,         <.,.> <,,,,,,,,.>
....                 fail
....,                fail
....,,               <.,.> <.,.>
....,,,              ,<..>, <.,.>
....,,,,             ,<..>, ,<..>,
....,,,,,            fail
....,,,,,,           fail
....,,,,,,,          <.,.> <,,,.> <,,,.>
....,,,,,,,,         <.,.> <,,,,.> <,,,.>
....,,,,,,,,,        <.,.> <,,,,,.> <,,,.>
.....                fail
.....,               fail
.....,,              fail
.....,,,             fail
.....,,,,            fail
.....,,,,,           <.,.> <.,.> <,,,.>
.....,,,,,,          <.,.> <.,.> <,,,,.>
.....,,,,,,,         <.,.> <.,.> <,,,,,.>
.....,,,,,,,,        <.,.> <.,.> <,,,,,,.>
.....,,,,,,,,,       <.,.> <.,.> <,,,,,,,.>
......               fail
......,              fail
......,,             fail
......,,,            <.,.> <.,.> <.,.>
......,,,,           ,<..>, <.,.> <.,.>
......,,,,,          ,<..>, ,<..>, <.,.>
......,,,,,,         ,<..>, ,<..>, ,<..>,
......,,,,,,,        fail
......,,,,,,,,       <.,.> <.,.> <,,,.> <,,,.>
......,,,,,,,,,      <.,.> <.,.> <,,,,.> <,,,.>
.......              fail
.......,             fail
.......,,            fail
.......,,,           fail
.......,,,,          fail
.......,,,,,         fail
.......,,,,,,        <.,.> <.,.> <.,.> <,,,.>
.......,,,,,,,       <.,.> <.,.> <.,.> <,,,,.>
.......,,,,,,,,      <.,.> <.,.> <.,.> <,,,,,.>
.......,,,,,,,,,     <.,.> <.,.> <.,.> <,,,,,,.>
........             fail
........,            fail
........,,           fail
........,,,          fail
........,,,,         <.,.> <.,.> <.,.> <.,.>
........,,,,,        ,<..>, <.,.> <.,.> <.,.>
........,,,,,,       ,<..>, ,<..>, <.,.> <.,.>
........,,,,,,,      ,<..>, ,<..>, ,<..>, <.,.>
........,,,,,,,,     ,<..>, ,<..>, ,<..>, ,<..>,
........,,,,,,,,,    <.,.> <.,.> <.,.> <,,,.> <,,,.>
.........            fail
.........,           fail
.........,,          fail
.........,,,         fail
.........,,,,        fail
.........,,,,,       fail
.........,,,,,,      fail
.........,,,,,,,     <.,.> <.,.> <.,.> <.,.> <,,,.>
.........,,,,,,,,    <.,.> <.,.> <.,.> <.,.> <,,,,.>
.........,,,,,,,,,   <.,.> <.,.> <.,.> <.,.> <,,,,,.>

Befunge, 249 218 byte

&::00p&::00g\`-2/:20p2*-3*:30p\20g-`:!00g20g-*\30g*+:30g-v>:#,_@
"~<.,,>~~"0_v#\g03+`g050`\0:-g02\p05:-\*2g02:-*/6+3g03p04<^
$"<">:#,_40p>:!#|_3-0" >.,,"40g3>3g#<\#-:#1_
0" ,>..<,">:#,_$>:!#|_1-
#@_1-0" >.,.<">:#,_$>:!

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

Điều này hiện dựa trên thuật toán trong câu trả lời Ruby của Level River St , cung cấp phạm vi lớn hơn cho việc chơi golf và giảm đáng kể kích thước so với giải pháp ban đầu của tôi.

C # 6, 321 303 byte

using System.Linq;string F(int x,int y)=>S(x,y)??"~<.,,>~~";string S(int x,int y)=>x<0|y<0?null:y<1?x<1?"":null:y*3>x?S(x-1,y-2)!=null?S(x-1,y-2)+"<.,.> ":S(x-2,y-2)!=null?S(x-2,y-2)+",<..>, ":null:string.Concat(new int[y].Select((_,k)=>k<1?C(x-y*3+3):C(3)));string C(int x)=>$"<{new string(',',x)}.> ";

Gọi F(). Hai chức năng khác là người trợ giúp. thay thế bản demo

// Coalesce failed combinations with commaleon
string F(int x,int y)=>S(x,y)??"~<.,,>~~";
// Get successful combination or null
string S(int x,int y)=>
    x<0|y<0
        // Fail: Out of range
        ?null
        :y<1
            ?x<1
                // Successful: All commas and periods accounted for
                ?""
                // Fail: Not enough periods for commas
                :null
            :y*3>x
                // Not all commapillars
                ?S(x-1,y-2)!=null
                    // Try koala
                    ?S(x-1,y-2)+"<.,.> "
                    // Try crab
                    :S(x-2,y-2)!=null
                        ?S(x-2,y-2)+",<..>, "
                        // Epic fail
                        :null
                // All commapillars
                :string.Concat(new int[y].Select((_,k)=>k<1
                    // This commapillar takes most of commas
                    ?C(x-y*3+3)
                    // The rest each takes 3
                    :C(3)));
// Generate single commapillar
string C(int x)=>$"<{new string(',',x)}.> ";