您的目标是在只有十个针脚的十针保龄球中显示编队的ASCII艺术。最少的字节数获胜。

十个针呈三角形形式：

O O O O         
 O O O   
  O O       
   O

引脚从1到10的标签为：

7 8 9 10    
 4 5 6            
  2 3    
   1

绘制图钉为O，缺少图钉为.，形式1 3 5 6 9 10为：

. . O O         
 . O O    
  . O       
   O

输入：

用空格分隔的字符串，按顺序列出数字1到10的非空子集。

输出：

打印相应的形式或将其输出为带有换行符的字符串。

地层应与筛网左侧齐平。只要可见图像正确，任何空格都可以。前后的空行也可以。

测试用例：

>> 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字节

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

这花了我两天的大部分时间。我认为这是值得的。通过改变存储在什么单元格中的东西，也许有些零件可以打更多的高尔夫球，但是现在我很高兴自己能工作。

如果问题未指定对输入进行排序，则该程序必须完全不同。这种工作方式是在输入的引脚周围构造10个引脚的列表。这有点令人困惑，但是也许这可以更好地解释它：

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]

在执行此操作时，它会记住用户在其中放置了哪些销钉以及在其中放置了哪些销钉。如果未对输入进行排序，则此策略将很难使用。

排序变得更容易的另一件事是数字10的检测。由于Brainfuck本身处理的是单个字节，而不是“数字”，所以这可能会很麻烦，但是排序后的输入使我更容易处理用。原因与我在程序中存储数据的方式有关。我一次输入一个字符，然后从结果中减去32。如果此后该单元格不为零，则我向前移动4个单元格。在重复之前。这意味着我每4个单元获得一个非空格字节的输入，并且我将引脚有效地存储为它们的数字+16。但是，10键入两个字节，因此我必须对其进行特殊处理。如果未对输入进行排序，则必须仔细检查引脚，但是由于已对引脚进行排序，因此如果出现，它将始终是最后一个引脚。我检查（input的最后一个字节+ 1）==（input的第二个最后一个字节），如果是，则必须为10。我摆脱了最后一个字节，并将第二个最后一个设置为系统所理解的“ 10”。那些角色'1'并且'0'不能放在单个字节中，但是数字26肯定可以！

我想使用一些技巧来使某件事完全起作用，这是我使用这种语言的最喜欢的部分。:)

如果您对这个程序的更详细的工作方式感兴趣，可以查看该程序及其编写时所用的注释，以确保我记得所有操作。由于没有注释语法，因此即使用Brainfuck编写注释也很困难。取而代之的是，除其中的所有字符外，其他所有字符<[+.,-]>都是禁忌。通过不小心包含.或,在您的注释中引入错误很容易！这就是为什么语法如此古怪而分号无处不在的原因。

编辑：作为这是多么容易搞砸的示例：我在其中之一中使用了“非空格”！当我从源代码中剥离所有非bf字符时，我曾经执行过的程序保存在-。幸运的是它没有破坏任何东西，但是现在我删除了它以节省一个字节。:)

编辑二：自从我碰到这已经有一段时间了，哈哈。在该站点上的另一个令人不安的答案中，我注意到我在注释版本中不小心使用了逗号。由于输入已经用尽，因此将当前单元格设置为0（这取决于实现，但是根据我的经验，这是最常见的行为）。我修复了该错误，但它使我产生了思考。将单元格设置为0的惯用方式是[-]（大约while (*p) { *p--; }），这要长两个字节。任何时候读取所有输入后，我都可以使用,。这为我节省了2个字节，而在这个答案中却节省了12个字节！

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个字节

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))

致电f("3 5 7 9 10")。

i是行号，其中4是第一行，1是最后一行。z是该行的第n个引脚，0表示它是该行中的第一个引脚，i-1意味着它是该行中的最后一个引脚。

主要hack是i*~-i/2-~z转换的(i, z) -> pin number。例如，(4, 0) -> 7第7行是第4行（第一行）的第一个引脚。推导如下：

• 我们希望有一个函数i进入行的第一个引脚i，即4 -> 7, 3 -> 4, 2 -> 2, 1 -> 1。可以满足(i**2-i)/2 + 1，因此可以(i**2-i)/2 + 1 + z提供正确的输入引脚号(i, z)

• 然后简化：

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

Pyth，33个字节

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

在线尝试。

该程序大致翻译为：

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)))

（感谢isaacg提供的提示）

珀斯（31）

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

在这里尝试。

V4 设置一个for循环，其中N为[0,1,2,3]上的变量。

*dN提供初始空间，因为d是空间。

要查找引脚位置，它使用+7+dZ-7 + d +Z。

d 是：

0 1 2 3
 1 2 3
  2 3
   3

而Z在第一行中为0，在第二行中为-4，在第三行中为-7，在第四行中为-9。这是因为Z从0开始，然后~Z-N4递减Z4，然后递减3，然后递减2。

然后，使用来检查引脚位置是否在输入中}+7+dZrz7。rz7是int列表形式的所需引脚。

然后，它创建一个Oif（如果存在），.否则。这是用空格分隔的，用jd，并隐式打印。

Perl 5：51（对于，为50 +1 -p）

using r标志s///是最近perl 5新增的功能之一。

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

CJam，48个 41字节

哇，这太长了

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

在这里测试。

说明

首先，我们生成布局：

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

这产生

6 7 8 9
 3 4 5 
  1 2  
   0

现在，我们根据输入内容替换数字字符：

[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.";

蟒蛇2，97 94

这使用了转换功能，该功能允许在字符串中进行字符对字符的替换。像perl中的tr一样，只是键入时间更长。我得到一个从9到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

第一次打高尔夫球，可能会更短。

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,'.'))}

打电话给

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

编辑

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,'.'))}

编辑

ES6版本，失败79

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

ES6版本72 77，无警告，仅返回

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

露比（91）

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

只需用.s和0s 替换命令行参数，并使用4个循环的循环来打印它们。

可读版本

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岁

• @Jordan节省了6个字节。

分数包括1个额外的-r选项：

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

通过STDIN输入：

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

在线尝试。

CJam，40 39字节

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

我知道有一个更短的方法，现在没有时间弄清楚。

这个怎么运作：

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";

在这里在线尝试

APL（35）

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

测试：

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

说明：

• 17110357⊤⍨28/2：的28位表示形式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
  

• \⍨：对于每个0，给一个空格，对于每个，给1左边的字符串取一个项目。

• ⎕∊⍨⍳10：从键盘上读取一行并进行评估（⎕），然后检查1到10（⍳10）之间的每个数字是否在输入（∊⍨）中包含该数字。
• '.O'[1+... ]：将1加到每个值（将1和2替换为0和1），然后将每个1 .和2 替换为O。
• 4 7⍴：将生成的字符串转换为4×7矩阵
• ⊖：水平翻转

动力壳：109

输入单位为$ i

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

那很有趣。还学习了很多有关管道如何工作的知识。

Haskell：163160字节

这接受与分隔的数字行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

取消高尔夫：

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)

还有一个好处：

C：250字节

此版本期望其命令行参数为数字列表。

#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

一个愚蠢的奖金方法并没有成功，共有90个字符：

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

Mathematica，109个字节

功能：

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

致电者：

f@"3 5 7 9 10"

如果允许匿名函数，则可以将其缩短为105个字节：

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

如果输入不必是由空格分隔的字符串，而是形式为数字的数组{3,5,7,9,10}，则可以将其进一步缩短为79个字节：

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

纯bash（无coreutils），85

简单模式替换：

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

列表是通过命令行参数输入的。

Rebol-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" "]

取消高尔夫：

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个字节

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

格式：

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

期望输入时没有尾随换行符。

在线尝试。

磁带用十个节点初始化，每个节点包含一个1和一个零。一个是引脚的初始值，而零则便于导航并充当空格字符的占位符。对于输入中的每个数字，该引脚将增加3；否则，该引脚将增加3。请注意ord('O') - ord('.') = 33，并且在打印阶段，图钉的值将乘以11。（此乘法也用于生成空格字符。）在磁带上，图钉从左到右的顺序简单地1达到10。如果输入以a结尾10，则进行更正，因为10a最初被视为a 1。

处理完输入后，在每行之后放置一个负数。然后以循环方式打印行，其中前导空格的数量由先前处理的行数确定。

Clojure，216个字符（ugh）

我相信这可以继续打下去。

(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"))))

像这样使用：

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

AWK：96个字节

{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}

注意：

• 输入值上的空格分隔符是可选的（但也可以根据需要与它们一起使用）
• 数字不一定是有序的
• 在STDIN上读取输入

C＃-192字节

因为C＃！

我开始尝试用数学来构建输出，但是简单的字符串替换令牌方法似乎最适合高级语言。Linq依赖关系虽然长，但仍然比保持计数器和进行范围检查短。

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);}}

编辑：Unix行返回（-3字节）

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)

接受以空格分隔的字符串集

JavaScript ES6，78个字节

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

使用以下代码片段进行测试。它使用提示和警报以及常规功能符号来简化测试。

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

VB /基本-229

我的目标是击败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

编辑vbCr而不是chr（13）

r = r +空格（3-（e-b））

简写如果

使用功能代替子

sub MAIN（）-> sub m（）

Java-223个字符

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);}}

我曾经喜欢这种方式，然后我意识到我需要一个小技巧，仍然有点像我的解决方案。

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个字节

竞争还不是很好，但这是一个开始：

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

用法示例：

  `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 

我首先以.-幸运的是，用K表示空格的数字是有效的列表字面量来评估输入字符串。通过在eval的结果前添加一个空列表，即使在单个引脚的情况下，我也可以确保它是一个列表。然后创建一个代表引脚位置的布尔向量：

  (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

然后，我索引一个字符串列表，以获取每个引脚位置的空格字符。

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

我将该序列切成行（_），将它们反转（|）并将每个片段（,/'）连接在一起：

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

现在，它开始看起来像我们想要的模式。剩下的就是在每行（((!4)#\:" "),'）的前导空格处添加行，并将行打印到stdout（0:）。

帕斯卡（FPC），165字节

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.

在线尝试！

从标准输入中获取数字，将格式打印到标准输出。

帕斯卡（FPC），175字节

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;

在线尝试！

该函数执行相同的功能，将引脚位置作为数组并返回格式化的字符串。

Powershell，84个字节

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

测试脚本：

$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
}

输出：

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

爪哇- 371 316 294个字符

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);}}

第一次这样做，我可以肯定它很烂，但是我是新手。当数字不排序时也可以使用。编号是错误的，但我没有时间找出解决方法...

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);
    }
}

输入java B 1 2 3 5 10例如给出。输出将是：

0 . . . 
 . 0 . 
  0 0 
   0 

Japt -Rx，29 19 18 17字节

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

试试吧

说明

                      :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