Mục tiêu của bạn là hiển thị nghệ thuật ASCII của một đội hình trong trò chơi bowling mười chân trong đó chỉ còn lại một số chân. Ít byte nhất sẽ thắng.

Các hàng chục chân là trong một hình tam giác:

O O O O         
 O O O   
  O O       
   O

Ghim được dán nhãn từ 1 đến 10 là:

7 8 9 10    
 4 5 6            
  2 3    
   1

Vẽ các chân như Ovà thiếu chân như ., sự hình thành 1 3 5 6 9 10là:

. . O O         
 . O O    
  . O       
   O

Đầu vào:

Một chuỗi được phân tách bằng dấu cách liệt kê một tập hợp con không trống của các số 1 mặc dù 10 theo thứ tự.

Đầu ra:

In đội hình tương ứng hoặc xuất nó dưới dạng một chuỗi có ngắt dòng.

Sự hình thành nên được tuôn ra với bên trái của màn hình. Bất kỳ khoảng trắng nào cũng được miễn là hình ảnh hiển thị là chính xác. Dòng trống trước và sau cũng tốt.

Các trường hợp thử nghiệm:

>> 1 2 3 4 5 6 7 8 9 10

O O O O    
 O O O    
  O O    
   O

>> 7 10

O . . O    
 . . .   
  . .   
   .

>> 3 5 7 9 10

O . O O    
 . O .    
  . O    
   .

>> 1

. . . .    
 . . .    
  . .    
   O       

brainfuck - 617 616 604 byte

+>>>>,[>++++[<-------->-]<[>>>>],]<<<<[>+<<+<+>>-]<[>+<-]+<+<<[>+>-<<-]>[<+>-]>[,+++++[>+++++<-]>>[<->-]<[>>>>>[>>>>]+[<<<<]<-]>>[<+>-]<<<]>[>>[,<]<<+++++++++<]<<<[-[+>>-<]>[>>[<+<+>>-]<<<<[>+>-<<-]>[<+>-]>[<<[<<<<]>>>>[[<<<<+>>>>-]>>>>]<<<<+>>-]>[>+<-]]<<<[-[+>]+<<<<]>>>>-<<<<<]>>>>>+++++[>----<-]>->[<+>>+<-]<[<<<[<<<<]+[>>>>]<-]>>[<+>-]<[<<<<]>>>++++[<-------->-]>[-[,+++>]+>>>[<<<->>]>]<<<<<[>-]>[>>]>>+[<++++[<++++++++>-]<]>>[+++++++++++++>>>>]<<<<----<+++[<<+<<[<<+<<]+[>>>>]<<<<-]<<<<[-<<<<]>[.,>>]<<<<<[<<<<]<++++++++++<<.<+<<+<<+<<+<<+<[.,>>]<<<<<[<<]>++++++++++<+<<+<<+<..<+<[.,>>]<[<<]<...<<.

Điều này đã cho tôi phần tốt hơn của hai ngày. Tôi nghĩ nó đáng đấy. Có lẽ các bộ phận có thể được đánh gôn nhiều hơn bằng cách thay đổi tế bào gì đó được lưu trữ trong bất cứ thứ gì, nhưng ngay bây giờ tôi rất vui khi tôi làm cho nó hoạt động.

Chương trình này sẽ phải hoàn toàn khác nếu câu hỏi không chỉ định rằng đầu vào sẽ được sắp xếp. Cách thức hoạt động này là bằng cách xây dựng một danh sách 10 chân xung quanh các chân được nhập. Điều đó thật khó hiểu nhưng có lẽ điều này sẽ giải thích nó tốt hơn:

If you input these pins:           [2, 3, 6, 8, 9]
First, the program does this:      [2, 3, 6, 8, 9] + [10]
Then this:                         [2, 3, 6] + [7] + [8, 9, 10]
Then this:                         [2, 3] + [4, 5] + [6, 7, 8, 9, 10]
Finally, this:                     [1] + [2, 3, 4, 5, 6, 7, 8, 9, 10]
To build this:                     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Trong khi thực hiện điều đó, nó sẽ nhớ những chân nào mà người dùng đặt ở đó và những cái nào được đặt ở đó. Chiến lược này sẽ rất khó sử dụng nếu đầu vào không được sắp xếp.

Một điều nữa mà việc sắp xếp dễ dàng hơn là phát hiện ra số 10. Vì brainfuck xử lý từng byte riêng lẻ, không phải là "số" mỗi se, nó có thể gây khó khăn cho ass, nhưng đầu vào được sắp xếp giúp tôi dễ dàng xử lý hơn với. Lý do cho điều đó có liên quan đến cách tôi lưu trữ dữ liệu trong chương trình. Tôi lấy một ký tự đầu vào tại thời điểm và trừ 32 từ kết quả. Nếu ô đó khác không sau đó, tôi di chuyển về phía trước 4 ô. trước khi lặp lại. Điều này có nghĩa là tôi nhận được một byte không gian đầu vào cứ sau 4 ô và tôi lưu trữ các chân một cách hiệu quả dưới dạng số của chúng + 16. Tuy nhiên, 10 mất hai byte để nhập, vì vậy tôi phải đặc biệt sử dụng nó. Nếu đầu vào không được sắp xếp, tôi phải xem qua các chân, nhưng vì nó được sắp xếp nên nó sẽ luôn là chân cuối cùng nếu nó xuất hiện. Tôi kiểm tra xem (byte cuối cùng của đầu vào + 1) == (byte cuối cùng thứ hai của đầu vào) và nếu vậy, nó phải là 10. Tôi thoát khỏi byte cuối cùng và đặt byte cuối cùng vào thứ mà hệ thống của tôi hiểu là "10". Các nhân vật'1'và '0'không vừa trong một byte đơn, nhưng số 26 chắc chắn có!

Đến với các thủ thuật chỉ để làm cho một cái gì đó hoạt động là phần yêu thích của tôi khi sử dụng ngôn ngữ này. :)

Nếu bạn quan tâm đến cách chương trình này hoạt động chi tiết hơn, bạn có thể xem chương trình với các nhận xét tôi đã sử dụng trong khi viết để đảm bảo tôi nhớ mọi thứ đã làm. Ngay cả việc viết bình luận trong brainfuck cũng khó, vì không có cú pháp bình luận. Thay vào đó, mọi nhân vật ngoại trừ những nhân vật trong <[+.,-]>đều là những người không hoạt động. Thật dễ dàng để giới thiệu các lỗi bằng cách vô tình bao gồm .hoặc ,trong ý kiến ​​của bạn! Đó là lý do tại sao ngữ pháp rất hay và dấu chấm phẩy ở khắp mọi nơi.

EDIT: Như một ví dụ về việc điều này dễ dàng như thế nào: Tôi đã sử dụng "phi không gian" trong một trong các ý kiến! Khi tôi loại bỏ tất cả các ký tự không phải bf khỏi nguồn, chương trình tôi đã sử dụng để giữ nó trong -. May mắn thay, nó đã không phá vỡ bất cứ điều gì, nhưng bây giờ tôi đã loại bỏ nó để tiết kiệm một byte. :)

EDIT II: Đã lâu rồi tôi mới chạm vào cái này, haha. Trong một câu trả lời khác trên trang web này, tôi nhận thấy rằng tôi đã vô tình sử dụng dấu phẩy trong phiên bản nhận xét. Vì đầu vào đã cạn kiệt, nó đặt ô hiện tại thành 0 (điều này phụ thuộc vào việc triển khai, nhưng theo kinh nghiệm của tôi, đó là hành vi phổ biến nhất). Tôi đã sửa lỗi, nhưng nó làm tôi suy nghĩ. Cách thành ngữ để đặt một ô thành 0 là [-](đại khái while (*p) { *p--; }), dài hơn hai byte. Bất cứ khi nào tất cả các đầu vào đã được đọc, tôi có thể sử dụng ,thay thế. Điều này đã tiết kiệm cho tôi 2 byte trong câu trả lời đó và 12 byte trong câu trả lời này!

one flag at the very left; will be important later
+>>>>

all nonspace bytes of input separated by 3 empty cells; pin number `n` stored with value `n` plus 16
,[>++++[<-------->-]<[>>>>],]<<<<

test if last pin is 10
[>+<<+<+>>-]<[>+<-]+<+<<[>+>-<<-]>[<+>-]>

[
    if not: find 10 minus the number it is; put that many placeholder pins (cells with value 1) at the end
    ,+++++[>+++++<-]>>[<->-]<[>>>>>[>>>>]+[<<<<]<-]>>[<+>-]<<<
]>


[
    if so: get rid of '0' byte; convert '1' byte to 26 (10 plus 16)
    >>[,<]<<+++++++++<
]<<<

pointer now sitting on the cell with the second greatest pin that was inputted (ie not a placeholder)

;;;;;;;

[
    check for flag placed at the very beginning of the program; if present: break
    -[+>>-<]>
    [
        find ((pin to our right) minus 1) minus pin to our left
        move all pins left of us 4*(that value) cells and insert placeholder pins
        >>[<+<+>>-]<<<<[>+>-<<-]>[<+>-]>[<<[<<<<]>>>>[[<<<<+>>>>-]>>>>]<<<<+>>-]>[>+<-]
    ]

    find first non placeholder pin to our left
    there has to be one because we haven't hit the flag yet
    <<<[-[+>]+<<<<]>>>>-<<<<<
]>>>>>+

we have now added placeholder pins at the end and in the middle; all that's left is the beginning

subtract 17 from lowest pin and put that many placeholders to the left
++++[>----<-]>->[<+>>+<-]<[<<<[<<<<]+[>>>>]<-]>>[<+>-]

subtract 32 from an empty cell 2 to the left of the lowest pin; will be useful later
<[<<<<]>>>++++[<-------->-]>

placeholder pins have the value 1; real pins have a value somewhere between 17 and 26
normalize it by stepping through and setting every pin with value != 1 to 3 (0's ascii code is 2 higher than period so this will make it easier to print later)
[-[,+++>]+>>>[<<<->>]>]<<<<<[>-]>[>>]>>

start writing 32s across the board; hitting every second cell
that's every pin and the cell 2 to the right of each pin
this is done in such a way that it will only halt if adding 32 to a cell sets it to 0; which is why we subtracted 0 from an empty cell earlier
it will catch us and prevent an infinite loop
+[<++++[<++++++++>-]<]

now write 13 to each pin; this adds up to 46 or 48; which are exactly the ascii values we want
>>[+++++++++++++>>>>]

we happen to have made a 14; turn it into a 10 for a newline
<<<<----

we're so close now; i can taste it
we have a list of 10 pins; each one with the ascii value that needs to be written
we have 32 everywhere because we'll need spaces
we even have a newline

the only problem now is that our list looks like this:
;;;;;;;;;;;;;;;;;;;;;;;;
;;1 2 3 4 5 6 7 8 9 10;;
;;;;;;;;;;;;;;;;;;;;;;;;

and we need to print in this order:
;;;;;;;;;;;;;;;;;;;;;;;;
;;7 8 9 10 4 5 6 2 3 1;;
;;;;;;;;;;;;;;;;;;;;;;;;

it's a pretty simple fix
once we print a pin we obviously don't need to remember it any more
so we simply print the last 4 pins on the list; destroying them on the way
then we print the last 3; which have become the ones we want
then two; then one
<+++[<<+<<[<<+<<]+[>>>>]<<<<-]<<<<[-<<<<]

print pins 7 8 9 10
>[.,>>]

print pins 4 5 6
<<<<<[<<<<]<++++++++++<<.<+<<+<<+<<+<<+<[.,>>]

print pins 3 2
<<<<<[<<]>++++++++++<+<<+<<+<..<+<[.,>>]

print the final pin!! :)
<[<<]<...<<.

Python 2, 108 byte

def f(x):
 for i in 4,3,2,1:print" "*(4-i)+" ".join(".O"[i*~-i/2-~z in map(int,x.split())]for z in range(i))

Gọi với f("3 5 7 9 10").

ilà số hàng, với 4 là hàng đầu tiên và 1 là hàng cuối cùng. zlà pin thứ n trên hàng đó, với 0 có nghĩa là pin đầu tiên trong hàng và i-1có nghĩa là pin cuối cùng trong hàng.

Các hack chính là i*~-i/2-~z, mà chuyển đổi (i, z) -> pin number. Ví dụ, (4, 0) -> 7vì chân 7 là chân đầu tiên trên hàng 4 (hàng đầu tiên). Đạo hàm diễn ra như sau:

• Chúng tôi muốn một chức năng lấy ipin đầu tiên trên hàng i, tức là 4 -> 7, 3 -> 4, 2 -> 2, 1 -> 1. Điều này được thỏa mãn bởi (i**2-i)/2 + 1, và do đó (i**2-i)/2 + 1 + zđưa ra số pin chính xác cho đầu vào(i, z)

• Sau đó đơn giản hóa:

(i**2-i)/2 + 1 + z
  = (i*(i-1))/2 + 1 + z
  = i*~-i/2 + 1 + z
  = i*~-i/2-~z

Bình thường , 33 byte

V4~Z-4N+*dNjdm@".O"}+d-11Zrz7U-4N

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

Chương trình tạm dịch là:

z = input()
Z = 0

for N in range(4):
  Z += 4-N
  print(" "*N + " ".join(".O"[d+11-Z in map(int, z.split())] for d in range(4-N)))

(Cảm ơn isaacg về lời khuyên)

Bình thường , 31

V4+*dNjdm?\O}+7+dZrz7\.rN4~Z-N4

Hãy thử nó ở đây .

V4 thiết lập một vòng lặp for, với N là biến trên [0,1,2,3].

*dNcung cấp các không gian ban đầu, bởi vì dlà không gian.

Để tìm vị trí pin, nó sử dụng +7+dZ- 7 + d + Z.

d Là:

0 1 2 3
 1 2 3
  2 3
   3

trong khi Zlà 0 ở dòng đầu tiên, -4 ở dòng thứ hai, -7 ở dòng thứ ba và -9 ở dòng thứ hai. Đây là becasue Zbắt đầu bằng 0 và ~Z-N4giảm Z4, rồi 3, rồi 2.

Sau đó, nó kiểm tra xem vị trí pin có trong đầu vào không, sử dụng }+7+dZrz7. rz7là các chân mong muốn ở dạng list-of-int.

Sau đó, nó tạo ra một Onếu nó có mặt, và .nếu không. Đây là không gian được phân tách, với jdvà được in ngầm.

Perl 5: 51 (50 + 1 cho -p)

Sử dụng rcờ cho s///một trong 5 bổ sung gần đây nhất.

#!perl -p
$_="7890
 456
  23
   1
"=~s!\d!'. '^a
x/$&\b/!egr

CJam, 48 41 byte

Wow, điều này đã kéo dài khủng khiếp

"6789345 12  0"S*7/N*[l~]:(s"O"erA,s"."er

Kiểm tra nó ở đây.

Giải trình

Đầu tiên chúng ta tạo bố cục:

"6789345 12  0"       "Push this string.";
               S*     "Riffle with spaces.";
                 7/   "Split into substrings of length 7.";
                   N* "Join with newlines.";

Sản lượng này

6 7 8 9
 3 4 5 
  1 2  
   0

Và bây giờ chúng ta thay thế các ký tự chữ số theo đầu vào:

[l~]                 "Read the input and turn it into an array of integers.";
    :(s              "Decrement each number and turn the array into a string of digits.";
       "O"           "Push this string.";
          er         "Character transliteration, replaces the input digits with O.";
            A,s      "Create the string '0123456789'.";
               "."   "Push this string.";
                  er "Character transliteration, replaces all remaining digits with periods.";

Con trăn 2, 97 94

Điều này sử dụng chức năng dịch, cho phép người ta thực hiện thay thế ký tự cho từng ký tự trong một chuỗi. Giống như tr trong perl, ngoại trừ lâu hơn để gõ. Tôi nhận được một danh sách các chữ số thập phân bằng cách tạo một chuỗi từ 9 đến 99.

lambda a:u"7890\n 456\n  23\n   1".translate({ord(n):u'.O'[n+' 'in a+' ']+' 'for n in`9**99`})

Javascript, 155

Golf đầu tiên, có lẽ có thể ngắn hơn.

function f(i){q='replace',s='7 8 9 0\n 4 5 6\n  2 3\n   1';alert(s[q](RegExp(i[q]('10','0')[q](/ /g,'|'),'g'),function(a){return a?'O':a})[q](/\d+/g,'.'))}

gọi với

f('1 2 3 4 5 6 7 8 9 10')
f('1 5 10')
f('')

BIÊN TẬP

Phiên bản ES6, 130

f=i=>{q='replace',s='7 8 9 0\n 4 5 6\n  2 3\n   1';alert(s[q](RegExp(i[q]('10','0')[q](/ /g,'|'),'g'),a=>a?'O':a)[q](/\d+/g,'.'))}

BIÊN TẬP

Phiên bản ES6, 79 lỗi

f=i=>alert('7890\n 456\n  23\n   1'.replace(/\d/g,a=>i.indexOf(a)<0?'. ':'O '))

Phiên bản ES6, 72 77, không có cảnh báo, chỉ trả về

f=i=>'7890\n 456\n  23\n   1'.replace(/\d/g,a=>i.search(a+'\\b')<0?'. ':'O ')

Ruby, 91

x=(1..10).map{|i|i.to_s==$*[0]?($*.shift;?0):?.}
4.times{|i|puts (x.pop(4-i)*' ').center 8}

Đơn giản chỉ cần thay thế các đối số dòng lệnh bằng .s và 0s và in chúng bằng cách sử dụng một vòng lặp gồm 4 chu kỳ.

Phiên bản dễ đọc

x = (1..10).map do |i|
  if i.to_s == ARGV[0]
    ARGV.shift
    "0"
  else
    "."
  end
end

4.times do |i|
  row = x.pop(4 - i)
  puts row.join(' ').center 8
end

GNU sed, 75

• Đã lưu 6 byte nhờ @Jordan.

Điểm bao gồm 1 thêm cho -rtùy chọn:

s/^/7 8 9 10\
 4 5 6\
  2 3\
   1 /
:
s/([0-9]+)(.*)\1/O\2/
t
s/[0-9]+/./g

Nhập thông qua STDIN:

$ echo 3 5 7 9 10 | sed -rf ./bowling.sed
O . O O
 . O .
  . O
   .    
$ 

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

CJam, 40 39 byte

4,Sf*'-A*[q~]{('ot}/3,{)/(\s}%Sf*W%]zN*

Tôi biết có một cách ngắn hơn, không có thời gian để tìm ra nó ngay bây giờ.

Làm thế nào nó hoạt động:

4,Sf*'-A*[q~]{('ot}/3,{)/(\s}%Sf*W%]zN*
4,                                          "Get the array [0,1,2,3]";
  Sf*                                       "Covert each number to that many spaces to";
                                            "get ["", " ", "  ", "   "] array";
     '-A*                                   "String '----------'";
         [q~]                               "Input numbers in an array";
             {    }/                        "For each input number";
              ('ot                          "Put 'o' at the corresponding index";
                    3,                      "Array [0,1,2]";
                      {     }%              "For each of the above number";
                       )                    "Increment the number";
                        /                   "Split the string into pieces of that length";
                         (\s                "Take the first string and join the rest back";
                              Sf*           "Riffle each string in array with space";
                                 W%         "Reverse the array of strings";
                                   ]z       "Zip together the space array and this one";
                                     N*     "Join by new line";

Dùng thử trực tuyến tại đây

APL (35)

⊖4 7⍴'.O'[1+⎕∊⍨⍳10]\⍨17110357⊤⍨28/2

Kiểm tra:

      ⊖4 7⍴'.O'[1+⎕∊⍨⍳10]\⍨17110357⊤⍨28/2
⎕:
      1 3 5 6 9 10
. . O O
 . O O 
  . O  
   O   

Giải trình:

• 17110357⊤⍨28/2: đại diện 28 bit của 17110357:

        4 7⍴17110357⊤⍨28/2
  0 0 0 1 0 0 0
  0 0 1 0 1 0 0
  0 1 0 1 0 1 0
  1 0 1 0 1 0 1
  

• \⍨: Với mỗi 0, hãy tạo một khoảng trắng và cho mỗi 1, lấy một mục từ chuỗi bên trái.

• ⎕∊⍨⍳10: Đọc một dòng từ bàn phím và đánh giá nó ( ⎕), sau đó kiểm tra mọi số từ 1 đến 10 ( ⍳10) xem nó có được chứa trong đầu vào ( ∊⍨) không.
• '.O'[1+... ]: Thêm 1 vào mỗi giá trị (đưa ra 1 và 2 thay vì 0 và 1), sau đó thay thế mỗi 1 bằng .và mỗi 2 bằng O.
• 4 7⍴: biến chuỗi được tạo thành ma trận 4 nhân 7
• ⊖: lật nó theo chiều ngang

Quyền hạn: 109

Đầu vào là $ i

(7..10),(4..6),(2,3),1|%{$c=0}{$_|%{$o=(" "*$c++)}{$o="$o $(if($i.split() -contains $_){'O'}else{'.'})"};$o}

Đó là niềm vui. Đã học một loạt các công cụ về cách thức hoạt động của đường ống.

Haskell: 163 160 byte

Điều này chấp nhận một dòng không gian tách số từ stdin.

m=map
y?x|x`elem`y="O "|0<1=". "
f y=putStr.unlines.zipWith(++)(m(`replicate`' ')[0..])$m(concat.m(y?))[[7..10],[4..6],[2,3],[1]]
main=getLine>>=f.m read.words

Ung dung:

layout :: [[Int]]
layout = [[7,8,9,10]
         ,[ 4,5,6  ]
         ,[  2,3   ]
         ,[   1    ]
         ]

indentBy :: Int -> String
indentBy n = replicate n ' '

indentLines :: [String] -> [String]
indentLines
  = zipWith (++)
            (map indentBy [0..])

bowling :: [Int] -> String
bowling pins
  = unlines
  . indentLines
  $ map (concatMap showPlace)
        layout
  where
    showPlace :: Int -> String
    showPlace index
      | index `elem` pins = "O "
      | otherwise         = ". "

parseInput :: String -> [Int]
parseInput = map read . words

main :: IO ()
main = do
  pins <- fmap parseInput getLine
  putStr (bowling pins)

Và một phần thưởng:

C: 250 byte

Phiên bản này hy vọng các đối số dòng lệnh của nó là danh sách các số.

#define w int
main(w
z,char**a){w
b[10]={1,3,2,6,5,4,10,9,8,7};w
q=9;for(w
k=4;k>0;--k){w
i;for(i=0;i<4-k;++i)printf(" ");for(i=0;i<k;++i,--q){w
g=0;w
c;for(w
p=1;p<z;++p){sscanf(a[p],"%d",&c);g|=b[q]==c;}c=g?'O':'.';printf("%c ",c);}printf("\n");}}

Perl, 73

$_="7 8 9 10\n 4 5 6\n  2 3\n   1";for$v(<>=~/\d+/g){s/$v/O/g};s/\d+/./g;print

Và một cách tiếp cận tiền thưởng ngớ ngẩn không thành công, 90 ký tự:

srand(1488068);$i=<>;print+(($i=~/$_\b/?O:".")." "x rand 5)=~s/  /\n /r for 7..10,4..6,2,3,1

Toán học, 109 byte

Chức năng:

f=(i=0;Reverse@Table[Row@Table[If[MemberQ[ToExpression/@StringSplit@#,++i],O,"."],{n}],{n,4}]~Column~Center&)

Gọi bằng:

f@"3 5 7 9 10"

Nếu các chức năng ẩn danh được cho phép, điều này có thể được rút ngắn xuống còn 105 byte :

i=0;Reverse@Table[Row@Table[If[MemberQ[ToExpression/@StringSplit@#,++i],O,"."],{n}],{n,4}]~Column~Center&

Nếu đầu vào không phải là một chuỗi được phân tách bằng dấu cách, nhưng có thể là một mảng các số trong biểu mẫu {3,5,7,9,10}, thì điều này có thể được rút ngắn hơn nữa thành 79 byte :

i=0;Reverse@Table[Row@Table[If[MemberQ[#,++i],O,"."],{n}],{n,4}]~Column~Center&

Bash tinh khiết (không có coreutils), 85

Thay thế mẫu đơn giản:

f="7 8 9 0
 4 5 6
  2 3
   1"
a=${@/10/0}
f="${f//[${a// /}]/O}"
echo "${f//[0-9]/.}"

Danh sách là đầu vào thông qua các đối số dòng lệnh.

Nổi loạn - 117

s: array/initial 10"."b:""foreach n to-block input[s/:n:"0"]for n 4 1 -1[prin b print take/last/part s n append b" "]

Ung dung:

s: array/initial 10 "."
b: ""
foreach n to-block input [s/:n: "0"]
for n 4 1 -1 [prin b print take/last/part s n append b " "]

Brainfuck, 179 byte

++++++++++[-[<<+>>-]+<<]>,[<[-]-[>-<-----]>++[-[>>+<<-]>>]>+++[<<],>,]<[,>>---[>
>]<<+++[<<]]>->>->>>>->>>>>>->[[>>]>,<<+[++[>+++++++++++<-]<+]>>[++.>-.>]>++++++
++++[>>]<<[.[<]<]<]

Định dạng:

++++++++++
[
  -[<<+>>-]
  +<<
]
>,
[
  <[-]
  -[>-<-----]
  >++
  [
    -[>>+<<-]
    >>
  ]
  >+++[<<]
  ,>,
]
<
[
  ,>>---[>>]
  <<+++[<<]
]
>->>->>>>->>>>>>->
[
  [>>]
  >,<
  <+
  [
    ++[>+++++++++++<-]
    <+
  ]
  >>[++.>-.>]
  >++++++++++[>>]
  <<[.[<]<]
  <
]

Mong đợi đầu vào mà không có một dòng mới.

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

Băng được khởi tạo với mười nút, mỗi nút chứa một nút theo sau là 0. Một là giá trị ban đầu của pin và số 0 tạo điều kiện cho việc điều hướng và đóng vai trò giữ chỗ cho ký tự khoảng trắng. Đối với mỗi số trong đầu vào, chân đó được tăng thêm 3; lưu ý rằng ord('O') - ord('.') = 33, và trong giai đoạn in, giá trị của pin sẽ được nhân với 11. (Phép nhân này cũng được sử dụng để tạo ký tự khoảng trắng.) Thứ tự của các chân từ trái sang phải trên băng chỉ đơn giản là 1lên đến 10. Nếu đầu vào kết thúc bằng a 10, một hiệu chỉnh được thực hiện, vì 10đầu tiên được coi là a 1.

Sau khi đầu vào được xử lý, một âm được đặt sau mỗi hàng. Sau đó, các hàng được in trong một vòng lặp, với số lượng khoảng trắng hàng đầu được xác định bởi số lượng hàng được xử lý trước đó.

Clojure, 216 ký tự (ugh)

Tôi chắc chắn rằng điều này có thể được chơi golf hơn nữa.

(let[s(map #(dec(read-string %))(.split(slurp *in*)" +"))](println(apply str(replace(apply hash-map(interleave(map #(char(+ 48 %))(range 10))(map #(if(some #{%}s)"O"".")(range 10))))"6 7 8 9\n 3 4 5\n  1 2\n   0"))))

Sử dụng như thế này:

echo -n "2 4 9 8 10 5" | clojure a-file-which-contains-this-program.clj

AWK: 96 byte

{gsub(/ /,"");a="6 7 8 9\n 3 4 5\n  1 2\n   0";gsub("["$0"]","O",a);gsub(/[0-9]/,".",a);print a}

Ghi chú:

• Các dấu phân cách khoảng trắng trên giá trị đầu vào là tùy chọn (nhưng nó cũng hoạt động với chúng theo yêu cầu)
• Các số không phải theo thứ tự
• Đầu vào được đọc trên STDIN

C # - 192 byte

Vì C #!

Tôi đã bắt đầu cố gắng xây dựng đầu ra bằng toán học, nhưng phương pháp thay thế mã thông báo đơn giản có vẻ tốt nhất cho các ngôn ngữ cấp cao hơn. Sự phụ thuộc Linq là dài nhưng vẫn ngắn hơn so với việc giữ một bộ đếm và kiểm tra phạm vi.

using System.Linq;class A{static void Main(string[]a){var s=@"7 8 9 0
 4 5 6
  2 3
   1";for(int c=11;c-->1;)s=s.Replace((char)(48+c%10),a.Contains(""+c)?'O':'.');System.Console.Write(s);}}

EDIT: trả về dòng unix (-3 byte)

Scala, 150 148

def t(n:Any)=("G H I J D E F   B C     A"/:('A'to'J'))((j,i)=>j.replace(i,(if((n+" ").indexOf((i-64)+" ")>=0)'0'else'.'))).grouped(7).maxBy(println)

Chấp nhận bộ chuỗi được phân tách bằng dấu cách

JavaScript ES6, 78 byte

F=i=>'7890\n 456\n  23\n   1'.replace(/\d/g,e=>'0.'[+!~i.search(e+'\\b')]+' ')

Sử dụng đoạn mã sau để kiểm tra. Nó sử dụng lời nhắc và cảnh báo và ký hiệu chức năng thông thường để dễ kiểm tra.

i=prompt()
alert('7890\n 456\n  23\n   1'.replace(/\d/g,function(e){return'0.'[+!~i.search(e+'\\b')]+' '}))

VB / Cơ bản-229

Mục tiêu của tôi là đánh bại java ^^

Dim f
Sub m()
f = " 1 2 3 4 5 6 7 8 9 10"
a = l(7, 10) + l(4, 6) + l(2, 3) + l(1, 1)
MsgBox a
End Sub
Function l(b, e)
r = Space(3 - (e - b))
For i = b To e
r = r + IIf(InStr(f, Str(i)), "0 ", ". ")
Next
l = r + vbCr
End Function

chỉnh sửa vbCr thay vì chr (13)

r = r + Không gian (3 - (e - b))

tốc ký nếu

sử dụng chức năng thay vì phụ

phụ MAIN () -> phụ m ()

Java - 223 ký tự

public class Pins {public static void main(String[] args) {String s = "7 8 9 0\n 4 5 6\n  2 3\n   1";for (String arg : args) {s = s.replace(arg.replace("10", "0"), "o");}s = s.replaceAll("\\d", ".");System.out.println(s);}}

Tôi đã từng thích cách làm này, sau đó tôi nhận ra rằng tôi cần một bản hack nhỏ, vẫn giống như giải pháp của tôi.

public class Pins {
public static void main(String[] args) {
    String s = "7 8 9 0\n 4 5 6\n  2 3\n   1";
    for (String arg : args) {
        s = s.replace(arg.replace("10", "0"), "o");
    }
    s = s.replaceAll("\\d", ".");
    System.out.println(s);
}
}

K, 57 byte

Chưa cạnh tranh lắm, nhưng đó là một khởi đầu:

`0:((!4)#\:" "),',/'|0 1 3 6_(". ";"O ")@|/(1+!10)=/:(),.

Ví dụ sử dụng:

  `0:((!4)#\:" "),',/'|0 1 3 6_(". ";"O ")@|/(1+!10)=/:(),."3 5 7 9 10"
O . O O 
 . O . 
  . O 
   . 
  `0:((!4)#\:" "),',/'|0 1 3 6_(". ";"O ")@|/(1+!10)=/:(),."1"
. . . . 
 . . . 
  . . 
   O 

Tôi bắt đầu bằng cách đánh giá chuỗi đầu vào với .- may mắn thay, các số được phân tách bằng dấu cách là một danh sách hợp lệ bằng chữ K. Bằng cách thêm một danh sách trống vào kết quả của eval tôi có thể đảm bảo đó là một danh sách ngay cả trong trường hợp của một pin. Sau đó, tôi tạo một vectơ boolean đại diện cho vị trí của các chân:

  (1+!10)=/:3 5 7 9 10
(0 0 1 0 0 0 0 0 0 0
 0 0 0 0 1 0 0 0 0 0
 0 0 0 0 0 0 1 0 0 0
 0 0 0 0 0 0 0 0 1 0
 0 0 0 0 0 0 0 0 0 1)
  |/(1+!10)=/:3 5 7 9 10
0 0 1 0 1 0 1 0 1 1

Sau đó, tôi lập chỉ mục vào một danh sách các chuỗi để có được các ký tự đệm không gian cho mỗi vị trí ghim.

  (". ";"O ")@0 0 1 0 1 0 1 0 1 1
(". "
 ". "
 "O "
 ". "
 "O "
 ". "
 "O "
 ". "
 "O "
 "O ")

Tôi cắt chuỗi đó thành các hàng ( _), đảo ngược chúng ( |) và nối với nhau từng đoạn ( ,/'):

  ,/'|0 1 3 6_(". ";"O ")@0 0 1 0 1 0 1 0 1 1
("O . O O "
 ". O . "
 ". O "
 ". ")

Bây giờ nó bắt đầu trông giống như mô hình mà chúng ta muốn. Tất cả những gì còn lại là giải quyết một số khoảng trắng hàng đầu cho mỗi hàng ( ((!4)#\:" "),') và in các hàng thành thiết bị xuất chuẩn ( 0:).

Pascal (FPC) , 165 byte

var f:string='. . . .'#10' . . .'#10'  . .'#10'   .';i:byte;z:array[1..10]of byte=(25,18,20,10,12,14,1,3,5,7);begin repeat read(i);f[z[i]]:='O'until eof;write(f)end.

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

Lấy số từ đầu vào tiêu chuẩn, in hình thành đầu ra tiêu chuẩn.

Pascal (FPC) , 175 byte

function f(q:array of byte):string;var i:byte;z:array[1..10]of byte=(25,18,20,10,12,14,1,3,5,7);begin f:='. . . .'#10' . . .'#10'  . .'#10'   .';for i in q do f[z[i]]:='O'end;

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

Một hàm thực hiện điều tương tự, lấy một mảng các vị trí pin và trả về một chuỗi được định dạng.

Powershell, 84 byte

$p='6789
 345
  12
   0'
-split$args|%{$p=$p-replace($_-1),'O '}
$p-replace'\d','. '

Kịch bản thử nghiệm:

$f = {

$p='6789
 345
  12
   0'
-split$args|%{$p=$p-replace($_-1),'O '}
$p-replace'\d','. '

}

# one space at the end of each line with pins
@(
,("1 2 3 4 5 6 7 8 9 10",
@"
O O O O 
 O O O 
  O O 
   O 
"@)

,("7 10",
@"
O . . O 
 . . . 
  . . 
   . 
"@)

,("3 5 7 9 10",
@"
O . O O 
 . O . 
  . O 
   . 
"@)

,("1",
@"
. . . . 
 . . . 
  . . 
   O 
"@)
) | % {
    $s, $expected = $_
    $result = &$f $s
    $result-eq$expected
    $result
}

Đầu ra:

True
O O O O
 O O O
  O O
   O
True
O . . O
 . . .
  . .
   .
True
O . O O
 . O .
  . O
   .
True
. . . .
 . . .
  . .
   O

Java - 371 316 294 ký tự

public class Bowling{public static void main(String[] a){boolean[] o=new boolean[10];int i;for(String s:a){i=Integer.parseInt(s)-1;o[i]=true;}for(int j=9;j>=0;j--){p((o[j]?"0 ":". "));p(j==6?"\n ":"");p(j==3?"\n  ":"");p(j==1?"\n   ":"");}p("\n");}static void p(String l){System.out.print(l);}}

Lần đầu tiên làm điều này, tôi khá chắc chắn rằng nó thật tồi tệ, nhưng tôi là một người mới. Nó cũng hoạt động khi các số không được đặt hàng. Việc đánh số là sai nhưng tôi không có thời gian để tìm cách sửa nó ...

public class Bowling {
    public static void main(String[] args) {
        boolean[] ordened = new boolean[10];
        int i;
        for (String s : args) {
            i = Integer.parseInt(s) - 1;
            ordened[i] = true;
        }
        for (int j = 9; j >= 0; j--) {
            p((ordened[j] ? "0 " : ". "));
            p(j == 6 ? "\n " : "");
            p(j == 3 ? "\n  " : "");
            p(j == 1 ? "\n   " : "");
        }
        p("\n");
    }
    static void p(String l){
        System.out.print(l);
    }
}

đầu vào được đưa ra bởi java B 1 2 3 5 10ví dụ. Đầu ra sau đó sẽ là:

0 . . . 
 . 0 . 
  0 0 
   0 

Japt -Rx , 29 19 18 17 byte

5ÇÆ".O"gUø°TøÃÔû

Thử nó

Giải trình

                      :Implicit input of integer array U
5Ç                    :Map each Z in the range [0,5)
  Æ                   :  Map the range [0,Z)
          °T          :    Increment T (initially 0)
        Uø            :    Does U contain T? (false=0, true=1)
   ".O"g              :    Get the character in the string ".O" at that index
            Ã         :  End mapping
             ¸        :  Join with spaces
              Ã       :End mapping
               Ô      :Reverse
                û     :Centre pad each element with spaces to the length of the longest
                      :Implicitly join with newlines, trim (not strictly necessary) and output