Amacınız ASCII'nin bir oluşum sanatını, sadece pinlerin bir kısmının kaldığı on iğneli bowlingde sergilemektir . En az bayt kazanır.

Onlarca iğne üçgen şeklindedir:

O O O O         
 O O O   
  O O       
   O

Pimler 1 ile 10 arasında etiketlenmiştir:

7 8 9 10    
 4 5 6            
  2 3    
   1

Çizim pimleri Ove eksik pimler ., formasyon 1 3 5 6 9 10:

. . O O         
 . O O    
  . O       
   O

Giriş:

Sırasıyla 1 ile 10 arasındaki sayıların boş olmayan bir alt kümesini listeleyen boşlukla ayrılmış bir dize.

Çıktı:

İlgili formasyonu yazdırın veya satır çizgileri olan bir dize olarak çıktı alın.

Formasyon ekranın soluyla aynı hizada olmalıdır. Görünür resim doğru olduğu sürece herhangi bir boşluk yeterlidir. Boş satırları öncesi ve sonrası da iyi.

Test durumları:

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

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

Bu beni iki günün daha iyi bir parçası aldı. Bence buna değdi. Muhtemelen bir şeyde hangi hücrede saklanan hücreyi değiştirerek daha fazla golf oynayabilecek kısımlar vardır, ama şu anda çalışmasından dolayı mutluyum.

Soru, girdinin sıralanacağını belirtmediyse, bu programın tamamen farklı olması gerekecektir. Bunun işleyişi, girilenlerin etrafına 10 iğneli bir liste oluşturmaktır. Bu biraz kafa karıştırıcı ama belki bu daha iyi açıklar:

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]

Bunu yaparken, kullanıcının oraya hangi iğne koyduğunu, hangisinin oraya koyduğunu hatırlar. Girdi sıralanmamışsa, bu stratejiyi kullanmak çok zor olurdu.

Sıralamanın kolaylaştırdığı bir başka şey de 10 sayısının tespitidir. Brainfuck bireysel baytlarla ilgilendiği için "sayılar" değil, eşek için bir acı olabilirdi, ancak sıralanan girdi benim başa çıkmamı çok kolaylaştırdı. ile. Bunun nedeni, verileri programda nasıl sakladığımla ilgili. Girişte bir karakter alırım ve sonuçtan 32 çıkarırım. Hücre bundan sonra sıfır değilse, 4 hücreyi ileri doğru hareket ettiririm. tekrar etmeden önce. Bu, her 4 hücrede girdi olmayan bir boşluk baytı elde ettiğim ve pinleri + 16 gibi etkili bir şekilde sakladığım anlamına gelir. Girdi sıralanmadıysa, pinlere bakmak zorunda kalırdım, ancak sıralandığından beri her zaman son pin olacak. (+ 1 girişinin son baytı) == (girişin ikinci son baytı) olup olmadığını kontrol ettim ve öyleyse 10 olmalı. Son bayttan kurtulup ikinci sonuncuyu da sistemimin anladığı şekilde ayarlayın. "10". Karakterler'1've '0'tek bir bayta sığmıyor, ancak 26 sayısı kesin!

Sadece bir şeyler yapmak için püf noktaları ile gelmek, bu dili kullanmanın en sevdiğim yanı. :)

Bu programın nasıl daha ayrıntılı olarak çalışmasıyla ilgileniyorsanız, programı, her şeyin ne yaptığını hatırladığımdan emin olmak için yazarken kullandığım yorumlar ile birlikte görebilirsiniz. Yorum yazarken bile beyin fırtınasıyla yorum yazmak bile zordur. Bunun yerine, içinde olanlar hariç her karakter <[+.,-]>op-op değildir. Yanlışlıkla yorumlarınıza .veya ,yorumlarınıza hatalar eklemek kolaydır ! Bu yüzden dilbilgisi çok garip ve noktalı virgüller her yerde.

EDIT: Bunun berbat olmasının kolay bir örneği olarak: yorumlardan birinde "boşluksuz" kullandım! Tüm bf olmayan karakterleri kaynaktan çıkardığımda, bunu programda tutardım -. Neyse ki hiçbir şey kırmadı, ama şimdi bir bayt kurtarmak için kaldırdım. :)

EDIT II: Bir süredir buna dokunduğumdan beri haha. Bu sitedeki başka bir beyefendi cevabında, yorumlanan versiyonda yanlışlıkla virgül kullandığımı fark ettim. Girdi zaten tükenmiş olduğundan, mevcut hücreyi 0 olarak ayarlayın (bu uygulamaya bağlıdır, ancak benim tecrübeme göre en yaygın davranış budur). Böceği düzelttim ama beni düşündürdü. Bir hücreyi 0 olarak ayarlamak için deyimsel yol [-](kabaca while (*p) { *p--; }), ki iki bayt daha uzun. Tüm girdiler okunduğunda, ,onun yerine kullanabilirim . Bu bana bu cevabı 2 bayt, bu cevabında 12 bayt kazandırdı!

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 bayt

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

İle ara f("3 5 7 9 10").

iSatır sayısı 4, ilk satır, 1 ise son sayıdır. zbu satırdaki nth pin, 0 ise satırdaki ilk pin ve satırdaki i-1son pin.

Ana kesmek, i*~-i/2-~zdönüştüren (i, z) -> pin number. Örneğin, (4, 0) -> 7pim 7 olarak 4. satırdaki ilk pimdir (ilk satır). Türev şöyle gider:

• Biz bir işlev alarak istediğiniz isatırda ilk pin iyani 4 -> 7, 3 -> 4, 2 -> 2, 1 -> 1. Bu, tatmin edicidir (i**2-i)/2 + 1ve bu nedenle (i**2-i)/2 + 1 + zgirdi için doğru pin numarasını verir.(i, z)

• Ardından sadeleştirin:

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

Pyth , 33 bayt

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

Çevrimiçi deneyin.

Program kabaca çevirir:

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

(İpuçları için isaacg için teşekkürler)

Pyth , 31

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

Burada dene .

V4 değişkeni olarak N ile [0,1,2,3] arasında bir for döngüsü kurar.

*dNboşluk sağlar çünkü başlangıçtaki boşlukları sağlar d.

Pin konumlarını bulmak için kullanır +7+dZ- 7 + d + Z.

d dır-dir:

0 1 2 3
 1 2 3
  2 3
   3

ise Zilk sırada 0, -4 ikinci, -7 üçüncü ve -9 forth in. Bu durum Z0 ile başlar ve 4, ardından 3 ve 2 ile ~Z-N4düşer Z.

Ardından, kullanarak pin konumunun girişte olup olmadığını kontrol eder }+7+dZrz7. rz7int listesindeki istenen pinlerdir.

Ardından, Omevcut olup olmadığını, .aksi takdirde oluşturur. Bu, boşlukla ayrılmış jdve örtülü olarak basılmıştır.

Perl 5: 51 (50 + 1 için -p)

Son 5 perl eklemesinden biri olan rbayrak kullanma s///.

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

CJam, 48 41 bayt

Vay canına, bu çok uzun sürdü

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

Burada test et.

açıklama

İlk önce düzeni oluşturuyoruz:

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

Bu verim

6 7 8 9
 3 4 5 
  1 2  
   0

Şimdi rakam karakterlerini girişe göre değiştiriyoruz:

[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

Bu, bir karakter dizisinde karakter yerine karakter değişimi yapabilmeyi sağlayan çeviri işlevini kullanır. Yazmak için çok uzun süre hariç perl'deki tr gibi. 9'dan 99'uncu güce kadar bir dize yaparak ondalık basamakların bir listesini alıyorum.

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

İlk golf, muhtemelen daha kısa olabilir.

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

ile ara

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

DÜZENLE

ES6 sürümü, 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,'.'))}

DÜZENLE

ES6 sürümü, 79 başarısız

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

ES6 sürümü, 72 77, uyarı yok, sadece geri dönüyor

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}

Komut satırı argümanlarını .s ve 0s ile değiştirir ve bunları 4 çevrimli bir döngü kullanarak yazdırır.

Okunabilir sürüm

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 sayesinde 6 bayt kaydedildi.

Puan -rseçeneği için 1 ekstra içerir :

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

STDIN ile giriş:

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

Çevrimiçi deneyin .

CJam, 40 39 bayt

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

Bunun daha kısa bir yolu olduğunu biliyorum, şimdi anlamaya vaktiniz yok.

Nasıl çalışır:

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

Burada çevrimiçi deneyin

APL (35)

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

Ölçek:

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

Açıklama:

• 17110357⊤⍨28/2: 28-bit gösterimi 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
  

• \⍨: Her biri 0için bir boşluk bırakın ve her biri 1için soldaki dizgiden bir öğe alın.

• ⎕∊⍨⍳10: Klavyeden bir satır okuyun ve değerlendirin ( ⎕), daha sonra her sayı için 1 ile 10 arasında bir sayı ⍳10olup olmadığını kontrol edin ( ∊⍨).
• '.O'[1+... ]: Her değere 1 ekleyin (0s ve 1s yerine 1s ve 2s verin) ve ardından her 1'i .ve 2'yi değiştirin O.
• 4 7⍴: oluşturulan dizeyi 4'e 7'lik bir matrise dönüştür
• ⊖: yatay çevir

Powershell: 109

Giriş $ i cinsinden

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

Bu eğlenceliydi. Boru hattının nasıl çalıştığı hakkında da bir sürü şey öğrendim.

Haskell: 163 160 bayt

Bu sayılardan ayrılmış bir boşluk satırı kabul eder 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)

Ve bir bonus:

C: 250 bayt

Bu sürüm, komut satırı argümanlarının sayı listesi olmasını bekler.

#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

Ve 90 karakterden oluşan panofy bonusu yaklaşımı:

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

Mathematica, 109 bayt

İşlev:

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

Denilen:

f@"3 5 7 9 10"

Anonim işlevlere izin verilirse, bu 105 bayta kısaltılabilir :

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

Girdi, boşlukla sınırlandırılmış bir dize olmak zorunda değilse, ancak formdaki bir sayı dizisi olabilirse {3,5,7,9,10}, bu 79 bayta daha da kısaltılabilir :

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

Saf bash (çekirdek çekirdek yok), 85

Basit desen değiştirme:

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

Liste, komut satırı argümanları üzerinden girilir.

Rebol - 117

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

Ungolfed:

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

Brainfuck, 179 bayt

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

biçimlendirilmiş:

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

Sondaki yeni satır olmadan girişi bekler.

Çevrimiçi deneyin.

Bant, her biri bir tane sıfıra sahip olan on düğümle başlatılır. Bir tanesi pimin başlangıç ​​değeridir ve sıfır gezinmeyi kolaylaştırır ve boşluk karakteri için bir yer tutucu görevi görür. Girişteki her sayı için bu pim 3 artırılır; unutmayın ord('O') - ord('.') = 33ve baskı aşamasında, iğnelerin değeri basitçe (Bu çarpma ayrıca boşluk karakteri oluşturmak için kullanılır.) kasete soldan sağa pimleri sırası 11 ile çarpılır 1kadar 10. Girdi a ile bitiyorsa , başlangıçta a olarak kabul edildiğinden bir 10düzeltme yapılır .101

Giriş işlendikten sonra, her satırdan sonra negatif bir satır yerleştirilir. Ardından, satırlar daha önce işlenen satır sayısı tarafından belirlenen ana boşluk sayısı ile birlikte bir döngü halinde yazdırılır.

Clojure, 216 karakter (ugh)

Bunun daha fazla golf oynayabileceğine eminim.

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

Bunun gibi kullanın:

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

AWK: 96 bayt

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

Not:

• Giriş değerindeki boşluk ayırıcılar isteğe bağlıdır (ancak gerektiğinde onlarla da çalışır)
• Sayılar sırayla olmak zorunda değil
• Giriş STDIN'de okunur

192 bayt

Çünkü C #!

Çıktıyı matematikle oluşturmaya başladım, ancak basit string-to-string-in-string yöntemi daha yüksek seviyeli diller için en iyisi gibi görünüyor. Linq bağımlılığı uzuncadır ancak hala bir sayaç tutmaktan ve aralık kontrolleri yapmaktan daha kısadır.

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 satır döndürür (-3 bayt)

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)

Boşluğu sınırlı dizge kümesini kabul eder

JavaScript ES6, 78 bayt

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

Test etmek için aşağıdaki pasajı kullanın. Test kolaylığı için istemleri ve uyarıları ve düzenli işlev gösterimini kullanır.

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

VB / Temel-229

Amacım Java'yı yenmek oldu ^^

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

düzenlemek vbCr yerine of chr (13)

r = r + Boşluk (3 - (e - b))

kısaca

alt yerine işlev kullanımı

alt MAIN () -> alt m ()

Java - 223 karakter

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

Eskiden böyle yapmayı severdim, sonra çözümüm gibi bir küçük kesmeye ihtiyacım olduğunu fark ettim.

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 bayt

Henüz çok rekabetçi değil, ama bu bir başlangıç:

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

Kullanım örneği:

  `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 

Giriş dizesini değerlendirerek başlıyorum .- neyse ki boşlukla ayrılmış sayılar K'da geçerli bir listedir. Değerlendirmenin sonucuna boş bir liste hazırlayarak tek bir pin durumunda bile bir liste olduğundan emin olabilirim. Sonra pimlerin pozisyonlarını temsil eden bir boolean vektörü yaratıyorum:

  (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

Sonra her pim pozisyonu için boşlukla doldurulmuş karakterleri elde etmek için dizgelerin listesine indekslerim.

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

Bu diziyi satırlara ( _) bölüyorum, onları tersine ( |) ve her bir parçayı ( ,/') birleştiriyorum:

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

Şimdi istediğimiz kalıba benzemeye başladı. Geriye kalan tek şey, her satıra ( ((!4)#\:" "),') giden bazı satır boşluklarını sıralamak ve satırları stdout'a ( 0:) yazdırmak .

Pascal (FPC) , 165 bayt

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.

Çevrimiçi deneyin!

Standart girdiden sayıları alır, formasyonu standart çıktıya yazdırır.

Pascal (FPC) , 175 bayt

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;

Çevrimiçi deneyin!

Aynı şeyi yapan, bir dizi pin konumu alan ve biçimlendirilmiş bir dize döndüren bir işlev.

Powershell, 84 bayt

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

Test komut dosyası:

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

Çıktı:

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 karakter

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

Bunu ilk defa yaptığımda, bunun boktan olduğuna eminim, ama acemi biriyim. Ayrıca numaralar sipariş edilmediğinde de çalışır. Numaralandırma yanlış ama nasıl düzelteceğimi bulmak için zamanım yok ...

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

giriş java B 1 2 3 5 10örneğin tarafından verilir . Çıktı daha sonra olacak:

0 . . . 
 . 0 . 
  0 0 
   0 

Japt -Rx , 29 19 18 17 bayt

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

Dene

açıklama

                      :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