Ваша мета - відобразити ASCII мистецтво формації в десятиконтактному боулінгу, де залишаються лише деякі штифти. Виграє найменше байт.

Десятки шпильок мають трикутну формацію:

O O O O         
 O O O   
  O O       
   O

Штифти маркуються від 1 до 10 як:

7 8 9 10    
 4 5 6            
  2 3    
   1

Малюючи шпильки як Oі відсутні шпильки як ., форма 1 3 5 6 9 10:

. . O O         
 . O O    
  . O       
   O

Вхід:

Пробіл, розділений пробілом, містить список порожнього підмножини чисел 1, хоча й 10 у порядку.

Вихід:

Роздрукуйте відповідне утворення або виведіть його у вигляді рядка з рядковими розривами.

Форма повинна бути врівень з лівою частиною екрана. Будь-яке пробіл добре, якщо видиме зображення правильне. Порожні рядки до і після теж добре.

Тестові приклади:

>> 1 2 3 4 5 6 7 8 9 10

O O O O    
 O O O    
  O O    
   O

>> 7 10

O . . O    
 . . .   
  . .   
   .

>> 3 5 7 9 10

O . O O    
 . O .    
  . O    
   .

>> 1

. . . .    
 . . .    
  . .    
   O       

мозковий ебать - 617 616 604 байт

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

Це зайняло у мене краще два дні. Я думаю, це того варте. Напевно, є деталі, які можна більше пограти в гольф, змінивши, у якій клітці щось зберігається чи що завгодно, але зараз я просто щасливий, що я працював.

Ця програма мала б бути зовсім іншою, якби в питанні не було вказано, що вхід буде сортований. Як це працює, склавши список з 10 штифтів навколо тих, що вводяться. Це щось заплутано, але, можливо, це пояснить це краще:

If you input these pins:           [2, 3, 6, 8, 9]
First, the program does this:      [2, 3, 6, 8, 9] + [10]
Then this:                         [2, 3, 6] + [7] + [8, 9, 10]
Then this:                         [2, 3] + [4, 5] + [6, 7, 8, 9, 10]
Finally, this:                     [1] + [2, 3, 4, 5, 6, 7, 8, 9, 10]
To build this:                     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Хоча це робить, він запам'ятовує, який із штифтів користувач поставив туди та які їх поставив. Цю стратегію було б дуже важко використати, якби введення не було відсортовано.

Інша річ, що сортування полегшує, це виявлення числа 10. Оскільки brainfuck має справу з окремими байтами, а не з "числами", це могло бути болем у попці, але відсортований вклад значно полегшив мені справу з. Причина цього пов’язана з тим, як я зберігав дані в програмі. Я беру вхід один символ за один раз і віднімаю 32 від результату. Якщо комірка після цього не дорівнює нулю, я рухаюся вперед на 4 комірки. перед повторенням. Це означає, що я отримую непробільний байт введення кожні 4 комірки, і я ефективно зберігаю шпильки як їх кількість + 16. Однак 10 займає два байти, щоб набрати, тому мені довелося це робити окремо. Якщо введення не було відсортовано, я повинен був би переглядати шпильки, але оскільки він відсортований, він завжди буде останнім штифтом, якщо він з'явиться. Я перевіряю, чи (останній байт введення + 1) == (другий останній байт вводу), і якщо так, то він повинен бути 10. Я позбавляюсь останнього байта і встановлюю другий останній на те, що моя система розуміє як "10". Персонажі'1'і '0'не вміщуються в одному байті, але число 26 точно!

Створення хитрощів просто для того, щоб взагалі щось працювати - це моя улюблена частина використання цієї мови. :)

Якщо вас цікавить, як ця програма працює більш детально, ви можете побачити програму з коментарями, які я використовував під час її написання, щоб переконатися, що я запам'ятав, що все робив. Навіть писати коментарі в мозковому слові важко, оскільки немає синтаксису коментарів. Натомість кожен персонаж, за винятком тих, що <[+.,-]>знаходяться, не є. Вносити помилки легко, випадково включивши .або ,у ваші коментарі! Ось чому граматика така вибаглива, а крапки з комою є скрізь.

EDIT: Як приклад того, як легко це викрутити: я використав "непробіл" в одному з коментарів! Коли я знімав усі символи, що не належать до BF, у програмі, яку я раніше робив, зберігалася в -. На щастя, це нічого не зламало, але тепер я його видалив, щоб зберегти байт. :)

РЕДАКЦІЯ ІІ: Минув час, коли я торкнувся цього, ха-ха. В іншій відповіді на цей епізод на цьому сайті я помітив, що випадково використав кому у коментованій версії. Оскільки вхід вже вичерпано, він встановив поточну комірку 0 (це залежить від реалізації, але, на мій досвід, це найпоширеніша поведінка). Я виправив помилку, але це змусило задуматися. Ідіоматичний спосіб встановити комірку на 0 - це [-](приблизно while (*p) { *p--; }), що на два байти довше. Кожен раз, коли всі дані були прочитані, я можу використовувати ,замість цього. Це врятувало мені 2 байти у цій відповіді та 12 - у цій!

one flag at the very left; will be important later
+>>>>

all nonspace bytes of input separated by 3 empty cells; pin number `n` stored with value `n` plus 16
,[>++++[<-------->-]<[>>>>],]<<<<

test if last pin is 10
[>+<<+<+>>-]<[>+<-]+<+<<[>+>-<<-]>[<+>-]>

[
    if not: find 10 minus the number it is; put that many placeholder pins (cells with value 1) at the end
    ,+++++[>+++++<-]>>[<->-]<[>>>>>[>>>>]+[<<<<]<-]>>[<+>-]<<<
]>


[
    if so: get rid of '0' byte; convert '1' byte to 26 (10 plus 16)
    >>[,<]<<+++++++++<
]<<<

pointer now sitting on the cell with the second greatest pin that was inputted (ie not a placeholder)

;;;;;;;

[
    check for flag placed at the very beginning of the program; if present: break
    -[+>>-<]>
    [
        find ((pin to our right) minus 1) minus pin to our left
        move all pins left of us 4*(that value) cells and insert placeholder pins
        >>[<+<+>>-]<<<<[>+>-<<-]>[<+>-]>[<<[<<<<]>>>>[[<<<<+>>>>-]>>>>]<<<<+>>-]>[>+<-]
    ]

    find first non placeholder pin to our left
    there has to be one because we haven't hit the flag yet
    <<<[-[+>]+<<<<]>>>>-<<<<<
]>>>>>+

we have now added placeholder pins at the end and in the middle; all that's left is the beginning

subtract 17 from lowest pin and put that many placeholders to the left
++++[>----<-]>->[<+>>+<-]<[<<<[<<<<]+[>>>>]<-]>>[<+>-]

subtract 32 from an empty cell 2 to the left of the lowest pin; will be useful later
<[<<<<]>>>++++[<-------->-]>

placeholder pins have the value 1; real pins have a value somewhere between 17 and 26
normalize it by stepping through and setting every pin with value != 1 to 3 (0's ascii code is 2 higher than period so this will make it easier to print later)
[-[,+++>]+>>>[<<<->>]>]<<<<<[>-]>[>>]>>

start writing 32s across the board; hitting every second cell
that's every pin and the cell 2 to the right of each pin
this is done in such a way that it will only halt if adding 32 to a cell sets it to 0; which is why we subtracted 0 from an empty cell earlier
it will catch us and prevent an infinite loop
+[<++++[<++++++++>-]<]

now write 13 to each pin; this adds up to 46 or 48; which are exactly the ascii values we want
>>[+++++++++++++>>>>]

we happen to have made a 14; turn it into a 10 for a newline
<<<<----

we're so close now; i can taste it
we have a list of 10 pins; each one with the ascii value that needs to be written
we have 32 everywhere because we'll need spaces
we even have a newline

the only problem now is that our list looks like this:
;;;;;;;;;;;;;;;;;;;;;;;;
;;1 2 3 4 5 6 7 8 9 10;;
;;;;;;;;;;;;;;;;;;;;;;;;

and we need to print in this order:
;;;;;;;;;;;;;;;;;;;;;;;;
;;7 8 9 10 4 5 6 2 3 1;;
;;;;;;;;;;;;;;;;;;;;;;;;

it's a pretty simple fix
once we print a pin we obviously don't need to remember it any more
so we simply print the last 4 pins on the list; destroying them on the way
then we print the last 3; which have become the ones we want
then two; then one
<+++[<<+<<[<<+<<]+[>>>>]<<<<-]<<<<[-<<<<]

print pins 7 8 9 10
>[.,>>]

print pins 4 5 6
<<<<<[<<<<]<++++++++++<<.<+<<+<<+<<+<<+<[.,>>]

print pins 3 2
<<<<<[<<]>++++++++++<+<<+<<+<..<+<[.,>>]

print the final pin!! :)
<[<<]<...<<.

Python 2, 108 байт

def f(x):
 for i in 4,3,2,1:print" "*(4-i)+" ".join(".O"[i*~-i/2-~z in map(int,x.split())]for z in range(i))

Подзвоніть з f("3 5 7 9 10").

i- номер рядка, 4 - перший рядок, а 1 - останній. z- n-й штифт у цьому рядку, причому 0 означає, що це перший штифт у рядку, і i-1це означає, що це останній штифт у рядку.

Основний хак i*~-i/2-~z, який конвертує (i, z) -> pin number. Наприклад, (4, 0) -> 7як шпилька 7 є першим штифтом у рядку 4 (перший рядок). Виведення відбувається так:

• Ми хочемо , щоб функція приймає iдо першого штифта на рядку i, тобто 4 -> 7, 3 -> 4, 2 -> 2, 1 -> 1. Це задоволено (i**2-i)/2 + 1і, таким чином, (i**2-i)/2 + 1 + zдає правильний номер штифта для введення(i, z)

• Потім спростіть:

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

Pyth , 33 байти

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

Спробуйте в Інтернеті.

Програма орієнтовно перекладається на:

z = input()
Z = 0

for N in range(4):
  Z += 4-N
  print(" "*N + " ".join(".O"[d+11-Z in map(int, z.split())] for d in range(4-N)))

(Завдяки isaacg за поради)

Піта , 31

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

Спробуйте тут .

V4 встановлює a для циклу, з N як змінної понад [0,1,2,3].

*dNзабезпечує початкові пробіли, тому що dце простір.

Щоб знайти місця контактів, він використовує +7+dZ- 7 + d + Z.

d є:

0 1 2 3
 1 2 3
  2 3
   3

тоді Zяк 0 у першому рядку, -4 у другому, -7 у третьому та -9 у четвертому. Це Zпочинається з 0, а ~Z-N4зменшення Zна 4, потім 3, потім 2.

Потім він перевіряє, чи знаходиться штифт у вході, використовуючи }+7+dZrz7. rz7є бажаними штифтами у списку-за-формою.

Потім він створює, Oякщо він був присутній, .інакше. Це розділений простір jd, і надруковано неявно.

Perl 5: 51 (50 + 1 для -p)

Використовуючи rпрапор, s///який є одним із останніх 5-ти доповнень Perl.

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

CJam, 48 41 байт

Ого, це стало жахливо довго

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

Перевірте це тут.

Пояснення

Спочатку ми генеруємо макет:

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

Це дає

6 7 8 9
 3 4 5 
  1 2  
   0

А тепер заміняємо знаки цифр відповідно до введення:

[l~]                 "Read the input and turn it into an array of integers.";
    :(s              "Decrement each number and turn the array into a string of digits.";
       "O"           "Push this string.";
          er         "Character transliteration, replaces the input digits with O.";
            A,s      "Create the string '0123456789'.";
               "."   "Push this string.";
                  er "Character transliteration, replaces all remaining digits with periods.";

Пітон 2, 97 94

Для цього використовується функція перекладу, яка дозволяє проводити заміну символів для символів у рядку. Як і tr в perl, за винятком набагато довшого типу. Я отримую список десяткових цифр, роблячи рядок від 9 до 99-ї потужності.

lambda a:u"7890\n 456\n  23\n   1".translate({ord(n):u'.O'[n+' 'in a+' ']+' 'for n in`9**99`})

Javascript, 155

Перший гольф, можливо, може бути і коротшим.

function f(i){q='replace',s='7 8 9 0\n 4 5 6\n  2 3\n   1';alert(s[q](RegExp(i[q]('10','0')[q](/ /g,'|'),'g'),function(a){return a?'O':a})[q](/\d+/g,'.'))}

дзвінок з

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

EDIT

Версія 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,'.'))}

EDIT

Версія ES6, 79 виходить з ладу

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

Версія ES6, 72 77, без попередження, просто повертається

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

Рубі, 91

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

Просто заміняє аргументи командного рядка на .s і 0s і друкує їх, використовуючи цикл із 4 циклів.

Читаема версія

x = (1..10).map do |i|
  if i.to_s == ARGV[0]
    ARGV.shift
    "0"
  else
    "."
  end
end

4.times do |i|
  row = x.pop(4 - i)
  puts row.join(' ').center 8
end

GNU sed, 75

• Збережено 6 байт завдяки @Jordan.

Оцінка включає 1 додатковий -rваріант:

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

Введення через STDIN:

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

Спробуйте в Інтернеті .

CJam, 40 39 байт

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

Я знаю, що існує коротший шлях, не встигайте зараз це зрозуміти.

Як це працює:

4,Sf*'-A*[q~]{('ot}/3,{)/(\s}%Sf*W%]zN*
4,                                          "Get the array [0,1,2,3]";
  Sf*                                       "Covert each number to that many spaces to";
                                            "get ["", " ", "  ", "   "] array";
     '-A*                                   "String '----------'";
         [q~]                               "Input numbers in an array";
             {    }/                        "For each input number";
              ('ot                          "Put 'o' at the corresponding index";
                    3,                      "Array [0,1,2]";
                      {     }%              "For each of the above number";
                       )                    "Increment the number";
                        /                   "Split the string into pieces of that length";
                         (\s                "Take the first string and join the rest back";
                              Sf*           "Riffle each string in array with space";
                                 W%         "Reverse the array of strings";
                                   ]z       "Zip together the space array and this one";
                                     N*     "Join by new line";

Спробуйте його онлайн тут

APL (35)

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

Тест:

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

Пояснення:

• 17110357⊤⍨28/2: 28-бітове представлення 17110357:

        4 7⍴17110357⊤⍨28/2
  0 0 0 1 0 0 0
  0 0 1 0 1 0 0
  0 1 0 1 0 1 0
  1 0 1 0 1 0 1
  

• \⍨: Для кожного 0дайте пробіл, а для кожного 1візьміть предмет із рядка зліва.

• ⎕∊⍨⍳10: Прочитайте рядок з клавіатури та оцініть його ( ⎕), після чого перевірте, ⍳10чи не міститься він у вході ( ∊⍨) на кожне число від 1 до 10 ( ).
• '.O'[1+... ]: Додайте 1 до кожного значення (даючи 1s і 2s замість 0s і 1s), а потім замінюйте кожен 1 на .і кожний 2 на O.
• 4 7⍴: перетворіть створений рядок у матрицю 4 на 7
• ⊖: перевернути його по горизонталі

Потужність: 109

Вхід становить $ i

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

Це було весело. Дізнався купу речей про те, як працює трубопровід.

Haskell: 163 160 байт

Це приймає рядок розділених пробілами чисел від stdin.

m=map
y?x|x`elem`y="O "|0<1=". "
f y=putStr.unlines.zipWith(++)(m(`replicate`' ')[0..])$m(concat.m(y?))[[7..10],[4..6],[2,3],[1]]
main=getLine>>=f.m read.words

Безголівки:

layout :: [[Int]]
layout = [[7,8,9,10]
         ,[ 4,5,6  ]
         ,[  2,3   ]
         ,[   1    ]
         ]

indentBy :: Int -> String
indentBy n = replicate n ' '

indentLines :: [String] -> [String]
indentLines
  = zipWith (++)
            (map indentBy [0..])

bowling :: [Int] -> String
bowling pins
  = unlines
  . indentLines
  $ map (concatMap showPlace)
        layout
  where
    showPlace :: Int -> String
    showPlace index
      | index `elem` pins = "O "
      | otherwise         = ". "

parseInput :: String -> [Int]
parseInput = map read . words

main :: IO ()
main = do
  pins <- fmap parseInput getLine
  putStr (bowling pins)

І бонус:

C: 250 байт

Ця версія очікує, що аргументи командного рядка будуть списком чисел.

#define w int
main(w
z,char**a){w
b[10]={1,3,2,6,5,4,10,9,8,7};w
q=9;for(w
k=4;k>0;--k){w
i;for(i=0;i<4-k;++i)printf(" ");for(i=0;i<k;++i,--q){w
g=0;w
c;for(w
p=1;p<z;++p){sscanf(a[p],"%d",&c);g|=b[q]==c;}c=g?'O':'.';printf("%c ",c);}printf("\n");}}

Перл, 73

$_="7 8 9 10\n 4 5 6\n  2 3\n   1";for$v(<>=~/\d+/g){s/$v/O/g};s/\d+/./g;print

І бонусний підхід, який не вийшов, 90 символів:

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

Математика, 109 байт

Функція:

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

Викликано:

f@"3 5 7 9 10"

Якщо дозволені анонімні функції, це може бути скорочено до 105 байт :

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

Якщо введення не повинно бути рядком з обмеженим пробілом, але може бути масивом чисел у формі {3,5,7,9,10}, це може бути додатково скорочено до 79 байт :

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

Чистий баш (без ядер), 85

Проста заміна шаблону:

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

Список вводиться через аргументи командного рядка.

Ребол - 117

s: array/initial 10"."b:""foreach n to-block input[s/:n:"0"]for n 4 1 -1[prin b print take/last/part s n append b" "]

Безголівки:

s: array/initial 10 "."
b: ""
foreach n to-block input [s/:n: "0"]
for n 4 1 -1 [prin b print take/last/part s n append b " "]

Brainfuck, 179 байт

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

Відформатовано:

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

Очікує введення без зворотного нового рядка.

Спробуйте в Інтернеті.

Стрічка ініціалізується з десяти вузлів, кожен з яких містить по одному, за яким іде нуль. Один є початковим значенням штифта, а нуль полегшує навігацію і виступає як заповнювач символу пробілу. Для кожного числа на вході цей контакт збільшується на 3; відзначити , що ord('O') - ord('.') = 33і на етапі друку, значення PIN - код буде множитися на 11. (Це множення також використовується для створення символу пробілу.) Порядок штирів зліва направо на стрічці просто 1до 10. Якщо вхід закінчується символом a 10, робиться поправка, оскільки 10спочатку трактується як a 1.

Після обробки даних, після кожного рядка розміщується негативний. Потім рядки друкуються в циклі, при цьому кількість провідних пробілів визначається кількістю попередньо оброблених рядків.

Clojure, 216 символів (ugh)

Я впевнений, що це можна пограти в гольф далі.

(let[s(map #(dec(read-string %))(.split(slurp *in*)" +"))](println(apply str(replace(apply hash-map(interleave(map #(char(+ 48 %))(range 10))(map #(if(some #{%}s)"O"".")(range 10))))"6 7 8 9\n 3 4 5\n  1 2\n   0"))))

Використовуйте так:

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

AWK: 96 байт

{gsub(/ /,"");a="6 7 8 9\n 3 4 5\n  1 2\n   0";gsub("["$0"]","O",a);gsub(/[0-9]/,".",a);print a}

Примітка:

• Роздільники пробілів у вхідному значенні необов’язкові (але він також працює з ними у міру необхідності)
• Цифри не повинні бути в порядку
• Вхід зчитується на STDIN

C # - 192 байти

Тому що C #!

Я почав намагатися будувати результати з математики, але простий метод заміни лексеми в рядку здається найкращим для мов вищого рівня. Залежність від Linq довга, але все ж коротша, ніж зберігати лічильник і робити перевірку дальності.

using System.Linq;class A{static void Main(string[]a){var s=@"7 8 9 0
 4 5 6
  2 3
   1";for(int c=11;c-->1;)s=s.Replace((char)(48+c%10),a.Contains(""+c)?'O':'.');System.Console.Write(s);}}

EDIT: повернення рядка Unix (-3 байти)

Скала, 150 148

def t(n:Any)=("G H I J D E F   B C     A"/:('A'to'J'))((j,i)=>j.replace(i,(if((n+" ").indexOf((i-64)+" ")>=0)'0'else'.'))).grouped(7).maxBy(println)

Приймає набір рядків з обмеженим простором

JavaScript ES6, 78 байт

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

Використовуйте наступний фрагмент для тестування. Для зручності тестування використовуються підказки та сповіщення та регулярні позначення функцій.

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

VB / Basic-229

Моєю метою було побити java ^^

Dim f
Sub m()
f = " 1 2 3 4 5 6 7 8 9 10"
a = l(7, 10) + l(4, 6) + l(2, 3) + l(1, 1)
MsgBox a
End Sub
Function l(b, e)
r = Space(3 - (e - b))
For i = b To e
r = r + IIf(InStr(f, Str(i)), "0 ", ". ")
Next
l = r + vbCr
End Function

редагувати vbCr замість chr (13)

r = r + пробіл (3 - (e - b))

скорочення, якщо

використання функції замість суб

sub MAIN () -> sub m ()

Ява - 223 символів

public class Pins {public static void main(String[] args) {String s = "7 8 9 0\n 4 5 6\n  2 3\n   1";for (String arg : args) {s = s.replace(arg.replace("10", "0"), "o");}s = s.replaceAll("\\d", ".");System.out.println(s);}}

Мені раніше подобався такий спосіб робити це, тоді я зрозумів, що мені потрібен невеликий злом, як і раніше, як моє рішення.

public class Pins {
public static void main(String[] args) {
    String s = "7 8 9 0\n 4 5 6\n  2 3\n   1";
    for (String arg : args) {
        s = s.replace(arg.replace("10", "0"), "o");
    }
    s = s.replaceAll("\\d", ".");
    System.out.println(s);
}
}

К, 57 байт

Ще не дуже конкурентоспроможний, але це початок:

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

Приклад використання:

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

Я починаю з оцінки вхідного рядка з .- на щастя, розділені пробілами цифри є дійсним літеральним списком у K. Заздалегідь додаючи порожній список до результату eval, я можу переконатися, що це список навіть у випадку одного штиря. Потім я створюю бульний вектор, що представляє позиції штифтів:

  (1+!10)=/:3 5 7 9 10
(0 0 1 0 0 0 0 0 0 0
 0 0 0 0 1 0 0 0 0 0
 0 0 0 0 0 0 1 0 0 0
 0 0 0 0 0 0 0 0 1 0
 0 0 0 0 0 0 0 0 0 1)
  |/(1+!10)=/:3 5 7 9 10
0 0 1 0 1 0 1 0 1 1

Потім я індексую в список рядків, щоб отримати символи з пробілом для кожної позиції шпильки.

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

Я розрізаю цю послідовність на рядки ( _), повертаю їх назад ( |) і з'єдную кожен фрагмент ( ,/'):

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

Тепер він починає виглядати так, як ми хочемо. Залишилося лише позначити провідні пробіли до кожного рядка ( ((!4)#\:" "),') та надрукувати рядки до stdout ( 0:).

Паскаль (FPC) , 165 байт

var f:string='. . . .'#10' . . .'#10'  . .'#10'   .';i:byte;z:array[1..10]of byte=(25,18,20,10,12,14,1,3,5,7);begin repeat read(i);f[z[i]]:='O'until eof;write(f)end.

Спробуйте в Інтернеті!

Бере числа зі стандартного вводу, друкує формацію на стандартний вихід.

Паскаль (FPC) , 175 байт

function f(q:array of byte):string;var i:byte;z:array[1..10]of byte=(25,18,20,10,12,14,1,3,5,7);begin f:='. . . .'#10' . . .'#10'  . .'#10'   .';for i in q do f[z[i]]:='O'end;

Спробуйте в Інтернеті!

Функція, яка робить те саме, займаючи масив положень штифтів і повертаючи відформатовану рядок.

Powershell, 84 байти

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

Тестовий сценарій:

$f = {

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

}

# one space at the end of each line with pins
@(
,("1 2 3 4 5 6 7 8 9 10",
@"
O O O O 
 O O O 
  O O 
   O 
"@)

,("7 10",
@"
O . . O 
 . . . 
  . . 
   . 
"@)

,("3 5 7 9 10",
@"
O . O O 
 . O . 
  . O 
   . 
"@)

,("1",
@"
. . . . 
 . . . 
  . . 
   O 
"@)
) | % {
    $s, $expected = $_
    $result = &$f $s
    $result-eq$expected
    $result
}

Вихід:

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

Ява - 371 316 294 символів

public class Bowling{public static void main(String[] a){boolean[] o=new boolean[10];int i;for(String s:a){i=Integer.parseInt(s)-1;o[i]=true;}for(int j=9;j>=0;j--){p((o[j]?"0 ":". "));p(j==6?"\n ":"");p(j==3?"\n  ":"");p(j==1?"\n   ":"");}p("\n");}static void p(String l){System.out.print(l);}}

Перший раз це роблю, я майже впевнений, що це гавно, але я новачок. Він також працює, коли номери не впорядковані. Нумерація неправильна, але я не встигаю дізнатися, як це виправити ...

public class Bowling {
    public static void main(String[] args) {
        boolean[] ordened = new boolean[10];
        int i;
        for (String s : args) {
            i = Integer.parseInt(s) - 1;
            ordened[i] = true;
        }
        for (int j = 9; j >= 0; j--) {
            p((ordened[j] ? "0 " : ". "));
            p(j == 6 ? "\n " : "");
            p(j == 3 ? "\n  " : "");
            p(j == 1 ? "\n   " : "");
        }
        p("\n");
    }
    static void p(String l){
        System.out.print(l);
    }
}

введення подається, java B 1 2 3 5 10наприклад. Вихідним результатом буде:

0 . . . 
 . 0 . 
  0 0 
   0 

Japt -Rx , 29 19 18 17 байт

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

Спробуй це

Пояснення

                      :Implicit input of integer array U
5Ç                    :Map each Z in the range [0,5)
  Æ                   :  Map the range [0,Z)
          °T          :    Increment T (initially 0)
        Uø            :    Does U contain T? (false=0, true=1)
   ".O"g              :    Get the character in the string ".O" at that index
            Ã         :  End mapping
             ¸        :  Join with spaces
              Ã       :End mapping
               Ô      :Reverse
                û     :Centre pad each element with spaces to the length of the longest
                      :Implicitly join with newlines, trim (not strictly necessary) and output