fork download
copy 
  1. #include <string>
  2. #include <iostream>
  3. #include <vector>
  4. using namespace std;
  5.  
  6.  
  7. int main()
  8. {
  9.  
  10.     vector<string> v = {"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p"};
  11.     vector<string> m = {"ab","ae","af","ba","bc","be","bf","bg","cb","cd","cf","cg","ch","dc","dg","dh","ea","eb","ef","ei","ej","fa","fb","fc","fe","fg","fi","fj","fk","gb","gc","gd","gf","gh","gj","gk","gl","hc","hd","hg","hk","hl","ie","if","ij","im","in","je","jf","jg","ji","jk","jm","jn","jo","kf","kg,","kh","kj","kl","kn","ko","kp","lg","lh","lk","lo","lp","mi","mj","mn","ni","nj","nk","nm","no","oj","ok","ol","on","op","pk","pl","po"};
  12.  
  13.    string sv = "z";
  14.     vector <string> vier, drei,funf,sechs,sieben,acht,neun,zehn;
  15.     string sp ;
  16.     string sh;
  17.     string sd, sr, so;
  18.  
  19.     for (int i=0;i<16;i++){
  20.         sh = v[i];
  21.  
  22.  
  23.         for (int j=0;j<86;j++){
  24.  
  25.  
  26.         sv = m[j];
  27.         sd = m [j];
  28.  
  29.         sv.erase(1,1);
  30.         sd.erase (0,1);
  31.  
  32.         if (sh == sv && sh != sd)
  33.          {
  34.  
  35.           sp = sh + sd;    
  36.  
  37.           drei.push_back(sp);
  38.          }
  39.  
  40.  
  41. 	   }
  42. 	   }
  43. 	   int three = drei.size();
  44. 	   cout << three << endl;
  45.  
  46. 	       for (size_t i=0;i<three;i++){
  47.         sh = drei[i];
  48.         sr = drei [i];
  49.         so = drei [i];
  50.         sr.erase (0,1);
  51.         so.erase (1,1);
  52.  
  53.         for (size_t j=0;j<86;j++){
  54.         sv = m[j];
  55.         sd = m [j];
  56.  
  57.         sv.erase(1,1);
  58.         sd.erase (0,1);
  59.  
  60.         if (sr == sv && so != sd)
  61.          {
  62.  
  63.  
  64.           sp = sh + sd;    
  65.  
  66.         vier.push_back(sp);
  67.          }
  68.  
  69.             }
  70.             }
  71.          for (int l=0;l <83;l++){
  72.                     cout <<drei [l] << endl;
  73.           }
  74.          for (int k=0;k<vier.size ();k++){
  75.  
  76.     cout << vier [k] << endl;
  77.   }
  78.     cout << vier.size ()<< endl;
  79.     string s3;
  80.   //  int vier = vier.size ();
  81.     //vier
  82. 	 for (size_t i=0;i<vier.size();i++){
  83.         sh = vier[i];
  84.         sr = vier [i];
  85.         so = vier[i];
  86.         s3 = vier[i];
  87.         sr.erase (1,2);
  88.         so.erase (0,2);
  89.         s3.erase (0,1);
  90.         s3.erase (1,1);
  91.  
  92.         for (size_t j=0;j<86;j++){
  93.         sv = m[j];
  94.         sd = m [j];
  95.  
  96.         sv.erase(1,1);
  97.         sd.erase (0,1);
  98.  
  99.         if (sr == sv && so != sd && s3 != sd)
  100.          {
  101.  
  102.  
  103.           sp = sh + sd;    
  104.  
  105.         funf.push_back(sp);
  106.          }
  107.  
  108.             }
  109.             }
  110.  
  111.          for (int k=0;k<funf.size();k++){
  112.  
  113.     cout << funf [k] << endl;
  114.   }
  115.     cout << funf.size()<< endl;
  116.     string s4;
  117.  
  118.    // funf
  119. 	 for (size_t i=0;i<funf.size();i++){
  120.         sh = funf[i];
  121.         sr = funf[i];
  122.         so = funf[i];
  123.         s3 = funf[i];
  124.         s4 = funf[i];
  125.         sr.erase (1,3);
  126.         so.erase (0,3);
  127.         s3.erase (0,1);
  128.         s3.erase (1,2);
  129.         s4.erase (0,2);
  130.         s4.erase (1,1);
  131.  
  132.         for (size_t j=0;j<86;j++){
  133.         sv = m[j];
  134.         sd = m [j];
  135.  
  136.         sv.erase(1,1);
  137.         sd.erase (0,1);
  138.  
  139.         if (sr == sv && so != sd && s3 != sd&&sd!=s4)
  140.          {
  141.  
  142.  
  143.           sp = sh + sd;    
  144.  
  145.         sechs.push_back(sp);
  146.          }
  147.  
  148.             }
  149.             }
  150.  
  151.          for (int k=0;k <sechs.size();k++){
  152.  
  153.     cout << sechs [k] << endl;
  154.   }
  155.     cout << sechs.size ()<< endl;
  156. 	string s5;
  157. 	//sechs
  158. 	 for (size_t i=0;i<sechs.size();i++){
  159.         sh = sechs[i];
  160.         sr = sechs[i];
  161.         so = sechs[i];
  162.         s3 = sechs[i];
  163.         s4 = sechs[i];
  164.         s5 = sechs [i];
  165.         sr.erase (1,4);
  166.         so.erase (0,4);
  167.         s3.erase (0,1);
  168.         s3.erase (1,3);
  169.         s4.erase (0,2);
  170.         s4.erase (1,2);
  171.         s5.erase (0,3);
  172.         s5.erase (1,1);
  173.  
  174.         for (size_t j=0;j<86;j++){
  175.         sv = m[j];
  176.         sd = m [j];
  177.  
  178.         sv.erase(1,1);
  179.         sd.erase (0,1);
  180.  
  181.         if (sr == sv && so != sd && s3 != sd&&sd!=s4&&sd!=s5)
  182.          {
  183.  
  184.  
  185.           sp = sh + sd;    
  186.  
  187.         sieben.push_back(sp);
  188.          }
  189.  
  190.             }
  191.             }
  192.  
  193.          for (int k=0;k <sieben.size();k++){
  194.  
  195.     cout << sieben [k] << endl;
  196.   }
  197.     cout << sieben.size ()<< endl;
  198.    string s6;
  199.        //sieben
  200. 	 for (size_t i=0;i<sieben.size();i++){
  201.         sh = sieben[i];
  202.         sr = sieben[i];
  203.         so = sieben[i];
  204.         s3 = sieben[i];
  205.         s4 = sieben[i];
  206.         s5 = sieben[i];
  207.         s6 = sieben[i];
  208.         sr.erase (1,5);
  209.         so.erase (0,5);
  210.         s3.erase (0,1);
  211.         s3.erase (1,4);
  212.         s4.erase (0,2);
  213.         s4.erase (1,3);
  214.         s5.erase (0,3);
  215.         s5.erase (1,2);
  216.         s6.erase (0,4);
  217.         s6.erase (1,1);
  218.  
  219.  
  220.         for (size_t j=0;j<86;j++){
  221.         sv = m[j];
  222.         sd = m [j];
  223.  
  224.         sv.erase(1,1);
  225.         sd.erase (0,1);
  226.  
  227.         if (sr == sv && so != sd && s3 != sd&&sd!=s4&&sd!=s5&&sd!=s6)
  228.          {
  229.  
  230.  
  231.           sp = sh + sd;    
  232.  
  233.         acht.push_back(sp);
  234.          }
  235.  
  236.             }
  237.             }
  238.  
  239.          for (int k=0;k <acht.size();k++){
  240.  
  241.     cout << acht [k] << endl;
  242.   }
  243.     cout << acht.size ()<< endl;
  244.  
  245. 	string s7;
  246. 	//acht
  247. 	 for (unsigned int i=0;i<acht.size();i++){
  248.         sh = acht[i];
  249.         sr = acht[i];
  250.         so = acht[i];
  251.         s3 = acht[i];
  252.         s4 = acht[i];
  253.         s5 = acht[i];
  254.         s6 = acht[i];
  255.         s7 = acht[i];
  256.         sr.erase (1,6);
  257.         so.erase (0,6);
  258.         s3.erase (0,1);
  259.         s3.erase (1,5);
  260.         s4.erase (0,2);
  261.         s4.erase (1,4);
  262.         s5.erase (0,3);
  263.         s5.erase (1,3);
  264.         s6.erase (0,4);
  265.         s6.erase (1,2);
  266.         s7.erase (0,5);
  267.         s7.erase (1,1);
  268.  
  269.  
  270.         for (size_t j=0;j<86;j++){
  271.         sv = m[j];
  272.         sd = m [j];
  273.  
  274.         sv.erase(1,1);
  275.         sd.erase (0,1);
  276.  
  277.         if (sr == sv && so != sd && s3 != sd&&sd!=s4&&sd!=s5&&sd!=s6&&sd!=s7)
  278.          {
  279.  
  280.  
  281.           sp = sh + sd;    
  282.  
  283.         neun.push_back(sp);
  284.          }
  285.  
  286.             }
  287.             }
  288.  
  289.          for (unsigned int k=0;k <neun.size();k++){
  290.  
  291.     cout << neun [k] << endl;
  292.   }
  293.     cout << neun.size ()<< endl;
  294.     cout << neun[177240]<< endl;
  295.  
  296.     //   string s8;
  297. 	//neun
  298. 	// for (size_t i=0;i<neun.size();i++){
  299.     //    sh = neun[i];
  300.      //   sr = neun[i];
  301.      //   so = neun[i];
  302.      //   s3 = neun[i];
  303.     //    s4 = neun[i];
  304.       //  s5 = neun[i];
  305.      //   s6 = neun[i];
  306.     //    s7 = neun[i];
  307.      //   s8 = neun[i];
  308.      //   sr.erase (1,7);
  309.       //  so.erase (0,7);
  310.    //     s3.erase (0,1);
  311.      //   s3.erase (1,6);
  312.     //    s4.erase (0,2);
  313.      //   s4.erase (1,5);
  314.       //  s5.erase (0,3);
  315.      //   s5.erase (1,4);
  316.      //   s6.erase (0,4);
  317.     //    s6.erase (1,3);
  318.    //     s7.erase (0,5);
  319.     //    s7.erase (1,2);
  320.      //   s8.erase (0,6);
  321.     //    s8.erase (1,1);
  322.  
  323.  
  324.     //    for (size_t j=0;j<86;j++){
  325.      //   sv = m[j];
  326.      //   sd = m [j];
  327.  
  328.      //   sv.erase(1,1);
  329.     //    sd.erase (0,1);
  330.  
  331.     //    if (sr == sv && so != sd && s3 != sd&&sd!=s4&&sd!=s5&&sd!=s6&&sd!=s7&&sd!=s8)
  332.       //   {
  333.  
  334.  
  335.     //      sp = sh + sd;    
  336.  
  337.     //    zehn.push_back(sp);
  338.         // }
  339.  
  340.           //  }
  341.        //     }
  342.  
  343.       //   for (int k=0;k <zehn.size();k++){
  344.  
  345.   //  cout << zehn [k] << endl;
  346.   //}
  347.    // cout << zehn.size ()<< endl;
  348.  
  349.  
  350.  
  351. 	}
Runtime error #stdin #stdout 0s 15256KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/dMWC6f
language:
C++14 (gcc 8.3)
created:
8 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!