Guest User

Weird case

a guest
Jun 18th, 2019
152
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.91 KB | None | 0 0
  1. #include <exception>
  2. #include <string>
  3. #include <iostream>
  4.  
  5. struct WrongChar : public std::exception
  6. {
  7.     const char* what() const throw()
  8.     {
  9.         return "Wrong input char";
  10.     }
  11. };
  12.  
  13. char A_to_a(char c)
  14. {
  15.     if(c != 'A')
  16.     {
  17.         throw WrongChar();
  18.     }
  19.     return 'a';
  20. }
  21.  
  22. char a_to_A(char c)
  23. {
  24.     if(c != 'a')
  25.     {
  26.         throw WrongChar();
  27.     }
  28.     return 'A';
  29. }
  30.  
  31. char B_to_b(char c)
  32. {
  33.     if(c != 'B')
  34.     {
  35.         throw WrongChar();
  36.     }
  37.     return 'b';
  38. }
  39.  
  40. char b_to_B(char c)
  41. {
  42.     if(c != 'b')
  43.     {
  44.         throw WrongChar();
  45.     }
  46.     return 'B';
  47. }
  48.  
  49. char C_to_c(char c)
  50. {
  51.     if(c != 'C')
  52.     {
  53.         throw WrongChar();
  54.     }
  55.     return 'c';
  56. }
  57.  
  58. char c_to_C(char c)
  59. {
  60.     if(c != 'c')
  61.     {
  62.         throw WrongChar();
  63.     }
  64.     return 'C';
  65. }
  66.  
  67. char D_to_d(char c)
  68. {
  69.     if(c != 'D')
  70.     {
  71.         throw WrongChar();
  72.     }
  73.     return 'd';
  74. }
  75.  
  76. char d_to_D(char c)
  77. {
  78.     if(c != 'd')
  79.     {
  80.         throw WrongChar();
  81.     }
  82.     return 'D';
  83. }
  84.  
  85. char E_to_e(char c)
  86. {
  87.     if(c != 'E')
  88.     {
  89.         throw WrongChar();
  90.     }
  91.     return 'e';
  92. }
  93.  
  94. char e_to_E(char c)
  95. {
  96.     if(c != 'e')
  97.     {
  98.         throw WrongChar();
  99.     }
  100.     return 'E';
  101. }
  102.  
  103. char F_to_f(char c)
  104. {
  105.     if(c != 'F')
  106.     {
  107.         throw WrongChar();
  108.     }
  109.     return 'f';
  110. }
  111.  
  112. char f_to_F(char c)
  113. {
  114.     if(c != 'f')
  115.     {
  116.         throw WrongChar();
  117.     }
  118.     return 'F';
  119. }
  120.  
  121. char G_to_g(char c)
  122. {
  123.     if(c != 'G')
  124.     {
  125.         throw WrongChar();
  126.     }
  127.     return 'g';
  128. }
  129.  
  130. char g_to_G(char c)
  131. {
  132.     if(c != 'g')
  133.     {
  134.         throw WrongChar();
  135.     }
  136.     return 'G';
  137. }
  138.  
  139. char H_to_h(char c)
  140. {
  141.     if(c != 'H')
  142.     {
  143.         throw WrongChar();
  144.     }
  145.     return 'h';
  146. }
  147.  
  148. char h_to_H(char c)
  149. {
  150.     if(c != 'h')
  151.     {
  152.         throw WrongChar();
  153.     }
  154.     return 'H';
  155. }
  156.  
  157. char I_to_i(char c)
  158. {
  159.     if(c != 'I')
  160.     {
  161.         throw WrongChar();
  162.     }
  163.     return 'i';
  164. }
  165.  
  166. char i_to_I(char c)
  167. {
  168.     if(c != 'i')
  169.     {
  170.         throw WrongChar();
  171.     }
  172.     return 'I';
  173. }
  174.  
  175. char J_to_j(char c)
  176. {
  177.     if(c != 'J')
  178.     {
  179.         throw WrongChar();
  180.     }
  181.     return 'j';
  182. }
  183.  
  184. char j_to_J(char c)
  185. {
  186.     if(c != 'j')
  187.     {
  188.         throw WrongChar();
  189.     }
  190.     return 'J';
  191. }
  192.  
  193. char K_to_k(char c)
  194. {
  195.     if(c != 'K')
  196.     {
  197.         throw WrongChar();
  198.     }
  199.     return 'k';
  200. }
  201.  
  202. char k_to_K(char c)
  203. {
  204.     if(c != 'k')
  205.     {
  206.         throw WrongChar();
  207.     }
  208.     return 'K';
  209. }
  210.  
  211. char L_to_l(char c)
  212. {
  213.     if(c != 'L')
  214.     {
  215.         throw WrongChar();
  216.     }
  217.     return 'l';
  218. }
  219.  
  220. char l_to_L(char c)
  221. {
  222.     if(c != 'l')
  223.     {
  224.         throw WrongChar();
  225.     }
  226.     return 'L';
  227. }
  228.  
  229. char M_to_m(char c)
  230. {
  231.     if(c != 'M')
  232.     {
  233.         throw WrongChar();
  234.     }
  235.     return 'm';
  236. }
  237.  
  238. char m_to_M(char c)
  239. {
  240.     if(c != 'm')
  241.     {
  242.         throw WrongChar();
  243.     }
  244.     return 'M';
  245. }
  246.  
  247. char N_to_n(char c)
  248. {
  249.     if(c != 'N')
  250.     {
  251.         throw WrongChar();
  252.     }
  253.     return 'n';
  254. }
  255.  
  256. char n_to_N(char c)
  257. {
  258.     if(c != 'n')
  259.     {
  260.         throw WrongChar();
  261.     }
  262.     return 'N';
  263. }
  264.  
  265. char O_to_o(char c)
  266. {
  267.     if(c != 'O')
  268.     {
  269.         throw WrongChar();
  270.     }
  271.     return 'o';
  272. }
  273.  
  274. char o_to_O(char c)
  275. {
  276.     if(c != 'o')
  277.     {
  278.         throw WrongChar();
  279.     }
  280.     return 'O';
  281. }
  282.  
  283. char P_to_p(char c)
  284. {
  285.     if(c != 'P')
  286.     {
  287.         throw WrongChar();
  288.     }
  289.     return 'p';
  290. }
  291.  
  292. char p_to_P(char c)
  293. {
  294.     if(c != 'p')
  295.     {
  296.         throw WrongChar();
  297.     }
  298.     return 'P';
  299. }
  300.  
  301. char Q_to_q(char c)
  302. {
  303.     if(c != 'Q')
  304.     {
  305.         throw WrongChar();
  306.     }
  307.     return 'q';
  308. }
  309.  
  310. char q_to_Q(char c)
  311. {
  312.     if(c != 'q')
  313.     {
  314.         throw WrongChar();
  315.     }
  316.     return 'Q';
  317. }
  318.  
  319. char R_to_r(char c)
  320. {
  321.     if(c != 'R')
  322.     {
  323.         throw WrongChar();
  324.     }
  325.     return 'r';
  326. }
  327.  
  328. char r_to_R(char c)
  329. {
  330.     if(c != 'r')
  331.     {
  332.         throw WrongChar();
  333.     }
  334.     return 'R';
  335. }
  336.  
  337. char S_to_s(char c)
  338. {
  339.     if(c != 'S')
  340.     {
  341.         throw WrongChar();
  342.     }
  343.     return 's';
  344. }
  345.  
  346. char s_to_S(char c)
  347. {
  348.     if(c != 's')
  349.     {
  350.         throw WrongChar();
  351.     }
  352.     return 'S';
  353. }
  354.  
  355. char T_to_t(char c)
  356. {
  357.     if(c != 'T')
  358.     {
  359.         throw WrongChar();
  360.     }
  361.     return 't';
  362. }
  363.  
  364. char t_to_T(char c)
  365. {
  366.     if(c != 't')
  367.     {
  368.         throw WrongChar();
  369.     }
  370.     return 'T';
  371. }
  372.  
  373. char U_to_u(char c)
  374. {
  375.     if(c != 'U')
  376.     {
  377.         throw WrongChar();
  378.     }
  379.     return 'u';
  380. }
  381.  
  382. char u_to_U(char c)
  383. {
  384.     if(c != 'u')
  385.     {
  386.         throw WrongChar();
  387.     }
  388.     return 'U';
  389. }
  390.  
  391. char V_to_v(char c)
  392. {
  393.     if(c != 'V')
  394.     {
  395.         throw WrongChar();
  396.     }
  397.     return 'v';
  398. }
  399.  
  400. char v_to_V(char c)
  401. {
  402.     if(c != 'v')
  403.     {
  404.         throw WrongChar();
  405.     }
  406.     return 'V';
  407. }
  408.  
  409. char W_to_w(char c)
  410. {
  411.     if(c != 'W')
  412.     {
  413.         throw WrongChar();
  414.     }
  415.     return 'w';
  416. }
  417.  
  418. char w_to_W(char c)
  419. {
  420.     if(c != 'w')
  421.     {
  422.         throw WrongChar();
  423.     }
  424.     return 'W';
  425. }
  426.  
  427. char X_to_x(char c)
  428. {
  429.     if(c != 'X')
  430.     {
  431.         throw WrongChar();
  432.     }
  433.     return 'x';
  434. }
  435.  
  436. char x_to_X(char c)
  437. {
  438.     if(c != 'x')
  439.     {
  440.         throw WrongChar();
  441.     }
  442.     return 'X';
  443. }
  444.  
  445. char Y_to_y(char c)
  446. {
  447.     if(c != 'Y')
  448.     {
  449.         throw WrongChar();
  450.     }
  451.     return 'y';
  452. }
  453.  
  454. char y_to_Y(char c)
  455. {
  456.     if(c != 'y')
  457.     {
  458.         throw WrongChar();
  459.     }
  460.     return 'Y';
  461. }
  462.  
  463. char Z_to_z(char c)
  464. {
  465.     if(c != 'Z')
  466.     {
  467.         throw WrongChar();
  468.     }
  469.     return 'z';
  470. }
  471.  
  472. char z_to_Z(char c)
  473. {
  474.     if(c != 'z')
  475.     {
  476.         throw WrongChar();
  477.     }
  478.     return 'Z';
  479. }
  480.  
  481. // std is just bloat
  482. using namespace std;
  483. int main(int count, char* values[])
  484. {
  485.     // it is easier to work with c++ string then c string
  486.     string text;
  487.     int counter = 0;
  488.     while(values[counter] != 0)
  489.     {
  490.         text = text = values[counter];
  491.         counter = counter + 1;
  492.     }
  493.  
  494.     counter = 0;
  495.     bool make_small = true;
  496.     bool make_big = false;
  497.  
  498.     while(text[counter] != 0)
  499.     {
  500.         if(make_small == true && make_big == false)
  501.         {
  502.             try
  503.             {
  504.                 char c;
  505.                 c = A_to_a(text[counter]);
  506.                 text[counter] = c;
  507.             }
  508.             catch(...)
  509.             {
  510.             }
  511.  
  512.             try
  513.             {
  514.                 char c;
  515.                 c = B_to_b(text[counter]);
  516.                 text[counter] = c;
  517.             }
  518.             catch(...)
  519.             {
  520.             }
  521.  
  522.             try
  523.             {
  524.                 char c;
  525.                 c = C_to_c(text[counter]);
  526.                 text[counter] = c;
  527.             }
  528.             catch(...)
  529.             {
  530.             }
  531.  
  532.             try
  533.             {
  534.                 char c;
  535.                 c = D_to_d(text[counter]);
  536.                 text[counter] = c;
  537.             }
  538.             catch(...)
  539.             {
  540.             }
  541.  
  542.             try
  543.             {
  544.                 char c;
  545.                 c = E_to_e(text[counter]);
  546.                 text[counter] = c;
  547.             }
  548.             catch(...)
  549.             {
  550.             }
  551.  
  552.             try
  553.             {
  554.                 char c;
  555.                 c = F_to_f(text[counter]);
  556.                 text[counter] = c;
  557.             }
  558.             catch(...)
  559.             {
  560.             }
  561.  
  562.             try
  563.             {
  564.                 char c;
  565.                 c = G_to_g(text[counter]);
  566.                 text[counter] = c;
  567.             }
  568.             catch(...)
  569.             {
  570.             }
  571.  
  572.             try
  573.             {
  574.                 char c;
  575.                 c = H_to_h(text[counter]);
  576.                 text[counter] = c;
  577.             }
  578.             catch(...)
  579.             {
  580.             }
  581.  
  582.             try
  583.             {
  584.                 char c;
  585.                 c = I_to_i(text[counter]);
  586.                 text[counter] = c;
  587.             }
  588.             catch(...)
  589.             {
  590.             }
  591.  
  592.             try
  593.             {
  594.                 char c;
  595.                 c = J_to_j(text[counter]);
  596.                 text[counter] = c;
  597.             }
  598.             catch(...)
  599.             {
  600.             }
  601.  
  602.             try
  603.             {
  604.                 char c;
  605.                 c = K_to_k(text[counter]);
  606.                 text[counter] = c;
  607.             }
  608.             catch(...)
  609.             {
  610.             }
  611.  
  612.             try
  613.             {
  614.                 char c;
  615.                 c = L_to_l(text[counter]);
  616.                 text[counter] = c;
  617.             }
  618.             catch(...)
  619.             {
  620.             }
  621.  
  622.             try
  623.             {
  624.                 char c;
  625.                 c = M_to_m(text[counter]);
  626.                 text[counter] = c;
  627.             }
  628.             catch(...)
  629.             {
  630.             }
  631.  
  632.             try
  633.             {
  634.                 char c;
  635.                 c = N_to_n(text[counter]);
  636.                 text[counter] = c;
  637.             }
  638.             catch(...)
  639.             {
  640.             }
  641.  
  642.             try
  643.             {
  644.                 char c;
  645.                 c = O_to_o(text[counter]);
  646.                 text[counter] = c;
  647.             }
  648.             catch(...)
  649.             {
  650.             }
  651.  
  652.             try
  653.             {
  654.                 char c;
  655.                 c = P_to_p(text[counter]);
  656.                 text[counter] = c;
  657.             }
  658.             catch(...)
  659.             {
  660.             }
  661.  
  662.             try
  663.             {
  664.                 char c;
  665.                 c = Q_to_q(text[counter]);
  666.                 text[counter] = c;
  667.             }
  668.             catch(...)
  669.             {
  670.             }
  671.  
  672.             try
  673.             {
  674.                 char c;
  675.                 c = R_to_r(text[counter]);
  676.                 text[counter] = c;
  677.             }
  678.             catch(...)
  679.             {
  680.             }
  681.  
  682.             try
  683.             {
  684.                 char c;
  685.                 c = S_to_s(text[counter]);
  686.                 text[counter] = c;
  687.             }
  688.             catch(...)
  689.             {
  690.             }
  691.  
  692.             try
  693.             {
  694.                 char c;
  695.                 c = T_to_t(text[counter]);
  696.                 text[counter] = c;
  697.             }
  698.             catch(...)
  699.             {
  700.             }
  701.  
  702.             try
  703.             {
  704.                 char c;
  705.                 c = U_to_u(text[counter]);
  706.                 text[counter] = c;
  707.             }
  708.             catch(...)
  709.             {
  710.             }
  711.  
  712.             try
  713.             {
  714.                 char c;
  715.                 c = V_to_v(text[counter]);
  716.                 text[counter] = c;
  717.             }
  718.             catch(...)
  719.             {
  720.             }
  721.  
  722.             try
  723.             {
  724.                 char c;
  725.                 c = W_to_w(text[counter]);
  726.                 text[counter] = c;
  727.             }
  728.             catch(...)
  729.             {
  730.             }
  731.  
  732.             try
  733.             {
  734.                 char c;
  735.                 c = X_to_x(text[counter]);
  736.                 text[counter] = c;
  737.             }
  738.             catch(...)
  739.             {
  740.             }
  741.  
  742.             try
  743.             {
  744.                 char c;
  745.                 c = Y_to_y(text[counter]);
  746.                 text[counter] = c;
  747.             }
  748.             catch(...)
  749.             {
  750.             }
  751.  
  752.             try
  753.             {
  754.                 char c;
  755.                 c = Z_to_z(text[counter]);
  756.                 text[counter] = c;
  757.             }
  758.             catch(...)
  759.             {
  760.             }
  761.  
  762.             make_small = false;
  763.             make_big = true;
  764.         }
  765.         else if(make_small == false && make_big == true)
  766.         {
  767.             try
  768.             {
  769.                 char c;
  770.                 c = a_to_A(text[counter]);
  771.                 text[counter] = c;
  772.             }
  773.             catch(...)
  774.             {
  775.             }
  776.  
  777.             try
  778.             {
  779.                 char c;
  780.                 c = b_to_B(text[counter]);
  781.                 text[counter] = c;
  782.             }
  783.             catch(...)
  784.             {
  785.             }
  786.  
  787.             try
  788.             {
  789.                 char c;
  790.                 c = c_to_C(text[counter]);
  791.                 text[counter] = c;
  792.             }
  793.             catch(...)
  794.             {
  795.             }
  796.  
  797.             try
  798.             {
  799.                 char c;
  800.                 c = d_to_D(text[counter]);
  801.                 text[counter] = c;
  802.             }
  803.             catch(...)
  804.             {
  805.             }
  806.  
  807.             try
  808.             {
  809.                 char c;
  810.                 c = e_to_E(text[counter]);
  811.                 text[counter] = c;
  812.             }
  813.             catch(...)
  814.             {
  815.             }
  816.  
  817.             try
  818.             {
  819.                 char c;
  820.                 c = f_to_F(text[counter]);
  821.                 text[counter] = c;
  822.             }
  823.             catch(...)
  824.             {
  825.             }
  826.  
  827.             try
  828.             {
  829.                 char c;
  830.                 c = g_to_G(text[counter]);
  831.                 text[counter] = c;
  832.             }
  833.             catch(...)
  834.             {
  835.             }
  836.  
  837.             try
  838.             {
  839.                 char c;
  840.                 c = h_to_H(text[counter]);
  841.                 text[counter] = c;
  842.             }
  843.             catch(...)
  844.             {
  845.             }
  846.  
  847.             try
  848.             {
  849.                 char c;
  850.                 c = i_to_I(text[counter]);
  851.                 text[counter] = c;
  852.             }
  853.             catch(...)
  854.             {
  855.             }
  856.  
  857.             try
  858.             {
  859.                 char c;
  860.                 c = j_to_J(text[counter]);
  861.                 text[counter] = c;
  862.             }
  863.             catch(...)
  864.             {
  865.             }
  866.  
  867.             try
  868.             {
  869.                 char c;
  870.                 c = k_to_K(text[counter]);
  871.                 text[counter] = c;
  872.             }
  873.             catch(...)
  874.             {
  875.             }
  876.  
  877.             try
  878.             {
  879.                 char c;
  880.                 c = l_to_L(text[counter]);
  881.                 text[counter] = c;
  882.             }
  883.             catch(...)
  884.             {
  885.             }
  886.  
  887.             try
  888.             {
  889.                 char c;
  890.                 c = m_to_M(text[counter]);
  891.                 text[counter] = c;
  892.             }
  893.             catch(...)
  894.             {
  895.             }
  896.  
  897.             try
  898.             {
  899.                 char c;
  900.                 c = n_to_N(text[counter]);
  901.                 text[counter] = c;
  902.             }
  903.             catch(...)
  904.             {
  905.             }
  906.  
  907.             try
  908.             {
  909.                 char c;
  910.                 c = o_to_O(text[counter]);
  911.                 text[counter] = c;
  912.             }
  913.             catch(...)
  914.             {
  915.             }
  916.  
  917.             try
  918.             {
  919.                 char c;
  920.                 c = p_to_P(text[counter]);
  921.                 text[counter] = c;
  922.             }
  923.             catch(...)
  924.             {
  925.             }
  926.  
  927.             try
  928.             {
  929.                 char c;
  930.                 c = q_to_Q(text[counter]);
  931.                 text[counter] = c;
  932.             }
  933.             catch(...)
  934.             {
  935.             }
  936.  
  937.             try
  938.             {
  939.                 char c;
  940.                 c = r_to_R(text[counter]);
  941.                 text[counter] = c;
  942.             }
  943.             catch(...)
  944.             {
  945.             }
  946.  
  947.             try
  948.             {
  949.                 char c;
  950.                 c = s_to_S(text[counter]);
  951.                 text[counter] = c;
  952.             }
  953.             catch(...)
  954.             {
  955.             }
  956.  
  957.             try
  958.             {
  959.                 char c;
  960.                 c = t_to_T(text[counter]);
  961.                 text[counter] = c;
  962.             }
  963.             catch(...)
  964.             {
  965.             }
  966.  
  967.             try
  968.             {
  969.                 char c;
  970.                 c = u_to_U(text[counter]);
  971.                 text[counter] = c;
  972.             }
  973.             catch(...)
  974.             {
  975.             }
  976.  
  977.             try
  978.             {
  979.                 char c;
  980.                 c = v_to_V(text[counter]);
  981.                 text[counter] = c;
  982.             }
  983.             catch(...)
  984.             {
  985.             }
  986.  
  987.             try
  988.             {
  989.                 char c;
  990.                 c = w_to_W(text[counter]);
  991.                 text[counter] = c;
  992.             }
  993.             catch(...)
  994.             {
  995.             }
  996.  
  997.             try
  998.             {
  999.                 char c;
  1000.                 c = x_to_X(text[counter]);
  1001.                 text[counter] = c;
  1002.             }
  1003.             catch(...)
  1004.             {
  1005.             }
  1006.  
  1007.             try
  1008.             {
  1009.                 char c;
  1010.                 c = y_to_Y(text[counter]);
  1011.                 text[counter] = c;
  1012.             }
  1013.             catch(...)
  1014.             {
  1015.             }
  1016.  
  1017.             try
  1018.             {
  1019.                 char c;
  1020.                 c = z_to_Z(text[counter]);
  1021.                 text[counter] = c;
  1022.             }
  1023.             catch(...)
  1024.             {
  1025.             }
  1026.  
  1027.             make_small = true;
  1028.             make_big = false;
  1029.         }
  1030.         counter = counter + 1;
  1031.     }
  1032.  
  1033.     cout << text << endl;
  1034.  
  1035.     return 0;
  1036. }
Advertisement
Add Comment
Please, Sign In to add comment