Twoim celem jest pokazanie sztuki ASCII formacji w kręgle z 10 pinami, gdzie pozostały tylko niektóre z pinów. Wygrywa najmniej bajtów.

Kołki dziesiątek mają trójkątny kształt:

O O O O         
 O O O   
  O O       
   O

Kołki są oznaczone od 1 do 10 jako:

7 8 9 10    
 4 5 6            
  2 3    
   1

Rysowanie szpilek jako Oi brakujących szpilek jako ., formacja 1 3 5 6 9 10jest:

. . O O         
 . O O    
  . O       
   O

Wejście:

Ciąg oddzielony spacjami, który wyświetla niepusty podzbiór liczb od 1 do 10 w kolejności.

Wynik:

Wydrukuj odpowiednią formację lub wyślij ją jako ciąg znaków z łamaniem linii.

Formacja powinna znajdować się na lewo od ekranu. Wszelkie białe znaki są poprawne, o ile widoczny obraz jest poprawny. Puste wiersze przed i po są również w porządku.

Przypadki testowe:

>> 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 bajtów

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

Zajęło mi to większą część dwóch dni. Myślę, że było warto. Prawdopodobnie są części, które można golfować bardziej, zmieniając komórkę, w której coś jest przechowywane, czy cokolwiek innego, ale teraz jestem szczęśliwy, że to działa.

Ten program musiałby być zupełnie inny, gdyby pytanie nie określało, że dane wejściowe zostaną posortowane. Działa to poprzez zbudowanie listy 10 pinów wokół tych, które są wprowadzane. To trochę mylące, ale może to lepiej to wyjaśni:

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]

Robiąc to, pamięta, które z pinów umieścił tam użytkownik, a które tam. Ta strategia byłaby bardzo trudna w użyciu, gdyby dane wejściowe nie były posortowane.

Kolejną rzeczą, która ułatwia sortowanie, jest wykrycie liczby 10. Ponieważ pieprzenie mózgu zajmuje się pojedynczymi bajtami, a nie „liczbami” jako takimi, mógł to być problem w dupie, ale posortowane dane wejściowe znacznie ułatwiły mi radzenie sobie z. Powodem tego jest sposób przechowywania danych w programie. Pobieram jeden znak naraz i odejmuję 32 od wyniku. Jeśli po tym komórka nie jest zerowa, przesuwam do przodu 4 komórki. przed powtórzeniem. Oznacza to, że co 4 komórki otrzymuję bajt niebędący spacją i skutecznie przechowuję piny jako ich liczbę + 16. Jednak 10 zajmuje dwa bajty na pisanie, więc musiałem to zrobić w specjalnym przypadku. Jeśli dane wejściowe nie zostały posortowane, musiałbym przejrzeć piny, ale ponieważ są posortowane, zawsze będzie to ostatni pin, jeśli się pojawi. Sprawdzam, czy (ostatni bajt wejścia + 1) == (drugi ostatni bajt danych wejściowych), a jeśli tak, to musi być 10. Pozbywam się ostatniego bajtu i ustawiam drugi ostatni na to, co mój system rozumie jako „10”. Postacie'1'i '0'nie mieszczą się w jednym bajcie, ale liczba 26 na pewno tak!

Wymyślanie sztuczek tylko po to, żeby coś w ogóle działało, jest moją ulubioną częścią używania tego języka. :)

Jeśli jesteś zainteresowany bardziej szczegółowym działaniem tego programu, możesz zobaczyć program z komentarzami, których użyłem podczas pisania, aby upewnić się, że pamiętam, co wszystko zrobiłem. Nawet pisanie komentarzy w przeróbce mózgu jest trudne, ponieważ nie ma składni komentarzy. Zamiast tego, każda postać oprócz tych w <[+.,-]>nie ma operacji. Łatwo jest wprowadzić błędy, przypadkowo włączając .lub ,w komentarzach! Właśnie dlatego gramatyka jest tak dziwna, a średniki są wszędzie.

EDYCJA: Jako przykład tego, jak łatwo to zepsuć: użyłem „spacji” w jednym z komentarzy! Kiedy usunąłem wszystkie znaki inne niż bf ze źródła, program, który kiedyś to robiłem, zachował się w -. Na szczęście nic nie zepsuło, ale teraz usunąłem go, aby zaoszczędzić bajt. :)

EDYCJA II: Minęło trochę czasu, odkąd go dotknąłem, haha. W innej odpowiedzi na temat pieprzenia mózgu na tej stronie zauważyłem, że przypadkowo użyłem przecinka w skomentowanej wersji. Ponieważ dane wejściowe zostały już wyczerpane, ustawiono bieżącą komórkę na 0 (jest to zależne od implementacji, ale z mojego doświadczenia wynika, że ​​jest to najczęstsze zachowanie). Naprawiłem błąd, ale przyszło mi to do głowy. Idiomatyczny sposób ustawienia komórki na 0 to [-](z grubsza while (*p) { *p--; }), który jest o dwa bajty dłuższy. Za każdym razem, gdy wszystkie dane wejściowe zostały odczytane, mogę ,zamiast tego użyć . To zaoszczędziło mi 2 bajty w tej odpowiedzi i 12 w tym!

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 bajtów

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

Zadzwoń z f("3 5 7 9 10").

ijest numerem wiersza, przy czym 4 oznacza pierwszy rząd, a 1 ostatni. zjest n-tym pinem w tym rzędzie, z 0 oznacza, że ​​jest to pierwszy pin w rzędzie i i-1oznacza, że ​​jest to ostatni pin w rzędzie.

Główny hack to i*~-i/2-~zkonwersja (i, z) -> pin number. Na przykład, (4, 0) -> 7ponieważ pin 7 jest pierwszym pinem w rzędzie 4 (pierwszy rząd). Wyprowadzenie wygląda następująco:

• Chcemy, aby funkcja przeniosła isię do pierwszego pinu w rzędzie i, tj 4 -> 7, 3 -> 4, 2 -> 2, 1 -> 1. Jest to spełnione przez (i**2-i)/2 + 1, a tym samym (i**2-i)/2 + 1 + zdaje prawidłowy numer pin dla wejścia(i, z)

• Następnie uprość:

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

Pyth , 33 bajty

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

Wypróbuj online.

Program z grubsza przekłada się na:

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

(Dzięki isaacg za wskazówki)

Pyth , 31

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

Wypróbuj tutaj .

V4 ustawia pętlę for, przy czym N jest zmienną powyżej [0,1,2,3].

*dNzapewnia początkowe spacje, ponieważ djest spacją.

Aby znaleźć lokalizacje pinów, używa +7+dZ- 7 + d + Z.

d jest:

0 1 2 3
 1 2 3
  2 3
   3

podczas gdy Zjest 0 w pierwszym wierszu, -4 w drugim, -7 w trzecim i -9 w czwartym. Dzieje się tak, ponieważ Zzaczyna się od 0 i ~Z-N4zmniejsza Zo 4, potem 3, a następnie 2.

Następnie sprawdza, czy lokalizacja pinu znajduje się na wejściu, za pomocą }+7+dZrz7. rz7jest pożądanymi pinami w formie listy-int.

Następnie tworzy, Ojeśli był obecny, i .inaczej. Jest to oddzielone spacją, z jdnadrukiem niejawnym.

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

Użycie rflagi, dla s///której jest jednym z ostatnich 5 dodatków perla.

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

CJam, 48 41 bajtów

Wow, to stało się strasznie długo

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

Sprawdź to tutaj.

Wyjaśnienie

Najpierw generujemy układ:

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

To daje

6 7 8 9
 3 4 5 
  1 2  
   0

A teraz zamieniamy cyfry zgodnie z wprowadzonymi danymi:

[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

Wykorzystuje to funkcję translacji, która pozwala na zamianę znaku na znak w ciągu. Jak tr w perlu, tyle że o wiele dłużej pisać. Otrzymuję listę cyfr dziesiętnych, tworząc ciąg od 9 do 99 potęgi.

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

Pierwszy golf może być prawdopodobnie krótszy.

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

Zadzwoń z

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

EDYTOWAĆ

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

EDYTOWAĆ

Wersja ES6, 79 nie działa

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

Wersja ES6, 72 77, brak alertu, po prostu wraca

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}

Po prostu zastępuje argumenty wiersza poleceń .s i 0si wypisuje je za pomocą pętli 4 cykli.

Wersja do odczytu

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

• Zaoszczędź 6 bajtów dzięki @Jordan.

Wynik obejmuje 1 dodatkowy dla -ropcji:

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

Wejście przez STDIN:

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

Wypróbuj online .

CJam, 40 39 bajtów

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

Wiem, że istnieje krótsza droga, nie mam teraz czasu, aby ją rozgryźć.

Jak to działa:

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

Wypróbuj online tutaj

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   

Wyjaśnienie:

• 17110357⊤⍨28/2: 28-bitowa reprezentacja 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
  

• \⍨: Dla każdego 0daj spację, a dla każdego 1weź przedmiot ze sznurka po lewej.

• ⎕∊⍨⍳10: Przeczytaj wiersz z klawiatury i oceń go ( ⎕), a następnie sprawdź każdą liczbę od 1 do 10 ( ⍳10), czy jest zawarta w input ( ∊⍨).
• '.O'[1+... ]: Dodaj 1 do każdej wartości (dając 1s i 2s zamiast 0 i 1s), a następnie zamieniaj co 1 o .i co 2 o O.
• 4 7⍴: zamień wygenerowany ciąg na matrycę 4 na 7
• ⊖: odwróć go w poziomie

PowerShell: 109

Dane wejściowe są w $ i

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

To było zabawne. Nauczyłem się również wielu rzeczy o tym, jak działa potok.

Haskell: 163 160 bajtów

To akceptuje linię liczb oddzielonych spacją 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

Nie golfowany:

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)

I bonus:

C: 250 bajtów

Ta wersja oczekuje, że argumentami wiersza poleceń będzie lista liczb.

#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

I głupie podejście premiowe, które się nie udało, 90 znaków:

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

Mathematica, 109 bajtów

Funkcjonować:

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

Nazwany przez:

f@"3 5 7 9 10"

Jeśli dozwolone są funkcje anonimowe, można to skrócić do 105 bajtów :

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

Jeśli dane wejściowe nie muszą być ciągiem rozdzielanym spacjami, ale mogą być tablicą liczb w formie {3,5,7,9,10}, można to dodatkowo skrócić do 79 bajtów :

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

Pure Bash (bez coreutils), 85

Prosta zamiana wzoru:

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

Lista jest wprowadzana za pomocą argumentów wiersza poleceń.

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

Nie golfowany:

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 bajtów

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

Sformatowany:

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

Oczekuje wprowadzania bez końcowego znaku nowej linii.

Wypróbuj online.

Taśma jest inicjowana za pomocą dziesięciu węzłów, z których każdy zawiera jeden, po którym następuje zero. Jeden jest początkową wartością pinezki, a zero ułatwia nawigację i działa jako symbol zastępczy znaku spacji. Dla każdej liczby na wejściu ten pin jest zwiększany o 3; zwróć uwagę, że ord('O') - ord('.') = 33podczas fazy drukowania wartość pinu zostanie pomnożona przez 11. (To zwielokrotnienie służy również do wygenerowania znaku spacji.) Kolejność pinów od lewej do prawej na taśmie jest po prostu 1do 10. Jeśli dane wejściowe kończą się na a 10, dokonywana jest korekta, ponieważ 10początkowo traktowane jest jako1 .

Po przetworzeniu danych wejściowych po każdym wierszu umieszcza się wartość ujemną. Następnie wiersze są drukowane w pętli, a liczba wiodących spacji zależy od liczby wcześniej przetworzonych wierszy.

Clojure, 216 znaków (ugh)

Jestem pewien, że można dalej grać w golfa.

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

Użyj w ten sposób:

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

AWK: 96 bajtów

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

Uwaga:

• Separatory spacji na wartości wejściowej są opcjonalne (ale w razie potrzeby działa również z nimi)
• Liczby nie muszą być w porządku
• Wejście jest odczytywane na STDIN

C # - 192 bajty

Ponieważ C #!

Zacząłem od zbudowania danych wyjściowych za pomocą matematyki, ale prosta metoda zastępowania tokenów w łańcuchach wydaje się najlepsza dla języków wyższego poziomu. Zależność Linq jest długa, ale wciąż krótsza niż utrzymywanie licznika i sprawdzanie zasięgu.

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

EDYCJA: zwraca uniksową linię (-3 bajty)

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)

Akceptuje rozdzielony spacjami zestaw ciągów znaków

JavaScript ES6, 78 bajtów

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

Aby przetestować, użyj następującego fragmentu kodu. Wykorzystuje podpowiedzi i alerty oraz regularną notację funkcji dla ułatwienia testowania.

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

VB / Basic-229

Moim celem było pokonanie 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

edytuj vbCr zamiast chr (13)

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

skrót, jeśli

użycie funkcji zamiast sub

sub MAIN () -> sub m ()

Java - 223 znaki

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

Kiedyś lubiłem ten sposób, ale potem zdałem sobie sprawę, że potrzebuję niewielkiego włamania, nadal trochę podobnego do mojego rozwiązania.

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 bajtów

Jeszcze niezbyt konkurencyjny, ale to początek:

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

Przykład użycia:

  `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 

Zaczynam od oceny ciągu wejściowego za pomocą .- na szczęście liczby oddzielone spacjami są poprawnym literałem listy w K. Przygotowując pustą listę do wyniku eval, mogę zapewnić, że jest to lista nawet w przypadku pojedynczego pinu. Następnie tworzę wektor boolowski reprezentujący pozycje pinów:

  (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

Następnie indeksuję listę ciągów znaków, aby uzyskać znaki z odstępami dla każdej pozycji pinezki.

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

Kroję tę sekwencję na wiersze ( _), odwracam je ( |) i łączę każdy fragment ( ,/'):

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

Teraz zaczyna wyglądać tak, jak chcemy. Pozostało tylko przyczepić się do niektórych wiodących spacji do każdego wiersza ( ((!4)#\:" "),') i wydrukować wiersze do stdout ( 0:).

Pascal (FPC) , 165 bajtów

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.

Wypróbuj online!

Pobiera liczby ze standardowego wejścia, drukuje formację na standardowe wyjście.

Pascal (FPC) , 175 bajtów

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;

Wypróbuj online!

Funkcja, która robi to samo, biorąc tablicę pozycji pinów i zwracając sformatowany ciąg.

PowerShell, 84 bajty

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

Skrypt testowy:

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

Wynik:

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 znaków

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

Po raz pierwszy robię to, jestem prawie pewien, że to gówno, ale jestem nowicjuszem. Działa również, gdy numery nie są uporządkowane. Numeracja jest nieprawidłowa, ale nie mam czasu, aby dowiedzieć się, jak to naprawić ...

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

dane wejściowe są podawane java B 1 2 3 5 10na przykład przez. Dane wyjściowe będą wówczas:

0 . . . 
 . 0 . 
  0 0 
   0 

Japt -Rx , 29 19 18 17 bajtów

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

Spróbuj

Wyjaśnienie

                      :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