Ваша цель - показать искусство 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. Поскольку мозговой трах имеет дело с отдельными байтами, а не с «числами» как таковыми, это могло быть болезненным задом, но отсортированный ввод сделал мне намного легче иметь дело с. Причина этого связана с тем, как я хранил данные в программе. Я беру ввод по одному символу за раз и вычитаю 32 из результата. Если после этого ячейка станет ненулевой, я продвигаюсь на 4 ячейки. перед повторением. Это означает, что я получаю непустой байт ввода каждые 4 ячейки, и я эффективно сохраняю выводы как их число + 16. Однако для ввода 10 требуется два байта, поэтому мне пришлось использовать его в особом случае. Если вход не был отсортирован, мне пришлось бы просматривать контакты, но поскольку он отсортирован, он всегда будет последним, если он появится. Я проверяю, является ли (последний байт ввода + 1) == (вторым последним байтом ввода), и если да, то должно быть 10. Я избавляюсь от последнего байта и устанавливаю второй последний на то, что моя система понимает как "10". Персонажи'1'и '0'не помещается в один байт, но число 26 точно подходит!

Придумывать трюки, чтобы заставить что-то работать, - моя любимая часть использования этого языка. :)

Если вас интересует, как эта программа работает более подробно, вы можете увидеть программу с комментариями, которые я использовал при ее написании, чтобы убедиться, что я вспомнил, что все делал. Даже писать комментарии в Brainfuck сложно, так как нет синтаксиса комментариев. Вместо этого, все персонажи, кроме тех, которые в не <[+.,-]>являются опа. Легко вносить ошибки, случайно включив .или ,в ваших комментариях! Вот почему грамматика такая шаткая, а точки с запятой везде.

РЕДАКТИРОВАТЬ: В качестве примера того, как это легко облажаться: я использовал "не пробел" в одном из комментариев! Когда я удалил все не-bf символы из источника, программа, которую я использовал для этого, сохранилась в -. К счастью, это ничего не сломало, но теперь я удалил его, чтобы сохранить байт. :)

РЕДАКТИРОВАТЬ II: Прошло много времени с тех пор, как я коснулся этого, ха-ха. В другом ответе о бреде на этом сайте я заметил, что я случайно использовал запятую в закомментированной версии. Поскольку ввод уже исчерпан, он устанавливает текущую ячейку на 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)))

(Спасибо Айзека за советы)

Пиф , 31

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

Попробуй это здесь .

V4 устанавливает цикл for с 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///которого является одним из последних дополнений Perl 5.

#!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.";

Python 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('')

РЕДАКТИРОВАТЬ

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

РЕДАКТИРОВАТЬ

Версия 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: Прочитайте строку с клавиатуры и оцените ее ( ⎕), затем проверьте для каждого числа от 1 до 10 ( ⍳10), содержится ли оно в input ( ∊⍨).
• '.O'[1+... ]: добавьте 1 к каждому значению (давая 1 и 2 вместо 0 и 1), а затем замените 1 на .2 и 2 на O.
• 4 7⍴: превратить сгенерированную строку в матрицу 4 на 7
• ⊖: перевернуть его горизонтально

Powershell: 109

Ввод в $ я

(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

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)

И бонус:

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

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

И глупый бонусный подход, который не удался, 90 символов:

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

Mathematica, 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&

Чистый bash (без coreutils), 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" "]

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 байтов

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

отформатирован:

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

Ожидается ввод без завершающей строки.

Попробуйте онлайн.

Лента инициализируется десятью узлами, каждый из которых содержит один, за которым следует ноль. Один является начальным значением булавки, а ноль облегчает навигацию и действует как заполнитель для символа пробела. Для каждого числа на входе этот вывод увеличивается на 3; обратите внимание, что ord('O') - ord('.') = 33во время фазы печати значение булавки будет умножено на 11. (Это умножение также используется для генерирования символа пробела.) Порядок выводов слева направо на ленте просто 1до 10. Если ввод оканчивается на a 10, выполняется коррекция, поскольку 10изначально он обрабатывается как a 1.

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

Clojure, 216 символов (тьфу)

Я уверен, что это может быть дальше.

(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 #!

Я начал пытаться построить вывод с помощью математики, но простой метод replace-tokens-in-string кажется лучшим для языков более высокого уровня. Зависимость 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);}}

РЕДАКТИРОВАТЬ: 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 ")

Я разрезаю эту последовательность на row ( _), инвертирую их ( |) и объединяю каждый фрагмент ( ,/'):

  ,/'|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