Seu objetivo é exibir a arte ASCII de uma formação no boliche de dez pinos, onde apenas alguns pinos permanecem. Menos bytes ganha.

Os dez pinos estão em uma formação triangular:

O O O O         
 O O O   
  O O       
   O

Os pinos são rotulados de 1 a 10 como:

7 8 9 10    
 4 5 6            
  2 3    
   1

Pinos de desenho como Oe pinos ausentes como ., a formação 1 3 5 6 9 10é:

. . O O         
 . O O    
  . O       
   O

Entrada:

Uma sequência separada por espaço que lista um subconjunto não vazio dos números de 1 a 10 em ordem.

Resultado:

Imprima a formação correspondente ou faça a saída como uma string com quebras de linha.

A formação deve estar nivelada com a esquerda da tela. Qualquer espaço em branco é bom, desde que a imagem visível esteja correta. Linhas vazias antes e depois também são boas.

Casos de teste:

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

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

Isso me levou a maior parte de dois dias. Eu acho que valeu a pena. Provavelmente, há partes que podem ser jogadas mais, alterando a célula em que algo está armazenado ou o que quer que seja, mas, no momento, estou feliz por fazê-lo funcionar.

Este programa teria que ser completamente diferente se a pergunta não especificasse que a entrada seria classificada. A maneira como isso funciona é construindo uma lista de 10 pinos em torno dos que são inseridos. Isso é meio confuso, mas talvez isso explique melhor:

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]

Enquanto faz isso, ele lembra quais pinos o usuário colocou lá e quais colocou lá. Essa estratégia seria muito difícil de usar se a entrada não fosse classificada.

Outra coisa que a classificação facilita é a detecção do número 10. Como o cérebro lida com bytes individuais, não com "números" por si só, poderia ter sido uma chatice, mas a entrada classificada tornou muito mais fácil para mim lidar com. A razão para isso tem a ver com a maneira como eu armazenei dados no programa. Pego a entrada um caractere de cada vez e subtraio 32 do resultado. Se a célula não for zero depois disso, avançarei 4 células. antes de repetir. Isso significa que eu recebo um byte de espaço não espacial a cada 4 células e efetivamente armazeno pinos como seu número + 16. No entanto, 10 leva dois bytes para digitar, então tive que ser especial. Se a entrada não fosse classificada, eu teria que olhar através dos pinos, mas, como é classificada, sempre será o último pino se aparecer. Verifico se o (último byte da entrada + 1) == (o segundo último byte da entrada) e, em caso afirmativo, deve ser 10. Me livre do último byte e defino o segundo último como o que meu sistema entende como "10". Os personagens'1'e '0'não cabe em um único byte, mas o número 26 com certeza se encaixa!

Criar truques apenas para fazer alguma coisa funcionar é minha parte favorita do uso dessa linguagem. :)

Se você estiver interessado em saber como esse programa funciona com mais detalhes, poderá vê-lo com os comentários que eu usei enquanto escrevia para garantir que eu me lembrasse do que tudo fazia. Até escrever comentários no cérebro é difícil, já que não há sintaxe para comentários. Em vez disso, todos os personagens, exceto aqueles em, <[+.,-]>não são ops. É fácil introduzir bugs acidentalmente incluindo .ou ,em seus comentários! É por isso que a gramática é tão instável e ponto e vírgula está em todo lugar.

EDIT: Como exemplo de como é fácil estragar tudo: usei "non-space" em um dos comentários! Quando retirei todos os caracteres não bf da fonte, o programa que costumava fazer isso ficava no arquivo -. Felizmente, não quebrou nada, mas agora eu o removi para salvar um byte. :)

EDIT II: Já faz um tempo desde que eu toquei este, haha. Em outra resposta cerebral neste site, notei que acidentalmente usei uma vírgula na versão comentada. Como a entrada já estava esgotada, ela definiu a célula atual como 0 (isso depende da implementação, mas, na minha experiência, é o comportamento mais comum). Corrigi o bug, mas isso me fez pensar. A maneira idiomática de definir uma célula como 0 é [-](aproximadamente while (*p) { *p--; }), que é mais dois bytes. Sempre que toda a entrada tiver sido lida, eu posso usar ,. Isso me salvou 2 bytes nessa resposta e 12 nessa!

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 bytes

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

Ligue com f("3 5 7 9 10").

ié o número da linha, com 4 sendo a primeira linha e 1 sendo a última. zé o nono pino nessa linha, com 0 significa que é o primeiro pino da linha e i-1significa que é o último pino da linha.

O principal hack é i*~-i/2-~z, o que é convertido (i, z) -> pin number. Por exemplo, (4, 0) -> 7como o pino 7 é o primeiro na linha 4 (a primeira linha). A derivação é assim:

• Queremos uma função levando ipara o primeiro pino da linha i, ou seja 4 -> 7, 3 -> 4, 2 -> 2, 1 -> 1. Isso é satisfeito (i**2-i)/2 + 1e, portanto, (i**2-i)/2 + 1 + zfornece o número de pino correto para a entrada(i, z)

• Em seguida, simplifique:

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

Pitão , 33 bytes

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

Experimente online.

O programa traduz aproximadamente para:

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

(Obrigado a isaacg por dicas)

Pyth , 31

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

Experimente aqui .

V4 configura um loop for, com N como a variável over [0,1,2,3].

*dNfornece os espaços iniciais, porque dé espaço.

Para encontrar a localização dos pinos, ele usa +7+dZ- 7 + d + Z.

d é:

0 1 2 3
 1 2 3
  2 3
   3

enquanto Zé 0 na primeira linha, -4 na segunda, -7 na terceira e -9 na quarta. Isso ocorre porque Zcomeça como 0 e ~Z-N4diminui Zem 4, depois em 3 e depois em 2.

Em seguida, verifica se o local do pino está na entrada, usando }+7+dZrz7. rz7são os pinos desejados na forma de lista de int.

Em seguida, ele cria um Ose estava presente e, .caso contrário. Este é um espaço separado, com jde impresso implicitamente.

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

Usando rsinalizador para o s///qual é uma das adições recentes ao perl 5.

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

CJam, 48 41 bytes

Uau, isso ficou terrivelmente longo

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

Teste aqui.

Explicação

Primeiro, geramos o layout:

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

Isso gera

6 7 8 9
 3 4 5 
  1 2  
   0

E agora substituímos os caracteres de dígito de acordo com a entrada:

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

Python 2, 97 94

Isso usa a função de conversão, que permite fazer substituições de caractere por caractere em uma string. Como tr em perl, exceto por muito mais tempo para digitar. Eu recebo uma lista de dígitos decimais criando uma sequência de 9 a 99 de potência.

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

Primeiro golfe, provavelmente pode ser mais curto.

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

ligue com

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

EDITAR

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

EDITAR

Versão ES6, 79 falha

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

Versão ES6, 72 77, nenhum alerta, apenas retorna

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}

Simplesmente substitui os argumentos de linha de comando com .s e 0s e imprime-los usando um loop de 4 ciclos.

Versão legível

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

• Guardado 6 bytes graças a @Jordan.

A pontuação inclui 1 extra para a -ropção:

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

Entrada via STDIN:

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

Experimente online .

CJam, 40 39 bytes

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

Eu sei que há uma maneira mais curta, não tenho tempo para descobrir isso agora.

Como funciona:

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

Experimente online aqui

APL (35)

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

Teste:

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

Explicação:

• 17110357⊤⍨28/2: a representação de 28 bits de 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
  

• \⍨: Para todos 0, forneça um espaço e, para todos 1, pegue um item da string à esquerda.

• ⎕∊⍨⍳10: Leia uma linha do teclado e avalie-a ( ⎕) e verifique se todos os números de 1 a 10 ( ⍳10) estão ou não contidos na entrada ( ∊⍨).
• '.O'[1+... ]: adicione 1 a cada valor (dando 1s e 2s em vez de 0s e 1s) e substitua a cada 1 por .cada 2 por O.
• 4 7⍴: transforme a sequência gerada em uma matriz de 4 por 7
• ⊖: virar horizontalmente

Powershell: 109

A entrada está em $ i

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

Foi divertido. Também aprendemos várias coisas sobre como o pipeline funciona.

Haskell: 163 160 bytes

Isso aceita uma linha de números separados por espaço 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

Ungolfed:

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)

E um bônus:

C: 250 bytes

Esta versão espera que seus argumentos de linha de comando sejam a lista de números.

#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

E uma abordagem de bônus pateta que não deu certo, 90 caracteres:

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

Mathematica, 109 bytes

Função:

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

Chamado por:

f@"3 5 7 9 10"

Se funções anônimas forem permitidas, isso pode ser reduzido para 105 bytes :

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

Se a entrada não tiver que ser uma cadeia de caracteres delimitada por espaço, mas possa ser uma matriz de números no formulário {3,5,7,9,10}, isso poderá ser reduzido ainda mais para 79 bytes :

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

Festança pura (sem coreutils), 85

Substituição simples de padrões:

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

A lista é inserida por meio da linha de comando args.

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

Ungolfed:

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 bytes

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

Formatado:

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

Espera entrada sem uma nova linha à direita.

Experimente online.

A fita é inicializada com dez nós, cada um dos quais contém um seguido por um zero. O primeiro é o valor inicial do pino e o zero facilita a navegação e atua como um espaço reservado para o caractere de espaço. Para cada número na entrada, esse pino é incrementado em 3; observe que ord('O') - ord('.') = 33, e durante a fase de impressão, o valor do pino será multiplicado por 11. (Essa multiplicação também é usada para gerar o caractere de espaço.) A ordem dos pinos da esquerda para a direita na fita é simplesmente de 1até 10. Se a entrada terminar com a 10, é feita uma correção, pois a 10é inicialmente tratada como a 1.

Após o processamento da entrada, uma negativa é colocada após cada linha. Em seguida, as linhas são impressas em um loop, com o número de espaços à esquerda determinado pelo número de linhas processadas anteriormente.

Clojure, 216 caracteres (ugh)

Tenho certeza que isso pode ser jogado ainda mais.

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

Use assim:

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

AWK: 96 bytes

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

Nota:

• Os separadores de espaços no valor de entrada são opcionais (mas também funcionam com eles, conforme necessário)
• Os números não precisam estar em ordem
• A entrada é lida em STDIN

C # - 192 bytes

Porque c #!

Comecei tentando criar a saída com matemática, mas o método simples de substituir tokens na string parece melhor para linguagens de nível superior. A dependência do Linq é longa, mas ainda menor do que manter um contador e fazer verificações de alcance.

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: retorno de linha unix (-3 bytes)

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)

Aceita conjunto de seqüências delimitadas por espaço

JavaScript ES6, 78 bytes

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

Use o seguinte trecho para testar. Ele usa avisos e alertas e notação de função regular para facilitar o teste.

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

VB / Basic-229

Meu objetivo era vencer 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

editar vbCr em vez de chr (13)

r = r + Espaço (3 - (e - b))

taquigrafia se

uso da função em vez de sub

sub MAIN () -> sub m ()

Java - 223 caracteres

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

Eu gostava dessa maneira de fazer isso, e então percebi que precisava de um pequeno hack, ainda como a minha solução.

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 bytes

Ainda não é muito competitivo, mas é um começo:

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

Exemplo de uso:

  `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 

Começo avaliando a string de entrada com .- felizmente, os números separados por espaço são uma lista válida literal em K. Ao incluir uma lista vazia no resultado de eval, posso garantir que seja uma lista, mesmo no caso de um único pino. Então eu crio um vetor booleano representando as posições dos pinos:

  (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

Então indexo em uma lista de strings para obter caracteres preenchidos com espaço para cada posição do pino.

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

Eu divido essa sequência em linhas ( _), inverto-as ( |) e uno cada fragmento ( ,/'):

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

Agora está começando a se parecer com o padrão que queremos. Tudo o que resta é juntar alguns espaços à esquerda em cada linha ( ((!4)#\:" "),') e imprimir as linhas em stdout ( 0:).

Pascal (FPC) , 165 bytes

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.

Experimente online!

Pega números da entrada padrão, imprime a formação na saída padrão.

Pascal (FPC) , 175 bytes

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;

Experimente online!

Uma função que faz a mesma coisa, assumindo uma matriz de posições de pinos e retornando uma string formatada.

Powershell, 84 bytes

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

Script de teste:

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

Resultado:

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 caracteres

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

Na primeira vez, tenho certeza de que é uma merda, mas sou um novato. Também funciona quando os números não são solicitados. A numeração está errada, mas não tenho tempo para descobrir como corrigi-la ...

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

entrada é fornecida por, java B 1 2 3 5 10por exemplo. A saída será então:

0 . . . 
 . 0 . 
  0 0 
   0 

Japt -Rx , 29 19 18 17 bytes

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

Tente

Explicação

                      :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