단어로 쓰여진 숫자에서 값을 읽는 방법은 무엇입니까?
https://stackoverflow.com/questions/70161
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
우리 모두 알고 있듯이 숫자는 숫자로 쓰거나 이름으로 부를 수 있습니다.123을 123으로 변환하는 예는 많이 있지만, 반대로 변환하는 방법에 대한 좋은 예는 찾을 수 없습니다.
몇 가지 주의 사항:
- 기수/명목 또는 순서:"하나" 그리고 "첫번째"
- 일반적인 철자 실수:"40"/"40"
- 수백/천:2100 -> "이십일백" 및 "이천일백"
- 구분 기호:"일백오십이"뿐만 아니라 "일백오십이" 또는 "일백오십이" 등도 있습니다.
- 구어체:"서른 살쯤"
- 분수:'3분의 1', '5분의 2'
- 일반적인 이름:'다스', '반'
그리고 아직 나열되지 않은 더 많은 주의 사항이 있을 수 있습니다.알고리즘이 매우 강력해야 하고 철자 오류도 이해해야 한다고 가정해 보겠습니다.
이 모든 것을 작성하는 방법을 배우려면 어떤 분야/논문/연구/알고리즘을 읽어야 합니까?정보는 어디에 있나요?
추신:내 최종 파서는 실제로 영어, 러시아어, 히브리어의 3가지 다른 언어를 이해해야 합니다.그리고 나중에는 더 많은 언어가 추가될 수도 있습니다.히브리어에도 남성/여성 숫자가 있습니다. 예를 들어 "한 남자"와 "한 여자"는 다른 "1"을 가집니다("ehad" 및 "ahat").러시아어에도 그 자체로 복잡한 부분이 있습니다.
Google은 이 분야에서 훌륭한 일을 하고 있습니다.예를 들어:
해결책
나는 당신이 원하는 것을 수행하기 위해 PEG 파서를 가지고 놀고 있었는데(나중에 별도의 답변으로 게시할 수도 있음) 영어, 스페인어 및 영어의 일반적인 숫자 형식에 대해 매우 좋은 작업을 수행하는 매우 간단한 알고리즘이 있다는 것을 발견했습니다. 최소한 독일어는요.
예를 들어 영어로 작업하려면 단어를 값에 명확한 방식으로 매핑하는 사전이 필요합니다.
"one" -> 1, "two" -> 2, ... "twenty" -> 20,
"dozen" -> 12, "score" -> 20, ...
"hundred" -> 100, "thousand" -> 1000, "million" -> 1000000
...기타 등등
알고리즘은 다음과 같습니다.
total = 0
prior = null
for each word w
v <- value(w) or next if no value defined
prior <- case
when prior is null: v
when prior > v: prior+v
else prior*v
else
if w in {thousand,million,billion,trillion...}
total <- total + prior
prior <- null
total = total + prior unless prior is null
예를 들어 다음과 같이 진행됩니다.
total prior v unconsumed string
0 _ four score and seven
4 score and seven
0 4
20 and seven
0 80
_ seven
0 80
7
0 87
87
total prior v unconsumed string
0 _ two million four hundred twelve thousand eight hundred seven
2 million four hundred twelve thousand eight hundred seven
0 2
1000000 four hundred twelve thousand eight hundred seven
2000000 _
4 hundred twelve thousand eight hundred seven
2000000 4
100 twelve thousand eight hundred seven
2000000 400
12 thousand eight hundred seven
2000000 412
1000 eight hundred seven
2000000 412000
1000 eight hundred seven
2412000 _
8 hundred seven
2412000 8
100 seven
2412000 800
7
2412000 807
2412807
등등.완벽하다고는 말할 수 없지만 빠르고 더러운 경우에는 꽤 잘 수행됩니다.
편집 시 특정 목록을 다루기:
- 기수/명목 또는 순서:"하나"와 "첫번째" -- 그냥 사전에 넣으세요
- 영어/영국:"사십"/"사십" -- 같게
- 수백/천:2100 -> "이십일백" 및 "이천일백" -- 그대로 작동
- 구분 기호:"1152" 뿐만 아니라 "1152" 또는 "1152" 등도 -- 정의된 단어와 일치하는 가장 긴 접두사로 "다음 단어"를 정의하거나, 그렇지 않은 경우 시작을 위해 다음 비 단어까지 정의하십시오.
- 구어체:"30대" -- 공장
- 조각:'1/3', '2/5' -- 어, 아직은 아니야...
- 일반적인 이름:'1다스', '반' -- 공장;"6개" 같은 것도 할 수 있어요
6번은 제가 답할 준비가 되어 있지 않은 유일한 것입니다. 그 이유는 제가 마지막으로 마신 커피 잔이 많은 몇 시간 전.
다른 팁
쉬운 문제가 아니며 이를 수행할 라이브러리가 없다는 것을 알고 있습니다.나도 언젠가는 앉아서 이런 글을 써 보려고 할 것이다.하지만 나는 Prolog, Java 또는 Haskell에서 이를 수행할 것입니다.제가 볼 때, 몇 가지 문제가 있습니다:
- 토큰화:때로는 숫자가 천백오십이로 쓰여지기도 하는데, 저는 천백오십이 또는 천백오십이 등을 본 적이 있습니다.실제로 어떤 형태가 사용되고 있는지에 대한 조사를 실시해야 할 것이다.이것은 히브리어의 경우 특히 까다로울 수 있습니다.
- 철자 오류:그다지 어렵지 않습니다.단어의 양이 제한되어 있으므로 약간의 Levenshtein 거리 마법을 사용하면 됩니다.
- 이미 언급한 것처럼 대체 형식이 존재합니다.여기에는 서수/기수뿐만 아니라 40/40 및...
- ...일반적인 이름이나 일반적으로 사용되는 문구 및 NE(명명된 엔터티).30년 전쟁에서 30개를 추출하시겠습니까, 아니면 제2차 세계 대전에서 2개를 추출하시겠습니까?
- 로마숫자도요?
- "30대", "3유로와 파편"과 같은 구어체를 어떻게 다루어야 할지 모르겠습니다.
관심이 있으시면 이번 주말에 한번 시도해 볼 수 있습니다.내 생각은 아마도 UIMA를 사용하여 토큰화한 다음 추가로 토큰화/명료화하고 최종적으로 번역하는 것입니다.더 많은 문제가 있을 수 있습니다. 좀 더 흥미로운 것을 생각해 낼 수 있는지 살펴보겠습니다.
죄송합니다. 이는 아직 실제 답변이 아니며 귀하의 질문에 대한 확장일 뿐입니다.내가 뭔가를 찾거나 쓰면 알려 드리겠습니다.
그건 그렇고, 당신이 숫자의 의미에 관심이 있다면, 나는 방금 다음을 찾았습니다. 흥미로운 종이 프리데리케 몰트만(Friederike Moltmann)이 숫자의 논리 해석에 관한 몇 가지 문제를 논의했습니다.
얼마 전에 작성한 코드가 있습니다. 텍스트 2개.이는 서수를 처리하지 않는다는 점을 제외하면 원하는 작업 중 일부를 수행합니다.실제로 이 코드를 어떤 용도로도 사용하지 않았으므로 대부분 테스트되지 않았습니다!
파이썬을 사용하세요 패턴엔 도서관:
>>> from pattern.en import number
>>> number('two thousand fifty and a half') => 2050.5
유럽과 미국은 다르게 계산된다는 점을 명심해야 합니다.
유럽 표준:
One Thousand
One Million
One Thousand Millions (British also use Milliard)
One Billion
One Thousand Billions
One Trillion
One Thousand Trillions
여기 그것에 대한 작은 참고 자료입니다.
차이점을 확인하는 간단한 방법은 다음과 같습니다.
(American counting Trillion) == (European counting Billion)
서수는 언어(적어도 영어)에서는 다른 숫자와 의미 있는 방식으로 결합할 수 없기 때문에 적용할 수 없습니다.
예를 들어101번째, 11초 등...
그러나 'and'라는 단어에는 또 다른 영어/미국 주의 사항이 있습니다.
즉.
1 백 1 명 (영어) 1 백 1 (미국)
또한, 영어에서 'a'는 하나를 의미하는 데 사용됩니다.
천 = 천
...참고로 Google의 계산기는 이 작업을 훌륭하게 수행합니다.
그리고 심지어...
...뭐야?!? 로마 숫자로 1점 더하기 12점
Clojure의 매우 강력한 솔루션은 다음과 같습니다.
AFAIK는 독특한 구현 접근 방식입니다.
;----------------------------------------------------------------------
; numbers.clj
; written by: Mike Mattie codermattie@gmail.com
;----------------------------------------------------------------------
(ns operator.numbers
(:use compojure.core)
(:require
[clojure.string :as string] ))
(def number-word-table {
"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
"fourty" 40
"fifty" 50
"sixty" 60
"seventy" 70
"eighty" 80
"ninety" 90
})
(def multiplier-word-table {
"hundred" 100
"thousand" 1000
})
(defn sum-words-to-number [ words ]
(apply + (map (fn [ word ] (number-word-table word)) words)) )
; are you down with the sickness ?
(defn words-to-number [ words ]
(let
[ n (count words)
multipliers (filter (fn [x] (not (false? x))) (map-indexed
(fn [ i word ]
(if (contains? multiplier-word-table word)
(vector i (multiplier-word-table word))
false))
words) )
x (ref 0) ]
(loop [ indices (reverse (conj (reverse multipliers) (vector n 1)))
left 0
combine + ]
(let
[ right (first indices) ]
(dosync (alter x combine (* (if (> (- (first right) left) 0)
(sum-words-to-number (subvec words left (first right)))
1)
(second right)) ))
(when (> (count (rest indices)) 0)
(recur (rest indices) (inc (first right))
(if (= (inc (first right)) (first (second indices)))
*
+))) ) )
@x ))
여기 몇 가지 예가 있어요
(operator.numbers/words-to-number ["six" "thousand" "five" "hundred" "twenty" "two"])
(operator.numbers/words-to-number ["fifty" "seven" "hundred"])
(operator.numbers/words-to-number ["hundred"])
귀하의 요구 사항 중 일부를 LPC로 구현했습니다(미국 영어만 해당).
internal mapping inordinal = ([]);
internal mapping number = ([]);
#define Numbers ([\
"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, \
"hundred" : 100, \
"thousand" : 1000, \
"million" : 1000000, \
"billion" : 1000000000, \
])
#define Ordinals ([\
"zeroth" : 0, \
"first" : 1, \
"second" : 2, \
"third" : 3, \
"fourth" : 4, \
"fifth" : 5, \
"sixth" : 6, \
"seventh" : 7, \
"eighth" : 8, \
"ninth" : 9, \
"tenth" : 10, \
"eleventh" : 11, \
"twelfth" : 12, \
"thirteenth" : 13, \
"fourteenth" : 14, \
"fifteenth" : 15, \
"sixteenth" : 16, \
"seventeenth" : 17, \
"eighteenth" : 18, \
"nineteenth" : 19, \
"twentieth" : 20, \
"thirtieth" : 30, \
"fortieth" : 40, \
"fiftieth" : 50, \
"sixtieth" : 60, \
"seventieth" : 70, \
"eightieth" : 80, \
"ninetieth" : 90, \
"hundredth" : 100, \
"thousandth" : 1000, \
"millionth" : 1000000, \
"billionth" : 1000000000, \
])
varargs int denumerical(string num, status ordinal) {
if(ordinal) {
if(member(inordinal, num))
return inordinal[num];
} else {
if(member(number, num))
return number[num];
}
int sign = 1;
int total = 0;
int sub = 0;
int value;
string array parts = regexplode(num, " |-");
if(sizeof(parts) >= 2 && parts[0] == "" && parts[1] == "-")
sign = -1;
for(int ix = 0, int iix = sizeof(parts); ix < iix; ix++) {
string part = parts[ix];
switch(part) {
case "negative" :
case "minus" :
sign = -1;
continue;
case "" :
continue;
}
if(ordinal && ix == iix - 1) {
if(part[0] >= '0' && part[0] <= '9' && ends_with(part, "th"))
value = to_int(part[..<3]);
else if(member(Ordinals, part))
value = Ordinals[part];
else
continue;
} else {
if(part[0] >= '0' && part[0] <= '9')
value = to_int(part);
else if(member(Numbers, part))
value = Numbers[part];
else
continue;
}
if(value < 0) {
sign = -1;
value = - value;
}
if(value < 10) {
if(sub >= 1000) {
total += sub;
sub = value;
} else {
sub += value;
}
} else if(value < 100) {
if(sub < 10) {
sub = 100 * sub + value;
} else if(sub >= 1000) {
total += sub;
sub = value;
} else {
sub *= value;
}
} else if(value < sub) {
total += sub;
sub = value;
} else if(sub == 0) {
sub = value;
} else {
sub *= value;
}
}
total += sub;
return sign * total;
}
글쎄, 나는 이 질문에 대한 답을 하기에는 너무 늦었지만 나에게 아주 잘 맞았던 것 같은 작은 테스트 시나리오를 작업하고 있었습니다.나는 모든 단어를 찾기 위해 (간단하지만 보기 흉하고 큰) 정규식을 사용했습니다.표현은 다음과 같습니다.
(?<Value>(?:zero)|(?:one|first)|(?:two|second)|(?:three|third)|(?:four|fourth)|
(?:five|fifth)|(?:six|sixth)|(?:seven|seventh)|(?:eight|eighth)|(?:nine|ninth)|
(?:ten|tenth)|(?:eleven|eleventh)|(?:twelve|twelfth)|(?:thirteen|thirteenth)|
(?:fourteen|fourteenth)|(?:fifteen|fifteenth)|(?:sixteen|sixteenth)|
(?:seventeen|seventeenth)|(?:eighteen|eighteenth)|(?:nineteen|nineteenth)|
(?:twenty|twentieth)|(?:thirty|thirtieth)|(?:forty|fortieth)|(?:fifty|fiftieth)|
(?:sixty|sixtieth)|(?:seventy|seventieth)|(?:eighty|eightieth)|(?:ninety|ninetieth)|
(?<Magnitude>(?:hundred|hundredth)|(?:thousand|thousandth)|(?:million|millionth)|
(?:billion|billionth)))
여기에는 서식 지정을 위해 줄바꿈을 사용하여 표시됩니다.
어쨌든 내 방법은 PCRE와 같은 라이브러리를 사용하여 이 RegEx를 실행한 다음 명명된 일치 항목을 다시 읽는 것이었습니다.그리고 이 질문에 나열된 모든 다른 예에서 "One Half" 유형을 제외하고 작동했습니다. 추가하지 않았지만 보시다시피 그렇게 하는 것은 어렵지 않습니다.이것은 많은 문제를 해결합니다.예를 들어 원래 질문과 기타 답변에서 다음 항목을 다룹니다.
- 기수/명목 또는 순서:"하나" 그리고 "첫번째"
- 일반적인 철자 실수:"forty"/"fourty"(이 문제를 명시적으로 다루지는 않는다는 점에 유의하세요. 문자열을 이 파서에 전달하기 전에 수행해야 할 작업입니다.이 파서는 이 예를 "FOUR"로 간주합니다...)
- 수백/천:2100 -> "이십일백" 및 "이천일백"
- 구분 기호:"일백오십이"뿐만 아니라 "일백오십이" 또는 "일백오십이" 등도 있습니다.
- 구어체:"30대"("무엇"이 무엇인지에 대해 완전히 언급되지는 않았습니까?음, 이 코드에서는 이 숫자를 단순히 "30"으로 찾습니다.**
이제 이 괴물같은 정규식을 소스에 저장하는 대신 다음과 같은 방법을 사용하여 런타임에 이 RegEx를 구축하는 것을 고려하고 있었습니다.
char *ones[] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve",
"thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
char *tens[] = {"", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
char *ordinalones[] = { "", "first", "second", "third", "fourth", "fifth", "", "", "", "", "", "", "twelfth" };
char *ordinaltens[] = { "", "", "twentieth", "thirtieth", "fortieth", "fiftieth", "sixtieth", "seventieth", "eightieth", "ninetieth" };
and so on...
여기서 쉬운 부분은 중요한 단어만 저장한다는 것입니다.SIXTH의 경우 항목이 없다는 것을 알 수 있습니다. 왜냐하면 TH가 붙은 일반 숫자이기 때문입니다.하지만 TWELVE와 같은 경우에는 다른 주의가 필요합니다.
자, 이제 (추악한) RegEx를 구축하는 코드가 생겼습니다. 이제 숫자 문자열에 대해 실행하면 됩니다.
제가 추천하고 싶은 한 가지는 "AND"라는 단어를 필터링하거나 먹는 것입니다.이는 필요하지 않으며 다른 문제만 발생시킬 뿐입니다.
따라서 여러분이 하려는 작업은 "크기"에 대한 명명된 일치 항목을 가능한 모든 크기 값을 확인하는 함수에 전달하고 현재 결과에 해당 크기 값을 곱하는 함수를 설정하는 것입니다.그런 다음 일치하는 이름의 "값"을 보고 발견된 값을 기반으로 int(또는 사용 중인 모든 항목)를 반환하는 함수를 만듭니다.
모든 VALUE 일치 항목이 결과에 추가되는 반면 magnitutde 일치 항목은 결과에 mag 값을 곱합니다.따라서 25만은 "2", "2 * 100", "200 + 50", "250 * 1000"을 거쳐 250000이 됩니다...
재미삼아 vbScript 버전을 작성했는데 제공된 모든 예제와 잘 작동했습니다.이제는 명명된 일치를 지원하지 않기 때문에 올바른 결과를 얻기 위해 조금 더 노력해야 했지만 얻었습니다.요점은 "VALUE" 일치인 경우 이를 누산기에 추가한다는 것입니다.크기가 일치하는 경우 누산기에 100, 1000, 1000000, 1000000000 등을 곱합니다.이것은 꽤 놀라운 결과를 제공할 것이며, "반쪽"과 같은 항목을 조정하기 위해 해야 할 일은 해당 항목을 RegEx에 추가하고 코드 마커를 넣은 다음 처리하는 것뿐입니다.
글쎄, 이 게시물이 누군가에게 도움이 되기를 바랍니다.누구든지 원한다면 이것을 테스트하는 데 사용한 vbScript 의사 코드로 게시할 수 있지만 이는 예쁜 코드도 아니고 프로덕션 코드도 아닙니다.
혹시..이것이 쓰여질 최종 언어는 무엇입니까?C++, 아니면 스크립트 언어 같은 것인가요?Greg Hewgill의 출처는 이 모든 것이 어떻게 결합되는지 이해하는 데 큰 도움이 될 것입니다.
다른 도움이 필요하시면 알려주세요.죄송합니다. 저는 영어/미국어만 알고 있어서 다른 언어로는 도움을 드릴 수 없습니다.
나는 초기 현대 서적의 서수판 설명을 변환하고 있었습니다(예:"2nd edition", "Editio quarta")를 정수로 변환하고 영어의 서수 1-100과 일부 로맨스 언어의 서수 1-10에 대한 지원이 필요했습니다.제가 Python에서 생각해낸 내용은 다음과 같습니다.
def get_data_mapping():
data_mapping = {
"1st": 1,
"2nd": 2,
"3rd": 3,
"tenth": 10,
"eleventh": 11,
"twelfth": 12,
"thirteenth": 13,
"fourteenth": 14,
"fifteenth": 15,
"sixteenth": 16,
"seventeenth": 17,
"eighteenth": 18,
"nineteenth": 19,
"twentieth": 20,
"new": 2,
"newly": 2,
"nova": 2,
"nouvelle": 2,
"altera": 2,
"andere": 2,
# latin
"primus": 1,
"secunda": 2,
"tertia": 3,
"quarta": 4,
"quinta": 5,
"sexta": 6,
"septima": 7,
"octava": 8,
"nona": 9,
"decima": 10,
# italian
"primo": 1,
"secondo": 2,
"terzo": 3,
"quarto": 4,
"quinto": 5,
"sesto": 6,
"settimo": 7,
"ottavo": 8,
"nono": 9,
"decimo": 10,
# french
"premier": 1,
"deuxième": 2,
"troisième": 3,
"quatrième": 4,
"cinquième": 5,
"sixième": 6,
"septième": 7,
"huitième": 8,
"neuvième": 9,
"dixième": 10,
# spanish
"primero": 1,
"segundo": 2,
"tercero": 3,
"cuarto": 4,
"quinto": 5,
"sexto": 6,
"septimo": 7,
"octavo": 8,
"noveno": 9,
"decimo": 10
}
# create 4th, 5th, ... 20th
for i in xrange(16):
data_mapping[str(4+i) + "th"] = 4+i
# create 21st, 22nd, ... 99th
for i in xrange(79):
last_char = str(i)[-1]
if last_char == "0":
data_mapping[str(20+i) + "th"] = 20+i
elif last_char == "1":
data_mapping[str(20+i) + "st"] = 20+i
elif last_char == "2":
data_mapping[str(20+i) + "nd"] = 20+i
elif last_char == "3":
data_mapping[str(20+i) + "rd"] = 20+i
else:
data_mapping[str(20+i) + "th"] = 20+i
ordinals = [
"first", "second", "third",
"fourth", "fifth", "sixth",
"seventh", "eighth", "ninth"
]
# create first, second ... ninth
for c, i in enumerate(ordinals):
data_mapping[i] = c+1
# create twenty-first, twenty-second ... ninty-ninth
for ci, i in enumerate([
"twenty", "thirty", "forty",
"fifty", "sixty", "seventy",
"eighty", "ninety"
]):
for cj, j in enumerate(ordinals):
data_mapping[i + "-" + j] = 20 + (ci*10) + (cj+1)
data_mapping[i.replace("y", "ieth")] = 20 + (ci*10)
return data_mapping
노력하다
"에 대한 HTTP 요청을 엽니다.http://www.google.com/search?q=" + 숫자 + "+in+소수".
귀하의 번호에 대한 결과를 구문 분석하십시오.
시간이 지남에 따라 요청을 학습하기 위해 숫자/결과 쌍을 캐시합니다.
살펴보기 시작할 한 곳은 GNU get_date lib, 구문 분석할 수 있는 그냥 아무거나 영어 텍스트 날짜를 타임스탬프로 변환합니다.정확히 당신이 찾고 있는 것은 아니지만 유사한 문제에 대한 그들의 해결책은 많은 유용한 단서를 제공할 수 있습니다.
