OpenLLM-France/wikimedia huggingface dataset:
# Livre de cuisine/Melomakarona

Le Melomakarona est une pâtisserie grecque.

## Ingrédients

* 1 300 g de farine
* 200 g de sucre
* 150 g de noix
* 150 cl d'huile
* 150 g de beurre
* 10 dl de miel
* 15 dl d'eau
* 70 cl de jus d'orange
* 20 cl de cognac
* 10 g de cannelle
* 6 g de bicarbonate de soude
* 1 orange

## Préparation

* Mélanger le beurre, l'huile et 50 g de sucre
* Ajouter le bicarbonate dissout dans le jus d'orange, le cognac et le zeste d’orange râpés
* Petit à petit, ajouter la farine
* Former des bâtonnets de 7 cm sur 3
* Enfourner a 180°C pendant 25 min
* Bouillir l'eau, le sucre et le miel, versez le sirop sur les biscuits tièdes, saupoudrer de noix concassées
# Livre de cuisine/Meringue

La meringue est une pâtisserie légère et fine à base d'un mélange de blancs d'œufs et de sucre, cuit doucement. Elle est typique des cuisines française, italienne et suisse, chacune ayant de petites différences.

### Les meringues

* Meringue française
* Meringue italienne
* Meringue suisse
* Wikipédia propose un article sur : « meringue ».
* Le Wiktionnaire possède une entrée pour « meringue ».
* Wikimedia Commons propose des documents multimédia sur meringue.
# Mathc matrices/Fichiers c : fp e mr

Déterminant

## Opérations élémentaires

* La fonction swapR_mR; échange deux lignes.
* La fonction mulR_mR; multiplie la ligne r par un scalaire.
* La fonction addR_mR;
* La fonction swapC_mR; échange deux colonnes.
* La fonction mulC_mR; multiplie la colonne c par un scalaire.
* La fonction addC_mR;
* La fonction pivotbest_mR; sélectionne le bon pivot.
* La fonction zero_under_pivot_mR; met zéro sous le pivot
* La fonction swapC_withR0_mR; échange deux colonnes avec l'index
* La fonction swapcoefR0_mR; échange deux index sans toucher aux colonnes
# Mathc matrices/Fichiers c : fp mr

Application
Installer et compiler ce fichier dans votre répertoire de travail.
La fonction fp_mR; est identique à la fonction p_mR; mais elle écrit les matrices dans un fichier texte.
# Photographie/Fabricants/Sunpak/Sunpak 7 R
## Caractéristiques

Caractéristiques générales :
| Type de flash | annulaire |
| Pays de fabrication | |
| Disponibilité | |
| Prix | |
| Appareils compatibles | |
| Caractéristiques lumineuses ||
| Nombre-guide pour 100 ISO | |
| Variation de puissance | 3 puissances |
| Alimentation | piles |
| Nombre d'éclairs par charge | 40 à pleine puissance |
| Temps de recyclage (s) | 10-12 à pleine puissance |
| Angle de champ (°) | 100 |
| Durée de l'éclair | 1/1.000 |
| Température de couleur (K) | 5.800 |
| Autres caractéristiques ||
| Modes de commande | |
| Automatismes | |
| Dimensions LxHxP (mm) | |
| Poids (g) | |
| Divers ||
| Accessoires dédiés | |
| Particularités | |
# Programmation

* Programmation
* un livre appartenant à la série Programmation
* et à l'étagère Informatique de Wikilivres.
Ce livre se propose d'expliquer clairement et intuitivement les concepts de base liés à la programmation sur ordinateur et des machines qui en dérivent. Il proposera également à la fin un panorama des langages de programmation afin de permettre au programmeur de pouvoir choisir le langage qui lui convient le mieux à ses algorithmes et son environnement.

## Sommaire

* Une version imprimable du livre « Programmation » est disponible. (voir/ modifier)
* Ce livre est un wiki et peut par conséquent être amélioré par tout le monde. N'hésitez pas à  participer !
Consultez également ces pages dans d’autres projets Wikimedia :
* Article encyclopédique sur Wikipédia.
* Définition sur Wiktionnaire.
* Ressources éducatives sur Wikiversité.
* Citations sur Wikiquote.
* Historique
* Abstraction

### Concepts de base

* Commentaires
* Instructions
* Variables
* Types
* Expressions
* Comparaisons
* Instructions de contrôle
* Entrées-sorties

### Concepts spécifiques

* Manipulation de chaînes
* Procédures et fonctions
* Gestion de mémoire
* Gestion des exceptions
* Paradigmes de programmation
* Programmation séquentielle
* Programmation concurrente
* Programmation impérative
* Programmation orientée objet
* Programmation générique
* Programmation orientée aspect
* Programmation fonctionnelle
* Programmation logique
* Programmation par contrat

### Logiciels

* Eclipse
* NetBeans
* PhpStorm
* PyCharm
* SciTE
* Visual Studio Code

### Annexes

* Structure et style
* Règles de programmation
* Langages

## Livres annexes

* Programmation algorithmique
* Patrons de conception
* Programmer en deux minutes
* À la découverte d'Unicode
* Moteur de jeu Godot
# Programmation/Glossaire
## Glossaire de la programmation

Ce glossaire permet de trouver une définition simple et concise du vocabulaire spécifiquement lié à la programmation, et plus particulièrement les termes qu'on trouve au sein de ce Wikilivre.
* Glossaire
* A -
* B -
* C -
* D -
* E -
* F -
* G -
* H -
* I -
* J -
* K -
* L -
* M -
* N -
* O -
* P -
* Q -
* R -
* S -
* T -
* U -
* V -
* W -
* X -
* Y -
* Z -
* Autres

## Voir aussi

Consultez également ces pages dans d’autres projets Wikimedia :
# Programmation/Entrées-sorties

* Historique
* Abstraction

## Concepts de base

* Commentaires
* Instructions
* Variables
* Types
* Expressions
* Comparaisons
* Instructions de contrôle
* Entrées-sorties

## Concepts spécifiques

* Manipulation de chaînes
* Procédures et fonctions
* Gestion de mémoire
* Gestion des exceptions
* Paradigmes de programmation
* Programmation séquentielle
* Programmation concurrente
* Programmation impérative
* Programmation orientée objet
* Programmation générique
* Programmation orientée aspect
* Programmation fonctionnelle
* Programmation logique
* Programmation par contrat

## Logiciels

* Eclipse
* NetBeans
* PhpStorm
* PyCharm
* SciTE
* Visual Studio Code

## Annexes

* Structure et style
* Règles de programmation
* Langages
* Historique
* Abstraction

## Concepts de base

* Commentaires
* Instructions
* Variables
* Types
* Expressions
* Comparaisons
* Instructions de contrôle
* Entrées-sorties

## Concepts spécifiques

* Manipulation de chaînes
* Procédures et fonctions
* Gestion de mémoire
* Gestion des exceptions
* Paradigmes de programmation
* Programmation séquentielle
* Programmation concurrente
* Programmation impérative
* Programmation orientée objet
* Programmation générique
* Programmation orientée aspect
* Programmation fonctionnelle
* Programmation logique
* Programmation par contrat

## Logiciels

* Eclipse
* NetBeans
* PhpStorm
* PyCharm
* SciTE
* Visual Studio Code

## Annexes

* Structure et style
* Règles de programmation
* Langages
[ Modifier le sommaire ]
Cette page est considérée comme une ébauche à compléter . Si vous possédez quelques connaissances sur le sujet, vous pouvez les partager en éditant dès à présent cette page (en cliquant sur le lien « »).
Ressources suggérées : Aucune (vous pouvez indiquer les ressources que vous suggérez qui pourraient aider d'autres personnes à compléter cette page dans le paramètre « ressources » du modèle engendrant ce cadre)
Les fonctions d'entrées-sorties sont des fonctions de l'API du langage de programmation permettant de réaliser des entrées (lecture de données) et des sorties (écriture de données) depuis / vers un flux d'entrée-sortie (console, fichier, socket, ...).
Par exemple :
* lire depuis le clavier, écrire sur l'écran,
* lire depuis un fichier, écrire dans un fichier,

## Interactions avec l'utilisateur

C'est pour faciliter les entrées et les sorties de données que des interfaces sont programmées. Elles doivent être simples et lisibles.
# Programmation/Glossaire/A

<< Retour au glossaire

# Al

* Algorithme : C'est une suite finie et non ambiguë d’opérations ou d'instructions permettant de résoudre un problème.
* ALU : C'est l'organe de l'ordinateur chargé d'effectuer les calculs. Le plus souvent, l'UAL est incluse dans l'unité centrale ou le microprocesseur.

# An

* Analyse :
* Annuaire :

# Ap

* API :
* Application :

# As

* ASCII : C'est une norme de codage de caractères en informatique ancienne et connue pour son influence incontournable sur les codages de caractères qui lui ont succédé. Elle était la plus largement compatible pour ce qui est des caractères latins non accentués.
* Assembleur : Application permettant de transformer du code assembleur en langage machine.
* Glossaire
* A -
* B -
* C -
* D -
* E -
* F -
* G -
* H -
* I -
* J -
* K -
* L -
* M -
* N -
* O -
* P -
* Q -
* R -
* S -
* T -
* U -
* V -
* W -
* X -
* Y -
* Z -
* Autres
# Programmation PHP avec Symfony/Bundle

* Introduction
* Service
** Contrôleur
** Commande
* Composant
** HttpClient
** Évènement
** Formulaire
** Mailer
** Stimulus
* Bundle
** Twig
** Doctrine
** API
* Introduction
* Service
** Contrôleur
** Commande
* Composant
** HttpClient
** Évènement
** Formulaire
** Mailer
** Stimulus
* Bundle
** Twig
** Doctrine
** API
[ Modifier le sommaire ]
Dans Symfony, on appelle bundle une bibliothèque prévue pour être installée dans Symfony comme module complémentaire au framework.

## Configurer un bundle

Après installation avec composer, il doit généralement être configuré dans le dossier config/ par un fichier YAML à son nom. Pour connaître les configurations possibles :
La classe du bundle est instanciée dans :
Pour l'activer ou le désactiver de certains environnements, il suffit de l'ajouter un paramètre. Ex :

## Créer un bundle

Par rapport à une application classique, la création d'un bundle possède des particularités du fait qu'il n'est prévu pour être utilisé que comme dépendance d'applications tierces. Par exemple :
* Ses namespaces doivent démarrer par le nom du vendor et se terminer par le mot Bundle (ex : Symfony\Bundle\FrameworkBundle).
* Il doit contenir un fichier point d'entrée dans sa racine (ex : FrameworkBundle.php).
* Il peut avoir un .yaml de configuration dans config/packages à créer automatiquement à l'installation grâce à une classe étendant ConfigurationInterface.

## Principaux bundles

Packagist propose une liste des bundles Symfony les plus utilisés.

### SensioFrameworkExtraBundle

Permet de créer des annotations.

### FOS

FriendsOfSymfony propose plusieurs bundles intéressants, parmi lesquels :
* FOSUserBundle : pour gérer des utilisateurs.
* FOSRestBundle : pour les API REST.

### KNP

KNP Labs offre également plusieurs bundles connus, dont un paginateur.

### SonataAdmin

Ce bundle permet de créer rapidement un back-office pour lire ou modifier une base de données.

### EasyAdmin

Mêmes principales fonctions que SonataAdmin mais plus léger.
Installation :
Pour l'accueil :
Pour une liste paginée d'entités Doctrine modifiables, avec liens vers leurs CRUD :

### The PHP League

Voir https://github.com/thephpleague.

## Références

* ↑ https://symfony.com/doc/current/bundles/best_practices.html
* ↑ https://symfony.com/doc/current/bundles/configuration.html#processing-the-configs-array
* ↑ https://packagist.org/packages/symfony/?query=symfony%20bundle&tags=symfony
* ↑ https://symfony.com/bundles/SensioFrameworkExtraBundle/current/index.html
* ↑ https://github.com/FriendsOfSymfony
* ↑ https://github.com/KnpLabs
* ↑ https://github.com/sonata-project/SonataAdminBundle
* ↑ https://symfony.com/bundles/EasyAdminBundle/current/index.html
# Programmation PHP avec Symfony

* La lecture préalable de Programmation PHP est conseillée.
* Une version imprimable du livre « Programmation PHP avec Symfony » est disponible. (voir/ modifier)
Ce livre décrit l'utilisation du framework PHP Symfony.
* Introduction
* Service
** Contrôleur
** Commande
* Composant
** HttpClient
** Évènement
** Formulaire
** Mailer
** Stimulus
* Bundle
** Twig
** Doctrine
** API
# Python pour le calcul scientifique/Polynômes

Les fonctions spécifiques aux polynômes sont dans le sous-module numpy.polynomial.polynomial. Comme ce préfixe est fastidieux à taper, nous l'abrégeons en nppol. L'en-tête du programme est donc :
Par la suite, on peut manipuler les polynômes de deux manières : soit sous la forme d'un vecteur de coefficients, soit sous la forme d'une classe.

## Vecteur de coefficients

Le polynôme a$_0$ + a$_1$⋅x + a$_2$⋅x$^2$ est décrit par le vecteur [a0, a1, a2] (ou par le n-uplet (a0, a1, a2)). Pour évaluer le polynôme avec une valeur x donnée, on utilise :
où x peut être une matrice, le résultat étant alors la matrice des résultats. Cela utilise la méthode de Horner.
Pour connaître les racine d'un polynôme :
À l'inverse, si l'on veut avoir les coefficients du polynôme ayant pour racines r$_1$, r$_2$ et r$_3$, c'est-a-dire le polynôme (x – r$_1$)⋅(x – r$_2$)⋅(x – r$_3$), on utilise :
On peut aussi évaluer un polynôme défini directement par ses racines :
Le vecteur du affine polynôme a$_0$ + a$_1$⋅x, donc le vecteur [a0, a1], s'obtient avec
NumPy propose des polynômes élémentaires :
On peut effectuer les opérations polynomiales suivantes :

## Régression polynomiale

Si l'on a un nuage de points M(x, y), les variables x et y étant des vecteurs de même taille, alors on peut déterminer le « meilleur polynôme » de degré d décrivant le nuage de points M c'est-à-dire la fonction polynôme ayant le plus petit écart quadratique. Cette régression polynomiale se fait de la manière suivante :
nppol.polyfit(x, y, d)
Par exemple :
Si l'on veut forcer certains coefficients à zéro, on n'indique non pas le degré du polynôme mais la liste des degrés qu'il contient. Par exemple, pour imposer a$_0$ = 0 :

## Classe Polynomial

Le module propose la classe Polynomial. Le polynôme a donc une représentation propre et dispose de méthodes optimisées.
Les exemples ci-dessus deviennent :
Les opérations classiques s'appliquent aux polynômes : +, -, *, //, %, divmod, **. La dérivation et l'intégration s'obtiennent avec :
Pour obtenir le vecteur des coefficients, on peut utiliser :
Pour reprendre l'exemple de régression polynomiale ci-dessus :

## Notes et références

Manipulation de matrices < ↑ > Statistiques
# Python pour le calcul scientifique/Calcul symbolique

Rappelons que dorénavant les programmes commencent tous par :

## Symboles

Le module sympy permet de faire du calcul symbolique. Il permet de déclarer des variables comme symboles puis, en utilisant les fonctions du module (comme par exemple sympy.sin pour le sinus), d'obtenir des calculs conservant les symboles.
Par exemple :

## Notes et références

Résolution d'équations < ↑ > Traitement d'images
# Python pour le calcul scientifique/Premiers programmes
## Premier programme

Écrivons un programme qui effectue les opérations suivantes :
* affiche un texte demandant de saisir un nombre entier ;
* saisie d'une valeur par l'utilisateur et affectation à une variable ;
* vérification que c'est bien un nombre entier qui a été saisi ;
* le cas échéant, affichage du résultat d'un calcul simple (ajouter 5 au nombre saisi), sinon affiche un message d'erreur ;
* affiche un message de fin.
Exemple :
Nous avons les commandes suivantes :
* variable = valeur (opérateur « égal ») : affectation d'une valeur à une variable ;
* input(chaîne) : affiche la chaîne et permet de saisir une chaîne de caractère ;
* variable.isdigit : fonction indiquant si la variable ne contient que des chiffres (valeur booléenne vraie, True) ou pas (False) ;
* if booléen: […] else: (structure de contrôle) : teste le booléen après if,
** s'il est vrai, exécute le bloc d'instructions qui suit,
** s'il est faux, exécute le bloc d'instructions qui suit else ;
* float(expression) : transforme l'expression en un nombre décimal à virgule flottante ;
* nombre + nombre (opérateur « plus » entre deux nombres) : addition ;
* print(expression) : affiche l'expression ; la chaîne de caractères \n provoque un retour à la ligne.
Dans la structure de contrôle if […] else, un bloc d'instruction est la série de lignes :
* qui suit le deux-points « : » ;
* qui commence par l'indentation de quatre espaces.
Les espaces en début de ligne sont donc importants.
On peut rédiger le même programme « à la sauce » C :
On commence par définir une fonction principale appelée main puis on appelle cette fonction. La définition de la fonction est de la forme : def nomDeFonction:<bloc d'instructions>. Ici encore, le bloc d'instructions est la série de commandes qui suit le deux-points et commence par une indentation. Le bloc d'instruction se termine à la première ligne qui n'a pas d'indentation ; il contient lui-même des blocs d'instructions.

## Deuxième programme

Écrivons un programme qui effectue les opérations suivantes :
* affiche un texte demandant de saisir une chaîne de caractères ;
* saisie d'une chaîne de caractères par l'utilisateur et affectation à une variable ;
* première ligne : affichage de la première et de la dernière lettre du mot ;
* deuxième ligne : affichage des deux premières et des deux dernières lettres ;
* le tout étant justifié (aligné à gauche et à droite).
Exemple :

## Notes et références

Découverte de Python et de Jupyter < ↑ > Fonctions mathématiques générales
# Étude scientifique de la technique du piano

Techniques pianistiques
Y a t-il des techniques différentes ou une seule et même technique ? La diversité des conceptions est impressionnante. « Il faudrait des efforts désespérés pour résumer les opinions et les enseignements sur le toucher pianistique » (Ludwig Riemann). Devant cette hétérogénéité, cherchons à découvrir une logique, à dégager une ligne directrice de l’évolution historique et méthodique de l’ensemble de ces enseignements. Trois notions :
* L’écriture pianistique désigne l’ensemble des procédés utilisés pour adapter un contenu musical selon les exigences spécifiques du piano et de son jeu ;
* La technique désigne l’ensemble des mouvements du pianiste ;
* La technologie est la théorie des techniques, qui explique en théorie ce que les grands pianistes ont fait par instinct. C’est une science dont l’objet est de décrire les mouvements pianistiques, de les analyser, de les expliquer.

## Sommaire

* 7/78
* La formation pré-scientifique de la technique
* L’étude scientifique de la technique
* L’apprentissage méthodique de la technique
* Épilogue
* Auteurs
# Étude scientifique de la technique du piano/Auteurs

* La formation pré-scientifique de la technique
* L’étude scientifique de la technique
* L’apprentissage méthodique de la technique
* Épilogue
* Auteurs
Ce wikilivre a été initié par Gerd Kaemper sur Wikipédia puis transféré et mis en forme sur Wikilivres.
# Étude scientifique de la technique du piano/Sommaire

* La formation pré-scientifique de la technique
* L’étude scientifique de la technique
* L’apprentissage méthodique de la technique
* Épilogue
* Auteurs
# Viscères du thorax

Retour à Anatomie.

## Cœur

Le cœur est l'organe clé du corps humain.Celui-ci se retrouve dans le thorax,donc protégé par celui-ci, avec les poumons. Il est situé dans le médiastin antérieur et recouvert sur ces parties latéraux par les poumons. Le cœur est composé de 2 ventricules et de 2 oreillettes.
# Boîte à jeux/Snaps
## Déroulement

Le premier joueur choisi une personnalité, et décompose son nom. Ex: Johnny Hallyday -> J O H N N Y H A L L Y D A Y
Puis il annonce le début du jeu par la phrase « Snaps est le nom du jeu le nom du jeu est Snaps ». Ensuite il épelle la liste des lettres du nom :
* Si c'est une voyelle il claque des doigts :
** 1 fois pour le A,
** 2 fois pour le E,
** 3 fois pour le I,
** 4 fois pour le O,
** 5 fois pour le U,
** 6 fois pour le Y.
* Si c'est un consonne il dit une phrase commençant par cette lettre.
Ex :
* Snaps est le nom du jeu le nom du jeu est Snaps
* Je pense que c'est facile
* 4 claquements
* Hâtez-vous il n'est pas dur.
* Ne vous déconcentrez pas
* Ne vous déconcentrez pas j'ai dit
* 6 claquements
* Honteux vous êtes si vous ne trouvez pas
* 1 claquement
* La fin est proche
Une fois que vous avez fini le nom ne dites plus rien, les autres joueurs pourraient penser que vous continuer d’épeler.
Le premier joueur qui trouve la personnalité choisie gagne la manche et devient le joueur menant le jeu.
# Boîte à jeux/Vocabulaire

Cette page présente le sens précis des mots communément utilisés dans la plupart des jeux de cartes.

## Jeu de cartes

Jeu de 32 cartes :
* Couleur
* Pique
* Cœur
* Trèfle
* Carreau
Les cartes supplémentaires dans un jeu de 54 cartes :
* Couleur
* Pique
* Cœur
* Trèfle
* Carreau
# C++ pour .NET

Livres sur le C++ répondant aux spécifications CLI (managed code) :
# Boîte à jeux/Yams

1 joueur à illimité
durée d'une partie :
Matériel : 5 dés à six faces
Règles : Les joueurs jettent les dés et doivent former des combinaisons. Ils ont le droit de lancer les dés 3 fois de suite, tout en sélectionnant les dés qu'ils souhaitent garder. Ils tentent une combinaison par session de jeu.
À la fin de la phase de lancer des dés, ils choisissent dans quelle combinaison ils inscrivent leurs résultat, le nombre de points obtenus varie avec le choix de la combinaison. S'il ne peuvent jouer la combinaison voulue, ils doivent se reporter sur un autre choix ou bien, si aucune autre combinaison n'est possible, inscrire 0 dans la case de la combinaison voulue.
Le tableau des scores est divisés en 2 sections (partie mineure et majeure). Ils peuvent inscrire un bonus en fonction du nombre de points obtenus dans la partie mineure.

## Combinaisons

Partie mineure
* Maximum de 1: les joueurs doivent obtenir le plus grand nombre de dés avec la face 1 / ils marquent 1 fois le nombre de dés de valeur 1
* Maximum de 2: les joueurs doivent obtenir le plus grand nombre de dés avec la face 2 / ils marquent 2 fois le nombre de dés de valeur 2
* Maximum de 3: les joueurs doivent obtenir le plus grand nombre de dés avec la face 3 / ils marquent 3 fois le nombre de dés de valeur 3
* Maximum de 4: les joueurs doivent obtenir le plus grand nombre de dés avec la face 4 / ils marquent 4 fois le nombre de dés de valeur 4
* Maximum de 5: les joueurs doivent obtenir le plus grand nombre de dés avec la face 5 / ils marquent 5 fois le nombre de dés de valeur 5
* Maximum de 6: les joueurs doivent obtenir le plus grand nombre de dés avec la face 6 / ils marquent 6 fois le nombre de dés de valeur 6
Ils obtiennent un bonus de 35 points si le total de la partie mineure est supérieure à 63 points.
Partie majeure
* Brelan : les joueurs doivent obtenir 3 dés de même valeur / ils marquent 3 fois la valeur des dés identiques
* Carré : les joueurs doivent obtenir 4 dés de même valeur / ils marquent 4 fois la valeur des dés identiques
* Full : les joueurs doivent obtenir 3 dés de même valeur et 2 dés de même valeur - (brelan + paire) / ils marquent 25 points
* Petite Suite : les joueurs doivent obtenir 4 dés qui se suivent (1-2-3-4 / 2-3-4-5 / 3-4-5-6) / ils marquent 30 points
* Grande Suite : les joueurs doivent obtenir 5 dés qui se suivent (1-2-3-4-5 / 2-3-4-5-6) / ils marquent 40 points
* Yams : les joueurs doivent obtenir 5 dés de même valeur / ils marquent 50 points
* Chance : les joueurs doivent obtenir le plus grand nombre de points / ils marquent la somme de la valeur des dés
En fonction du total (bonus inclus) de la partie mineure et de la partie majeure, le vainqueur est désigné.

## Voir aussi

* Grille du jeu de Yams
# Boîte à jeux/Zanzi

À partir de 3 joueurs
durée d'une partie: 20mn
But de jeu: Faire ZANZI, c'est-à-dire tirer 3 dés de même valeur.
Matériel: 3 dés à six faces
Règles: On dit ZANZI d'as ou de 6 ou de 5. Si personne ne fait ZANZI on totalise les dés suivants :
As : 10 points, - 6 : 6 points, - 5 : 5 points, --- etc.
Marche du jeu : Jeter les dés. Si le jeu ne plaît pas reprendre un ou deux dés et les relancer au maximum 3 fois.
Si le premier joueur ne lance qu'une ou 2 fois, les suivants doivent faire de même. S'il y a rampot, départager par un coup sec.
Variante : Le premier joueur peut déterminer la manière de jouer suivant son propre jeu. S'il a peu de points, il annonce « PETIT » ce qui oblige les adversaires à faire plus petit que lui.
Au contraire, il peut annoncer « GROS » pour obliger à faire plus fort.