Comment compter les doublons dans une poule mixte en utilisant AnyDice ?

Question

La question suivante fournit une fonction qui répond à la question pour un seul type de dé ; Comment compter le nombre de doublons dans anydice ?

Je veux compter combien de doublons il y a dans un pool mixte tel que 3d12, 2d10, 1d8.

Par exemple, si je lance 12, 12, 3, 3, 3, 1, le résultat sera 5, car 5 des dés ont au moins un autre dé qui a obtenu la même valeur.

Answer 1

Pour les duplicatas exacts, le programme donné en Réponse de Carcer à la question que vous citez peut être facilement modifié pour prendre plusieurs pools de dés :

function: dupes in A:s B:s C:s {
  DICE: [sort {A, B, C}]
  DUPES: 0
  loop X over {2..#DICE} {
    if (X-1)@DICE = X@DICE { DUPES: DUPES + 1 }
  }
  result: DUPES
}

output [dupes in 1d12 2d10 1d8]

Notez que, comme le code original de Carcer, cette fonction retournera 3 pour (12, 12, 3, 3, 3, 1), et non 5, car elle compte un groupe de \$n\$ dés identiques à \$n-1\$ duplicata ! Si vous voulez compter tous les dés qui correspondent à au moins un autre dé, Voici une version qui permet de le faire :

function: dupes in A:s B:s C:s {
  DICE: [sort {A, B, C}]
  DUPES: 0
  loop X over {1..#DICE} {
    PREV_MATCH: X > 1 & (X-1)@DICE = X@DICE
    NEXT_MATCH: X < #DICE & (X+1)@DICE = X@DICE
    if PREV_MATCH | NEXT_MATCH { DUPES: DUPES + 1 }
  }
  result: DUPES
}

output [dupes in 1d12 2d10 1d8]

Notez que cette version ne donnera jamais un résultat de "un doublon" - il y en a toujours au moins deux, ou aucun !

Hélas, comme ces programmes doivent itérer à travers tous les résultats possibles de tous les lancers, ils peuvent être plutôt lents s'il y a beaucoup de dés avec beaucoup de faces dans le pool. Par exemple, les résultats de mes tests ci-dessus utilisent 1d12, 2d10 et 1d8, car essayer de les exécuter pour votre exemple de 3 d12, 2d10 et 1d8 fois. :/

Pour de plus grandes quantités de dés, mon rouleau de dés Python de une réponse antérieure peut faire l'affaire à la place. Voici une solution utilisant la méthode de comptage de Carcer :

from collections import defaultdict
summary = defaultdict(float)

for d12, p12 in dice_roll(12, count=3):
  for d10, p10 in dice_roll(10, count=2):
    for d8, p8 in dice_roll(8, count=1):
      prob = p12 * p10 * p8
      roll = sorted(d12 + d10 + d8)
      dupes = sum(roll[i] == roll[i+1] for i in range(len(roll) - 1))
      summary[dupes] += prob

for dupes, prob in sorted(summary.items()):
  print("%d duplicates: %.2f%%" % (dupes, 100 * prob))

y en voici un qui utilise le vôtre :

from collections import defaultdict
summary = defaultdict(float)

for d12, p12 in dice_roll(12, count=3):
  for d10, p10 in dice_roll(10, count=2):
    for d8, p8 in dice_roll(8, count=1):
      prob = p12 * p10 * p8
      roll = sorted(d12 + d10 + d8)
      dupes = sum(
        (i > 0 and roll[i-1] == roll[i])
        or (i < len(roll)-1 and roll[i+1] == roll[i])
        for i in range(len(roll))
      )
      summary[dupes] += prob

for dupes, prob in sorted(summary.items()):
  print("%d duplicates: %.2f%%" % (dupes, 100 * prob))

(Il s'agit également de solutions de force brute, mais Python est plus rapide qu'AnyDice. Et, si vous l'exécutez sur votre propre ordinateur, il n'a pas de limite de temps).

---

Tous ces programmes peuvent être assez facilement modifiés pour compter également les "quasi-accidents". Puisque vous avez maintenant divisé cette partie en une question séparée, J'y ai répondu .

Answer 2

Comment travailler avec des pools de dés mixtes dans Anydice ?

En général, pour travailler avec des pools de dés dans Anydice, nous les passons à une fonction sous forme de séquence (par ex. DICE:s ) mais vous ne pouvez pas passer directement des pools mixtes de cette façon (ils sont ajoutés avant d'être passés, ce qui est très différent). Au lieu de cela, vous devez lui transmettre plusieurs pools de type unique, puis les regrouper.

function: do a thing to A:s B:s C: {
   DICE: [sort {A, B, C}]
}

Pour expliquer ce que nous faisons ici, nous combinons les séquences et les trions de manière à ce que les numéros soient en ordre décroissant, de la même manière que les pools de dés "normaux" le sont dans Anydice (ce qui est utilisé dans de nombreuses situations). Nous codons évidemment le nombre maximum de dés différents, mais l'étendre devrait être trivial et si vous avez besoin de moins, vous pouvez simplement lui passer une séquence vide ( {} ).

En faisant cela comme une extension de La fonction de Carcer dans la question liée on obtient :

function: dupes in mixed A:s B:s C:s {
  DICE: [sort {A, B, C}]
  D: 0
  loop X over {2..#DICE} {
    if ((X-1)@DICE = X@DICE) { D: D + 1}
  }
  result: D
}

Cependant, il s'agit d'une fonction différente de celle que vous recherchez (elle donnerait 3 avec votre exemple), donc pour cela nous pouvons plutôt utiliser :

function: count dupes upto MAX in A:s B:s C:s {
   POOL: [sort {A, B, C}]
   R: 0
   loop N over {1..MAX} {
      T: [count N in POOL]
      if T > 1 { R: R + T }
   }
   result: R
}