Advertisement
Guest User

Untitled

a guest
Mar 18th, 2018
74
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 17.10 KB | None | 0 0
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #pragma warning(disable:4996)
  4. int main(void)
  5. {
  6.     int r1 = 0;
  7.     int r2 = 0;
  8.     int r3 = 0;
  9.     int r4 = 0;
  10.     int r5 = 0;
  11.     int r6 = 0;
  12.     int r7 = 0;
  13.     int r8 = 0;
  14.     int r9 = 0;
  15.     int r10 = 0;
  16.     int r12 = 0;
  17.     int r123 = 0;
  18.     int r45 = 0;
  19.     int a,m;
  20.     int s = 0;
  21.     scanf("%d",&a);
  22.     m = a;
  23.     if ( m == 0)
  24.     {   printf("zero"); return 0;}
  25.     while(m != 0)
  26.     {
  27.         m = m / 10;
  28.         s++;
  29.     }
  30.     switch (s)
  31.     {
  32.     case 1:
  33.         {
  34.             switch (a)
  35.             {
  36.             case 0:
  37.                 printf("zero");
  38.                 break;
  39.             case 1:
  40.                 printf("one");
  41.                 break;
  42.             case 2:
  43.                 printf("two");
  44.                 break;
  45.             case 3:
  46.                 printf("three");
  47.                 break;
  48.             case 4:
  49.                 printf("four");
  50.                 break;
  51.             case 5:
  52.                 printf("five");
  53.                 break;
  54.             case 6:
  55.                 printf("six");
  56.                 break;
  57.             case 7:
  58.                 printf("seven");
  59.                 break;
  60.             case 8:
  61.                 printf("eight");
  62.                 break;
  63.             case 9:
  64.                 printf("nine");
  65.                 break;
  66.             }
  67.             return 0;
  68.         }
  69.     case 2:
  70.         {  
  71.             switch (a)
  72.             {
  73.             case 10:
  74.                 printf("ten");
  75.                 break;
  76.             case 11:
  77.                 printf("eleven");
  78.                 break;
  79.             case 12:
  80.                 printf("twelve");
  81.                 break;
  82.             case 13:
  83.                 printf("thirteen");
  84.                 break;
  85.             case 14:
  86.                 printf("fourteen");
  87.                 break;
  88.             case 15:
  89.                 printf("fifteen");
  90.                 break;
  91.             case 16:
  92.                 printf("sixteen");
  93.                 break;
  94.             case 17:
  95.                 printf("seventeen");
  96.                 break;
  97.             case 18:
  98.                 printf("eighteen");
  99.                 break;
  100.             case 19:
  101.                 printf("nineteen");
  102.                 break;
  103.             case 20:
  104.                 printf("twenty");
  105.                 break;
  106.             case 30:
  107.                 printf("thirty");
  108.                 break;
  109.             case 40:
  110.                 printf("forty");
  111.                 break;
  112.             case 50:
  113.                 printf("fifty");
  114.                 break;
  115.             case 60:
  116.                 printf("sixty");
  117.                 break;
  118.             case 70:
  119.                 printf("seventy");
  120.                 break;
  121.             case 80:
  122.                 printf("eighty");
  123.                 break;
  124.             case 90:
  125.                 printf("ninety");
  126.                 break;
  127.             default:
  128.                 {
  129.                     r1 = a % 10;
  130.                     a = a / 10;
  131.                     r2 = a % 10;
  132.                     switch(r2)
  133.                     {
  134.                     case 2:
  135.                         printf("twenty-");
  136.                         break;
  137.                     case 3:
  138.                         printf("thirty-");
  139.                         break;
  140.                     case 4:
  141.                         printf("forty-");
  142.                         break;
  143.                     case 5:
  144.                         printf("fifty-");
  145.                         break;
  146.                     case 6:
  147.                         printf("sixty-");
  148.                         break;
  149.                     case 7:
  150.                         printf("seventy-");
  151.                         break;
  152.                     case 8:
  153.                         printf("eighty-");
  154.                         break;
  155.                     case 9:
  156.                         printf("ninety-");
  157.                         break;
  158.                     }
  159.                     switch(r1)
  160.                     {
  161.                     case 1:
  162.                         printf("one");
  163.                         break;
  164.                     case 2:
  165.                         printf("two");
  166.                         break;
  167.                     case 3:
  168.                         printf("three");
  169.                         break;
  170.                     case 4:
  171.                         printf("four");
  172.                         break;
  173.                     case 5:
  174.                         printf("five");
  175.                         break;
  176.                     case 6:
  177.                         printf("six");
  178.                         break;
  179.                     case 7:
  180.                         printf("seven");
  181.                         break;
  182.                     case 8:
  183.                         printf("eight");
  184.                         break;
  185.                     case 9:
  186.                         printf("nine");
  187.                         break;
  188.                     }
  189.                 }
  190.             }
  191.             return 0;
  192.         }
  193.     case 3:
  194.         {
  195.             switch (a)
  196.             {
  197.             case 100:
  198.                 printf("one hundred");
  199.                 break;
  200.             case 200:
  201.                 printf("two hundred");
  202.                 break;
  203.             case 300:
  204.                 printf("three hundred");
  205.                 break;
  206.             case 400:
  207.                 printf("four hundred");
  208.                 break;
  209.             case 500:
  210.                 printf("five hundred");
  211.                 break;
  212.             case 600:
  213.                 printf("six hundred");
  214.                 break;
  215.             case 700:
  216.                 printf("seven hundred");
  217.                 break;
  218.             case 800:
  219.                 printf("eight hundred");
  220.                 break;
  221.             case 900:
  222.                 printf("nine hundred");
  223.                 break;
  224.             default:
  225.                 {
  226.                     r1 = a % 10;
  227.                     r12 = a % 100;
  228.                     a = a / 10;
  229.                     r2 = a % 10;
  230.                     a = a / 10;
  231.                     r3  = a % 10;
  232.                     switch (r3)
  233.                     {
  234.                     case 1:
  235.                         printf("one hundred ");
  236.                         break;
  237.                     case 2:
  238.                         printf("two hundred ");
  239.                         break;
  240.                     case 3:
  241.                         printf("three hundred ");
  242.                         break;
  243.                     case 4:
  244.                         printf("four hundred ");
  245.                         break;
  246.                     case 5:
  247.                         printf("five hundred ");
  248.                         break;
  249.                     case 6:
  250.                         printf("six hundred ");
  251.                         break;
  252.                     case 7:
  253.                         printf("seven hundred ");
  254.                         break;
  255.                     case 8:
  256.                         printf("eight hundred ");
  257.                         break;
  258.                     case 9:
  259.                         printf("nine hundred ");
  260.                         break;
  261.                     }
  262.                     switch(r2)
  263.                     {
  264.                     case 0:
  265.                         break;
  266.                     case 1:
  267.                         r1 = 0;
  268.                         switch (r12)
  269.                         {
  270.                         case 10:
  271.                             printf("ten");
  272.                             return 0;
  273.                         case 11:
  274.                             printf("eleven");
  275.                             return 0;
  276.                         case 12:
  277.                             printf("twelve");
  278.                             return 0;
  279.                         case 13:
  280.                             printf("thirteen");
  281.                             return 0;
  282.                         case 14:
  283.                             printf("fourteen");
  284.                             return 0;
  285.                         case 15:
  286.                             printf("fifteen");
  287.                             return 0;
  288.                         case 16:
  289.                             printf("sixteen");
  290.                             return 0;
  291.                         case 17:
  292.                             printf("seventeen");
  293.                             return 0;
  294.                         case 18:
  295.                             printf("eighteen");
  296.                             return 0;
  297.                         case 19:
  298.                             printf("nineteen");
  299.                             return 0;
  300.                         }
  301.                         break;
  302.                     case 2:
  303.                         if (r1 != 0)
  304.                             printf("twenty-");
  305.                         else
  306.                             printf("twenty");
  307.                         break;
  308.                     case 3:
  309.                         if (r1 != 0)
  310.                             printf("thirty-");
  311.                         else
  312.                             printf("thirty");
  313.                         break;
  314.                     case 4:
  315.                         if (r1 != 0)
  316.                             printf("forty-");
  317.                         else
  318.                             printf("forty");
  319.                         break;
  320.                     case 5:
  321.                         if (r1 != 0)
  322.                             printf("fifty-");
  323.                         else
  324.                             printf("fifty");
  325.                         break;
  326.                     case 6:
  327.                         if (r1 != 0)
  328.                             printf("sixty-");
  329.                         else
  330.                             printf("sixty");
  331.                         break;
  332.                     case 7:
  333.                         if (r1 != 0)
  334.                             printf("seventy-");
  335.                         else
  336.                             printf("seventy");
  337.                         break;
  338.                     case 8:
  339.                         if (r1 != 0)
  340.                             printf("eighty-");
  341.                         else
  342.                             printf("eighty");
  343.                         break;
  344.                     case 9:
  345.                         if (r1 != 0)
  346.                             printf("ninety-");
  347.                         else
  348.                             printf("ninety");
  349.                         break;
  350.                     }
  351.                     switch(r1)
  352.                     {
  353.                     case 1:
  354.                         printf("one");
  355.                         break;
  356.                     case 2:
  357.                         printf("two");
  358.                         break;
  359.                     case 3:
  360.                         printf("three");
  361.                         break;
  362.                     case 4:
  363.                         printf("four");
  364.                         break;
  365.                     case 5:
  366.                         printf("five");
  367.                         break;
  368.                     case 6:
  369.                         printf("six");
  370.                         break;
  371.                     case 7:
  372.                         printf("seven");
  373.                         break;
  374.                     case 8:
  375.                         printf("eight");
  376.                         break;
  377.                     case 9:
  378.                         printf("nine");
  379.                         break;
  380.                     }
  381.                 }
  382.             }
  383.             return 0;
  384.         }
  385.     case 4:
  386.         {
  387.             switch (a)
  388.             {
  389.             case 1000:
  390.                 printf("one thousand");
  391.                 break;
  392.             case 2000:
  393.                 printf("two thousand");
  394.                 break;
  395.             case 3000:
  396.                 printf("three thousand");
  397.                 break;
  398.             case 4000:
  399.                 printf("four thousand");
  400.                 break;
  401.             case 5000:
  402.                 printf("five thousand");
  403.                 break;
  404.             case 6000:
  405.                 printf("six thousand");
  406.                 break;
  407.             case 7000:
  408.                 printf("seven thousand");
  409.                 break;
  410.             case 8000:
  411.                 printf("eight thousand");
  412.                 break;
  413.             case 9000:
  414.                 printf("nine thousand");
  415.                 break;
  416.             default:
  417.                 {
  418.                     r1 = a % 10;
  419.                     r12 = a % 100;
  420.                     r123 = a % 1000;
  421.                     a = a / 10;
  422.                     r2 = a % 10;
  423.                     a = a / 10;
  424.                     r3  = a % 10;
  425.                     a  = a / 10;
  426.                     r4 = a % 10;
  427.                     switch (r4)
  428.                     {
  429.                     case 1:
  430.                         printf("one thousand ");
  431.                         break;
  432.                     case 2:
  433.                         printf("two thousand ");
  434.                         break;
  435.                     case 3:
  436.                         printf("three thousand ");
  437.                         break;
  438.                     case 4:
  439.                         printf("four thousand ");
  440.                         break;
  441.                     case 5:
  442.                         printf("five thousand ");
  443.                         break;
  444.                     case 6:
  445.                         printf("six thousand ");
  446.                         break;
  447.                     case 7:
  448.                         printf("seven thousand ");
  449.                         break;
  450.                     case 8:
  451.                         printf("eight thousand ");
  452.                         break;
  453.                     case 9:
  454.                         printf("nine thousand ");
  455.                         break;
  456.                     }
  457.                     switch (r3)
  458.                     {
  459.                     case 0:
  460.                         break;
  461.                     case 1:
  462.                         printf("one hundred ");
  463.                         break;
  464.                     case 2:
  465.                         printf("two hundred ");
  466.                         break;
  467.                     case 3:
  468.                         printf("three hundred ");
  469.                         break;
  470.                     case 4:
  471.                         printf("four hundred ");
  472.                         break;
  473.                     case 5:
  474.                         printf("five hundred ");
  475.                         break;
  476.                     case 6:
  477.                         printf("six hundred ");
  478.                         break;
  479.                     case 7:
  480.                         printf("seven hundred ");
  481.                         break;
  482.                     case 8:
  483.                         printf("eight hundred ");
  484.                         break;
  485.                     case 9:
  486.                         printf("nine hundred ");
  487.                         break;
  488.                     }
  489.                     switch(r2)
  490.                     {
  491.                     case 0:
  492.                         break;
  493.                     case 1:
  494.                         r1 = 0;
  495.                         switch (r12)
  496.                         {
  497.                         case 10:
  498.                             printf("ten");
  499.                             return 0;
  500.                         case 11:
  501.                             printf("eleven");
  502.                             return 0;
  503.                         case 12:
  504.                             printf("twelve");
  505.                             return 0;
  506.                         case 13:
  507.                             printf("thirteen");
  508.                             return 0;
  509.                         case 14:
  510.                             printf("fourteen");
  511.                             return 0;
  512.                         case 15:
  513.                             printf("fifteen");
  514.                             return 0;
  515.                         case 16:
  516.                             printf("sixteen");
  517.                             return 0;
  518.                         case 17:
  519.                             printf("seventeen");
  520.                             return 0;
  521.                         case 18:
  522.                             printf("eighteen");
  523.                             return 0;
  524.                         case 19:
  525.                             printf("nineteen");
  526.                             return 0;
  527.                         }
  528.                     case 2:
  529.                         if (r1 != 0)
  530.                             printf("twenty-");
  531.                         else
  532.                             printf("twenty");
  533.                         break;
  534.                     case 3:
  535.                         if (r1 != 0)
  536.                             printf("thirty-");
  537.                         else
  538.                             printf("thirty");
  539.                         break;
  540.                     case 4:
  541.                         if (r1 != 0)
  542.                             printf("forty-");
  543.                         else
  544.                             printf("forty");
  545.                         break;
  546.                     case 5:
  547.                         if (r1 != 0)
  548.                             printf("fifty-");
  549.                         else
  550.                             printf("fifty");
  551.                         break;
  552.                     case 6:
  553.                         if (r1 != 0)
  554.                             printf("sixty-");
  555.                         else
  556.                             printf("sixty");
  557.                         break;
  558.                     case 7:
  559.                         if (r1 != 0)
  560.                             printf("seventy-");
  561.                         else
  562.                             printf("seventy");
  563.                         break;
  564.                     case 8:
  565.                         if (r1 != 0)
  566.                             printf("eighty-");
  567.                         else
  568.                             printf("eighty");
  569.                         break;
  570.                     case 9:
  571.                         if (r1 != 0)
  572.                             printf("ninety-");
  573.                         else
  574.                             printf("ninety");
  575.                         break;
  576.                     }
  577.                     switch(r1)
  578.                     {
  579.                     case 1:
  580.                         printf("one");
  581.                         break;
  582.                     case 2:
  583.                         printf("two");
  584.                         break;
  585.                     case 3:
  586.                         printf("three");
  587.                         break;
  588.                     case 4:
  589.                         printf("four");
  590.                         break;
  591.                     case 5:
  592.                         printf("five");
  593.                         break;
  594.                     case 6:
  595.                         printf("six");
  596.                         break;
  597.                     case 7:
  598.                         printf("seven");
  599.                         break;
  600.                     case 8:
  601.                         printf("eight");
  602.                         break;
  603.                     case 9:
  604.                         printf("nine");
  605.                         break;
  606.                     }  
  607.                 }
  608.             }
  609.             return 0;
  610.         }
  611.  
  612.     case 5:
  613.         {
  614.  
  615.             switch (a)
  616.             {
  617.             case 10000:
  618.                 printf("ten thousand");
  619.                 break;
  620.             case 11000:
  621.                 printf("eleven thousand");
  622.                 break;
  623.             case 12000:
  624.                 printf("twelve thousand");
  625.                 break;
  626.             case 13000:
  627.                 printf("thirteen thousand");
  628.                 break;
  629.             case 14000:
  630.                 printf("fourteen thousand");
  631.                 break;
  632.             case 15000:
  633.                 printf("fifteen thousand");
  634.                 break;
  635.             case 16000:
  636.                 printf("sixteen thousand");
  637.                 break;
  638.             case 17000:
  639.                 printf("seventeen thousand");
  640.                 break;
  641.             case 18000:
  642.                 printf("eighteen thousand");
  643.                 break;
  644.             case 19000:
  645.                 printf("nineteen thousand");
  646.                 break;
  647.             case 20000:
  648.                 printf("twenty thousand");
  649.                 break;
  650.             case 30000:
  651.                 printf("thirty thousand");
  652.                 break;
  653.             case 40000:
  654.                 printf("forty thousand");
  655.                 break;
  656.             case 50000:
  657.                 printf("fifty thousand");
  658.                 break;
  659.             case 60000:
  660.                 printf("sixty thousand");
  661.                 break;
  662.             case 70000:
  663.                 printf("seventy thousand");
  664.                 break;
  665.             case 80000:
  666.                 printf("eighty thousand");
  667.                 break;
  668.             case 90000:
  669.                 printf("ninety thousand");
  670.                 break;
  671.             default:
  672.                 {
  673.                     r1 = a % 10;
  674.                     r12 = a % 100;
  675.                     r123 = a % 1000;
  676.                     a = a / 10;
  677.                     r2 = a % 10;
  678.                     a = a / 10;
  679.                     r3  = a % 10;
  680.                     a  = a / 10;
  681.                     r4 = a % 10;
  682.                     r45 = a % 100;
  683.                     a = a / 10;
  684.                     r5 = a % 10;
  685.                     switch(r5)
  686.                     {
  687.                     case 1:
  688.                        
  689.                             r4 = 0;
  690.                             switch (r45)
  691.                             {
  692.                             case 10:
  693.                                 printf("ten thousand");
  694.                                 break;
  695.                             case 11:
  696.                                 printf("eleven thousand");
  697.                                 break;
  698.                             case 12:
  699.                                 printf("twelve thousand");
  700.                                 break;
  701.                             case 13:
  702.                                 printf("thirteen thousand");
  703.                                 break;
  704.                             case 14:
  705.                                 printf("fourteen thousand");
  706.                                 break;
  707.                             case 15:
  708.                                 printf("fifteen thousand");
  709.                                 break;
  710.                             case 16:
  711.                                 printf("sixteen thousand");
  712.                                 break;
  713.                             case 17:
  714.                                 printf("seventeen thousand");
  715.                                 break;
  716.                             case 18:
  717.                                 printf("eighteen thousand");
  718.                                 break;
  719.                             case 19:
  720.                                 printf("nineteen thousand");
  721.                                 break;
  722.                             }
  723.                             break;
  724.                     case 2:
  725.                         if (r4 != 0)
  726.                             printf("twenty-");
  727.                         else
  728.                             printf("twenty thousand");
  729.                         break;
  730.                     case 3:
  731.                         if (r4 != 0)
  732.                             printf("thirty-");
  733.                         else
  734.                             printf("thirty thousand");
  735.                         break;
  736.                     case 4:
  737.                         if (r4 != 0)
  738.                             printf("forty-");
  739.                         else
  740.                             printf("forty thousand");
  741.                         break;
  742.                     case 5:
  743.                         if (r4 != 0)
  744.                             printf("fifty-");
  745.                         else
  746.                             printf("fifty thousand");
  747.                         break;
  748.                     case 6:
  749.                         if (r4 != 0)
  750.                             printf("sixty-");
  751.                         else
  752.                             printf("sixty thousand");
  753.                         break;
  754.                     case 7:
  755.                         if (r4 != 0)
  756.                             printf("seventy-");
  757.                         else
  758.                             printf("seventy thousand");
  759.                         break;
  760.                     case 8:
  761.                         if (r4 != 0)
  762.                             printf("eighty-");
  763.                         else
  764.                             printf("eighty thousand");
  765.                         break;
  766.                     case 9:
  767.                         if (r4 != 0)
  768.                             printf("ninety-");
  769.                         else
  770.                             printf("ninety thousand");
  771.                         break;
  772.                     }
  773.                     switch(r4)
  774.                     {
  775.                     case 0:
  776.                         break;
  777.                     case 1:
  778.                         printf("one thousand");
  779.                         break;
  780.                     case 2:
  781.                         printf("two thousand");
  782.                         break;
  783.                     case 3:
  784.                         printf("three thousand");
  785.                         break;
  786.                     case 4:
  787.                         printf("four thousand");
  788.                         break;
  789.                     case 5:
  790.                         printf("five thousand");
  791.                         break;
  792.                     case 6:
  793.                         printf("six thousand");
  794.                         break;
  795.                     case 7:
  796.                         printf("seven thousand");
  797.                         break;
  798.                     case 8:
  799.                         printf("eight thousand");
  800.                         break;
  801.                     case 9:
  802.                         printf("nine thousand");
  803.                         break;
  804.                     }
  805.                     switch (r3)
  806.                     {
  807.                     case 0:
  808.                         break;
  809.                     case 1:
  810.                         printf(" one hundred");
  811.                         break;
  812.                     case 2:
  813.                         printf(" two hundred");
  814.                         break;
  815.                     case 3:
  816.                         printf(" three hundred");
  817.                         break;
  818.                     case 4:
  819.                         printf(" four hundred");
  820.                         break;
  821.                     case 5:
  822.                         printf(" five hundred");
  823.                         break;
  824.                     case 6:
  825.                         printf(" six hundred");
  826.                         break;
  827.                     case 7:
  828.                         printf(" seven hundred");
  829.                         break;
  830.                     case 8:
  831.                         printf(" eight hundred");
  832.                         break;
  833.                     case 9:
  834.                         printf(" nine hundred");
  835.                         break;
  836.                     }
  837.                     switch(r2)
  838.                     {
  839.                     case 0:
  840.                         break;
  841.                     case 1:
  842.                         r1 = 0;
  843.                         switch (r12)
  844.                         {
  845.                         case 10:
  846.                             printf(" ten");
  847.                             return 0;
  848.                         case 11:
  849.                             printf(" eleven");
  850.                             return 0;
  851.                         case 12:
  852.                             printf(" twelve");
  853.                             return 0;
  854.                         case 13:
  855.                             printf(" thirteen");
  856.                             return 0;
  857.                         case 14:
  858.                             printf(" fourteen");
  859.                             return 0;
  860.                         case 15:
  861.                             printf(" fifteen");
  862.                             return 0;
  863.                         case 16:
  864.                             printf(" sixteen");
  865.                             return 0;
  866.                         case 17:
  867.                             printf(" seventeen");
  868.                             return 0;
  869.                         case 18:
  870.                             printf(" eighteen");
  871.                             return 0;
  872.                         case 19:
  873.                             printf(" nineteen");
  874.                             return 0;
  875.                         }
  876.                     case 2:
  877.                         if (r1 != 0)
  878.                             printf(" twenty-");
  879.                         else
  880.                             printf(" twenty");
  881.                         break;
  882.                     case 3:
  883.                         if (r1 != 0)
  884.                             printf(" thirty-");
  885.                         else
  886.                             printf(" thirty");
  887.                         break;
  888.                     case 4:
  889.                         if (r1 != 0)
  890.                             printf(" forty-");
  891.                         else
  892.                             printf(" forty");
  893.                         break;
  894.                     case 5:
  895.                         if (r1 != 0)
  896.                             printf(" fifty-");
  897.                         else
  898.                             printf(" fifty");
  899.                         break;
  900.                     case 6:
  901.                         if (r1 != 0)
  902.                             printf(" sixty-");
  903.                         else
  904.                             printf(" sixty");
  905.                         break;
  906.                     case 7:
  907.                         if (r1 != 0)
  908.                             printf(" seventy-");
  909.                         else
  910.                             printf(" seventy");
  911.                         break;
  912.                     case 8:
  913.                         if (r1 != 0)
  914.                             printf(" eighty-");
  915.                         else
  916.                             printf(" eighty");
  917.                         break;
  918.                     case 9:
  919.                         if (r1 != 0)
  920.                             printf(" ninety-");
  921.                         else
  922.                             printf(" ninety");
  923.                         break;
  924.                     }
  925.                     switch(r1)
  926.                     {
  927.                     case 1:
  928.                         if(r2 == 0)
  929.                         printf(" one");
  930.                         else printf("one");
  931.                         break;
  932.                     case 2:
  933.                         if (r2 == 0)
  934.                         printf(" two");
  935.                         else printf("two");
  936.                         break;
  937.                     case 3:
  938.                         if(r2 == 0)
  939.                         printf(" three");
  940.                         else printf("three");
  941.                         break;
  942.                     case 4:
  943.                         if (r2 == 0)
  944.                         printf(" four");
  945.                         else printf("four");
  946.                         break;
  947.                     case 5:
  948.                         if (r2 == 0)
  949.                         printf(" five");
  950.                         else
  951.                         printf("five");
  952.                         break;
  953.                     case 6:
  954.                         if (r2 == 0)
  955.                         printf(" six");
  956.                         else
  957.                         printf("six");
  958.                         break;
  959.                     case 7:
  960.                         if (r2 == 0)
  961.                         printf(" seven");
  962.                         else
  963.                             printf("seven");
  964.  
  965.                         break;
  966.                     case 8:
  967.                         if(r2 == 0)
  968.                         printf(" eight");
  969.                         else
  970.                             printf("eight");
  971.                         break;
  972.                     case 9:
  973.                         if(r2 == 0)
  974.                         printf(" nine");
  975.                         else
  976.                             printf("nine");
  977.                         break;
  978.                     }  
  979.                 }
  980.             }
  981.             return 0;
  982.         }
  983.     }
  984.     return 0;
  985. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement