API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 28th, 2020
100
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 30.54 KB | None | 0 0
raw download clone embed print report
  1. //--------------Реализация простых мат. операций (1-9)--------------
  2. char* SimpleMath1()
  3. {
  4.     static char ret[1024];
  5.  
  6.     int type = rnum(1, 20);
  7.     switch (type)
  8.     {
  9.     case 1:
  10.     {
  11.         sprintf(ret, "n1");
  12.         break;
  13.     }
  14.     case 2:
  15.     {
  16.         sprintf(ret, "n1");
  17.         break;
  18.     }
  19.     case 3:
  20.     {
  21.         sprintf(ret, "((n3+n3)-n5)");
  22.         break;
  23.     }
  24.     case 4:
  25.     {
  26.         sprintf(ret, "((n4+n4)-n7)");
  27.         break;
  28.     }
  29.     case 5:
  30.     {
  31.         sprintf(ret, "(n5+n5-n9)");
  32.         break;
  33.     }
  34.     case 6:
  35.     {
  36.         sprintf(ret, "((n6 + n6) -(n7+n4))");
  37.         break;
  38.     }
  39.     case 7:
  40.     {
  41.         sprintf(ret, "((n7+n7)-(n8+n5))");
  42.         break;
  43.     }
  44.     case 8:
  45.     {
  46.         sprintf(ret, "((n8+n8)-(n9+n6))");
  47.         break;
  48.     }
  49.     case 9:
  50.     {
  51.         sprintf(ret, "((n1*n2)-n1)");
  52.         break;
  53.     }
  54.     case 10:
  55.     {
  56.         sprintf(ret, "((n2*n3)-n5)");
  57.         break;
  58.     }
  59.     case 11:
  60.     {
  61.         sprintf(ret, "((n3*n3)-n8)");
  62.         break;
  63.     }
  64.     case 12:
  65.     {
  66.         sprintf(ret, "((n4*n4)-((n3*n4)+n3))");
  67.         break;
  68.     }
  69.     case 13:
  70.     {
  71.         sprintf(ret, "((n5*n5)-(n6*n4))");
  72.         break;
  73.     }
  74.     case 14:
  75.     {
  76.         sprintf(ret, "((n6*n6)-((n6*n5)+n5))");
  77.         break;
  78.     }
  79.     case 15:
  80.     {
  81.         sprintf(ret, "((n7*n7)-(n6*n8))");
  82.         break;
  83.     }
  84.     case 16:
  85.     {
  86.         sprintf(ret, "((n8*n8)-(n7*n9))");
  87.         break;
  88.     }
  89.     case 17:
  90.     {
  91.         sprintf(ret, "((n9*n9)-((n2*n5)*n8))");
  92.         break;
  93.     }
  94.     case 18:
  95.     {
  96.         sprintf(ret, "((n3*n3)-(n4*n2))");
  97.         break;
  98.     }
  99.     case 19:
  100.     {
  101.         sprintf(ret, "(((n2*n3)+n2)-(n3+n4))");
  102.         break;
  103.     }
  104.     case 20:
  105.     {
  106.         sprintf(ret, "((n4*n3)-(n3*n2))");
  107.         break;
  108.     }
  109.     }
  110.  
  111.     return ret;
  112. }
  113.  
  114. char* SimpleMath2()
  115. {
  116.     static char ret[1024];
  117.  
  118.     int type = rnum(1, 20);
  119.     switch (type)
  120.     {
  121.     case 1:
  122.     {
  123.         sprintf(ret, "n2");
  124.         break;
  125.     }
  126.     case 2:
  127.     {
  128.         sprintf(ret, "n2");
  129.         break;
  130.     }
  131.     case 3:
  132.     {
  133.         sprintf(ret, "(n2*n1)");
  134.         break;
  135.     }
  136.     case 4:
  137.     {
  138.         sprintf(ret, "(n1*n2)");
  139.         break;
  140.     }
  141.     case 5:
  142.     {
  143.         sprintf(ret, "((n2*n2)-n2)");
  144.         break;
  145.     }
  146.     case 6:
  147.     {
  148.         sprintf(ret, "(n4/n2)");
  149.         break;
  150.     }
  151.     case 7:
  152.     {
  153.         sprintf(ret, "(n8/n4)");
  154.         break;
  155.     }
  156.     case 8:
  157.     {
  158.         sprintf(ret, "((n3*n3)-(n4+n3))");
  159.         break;
  160.     }
  161.     case 9:
  162.     {
  163.         sprintf(ret, "((n3*n4)-(n6+n4))");
  164.         break;
  165.     }
  166.     case 10:
  167.     {
  168.         sprintf(ret, "((n3*n3+n1)-n8)");
  169.         break;
  170.     }
  171.     case 11:
  172.     {
  173.         sprintf(ret, "(n5-n3)");
  174.         break;
  175.     }
  176.     case 12:
  177.     {
  178.         sprintf(ret, "(((n2*n5)*n2)-(n9*n2))");
  179.         break;
  180.     }
  181.     case 13:
  182.     {
  183.         sprintf(ret, "(((n3*n3)*n2)-(n4*n4))");
  184.         break;
  185.     }
  186.     case 14:
  187.     {
  188.         sprintf(ret, "(((n2*n2)*n2)-(n3*n2))");
  189.         break;
  190.     }
  191.     case 15:
  192.     {
  193.         sprintf(ret, "n2");
  194.         break;
  195.     }
  196.     case 16:
  197.     {
  198.         sprintf(ret, "((n3*n3)-(n5+n2))");
  199.         break;
  200.     }
  201.     case 17:
  202.     {
  203.         sprintf(ret, "(n4-(n1*n2))");
  204.         break;
  205.     }
  206.     case 18:
  207.     {
  208.         sprintf(ret, "((n5*n4)/(n2+n8))");
  209.         break;
  210.     }
  211.     case 19:
  212.     {
  213.         sprintf(ret, "((8+2)-(4*2))");
  214.         break;
  215.     }
  216.     case 20:
  217.     {
  218.         sprintf(ret, "((2*6)-(2+2+2+2+2))");
  219.         break;
  220.     }
  221.     }
  222.  
  223.     return ret;
  224. }
  225.  
  226. char* SimpleMath3()
  227. {
  228.     static char ret[1024];
  229.  
  230.     int type = rnum(1, 20);
  231.     switch (type)
  232.     {
  233.     case 1:
  234.     {
  235.         sprintf(ret, "n3");
  236.         break;
  237.     }
  238.     case 2:
  239.     {
  240.         sprintf(ret, "n3");
  241.         break;
  242.     }
  243.     case 3:
  244.     {
  245.         sprintf(ret, "(n2+n1)");
  246.         break;
  247.     }
  248.     case 4:
  249.     {
  250.         sprintf(ret, "((n2*n2)-n1)");
  251.         break;
  252.     }
  253.     case 5:
  254.     {
  255.         sprintf(ret, "((n2+n3)-(n1*n2))");
  256.         break;
  257.     }
  258.     case 6:
  259.     {
  260.         sprintf(ret, "((n2*n3)/n2)");
  261.         break;
  262.     }
  263.     case 7:
  264.     {
  265.         sprintf(ret, "(((n2*n2)*n2)-(n1*n5))");
  266.         break;
  267.     }
  268.     case 8:
  269.     {
  270.         sprintf(ret, "((n6*n2)/n4)");
  271.         break;
  272.     }
  273.     case 9:
  274.     {
  275.         sprintf(ret, "(n9/n3)");
  276.         break;
  277.     }
  278.     case 10:
  279.     {
  280.         sprintf(ret, "(n3*n1)");
  281.         break;
  282.     }
  283.     case 11:
  284.     {
  285.         sprintf(ret, "(n1*n3)");
  286.         break;
  287.     }
  288.     case 12:
  289.     {
  290.         sprintf(ret, "((n4/n2)+n1)");
  291.         break;
  292.     }
  293.     case 13:
  294.     {
  295.         sprintf(ret, "(n2+n2-n1)");
  296.         break;
  297.     }
  298.     case 14:
  299.     {
  300.         sprintf(ret, "(n1+n1+n1)");
  301.         break;
  302.     }
  303.     case 15:
  304.     {
  305.         sprintf(ret, "(((n4*n3)/n2)/n2)");
  306.         break;
  307.     }
  308.     case 16:
  309.     {
  310.         sprintf(ret, "(((n7*n2)+1)/n5)");
  311.         break;
  312.     }
  313.     case 17:
  314.     {
  315.         sprintf(ret, "(((n4+n3)*n3)/n7)");
  316.         break;
  317.     }
  318.     case 18:
  319.     {
  320.         sprintf(ret, "((((n8*n2)+n2)/n9)+n1)");
  321.         break;
  322.     }
  323.     case 19:
  324.     {
  325.         sprintf(ret, "(((n3*n3)*n3)/n9)");
  326.         break;
  327.     }
  328.     case 20:
  329.     {
  330.         sprintf(ret, "((n4-n3)*(n2+n1))");
  331.         break;
  332.     }
  333.     }
  334.  
  335.     return ret;
  336. }
  337.  
  338. char* SimpleMath4()
  339. {
  340.     static char ret[1024];
  341.  
  342.     int type = rnum(1, 20);
  343.     switch (type)
  344.     {
  345.     case 1:
  346.     {
  347.         sprintf(ret, "n4");
  348.         break;
  349.     }
  350.     case 2:
  351.     {
  352.         sprintf(ret, "n4");
  353.         break;
  354.     }
  355.     case 3:
  356.     {
  357.         sprintf(ret, "(n2*n2)");
  358.         break;
  359.     }
  360.     case 4:
  361.     {
  362.         sprintf(ret, "((n8*n2)/n4)");
  363.         break;
  364.     }
  365.     case 5:
  366.     {
  367.         sprintf(ret, "((n3*n2)-n2)");
  368.         break;
  369.     }
  370.     case 6:
  371.     {
  372.         sprintf(ret, "((n3*n4)/n3)");
  373.         break;
  374.     }
  375.     case 7:
  376.     {
  377.         sprintf(ret, "(n8/n2)");
  378.         break;
  379.     }
  380.     case 8:
  381.     {
  382.         sprintf(ret, "(n1*n2*n2)");
  383.         break;
  384.     }
  385.     case 9:
  386.     {
  387.         sprintf(ret, "(n2*n1*n2)");
  388.         break;
  389.     }
  390.     case 10:
  391.     {
  392.         sprintf(ret, "(((n3*n3)/n3)+n1)");
  393.         break;
  394.     }
  395.     case 11:
  396.     {
  397.         sprintf(ret, "(n1+n1+n1+n1)");
  398.         break;
  399.     }
  400.     case 12:
  401.     {
  402.         sprintf(ret, "((n2*n1)+n2)");
  403.         break;
  404.     }
  405.     case 13:
  406.     {
  407.         sprintf(ret, "(n5-n1)");
  408.         break;
  409.     }
  410.     case 14:
  411.     {
  412.         sprintf(ret, "(n9-n5)");
  413.         break;
  414.     }
  415.     case 15:
  416.     {
  417.         sprintf(ret, "((n7+n1)/n2)");
  418.         break;
  419.     }
  420.     case 16:
  421.     {
  422.         sprintf(ret, "((n9+n1)-n6)");
  423.         break;
  424.     }
  425.     case 17:
  426.     {
  427.         sprintf(ret, "(n7-n3)");
  428.         break;
  429.     }
  430.     case 18:
  431.     {
  432.         sprintf(ret, "(n1+n3)");
  433.         break;
  434.     }
  435.     case 19:
  436.     {
  437.         sprintf(ret, "(n9-n3-n2)");
  438.         break;
  439.     }
  440.     case 20:
  441.     {
  442.         sprintf(ret, "(n6-(n1+n1))");
  443.         break;
  444.     }
  445.     }
  446.  
  447.     return ret;
  448. }
  449.  
  450. char* SimpleMath5()
  451. {
  452.     static char ret[1024];
  453.  
  454.     int type = rnum(1, 20);
  455.     switch (type)
  456.     {
  457.     case 1:
  458.     {
  459.         sprintf(ret, "n5");
  460.         break;
  461.     }
  462.     case 2:
  463.     {
  464.         sprintf(ret, "n5");
  465.         break;
  466.     }
  467.     case 3:
  468.     {
  469.         sprintf(ret, "(n4+n1)");
  470.         break;
  471.     }
  472.     case 4:
  473.     {
  474.         sprintf(ret, "(n1+n1+n1+n1+n1)");
  475.         break;
  476.     }
  477.     case 5:
  478.     {
  479.         sprintf(ret, "(n2+n3)");
  480.         break;
  481.     }
  482.     case 6:
  483.     {
  484.         sprintf(ret, "((n2*n2)+n1)");
  485.         break;
  486.     }
  487.     case 7:
  488.     {
  489.         sprintf(ret, "(((n2*n2*n2)+n2)-(n3+n2))");
  490.         break;
  491.     }
  492.     case 8:
  493.     {
  494.         sprintf(ret, "(((n7*n7)+n1)/(n3*n3+n1))");
  495.         break;
  496.     }
  497.     case 9:
  498.     {
  499.         sprintf(ret, "(((n3*n3)+n1)-(n3+n2))");
  500.         break;
  501.     }
  502.     case 10:
  503.     {
  504.         sprintf(ret, "(n2+n2+n1)");
  505.         break;
  506.     }
  507.     case 11:
  508.     {
  509.         sprintf(ret, "(n2+(n1+n1+n1))");
  510.         break;
  511.     }
  512.     case 12:
  513.     {
  514.         sprintf(ret, "(n1+n1+(n1*n3))");
  515.         break;
  516.     }
  517.     case 13:
  518.     {
  519.         sprintf(ret, "(n2+n2+n1)");
  520.         break;
  521.     }
  522.     case 14:
  523.     {
  524.         sprintf(ret, "((n8-n4)+n1)");
  525.         break;
  526.     }
  527.     case 15:
  528.     {
  529.         sprintf(ret, "(n7-n2)");
  530.         break;
  531.     }
  532.     case 16:
  533.     {
  534.         sprintf(ret, "((n2*n5)/n2)");
  535.         break;
  536.     }
  537.     case 17:
  538.     {
  539.         sprintf(ret, "(n6-n1)");
  540.         break;
  541.     }
  542.     case 18:
  543.     {
  544.         sprintf(ret, "(n1*n2+n3)");
  545.         break;
  546.     }
  547.     case 19:
  548.     {
  549.         sprintf(ret, "(((n5-n2)*n2)-n1)");
  550.         break;
  551.     }
  552.     case 20:
  553.     {
  554.         sprintf(ret, "((n6+n2)-n3)");
  555.         break;
  556.     }
  557.     }
  558.  
  559.     return ret;
  560. }
  561.  
  562. char* SimpleMath6()
  563. {
  564.     static char ret[1024];
  565.  
  566.     int type = rnum(1, 20);
  567.     switch (type)
  568.     {
  569.     case 1:
  570.     {
  571.         sprintf(ret, "n6");
  572.         break;
  573.     }
  574.     case 2:
  575.     {
  576.         sprintf(ret, "n6");
  577.         break;
  578.     }
  579.     case 3:
  580.     {
  581.         sprintf(ret, "(n6*n1)");
  582.         break;
  583.     }
  584.     case 4:
  585.     {
  586.         sprintf(ret, "(n1*n6)");
  587.         break;
  588.     }
  589.     case 5:
  590.     {
  591.         sprintf(ret, "(n8-n2)");
  592.         break;
  593.     }
  594.     case 6:
  595.     {
  596.         sprintf(ret, "(n3*n2)");
  597.         break;
  598.     }
  599.     case 7:
  600.     {
  601.         sprintf(ret, "((n3*n3)-n3)");
  602.         break;
  603.     }
  604.     case 8:
  605.     {
  606.         sprintf(ret, "(n1+n1+n1+n1+n1+n1)");
  607.         break;
  608.     }
  609.     case 9:
  610.     {
  611.         sprintf(ret, "(n3+n3)");
  612.         break;
  613.     }
  614.     case 10:
  615.     {
  616.         sprintf(ret, "((n2*n5)-n4)");
  617.         break;
  618.     }
  619.     case 11:
  620.     {
  621.         sprintf(ret, "(n2*n2+n2)");
  622.         break;
  623.     }
  624.     case 12:
  625.     {
  626.         sprintf(ret, "(n2+n2+n2)");
  627.         break;
  628.     }
  629.     case 13:
  630.     {
  631.         sprintf(ret, "(n3+n1+n1+n1)");
  632.         break;
  633.     }
  634.     case 14:
  635.     {
  636.         sprintf(ret, "((n9*n2)/n3)");
  637.         break;
  638.     }
  639.     case 15:
  640.     {
  641.         sprintf(ret, "(((n4+n4)/n4)*n3)");
  642.         break;
  643.     }
  644.     case 16:
  645.     {
  646.         sprintf(ret, "(n5+n1)");
  647.         break;
  648.     }
  649.     case 17:
  650.     {
  651.         sprintf(ret, "(((n9+n1)/n2)+n1)");
  652.         break;
  653.     }
  654.     case 18:
  655.     {
  656.         sprintf(ret, "(n1+n2+n3)");
  657.         break;
  658.     }
  659.     case 19:
  660.     {
  661.         sprintf(ret, "(((n7+n3)/n3)*n2)");
  662.         break;
  663.     }
  664.     case 20:
  665.     {
  666.         sprintf(ret, "((((n2*n5)*n2)+n4)/n4)");
  667.         break;
  668.     }
  669.     }
  670.  
  671.     return ret;
  672. }
  673.  
  674. char* SimpleMath7()
  675. {
  676.     static char ret[1024];
  677.  
  678.     int type = rnum(1, 20);
  679.     switch (type)
  680.     {
  681.     case 1:
  682.     {
  683.         sprintf(ret, "n7");
  684.         break;
  685.     }
  686.     case 2:
  687.     {
  688.         sprintf(ret, "n7");
  689.         break;
  690.     }
  691.     case 3:
  692.     {
  693.         sprintf(ret, "(n6+n1)");
  694.         break;
  695.     }
  696.     case 4:
  697.     {
  698.         sprintf(ret, "(n5+n2)");
  699.         break;
  700.     }
  701.     case 5:
  702.     {
  703.         sprintf(ret, "(n4+n3)");
  704.         break;
  705.     }
  706.     case 6:
  707.     {
  708.         sprintf(ret, "(n3+n4)");
  709.         break;
  710.     }
  711.     case 7:
  712.     {
  713.         sprintf(ret, "((n2*n3)+n1)");
  714.         break;
  715.     }
  716.     case 8:
  717.     {
  718.         sprintf(ret, "(((n2*n2)*n2)-n1)");
  719.         break;
  720.     }
  721.     case 9:
  722.     {
  723.         sprintf(ret, "((n3*n3)-(n2*n1))");
  724.         break;
  725.     }
  726.     case 10:
  727.     {
  728.         sprintf(ret, "((n5+n5)-(n2+n1))");
  729.         break;
  730.     }
  731.     case 11:
  732.     {
  733.         sprintf(ret, "((n7+n3)-n3)");
  734.         break;
  735.     }
  736.     case 12:
  737.     {
  738.         sprintf(ret, "((n2+n2+n3)+(n1-n1))");
  739.         break;
  740.     }
  741.     case 13:
  742.     {
  743.         sprintf(ret, "((n2*n4)-(n1*n1))");
  744.         break;
  745.     }
  746.     case 14:
  747.     {
  748.         sprintf(ret, "((n9/n3)+(n2*n2))");
  749.         break;
  750.     }
  751.     case 15:
  752.     {
  753.         sprintf(ret, "((n8/n4)+n5)");
  754.         break;
  755.     }
  756.     case 16:
  757.     {
  758.         sprintf(ret, "((n3*n3)-(n4+n4)+n6)");
  759.         break;
  760.     }
  761.     case 17:
  762.     {
  763.         sprintf(ret, "((n5*n3)-(n4*n2))");
  764.         break;
  765.     }
  766.     case 18:
  767.     {
  768.         sprintf(ret, "(((n7-n3)*n2)-n1)");
  769.         break;
  770.     }
  771.     case 19:
  772.     {
  773.         sprintf(ret, "((n2*n3)-(n3+n2)+n6)");
  774.         break;
  775.     }
  776.     case 20:
  777.     {
  778.         sprintf(ret, "((n1+n1)*(n1+n1)+n3)");
  779.         break;
  780.     }
  781.     }
  782.  
  783.     return ret;
  784. }
  785.  
  786. char* SimpleMath8()
  787. {
  788.     static char ret[1024];
  789.  
  790.     int type = rnum(1, 20);
  791.     switch (type)
  792.     {
  793.     case 1:
  794.     {
  795.         sprintf(ret, "n8");
  796.         break;
  797.     }
  798.     case 2:
  799.     {
  800.         sprintf(ret, "n8");
  801.         break;
  802.     }
  803.     case 3:
  804.     {
  805.         sprintf(ret, "(n8*n1)");
  806.         break;
  807.     }
  808.     case 4:
  809.     {
  810.         sprintf(ret, "(n2*n2*n2)");
  811.         break;
  812.     }
  813.     case 5:
  814.     {
  815.         sprintf(ret, "(n4*n2)");
  816.         break;
  817.     }
  818.     case 6:
  819.     {
  820.         sprintf(ret, "(n4*n4)/n2");
  821.         break;
  822.     }
  823.     case 7:
  824.     {
  825.         sprintf(ret, "((n3*n3)-n1)");
  826.         break;
  827.     }
  828.     case 8:
  829.     {
  830.         sprintf(ret, "(n5+n3)");
  831.         break;
  832.     }
  833.     case 9:
  834.     {
  835.         sprintf(ret, "(n1+n1+n1+n1+n1+n1+n1+n1)");
  836.         break;
  837.     }
  838.     case 10:
  839.     {
  840.         sprintf(ret, "(n2+n2+n2+n2)");
  841.         break;
  842.     }
  843.     case 11:
  844.     {
  845.         sprintf(ret, "(n3+n3+n2)");
  846.         break;
  847.     }
  848.     case 12:
  849.     {
  850.         sprintf(ret, "(n9-n1)");
  851.         break;
  852.     }
  853.     case 13:
  854.     {
  855.         sprintf(ret, "((n2*n5)-n2)");
  856.         break;
  857.     }
  858.     case 14:
  859.     {
  860.         sprintf(ret, "(n4*n4)/n2");
  861.         break;
  862.     }
  863.     case 15:
  864.     {
  865.         sprintf(ret, "(n5+n2+n1)");
  866.         break;
  867.     }
  868.     case 16:
  869.     {
  870.         sprintf(ret, "((n4*n3)-n4)");
  871.         break;
  872.     }
  873.     case 17:
  874.     {
  875.         sprintf(ret, "(n2+n6)");
  876.         break;
  877.     }
  878.     case 18:
  879.     {
  880.         sprintf(ret, "(n1+n2+n3+n2)");
  881.         break;
  882.     }
  883.     case 19:
  884.     {
  885.         sprintf(ret, "(n7+(n2-n1))");
  886.         break;
  887.     }
  888.     case 20:
  889.     {
  890.         sprintf(ret, "((n2+n3)+n3)");
  891.         break;
  892.     }
  893.     }
  894.  
  895.     return ret;
  896. }
  897.  
  898. char* SimpleMath9()
  899. {
  900.     static char ret[1024];
  901.  
  902.     int type = rnum(1, 20);
  903.     switch (type)
  904.     {
  905.     case 1:
  906.     {
  907.         sprintf(ret, "n9");
  908.         break;
  909.     }
  910.     case 2:
  911.     {
  912.         sprintf(ret, "n9");
  913.         break;
  914.     }
  915.     case 3:
  916.     {
  917.         sprintf(ret, "(n3*n3)");
  918.         break;
  919.     }
  920.     case 4:
  921.     {
  922.         sprintf(ret, "(n3+n3+n3)");
  923.         break;
  924.     }
  925.     case 5:
  926.     {
  927.         sprintf(ret, "(n1+n1+n1+n1+n1+n1+n1+n1+n1)");
  928.         break;
  929.     }
  930.     case 6:
  931.     {
  932.         sprintf(ret, "(n8+n1)");
  933.         break;
  934.     }
  935.     case 7:
  936.     {
  937.         sprintf(ret, "((n2*n3)+n3)");
  938.         break;
  939.     }
  940.     case 8:
  941.     {
  942.         sprintf(ret, "((n2*n5)-n1)");
  943.         break;
  944.     }
  945.     case 9:
  946.     {
  947.         sprintf(ret, "((n4*n2)+n1)");
  948.         break;
  949.     }
  950.     case 10:
  951.     {
  952.         sprintf(ret, "((n2*n2)+n5)");
  953.         break;
  954.     }
  955.     case 11:
  956.     {
  957.         sprintf(ret, "(n7+n2)");
  958.         break;
  959.     }
  960.     case 12:
  961.     {
  962.         sprintf(ret, "((n1+n2+n3+n4)-n1)");
  963.         break;
  964.     }
  965.     case 13:
  966.     {
  967.         sprintf(ret, "((n6*n2)-n3)");
  968.         break;
  969.     }
  970.     case 14:
  971.     {
  972.         sprintf(ret, "((n2*n3)+(n2+n1))");
  973.         break;
  974.     }
  975.     case 15:
  976.     {
  977.         sprintf(ret, "(n3+n6)");
  978.         break;
  979.     }
  980.     case 16:
  981.     {
  982.         sprintf(ret, "((n2*n2)+(n2+n3))");
  983.         break;
  984.     }
  985.     case 17:
  986.     {
  987.         sprintf(ret, "(n7+(n5-n3))");
  988.         break;
  989.     }
  990.     case 18:
  991.     {
  992.         sprintf(ret, "(((n4-n2)*n4)+n1)");
  993.         break;
  994.     }
  995.     case 19:
  996.     {
  997.         sprintf(ret, "((n2*n8)-n7)");
  998.         break;
  999.     }
  1000.     case 20:
  1001.     {
  1002.         sprintf(ret, "((n8-n7)*(n6+n4))");
  1003.         break;
  1004.     }
  1005.     }
  1006.  
  1007.     return ret;
  1008. }
  1009. //--------------Реализация простых мат. операций (1-9)--------------
  1010.  
  1011.  
  1012. //--------------Реализация сложных мат. операций чисел от 0 до 9. Составляются из более простых операций--------------
  1013. char* HardMathMinus1()
  1014. {
  1015.     static char ret[1024];
  1016.  
  1017.     int type = rnum(1, 4);
  1018.     switch (type)
  1019.     {
  1020.     case 1:
  1021.     {
  1022.         sprintf(ret, "((%s)-(%s))", HardMath1(), HardMath2());
  1023.         break;
  1024.     }
  1025.     case 2:
  1026.     {
  1027.         sprintf(ret, "((%s)-(%s))", HardMath2(), HardMath3());
  1028.         break;
  1029.     }
  1030.     case 3:
  1031.     {
  1032.         sprintf(ret, "((%s)-(%s))", HardMath4(), HardMath5());
  1033.         break;
  1034.     }
  1035.     case 4:
  1036.     {
  1037.         sprintf(ret, "((%s)-(%s))", HardMath6(), HardMath7());
  1038.         break;
  1039.     }
  1040.     case 5:
  1041.     {
  1042.         sprintf(ret, "((%s)-(%s))", HardMath8(), HardMath9());
  1043.         break;
  1044.     }
  1045.     }
  1046.  
  1047.     return ret;
  1048. }
  1049.  
  1050. char* HardMath0()
  1051. {
  1052.     static char ret[1024];
  1053.  
  1054.     int type = rnum(1, 9);
  1055.  
  1056.     switch (type)
  1057.     {
  1058.         case 1:
  1059.         {
  1060.             sprintf(ret, "((%s)-(%s))", HardMath1(), HardMath1());
  1061.             break;
  1062.         }
  1063.         case 2:
  1064.         {
  1065.             sprintf(ret, "((%s)-(%s))", HardMath2(), HardMath2());
  1066.             break;
  1067.         }
  1068.         case 3:
  1069.         {
  1070.             sprintf(ret, "((%s)-(%s))", HardMath3(), HardMath3());
  1071.             break;
  1072.         }
  1073.         case 4:
  1074.         {
  1075.             sprintf(ret, "((%s)-(%s))", HardMath4(), HardMath4());
  1076.             break;
  1077.         }
  1078.         case 5:
  1079.         {
  1080.             sprintf(ret, "((%s)-(%s))", HardMath5(), HardMath5());
  1081.             break;
  1082.         }
  1083.         case 6:
  1084.         {
  1085.             sprintf(ret, "((%s)-(%s))", HardMath6(), HardMath6());
  1086.             break;
  1087.         }
  1088.         case 7:
  1089.         {
  1090.             sprintf(ret, "((%s)-(%s))", HardMath7(), HardMath7());
  1091.             break;
  1092.         }
  1093.         case 8:
  1094.         {
  1095.             sprintf(ret, "((%s)-(%s))", HardMath8(), HardMath8());
  1096.             break;
  1097.         }
  1098.         case 9:
  1099.         {
  1100.             sprintf(ret, "((%s)-(%s))", HardMath9(), HardMath9());
  1101.             break;
  1102.         }
  1103.     }
  1104.  
  1105.     return ret;
  1106. }
  1107.  
  1108. char* HardMath1()
  1109. {
  1110.     static char ret[1024];
  1111.  
  1112.     int type = rnum(1, 4);
  1113.     switch (type)
  1114.     {
  1115.     case 1:
  1116.     {
  1117.         //(((2*9)*(2*5))+9/3)-(9*9+2)-(((2*5)*(2*5))/2)-(((2*5)*2)*2+9)
  1118.         sprintf(ret, "(((%s*%s)*(%s*%s))+%s/%s)-(%s*%s+%s)-(((%s*%s)*(%s*%s))/%s)-(((%s*%s)*%s)*%s+%s)", SimpleMath2(), SimpleMath9(), SimpleMath2(), SimpleMath5(), SimpleMath9(), SimpleMath3(), SimpleMath9(), SimpleMath9(), SimpleMath2(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath2(), SimpleMath9());
  1119.         break;
  1120.     }
  1121.     case 2:
  1122.     {
  1123.         //((((3*3)*(2*5))*7-((2*4+2)*(2*5))*5)/2)-(((1*(2*5))*6)+(2*2))
  1124.         sprintf(ret, "((((%s*%s)*(%s*%s))*%s-((%s*%s+%s)*(%s*%s))*%s)/%s)-(((%s*(%s*%s))*%s)+(%s*%s))", SimpleMath3(), SimpleMath3(), SimpleMath2(), SimpleMath5(), SimpleMath7(), SimpleMath2(), SimpleMath4(), SimpleMath2(), SimpleMath2(), SimpleMath5(), SimpleMath5(), SimpleMath2(), SimpleMath1(), SimpleMath2(), SimpleMath5(), SimpleMath6(), SimpleMath2(), SimpleMath2());
  1125.         break;
  1126.     }
  1127.     case 3:
  1128.     {
  1129.         //(((7*7*(2*5))-(((2*5)*(2*5))*4))/2)-(((2*2*2*2)+2)+(2*2)+((2*2*2+2)*2+2))
  1130.         sprintf(ret, "(((%s*%s*(%s*%s))-(((%s*%s)*(%s*%s))*%s))/%s)-(((%s*%s*%s*%s)+%s)+(%s*%s)+((%s*%s*%s+%s)*%s+%s))", SimpleMath7(), SimpleMath7(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath5(), SimpleMath4(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2());
  1131.         break;
  1132.     }
  1133.     case 4:
  1134.     {
  1135.         //((((2*5)*(2*5)*(2*5))/((2*5)*2)+(2*6)*2)-(2*6))/2-(((2*2+2*2)+2)*3)
  1136.         sprintf(ret, "((((%s*%s)*(%s*%s)*(%s*%s))/((%s*%s)*%s)+(%s*%s)*%s)-(%s*%s))/%s-(((%s*%s+%s*%s)+%s)*%s)", SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath2(), SimpleMath6(), SimpleMath2(), SimpleMath2(), SimpleMath6(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath3());
  1137.         break;
  1138.     }
  1139.     }
  1140.  
  1141.     return ret;
  1142. }
  1143.  
  1144. char* HardMath2()
  1145. {
  1146.     static char ret[1024];
  1147.  
  1148.     int type = rnum(1, 4);
  1149.     switch (type)
  1150.     {
  1151.     case 1:
  1152.     {
  1153.         sprintf(ret, "((((((%s*%s)*(%s-%s))/%s)*(%s-%s))-((%s*%s)+%s+((%s*%s)*%s)))/%s)", SimpleMath2(), SimpleMath2(), SimpleMath9(), SimpleMath5(), SimpleMath2(), SimpleMath9(), SimpleMath1(), SimpleMath5(), SimpleMath6(), SimpleMath4(), SimpleMath2(), SimpleMath2(), SimpleMath3(), SimpleMath9());
  1154.         break;
  1155.     }
  1156.     case 2:
  1157.     {
  1158.         sprintf(ret, "(((((((%s*%s)*(%s*%s))/%s)*(%s+%s))-(%s*(%s+%s)))/%s)-(%s+%s+%s+%s+%s))", SimpleMath3(), SimpleMath3(), SimpleMath2(), SimpleMath2(), SimpleMath3(), SimpleMath1(), SimpleMath1(), SimpleMath2(), SimpleMath3(), SimpleMath2(), SimpleMath2(), SimpleMath1(), SimpleMath1(), SimpleMath1(), SimpleMath1(), SimpleMath1());
  1159.         break;
  1160.     }
  1161.     case 3:
  1162.     {
  1163.         sprintf(ret, "((((%s+%s+%s)+(%s-%s))*%s)-((%s+%s*%s)+((%s+%s)*(%s*%s)+(%s*(%s-%s))))-(%s-%s))", SimpleMath1(), SimpleMath1(), SimpleMath1(), SimpleMath5(), SimpleMath3(), SimpleMath8(), SimpleMath1(), SimpleMath1(), SimpleMath3(), SimpleMath1(), SimpleMath1(), SimpleMath2(), SimpleMath4(), SimpleMath5(), SimpleMath6(), SimpleMath4(), SimpleMath9(), SimpleMath1());
  1164.         break;
  1165.     }
  1166.     case 4:
  1167.     {
  1168.         sprintf(ret, "(((((((%s*(%s-%s))+(%s*%s))/%s)+(%s*%s))/(%s-%s))-(((%s-%s)+(%s-%s))))/%s)", SimpleMath9(), SimpleMath5(), SimpleMath4(), SimpleMath5(), SimpleMath5(), SimpleMath2(), SimpleMath3(), SimpleMath1(), SimpleMath9(), SimpleMath7(), SimpleMath5(), SimpleMath3(), SimpleMath7(), SimpleMath5(), SimpleMath3());
  1169.         break;
  1170.     }
  1171.     }
  1172.  
  1173.     return ret;
  1174. }
  1175.  
  1176. char* HardMath3()
  1177. {
  1178.     static char ret[1024];
  1179.  
  1180.     int type = rnum(1, 4);
  1181.     switch (type)
  1182.     {
  1183.     case 1:
  1184.     {
  1185.         sprintf(ret, "(((((%s*(%s*%s))*%s)/((%s*(%s+%s+%s)))/%s)/((%s+%s)*(%s-%s)))+(%s-%s))", SimpleMath9(), SimpleMath4(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath3(), SimpleMath1(), SimpleMath1(), SimpleMath2(), SimpleMath1(), SimpleMath2(), SimpleMath9(), SimpleMath6(), SimpleMath8(), SimpleMath7());
  1186.         break;
  1187.     }
  1188.     case 2:
  1189.     {
  1190.         sprintf(ret, "(((%s*(%s+(%s*%s))/((%s*%s)-(%s+%s)))+(%s-%s))/(%s+(%s-%s)))", SimpleMath9(), SimpleMath5(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath5(), SimpleMath4(), SimpleMath3(), SimpleMath8(), SimpleMath5(), SimpleMath7(), SimpleMath5(), SimpleMath2());
  1191.         break;
  1192.     }
  1193.     case 3:
  1194.     {
  1195.         sprintf(ret, "((((((%s*%s)+(%s-%s))/(%s-%s))+(%s+%s-%s))/((%s*%s+%s)-(%s-%s)))/%s)", SimpleMath7(), SimpleMath7(), SimpleMath9(), SimpleMath8(), SimpleMath8(), SimpleMath6(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath1(), SimpleMath4(), SimpleMath1(), SimpleMath5());
  1196.         break;
  1197.     }
  1198.     case 4:
  1199.     {
  1200.         sprintf(ret, "((((%s*(%s-%s))+(%s-((%s+%s)-%s)))/(%s-(%s-%s)))-((%s+(%s*%s))/%s))", SimpleMath6(), SimpleMath9(), SimpleMath3(), SimpleMath9(), SimpleMath4(), SimpleMath3(), SimpleMath2(), SimpleMath6(), SimpleMath5(), SimpleMath4(), SimpleMath2(), SimpleMath2(), SimpleMath4(), SimpleMath2());
  1201.         break;
  1202.     }
  1203.     }
  1204.  
  1205.     return ret;
  1206. }
  1207.  
  1208. char* HardMath4()
  1209. {
  1210.     static char ret[1024];
  1211.  
  1212.     int type = rnum(1, 4);
  1213.     switch (type)
  1214.     {
  1215.     case 1:
  1216.     {
  1217.         sprintf(ret, "((((((%s*%s)*%s)+(%s*%s)+(%s-%s))/(%s-%s))-(%s-%s))/((%s+%s)*(%s-%s)))", SimpleMath3(), SimpleMath2(), SimpleMath5(), SimpleMath6(), SimpleMath9(), SimpleMath7(), SimpleMath1(), SimpleMath6(), SimpleMath4(), SimpleMath9(), SimpleMath4(), SimpleMath2(), SimpleMath3(), SimpleMath7(), SimpleMath5());
  1218.         break;
  1219.     }
  1220.     case 2:
  1221.     {
  1222.         sprintf(ret, "(((((%s+%s)*%s)+((%s-%s)*%s))/((%s-%s)*%s)/%s)-(%s-%s))", SimpleMath3(), SimpleMath9(), SimpleMath6(), SimpleMath8(), SimpleMath4(), SimpleMath2(), SimpleMath9(), SimpleMath5(), SimpleMath2(), SimpleMath2(), SimpleMath4(), SimpleMath3());
  1223.         break;
  1224.     }
  1225.     case 3:
  1226.     {
  1227.         sprintf(ret, "(((((((%s*%s)+(%s-%s))*%s)/((%s+%s)-(%s-%s))+(%s-%s))/%s)-(%s+%s))/(%s+%s))", SimpleMath5(), SimpleMath6(), SimpleMath5(), SimpleMath1(), SimpleMath5(), SimpleMath4(), SimpleMath5(), SimpleMath9(), SimpleMath2(), SimpleMath6(), SimpleMath1(), SimpleMath2(), SimpleMath4(), SimpleMath1(), SimpleMath8(), SimpleMath2());
  1228.         break;
  1229.     }
  1230.     case 4:
  1231.     {
  1232.         sprintf(ret, "(((((%s*%s)*(%s+(%s+%s)))/(%s-%s))-(%s+(%s-%s)))/((%s-%s)+%s))", SimpleMath5(), SimpleMath2(), SimpleMath4(), SimpleMath2(), SimpleMath3(), SimpleMath8(), SimpleMath6(), SimpleMath4(), SimpleMath9(), SimpleMath8(), SimpleMath8(), SimpleMath1(), SimpleMath3());
  1233.         break;
  1234.     }
  1235.     }
  1236.  
  1237.     return ret;
  1238. }
  1239.  
  1240. char* HardMath5()
  1241. {
  1242.     static char ret[1024];
  1243.  
  1244.     int type = rnum(1, 4);
  1245.  
  1246.     switch (type)
  1247.     {
  1248.     case 1:
  1249.     {
  1250.         sprintf(ret, "(((((((%s*%s)+(%s*%s))*(%s+%s))/(%s-%s))-(%s-%s))/%s)/(%s-%s))", SimpleMath6(), SimpleMath7(), SimpleMath4(), SimpleMath9(), SimpleMath4(), SimpleMath3(), SimpleMath6(), SimpleMath3(), SimpleMath5(), SimpleMath3(), SimpleMath9(), SimpleMath9(), SimpleMath5());
  1251.         break;
  1252.     }
  1253.     case 2:
  1254.     {
  1255.         //
  1256.         sprintf(ret, "(((((((((%s/%s)*%s)+((%s+%s)*%s))/(%s/%s))+(%s+%s-(%s*%s)))/(%s-%s))+(%s-%s))/%s)+(%s*%s))", SimpleMath8(), SimpleMath4(), SimpleMath9(), SimpleMath5(), SimpleMath7(), SimpleMath8(), SimpleMath6(), SimpleMath3(), SimpleMath5(), SimpleMath6(), SimpleMath5(), SimpleMath2(), SimpleMath5(), SimpleMath6(), SimpleMath7(), SimpleMath6(), SimpleMath6(), SimpleMath2(), SimpleMath7());
  1257.         break;
  1258.     }
  1259.     case 3:
  1260.     {
  1261.         sprintf(ret, "((((((((%s*%s)*%s)/%s)*(%s-%s))-%s)-((%s+%s)-((%s+%s)-(%s+%s)))-%s)/(%s/%s))+(%s-%s))", SimpleMath1(), SimpleMath9(), SimpleMath7(), SimpleMath6(), SimpleMath7(), SimpleMath5(), SimpleMath1(), SimpleMath2(), SimpleMath2(), SimpleMath5(), SimpleMath4(), SimpleMath6(), SimpleMath3(), SimpleMath1(), SimpleMath9(), SimpleMath3(), SimpleMath6(), SimpleMath5());
  1262.         break;
  1263.     }
  1264.     case 4:
  1265.     {
  1266.         sprintf(ret, "((((((%s*(%s+(%s+%s)))-((%s-%s)+%s))-(%s*%s))/(((%s+%s+%s+%s)+%s+%s)/%s)+(%s+%s)))-%s)", SimpleMath5(), SimpleMath4(), SimpleMath2(), SimpleMath3(), SimpleMath9(), SimpleMath7(), SimpleMath5(), SimpleMath2(), SimpleMath3(), SimpleMath5(), SimpleMath2(), SimpleMath3(), SimpleMath3(), SimpleMath2(), SimpleMath1(), SimpleMath2(), SimpleMath1(), SimpleMath2(), SimpleMath2());
  1267.         break;
  1268.     }
  1269.     }
  1270.  
  1271.     return ret;
  1272. }
  1273.  
  1274. char* HardMath6()
  1275. {
  1276.     static char ret[1024];
  1277.  
  1278.     int type = rnum(1, 4);
  1279.     switch (type)
  1280.     {
  1281.     case 1:
  1282.     {
  1283.         sprintf(ret, "(((((%s*%s)+(%s/%s)*(%s-%s)/%s+(%s+%s)+(%s-%s))/%s))*%s)", SimpleMath2(), SimpleMath3(), SimpleMath8(), SimpleMath2(), SimpleMath5(), SimpleMath3(), SimpleMath2(), SimpleMath3(), SimpleMath2(), SimpleMath3(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath3(), SimpleMath2());
  1284.         break;
  1285.     }
  1286.     case 2:
  1287.     {
  1288.         sprintf(ret, "(((((%s+%s)*%s)-(%s+%s)*((%s+%s)-%s)+((%s-%s)*%s))/%s))", SimpleMath4(), SimpleMath5(), SimpleMath2(), SimpleMath5(), SimpleMath3(), SimpleMath3(), SimpleMath5(), SimpleMath5(), SimpleMath9(), SimpleMath3(), SimpleMath3(), SimpleMath2());
  1289.         break;
  1290.     }
  1291.     case 3:
  1292.     {
  1293.         sprintf(ret, "((((((%s*%s)/(%s-%s)+(%s/%s)+(%s*%s))/%s)+(%s-%s)+(%s-%s))/%s))", SimpleMath2(), SimpleMath5(), SimpleMath8(), SimpleMath3(), SimpleMath6(), SimpleMath3(), SimpleMath6(), SimpleMath3(), SimpleMath2(), SimpleMath8(), SimpleMath4(), SimpleMath9(), SimpleMath6(), SimpleMath3());
  1294.         break;
  1295.     }
  1296.     case 4:
  1297.     {
  1298.         sprintf(ret, "((((((%s+%s)*(%s-%s)+(%s-%s)+(%s-%s))/%s)+(%s-%s))/%s))", SimpleMath7(), SimpleMath5(), SimpleMath6(), SimpleMath4(), SimpleMath9(), SimpleMath4(), SimpleMath5(), SimpleMath2(), SimpleMath2(), SimpleMath8(), SimpleMath6(), SimpleMath3());
  1299.         break;
  1300.     }
  1301.     }
  1302.  
  1303.     return ret;
  1304. }
  1305.  
  1306. char* HardMath7()
  1307. {
  1308.     static char ret[1024];
  1309.  
  1310.     int type = rnum(1, 4);
  1311.     switch (type)
  1312.     {
  1313.     case 1:
  1314.     {
  1315.         sprintf(ret, "(((((%s*(%s+%s+%s))*(%s-%s))/%s)/(%s+%s+%s))+(%s+%s+%s+(%s-%s)-%s))", SimpleMath5(), SimpleMath2(), SimpleMath3(), SimpleMath1(), SimpleMath5(), SimpleMath1(), SimpleMath2(), SimpleMath5(), SimpleMath4(), SimpleMath1(), SimpleMath4(), SimpleMath2(), SimpleMath1(), SimpleMath5(), SimpleMath2(), SimpleMath9());
  1316.         break;
  1317.     }
  1318.     case 2:
  1319.     {
  1320.         sprintf(ret, "((((%s*(%s/%s))*(%s+%s))/(((%s+%s)/%s)*%s))/((%s+%s)-(%s+%s)))", SimpleMath7(), SimpleMath6(), SimpleMath2(), SimpleMath2(), SimpleMath2(), SimpleMath3(), SimpleMath5(), SimpleMath4(), SimpleMath2(), SimpleMath5(), SimpleMath4(), SimpleMath4(), SimpleMath2());
  1321.         break;
  1322.     }
  1323.     case 3:
  1324.     {
  1325.         sprintf(ret, "((((((%s+%s+%s)*%s)+(%s+%s))-(%s*%s))/%s)+((%s+%s)/%s))", SimpleMath7(), SimpleMath3(), SimpleMath5(), SimpleMath2(), SimpleMath6(), SimpleMath2(), SimpleMath5(), SimpleMath6(), SimpleMath2(), SimpleMath5(), SimpleMath1(), SimpleMath2());
  1326.         break;
  1327.     }
  1328.     case 4:
  1329.     {
  1330.         sprintf(ret, "(((((((%s+%s)*%s)/(%s-%s))+(%s+%s))-%s)/(%s-(%s-%s)))/(%s-%s))", SimpleMath4(), SimpleMath2(), SimpleMath6(), SimpleMath6(), SimpleMath3(), SimpleMath7(), SimpleMath2(), SimpleMath2(), SimpleMath3(), SimpleMath1(), SimpleMath5(), SimpleMath6(), SimpleMath2(), SimpleMath9(), SimpleMath6());
  1331.         break;
  1332.     }
  1333.     }
  1334.  
  1335.     return ret;
  1336. }
  1337.  
  1338. char* HardMath8()
  1339. {
  1340.     static char ret[1024];
  1341.  
  1342.     int type = rnum(1, 4);
  1343.     switch (type)
  1344.     {
  1345.     case 1:
  1346.     {
  1347.         sprintf(ret, "((((%s*%s+(%s*%s)+%s)*(%s+%s-%s)+(%s+%s-%s))/(%s-%s))/(%s*(%s-%s)))", SimpleMath7(), SimpleMath3(), SimpleMath6(), SimpleMath3(), SimpleMath1(), SimpleMath7(), SimpleMath2(), SimpleMath6(), SimpleMath9(), SimpleMath1(), SimpleMath2(), SimpleMath7(), SimpleMath5(), SimpleMath8(), SimpleMath9(), SimpleMath8());
  1348.         break;
  1349.     }
  1350.     case 2:
  1351.     {
  1352.         sprintf(ret, "(((%s*%s+%s*%s+%s)-(%s+%s-%s))/(((%s+(%s-%s))+(%s-%s)-%s)))", SimpleMath4(), SimpleMath7(), SimpleMath3(), SimpleMath2(), SimpleMath1(), SimpleMath7(), SimpleMath2(), SimpleMath6(), SimpleMath7(), SimpleMath5(), SimpleMath3(), SimpleMath9(), SimpleMath8(), SimpleMath6());
  1353.         break;
  1354.     }
  1355.     case 3:
  1356.     {
  1357.         sprintf(ret, "(((%s*(%s+%s))/((%s+(%s+(%s-%s)))-(%s+%s))/(%s-((%s-%s)-%s))))", SimpleMath8(), SimpleMath2(), SimpleMath6(), SimpleMath7(), SimpleMath3(), SimpleMath8(), SimpleMath9(), SimpleMath4(), SimpleMath3(), SimpleMath8(), SimpleMath7(), SimpleMath1(), SimpleMath2());
  1358.         break;
  1359.     }
  1360.     case 4:
  1361.     {
  1362.         sprintf(ret, "(((((%s*%s)+(%s-%s)*(%s+%s))/%s)*(%s-%s))/(%s*%s+%s))", SimpleMath8(), SimpleMath4(), SimpleMath6(), SimpleMath4(), SimpleMath6(), SimpleMath2(), SimpleMath2(), SimpleMath6(), SimpleMath4(), SimpleMath2(), SimpleMath2(), SimpleMath2());
  1363.         break;
  1364.     }
  1365.     }
  1366.  
  1367.     return ret;
  1368. }
  1369.  
  1370. char* HardMath9()
  1371. {
  1372.     static char ret[1024];
  1373.  
  1374.     int type = rnum(1, 4);
  1375.     switch (type)
  1376.     {
  1377.     case 1:
  1378.     {
  1379.         sprintf(ret, "(((%s*%s+%s+(%s-%s))/((%s+%s-%s)/(%s-%s))/(((%s*%s)/%s)/(%s-%s))))", SimpleMath5(), SimpleMath2(), SimpleMath7(), SimpleMath8(), SimpleMath7(), SimpleMath3(), SimpleMath4(), SimpleMath5(), SimpleMath9(), SimpleMath7(), SimpleMath8(), SimpleMath2(), SimpleMath4(), SimpleMath7(), SimpleMath5());
  1380.         break;
  1381.     }
  1382.     case 2:
  1383.     {
  1384.         sprintf(ret, "(((((%s-%s)*%s+(%s+%s)+%s)/((%s*%s)/%s))*(%s+%s)+%s)/(%s*%s))", SimpleMath9(), SimpleMath2(), SimpleMath3(), SimpleMath4(), SimpleMath4(), SimpleMath1(), SimpleMath6(), SimpleMath2(), SimpleMath4(), SimpleMath5(), SimpleMath3(), SimpleMath1(), SimpleMath3(), SimpleMath3());
  1385.         break;
  1386.     }
  1387.     case 3:
  1388.     {
  1389.         sprintf(ret, "(((((((%s+%s)+(((%s-%s)+%s)/%s)*%s)+(%s*%s))*%s)/(%s-%s))+(%s*%s))/(%s+%s))", SimpleMath6(), SimpleMath2(), SimpleMath6(), SimpleMath3(), SimpleMath1(), SimpleMath2(), SimpleMath5(), SimpleMath6(), SimpleMath2(), SimpleMath6(), SimpleMath6(), SimpleMath3(), SimpleMath5(), SimpleMath6(), SimpleMath4(), SimpleMath6());
  1390.         break;
  1391.     }
  1392.     case 4:
  1393.     {
  1394.         sprintf(ret, "((((%s*%s+(%s+%s))+(%s-%s))*(%s*%s))/((%s/%s))/((%s+%s*%s)))", SimpleMath6(), SimpleMath3(), SimpleMath6(), SimpleMath1(), SimpleMath9(), SimpleMath7(), SimpleMath3(), SimpleMath3(), SimpleMath6(), SimpleMath2(), SimpleMath3(), SimpleMath3(), SimpleMath2());
  1395.         break;
  1396.     }
  1397.     }
  1398.  
  1399.     return ret;
  1400. }
  1401.  
  1402. char* HardMath10()
  1403. {
  1404.     static char ret[1024];
  1405.  
  1406.     int type = rnum(1, 4);
  1407.     switch (type)
  1408.     {
  1409.     case 1:
  1410.     {
  1411.         sprintf(ret, "((((((%s+%s)*%s)/%s)+(((%s*%s)/(%s-%s))+(%s-%s)))/%s)+(%s-%s))", SimpleMath5(), SimpleMath1(), SimpleMath3(), SimpleMath2(), SimpleMath4(), SimpleMath4(), SimpleMath7(), SimpleMath5(), SimpleMath5(), SimpleMath4(), SimpleMath2(), SimpleMath6(), SimpleMath5());
  1412.         break;
  1413.     }
  1414.     case 2:
  1415.     {
  1416.         sprintf(ret, "((((%s+%s)*%s)-(%s/%s))/((((%s+%s)*%s)*(%s-%s))/%s))", SimpleMath6(), SimpleMath5(), SimpleMath3(), SimpleMath6(), SimpleMath2(), SimpleMath1(), SimpleMath1(), SimpleMath2(), SimpleMath5(), SimpleMath2(), SimpleMath4());
  1417.         break;
  1418.     }
  1419.     case 3:
  1420.     {
  1421.         sprintf(ret, "((((%s*%s)+(%s+%s))/(%s+%s))+(%s/%s))", SimpleMath5(), SimpleMath4(), SimpleMath4(), SimpleMath6(), SimpleMath3(), SimpleMath2(), SimpleMath8(), SimpleMath2());
  1422.         break;
  1423.     }
  1424.     case 4:
  1425.     {
  1426.         sprintf(ret, "(((((%s+%s)*%s)/%s)/%s)+((%s/%s)+(%s-%s)))", SimpleMath8(), SimpleMath4(), SimpleMath5(), SimpleMath5(), SimpleMath2(), SimpleMath6(), SimpleMath2(), SimpleMath3(), SimpleMath2());
  1427.         break;
  1428.     }
  1429.     }
  1430.  
  1431.     return ret;
  1432. }
  1433.  
  1434. //--------------Реализация сложных мат. операций чисел от -1 до 10. Составляются из более простых операций--------------
  1435.  
  1436. //возвращает num, предаставленное в виде мат. операций
  1437. char* GetNumMath(int num)
  1438. {
  1439.     static char ret[1024*4];
  1440.  
  1441.     if (num <= 10)
  1442.     {
  1443.         switch (num)
  1444.         {
  1445.             case -1:
  1446.             {
  1447.                 sprintf(ret, "(%s)", HardMathMinus1());
  1448.                 break;
  1449.             }
  1450.             case 0:
  1451.             {
  1452.                 sprintf(ret, "(%s)", HardMath0());
  1453.                 break;
  1454.             }
  1455.             case 1:
  1456.             {
  1457.                 sprintf(ret, "(%s)", HardMath1());
  1458.                 break;
  1459.             }
  1460.             case 2:
  1461.             {
  1462.                 sprintf(ret, "(%s)", HardMath2());
  1463.                 break;
  1464.             }
  1465.             case 3:
  1466.             {
  1467.                 sprintf(ret, "(%s)", HardMath3());
  1468.                 break;
  1469.             }
  1470.             case 4:
  1471.             {
  1472.                 sprintf(ret, "(%s)", HardMath4());
  1473.                 break;
  1474.             }
  1475.             case 5:
  1476.             {
  1477.                 sprintf(ret, "(%s)", HardMath5());
  1478.                 break;
  1479.             }
  1480.             case 6:
  1481.             {
  1482.                 sprintf(ret, "(%s)", HardMath6());
  1483.                 break;
  1484.             }
  1485.             case 7:
  1486.             {
  1487.                 sprintf(ret, "(%s)", HardMath7());
  1488.                 break;
  1489.             }
  1490.             case 8:
  1491.             {
  1492.                 sprintf(ret, "(%s)", HardMath8());
  1493.                 break;
  1494.             }
  1495.             case 9:
  1496.             {
  1497.                 sprintf(ret, "(%s)", HardMath9());
  1498.                 break;
  1499.             }
  1500.             case 10:
  1501.             {
  1502.                 sprintf(ret, "(%s)", HardMath10());
  1503.                 break;
  1504.             }
  1505.         }
  1506.  
  1507.         return ret;
  1508.     }
  1509.     else
  1510.     {
  1511.         int random = rnum(1, 5);
  1512.  
  1513.         switch (random)
  1514.         {
  1515.             case 1:
  1516.             {
  1517.                 int numMath = ((num * 9)*(6*5));
  1518.  
  1519.                 sprintf(ret, "((%d/%s)/(%s*%s))", numMath, HardMath9(), HardMath6(), HardMath5());
  1520.  
  1521.                 break;
  1522.             }
  1523.             case 2:
  1524.             {
  1525.                 int numMath = num << 7;
  1526.  
  1527.                 sprintf(ret, "(%s+(%d>>%s))", HardMath0(), numMath, HardMath7());
  1528.  
  1529.                 break;
  1530.             }
  1531.             case 3:
  1532.             {
  1533.                 int numMath = num + 81;
  1534.  
  1535.                 sprintf(ret, "((%s+%d)-(%s*%s))", HardMath0(), numMath, HardMath9(), HardMath9());
  1536.  
  1537.                 break;
  1538.             }
  1539.             case 4:
  1540.             {
  1541.                 int numMath = num * 5;
  1542.  
  1543.                 sprintf(ret, "(((%s)+%d-(%s))/((%s)-(%s)))", HardMath1(), numMath, HardMath1(), HardMath9(), HardMath4());
  1544.  
  1545.                 break;
  1546.             }
  1547.             case 5:
  1548.             {
  1549.                 int numMath = num*3;
  1550.  
  1551.                 sprintf(ret, "(((%s)+%d+%s)/%s)", HardMathMinus1(), numMath, HardMath1(), HardMath3());
  1552.  
  1553.                 break;
  1554.             }
  1555.             //не забудь дополнить кейсов
  1556.         }
  1557.     }
  1558.  
  1559.     return ret;
  1560. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!