Javascript разбора строки в целое

Question

Работая над на codewars я пытался решить эту проблему:

В этом ката мы хотим, чтобы преобразовать строку в целое число. Строки просто представляют числа в словах.

Примеры:

• "один" => 1
• "двадцать" => 20
• "двести сорок шесть" => 246
• «семьсот восемьдесят три тысячи девятьсот девятнадцать "=> 783919

====================================================================================================================================================================================== ==========================================

Я придумал код ниже, чтобы сделать это. On jsfiddle for you convience.

Проблема я столкнулся в «семьсот тысяч» дает 10700.

Я провел целый день, глядя вокруг и пытается понять это, но я просто плоский застрял. Шаги, программа занимает:

• строка становится «тысяча сто семь» - хороший
• первым в то время как петля находки «Thousand» и устанавливают множитель 1000 - хороший
• второго в то время как петля находки «сто», но то оператор mult.exec (a [0]) if имеет значение null. - damn

Таким образом, вместо множителя, становящегося 100000, значение становится 100000, и мы обречены на неправильный ответ.

При попытке отладки это я попытался создать массив, используемый во время второго цикла в то время как в jsfiddle. Там он работал и приравнивался к «сто» вместо нуля. Кто-нибудь знает, почему это произойдет?

function parseInt(number) { 

    // reference array for english -> integer 
    var ref = { one:1, two:2, three:3, four:4, five:5, six:6, seven:7, eight:8, nine:9, ten:10, eleven:11, twelve:12, thirteen:13, fourteen:14, fifteen:15, sixteen:16, seventeen:17, eighteen:18, nineteen:19, twenty:20, thirty: 30, forty: 40, fifty: 50, sixty: 60, seventy: 70, eighty: 80, ninety:90, hundred: 100, thousand: 1000, million: 1000000 }; 

    // regex to find number values from the string 
    var find = new RegExp("(one|t(wo|hree|en|welve|hirteen|wenty|hirty)|f(our|ive|ourteen|iftenn|orty|ifty)|s(ixteen|ixty|eventy|ix|even|eventeen|teen)|eigh(ty|t|teen)|nin(ety|e|eteen)|zero|hundred|thousand|million)", "gi"); 

    // hundred/thousand/million etc. act as multipliers in this solution and need a seperate search 
    var mult = new RegExp("(hundred|thousand|million)", "gi"); 

    // reversing the string allows us to add largest digits first 
    number = number.split(' ').reverse().join(" "); 

    // while there is a number in string number 
    // if that number is a multiplier 
    //  if that number is 100 -> multiplier = multiplier * 100; 
    //  else multiplier = reference value; 
    // else value = value + reference value * multiplier 
    // end while 
    value = 0; multiplier = 1; 
    while(a = find.exec(number)) { 

     if(m = mult.exec(a[0])) { 

      if(m[0] == 'hundred') { multiplier *= 100; } 
      else { multiplier = ref[m[0]]; } 

     } 
     else { 

      value += ref[a[0]] * multiplier; 

     } 

    } 
    return value; 
} 

Answer 1

может быть, вам не нужно регулярное выражение

function parse(numbersInString){ 
    var ref = { one:1, two:2, three:3, four:4, five:5, six:6, seven:7, eight:8, nine:9, ten:10, eleven:11, twelve:12, thirteen:13, fourteen:14, fifteen:15, sixteen:16, seventeen:17, eighteen:18, nineteen:19, twenty:20, thirty: 30, forty: 40, fifty: 50, sixty: 60, seventy: 70, eighty: 80, ninety:90 }, 
     mult = { hundred: 100, thousand: 1000, million: 1000000 }, 
     strNums = numbersInString.split(' ').reverse(), 
     number = 0, 
     multiplier = 1; 

    for(i in strNums){ 
     if(mult[strNums[i]] != undefined) { 
      if(mult[strNums[i]]==100) { 
       multiplier*=mult[strNums[i]] 
      }else{ 
       multiplier=mult[strNums[i]] 
      } 
     } else { 
      if (!isNaN(parseFloat(strNums[i]))) { 
       number += parseFloat(strNums[i]) * multiplier; 
      } else { 
       var nums = strNums[i].split('-'); 
       number += ((ref[nums[0]]||0) + (ref[nums[1]]||0)) * multiplier; 
      } 
     } 
    } 
    return number; 
} 

Answer 2

Такое ощущение, что mult.exec должен быть в while блоке, чтобы получить все мультипликаторы вместе.

Этого маленький фрагмент

while(a = find.exec(number)) { 
    if(m = mult.exec(a[0])) { 
     while(m) { 
      multiplier *= ref[m[0]]; 
      m = mult.exec(a[0]); 
     } 
    } 
    else { 
     value += ref[a[0]] * multiplier; 
    } 
} 

делает вещи работать на семьсот тысяч, но потом бюсты его для этого огромного количества. Тот факт, что сто находится в массиве number, и массив multiplier, вероятно, является корнем проблемы, хотя я не смог найти точное решение.

Увлекательная проблема. Может быть, с этой подсказкой, вы можете понять, что остальные.

Answer 3

Это не ответ, но мне нравится комментировать подход немного, так как я не вижу, как вы могли бы разобрать слова с помощью вашего текущего алгоритма. Вы можете заставить его работать для одного конкретного экземпляра или диапазона, но он никогда не будет работать для всех вариантов слов.

Было бы проще и предсказуемо, если бы вы учитывали все типы единиц отдельно в структуре данных, например.

var data = { 
    millions:3, 
    hundredThousands:2, 
    tenThousands:6, 
    thousands:6, 
    hundreds:0, 
    tens:8, 
    ones:9 
}; 

После подсчета вы можете просто поместить все результаты (с нулевым включением), чтобы составить целочисленное значение.

var value = [ 
     data.millions, 
     data.hundredThousands, 
     data.tenThousands, 
     data.thousands, 
     data.hundreds, 
     data.tens, 
     data.ones 
    ].join(''); 

return parseInt(value); // 3266089 

Answer 4

Очень интересная проблема. Я думаю, очень важно наблюдать, что всякий раз, когда в цепочке происходит сто миллионов, миллиард и т. Д., Это может быть либо все до того, как это число будет, либо само число. Если это сто, может быть, это даже не конец. Возможно, нам придется размножаться другим множеством позже, как в «сто тысяч».

Поэтому я разложил вычисление суммы на 3 переменные: totalOfUnits, totalOfHundreds и totalOfMultitudes. Затем пересмотреть все номера в порядке, как это:

• Если число ниже 100 встречается, добавьте его в totalOfUnits
• Если 100 встречается:
  • Если totalOfUnit сек == 0, Добавить 100 в totalOfHundreds
  • Если totalOfUnits> 0, добавить 100 * единиц в totalOfHundreds и установить totalOfUnits до 0
• Если другой мульт itude встречается:
  • Если totalOfUnits == 0 и сотни == 0, добавить само множество в totalOfMultitudes
  • Если totalOfUnits> 0 или totalOfHundreds> 0, добавить множество раз (totalOfUnits + totalOfHundreds) в totalOfMultitudes и установить totalOfUnits и totalOfHundreds 0.

в конце концов, вернуться totalOfUnits + totalOfHundreds + totalOfMultitudes. Код работает для всех приведенных примеров и выглядит следующим образом:

function parseNumber(num){ 
    var units = { 
     zero:0, one:1, two:2, three:3, four:4, five:5, six:6, seven:7, eight:8, nine:9, ten:10, 
     eleven:11, twelve:12, thirteen:13, fourteen:14, fifteen:15, sixteen:16, seventeen:17, eighteen:18, nineteen:19, 
     twenty:20, thirty: 30, forty: 40, fifty: 50, sixty: 60, seventy: 70, eighty: 80, ninety:90 
    }; 
    var hundreds = { 
     hundred: 100 
    }; 
    var multitudes = { 
     hundred: 100, 
     thousand: 1000, 
     million: 1000000 
    }; 

    var parts = num.split(/[ -]/); 

    totalOfUnits = 0; 
    totalOfHundreds = 0; 
    totalOfMultitudes = 0; 

    var result = undefined; 

    for(var i = 0; i < parts.length; i++){ 
     if(units[parts[i]]){ 
      //Add unit 
      totalOfUnits = totalOfUnits + units[parts[i]]; 
     }else if(hundreds[parts[i]]){ 
      totalOfHundreds += hundreds[parts[i]] * (totalOfUnits || 1); 
      totalOfUnits = 0; 
     }else if(multitudes[parts[i]]){ 
      totalOfMultitudes += multitudes[parts[i]] * (((totalOfUnits || 0) + (totalOfHundreds || 0)) || 1); 
      totalOfUnits = totalOfHundreds = 0; 
     } 
    } 

    return totalOfUnits + totalOfHundreds + totalOfMultitudes; 
}