(liên quan / lấy cảm hứng từ: Vẽ một đội hình bowling )

Một trò tiêu khiển thú vị trong những tháng mùa đông ở đây là biểu diễn bowling người tuyết, sử dụng một quả bóng lớn (như quả bóng rổ) và những hình người tuyết nhỏ xíu. Hãy tạo lại điều này trong ASCII.

Mỗi người tuyết bao gồm:

(.,.)
( : )

Dưới đây là sự liên kết của mười "chân" người tuyết

(.,.) (.,.) (.,.) (.,.)
( : ) ( : ) ( : ) ( : )
   (.,.) (.,.) (.,.)
   ( : ) ( : ) ( : )
      (.,.) (.,.)
      ( : ) ( : )
         (.,.)
         ( : )

Những "chân" được dán nhãn từ 1đến 10như

7 8 9 10
 4 5 6
  2 3
   1

Cho đến nay, rất chuẩn. Tuy nhiên, không giống như bowling thông thường, các chân người tuyết chỉ được làm phẳng và không hoàn toàn bị loại bỏ. Điều này được thực hiện bởi một người nào đó cần phải tự làm phẳng tuyết của bất kỳ chiếc ghim nào bị đánh. Một người tuyết dẹt được đại diện bởi _____(năm dấu gạch dưới), với khoảng trắng ở trên. Dưới đây là một ví dụ với các 1 3 5 6 9 10chân được làm phẳng (có nghĩa là chỉ còn lại các 2 4 7 8chân):

(.,.) (.,.)
( : ) ( : ) _____ _____
   (.,.)
   ( : ) _____ _____
      (.,.) 
      ( : ) _____

         _____

Đầu vào

• Một danh sách các số nguyên từ 1đến 10 trong bất kỳ định dạng thuận tiện nào đại diện cho các chân được đánh và do đó cần phải được làm phẳng.
• Mỗi số sẽ chỉ xuất hiện tối đa một lần và các số có thể theo bất kỳ thứ tự nào (được sắp xếp, không sắp xếp, sắp xếp giảm dần) - sự lựa chọn của bạn, bất cứ điều gì làm cho mã của bạn trở nên tốt hơn.
• Đầu vào được đảm bảo có ít nhất một số nguyên.

Đầu ra

Kết quả đại diện nghệ thuật ASCII của các chân người tuyết, với các chân chính xác được làm phẳng.

Quy tắc

• Các dòng mới hoặc dấu cách hàng đầu hoặc dấu trắng đều là tùy chọn, miễn là bản thân các ký tự xếp hàng chính xác.
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Nếu có thể, vui lòng bao gồm một liên kết đến một môi trường thử nghiệm trực tuyến để mọi người có thể thử mã của bạn!
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

1 3 5 6 9 10

(.,.) (.,.)
( : ) ( : ) _____ _____
   (.,.)
   ( : ) _____ _____
      (.,.) 
      ( : ) _____

         _____

1 2 3

(.,.) (.,.) (.,.) (.,.)
( : ) ( : ) ( : ) ( : )
   (.,.) (.,.) (.,.)
   ( : ) ( : ) ( : )

      _____ _____

         _____

1 2 3 4 5 6 8 9 10

(.,.)
( : ) _____ _____ _____

   _____ _____ _____

      _____ _____

         _____

05AB1E , 45 44 byte

TF"(.,.)( : )"„ _5×{«4ä2ä¹N>åè})4L£Rvyø»}».c

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

Giải trình

TF                                           # for N in [0 ... 9] do:
  "(.,.)( : )"                               # push string
              „ _                            # push the string " _"
                 5×                          # repeat it 5 times
                   {                         # sort
                    «                        # concatenate the strings
                     4ä                      # split the string in 4 parts
                       2ä                    # split the list in 2 parts
                         ¹N>åè               # if index+1 is in the input, push the first part
                                             # else push the second part
                              }              # end loop
                               )             # wrap stack in a list
                                4L£          # split list in parts of size 1,2,3,4
                                   R         # reverse list
                                    v        # for each list in list of lists
                                     yø      # transpose the list
                                       »     # join by spaces and newlines
                                        }    # end loop
                                         »   # join by newlines
                                          .c # centralize

Người tuyết 1.0.2 , 157 byte

(()("789:045600230001"4aG::48nSdU][:#:]eq]/nM;AsI[:"_____"wR["     "wR/aC;:"( : )"wR["(.,.)"wR/aC;bI;:"  "wRdUaC;bI\#**\;aMaZ:" "aJ1AfL;aM;aM1AfL"
"aJ1AfL*))

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

Khi tôi thấy thử thách này, tôi biết mình chỉ cần trả lời bằng ngôn ngữ hoàn hảo ...

Đây là một chương trình con lấy đầu vào là một mảng các số và đầu ra dưới dạng một chuỗi thông qua permavar hiện tại.

Gói cho "dễ đọc" / thẩm mỹ:

(()("789:045600230001"4aG::48nSdU][:#:]eq]/nM;AsI[
:"_____"wR["     "wR/aC;:"( : )"wR["(.,.)"wR/aC;bI
;:"  "wRdUaC;bI\#**\;aMaZ:" "aJ1AfL;aM;aM1AfL"
"aJ1AfL*))

Phiên bản hơi vô căn cứ / nhận xét:

}
1wR`
3wR`aC`
5wR`aC`
6wR`aC`
9wR`aC`
*

((
    )(
    "789:045600230001"  // pin layout data
    4aG                 // split into groups of 4; we need each row twice
    :                   // map over groups of 2 output lines
        :               // map over pins (or whitespace)
            48nS        // subtract ascii '0'
            dU][        // duplicate the pin; we need it in the if{}
            :           // if (pin) {
                #:]eq]/nM;AsI[:"_____"wR["     "wR/aC;:"( : )"wR["(.,.)"wR/aC;bI
            ;:          // } else {
                "  "wRdUaC
            ;bI         // }
            \#**\       // maneuver the permavars around to discard pin
        ;aM
        aZ:" "aJ1AfL;aM
    ;aM
    1AfL                // flatten (simulate a flatmap)
    "
"aJ                     // join on newline
    1AfL                // flatten again into a single string
    *
))

#sP

xếp chồng , không biên dịch, 118 byte

Tôi đã thêm deepmapvà một vài thứ khác sau thử thách này, cùng với hàng tấn lỗi. Hãy thử nó ở đây!

@a((7 8 9 10)(4 5 6)(2 3)(1)){e:('(.,.)
( : )' ' 
_'5 hrep)a e has#'  'hcat
}deepmap{e i:' 
 'i 3*hrep e,$hcat#/!LF+}map

Bị đánh cắp

{ a :
  ((7 8 9 10) (4 5 6) (2 3) (1))
  { e :
    (
      '(.,.)' LF '( : )' + + 
      ' ' LF '_' + + 5 hrep
    ) @possible
    a e has @ind
    possible ind get @res
    '  ' @padding
    res padding hcat return
  } deepmap
  { e i:
    ' ' LF ' ' + + i 3 * hrep
    e ,
    $hcat insert!
    LF +
  } map
} @:bowl

(1 2 3 4 6 10) bowl out

Đầu ra:

(.,.) (.,.) (.,.)       
( : ) ( : ) ( : ) _____ 
         (.,.)       
   _____ ( : ) _____ 

      _____ _____ 

         _____ 

Python 2, 248 243 241 226 224 223 221 210 206 200 177 byte

-5 cảm ơn @Rod

-15 một lần nữa nhờ Rod

-1 sử dụng tính toán lại không gian từ Rod

Trông dài hơn do có nhiều dòng và thụt lề hơn nhưng đáng ngạc nhiên là ngắn hơn 11 byte.

Tôi chắc chắn rằng điều này sẽ đi dưới 200 ...

Tôi đã đúng nhưng không phải không có 23 byte gợi ý nghiêm túc từ @ Pietu1998. Cảm ơn nhiều!

i,z=input(),0;m=['']*10;n=m[:]
for x in range(11):m[x-1],n[x-1]=('(.,.)',' '*5,'( : )','_'*5)[x in i::2]
for y in 10,6,3,1:
 for q in m,n:print' '*3*z+' '.join(q[y-4+z:y])
 z+=1

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

Lấy đầu vào là một danh sách các số nguyên. Cách quá lớn ở mức 248 nhưng nó hoạt động.

C # 233 221 213 203 byte

phương thức lấy một mảng int làm danh sách các chân rơi

string S(int[]a){string o="",x=o,y=o,z=o;for(int i=10;i>0;){var c=a.Contains(i);x=(c?"      ":"(.,.) ")+x;y=(c?"_____ ":"( : ) ")+y;if(i==7|i<5&i--!=3){o+=$"{z}{x}\n{z}{y}\n";x=y="";z+="   ";}}return o;}

bọc

string S(int[]a){string o="",x=o,y=o,z=o;for(int i=10;i>0;)
{var c=a.Contains(i);x=(c?"      ":"(.,.) ")+x;y=(c?"_____ ":
"( : ) ")+y;if(i==7|i<5&i--!=3){o+=$"{z}{x}\n{z}{y}\n";x=y="";
z+="   ";}}return o;}

mở rộng

string S(int[] a)
{
    string o = "", x = o, y = o, z= o;
    for (int i = 10; i > 0;)
    {
        var c = a.Contains(i);
        x = (c ? "      " : "(.,.) ") + x;
        y = (c ? "_____ " : "( : ) ") + y;

        if (i==7|i<5&i--!=3)
        {
            o += $"{z}{x}\n{z}{y}\n";
            x = y = "";
            z += "   ";
        }
    }
    return o;
}

loại bỏ một vài byte bởi những gợi ý trong các bình luận từ Ghost, raznagul và auhmaan.

Hàng loạt, 262 byte

@echo off
for /l %%i in (1,1,10)do set s%%i=( : ) 
for %%i in (%*)do set s%%i=_____ 
set l=call:l 
%l%%s7%%s8%%s9%%s10%
%l%"   %s4%%s5%%s6%
%l%"      %s2%%s3%
%l%"         %s1%
exit/b
:l
set s=%~1
set s=%s:( : )=(.,.)%
echo(%s:_____=     %
echo(%~1

Lưu ý: Các dòng 2, 3 và 4 kết thúc trong một khoảng trắng và cũng xuất ra một khoảng trắng ở mỗi dòng. Chúng có thể được gỡ bỏ với chi phí 5 byte. Hoạt động bằng cách tạo các biến s1 ... s10 như một nửa dưới cùng của người tuyết, sau đó làm phẳng các biến được đưa ra dưới dạng đối số dòng lệnh. Các hàng thích hợp được in hai lần, lần đầu tiên với các nửa dưới được thay thế bằng các nửa trên cùng. Điều này tiết kiệm 18 byte khi sử dụng hai bộ biến nửa trên và dưới.

JavaScript, 154 149 byte

f=
a=>`6 7 8 9
_3 4 5
__1 2
___0
`[r='replace'](/\d|_/g,m=>++m?~a.indexOf(m)?'_____':'( : )':'   ')[r](/.*\n?/g,m=>m[r](/ : |_/g,s=>s=='_'?' ':'.,.')+m)


I.oninput=()=>O.innerHTML=f(JSON.parse(`[${I.value.match(/\d+/g)}]`))
I.oninput()

<input id=I value="1 3 5 6 9 10"><pre id=O>

Bình thường, 63 byte

j.ejm+**3k;j;db)_CcR[1 3 6).e:*T]btMQ@m*T]*5d,d\_kc2"(.,.)( : )

Một chương trình lấy đầu vào của danh sách các số nguyên và in kết quả.

Bộ kiểm tra

[Giải thích đến sau]

Bình thường, 51 byte

Mã này chứa một số không thể in được, vì vậy đây là một xxdhexdump.

00000000: 6a6d 2e5b 3233 5f6a 3b6d 4063 323f 7d6b  jm.[23_j;m@c2?}k
00000010: 5172 2235 2035 5f22 392e 2220 3b5b 8db2  Qr"5 5_"9." ;[..
00000020: 1778 a822 6472 4673 4d50 4253 2d34 2f64  .x."drFsMPBS-4/d
00000030: 323b 38                                  2;8

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

Không có dấu vết, 52 byte

jm.[23_j;m@c2?}kQr"5 5_"9").,.() : ("drFsMPBS-4/d2;8

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

Javascript 178 169 byte

Thực chất là một cổng từ câu trả lời C # của tôi.

Lấy một mảng int là danh sách các "chân" dẹt;

f=a=>{o=x=y=z="";for(i=10;i>0;){c=a.includes(i);x=(c?"      ":"(.,.) ")+x;y=(c?"_____ ":"( : ) ")+y;if(i==7|i<5&i--!=3){o+=z+x+"\n"+z+y+"\n";x=y="";z+= "   ";}}return o}

Gói:

f=a=>{o=x=y=z="";for(i=10;i>0;){c=a.includes(i);
x=(c?"      ":"(.,.) ")+x;y=(c?"_____ ":"( : ) ")+y;
if(i==7|i<5&i--!=3){o+=z+x+"\n"+z+y+"\n";x=y="";
z+= "   ";}}return o}

Mở rộng & giải thích:

// function f takes parameter a (an array of ints) 
f = a => {

    // four strings:
    // o: output
    // x: top row of snowmen
    // y: bottom row of snowmen
    // z: padding to indent the snowmen
    o = x = y = z = "";

    // loop from 10 to 1 (the pins)
    // remove the "afterthought" decrement - we can do that later
    for (i = 10; i > 0;) {

        // set the boolean c to whether the current pin has been flattened
        c = a.includes(i);

        // prefix x and y with the appropriate "sprite"
        // using a ternary if on c
        x = (c ? "      " : "(.,.) ") + x;
        y = (c ? "_____ " : "( : ) ") + y;

        // determine if we've reached the end of a row (i equals 7, 4, 2 or 1)
        // use non shortcircuit operators to save bytes and ensure we hit the final i, because...
        // we also decrement i here 
        // (we didn't do this in the for loop declaration to save a byte)
        if (i == 7 | i < 5 & i-- != 3) {

            // concatenate our rows x & y,
            // prefixing them with the padding z,
            // postfixing them with a newline
            o += z + x + "\n" + z + y + "\n";

            // reset x and y rows
            x = y = "";

            // increase our padding for next time
            z += "   ";
        }
    }

    // return our final string (no semicolon to save a byte)
    return o
}