免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
› 论坛 › 程序设计 › C/C++ › Linux 下实现计算器程序，高手请进！！
123下一页
最近访问板块 发新帖
查看: 8988 | 回复: 26
打印 上一主题 下一主题

Linux 下实现计算器程序，高手请进！！ [复制链接]

toddytao

论坛徽章:
0
跳转到指定楼层
1楼 [收藏(0)] [报告]
发表于 2011-08-08 15:09 |只看该作者 |倒序浏览
大家好！！

我现在要在Linux下实现一个计算器程序， 它有如下的要求:
1.  能识别英文数字：比如 three hundred and ninety two， 要能转换为392.
2.  能识别英文的加减乘除： Add, minus, multiply, divide.
3.  能识别符号的加减乘除： +, -, *, /

例子如下：
输入：three hundred and ninety two multiply with 7
结果：2744

输入：12 minus 3
结果： 9


要怎么实现这个程序啊。。。跪求各位高手指点一下。。。尤其是是英文数字的识别。。这个还没头绪啊。。。
yulihua49

论坛徽章:
15
射手座 日期:2014-11-29 19:22:4915-16赛季CBA联赛之青岛 日期:2017-11-17 13:20:09黑曼巴 日期:2017-07-13 19:13:4715-16赛季CBA联赛之四川 日期:2017-02-07 21:08:572015年亚冠纪念徽章 日期:2015-11-06 12:31:58每日论坛发贴之星 日期:2015-08-04 06:20:00程序设计版块每日发帖之星 日期:2015-08-04 06:20:00程序设计版块每日发帖之星 日期:2015-07-12 22:20:002015亚冠之浦和红钻 日期:2015-07-08 10:10:132015亚冠之大阪钢巴 日期:2015-06-29 11:21:122015亚冠之广州恒大 日期:2015-05-22 21:55:412015年亚洲杯之伊朗 日期:2015-04-10 16:28:25
2楼 [报告]
发表于 2011-08-08 15:14 |只看该作者
大家好！！

我现在要在Linux下实现一个计算器程序， 它有如下的要求:
1.  能识别英文数字：比如 three  ...
toddytao 发表于 2011-08-08 15:09



    YACC
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
toddytao

论坛徽章:
0
3楼 [报告]
发表于 2011-08-08 15:16 |只看该作者
回复 2# yulihua49


    求详解啊。。。大侠！！
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
coding3125

论坛徽章:
0
4楼 [报告]
发表于 2011-08-08 15:47 |只看该作者
flex & bison
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
5楼 [报告]
发表于 2011-08-09 13:45 |只看该作者
注意：输入数字不能超过整数的范围，否则会溢出，将得不到正确结果。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;

  192.         if (p == NULL || io_index == NULL || o_value == NULL) {
  193.                 return -1;
  194.         }
  195.         index = *io_index;
  196.         if (index < 0) {
  197.                 return -1;
  198.         }
  199.         if (get_english_digit_decade(p, &index, &value) == -1) {
  200.                 value = 0;
  201.         }
  202.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  203.                 value += digit;
  204.         }else {
  205.                 if (value == 0) {
  206.                         return -1;
  207.                 }
  208.         }
  209.         *o_value = value;
  210.         *io_index = index;
  211.         return 0;
  212. }

  214. int get_digit_base(const char *p, int *io_index, int *o_base)
  215. {
  216.         static const char *more[] = {
  217.                 "hundred",
  218.                 "thousand",
  219.                 "million",
  220.                 "billion",
  221.         };
  222.         static const int base[] = {
  223.                 100,
  224.                 1000,
  225.                 1000000,
  226.                 1000000000,
  227.         };
  228.         int index;
  229.         int start,len;
  230.         int retn;

  232.         if (p == NULL || io_index == NULL || o_base == NULL) {
  233.                 return -1;
  234.         }
  235.         index = *io_index;
  236.         if (index < 0) {
  237.                 return -1;
  238.         }
  239.         skip_space(p, &index);
  240.         if (get_word(p, &index, &start, &len) == 0) {
  241.                 retn = get_token(p + start, len, more, 4);
  242.                 if (retn != -1) {
  243.                         *o_base = base[retn];
  244.                         *io_index = index;
  245.                         return 0;
  246.                 }
  247.         }
  248.         return -1;
  249. }

  251. int get_english_digit(const char *p, int *io_index, int *o_value)
  252. {
  253.         int index;
  254.         int value;
  255.         int sum;
  256.         int base;

  258.         if (p == NULL || io_index == NULL || o_value == NULL) {
  259.                 return -1;
  260.         }
  261.         index = *io_index;
  262.         if (index < 0) {
  263.                 return -1;
  264.         }
  265.         sum = 0;
  266.         for (;;) {
  267.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  268.                         sum += value;
  269.                         if (get_digit_base(p, &index, &base) == 0) {
  270.                                 sum *= base;
  271.                                 if (skip_word(p, &index, "and") == 0) {
  272.                                         continue;
  273.                                 }
  274.                         }
  275.                         *o_value = sum;
  276.                         *io_index = index;
  277.                         return 0;
  278.                 }
  279.                 return -1;
  280.         }
  281. }

  283. int get_operator1(const char *p, int *io_index, int *o_op)
  284. {
  285.         static const char *op_list[] = {
  286.                 "positive",
  287.                 "+",
  288.                 "negative",
  289.                 "-",
  290.         };
  291.         int index;
  292.         int start, len;
  293.         int retn;
  294.        
  295.         if (p == NULL || io_index == NULL || o_op == NULL) {
  296.                 return -1;
  297.         }
  298.         index = *io_index;
  299.         if (index < 0) {
  300.                 return -1;
  301.         }
  302.         skip_space(p, &index);
  303.         if (get_word(p, &index, &start, &len) == 0) {
  304.                 retn = get_token(p + start, len, op_list, 8);
  305.                 if (retn != -1) {
  306.                         *o_op = retn / 2;
  307.                         *io_index = index;
  308.                         return 0;
  309.                 }
  310.         }
  311.         return -1;
  312. }

  314. int get_operator2(const char *p, int *io_index, int *o_op)
  315. {
  316.         static const char *op_list[] = {
  317.                 "plus",
  318.                 "+",
  319.                 "minus",
  320.                 "-",
  321.                 "multiple",
  322.                 "*",
  323.                 "divide",
  324.                 "/",
  325.         };
  326.         int index;
  327.         int start, len;
  328.         int retn;

  330.         if (p == NULL || io_index == NULL || o_op == NULL) {
  331.                 return -1;
  332.         }
  333.         index = *io_index;
  334.         if (index < 0) {
  335.                 return -1;
  336.         }
  337.         skip_space(p, &index);
  338.         if (get_word(p, &index, &start, &len) == 0) {
  339.                 retn = get_token(p + start, len, op_list, 8);
  340.                 if (retn != -1) {
  341.                         *o_op = retn / 2;
  342.                         *io_index = index;
  343.                         return 0;
  344.                 }
  345.         }
  346.         return -1;
  347. }

  349. int main(void)
  350. {
  351.         char cmd_line[1024];
  352.         int op; /* operator */
  353.         int d1, d2; /* oprand number */
  354.         int result; /* store the expression result */
  355.         int index;

  357.         puts("English Caculator\n");
  358.         puts("Please enter an expression");
  359.         puts("CTRL-Z to exit");
  360.         for (;;) {
  361.                 printf("\n: ");
  362.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  363.                         return 0;
  364.                 }
  365.                 index = 0;
  366.                 if (get_english_digit(cmd_line, &index, &d1) == 0) {
  367.                         /* two oprands operation */
  368.                         if (get_operator2(cmd_line, &index, &op) != 0) {
  369.                                 printf("Invalid Operator\n");
  370.                                 continue;
  371.                         }
  372.                         if (get_english_digit(cmd_line, &index, &d2) != 0) {
  373.                                 printf("Invalid English Number\n");
  374.                                 continue;
  375.                         }
  376.                         switch (op) {
  377.                         case 0:
  378.                                 result = d1 + d2;
  379.                                 break;
  380.                         case 1:
  381.                                 result = d1 - d2;
  382.                                 break;
  383.                         case 2:
  384.                                 result = d1 * d2;
  385.                                 break;
  386.                         case 3:
  387.                                 result = d1 / d2;
  388.                                 break;
  389.                         default:
  390.                                 printf("unknown operator\n");
  391.                                 continue;
  392.                         }
  393.                 }else {
  394.                         /* one oprands operation */
  395.                         if (get_operator1(cmd_line, &index, &op) != 0) {
  396.                                 printf("Invalid Operator\n");
  397.                                 continue;
  398.                         }
  399.                         if (get_english_digit(cmd_line, &index, &d1) != 0) {
  400.                                 printf("Invalid English Number\n");
  401.                                 continue;
  402.                         }
  403.                         switch (op) {
  404.                         case 0:
  405.                                 result = d1;
  406.                                 break;
  407.                         case 1:
  408.                                 result = -d1;
  409.                                 break;
  410.                         default:
  411.                                 printf("unknown operator\n");
  412.                                 continue;
  413.                         }
  414.                 }
  415.                 printf("%d\n", result);
  416.         }
  417. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
6楼 [报告]
发表于 2011-08-09 13:59 |只看该作者
本帖最后由 cobras 于 2011-08-09 14:01 编辑

上面的修正版。
修正zero输入问题。

  2. Files in Workspace
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
7楼 [报告]
发表于 2011-08-09 14:01 |只看该作者

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 value += digit;
  208.         }else {
  209.                 if (!decade_yes) {
  210.                         return -1;
  211.                 }
  212.         }
  213.         *o_value = value;
  214.         *io_index = index;
  215.         return 0;
  216. }

  218. int get_digit_base(const char *p, int *io_index, int *o_base)
  219. {
  220.         static const char *more[] = {
  221.                 "hundred",
  222.                 "thousand",
  223.                 "million",
  224.                 "billion",
  225.         };
  226.         static const int base[] = {
  227.                 100,
  228.                 1000,
  229.                 1000000,
  230.                 1000000000,
  231.         };
  232.         int index;
  233.         int start,len;
  234.         int retn;

  236.         if (p == NULL || io_index == NULL || o_base == NULL) {
  237.                 return -1;
  238.         }
  239.         index = *io_index;
  240.         if (index < 0) {
  241.                 return -1;
  242.         }
  243.         skip_space(p, &index);
  244.         if (get_word(p, &index, &start, &len) == 0) {
  245.                 retn = get_token(p + start, len, more, 4);
  246.                 if (retn != -1) {
  247.                         *o_base = base[retn];
  248.                         *io_index = index;
  249.                         return 0;
  250.                 }
  251.         }
  252.         return -1;
  253. }

  255. int get_english_digit(const char *p, int *io_index, int *o_value)
  256. {
  257.         int index;
  258.         int value;
  259.         int sum;
  260.         int base;

  262.         if (p == NULL || io_index == NULL || o_value == NULL) {
  263.                 return -1;
  264.         }
  265.         index = *io_index;
  266.         if (index < 0) {
  267.                 return -1;
  268.         }
  269.         sum = 0;
  270.         for (;;) {
  271.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  272.                         sum += value;
  273.                         if (get_digit_base(p, &index, &base) == 0) {
  274.                                 sum *= base;
  275.                                 if (skip_word(p, &index, "and") == 0) {
  276.                                         continue;
  277.                                 }
  278.                         }
  279.                         *o_value = sum;
  280.                         *io_index = index;
  281.                         return 0;
  282.                 }
  283.                 return -1;
  284.         }
  285. }

  287. int get_operator1(const char *p, int *io_index, int *o_op)
  288. {
  289.         static const char *op_list[] = {
  290.                 "positive",
  291.                 "+",
  292.                 "negative",
  293.                 "-",
  294.         };
  295.         int index;
  296.         int start, len;
  297.         int retn;
  298.        
  299.         if (p == NULL || io_index == NULL || o_op == NULL) {
  300.                 return -1;
  301.         }
  302.         index = *io_index;
  303.         if (index < 0) {
  304.                 return -1;
  305.         }
  306.         skip_space(p, &index);
  307.         if (get_word(p, &index, &start, &len) == 0) {
  308.                 retn = get_token(p + start, len, op_list, 8);
  309.                 if (retn != -1) {
  310.                         *o_op = retn / 2;
  311.                         *io_index = index;
  312.                         return 0;
  313.                 }
  314.         }
  315.         return -1;
  316. }

  318. int get_operator2(const char *p, int *io_index, int *o_op)
  319. {
  320.         static const char *op_list[] = {
  321.                 "plus",
  322.                 "+",
  323.                 "minus",
  324.                 "-",
  325.                 "multiple",
  326.                 "*",
  327.                 "divide",
  328.                 "/",
  329.         };
  330.         int index;
  331.         int start, len;
  332.         int retn;

  334.         if (p == NULL || io_index == NULL || o_op == NULL) {
  335.                 return -1;
  336.         }
  337.         index = *io_index;
  338.         if (index < 0) {
  339.                 return -1;
  340.         }
  341.         skip_space(p, &index);
  342.         if (get_word(p, &index, &start, &len) == 0) {
  343.                 retn = get_token(p + start, len, op_list, 8);
  344.                 if (retn != -1) {
  345.                         *o_op = retn / 2;
  346.                         *io_index = index;
  347.                         return 0;
  348.                 }
  349.         }
  350.         return -1;
  351. }

  353. int main(void)
  354. {
  355.         char cmd_line[1024];
  356.         int op; /* operator */
  357.         int d1, d2; /* oprand number */
  358.         int result; /* store the expression result */
  359.         int index;

  361.         puts("English Caculator\n");
  362.         puts("Please enter an expression");
  363.         puts("CTRL-Z to exit");
  364.         for (;;) {
  365.                 printf("\n: ");
  366.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  367.                         return 0;
  368.                 }
  369.                 index = 0;
  370.                 if (get_english_digit(cmd_line, &index, &d1) == 0) {
  371.                         /* two oprands operation */
  372.                         if (get_operator2(cmd_line, &index, &op) != 0) {
  373.                                 printf("Invalid Operator\n");
  374.                                 continue;
  375.                         }
  376.                         if (get_english_digit(cmd_line, &index, &d2) != 0) {
  377.                                 printf("Invalid English Number\n");
  378.                                 continue;
  379.                         }
  380.                         switch (op) {
  381.                         case 0:
  382.                                 result = d1 + d2;
  383.                                 break;
  384.                         case 1:
  385.                                 result = d1 - d2;
  386.                                 break;
  387.                         case 2:
  388.                                 result = d1 * d2;
  389.                                 break;
  390.                         case 3:
  391.                                 result = d1 / d2;
  392.                                 break;
  393.                         default:
  394.                                 printf("unknown operator\n");
  395.                                 continue;
  396.                         }
  397.                 }else {
  398.                         /* one oprand operation */
  399.                         if (get_operator1(cmd_line, &index, &op) != 0) {
  400.                                 printf("Invalid Operator\n");
  401.                                 continue;
  402.                         }
  403.                         if (get_english_digit(cmd_line, &index, &d1) != 0) {
  404.                                 printf("Invalid English Number\n");
  405.                                 continue;
  406.                         }
  407.                         switch (op) {
  408.                         case 0:
  409.                                 result = d1;
  410.                                 break;
  411.                         case 1:
  412.                                 result = -d1;
  413.                                 break;
  414.                         default:
  415.                                 printf("unknown operator\n");
  416.                                 continue;
  417.                         }
  418.                 }
  419.                 printf("%d\n", result);
  420.         }
  421. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
8楼 [报告]
发表于 2011-08-09 14:15 |只看该作者
增加解释"a hundred"一类的英文数字简明表示法。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 value += digit;
  208.         }else {
  209.                 if (!decade_yes) {
  210.                         return -1;
  211.                 }
  212.         }
  213.         *o_value = value;
  214.         *io_index = index;
  215.         return 0;
  216. }

  218. int get_digit_base(const char *p, int *io_index, int *o_base)
  219. {
  220.         static const char *more[] = {
  221.                 "hundred",
  222.                 "thousand",
  223.                 "million",
  224.                 "billion",
  225.         };
  226.         static const int base[] = {
  227.                 100,
  228.                 1000,
  229.                 1000000,
  230.                 1000000000,
  231.         };
  232.         int index;
  233.         int start,len;
  234.         int retn;

  236.         if (p == NULL || io_index == NULL || o_base == NULL) {
  237.                 return -1;
  238.         }
  239.         index = *io_index;
  240.         if (index < 0) {
  241.                 return -1;
  242.         }
  243.         skip_space(p, &index);
  244.         if (get_word(p, &index, &start, &len) == 0) {
  245.                 retn = get_token(p + start, len, more, 4);
  246.                 if (retn != -1) {
  247.                         *o_base = base[retn];
  248.                         *io_index = index;
  249.                         return 0;
  250.                 }
  251.         }
  252.         return -1;
  253. }

  255. int get_english_digit(const char *p, int *io_index, int *o_value)
  256. {
  257.         int index;
  258.         int value;
  259.         int sum;
  260.         int base;

  262.         if (p == NULL || io_index == NULL || o_value == NULL) {
  263.                 return -1;
  264.         }
  265.         index = *io_index;
  266.         if (index < 0) {
  267.                 return -1;
  268.         }
  269.         sum = 0;
  270.         for (;;) {
  271.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  272.                         sum += value;
  273.                         if (get_digit_base(p, &index, &base) == 0) {
  274.                                 sum *= base;
  275.                                 if (skip_word(p, &index, "and") == 0) {
  276.                                         continue;
  277.                                 }
  278.                         }
  279.                         *o_value = sum;
  280.                         *io_index = index;
  281.                         return 0;
  282.                 }else if (sum == 0) {
  283.                         if (skip_word(p, &index, "a") == 0) {
  284.                                 if (get_digit_base(p, &index, &base) == 0) {
  285.                                         sum = base;
  286.                                         if (skip_word(p, &index, "and") == 0) {
  287.                                                 continue;
  288.                                         }
  289.                                         *o_value = sum;
  290.                                         *io_index = index;
  291.                                         return 0;
  292.                                 }
  293.                         }
  294.                 }
  295.                 return -1;
  296.         }
  297. }

  299. int get_operator1(const char *p, int *io_index, int *o_op)
  300. {
  301.         static const char *op_list[] = {
  302.                 "positive",
  303.                 "+",
  304.                 "negative",
  305.                 "-",
  306.         };
  307.         int index;
  308.         int start, len;
  309.         int retn;
  310.        
  311.         if (p == NULL || io_index == NULL || o_op == NULL) {
  312.                 return -1;
  313.         }
  314.         index = *io_index;
  315.         if (index < 0) {
  316.                 return -1;
  317.         }
  318.         skip_space(p, &index);
  319.         if (get_word(p, &index, &start, &len) == 0) {
  320.                 retn = get_token(p + start, len, op_list, 8);
  321.                 if (retn != -1) {
  322.                         *o_op = retn / 2;
  323.                         *io_index = index;
  324.                         return 0;
  325.                 }
  326.         }
  327.         return -1;
  328. }

  330. int get_operator2(const char *p, int *io_index, int *o_op)
  331. {
  332.         static const char *op_list[] = {
  333.                 "plus",
  334.                 "+",
  335.                 "minus",
  336.                 "-",
  337.                 "multiple",
  338.                 "*",
  339.                 "divide",
  340.                 "/",
  341.         };
  342.         int index;
  343.         int start, len;
  344.         int retn;

  346.         if (p == NULL || io_index == NULL || o_op == NULL) {
  347.                 return -1;
  348.         }
  349.         index = *io_index;
  350.         if (index < 0) {
  351.                 return -1;
  352.         }
  353.         skip_space(p, &index);
  354.         if (get_word(p, &index, &start, &len) == 0) {
  355.                 retn = get_token(p + start, len, op_list, 8);
  356.                 if (retn != -1) {
  357.                         *o_op = retn / 2;
  358.                         *io_index = index;
  359.                         return 0;
  360.                 }
  361.         }
  362.         return -1;
  363. }

  365. int main(void)
  366. {
  367.         char cmd_line[1024];
  368.         int op; /* operator */
  369.         int d1, d2; /* oprand number */
  370.         int result; /* store the expression result */
  371.         int index;

  373.         puts("English Caculator\n");
  374.         puts("Please enter an expression");
  375.         puts("CTRL-Z to exit");
  376.         for (;;) {
  377.                 printf("\n: ");
  378.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  379.                         return 0;
  380.                 }
  381.                 index = 0;
  382.                 if (get_english_digit(cmd_line, &index, &d1) == 0) {
  383.                         /* two oprands operation */
  384.                         if (get_operator2(cmd_line, &index, &op) != 0) {
  385.                                 printf("Invalid Operator\n");
  386.                                 continue;
  387.                         }
  388.                         if (get_english_digit(cmd_line, &index, &d2) != 0) {
  389.                                 printf("Invalid English Number\n");
  390.                                 continue;
  391.                         }
  392.                         switch (op) {
  393.                         case 0:
  394.                                 result = d1 + d2;
  395.                                 break;
  396.                         case 1:
  397.                                 result = d1 - d2;
  398.                                 break;
  399.                         case 2:
  400.                                 result = d1 * d2;
  401.                                 break;
  402.                         case 3:
  403.                                 result = d1 / d2;
  404.                                 break;
  405.                         default:
  406.                                 printf("unknown operator\n");
  407.                                 continue;
  408.                         }
  409.                 }else {
  410.                         /* one oprand operation */
  411.                         if (get_operator1(cmd_line, &index, &op) != 0) {
  412.                                 printf("Invalid Operator\n");
  413.                                 continue;
  414.                         }
  415.                         if (get_english_digit(cmd_line, &index, &d1) != 0) {
  416.                                 printf("Invalid English Number\n");
  417.                                 continue;
  418.                         }
  419.                         switch (op) {
  420.                         case 0:
  421.                                 result = d1;
  422.                                 break;
  423.                         case 1:
  424.                                 result = -d1;
  425.                                 break;
  426.                         default:
  427.                                 printf("unknown operator\n");
  428.                                 continue;
  429.                         }
  430.                 }
  431.                 printf("%d\n", result);
  432.         }
  433. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
9楼 [报告]
发表于 2011-08-09 14:17 |只看该作者
修正"twenty zero"之类的错误表示。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 if (decade_yes && digit == 0) {
  208.                         return -1;
  209.                 }
  210.                 value += digit;
  211.         }else {
  212.                 if (!decade_yes) {
  213.                         return -1;
  214.                 }
  215.         }
  216.         *o_value = value;
  217.         *io_index = index;
  218.         return 0;
  219. }

  221. int get_digit_base(const char *p, int *io_index, int *o_base)
  222. {
  223.         static const char *more[] = {
  224.                 "hundred",
  225.                 "thousand",
  226.                 "million",
  227.                 "billion",
  228.         };
  229.         static const int base[] = {
  230.                 100,
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_digit(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;
  263.         int base;

  265.         if (p == NULL || io_index == NULL || o_value == NULL) {
  266.                 return -1;
  267.         }
  268.         index = *io_index;
  269.         if (index < 0) {
  270.                 return -1;
  271.         }
  272.         sum = 0;
  273.         for (;;) {
  274.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  275.                         sum += value;
  276.                         if (get_digit_base(p, &index, &base) == 0) {
  277.                                 sum *= base;
  278.                                 if (skip_word(p, &index, "and") == 0) {
  279.                                         continue;
  280.                                 }
  281.                         }
  282.                         *o_value = sum;
  283.                         *io_index = index;
  284.                         return 0;
  285.                 }else if (sum == 0) {
  286.                         if (skip_word(p, &index, "a") == 0) {
  287.                                 if (get_digit_base(p, &index, &base) == 0) {
  288.                                         sum = base;
  289.                                         if (skip_word(p, &index, "and") == 0) {
  290.                                                 continue;
  291.                                         }
  292.                                         *o_value = sum;
  293.                                         *io_index = index;
  294.                                         return 0;
  295.                                 }
  296.                         }
  297.                 }
  298.                 return -1;
  299.         }
  300. }

  302. int get_operator1(const char *p, int *io_index, int *o_op)
  303. {
  304.         static const char *op_list[] = {
  305.                 "positive",
  306.                 "+",
  307.                 "negative",
  308.                 "-",
  309.         };
  310.         int index;
  311.         int start, len;
  312.         int retn;
  313.        
  314.         if (p == NULL || io_index == NULL || o_op == NULL) {
  315.                 return -1;
  316.         }
  317.         index = *io_index;
  318.         if (index < 0) {
  319.                 return -1;
  320.         }
  321.         skip_space(p, &index);
  322.         if (get_word(p, &index, &start, &len) == 0) {
  323.                 retn = get_token(p + start, len, op_list, 8);
  324.                 if (retn != -1) {
  325.                         *o_op = retn / 2;
  326.                         *io_index = index;
  327.                         return 0;
  328.                 }
  329.         }
  330.         return -1;
  331. }

  333. int get_operator2(const char *p, int *io_index, int *o_op)
  334. {
  335.         static const char *op_list[] = {
  336.                 "plus",
  337.                 "+",
  338.                 "minus",
  339.                 "-",
  340.                 "multiple",
  341.                 "*",
  342.                 "divide",
  343.                 "/",
  344.         };
  345.         int index;
  346.         int start, len;
  347.         int retn;

  349.         if (p == NULL || io_index == NULL || o_op == NULL) {
  350.                 return -1;
  351.         }
  352.         index = *io_index;
  353.         if (index < 0) {
  354.                 return -1;
  355.         }
  356.         skip_space(p, &index);
  357.         if (get_word(p, &index, &start, &len) == 0) {
  358.                 retn = get_token(p + start, len, op_list, 8);
  359.                 if (retn != -1) {
  360.                         *o_op = retn / 2;
  361.                         *io_index = index;
  362.                         return 0;
  363.                 }
  364.         }
  365.         return -1;
  366. }

  368. int main(void)
  369. {
  370.         char cmd_line[1024];
  371.         int op; /* operator */
  372.         int d1, d2; /* oprand number */
  373.         int result; /* store the expression result */
  374.         int index;

  376.         puts("English Caculator\n");
  377.         puts("Please enter an expression");
  378.         puts("CTRL-Z to exit");
  379.         for (;;) {
  380.                 printf("\n: ");
  381.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  382.                         return 0;
  383.                 }
  384.                 index = 0;
  385.                 if (get_english_digit(cmd_line, &index, &d1) == 0) {
  386.                         /* two oprands operation */
  387.                         if (get_operator2(cmd_line, &index, &op) != 0) {
  388.                                 printf("Invalid Operator\n");
  389.                                 continue;
  390.                         }
  391.                         if (get_english_digit(cmd_line, &index, &d2) != 0) {
  392.                                 printf("Invalid English Number\n");
  393.                                 continue;
  394.                         }
  395.                         switch (op) {
  396.                         case 0:
  397.                                 result = d1 + d2;
  398.                                 break;
  399.                         case 1:
  400.                                 result = d1 - d2;
  401.                                 break;
  402.                         case 2:
  403.                                 result = d1 * d2;
  404.                                 break;
  405.                         case 3:
  406.                                 result = d1 / d2;
  407.                                 break;
  408.                         default:
  409.                                 printf("unknown operator\n");
  410.                                 continue;
  411.                         }
  412.                 }else {
  413.                         /* one oprand operation */
  414.                         if (get_operator1(cmd_line, &index, &op) != 0) {
  415.                                 printf("Invalid Operator\n");
  416.                                 continue;
  417.                         }
  418.                         if (get_english_digit(cmd_line, &index, &d1) != 0) {
  419.                                 printf("Invalid English Number\n");
  420.                                 continue;
  421.                         }
  422.                         switch (op) {
  423.                         case 0:
  424.                                 result = d1;
  425.                                 break;
  426.                         case 1:
  427.                                 result = -d1;
  428.                                 break;
  429.                         default:
  430.                                 printf("unknown operator\n");
  431.                                 continue;
  432.                         }
  433.                 }
  434.                 printf("%d\n", result);
  435.         }
  436. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
cobras

论坛徽章:
2
2015年辞旧岁徽章 日期:2015-03-03 16:54:152015年迎新春徽章 日期:2015-03-04 09:56:11
10楼 [报告]
发表于 2011-08-09 14:22 |只看该作者
修正："a hundred and zero"和"zero hundred"之类的错误解析。

  2. /* eng_cac.c */

  4. /* english caculator */

  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include <string.h>

  10. int skip_space(const char *p, int *io_index)
  11. {
  12.         int index;

  14.         if (p == NULL || io_index == NULL) {
  15.                 return -1;
  16.         }
  17.         index = *io_index;
  18.         if (index < 0) {
  19.                 return -1;
  20.         }
  21.         if (!isspace(p[index])) {
  22.                 return -1;
  23.         }
  24.         do {
  25.                 ++index;
  26.         }while (isspace(p[index]));
  27.         *io_index = index;
  28.         return 0;
  29. }

  31. int get_word(const char *p, int *io_index, int *o_start, int *o_len)
  32. {
  33.         int index;

  35.         if (p == NULL || io_index == NULL || o_start == NULL || o_len == NULL) {
  36.                 return -1;
  37.         }
  38.         index = *io_index;
  39.         if (index < 0) {
  40.                 return -1;
  41.         }
  42.         if (isalpha(p[index])) {
  43.                 do {
  44.                         ++index;
  45.                 }while (isalpha(p[index]));
  46.                 *o_start = *io_index;
  47.                 *o_len = index - *io_index;
  48.                 *io_index = index;
  49.                 return 0;
  50.         }else if (ispunct(p[index])) {
  51.                 ++index;
  52.                 *o_start = *io_index;
  53.                 *o_len = 1;
  54.                 *io_index = index;
  55.                 return 0;
  56.         }else {
  57.                 return -1;
  58.         }
  59. }

  61. int get_token(const char *tok, int len, const char *tok_tab[], int tab_len)
  62. {
  63.         int i;

  65.         if (tok == NULL || tok_tab == NULL) {
  66.                 return -1;
  67.         }
  68.         if (len <= 0 || tab_len <= 0) {
  69.                 return -1;
  70.         }
  71.         for (i = 0; i < tab_len; ++i) {
  72.                 if (strncmp(tok, tok_tab[i], len) == 0) {
  73.                         return i;
  74.                 }
  75.         }
  76.         return -1;
  77. }

  79. int skip_word(const char *p, int *io_index, const char *s)
  80. {
  81.         int index;
  82.         int start, len;

  84.         if (p == NULL || io_index == NULL || s == NULL) {
  85.                 return -1;
  86.         }
  87.         index = *io_index;
  88.         if (index < 0) {
  89.                 return -1;
  90.         }
  91.         skip_space(p, &index);
  92.         if (get_word(p, &index, &start, &len) == 0) {
  93.                 if (strncmp(p + start, s, len) == 0) {
  94.                         *io_index = index;
  95.                         return 0;
  96.                 }
  97.         }
  98.         return -1;
  99. }

  101. int get_english_digit_bellow_twenty(const char *p, int *io_index, int *o_value)
  102. {
  103.         static const char *digit20[20] = {
  104.                 "zero",
  105.                 "one",
  106.                 "two",
  107.                 "three",
  108.                 "four",
  109.                 "five",
  110.                 "six",
  111.                 "seven",
  112.                 "eight",
  113.                 "nine",
  114.                 "ten",
  115.                 "eleven",
  116.                 "twelve",
  117.                 "thirteen",
  118.                 "fourteen",
  119.                 "fifteen",
  120.                 "sixteen",
  121.                 "seventeen",
  122.                 "eighteen",
  123.                 "nineteen",
  124.         };
  125.         int index;
  126.         int start;
  127.         int len;
  128.         int tok;

  130.         if (p == NULL || io_index == NULL || o_value == NULL) {
  131.                 return -1;
  132.         }
  133.         index = *io_index;
  134.         if (index < 0) {
  135.                 return -1;
  136.         }
  137.         skip_space(p, &index);
  138.         if (get_word(p, &index, &start, &len) == 0) {
  139.                 tok = get_token(p + start, len, digit20, 20);
  140.                 if (tok != -1) {
  141.                         *o_value = tok;
  142.                         *io_index = index;
  143.                         return 0;
  144.                 }
  145.         }
  146.         return -1;
  147. }

  149. int get_english_digit_decade(const char *p, int *io_index, int *o_value)
  150. {
  151.         static const char *decades[8] = {
  152.                 "twenty",
  153.                 "thirty",
  154.                 "forty",
  155.                 "fifty",
  156.                 "sixty",
  157.                 "seventy",
  158.                 "eighty",
  159.                 "ninety",
  160.         };
  161.         int index;
  162.         int start, len;
  163.         int value;
  164.         int retn;

  166.         if (p == NULL || io_index == NULL || o_value == NULL) {
  167.                 return -1;
  168.         }
  169.         index = *io_index;
  170.         if (index < 0) {
  171.                 return -1;
  172.         }
  173.         skip_space(p, &index);
  174.         if (get_word(p, &index, &start, &len) == 0) {
  175.                 retn = get_token(p + start, len, decades, 8);
  176.                 if (retn != -1) {
  177.                         value = retn * 10 + 20;
  178.                         *o_value = value;
  179.                         *io_index = index;
  180.                         return 0;
  181.                 }
  182.         }
  183.         return -1;
  184. }

  186. int get_english_digit_bellow_hundred(const char *p, int *io_index, int *o_value)
  187. {
  188.         int index;
  189.         int value;
  190.         int digit;
  191.         int decade_yes;

  193.         if (p == NULL || io_index == NULL || o_value == NULL) {
  194.                 return -1;
  195.         }
  196.         index = *io_index;
  197.         if (index < 0) {
  198.                 return -1;
  199.         }
  200.         decade_yes = 0;
  201.         if (get_english_digit_decade(p, &index, &value) == -1) {
  202.                 value = 0;
  203.         }else {
  204.                 decade_yes = 1;
  205.         }
  206.         if (get_english_digit_bellow_twenty(p, &index, &digit) == 0) {
  207.                 if (decade_yes && digit == 0) {
  208.                         return -1;
  209.                 }
  210.                 value += digit;
  211.         }else {
  212.                 if (!decade_yes) {
  213.                         return -1;
  214.                 }
  215.         }
  216.         *o_value = value;
  217.         *io_index = index;
  218.         return 0;
  219. }

  221. int get_digit_base(const char *p, int *io_index, int *o_base)
  222. {
  223.         static const char *more[] = {
  224.                 "hundred",
  225.                 "thousand",
  226.                 "million",
  227.                 "billion",
  228.         };
  229.         static const int base[] = {
  230.                 100,
  231.                 1000,
  232.                 1000000,
  233.                 1000000000,
  234.         };
  235.         int index;
  236.         int start,len;
  237.         int retn;

  239.         if (p == NULL || io_index == NULL || o_base == NULL) {
  240.                 return -1;
  241.         }
  242.         index = *io_index;
  243.         if (index < 0) {
  244.                 return -1;
  245.         }
  246.         skip_space(p, &index);
  247.         if (get_word(p, &index, &start, &len) == 0) {
  248.                 retn = get_token(p + start, len, more, 4);
  249.                 if (retn != -1) {
  250.                         *o_base = base[retn];
  251.                         *io_index = index;
  252.                         return 0;
  253.                 }
  254.         }
  255.         return -1;
  256. }

  258. int get_english_digit(const char *p, int *io_index, int *o_value)
  259. {
  260.         int index;
  261.         int value;
  262.         int sum;
  263.         int base;

  265.         if (p == NULL || io_index == NULL || o_value == NULL) {
  266.                 return -1;
  267.         }
  268.         index = *io_index;
  269.         if (index < 0) {
  270.                 return -1;
  271.         }
  272.         sum = 0;
  273.         for (;;) {
  274.                 if (get_english_digit_bellow_hundred(p, &index, &value) == 0) {
  275.                         if (sum > 0 && value == 0) {
  276.                                 return -1;
  277.                         }
  278.                         sum += value;
  279.                         if (get_digit_base(p, &index, &base) == 0) {
  280.                                 if (sum == 0) {
  281.                                         return -1;
  282.                                 }
  283.                                 sum *= base;
  284.                                 if (skip_word(p, &index, "and") == 0) {
  285.                                         continue;
  286.                                 }
  287.                         }
  288.                         *o_value = sum;
  289.                         *io_index = index;
  290.                         return 0;
  291.                 }else if (sum == 0) {
  292.                         if (skip_word(p, &index, "a") == 0) {
  293.                                 if (get_digit_base(p, &index, &base) == 0) {
  294.                                         sum = base;
  295.                                         if (skip_word(p, &index, "and") == 0) {
  296.                                                 continue;
  297.                                         }
  298.                                         *o_value = sum;
  299.                                         *io_index = index;
  300.                                         return 0;
  301.                                 }
  302.                         }
  303.                 }
  304.                 return -1;
  305.         }
  306. }

  308. int get_operator1(const char *p, int *io_index, int *o_op)
  309. {
  310.         static const char *op_list[] = {
  311.                 "positive",
  312.                 "+",
  313.                 "negative",
  314.                 "-",
  315.         };
  316.         int index;
  317.         int start, len;
  318.         int retn;
  319.        
  320.         if (p == NULL || io_index == NULL || o_op == NULL) {
  321.                 return -1;
  322.         }
  323.         index = *io_index;
  324.         if (index < 0) {
  325.                 return -1;
  326.         }
  327.         skip_space(p, &index);
  328.         if (get_word(p, &index, &start, &len) == 0) {
  329.                 retn = get_token(p + start, len, op_list, 8);
  330.                 if (retn != -1) {
  331.                         *o_op = retn / 2;
  332.                         *io_index = index;
  333.                         return 0;
  334.                 }
  335.         }
  336.         return -1;
  337. }

  339. int get_operator2(const char *p, int *io_index, int *o_op)
  340. {
  341.         static const char *op_list[] = {
  342.                 "plus",
  343.                 "+",
  344.                 "minus",
  345.                 "-",
  346.                 "multiple",
  347.                 "*",
  348.                 "divide",
  349.                 "/",
  350.         };
  351.         int index;
  352.         int start, len;
  353.         int retn;

  355.         if (p == NULL || io_index == NULL || o_op == NULL) {
  356.                 return -1;
  357.         }
  358.         index = *io_index;
  359.         if (index < 0) {
  360.                 return -1;
  361.         }
  362.         skip_space(p, &index);
  363.         if (get_word(p, &index, &start, &len) == 0) {
  364.                 retn = get_token(p + start, len, op_list, 8);
  365.                 if (retn != -1) {
  366.                         *o_op = retn / 2;
  367.                         *io_index = index;
  368.                         return 0;
  369.                 }
  370.         }
  371.         return -1;
  372. }

  374. int main(void)
  375. {
  376.         char cmd_line[1024];
  377.         int op; /* operator */
  378.         int d1, d2; /* oprand number */
  379.         int result; /* store the expression result */
  380.         int index;

  382.         puts("English Caculator\n");
  383.         puts("Please enter an expression");
  384.         puts("CTRL-Z to exit");
  385.         for (;;) {
  386.                 printf("\n: ");
  387.                 if (fgets(cmd_line, sizeof(cmd_line), stdin) == NULL) {
  388.                         return 0;
  389.                 }
  390.                 index = 0;
  391.                 if (get_english_digit(cmd_line, &index, &d1) == 0) {
  392.                         /* two oprands operation */
  393.                         if (get_operator2(cmd_line, &index, &op) != 0) {
  394.                                 printf("Invalid Operator\n");
  395.                                 continue;
  396.                         }
  397.                         if (get_english_digit(cmd_line, &index, &d2) != 0) {
  398.                                 printf("Invalid English Number\n");
  399.                                 continue;
  400.                         }
  401.                         switch (op) {
  402.                         case 0:
  403.                                 result = d1 + d2;
  404.                                 break;
  405.                         case 1:
  406.                                 result = d1 - d2;
  407.                                 break;
  408.                         case 2:
  409.                                 result = d1 * d2;
  410.                                 break;
  411.                         case 3:
  412.                                 result = d1 / d2;
  413.                                 break;
  414.                         default:
  415.                                 printf("unknown operator\n");
  416.                                 continue;
  417.                         }
  418.                 }else {
  419.                         /* one oprand operation */
  420.                         if (get_operator1(cmd_line, &index, &op) != 0) {
  421.                                 printf("Invalid Operator\n");
  422.                                 continue;
  423.                         }
  424.                         if (get_english_digit(cmd_line, &index, &d1) != 0) {
  425.                                 printf("Invalid English Number\n");
  426.                                 continue;
  427.                         }
  428.                         switch (op) {
  429.                         case 0:
  430.                                 result = d1;
  431.                                 break;
  432.                         case 1:
  433.                                 result = -d1;
  434.                                 break;
  435.                         default:
  436.                                 printf("unknown operator\n");
  437.                                 continue;
  438.                         }
  439.                 }
  440.                 printf("%d\n", result);
  441.         }
  442. }
复制代码
实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？
123下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号：11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们：huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP