당신의 목표는 일부 핀만 남아 있는 10 핀 볼링 에서 포메이션의 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를 뺍니다. 그 후 셀이 0이 아닌 경우 4 셀 앞으로 이동합니다. 반복하기 전에. 즉, 4 셀마다 공백이 아닌 바이트의 입력을 받고 핀을 숫자 + 16으로 효과적으로 저장합니다. 그러나 10은 입력하는 데 2 ​​바이트가 걸리므로 특수한 경우가 필요했습니다. 입력이 정렬되지 않은 경우 핀을 살펴 봐야하지만 정렬되어 있기 때문에 그것이 나타날 경우 항상 마지막 핀이됩니다. (입력의 마지막 바이트 + 1) == (입력의 마지막 두 번째 바이트)인지 확인하고 그렇다면 10이어야합니다. 마지막 바이트를 제거하고 마지막 두 번째 바이트를 시스템이 이해하는 것으로 설정합니다. "10". 캐릭터'1'그리고 '0'단일 바이트에 맞게, 그러나 수 (26)은 확인하지 않아!

무언가를 작동시키기위한 요령을 생각해내는 것이이 언어를 사용하는 데있어 제가 가장 좋아하는 부분입니다. :)

이 프로그램이 어떻게 작동하는지에 관심이 있다면, 프로그램을 작성할 때 사용한 주석과 함께 프로그램을보고 모든 일을 기억했는지 확인할 수 있습니다. 주석 구문이 없기 때문에 brainfuck로 주석을 작성하는 것조차 어렵습니다. 대신에있는 캐릭터를 제외한 모든 캐릭터 <[+.,-]>는 작전이 아닙니다. 귀하의 의견 을 실수로 포함 .시키거나 포함시켜 버그를 쉽게 소개 ,할 수 있습니다! 이것이 문법이 너무 까다 롭고 세미콜론이 도처에있는 이유입니다.

편집 : 이것이 얼마나 쉬운 짓의 예입니다 : 나는 의견 중 하나에 "비 공간"을 사용했습니다! 소스에서 비 bf 문자를 모두 제거했을 때, 내가 사용했던 프로그램은에서 유지되었습니다 -. 운 좋게도 아무것도 깨지 않았지만 이제는 바이트를 절약하기 위해 제거했습니다. :)

편집 II : 이 하나를 만진 지 오래되었습니다. 하하. 이 사이트의 또 다른 brainfuck 답변에서 실수로 주석이 달린 버전에서 쉼표를 사용했음을 알았습니다. 입력이 이미 소진되었으므로 현재 셀을 0으로 설정했습니다 (구현에 따라 다르지만 내 경험상 가장 일반적인 동작입니다). 버그를 수정했지만 생각이 듭니다. 셀을 0으로 설정하는 관용적 방법은 [-]대략 while (*p) { *p--; }2 바이트입니다. 모든 입력을 읽을 때마다 ,대신 사용할 수 있습니다 . 이것은 그 대답에서 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!! :)
<[<<]<...<<.

파이썬 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 N을 [0,1,2,3]에 대한 변수로 사용하여 for 루프를 설정합니다.

*dN공간이므로 초기 공간을 제공합니다 d.

핀 위치를 찾으려면 +7+dZ-7 + d + Z를 사용합니다.

d 입니다 :

0 1 2 3
 1 2 3
  2 3
   3

동시에 Z첫 번째 행에 0, -4 초에서, 제 -7 및 -8 앞뒤로한다. 이것은 Z0으로 시작 하고 4, 3, 2로 ~Z-N4감소하기 때문 Z입니다.

그런 다음을 사용하여 핀 위치가 입력에 있는지 확인합니다 }+7+dZrz7. rz7in-int 형식의 원하는 핀입니다.

그런 다음 O존재 하는 경우, .그렇지 않으면 생성합니다. 이 공간은으로 구분 jd되어 암시 적으로 인쇄됩니다.

펄 5:51 (50 + 1 -p)

최근 perl 5 추가 중 하나 인 r플래그 사용 s///.

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

이것은 변환 함수를 사용하여 문자열에서 문자를 문자로 대체 할 수 있습니다. 입력하는 데 훨씬 더 긴 것을 제외하고 perl의 tr과 같습니다. 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`})

자바 스크립트, 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

• @Jordan 덕분에 6 바이트를 절약했습니다.

점수는 -r옵션에 대한 추가 1을 포함합니다 :

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)가 입력에 포함되어 있는지 확인하십시오 ( ∊⍨).
• '.O'[1+... ]: 모든 값에 1을 더한 다음 (0과 1 대신 1과 2를 부여) 1을 1 .씩 2 씩 바꿉니다 O.
• 4 7⍴: 생성 된 문자열을 4x7 행렬로 변환
• ⊖: 가로로 뒤집습니다

파워 쉘 : 109

입력은 $ i입니다

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

재미있었습니다. 파이프 라인의 작동 방식에 대해서도 많은 것을 배웠습니다.

하스켈 : 163160 바이트

공백으로 구분 된 숫자를에서 허용합니다 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&

입력이 공백으로 구분 된 문자열 일 필요는 없지만 형식의 숫자 배열 일 수있는 경우 79 바이트{3,5,7,9,10} 로 단축 될 수 있습니다 .

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

순수 배쉬 (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" "]

언 골프 드 :

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 바이트

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

형식화 :

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

후행 줄 바꿈없이 입력을 예상합니다.

온라인으로 사용해보십시오.

테이프는 10 개의 노드로 초기화되며 각 노드에는 1이 있고 그 뒤에 0이 있습니다. 하나는 핀의 초기 값이며, 0은 탐색을 용이하게하고 공백 문자의 자리 표시 자 역할을합니다. 입력의 각 숫자에 대해 해당 핀은 3 씩 증가합니다. 점에 유의 ord('O') - ord('.') = 33하고, 상기 인쇄 단계에서, 상기 핀의 값은 단순히 (이 승산은 또한 공백 문자를 생성하기 위해 사용된다.) 테이프를 왼쪽에서 오른쪽으로 핀의 순서 11을 곱한 것 1까지 10. 입력이로 끝나는 경우 처음에가로 취급 10되므로 수정이 이루어집니다 .101

입력이 처리 된 후 각 행 다음에 음수가 입력됩니다. 그런 다음 행은 루프로 인쇄되며 선행 공백 수는 이전에 처리 된 행 수에 의해 결정됩니다.

클로저, 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 #!

수학으로 출력을 만들려고 시도했지만 문자열에서 간단한 토큰 교체 방법이 고급 언어에 가장 적합합니다. 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);}}

편집 : 유닉스 라인 반환 (-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)

공백으로 구분 된 문자열 세트를 허용합니다.

자바 스크립트 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 / 기본 -229

내 목표는 자바를이기는 것이 었습니다 ^^

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

chr (13) 대신 vbCr 편집

r = r + 스페이스 (3-(e-b))

속기

서브 대신 기능 사용

하위 MAIN ()-> 하위 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);
}
}

K, 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의 유효한 목록 리터럴입니다. 평가 결과에 빈 목록을 추가하면 단일 핀의 경우에도 목록임을 확인할 수 있습니다. 그런 다음 핀의 위치를 ​​나타내는 부울 벡터를 만듭니다.

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

온라인으로 사용해보십시오!

핀 위치 배열을 가져 와서 형식화 된 문자열을 반환하는 동일한 기능을 수행하는 함수입니다.

파워 쉘, 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