Il tuo obiettivo è quello di visualizzare l'arte ASCII di una formazione nel bowling a dieci pin dove rimangono solo alcuni dei pin. Vince il minor numero di byte.

I perni delle decine hanno una formazione triangolare:

O O O O         
 O O O   
  O O       
   O

I pin sono etichettati da 1 a 10 come:

7 8 9 10    
 4 5 6            
  2 3    
   1

Puntine da disegno Oe puntine mancanti come ., la formazione 1 3 5 6 9 10è:

. . O O         
 . O O    
  . O       
   O

Ingresso:

Una stringa separata da spazio che elenca un sottoinsieme non vuoto dei numeri da 1 a 10 in ordine.

Produzione:

Stampa la formazione corrispondente o stampala come stringa con interruzioni di riga.

La formazione dovrebbe essere a filo con la parte sinistra dello schermo. Qualsiasi spazio bianco va bene purché l'immagine visibile sia corretta. Anche le righe vuote prima e dopo vanno bene.

Casi test:

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

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

Questo mi ha portato la parte migliore di due giorni. Penso che ne sia valsa la pena. Probabilmente ci sono parti che possono essere giocate di più cambiando in quale cella è memorizzato qualcosa o qualunque cosa, ma in questo momento sono solo felice di averlo fatto funzionare.

Questo programma dovrebbe essere completamente diverso se la domanda non specifica che l'input verrà ordinato. Il modo in cui funziona è costruendo un elenco di 10 pin attorno a quelli che vengono inseriti. È un po 'confuso, ma forse questo lo spiegherà meglio:

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]

Mentre lo fa, ricorda quale dei pin l'utente ha messo lì e quali ha messo lì. Questa strategia sarebbe molto difficile da usare se l'input non fosse ordinato.

Un'altra cosa che semplifica l'ordinamento è il rilevamento del numero 10. Dato che brainfuck si occupa di singoli byte, non di "numeri" di per sé, avrebbe potuto essere un dolore nel culo, ma l'input ordinato ha reso molto più facile per me gestire con. La ragione di ciò ha a che fare con il modo in cui ho archiviato i dati nel programma. Prendo l'input di un carattere alla volta e sottraggo 32 dal risultato. Se la cella è diversa da zero dopo, mi sposto in avanti di 4 celle. prima di ripetere. Ciò significa che ricevo un byte di spazio non spaziale ogni 4 celle e in effetti memorizzo i pin come numero + 16. Tuttavia, 10 richiede due byte per digitare, quindi ho dovuto fare un caso speciale. Se l'input non è stato ordinato, dovrei guardare attraverso i pin, ma dato che è ordinato sarà sempre l'ultimo pin se appare. Controllo se (l'ultimo byte di input + 1) == (il secondo ultimo byte di input) e, in tal caso, deve essere 10. Mi libero dell'ultimo byte e imposto il secondo ultimo su ciò che il mio sistema comprende "10". I personaggi'1'e '0'non rientrano in un singolo byte, ma sicuramente il numero 26 lo fa!

Venire con i trucchi solo per far funzionare qualcosa è la mia parte preferita dell'uso di questo linguaggio. :)

Se sei interessato a come funziona questo programma in modo più dettagliato, puoi vedere il programma con i commenti che ho usato durante la scrittura per assicurarmi di ricordare cosa ha fatto tutto. Anche scrivere commenti in brainfuck è difficile, dal momento che non c'è sintassi dei commenti. Invece, tutti i personaggi tranne quelli in <[+.,-]>non sono operazioni. È facile introdurre bug includendo accidentalmente .o ,nei tuoi commenti! Ecco perché la grammatica è così traballante e i punti e virgola sono ovunque.

EDIT: Come esempio di quanto sia facile rovinare tutto: ho usato "non-spazio" in uno dei commenti! Quando ho rimosso tutti i caratteri non bf dalla fonte, il programma che ho usato per farlo è rimasto nel -. Fortunatamente non ha rotto nulla, ma ora l'ho rimosso per salvare un byte. :)

EDIT II: È passato un po 'di tempo da quando ho toccato questo, haha. In un'altra risposta brainfuck su questo sito, ho notato che ho usato accidentalmente una virgola nella versione commentata. Poiché l'input era già stato esaurito, imposta la cella corrente su 0 (dipende dall'implementazione, ma nella mia esperienza è il comportamento più comune). Ho corretto l'errore, ma mi ha fatto pensare. Il modo idiomatico di impostare una cella su 0 è [-](approssimativamente while (*p) { *p--; }), che è più lungo di due byte. Ogni volta che tutti gli input sono stati letti, posso usare ,invece. Questo mi ha salvato 2 byte in quella risposta e 12 in questo!

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

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

iè il numero di riga, con 4 come prima riga e 1 come ultima. zè l'ennesimo pin di quella riga, con 0 che significa che è il primo pin della riga e che i-1significa che è l'ultimo pin della riga.

L'hack principale è i*~-i/2-~z, che converte (i, z) -> pin number. Ad esempio, (4, 0) -> 7poiché il pin 7 è il primo pin sulla riga 4 (la prima riga). La derivazione va così:

• Vogliamo una funzione che porti ial primo pin sulla riga i, ad es 4 -> 7, 3 -> 4, 2 -> 2, 1 -> 1. Ciò è soddisfatto (i**2-i)/2 + 1e quindi (i**2-i)/2 + 1 + zfornisce il numero pin corretto per l'ingresso(i, z)

• Quindi semplifica:

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

Pyth , 33 byte

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

Provalo online.

Il programma si traduce approssimativamente in:

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

(Grazie a isaacg per i suggerimenti)

Pyth , 31

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

Provalo qui .

V4 imposta un ciclo for, con N come variabile su [0,1,2,3].

*dNfornisce gli spazi iniziali, perché dè spazio.

Per trovare la posizione dei pin, utilizza +7+dZ- 7 + d + Z.

d è:

0 1 2 3
 1 2 3
  2 3
   3

mentre Zè 0 nella prima riga, -4 nella seconda, -7 nella terza e -9 nella quarta. Questo perché Zinizia come 0 e ~Z-N4diminuisce Zdi 4, quindi 3, quindi 2.

Quindi, controlla se la posizione del pin è nell'input, usando }+7+dZrz7. rz7è i pin desiderati in forma di elenco di int.

Quindi crea un Oif se era presente e in caso .contrario. Questo è spazio separato, con jde stampato implicitamente.

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

Utilizzo di rflag per il s///quale è una delle recenti aggiunte perl 5.

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

CJam, 48 41 byte

Wow, è diventato orribilmente lungo

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

Provalo qui.

Spiegazione

Innanzitutto generiamo il layout:

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

Questo cede

6 7 8 9
 3 4 5 
  1 2  
   0

E ora sostituiamo i caratteri delle cifre in base all'input:

[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

Questo utilizza la funzione di traduzione, che consente di effettuare sostituzioni carattere per carattere in una stringa. Come tr in perl, tranne molto più a lungo da digitare. Ottengo un elenco di cifre decimali creando una stringa da 9 alla 99a potenza.

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

Primo golf, probabilmente può essere più breve.

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

chiama con

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

MODIFICARE

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

MODIFICARE

Versione ES6, 79 non riesce

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

Versione ES6, 72 77, nessun avviso, ritorna

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}

Semplicemente sostituisce gli argomenti della riga di comando con .s e 0s e stampe utilizzando un ciclo di 4 cicli.

Versione leggibile

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

• 6 byte salvati grazie a @Jordan.

Il punteggio include 1 extra per -ropzione:

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

Ingresso tramite STDIN:

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

Provalo online .

CJam, 40 39 byte

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

So che c'è un modo più breve, non ho tempo di capirlo adesso.

Come funziona:

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

Provalo online qui

APL (35)

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

Test:

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

Spiegazione:

• 17110357⊤⍨28/2: la rappresentazione a 28 bit di 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
  

• \⍨: Per ogni 0, dai uno spazio e per ogni1 , prendi un oggetto dalla stringa a sinistra.

• ⎕∊⍨⍳10: Leggi una riga dalla tastiera e valutala ( ⎕), quindi controlla ogni numero compreso tra 1 e 10 ( ⍳10) indipendentemente dal fatto che sia contenuto o meno nell'input (∊⍨ ).
• '.O'[1+... ]: aggiungi 1 a ogni valore (dando 1 e 2 invece di 0 e 1), quindi sostituisci ogni 1 con .ogni 2 conO .
• 4 7⍴: trasforma la stringa generata in una matrice 4 per 7
• ⊖: capovolgi orizzontalmente

Powershell: 109

L'input è in $ i

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

È stato divertente. Ho anche imparato un sacco di cose su come funziona la pipeline.

Haskell: 163 160 byte

Questo accetta una linea di numeri separati da spazio 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 un bonus:

C: 250 byte

Questa versione prevede che i suoi argomenti della riga di comando siano l'elenco di numeri.

#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 un approccio bonus sciocco che non ha funzionato, 90 personaggi:

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

Mathematica, 109 byte

Funzione:

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

Chiamato da:

f@"3 5 7 9 10"

Se sono consentite funzioni anonime, ciò può essere ridotto a 105 byte :

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

Se l'input non deve essere una stringa delimitata da spazi, ma potrebbe essere un array di numeri nel modulo {3,5,7,9,10}, questo può essere ulteriormente ridotto a 79 byte :

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

Bash puro (no coreutils), 85

Semplice sostituzione del motivo:

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

L'elenco viene inserito tramite gli arg della riga di comando.

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 byte

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

formattato:

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

Prevede input senza una nuova riga finale.

Provalo online.

Il nastro viene inizializzato con dieci nodi, ognuno dei quali contiene uno seguito da uno zero. Quello è il valore iniziale del pin e lo zero facilita la navigazione e funge da segnaposto per il personaggio dello spazio. Per ogni numero nell'input, quel pin viene incrementato di 3; notare che ord('O') - ord('.') = 33, e durante la fase di stampa, il valore del perno verrà moltiplicato per 11. (Questa moltiplicazione viene anche utilizzata per generare il carattere dello spazio). L'ordine dei pin da sinistra a destra sul nastro è semplicemente 1fino a 10. Se l'input termina con a 10, viene eseguita una correzione, poiché il10 inizialmente viene trattata come a1 .

Dopo che l'input è stato elaborato, uno negativo viene inserito dopo ogni riga. Quindi le righe vengono stampate in un ciclo, con il numero di spazi iniziali determinato dal numero di righe precedentemente elaborate.

Clojure, 216 caratteri (ugh)

Sono sicuro che questo può essere ulteriormente migliorato.

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

Usa così:

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}

Nota:

• I separatori di spazi sul valore di input sono opzionali (ma funziona anche con essi come richiesto)
• I numeri non devono essere in ordine
• L'ingresso viene letto su STDIN

C # - 192 byte

Perché C #!

Ho iniziato cercando di creare l'output con la matematica, ma il semplice metodo di sostituzione dei token nella stringa sembra il migliore per linguaggi di livello superiore. La dipendenza da Linq è lunga ma ancora più breve rispetto a tenere un contatore e fare controlli di distanza.

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: ritorna riga 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)

Accetta set di stringhe delimitati da spazi

JavaScript ES6, 78 byte

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

Utilizzare il frammento seguente per testare. Utilizza prompt e avvisi e notazione delle funzioni regolari per facilitare i test.

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

VB / Basic-229

Il mio obiettivo era battere 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

modifica vbCr invece di chr (13)

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

stenografia se

uso della funzione anziché del sub

sub MAIN () -> sub m ()

Java - 223 caratteri

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

Mi piaceva questo modo di farlo, poi mi sono reso conto che avevo bisogno di un piccolo trucco, ancora un po 'come la mia soluzione.

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

Non ancora molto competitivo, ma è un inizio:

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

Esempio di utilizzo:

  `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 

Comincio valutando la stringa di input con .- fortunatamente, i numeri separati da spazio sono un elenco valido letterale in K. Anticipando un elenco vuoto al risultato di eval posso garantire che sia un elenco anche nel caso di un singolo pin. Quindi creo un vettore booleano che rappresenta le posizioni dei pin:

  (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

Quindi indicizzo un elenco di stringhe per ottenere caratteri riempiti di spazio per ogni posizione del perno.

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

Divido quella sequenza in righe ( _), li inverto ( |) e unisco ogni frammento ( ,/'):

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

Ora sta iniziando a sembrare il modello che vogliamo. Non resta che virare su alcuni spazi iniziali per ogni riga ( ((!4)#\:" "),') e stampare le righe su stdout ( 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.

Provalo online!

Prende i numeri dall'input standard, stampa la formazione sull'output standard.

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;

Provalo online!

Una funzione che fa la stessa cosa, prendendo una serie di posizioni dei pin e restituendo una stringa formattata.

Powershell, 84 byte

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

Script di prova:

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

Produzione:

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 caratteri

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 prima volta che lo faccio, sono abbastanza sicuro che sia una merda, ma sono un principiante. Funziona anche quando i numeri non sono ordinati. La numerazione è sbagliata ma non ho tempo per scoprire come risolverlo ...

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

l'input è dato java B 1 2 3 5 10per esempio. L'output sarà quindi:

0 . . . 
 . 0 . 
  0 0 
   0 

Japt -Rx , 29 19 18 17 byte

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

Provalo

Spiegazione

                      :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