Forum |  HardWare.fr | News | Articles | PC | Prix | S'identifier | S'inscrire | Shop Recherche
1854 connectés 

  FORUM HardWare.fr
  Programmation
  PHP

  convertir des chiffres litéraus en nombre

 



 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

convertir des chiffres litéraus en nombre

n°2370600
PierreC
Posté le 08-12-2020 à 09:35:28  profilanswer
 

Bonjour,
  C'est plus un problème d'algo que de php.  
  J'ai besoin de convertir des nombre écrit en lettre, en chiffre. Mais pas juste UN, DEUX, TROIS, cela doit aller jusqu'au MILLION.Exemple :  
TROIS CENTS MILLE QUARANTE DEUX  sera convertit en 300042
des idées ?
Merci
Pierre


---------------
Du tofu en Alsace : www.tofuhong.com
mood
Publicité
Posté le 08-12-2020 à 09:35:28  profilanswer
 

n°2370642
rufo
Pas me confondre avec Lycos!
Posté le 08-12-2020 à 13:14:32  profilanswer
 

Dans mon soft CanteenCalandreta, j'ai utilisé ce script Nuts.php :

Code :
  1. <?php
  2. /**
  3. * Conversion d'un nombre quelconque en lettres.
  4. *
  5. * @author Antoine MATTEI (a.mattei@free.fr)
  6. * @version 0.2
  7. */
  8.  
  9. class nuts {
  10.    const DEBUG = FALSE;
  11.    private $nb, $decSep, $unit;
  12.    private $parts = array();
  13.    private $separators = array(
  14.                                "fr-FR" => array(', ', '-', ' ', ' '),
  15.                                "en-EN" => array(', ', '-', ' ', ' '),
  16.                                "pt-PT" => array(' e ', ' e ', ' e ', ' e ')
  17.                               );
  18.  
  19.    private $units = array("USD" => array(100,
  20.                                          "fr-FR" => array('dollar', 'dollars', 'centime', 'centimes', '', ''),
  21.                                          "pt-PT" => array('dollar', 'dollars', 'cêntimo', 'cêntimos', 'm', 'm'),
  22.                                          "en-EN" => array('dollar', 'dollars', 'cent', 'cents', '')
  23.                                         ),
  24.                           "EUR" => array(100,
  25.                                          "fr-FR" => array('euro', 'euros', 'centime', 'centimes', '', ''),
  26.                                          "pt-PT" => array('euro', 'euros', 'cêntimo', 'cêntimos', 'm', 'm'),
  27.                                          "en-EN" => array('euro', 'euros', 'cent', 'cents', '', '')
  28.                                         ),
  29.                           "t" => array(1000,
  30.                                        "fr-FR" => array('tonne', 'tonnes', 'kilo', 'kilos', '', ''),
  31.                                        "pt-PT" => array('tonelada', 'toneladas', 'quilo', 'quilos', 'f', 'm'),
  32.                                        "en-EN" => array('ton', 'tons', 'kilogram', 'kilograms', '', '')
  33.                                       )
  34.                          );
  35.  
  36.    private $numbers = array(
  37.                             "fr-FR" => array(
  38.                                              0 => array('zéro', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 'huit', 'neuf'),
  39.                                              1 => array('dix', 'vingt', 'trente', 'quarante', 'cinquante', 'soixante', 'soixante-dix', 'quatre-vingts', 'quatre-vingt-dix'),
  40.                                              2 => array('cent', 'cents'),
  41.                                              3 => array('mille', 'mille'), /* Règle 3 */
  42.                                              6 => array('million', 'millions'),
  43.                                              9 => array('milliard', 'milliards')
  44.                                             ),
  45.                             "pt-PT" => array(
  46.                                              0 => array('zero', 'um', 'dois', 'três', 'quatro', 'cinco', 'seis', 'sete', 'oito', 'nove'),
  47.                                              1 => array('dez', 'vinte', 'trinta', 'quarenta', 'cinquenta', 'sessenta', 'setenta', 'oitenta', 'noventa'),
  48.                                              2 => array('cem', 'cem', 'f'),
  49.                                              3 => array('mil', 'mil', 'f'),
  50.                                              6 => array('milhão', 'milhões', 'm'),
  51.                                              9 => array('mil milhões', 'mil milhões', 'm')
  52.                                             ),
  53.                             "en-EN" => array(
  54.                                              0 => array('zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'),
  55.                                              1 => array('ten', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'),
  56.                                              2 => array('hundred', 'hundred'),
  57.                                              3 => array('thousand', 'thousand'),
  58.                                              6 => array('million', 'millions'),
  59.                                              9 => array('billion', 'billions')
  60.                                             )
  61.                            );
  62.  
  63.    private $localExceptions = array(
  64.                                     "fr-FR" => array(
  65.                                                      array("/dix-un/", "onze" ),
  66.                                                      array("/dix-deux/", "douze" ),
  67.                                                      array("/dix-trois/", "treize" ),
  68.                                                      array("/dix-quatre/", "quatorze" ),
  69.                                                      array("/dix-cinq/", "quinze" ),
  70.                                                      array("/dix-six/", "seize" ),
  71.                                                      array("/-un/", " et un" ), /* Règle 1 */
  72.                                                      array('/^et /', ''),
  73.                                                      array("/soixante-onze/", "soixante et onze" ), /* Règle 2 */
  74.                                                      array('/^-/', ''),
  75.                                                      array('/ zéro$/', "" ),
  76.                                                      array("/-zéro/", "" ),
  77.                                                      array("/cents /", "cent " ), /* Règle 4 */
  78.                                                      array('/cent et/', 'cent'),
  79.                                                      array('/cents et/', 'cents'),
  80.                                                      array('/-$/', "" ),
  81.                                                      array("/vingts-/", "vingt-" ), /* Règle 4 */
  82.                                                      array("/un cent/", "cent" ),
  83.                                                      array("/^un mille/", "mille" ),
  84.                                                      array("/cent millions/", "cents millions" ), /* Règle 5 */
  85.                                                      array("/cent milliards/", "cents milliards" ) /* Règle 5 */
  86.                                                     ),
  87.                                     "pt-PT" => array(
  88.                                                      array('/^ e zero$/', 'zero'),
  89.                                                      array('/ zero$/', ''),
  90.                                                      array('/ e zero/', ''),
  91.                                                      array("/dez e um/", "onze" ),
  92.                                                      array("/dez e dois/", "doze" ),
  93.                                                      array("/dez e três/", "treze" ),
  94.                                                      array("/dez e quatro/", "catorze" ),
  95.                                                      array("/dez e cinco/", "quinze" ),
  96.                                                      array("/dez e seis/", "dezasseis" ),
  97.                                                      array("/dez e sete/", "dezassete" ),
  98.                                                      array("/dez e oito/", "dezoito" ),
  99.                                                      array("/dez e nove/", "dezenove" ),
  100.                                                      array("/um e cem/", "cem" ),
  101.                                                      array("/dois e cem/", "e duzentos" ),
  102.                                                      array('/e duzentos e /', 'duzentos e '),
  103.                                                      array('/três e cem/', 'e trezentos'),
  104.                                                      array('/e trezentos e /', 'trezentos e '),
  105.                                                      array("/quatro e cem/", "e quatro centos" ),
  106.                                                      array('/e quatro centos e /', 'quatro centos e '),
  107.                                                      array('/cinco e cem/', 'e quinhentos'),
  108.                                                      array('/e quinhentos e /', 'quinhentos e '),
  109.                                                      array("/seis e cem/", "e seiscentos" ),
  110.                                                      array('/e seiscentos e /', 'seiscentos e '),
  111.                                                      array("/sete e cem/", "e setecentos" ),
  112.                                                      array('/e setecentos e /', 'setecentos e '),
  113.                                                      array("/oito e cem/", "e oitocentos" ),
  114.                                                      array('/e oitocentos e /', 'oitocentos e '),
  115.                                                      array("/nove e cem/", "e novecentos" ),
  116.                                                      array('/e novecentos e /', 'novecentos e '),
  117.                                                      array('/cem e /', 'cento e '),
  118.                                                      array('/ e$/', ''),
  119.                                                      array('/^e$/', ''),
  120.                                                      array('/um mil$/', 'mil')
  121.                                                     ),
  122.                                     "en-EN" => array(
  123.                                                      array("/ten-one/", "eleven" ),
  124.                                                      array("/ten-two/", "twelve" ),
  125.                                                      array("/ten-three/", "thirteen" ),
  126.                                                      array("/ten-four/", "fourteen" ),
  127.                                                      array("/ten-five/", "sixteen" ),
  128.                                                      array("/ten-six/", "sixteen" ),
  129.                                                      array("/ten-seven/", "seventeen" ),
  130.                                                      array("/ten-height/", "eighteen" ),
  131.                                                      array("/ten-nine/", "nineteen" ),
  132.                                                      array('/^-/', ''),
  133.                                                      array("/-zero/", "" ),
  134.                                                      array("/hundred /", "hundred and " ),
  135.                                                      array('/hundred-/', 'hundred and '),
  136.                                                      array('/hundred and thousand/', 'hundred thousand'),
  137.                                                      array("/ and zero/", "" )
  138.                                                     )
  139.                                    );
  140.  
  141.    private $partExceptions = array(
  142.                                    "fr-FR" => array(
  143.                                                     array("/ zéro/", "" ),
  144.                                                     array("/[[:blank:]].zéro/", "" ),
  145.                                                     array('/^-/', ''),
  146.                                                     array('/ -/', ' '),
  147.                                                     array('/million$/', "million de" ),
  148.                                                     array('/millions$/', "millions de" ),
  149.                                                     array('/milliard$/', "milliard de" ),
  150.                                                     array('/milliards$/', "milliards de" )
  151.                                                    ),
  152.                                    "pt-PT" => array(
  153.                                                     array('/ zero/', "" ),
  154.                                                     array('/^e /', ''),
  155.                                                     array('/milhões$/', 'milhões de'),
  156.                                                     array('/milhão$/', 'milhão de')
  157.                                                    ),
  158.                                    "en-EN" => array(
  159.                                                     array("/ zero/", "" ),
  160.                                                     array("/[[:blank:]].zero/", "" )
  161.                                                    )
  162.                                   );
  163.  
  164.    private $genderExceptions = array(
  165.                                      "fr-FR" => array(),
  166.                                      "pt-PT" => array(
  167.                                                       array('/um/', 'uma'),
  168.                                                       array('/dois/', 'duas'),
  169.                                                       array('/entos/', 'entas')
  170.                                                      ),
  171.                                      "en-EN" => array()
  172.                                     );
  173.  
  174.    private $globalExceptions = array(
  175.                                      "fr-FR" => array(
  176.                                                       array("/de e/", "d'e" )
  177.                                                      ),
  178.                                      "pt-PT" => array(),
  179.                                      "en-EN" => array()
  180.                                     );
  181.  
  182. /**
  183. * @param real $nb Nombre à convertir.
  184. * @abstract Formats acceptés : 1234 | 12,34 | 12.34 | 12 345.
  185. * Un seul caractère non numérique sera accepté et considéré comme le séparateur décimal en entrée.
  186. * @example
  187. * $obj = new nuts("12345.67", "EUR" );
  188. * $text = $obj->convert("fr-FR" );
  189. * $nb = $obj->getFormated(" ", "," );
  190. */
  191. function __construct($nb, $unit){
  192.    // Nettoyages.
  193.    $this->nb = str_replace(' ', '', $nb); // Suppession de tous les espaces.
  194.    $this->nb = preg_replace("/[A-Za-z]/", "", $this->nb);
  195.    $this->nb = preg_replace("/^0+/", "", $this->nb); // Suppression des 0 de tête.
  196.  
  197.    if ($this->nb == '') $this->nb = '0';
  198.  
  199.    $this->unit = $unit;
  200.  
  201.    // Séparateur.
  202.    $this->decSep = preg_replace("/[0-9]/", '', $this->nb); // On ne garde que ce qui n'est pas numérique
  203.    $this->decSep = substr($this->decSep, -1); // et on prend le dernier des caractères restants.
  204.  
  205.    // Partie entière et partie décimale.
  206.    if ($this->decSep == '') {
  207.        // Pas de partie décimale.
  208.        $this->parts[] = $this->nb;
  209.    } else {
  210.        // Ajout d'un 0 quand il manque devant le séparateur décimal.
  211.        // Noter le double \ pour échapper le séparateur . qui est un opérateur dans les expressions régulières.
  212.        $this->nb = preg_replace("/^\\" . $this->decSep . "/", "0" . $this->decSep, $this->nb);
  213.  
  214.        $this->parts = explode($this->decSep, preg_replace("/^[0-9] " . $this->decSep . "/", '', $this->nb));
  215.  
  216.        // Nettoyage partie décimale.
  217.        if ($this->parts[1] == ''){
  218.            unset($this->parts[1]);
  219.            $this->decSep = '';
  220.        } else {
  221.            // On coupe la partie décimale au nombre de caractères en fonction du rapport entre unité et sous-unité.
  222.            $this->parts[1] = substr($this->parts[1], 0, strlen($this->units[$this->unit][0]) - 1);
  223.  
  224.            // On bourre avec des 0 de fin.
  225.            while (strlen($this->parts[1]) < strlen($this->units[$this->unit][0]) - 1){
  226.                $this->parts[1] .= '0';
  227.            }
  228.        }
  229.    }
  230.  
  231.    if (nuts::DEBUG) echo "construct : [" . $this->nb . "]";
  232. }
  233.  
  234.  
  235. /**
  236. *
  237. */
  238. function __destruct(){
  239.  
  240. }
  241.  
  242.  
  243. /**
  244. * Module de traduction d'un groupe de 3 digits.
  245. *
  246. * @param string $group Groupe de 3 digits.
  247. * @param integer $unit Indice de l'unité concernée par $group.
  248. * @param string $language Langue demandée.
  249. * @param integer $gender Indice du genre dans le tableau (4 pour l'unité de mesure, 5 pour la sous-unité).
  250. */
  251. private function getThree($group, $unit, $language, $gender){
  252.    $return = "";
  253.  
  254.    if ($group == '') $group = 0;
  255.  
  256.    // Centaines.
  257.    if ($group >= 100) {
  258.        $hundreds = floor($group / 100);
  259.        if ($hundreds == 1) {
  260.            $return .= $this->numbers[$language][0][$hundreds] . $this->separators[$language][3] . $this->numbers[$language][2][0];
  261.        } else {
  262.            $return .= $this->numbers[$language][0][$hundreds] . $this->separators[$language][3] . $this->numbers[$language][2][1];
  263.        }
  264.  
  265.        $tens = $group % 100; // On enlève les centaines.
  266.    } else {
  267.        $tens = $group;
  268.    }
  269.  
  270.    // Dizaines et unités.
  271.    if ($tens >= 10) {
  272.        $return .= $this->separators[$language][2] . $this->numbers[$language][1][floor($tens / 10) - 1] . $this->separators[$language][1] . $this->numbers[$language][0][$tens % 10];
  273.    } else {
  274.        $return .= $this->separators[$language][1] . $this->numbers[$language][0][(int) $tens];
  275.    }
  276.  
  277.    if ($unit < 3){
  278.        // [0..999].
  279.    } else {
  280.        // 0, 1 ou n ?
  281.        if ($group == 0) {
  282.  
  283.        } elseif ($group == 1){
  284.            $return .= ' ' . $this->numbers[$language][$unit][0];
  285.        } else {
  286.            $return .= ' ' . $this->numbers[$language][$unit][1];
  287.        }
  288.    }
  289.  
  290.    if (nuts::DEBUG) echo "<br>local a [" . $return . "] ";
  291.    // Exceptions.
  292.    for ($i = 0; $i < count($this->localExceptions[$language]); $i++){
  293.        $return = trim(preg_replace($this->localExceptions[$language][$i][0], $this->localExceptions[$language][$i][1], $return));
  294.    }
  295.  
  296.    if (nuts::DEBUG) echo "<br>local b $unit [" . $return . "] ";
  297.    // Exceptions de genre.
  298.    if ( ($this->units[$this->unit][$language][$gender] == 'f' && $unit < 3)
  299.       || ($this->units[$this->unit][$language][$gender] == 'f' && $this->numbers[$language][$unit][2] == 'f')) {
  300.        // L'unité (tonelada) peut être de genre féminin mais les milliers ou millards peuvent être invariables en genre.
  301.        for ($i = 0; $i < count($this->genderExceptions[$language]); $i++){
  302.            $return = trim(preg_replace($this->genderExceptions[$language][$i][0], $this->genderExceptions[$language][$i][1], $return));
  303.        }
  304.    }
  305.  
  306.    if (nuts::DEBUG) echo "<br>local c [" . $return . "] ";
  307.    return $return;
  308. }
  309.  
  310.  
  311. /**
  312. * Formate la sortie numérique avec séparateurs décimal et des milliers souhaités.
  313. *
  314. * @param string $tSep Séparateur des milliers, en sortie.
  315. * @param string $dSep Séparateur décimal, en sortie.
  316. */
  317. function getFormated($tSep = '', $dSep = '.'){
  318.    if ($tSep == $dSep) {
  319.        // Les 2 séparateurs ne peuvent être identiques > valeurs par défaut.
  320.        $tSep = '';
  321.        $dSep = '.';
  322.    }
  323.  
  324.    $return = $this->format($this->parts[0], $tSep);
  325.    if ($this->decSep == '') {
  326.        // Pas de partie décimale.
  327.        $return .= ' ' . $this->unit;
  328.    } else {
  329.        $return .= $dSep . $this->parts[1] . ' ' . $this->unit;
  330.    }
  331.  
  332.    return $return;
  333. }
  334.  
  335.  
  336. /**
  337. * Formatage par groupe de 3 digits avec séparateur.
  338. *
  339. * @param string $nb Nombre à formater.
  340. * @param string $sep Séparateur de milliers (espace, virgule).
  341. * @todo Il faudra s'assurer que le séparateur n'est pas le même que le séparateur décimal qui a été identifié automatiquement.
  342. */
  343. private function format($nb, $sep){
  344.    $nb = strrev($nb);
  345.    $n = 0;
  346.    for ($i = 2; $i < strlen($nb); $i++){
  347.        if ($i % 3 == 0){
  348.            $nb = substr($nb, 0, $i + $n) . $sep . substr($nb, $i + $n);
  349.            $n++;
  350.        }
  351.    }
  352.  
  353.    return strrev(trim($nb));
  354. }
  355.  
  356.  
  357. /**
  358. * Effectue la conversion en texte de la partie entière ou décimale.
  359. *
  360. * @param string $nb Partie entière ou décimale.
  361. * @param string $language Langue à utiliser pour la sortie.
  362. * @param integer $gender Indice du genre dans le tableau (4 pour l'unité de mesure, 5 pour la sous-unité).
  363. */
  364. private function part($nb, $language, $gender){
  365.    $return = "";
  366.  
  367.    // Décodage par blocs de 3.
  368.    $groups = explode(' ', $this->format($nb, ' '));
  369.    for ($i = 0; $i < count($groups) ; $i++){
  370.        $return .= $this->getThree($groups[$i], (count($groups) - 1 - $i) * 3, $language, $gender) . ' ';
  371.    }
  372.  
  373.    $return = trim($return);
  374.  
  375.    if (nuts::DEBUG) echo "<br>part a : [" . $return . "]";
  376.    // Exceptions.
  377.    for ($i = 0; $i < count($this->partExceptions[$language]); $i++){
  378.        $return = trim(preg_replace($this->partExceptions[$language][$i][0], $this->partExceptions[$language][$i][1], $return));
  379.    }
  380.  
  381.    if (nuts::DEBUG) echo "<br>part b : [" . $return . "]";
  382.  
  383.    return $return;
  384. }
  385.  
  386.  
  387. /**
  388. * Demande la conversion en texte de chaque partie et ajoute les unités.
  389. *
  390. * @param string $language Langue à utiliser pour la sortie.
  391. */
  392. function convert($language){
  393.    // Partie entière.
  394.    $return = $this->part($this->parts[0], $language, 4) . " ";
  395.    $return .= ($this->parts[0] > 1) ? $this->units[$this->unit][$language][1] : $this->units[$this->unit][$language][0];
  396.  
  397.    // Exceptions.
  398.    for ($i = 0; $i < count($this->globalExceptions[$language]); $i++){
  399.        $return = trim(preg_replace($this->globalExceptions[$language][$i][0], $this->globalExceptions[$language][$i][1], $return));
  400.    }
  401.  
  402.    // Partie décimale.
  403.    if (count($this->parts) == 2){
  404.        $return .= $this->separators[$language][0] . $this->part($this->parts[1], $language, 5) . " ";
  405.        $return .= ($this->parts[1] > 1) ? $this->units[$this->unit][$language][3] : $this->units[$this->unit][$language][2];
  406.    }
  407.  
  408.    if (nuts::DEBUG) echo "<br>";
  409.    return $return;
  410. }
  411.  
  412. //Fin de la classe
  413. }
  414. ?>


 
Ca marche bien ;) Je m'en sers pour faire des reçus fiscaux.


Message édité par rufo le 08-12-2020 à 13:15:03

---------------
Astres, outil de help-desk GPL : http://sourceforge.net/projects/astres, ICARE, gestion de conf : http://sourceforge.net/projects/icare, Outil Cantine Calandreta : http://sourceforge.net/projects/canteen-calandreta
n°2370678
PierreC
Posté le 08-12-2020 à 15:24:27  profilanswer
 

Salut rufo, merci pour ta réponse.
 
Dans le commentaire en haut je lis "Conversion d'un nombre quelconque en lettres."
 
C'est l'inverse que je cherche :)


---------------
Du tofu en Alsace : www.tofuhong.com
n°2370737
rufo
Pas me confondre avec Lycos!
Posté le 08-12-2020 à 18:54:08  profilanswer
 

Ah, mince, j'ai lu trop vite. :(
La lib que j'ai postée pourra peut-être t'aider pour faire l'algo à l'envers.


---------------
Astres, outil de help-desk GPL : http://sourceforge.net/projects/astres, ICARE, gestion de conf : http://sourceforge.net/projects/icare, Outil Cantine Calandreta : http://sourceforge.net/projects/canteen-calandreta
n°2370892
rat de com​bat
attention rongeur méchant!
Posté le 09-12-2020 à 21:32:32  profilanswer
 

Il te faut un - mot anglais: "Parser". C'est toujours très drôle à écrire à la main... Il y a des générateurs ("parser generator" ) genre Yacc et machin mais je pense que ça doit faire usine à gaz. Sinon sur internet rien de tout fait?

n°2370893
rufo
Pas me confondre avec Lycos!
Posté le 09-12-2020 à 21:49:50  profilanswer
 

Yacc et lex, non ?


---------------
Astres, outil de help-desk GPL : http://sourceforge.net/projects/astres, ICARE, gestion de conf : http://sourceforge.net/projects/icare, Outil Cantine Calandreta : http://sourceforge.net/projects/canteen-calandreta
n°2370895
rat de com​bat
attention rongeur méchant!
Posté le 09-12-2020 à 21:53:53  profilanswer
 

Lex c'est un "lexer", pas un "parser", mais franchement ne me demande pas la différence, je suis pas ingé en info moi... Il faut les deux pour faire un compilateur, ça je le sais.

 

PS: Je suis tatillon mais ça me fait mal à l'oeil à chaque fois que je vais dans cette cat: chiffres litérauX.


Message édité par rat de combat le 09-12-2020 à 22:03:53
n°2370903
rufo
Pas me confondre avec Lycos!
Posté le 09-12-2020 à 22:28:13  profilanswer
 

Je les ai un peu étudié en école d'ingé. Les 2 permettent de créer une grammaire et un vocabulaire afin de créer un compilateur.
Tu crées un corpus et Lex va permettre de créer le scan line pour analyser la ligne. Yacc va s'occuper de la grammaire et de compiler le tout.
 
Mais bon, pour ce qu'il veux faire, c'est too much.


---------------
Astres, outil de help-desk GPL : http://sourceforge.net/projects/astres, ICARE, gestion de conf : http://sourceforge.net/projects/icare, Outil Cantine Calandreta : http://sourceforge.net/projects/canteen-calandreta
n°2370907
PierreC
Posté le 09-12-2020 à 22:44:05  profilanswer
 

oui un eu trop much :)
Je suis sur le point d'y arriver avec un algo basic qu'un lycéen pourrait écrire :)
J'arrive à convertir ca par exemple :  
deux cents quarante deux million quatre cent quatre vingt dix huit mille six cents vingt huit
 
l'algo est assez simple au final :  
DIX HUIT , c'est 10 + 8
CENT VINGT DEUX, c'est 100 + 20 + 2
TROIS CENTS c'est 3 * 100
TROIS CENTS VINGT DEUX : 3 * 100 + 20 + 2
SOIXANTE DIX SEPT : 60 + 10 + 7
 
Il faut deviner où mettre un plus, un fois, et une petite table de correspondance de chaîne en nombre (de un à seize, chaque dizaine, quatrevingt, cents, mille, million).
 
Petit soucis encore quand j'ai mille et cent qui se suivent, par exemple avec quatre cent mille cent six (4*100*1000*100+6 : ca marche pas :) )
 
Mais pas grand chose, un if à ajouter quelque part.


---------------
Du tofu en Alsace : www.tofuhong.com
n°2371259
MaybeEijOr​Not
but someone at least
Posté le 11-12-2020 à 19:55:24  profilanswer
 

Je n'ai pas eu le temps de finir, mais oui en lisant mot à mot ta chaîne de caractères c'est quand même faisable. Ta récursion prend en paramètre la phrase, le nombre, le coefficient et la base.
Pour l'instant j'étais parti sur les cas :
- coefficient suivi d'un coefficient = coefficient composé (dix-huit) donc coefficient n + coefficient n+1, à voir s'il faut traiter par le tiret.
- coefficient suivi de la base = coefficient x base
- base suivie de la base = nombre x base
- initialisation par coefficient = 1 si base détectée ou coefficient = coefficient si coefficient détecté
 
Mais comme toi ça chiadait avec ton exemple, je pense qu'il faut reset la base après qu'on ait une base qui suit une base.


---------------
C'est en écrivant n'importe quoi qu'on devient n'importe qui.

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  PHP

  convertir des chiffres litéraus en nombre

 

Sujets relatifs
Compter le nombre de caractères en CPuisssance d'un nombre(fonction récursive)
selectionner une suite de chiffres dans une routine de tri C++[MySQL] Ajouter un nombre à une colonne null
[Python] Exercice nombre premiers et fonction seuilConvertir un tableau Wordpress en format mobile AMP
[MySQL] Nombre de cours et exercices avec une seules requêteProblème avec WHERE et un nombre
C++ calcul d'un nombre prmierNombre limite de fichiers dans un répertoire ?
Plus de sujets relatifs à : convertir des chiffres litéraus en nombre


Copyright © 1997-2018 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR