Ihr Ziel ist es, ASCII-Kunst einer Formation beim Bowling mit zehn Stiften anzuzeigen, bei der nur einige der Stifte übrig bleiben. Wenigste Bytes gewinnt.

Die Zehnerpins haben eine dreieckige Formation:

O O O O         
 O O O   
  O O       
   O

Die Pins sind von 1 bis 10 wie folgt beschriftet:

7 8 9 10    
 4 5 6            
  2 3    
   1

Ziehstifte als Ound fehlende Stifte als ., die Formation 1 3 5 6 9 10ist:

. . O O         
 . O O    
  . O       
   O

Eingang:

Eine durch Leerzeichen getrennte Zeichenfolge, die eine nicht leere Teilmenge der Nummern 1 bis 10 in der angegebenen Reihenfolge auflistet.

Ausgabe:

Drucken Sie die entsprechende Formation aus oder geben Sie sie als Zeichenfolge mit Zeilenumbrüchen aus.

Die Formation sollte mit der linken Seite des Bildschirms bündig sein. Alle Leerzeichen sind in Ordnung, solange das sichtbare Bild korrekt ist. Leerzeilen davor und danach sind ebenfalls in Ordnung.

Testfälle:

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

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

Das hat mich fast zwei Tage gekostet. Ich denke, es hat sich gelohnt. Es gibt wahrscheinlich Teile, die man besser spielen kann, wenn man ändert, in welcher Zelle etwas gespeichert ist oder was auch immer, aber im Moment bin ich einfach froh, dass es funktioniert.

Dieses Programm müsste völlig anders sein, wenn die Frage nicht angibt, dass die Eingabe sortiert werden soll. Die Art und Weise, wie dies funktioniert, besteht darin, eine Liste von 10 Stiften um die eingegebenen Stifte herum zu erstellen. Das ist etwas verwirrend, aber vielleicht wird es dadurch besser erklärt:

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]

Dabei merkt es sich, welche Pins der Benutzer dort abgelegt hat und welche dort abgelegt wurden. Diese Strategie wäre sehr schwierig anzuwenden, wenn die Eingabe nicht sortiert wäre.

Eine andere Sache, die das Sortieren erleichtert, ist das Erkennen der Nummer 10. Da es sich bei Brainfuck um einzelne Bytes und nicht um "Zahlen" an sich handelt, hätte es ein Ärgernis sein können, aber die sortierte Eingabe hat es mir viel leichter gemacht, damit umzugehen mit. Der Grund dafür hat damit zu tun, wie ich Daten im Programm gespeichert habe. Ich nehme die Eingabe jeweils um ein Zeichen und subtrahiere 32 vom Ergebnis. Wenn die Zelle danach nicht Null ist, gehe ich 4 Zellen vorwärts. vor dem Wiederholen. Dies bedeutet, dass ich alle 4 Zellen ein Nicht-Leerzeichen-Byte an Eingaben erhalte und Pins effektiv als Nummer + 16 speichere. Für die Eingabe von 10 werden jedoch zwei Bytes benötigt, weshalb ich es in Sonderfällen tun musste. Wenn der Eingang nicht sortiert wäre, müsste ich die Stifte durchsehen, aber da er sortiert ist, ist er immer der letzte Stift, wenn er angezeigt wird. Ich überprüfe, ob das (letzte Byte der Eingabe + 1) == (das vorletzte Byte der Eingabe) ist und wenn ja, muss es 10 sein. Ich werde das letzte Byte los und setze das vorletzte auf das, was mein System versteht "10". Die Charaktere'1'und '0'passen nicht in ein einziges Byte, aber die Nummer 26 tut es auf jeden Fall!

Tricks auszudenken, um etwas überhaupt zum Laufen zu bringen, ist mein Lieblingsteil bei der Verwendung dieser Sprache. :)

Wenn Sie daran interessiert sind, wie dieses Programm im Detail funktioniert, können Sie das Programm mit den Kommentaren anzeigen, die ich beim Schreiben verwendet habe, um sicherzustellen, dass ich mich an alles erinnere, was es getan hat. Selbst das Schreiben von Kommentaren in Brainfuck ist schwierig, da es keine Kommentarsyntax gibt. Stattdessen sind alle Charaktere außer denen in <[+.,-]>No-Ops. Es ist einfach, Fehler einzufügen, indem Sie versehentlich .oder ,in Ihre Kommentare aufnehmen! Deshalb ist die Grammatik so wackelig und Semikolons sind überall.

EDIT: Als Beispiel dafür, wie einfach es ist, Fehler zu machen: Ich habe in einem der Kommentare "Nicht-Leerzeichen" verwendet! Als ich alle Nicht-BF-Zeichen aus dem Quellcode entfernt habe, wurde das Programm, mit dem ich das gemacht habe, im beibehalten -. Zum Glück hat es nichts kaputt gemacht, aber jetzt habe ich es entfernt, um ein Byte zu speichern. :)

EDIT II: Es ist schon eine Weile her, seit ich dieses berührt habe, haha. In einer anderen Antwort auf dieser Website habe ich bemerkt, dass ich in der kommentierten Version versehentlich ein Komma verwendet habe. Da die Eingabe bereits erschöpft war, wurde die aktuelle Zelle auf 0 gesetzt (dies ist implementierungsabhängig, aber meiner Erfahrung nach das häufigste Verhalten). Ich habe den Fehler behoben, aber ich habe nachgedacht. Der idiomatische Weg, eine Zelle auf 0 zu setzen, ist [-](ungefähr while (*p) { *p--; }), was zwei Bytes länger ist. Jedes Mal, wenn alle Eingaben gelesen wurden, kann ich sie ,stattdessen verwenden. Dies ersparte mir 2 Bytes in dieser Antwort und 12 in dieser!

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 Bytes

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

Mit anrufen f("3 5 7 9 10").

iist die Zeilennummer, wobei 4 die erste und 1 die letzte Zeile ist. zist der n-te Stift in dieser Reihe, wobei 0 bedeutet, dass es der erste Stift in der Reihe ist und i-1dass es der letzte Stift in der Reihe ist.

Der wichtigste Hack ist i*~-i/2-~z, was konvertiert (i, z) -> pin number. Zum Beispiel ist (4, 0) -> 7Pin 7 der erste Pin in Zeile 4 (die erste Zeile). Die Herleitung geht so:

• Wir wollen eine Funktion, die izum ersten Pin in der Reihe führt i, dh 4 -> 7, 3 -> 4, 2 -> 2, 1 -> 1. Dies wird durch erfüllt (i**2-i)/2 + 1und (i**2-i)/2 + 1 + zgibt somit die richtige Pin-Nummer für die Eingabe(i, z)

• Dann vereinfachen Sie:

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

Pyth , 33 Bytes

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

Probieren Sie es online aus.

Das Programm übersetzt grob in:

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

(Danke an isaacg für die Tipps)

Pyth , 31

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

Probieren Sie es hier aus .

V4 richtet eine for-Schleife mit N als Variable über [0,1,2,3] ein.

*dNliefert die Anfangsräume, weil dRaum ist.

Um die Pin-Positionen zu finden, wird +7+dZ- 7 + d + Z verwendet.

d ist:

0 1 2 3
 1 2 3
  2 3
   3

while Zist in der ersten Zeile 0, in der zweiten -4, in der dritten -7 und in der vierten -9. Dies liegt daran, dass Zmit 0 begonnen und um 4, dann 3 und dann 2 ~Z-N4verringert Zwird.

Anschließend wird mit überprüft, ob sich die Pin-Position in der Eingabe befindet }+7+dZrz7. rz7sind die gewünschten Pins in List-of-Int-Form.

Dann wird ein OWenn erstellt, wenn es vorhanden war, und .ansonsten. Dies ist durch Leerzeichen getrennt, mit jdund implizit gedruckt.

Perl 5: 51 (50 + 1 für -p)

Using rFlag, für s///das eine der letzten 5 Perl-Ergänzungen ist.

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

CJam, 48 41 Bytes

Wow, das wurde schrecklich lang

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

Teste es hier.

Erläuterung

Zuerst generieren wir das Layout:

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

Dies ergibt

6 7 8 9
 3 4 5 
  1 2  
   0

Und jetzt ersetzen wir die Ziffern entsprechend der Eingabe:

[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

Hierbei wird die Übersetzungsfunktion verwendet, mit der Zeichen für Zeichen in einer Zeichenfolge ersetzt werden können. Wie tr in Perl, nur dass die Eingabe viel länger dauert. Ich erhalte eine Liste von Dezimalstellen, indem ich eine Zeichenfolge von 9 bis zur 99sten Potenz mache.

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

Erster Golf, kann wohl kürzer sein.

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

mit anrufen

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

BEARBEITEN

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

BEARBEITEN

ES6-Version 79 schlägt fehl

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

ES6-Version, 72 77, keine Warnung, kehrt nur zurück

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

Rubin, 91

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

Ersetzen Sie einfach die Befehlszeilenargumente durch .s und 0s und drucken Sie sie in einer Schleife von 4 Zyklen aus.

Lesbare Version

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 Bytes gespart dank @Jordan.

Die Punktzahl enthält 1 Extra für die -rOption:

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

Eingabe über STDIN:

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

Probieren Sie es online aus .

CJam, 40 39 Bytes

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

Ich weiß, dass es einen kürzeren Weg gibt, ich habe gerade keine Zeit, es herauszufinden.

Wie es funktioniert:

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

Probieren Sie es hier online aus

APL (35)

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

Prüfung:

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

Erläuterung:

• 17110357⊤⍨28/2: die 28-Bit-Darstellung von 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
  

• \⍨: 0Geben Sie für jeden ein Leerzeichen ein und nehmen Sie für jeden 1einen Eintrag aus der Zeichenfolge links.

• ⎕∊⍨⍳10: Lesen Sie eine Zeile von der Tastatur und werten Sie sie aus ( ⎕). Prüfen Sie dann für jede Zahl von 1 bis 10 ( ⍳10), ob sie in der Eingabe enthalten ist ( ∊⍨).
• '.O'[1+... ]: Addiere 1 zu jedem Wert (gebe 1s und 2s anstelle von 0s und 1s) und ersetze dann jede 1 nach .und jede 2 nach O.
• 4 7⍴: verwandle den generierten String in eine 4-mal-7-Matrix
• ⊖: drehen Sie es horizontal

Powershell: 109

Die Eingabe erfolgt in $ i

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

Das hat Spaß gemacht. Ich habe auch einiges über die Funktionsweise der Pipeline gelernt.

Haskell: 163-160 Bytes

Dies akzeptiert eine Reihe von durch Leerzeichen getrennten Zahlen von 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)

Und ein Bonus:

C: 250 Bytes

Diese Version erwartet, dass die Befehlszeilenargumente die Liste der Zahlen sind.

#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

Und ein alberner Bonusansatz, der nicht aufgeht, 90 Zeichen:

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

Mathematica, 109 Bytes

Funktion:

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

Angerufen von:

f@"3 5 7 9 10"

Wenn anonyme Funktionen erlaubt sind, kann dies auf 105 Bytes gekürzt werden :

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

Wenn die Eingabe keine durch Leerzeichen getrennte Zeichenfolge sein musste, sondern ein Array von Zahlen im Formular sein konnte {3,5,7,9,10}, kann dies weiter auf 79 Byte verkürzt werden :

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

Pure Bash (keine Coreutils), 85

Einfaches Ersetzen von Mustern:

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

Die Liste wird über die Befehlszeilenargumente eingegeben.

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 Bytes

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

Formatiert:

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

Erwartet Eingaben ohne abschließende Zeilenumbrüche.

Probieren Sie es online aus.

Das Band wird mit zehn Knoten initialisiert, von denen jeder eine Eins gefolgt von einer Null enthält. Die Eins ist der Anfangswert der Stecknadel, und die Null erleichtert die Navigation und fungiert als Platzhalter für das Leerzeichen. Für jede Zahl in der Eingabe wird dieser Pin um 3 erhöht. Beachten Sie, dass ord('O') - ord('.') = 33während der Druckphase der Wert des Stifts mit 11 multipliziert wird. (Diese Multiplikation wird auch zum Generieren des Leerzeichens verwendet.) Die Reihenfolge der Stifte von links nach rechts auf dem Band ist einfach 1beliebig 10. Wenn die Eingabe mit a endet 10, wird eine Korrektur vorgenommen, da das 10zunächst als a behandelt wird 1.

Nachdem die Eingabe verarbeitet wurde, wird nach jeder Zeile eine negative eingefügt. Dann werden die Zeilen in einer Schleife gedruckt, wobei die Anzahl der führenden Leerzeichen durch die Anzahl der zuvor verarbeiteten Zeilen bestimmt wird.

Clojure, 216 Zeichen (ugh)

Ich bin mir sicher, dass dies weiter golfen werden kann.

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

Verwenden Sie wie folgt:

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

AWK: 96 Bytes

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

Hinweis:

• Die Leerzeichen auf dem Eingabewert sind optional (aber es funktioniert auch mit ihnen nach Bedarf)
• Die Nummern müssen nicht in Ordnung sein
• Der Eingang wird auf STDIN gelesen

192 Bytes

Weil C #!

Ich habe zunächst versucht, die Ausgabe mit Mathe zu erstellen, aber die einfache Methode zum Ersetzen von Tokens in Strings scheint für höhere Sprachen am besten zu sein. Die Abhängigkeit von Linq ist langwierig, aber immer noch kürzer als ein Zähler und die Durchführung von Reichweitenprüfungen.

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-Zeilenumbruch (-3 Bytes)

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)

Akzeptiert durch Leerzeichen getrennte Zeichenfolgen

JavaScript ES6, 78 Byte

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

Verwenden Sie zum Testen das folgende Snippet. Es verwendet Eingabeaufforderungen und Warnungen sowie die regelmäßige Funktionsnotation, um das Testen zu vereinfachen.

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

VB / Basic-229

Mein Ziel war es, Java zu schlagen ^^

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

bearbeite vbCr anstelle von chr (13)

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

Kurzschrift wenn

Verwendung der Funktion anstelle von sub

sub MAIN () -> sub m ()

Java - 223 Zeichen

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

Ich mochte diese Art und Weise, dann wurde mir klar, dass ich einen kleinen Hack brauchte, der immer noch meiner Lösung gleicht.

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 Bytes

Noch nicht sehr wettbewerbsfähig, aber es ist ein Anfang:

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

Anwendungsbeispiel:

  `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 

Ich beginne mit der Auswertung der Eingabezeichenfolge mit .- glücklicherweise sind durch Leerzeichen getrennte Zahlen ein gültiges Listenliteral in K. Indem ich dem Ergebnis von eval eine leere Liste voranstelle, kann ich sicherstellen, dass es sich auch bei einem einzelnen Pin um eine Liste handelt. Dann erstelle ich einen booleschen Vektor, der die Positionen der Stifte darstellt:

  (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

Dann indexiere ich eine Liste von Strings, um mit Leerzeichen aufgefüllte Zeichen für jede Pin-Position zu erhalten.

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

Ich schneide diese Sequenz in Reihen ( _), kehre sie um ( |) und füge jedes Fragment zusammen ( ,/'):

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

Jetzt fängt es an, wie das Muster auszusehen, das wir wollen. Alles, was übrig bleibt, ist, einige führende Leerzeichen für jede Zeile anzuheften ( ((!4)#\:" "),') und die Zeilen auf stdout ( 0:) zu drucken .

Pascal (FPC) , 165 Bytes

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.

Probieren Sie es online!

Nimmt Zahlen von der Standardeingabe und druckt die Formation auf die Standardausgabe.

Pascal (FPC) , 175 Byte

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;

Probieren Sie es online!

Eine Funktion, die dasselbe tut, indem sie eine Reihe von Stiftpositionen einnimmt und eine formatierte Zeichenfolge zurückgibt.

Powershell, 84 Bytes

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

Testskript:

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

Ausgabe:

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 Zeichen

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

Wenn ich das zum ersten Mal mache, bin ich mir ziemlich sicher, dass es beschissen ist, aber ich bin ein Anfänger. Es funktioniert auch, wenn die Nummern nicht bestellt sind. Die Nummerierung ist falsch, aber ich habe keine Zeit herauszufinden, wie ich das Problem beheben kann ...

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

Die Eingabe erfolgt java B 1 2 3 5 10beispielsweise durch. Die Ausgabe wird dann sein:

0 . . . 
 . 0 . 
  0 0 
   0 

Japt -Rx , 29 19 18 17 Bytes

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

Versuch es

Erläuterung

                      :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