Je regardais le championnat du monde de snooker et ça m'a fait me demander ..

Score de snooker

Dans le jeu de snooker, il y a certaines règles que vous devez également respecter:

• Lorsqu'il y a des boules rouges sur la table, pendant votre tour, vous devez d'abord mettre une boule rouge en pot
• Après avoir mis chaque balle rouge en pot, vous devez mettre une balle colorée (pas rouge) en pot (la balle colorée en pot est ensuite replacée sur la table)
• Une fois que toutes les boules rouges sont en place (il y en a 15), vous pouvez d'abord choisir une balle de couleur, puis vous commencez avec la balle ayant le score le plus bas et vous progressez jusqu'à la balle ayant le score le plus élevé (celles-ci ne sont pas remplacées)
• Ne rempoter à aucun moment met fin à votre tour.
• Points par balle
  • Boule rouge: 1 point
  • Ballon jaune: 2 points
  • Boule verte: 3 points
  • Balle brune: 4 points
  • Boule bleue: 5 points
  • Boule rose: 6 points
  • Boule noire: 7 points

La question

Vous commencez avec une table avec toutes les boules encore dessus - 15 rouges et une de chacune des autres boules colorées - et vous recevez le score d'un joueur de snooker après son premier tour, comment ont-ils pu y arriver But?

L'entrée sera un score allant de 1 à 147. Vous pouvez choisir s'il s'agit d'un entier ou d'une chaîne. La sortie doit correspondre aux différentes combinaisons de nombre de fois où vous avez mis chaque balle en pot.

Cas de test:

Input: 4
Output: 
1r 1g
2r 1y
Input: 25
Output:
4r 3b
5r 2b 1br 1y
5r 2b 2g
...
9r 8y

Règles:

• Vous pouvez choisir d'afficher les possibilités divisées par une nouvelle ligne ou un séparateur quelconque (/ ,; | \ ou même d'autres qui me manquent)

C'est codegolf, donc le code le plus court l'emporte.

Gelée , 66 octets

L⁼30µÐfµ7Ḋ;\¤;€Ṣ€µ€;/
ċ1<⁴µÐfµ;Ç
7Ḋœċ⁴Ḷ¤;/L€;$€;@þ2B¤;/ḟ€0ÇS⁼¥Ðf⁸G

Eh bien, c'est trop lent pour TIO maintenant!
... voici donc une liste des 2636 façons de produire exactement 100 produites hors ligne.
... et voici une version qui s'y déroulera avec seulement SIX rouges (break maximum = 75)

Imprime une grille de nombres chaque ligne étant une liste de valeurs de balle séparées par des espaces (par exemple, trois rouges et deux verts seraient sur une ligne 1 1 1 3 3).

Pour une version groupée qui imprime des lignes de comptage avec les noms complets des boules, à 102 octets:

ŒrÑ€
Ṫ;ị“¡^³ṗ⁼¬wḌ⁼ø÷OẏK¦ẆP»Ḳ¤$K
L⁼30µÐfµ7Ḋ;\¤;€Ṣ€µ€;/
ċ1<⁴µÐfµ;Ç
7Ḋœċ⁴Ḷ¤;/L€;$€;@þ2B¤;/ḟ€0ÇS⁼¥Ðf⁸Ñ€K€Y

Comment?

L⁼30µÐfµ7Ḋ;\¤;€Ṣ€µ€;/ - Link 1, create post-red-ball games: list of all pre-yellow-ball-games
    µÐf               - filter keep if:
L⁼30                  -   length equals 30 (games that get on to the yellow)
       µ         µ€   - for €ach sequence leading to the yellow:
            ¤         -   nilad followed by link(s) as a nilad:
        7Ḋ            -     7 dequeued  = [2,3,4,5,6,7]
          ;\          -     ;\ cumulative reduce with concatenation  = [[2],[2,3],[2,3,4],...]
             ;€       - concatenate the sequence with €ach of those
               Ṣ€     - sort each one
                   ;/ - reduce with concatenation (flatten by one)

ċ1<⁴µÐfµ;Ç - Link 2, filter bogus entries created and append post-yellow-ball games: list of pre-yellow-ball games (along with the bogus ones with 16 reds potted)
    µÐf    - filter keep if:
ċ1         -   count ones
   ⁴       -   literal 16
  <        -   less than?
       µ   - monadic chain separation
         Ç - call the last link (1) as a monad
        ;  - concatenate

7Ḋœċ⁴Ḷ¤;/L€;$€;@þ2B¤;/ḟ€0ÇS⁼¥Ðf⁸G - Main link: score
7Ḋ                                - 7 dequeued = [2,3,4,5,6,7]
      ¤                           - nilad followed by link(s) as a nilad:
     ⁴                            -   literal 16
    Ḷ                             -   lowered range = [0,1,2,...,15]
  œċ                              - combinations with replacement (every possible colour-ball selection that goes with the red pots)
       ;/                         - reduce with concatenation (flatten by one)
            $€                    - last two links as a monad for €ach:
         L€                       -   length of €ach (number of coloured balls potted)
           ;                      -   concatenate
                   ¤              - nilad followed by link(s) as a nilad:
                 2B               -   2 in binary = [1,0]
                þ                 - outer product with:
              ;@                  -   concatenation with reversed @rguments
                    ;/            - reduce with concatenation (flatten by one)
                      ḟ€0         - filter discard zeros from €ach
                         Ç        - call the last link (2) as a monad
                             Ðf   - filter keep:
                            ¥  ⁸  -   last two links as a dyad, with score on the right
                          S⁼      -     sum(ball values) is equal to score?
                                G - format as a grid
                                  - implicit print

JavaScript (ES7), 188 180 178 octets

Renvoie un tableau de tableaux (triés du rouge au noir).

n=>[...Array(17**6)].map((_,x)=>[2,3,4,5,6,p=7].map(v=>(k=a[++j]=x%17|0,x/=17,t+=k,p+=!!(y=y&&k),s-=k*v),y=s=n,a=[j=t=0])&&(s==15|s>=t)&s<16&s<t+2&t<9+p&&(a[0]=s,a)).filter(a=>a)

Commenté

Remarque : Cette version n'inclut pas la dernière optimisation p(maintenant initialisée à 7), ce qui rend la logique plus difficile à comprendre.

n =>                              // given a target score n:
  [...Array(17**6)].map((_, x) => // for each x in [0 .. 17^6 - 1]:
    [2, 3, 4, 5, 6, 7].map(v =>   //   for each v in [2 .. 7] (yellow to black):
      ( k = a[++j] = x % 17 | 0,  //     k = a[j] = number of colored balls of value v
        x /= 17,                  //     update x to extract the next value
        t += k,                   //     update t = total number of colored balls
        p += !!(                  //     update p = number of consecutive colors that were
          y = y && k              //     potted at least once, using y = flag that is zeroed
        ),                        //     as soon as a color is not potted at all
        s -= k * v ),             //     subtract k * v from the current score s
      y = s = n,                  //     initialize y and s
      a = [j = t = p = 0]         //     initialize a, j (pointer in a), t and p
    )                             //   at this point, s is the alleged number of red balls
    &&                            //   this combination is valid if we have:
      (s == 15 | s >= t) &        //     - 15 red balls or more red balls than colored ones
      s < 16 &                    //     - no more than 15 red balls
      s < t + 2 &                 //     - at most one more red ball than colored ones
      t < 16 + p                  //     - no more than 15 + p colored balls
    &&                            //   if valid:
      (a[0] = s, a)               //     update the combination with red balls and return it
  ).filter(a => a)                // end of outer map(): filter out invalid entries

Exemple de sortie

Voici la sortie pour n = 140:

//  R   Y  G  Br Bl P  Bk 
[ [ 15, 1, 1, 1, 1, 8, 9  ],
  [ 15, 1, 1, 1, 2, 6, 10 ],
  [ 15, 1, 1, 1, 3, 4, 11 ],
  [ 15, 1, 1, 2, 1, 5, 11 ],
  [ 15, 1, 1, 1, 4, 2, 12 ],
  [ 15, 1, 1, 2, 2, 3, 12 ],
  [ 15, 1, 2, 1, 1, 4, 12 ],
  [ 15, 1, 1, 2, 3, 1, 13 ],
  [ 15, 1, 1, 3, 1, 2, 13 ],
  [ 15, 1, 2, 1, 2, 2, 13 ],
  [ 15, 2, 1, 1, 1, 3, 13 ],
  [ 15, 1, 2, 2, 1, 1, 14 ],
  [ 15, 2, 1, 1, 2, 1, 14 ],
  [ 15, 1, 1, 1, 1, 1, 15 ] ]

Démo

C'est trop lent pour un extrait. Vous pouvez essayer ici à la place. (Vous pouvez recevoir une ou deuxalertes de script qui ne répondent pas , mais elles devraient finir par se terminer.)