Votre but est d’afficher l’art ASCII d’une formation au bowling à dix quilles où il ne reste que quelques-unes des quilles. Le moins d'octets gagne.

Les broches des dizaines sont dans une formation triangulaire:

O O O O         
 O O O   
  O O       
   O

Les repères sont étiquetés de 1 à 10 comme suit:

7 8 9 10    
 4 5 6            
  2 3    
   1

Traceurs au fur Oet à mesure qu'il en manque ., la formation 1 3 5 6 9 10est:

. . O O         
 . O O    
  . O       
   O

Contribution:

Chaîne séparée par des espaces qui répertorie un sous-ensemble non vide des nombres 1 à 10 dans l'ordre.

Sortie:

Imprimer la formation correspondante ou la sortir sous forme de chaîne avec des sauts de ligne.

La formation doit être alignée avec la gauche de l'écran. N'importe quel espace est correct tant que l'image visible est correcte. Les lignes vides avant et après sont bien aussi.

Cas de test:

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

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

Cela m'a pris la plus grande partie de deux jours. Je pense que ça valait le coup. Il est probablement possible de jouer au golf davantage en modifiant la cellule dans laquelle un objet est stocké, mais pour le moment, je suis simplement heureux de l'avoir fait fonctionner.

Ce programme devrait être complètement différent si la question ne spécifiait pas que l'entrée serait triée. Cela fonctionne en construisant une liste de 10 broches autour de celles qui sont entrées. C'est un peu déroutant mais peut-être que cela l'expliquera mieux:

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]

Pendant ce temps, il se souvient quelles broches l’utilisateur a placées et celles qu’il a placées là. Cette stratégie serait très difficile à utiliser si l'entrée n'était pas triée.

Une autre chose que le tri facilite est la détection du nombre 10. Étant donné que le brainfuck concerne des octets individuels, et non pas des "nombres" en tant que tels, cela aurait pu être un casse-tête, mais l'entrée triée m'a beaucoup facilité la gestion avec. La raison en est liée à la manière dont j'ai stocké les données dans le programme. Je prends l’entrée un caractère à la fois et soustrais 32 du résultat. Si la cellule est non nulle par la suite, j'avance 4 cellules. avant de répéter. Cela signifie que je reçois un octet d’entrée non-espace toutes les 4 cellules et que je stocke effectivement les épingles sous leur numéro + 16. Cependant, il faut deux octets à la saisie de 10, j’ai donc dû le mettre dans un cas spécial. Si l'entrée n'était pas triée, il faudrait que je regarde à travers les punaises, mais comme elle est triée, ce sera toujours la dernière punaise si elle apparaît. Je vérifie si le (dernier octet de l'entrée + 1) == (l'avant-dernier octet de l'entrée) et, dans l'affirmative, il doit être 10. Je me débarrasse du dernier octet et mets l'avant-dernier en fonction de ce que mon système comprend "dix". Les personnages'1'et '0'ne rentre pas dans un seul octet, mais le nombre 26 le fait!

Utiliser des astuces pour faire fonctionner quelque chose est ce que je préfère dans l'utilisation de ce langage. :)

Si le fonctionnement de ce programme vous intéresse plus en détail, vous pouvez consulter le programme avec les commentaires que j'ai utilisés lors de sa rédaction pour vous assurer que je me souvenais de tout. Même écrire des commentaires dans brainfuck est difficile, car il n'y a pas de syntaxe de commentaire. Au lieu de cela, tous les personnages sauf ceux qui <[+.,-]>sont dedans sont no-ops. Il est facile d'introduire des bugs en incluant .ou ,dans vos commentaires accidentellement ! C'est pourquoi la grammaire est si méchante et les points-virgules sont partout.

EDIT: Comme exemple de combien il est facile de tout gâcher: j'ai utilisé "non-espace" dans l'un des commentaires! Quand j'ai enlevé tous les caractères non-bf de la source, le programme que j’avais l'habitude de faire était conservé dans le -. Heureusement, rien n'a été cassé, mais maintenant je l'ai supprimé pour sauvegarder un octet. :)

EDIT II: Cela fait longtemps que je n’ai pas touché celui-ci, haha. Dans une autre réponse de brainfuck sur ce site, j'ai remarqué que j'avais accidentellement utilisé une virgule dans la version commentée. Comme l'entrée avait déjà été épuisée, la cellule actuelle était définie sur 0 (cela dépend de la mise en œuvre, mais d'après mon expérience, c'est le comportement le plus courant). J'ai corrigé le bug, mais ça m'a fait réfléchir. La manière idiomatique de définir une cellule sur 0 est [-](approximativement while (*p) { *p--; }), ce qui correspond à deux octets de plus. Chaque fois que toutes les entrées ont été lues, je peux les utiliser à la ,place. Cela m'a sauvé 2 octets dans cette réponse et 12 dans celle-ci!

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 octets

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

Appeler avec f("3 5 7 9 10").

iest le numéro de la ligne, 4 étant la première ligne et 1 la dernière. zest la nième épingle de cette rangée, 0 signifiant que c'est la première épingle de la rangée et i-1que c'est la dernière épingle de la rangée.

Le hack principal est celui i*~-i/2-~zqui convertit (i, z) -> pin number. Par exemple, (4, 0) -> 7la broche 7 est la première de la rangée 4 (la première rangée). La dérivation va comme ceci:

• Nous voulons une fonction prenant ila première broche sur la ligne i, c'est à dire 4 -> 7, 3 -> 4, 2 -> 2, 1 -> 1. Ceci est satisfait par (i**2-i)/2 + 1, et (i**2-i)/2 + 1 + zdonne donc le numéro de pin correct pour l’entrée(i, z)

• Alors simplifiez:

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

Pyth , 33 octets

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

Essayez-le en ligne.

Le programme se traduit approximativement par:

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

(Merci à isaacg pour les conseils)

Pyth , 31

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

Essayez ici .

V4 définit une boucle for, avec N comme variable sur [0,1,2,3].

*dNfournit les espaces initiaux, car dis space.

Pour trouver les emplacements des broches, il utilise +7+dZ- 7 + d + Z.

d est:

0 1 2 3
 1 2 3
  2 3
   3

while Zest 0 dans la première ligne, -4 dans la seconde, -7 dans la troisième et -9 dans la quatrième. C'est parce que Zcommence à 0 et ~Z-N4diminue Zde 4, puis 3, puis 2.

Ensuite, il vérifie si l'emplacement de la broche est dans l'entrée, en utilisant }+7+dZrz7. rz7est les pins désirés sous forme de liste-of-int.

Ensuite, il crée un Osi il était présent, et .sinon. Ceci est séparé de l’espace, avec jdet imprimé implicitement.

Perl 5: 51 (50 + 1 pour -p)

Utiliser rflag pour s///lequel est l’un des ajouts récents de perl 5.

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

CJam, 48 41 octets

Wow, cela a horriblement long

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

Testez-le ici.

Explication

Nous générons d'abord la mise en page:

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

Cela donne

6 7 8 9
 3 4 5 
  1 2  
   0

Et maintenant, nous remplaçons les caractères numériques en fonction de l'entrée:

[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

Ceci utilise la fonction de traduction, qui permet de faire des substitutions caractère par caractère dans une chaîne. Comme tr en perl, mais beaucoup plus longtemps à taper. Je reçois une liste de chiffres décimaux en créant une chaîne de 9 à la 99ème puissance.

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

Premier golf, peut-être probablement plus court.

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

appeler avec

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

MODIFIER

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

MODIFIER

Version ES6, échec de 79

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

Version ES6, 72 77, aucune alerte, ne fait que revenir

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}

Substitue simplement les arguments de la ligne de commande avec .s et 0s et les imprime en utilisant une boucle de 4 cycles.

Version lisible

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

• Sauvegardé 6 octets grâce à @Jordan.

Le score inclut 1 extra pour l' -roption:

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

Entrée via STDIN:

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

Essayez-le en ligne .

CJam, 40 39 octets

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

Je sais qu'il existe un moyen plus court, vous n'avez pas le temps de le savoir maintenant.

Comment ça marche:

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

Essayez-le en ligne ici

APL (35)

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

Tester:

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

Explication:

• 17110357⊤⍨28/2: la représentation 28 bits de 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
  

• \⍨: Pour chaque 0, donnez un espace, et pour chaque 1, prenez un élément de la chaîne à gauche.

• ⎕∊⍨⍳10: Lit une ligne sur le clavier et l’évalue ( ⎕), puis vérifie chaque nombre compris entre 1 et 10 ( ⍳10), qu’il soit contenu ou non dans input ( ∊⍨).
• '.O'[1+... ]: Ajoutez 1 à chaque valeur (donnant 1 et 2 au lieu de 0 et 1), puis remplacez tous les 1 par .et tous les 2 par O.
• 4 7⍴: transformer la chaîne générée en une matrice 4 x 7
• ⊖: retournez-le horizontalement

Powershell: 109

L'entrée est dans $ i

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

C'était amusant. J'ai appris beaucoup de choses sur le fonctionnement du pipeline.

Haskell: 163 160 octets

Ceci accepte une ligne d'espaces séparés par des nombres 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)

Et un bonus:

C: 250 octets

Cette version s'attend à ce que ses arguments de ligne de commande soient la liste des nombres.

#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

Et une approche de bonus loufoque qui n'a pas abouti, 90 personnages:

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

Mathematica, 109 octets

Une fonction:

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

Appelé par:

f@"3 5 7 9 10"

Si les fonctions anonymes sont autorisées, cela peut être réduit à 105 octets :

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

Si l'entrée ne doit pas nécessairement être une chaîne délimitée par des espaces, mais peut être un tableau de nombres sous la forme {3,5,7,9,10}, vous pouvez réduire ce nombre à 79 octets :

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

Pure bash (no coreutils), 85

Remplacement de modèle simple:

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

La liste est entrée via les arguments de ligne de commande.

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 octets

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

Formaté:

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

Attend une entrée sans fin de ligne.

Essayez-le en ligne.

La bande est initialisée avec dix nœuds, chacun contenant un nœud suivi d’un zéro. L'un est la valeur initiale de la broche et le zéro facilite la navigation et sert d'espace réservé pour le caractère d'espace. Pour chaque numéro de l'entrée, cette broche est incrémentée de 3; notez que ord('O') - ord('.') = 33, et pendant la phase d'impression, la valeur de la broche sera multipliée par 11. (Cette multiplication sert également à générer le caractère d'espacement.) L'ordre des broches de gauche à droite sur la bande va tout simplement 1jusqu'à 10. Si l'entrée se termine par un 10, une correction est effectuée, car elle 10est initialement traitée comme un 1.

Une fois l’entrée traitée, un négatif est placé après chaque ligne. Ensuite, les lignes sont imprimées en boucle, le nombre d'espaces en tête étant déterminé par le nombre de lignes traitées précédemment.

Clojure, 216 caractères (ough)

Je suis sûr que cela peut être joué au golf plus loin.

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

Utilisez comme ceci:

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

AWK: 96 octets

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

Remarque:

• Les séparateurs d'espaces sur la valeur d'entrée sont facultatifs (mais cela fonctionne aussi avec eux si nécessaire)
• Les chiffres ne doivent pas nécessairement être en ordre
• L'entrée est lue sur STDIN

C # - 192 octets

Parce que C #!

J'ai commencé par essayer de construire la sortie avec les mathématiques, mais la méthode simple de remplacement des jetons dans la chaîne semble être la meilleure solution pour les langages de niveau supérieur. La dépendance à Linq est longue mais reste plus courte que celle de garder un compteur et de vérifier les plages.

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: retourne une ligne (-3 octets)

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)

Accepte les ensembles de chaînes délimités par des espaces

JavaScript ES6, 78 octets

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

Utilisez l'extrait suivant pour tester. Il utilise des invites et des alertes et une notation de fonction régulière pour faciliter les tests.

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

VB / Basic-229

Mon but était de battre 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

éditer vbCr au lieu de chr (13)

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

sténographie si

utilisation de la fonction au lieu de sous

sous MAIN () -> sous m ()

Java - 223 caractères

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

J'aimais cette façon de faire, puis j'ai réalisé qu'il me fallait un petit bidouillage, tout comme ma solution.

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 octets

Pas encore très compétitif, mais c'est un début:

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

Exemple d'utilisation:

  `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 

Je commence par évaluer la chaîne d'entrée avec .- heureusement, les nombres séparés par des espaces constituent un littéral de liste valide en K. En ajoutant une liste vide au résultat de eval, je peux m'assurer que c'est une liste même dans le cas d'une seule broche. Puis je crée un vecteur booléen représentant les positions des pins:

  (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

Ensuite, j'indexe dans une liste de chaînes pour obtenir des caractères remplis d'espace pour chaque position de la broche.

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

Je découpe cette séquence en lignes ( _), les inverse ( |) et assemble chaque fragment ( ,/'):

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

Maintenant, cela commence à ressembler au modèle que nous voulons. Tout ce qui reste à faire est de clouer sur les espaces devant chaque ligne ( ((!4)#\:" "),') et d’imprimer les lignes sur stdout ( 0:).

Pascal (FPC) , 165 octets

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.

Essayez-le en ligne!

Prend les nombres de l'entrée standard, imprime la formation sur la sortie standard.

Pascal (FPC) , 175 octets

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;

Essayez-le en ligne!

Une fonction qui fait la même chose, prenant un tableau de positions de broches et renvoyant une chaîne formatée.

Powershell, 84 octets

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

Script de test:

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

Sortie:

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 caractères

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

La première fois que je fais ça, je suis presque sûr que c'est merdique, mais je suis novice. Cela fonctionne également lorsque les numéros ne sont pas commandés. La numérotation est fausse, mais je n'ai pas le temps de trouver des solutions.

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

l'entrée est donnée par java B 1 2 3 5 10exemple. La sortie sera alors:

0 . . . 
 . 0 . 
  0 0 
   0 

Japt -Rx , 29 19 18 17 octets

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

L'essayer

Explication

                      :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