convertir des chiffres litéraus en nombre

convertir des chiffres litéraus en nombre - PHP - Programmation

Marsh Posté le 08-12-2020 à 09:35:28    

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
Reply

Marsh Posté le 08-12-2020 à 09:35:28   

Reply

Marsh Posté le 08-12-2020 à 13:14:32    

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 Planeta Calandreta : https://framalibre.org/content/planeta-calandreta
Reply

Marsh Posté le 08-12-2020 à 15:24:27    

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
Reply

Marsh Posté le 08-12-2020 à 18:54:08    

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 Planeta Calandreta : https://framalibre.org/content/planeta-calandreta
Reply

Marsh Posté le 09-12-2020 à 21:32:32    

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?

Reply

Marsh Posté le 09-12-2020 à 21:49:50    

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 Planeta Calandreta : https://framalibre.org/content/planeta-calandreta
Reply

Marsh Posté le 09-12-2020 à 21:53:53    

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
Reply

Marsh Posté le 09-12-2020 à 22:28:13    

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 Planeta Calandreta : https://framalibre.org/content/planeta-calandreta
Reply

Marsh Posté le 09-12-2020 à 22:44:05    

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
Reply

Marsh Posté le 11-12-2020 à 19:55:24    

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.
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed