dicelab - En ligne dans le Cloud

Exécutez dicelab dans le fournisseur d'hébergement gratuit OnWorks sur Ubuntu Online, Fedora Online, l'émulateur en ligne Windows ou l'émulateur en ligne MAC OS

Il s'agit de la commande dicelab qui peut être exécutée dans le fournisseur d'hébergement gratuit OnWorks en utilisant l'un de nos multiples postes de travail en ligne gratuits tels que Ubuntu Online, Fedora Online, l'émulateur en ligne Windows ou l'émulateur en ligne MAC OS

Exécuter sous Ubuntu Courir dans Fedora Exécuter dans Windows Sim Exécuter dans MACOS Sim

PROGRAMME:

Nom

dicelab - lancer et examiner les schémas de lancer de dés

SYNOPSIS

laboratoire de dés [choix] [-F ]

OPTIONS

-h, --Aidez-moi, -?
imprimer un message d'aide

--version, -v
afficher le numéro de version

--calc, -c
calculer la répartition

--rouler, -r
lancer les dés comme spécifié. Ceci sera également utilisé si aucune autre action n'est demandée

--évaluation, -e
relancer plusieurs fois et résumer les résultats pour obtenir une distribution statistique de
valeurs

--compter, -n
spécifiez le nombre de relances pour --eval, par défaut 10000

--print-tree, -p
imprimer l'arbre d'analyse (à des fins de débogage)

-f
lire la description du schéma à partir du fichier au lieu de stdin

DESCRIPTION

Dicelab lit une description d'un schéma de lancer de dés à partir d'un fichier ou de stdin si aucun fichier
est spécifié, puis lance ou examine ce schéma.

RAPIDE La START

Des rouleaux de matrice simples peuvent être effectués à l'aide de l'opérateur « d », suivi du nombre de faces sur
le dé à lancer. Par exemple, d6 lancera un seul dé à six faces et d2 lancera une pièce.
Les expressions peuvent être modifiées par les opérateurs arithmétiques standard. d10-1 donnera une valeur
entre 0 et 9 inclus. Pour lancer plusieurs dés du même type, utilisez le
opérateur de répétition '#'. 2#d6 lancera deux dés à six faces ; ce n'est pas la même chose que 2*d6,
qui ne lance qu'un seul dé mais multiplie le résultat par deux, soit 2d6 qui provoquera un
erreur de syntaxe. Pour obtenir la somme de deux dés à six faces, faites sum(2#d6).

FULL SYNTAXE

SÉMANTIQUE

+ - * / ^

Ce sont les opérateurs arithmétiques binaires familiers pour l'addition, la soustraction,
multiplication, division et exponentiation. La division s'arrondit vers zéro.
Exemples : 5+7, d6-1, 2^10

-

Il s'agit de l'opérateur moins unaire. Exemples : -1

%

C'est l'opérateur module. x % y donne le reste de x divisé par y.
Exemples : 11%2, d6%3

.

C'est l'opérateur de concaténation scalaire. X . y donne xy, la concaténation de x
Andy. Exemples : -10.9, d6.d6

d

C'est l'opérateur du rouleau de dé. dn donne la valeur d'un seul rouleau d'un n côtés
mourir. Exemples : d6, 2#d6

somme poussée

Ce sont les opérateurs de somme et de produit étendus. Si e est une expression, somme e et
prod e donne la somme des membres de e et le produit des membres de e,
respectivement. Exemples : sum(1..100), prod(3#d6)

compter

Il s'agit de l'opérateur de taille de liste. Si e est une expression, alors le compte e donne le
nombre de membres de e. Exemples : compter(1,2,3), compter(== 6 10#d6)

#

C'est l'opérateur de répétition de liste. Si n est un scalaire non négatif et e est un
expression, alors n#e est une liste contenant les résultats de n évaluations de e.
Exemples : 10#8, 3#d10

..

Il s'agit de l'opérateur de plage. Si x et y sont des scalaires, alors x..y est une liste composée
de l'intervalle [x,y]. Si x>y, alors la liste résultante est vide. Exemples : 1..10,
4..d10

,

Il s'agit de l'opérateur de concaténation de liste. v,u donne la liste composée de tous les
les membres de v, suivis de tous les membres de u. Exemples : 1,2 4,(3#d6)

sort

Il s'agit de l'opérateur de tri de liste. sort e trie la liste e par ordre croissant.
Exemples : tri (10#d6)

permanente

C'est l'opérateur de permutation de liste. le tri e donne une permutation aléatoire de
la liste e. Utilisez perm pour mélanger une liste. Exemples : permanente(1)

tour

C'est l'opérateur d'inversion de liste. rev e aboutit à une liste avec les mêmes membres
comme la liste e, mais dans l'ordre inverse. Exemples : rev(1..10), rev sort(10#d8)

faible Élevée

Ces opérateurs agissent comme des filtres en trouvant les valeurs les plus petites et les plus grandes dans les listes.
Si n est un scalaire non négatif et e est une expression, alors ne bas donne le n le moins
membres de e, et high ne donne les n plus grands membres de e. Exemples : élevé 3 5#d6

premier dernier

Ces opérateurs agissent comme des filtres en trouvant les segments initiaux et finaux des listes. Si n
est un scalaire non négatif et e est une expression, alors le premier ne donne le premier n
membres de e, et last ne donne les n derniers membres de e. Exemples : 3 premiers
(1..10)

== != < > <= >=

Ces opérateurs agissent comme des filtres en trouvant des valeurs dans des listes qui répondent à des
conditions. Si x est un scalaire et e est une expression, alors == xe donne la liste des
membres de e égaux à x ; != xe donne la liste des membres de e non égal à x ; <x
e donne la liste des membres de e inférieur à x ; > xe donne la liste des membres de e
supérieur à x ; <= xe donne la liste des membres de e inférieur ou égal à x ; >= x
e donne la liste des membres de e supérieur ou égal à x. Exemples : >= 3 5#d6

déposer garder

Ces opérateurs modifient les filtres sur les listes. Si fop est une opération de filtrage sur un
expression e, alors keep fop e a le même résultat que fop e et drop fop e évalue
pour e moins garder fop e. En d'autres termes, supprimez annule les conditions de filtrage et conservez
les affirme. keep n'est jamais nécessaire et n'existe que pour la symétrie. Exemples:
somme (chute bas 1 4#d6)

laisser

Il s'agit de l'opérateur d'affectation et de substitution de variable. Si x est une variable et e
et f sont des expressions, alors soit x = e dans f donne la liste qui résulte de
évaluer f avec la valeur de e substituée à chaque occurrence de x dans f.
L'évaluation de e est effectuée avant la substitution. Exemples : soit x = d6 dans x*x

foreach

Il s'agit de l'opérateur d'itération borné. Si x est une variable et e et f sont
expressions, alors foreach x dans e do f donne la liste qui résulte de l'affectation
à x chacun des membres de e et évaluer f. Exemples : foreach x in c do x+1

tout en

Il s'agit de l'opérateur d'itération illimité. Si x est une variable et e et f sont
expressions, alors alors que x = e do f est la liste v0,v1,...,vn, où v0 est le résultat
d'évaluer e et vi+1 est le résultat de l'affectation de vi à x et de l'évaluation de f,
en s'arrêtant au premier vi qui est vide. Exemples : tandis que x=d6 do ((count <6 x)#d6)

if

C'est l'opérateur de branchement. Si e, f et g sont des expressions, alors si e alors f
sinon g donne f si e est non vide, et g sinon. Exemples : si compte(>4 2#d6) alors
1 autre 0

EXEMPLES

Comptez le nombre de dés supérieur à 7 :

compte >7 5#d10

Comptez le nombre de dés supérieur à 7 moins le nombre de dés égal à 1 :

laissez c=5#d10 dans (compte >7 c)-(compte ==1 c)

Comptez le nombre de rouleaux jusqu'à ce qu'un 6 soit obtenu :

compter (tandis que x=d6 do ((compte <6 x)#d6))

Comptez le nombre de rouleaux jusqu'à ce qu'un 6 soit obtenu, plus efficacement :

compter (tandis que x=(d6/6) do ((compte <1 x)#(d6/6)))

Attributs de jet pour un nouveau personnage D&D :

6#somme(chute bas 1 4#d6)

Lancez le test de moral 11..66 dans The Gamers' Civil War Brigade Series :

d6.d6

Trouvez la médiane de 3 d20 :

élevé 1 faible 2 3#d20

3d6 avec relances sur 6s :

sum(tandis que x=3#d6 do ((count ==6 x)#d6))

Lancez 7 d10 et trouvez la plus grande somme de dés identiques :

let x = 7#d10 in high 1 (foreach y in 1..10 do sum (==yx))

La suite de Fibonacci est définie par Fn = Fn-1 + Fn-2, avec F1 = F2 = 1. Calculer le
vingt premiers nombres de Fibonacci :

soit n = 20 dans
soit f = (1,1) dans
foreach je dans 1..n faire
soit f = (f,sum(high 2 f)) dans
if ==ni alors f else()

Le risque a des batailles où l'attaquant lance 3d6 et le défenseur lance 2d6. Le plus haut
le dé de l'attaquant correspond au dé le plus élevé du défenseur et au deuxième dé de l'attaquant le plus élevé
au deuxième plus grand défenseur. Pour les deux matches, le plus grand gagne, les égalités allant à
le défenseur. Le nombre d'attaquants gagne :

soit a = 3#d6 dans
soit b = 2#d6 dans
compter( (<(élevé 1 a) élevé 1 b),
(<(élevé 1 faible 2 a) faible 1 b))

Lancer de dé du conteur avec la cible numéro 8 et les échecs indiqués à -1 :

soit c=5#d10 dans
laisser succs = compter >7 c dans
laisser ceux = compter ==1 c dans
si >0 succs alors élevé 1 (0,sucs-ones)
sinon si >0 alors -1 sinon 0

Le combat dans Silent Death est assez complexe. Trois dés sont lancés. Si leur somme est supérieure à un
cible, le rouleau est un succès. Pour calculer les dégâts, les mêmes dés sont triés. Si les trois sont
égaux, tous sont additionnés pour produire les dommages. Si les deux moins sont égaux, mais que le troisième est
plus haut, le dé haut est le dommage. Si les deux plus élevés sont égaux, mais que le troisième est inférieur,
les deux dés les plus élevés sont additionnés pour infliger les dégâts. Si les trois dés sont différents, le
le dé du milieu est le dommage. Cet exemple suppose que les dés sont deux d8 et un d10, avec un
nombre cible de 15 :

soit x = 2#d8,d10 dans
(compter >15 somme x)#
soit a = bas 1 x in // bas die
laisser b = haut 1 bas 2 x in // dé du milieu
soit c = high 1 x in // high die
if ==a ==bc then a+b+c // tous égaux
sinon si ==a
else if >a ==cb then b+c // deux hauts égaux else
b // tous différents

CRÉDITS

Dicelab est basé sur l'excellent ouvrage "roll" de Torben Mogensen
(http://www.diku.dk/~torbenm/Dice.zip). Sans son travail et ses commentaires, ce serait difficilement
jamais arrivé.

La spécification de la langue actuelle et les extensions de la langue d'origine sont dérivées
d'après l'œuvre de Joel Uckelman (http://dice.nomic.net/bones.html), la plupart
des documents lui sont également volés.

Ce code a été écrit par Robert Lemmen[email protected]> qui serait heureux d'entendre
vos questions et remarques.

Utilisez dicelab en ligne en utilisant les services onworks.net