Su objetivo es mostrar el arte ASCII de una formación en bolos donde solo quedan algunos de los bolos. Pocos bytes ganan.

Los pines de decenas están en una formación triangular:

O O O O         
 O O O   
  O O       
   O

Los pines están etiquetados del 1 al 10 como:

7 8 9 10    
 4 5 6            
  2 3    
   1

Chinchetas como Oy alfileres faltantes como ., la formación 1 3 5 6 9 10es:

. . O O         
 . O O    
  . O       
   O

Entrada:

Una cadena separada por espacios que enumera un subconjunto no vacío de los números del 1 al 10 en orden.

Salida:

Imprima la formación correspondiente o envíela como una cadena con saltos de línea.

La formación debe estar al ras con la izquierda de la pantalla. Cualquier espacio en blanco está bien siempre que la imagen visible sea correcta. Las líneas vacías antes y después también están bien.

Casos de prueba:

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

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

Esto me llevó la mayor parte de dos días. Creo que valió la pena. Probablemente hay partes que se pueden jugar más al cambiar en qué celda se almacena algo o lo que sea, pero en este momento estoy feliz de que funcione.

Este programa tendría que ser completamente diferente si la pregunta no especificara que la entrada se ordenaría. La forma en que esto funciona es mediante la construcción de una lista de 10 pines alrededor de los que se ingresan. Eso es un poco confuso, pero tal vez esto lo explique mejor:

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]

Mientras hace eso, recuerda cuáles de los pines puso el usuario allí y cuáles puso allí. Esta estrategia sería muy difícil de usar si la entrada no estuviera ordenada.

Otra cosa que facilita la clasificación es la detección del número 10. Dado que Brainfuck trata con bytes individuales, no con "números" per se, podría haber sido una molestia, pero la entrada clasificada me facilitó mucho el trato. con. La razón de eso tiene que ver con cómo almacené los datos en el programa. Tomo la entrada un carácter a la vez y resta 32 del resultado. Si la celda no es cero después de eso, avanzo 4 celdas. antes de repetir Esto significa que obtengo un byte de entrada no espacial cada 4 celdas, y almaceno efectivamente los pines como su número + 16. Sin embargo, 10 toma dos bytes para escribir, así que tuve que ponerlo en mayúsculas y minúsculas. Si la entrada no fue ordenada, tendría que mirar a través de los pines, pero dado que está ordenada, siempre será el último pin si aparece. Verifico si el (último byte de entrada + 1) == (el segundo último byte de entrada) y si es así, debe ser 10. Me deshago del último byte y configuro el segundo último a lo que mi sistema entiende como "10". Los caracteres'1'y '0'no caben en un solo byte, ¡pero el número 26 sí!

Crear trucos para hacer que algo funcione es mi parte favorita de usar este lenguaje. :)

Si está interesado en cómo funciona este programa con más detalle, puede ver el programa con los comentarios que usé mientras lo escribía para asegurarse de recordar lo que hizo todo. Incluso escribir comentarios en brainfuck es difícil, ya que no hay sintaxis de comentarios. En cambio, todos los personajes, excepto los de adentro, <[+.,-]>son no operativos. ¡Es fácil introducir errores al incluirlos accidentalmente .o ,en sus comentarios! Es por eso que la gramática es tan inestable y los puntos y comas están en todas partes.

EDITAR: Como ejemplo de lo fácil que es arruinarlo: ¡utilicé "no espacio" en uno de los comentarios! Cuando eliminé todos los caracteres que no son bf de la fuente, el programa que solía hacer se mantuvo en el -. Por suerte no rompió nada, pero ahora lo he eliminado para guardar un byte. :)

EDITAR II: Ha pasado un tiempo desde que toqué este, jaja. En otra respuesta mental en este sitio, noté que accidentalmente usé una coma en la versión comentada. Como la entrada ya se había agotado, estableció la celda actual en 0 (esto depende de la implementación, pero en mi experiencia es el comportamiento más común). Arreglé el error, pero me hizo pensar. La forma idiomática de establecer una celda en 0 es [-](aproximadamente while (*p) { *p--; }), que es dos bytes más larga. Cada vez que se ha leído toda la entrada, puedo usarla ,. ¡Esto me ahorró 2 bytes en esa respuesta y 12 en esta!

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

Llamada con f("3 5 7 9 10").

ies el número de fila, siendo 4 la primera fila y 1 la última. zes el enésimo pin de esa fila, con 0 significa que es el primer pin de la fila y i-1significa que es el último pin de la fila.

El truco principal es i*~-i/2-~z, que convierte (i, z) -> pin number. Por ejemplo, (4, 0) -> 7como el pin 7 es el primer pin en la fila 4 (la primera fila). La derivación es así:

• Queremos una función que lleve ial primer pin de la fila i, es decir 4 -> 7, 3 -> 4, 2 -> 2, 1 -> 1. Esto lo satisface (i**2-i)/2 + 1y, por lo tanto, (i**2-i)/2 + 1 + zproporciona el número de pin correcto para la entrada(i, z)

• Luego simplifica:

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

Pyth , 33 bytes

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

Pruébalo en línea.

El programa se traduce aproximadamente a:

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

(Gracias a Isaac por los consejos)

Pyth , 31

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

Pruébalo aquí .

V4 configura un bucle for, con N como la variable sobre [0,1,2,3].

*dNproporciona los espacios iniciales, porque des espacio.

Para encontrar las ubicaciones de los pines, utiliza +7+dZ- 7 + d + Z.

d es:

0 1 2 3
 1 2 3
  2 3
   3

mientras que Zes 0 en la primera línea, -4 en la segunda, -7 en la tercera y -9 en la cuarta. Esto se debe a que Zcomienza como 0 y ~Z-N4disminuye Zen 4, luego en 3 y luego en 2.

Luego, verifica si la ubicación del pin está en la entrada, usando }+7+dZrz7. rz7son los pines deseados en forma de lista de int.

Luego, crea un Osi estaba presente, y de lo .contrario. Este es un espacio separado, con jd, e impreso implícitamente.

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

Usando rflag para el s///cual es una de las adiciones recientes de perl 5.

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

CJam, 48 41 bytes

Wow, esto se hizo terriblemente largo

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

Pruébalo aquí.

Explicación

Primero generamos el diseño:

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

Esto produce

6 7 8 9
 3 4 5 
  1 2  
   0

Y ahora reemplazamos los caracteres de dígitos de acuerdo con la 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.";

Pitón 2, 97 94

Esto utiliza la función de traducción, que le permite a uno hacer sustituciones de carácter por carácter en una cadena. Como tr en perl, excepto que es mucho más largo para escribir. Obtengo una lista de dígitos decimales haciendo una cadena del 9 al 99 de potencia.

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

Primer golf, probablemente puede ser más corto.

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

llamar con

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

EDITAR

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

EDITAR

Versión ES6, 79 falla

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

Versión ES6, 72 77, sin alerta, solo regresa

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}

Simplemente sustituye los argumentos de la línea de comando con .sy 0s, y los imprime usando un ciclo de 4 ciclos.

Versión legible

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 gracias a @Jordan.

La puntuación incluye 1 extra para la -ropción:

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

Entrada a través de STDIN:

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

Pruébalo en línea .

CJam, 40 39 bytes

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

Sé que hay un camino más corto, no tengo tiempo para resolverlo en este momento.

Cómo 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";

Pruébalo en línea aquí

APL (35)

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

Prueba:

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

Explicación:

• 17110357⊤⍨28/2: la representación 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 cada 0, dé un espacio, y para cada 1, tome un elemento de la cadena de la izquierda.

• ⎕∊⍨⍳10: Lea una línea desde el teclado y evalúela ( ⎕), luego verifique para cada número del 1 al 10 ( ⍳10) si está contenida o no en la entrada (∊⍨ ).
• '.O'[1+... ]: Agregue 1 a cada valor (dando 1s y 2s en lugar de 0s y 1s), y luego reemplace cada 1 por .y cada 2 porO .
• 4 7⍴: convierte la cadena generada en una matriz de 4 por 7
• ⊖: voltéalo horizontalmente

Powershell: 109

La entrada está en $ i

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

Eso fue divertido. También aprendí un montón de cosas sobre cómo funciona la tubería.

Haskell: 163 160 bytes

Esto acepta una línea de números separados por espacios 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

Sin golf:

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)

Y una bonificación:

C: 250 bytes

Esta versión espera que sus argumentos de línea de comando sean la 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

Y un enfoque extra tonto que no funcionó, 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

Función:

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

Llamado por:

f@"3 5 7 9 10"

Si se permiten funciones anónimas, esto se puede acortar a 105 bytes :

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

Si la entrada no tiene que ser una cadena delimitada por espacios, pero podría ser una matriz de números en el formulario {3,5,7,9,10}, esto se puede acortar aún más a 79 bytes :

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

Pure bash (sin coreutils), 85

Reemplazo de patrón simple:

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

La lista se ingresa a través de los argumentos de la línea de comandos.

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

Sin golf:

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

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

Formateado:

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

Espera entrada sin una nueva línea final.

Pruébalo en línea.

La cinta se inicializa con diez nodos, cada uno de los cuales contiene uno seguido de un cero. El uno es el valor inicial del pin, y el cero facilita la navegación y actúa como marcador de posición para el carácter de espacio. Para cada número en la entrada, ese pin se incrementa en 3; tenga en cuenta que ord('O') - ord('.') = 33, y durante la fase de impresión, el valor del pin se multiplicará por 11. (Esta multiplicación también se utiliza para generar el carácter de espacio). El orden de los pines de izquierda a derecha en la cinta es simplemente 1hasta 10. Si la entrada termina con a 10, se realiza una corrección, ya 10que inicialmente se trata como un1 .

Después de que la entrada ha sido procesada, se coloca una negativa después de cada fila. Luego, las filas se imprimen en un bucle, con el número de espacios iniciales determinado por el número de filas procesadas previamente.

Clojure, 216 caracteres (ugh)

Estoy seguro de que esto se puede jugar más.

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

Usar así:

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:

• Los separadores de espacios en el valor de entrada son opcionales (pero también funciona con ellos según sea necesario)
• Los números no tienen que estar en orden
• La entrada se lee en STDIN

C # - 192 bytes

Porque C #!

Comencé tratando de construir el resultado con matemáticas, pero el método simple replace-tokens-in-string parece mejor para lenguajes de nivel superior. La dependencia de Linq es larga pero aún más corta que mantener un contador y hacer comprobaciones de rango.

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

EDITAR: retornos de línea 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)

Acepta un conjunto de cadenas delimitadas por espacios

JavaScript ES6, 78 bytes

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

Use el siguiente fragmento para probar. Utiliza avisos y alertas y notación de funciones regulares para facilitar las pruebas.

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

VB / Basic-229

Mi objetivo era vencer a 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 en lugar de chr (13)

r = r + espacio (3 - (e - b))

taquigrafía si

uso de la función en lugar de sub

sub PRINCIPAL () -> 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);}}

Solía ​​gustarme esta forma de hacerlo, luego me di cuenta de que necesitaba un pequeño truco, todavía algo así como mi solución.

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

Todavía no es muy competitivo, pero es un comienzo:

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

Ejemplo 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 

Comienzo evaluando la cadena de entrada con .: afortunadamente, los números separados por espacios son una lista literal válida en K. Al anteponer una lista vacía al resultado de eval, puedo asegurarme de que es una lista incluso en el caso de un solo pin. Luego creo un vector booleano que representa las posiciones de los pines:

  (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

Luego indexo en una lista de cadenas para obtener caracteres con espacio para cada posición de pin.

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

Corté esa secuencia en filas ( _), las invertí ( |) y uní cada fragmento ( ,/'):

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

Ahora está empezando a parecerse al patrón que queremos. Todo lo que queda es agregar algunos espacios iniciales a cada fila ( ((!4)#\:" "),') e imprimir las filas en 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.

Pruébalo en línea!

Toma números de la entrada estándar, imprime la formación a la salida estándar.

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;

Pruébalo en línea!

Una función que hace lo mismo, toma una matriz de posiciones de pin y devuelve una cadena formateada.

Powershell, 84 bytes

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

Script de prueba:

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

Salida:

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

La primera vez que hago esto, estoy bastante seguro de que es una mierda, pero soy un novato. También funciona cuando los números no están ordenados. La numeración es incorrecta, pero no tengo tiempo para averiguar cómo solucionarlo ...

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

la entrada está dada por, java B 1 2 3 5 10por ejemplo. La salida será entonces:

0 . . . 
 . 0 . 
  0 0 
   0 

Japt -Rx , 29 19 18 17 bytes

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

Intentalo

Explicación

                      :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