Advertisement
Guest User

Untitled

a guest
Nov 21st, 2019
87
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 6.70 KB | None | 0 0
  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. vector<string>v;
  4. map<string,char>m;
  5. int countone(string s)
  6. {
  7.     int cnt=0;
  8.     for(int i=0; i<s.size(); i++)
  9.     {
  10.         if(s[i]=='1')
  11.         {
  12.             cnt++;
  13.         }
  14.     }
  15.     return cnt;
  16. }
  17. string reset(string s,int cnt)
  18. {
  19.     s.clear();
  20.     for(int i=0; i<cnt; i++)
  21.     {
  22.         s.push_back('0');
  23.     }
  24.     return s;
  25.  
  26. }
  27. string leftshift(string s)
  28. {
  29.     int flag=0;
  30.     for(int i=s.size()-1; i>0; i--)
  31.     {
  32.         if(s[i]=='1' && s[i-1]=='0')
  33.         {
  34.             s[i-1]='1';
  35.             for(int j=i; j<s.size(); j++)
  36.             {
  37.                 s[j]='0';
  38.             }
  39.             break;
  40.         }
  41.     }
  42.     return s;
  43.  
  44. }
  45. //00000010
  46. int main()
  47. {
  48.     int cnt=1;
  49.     string s="0",input,result;
  50.     while(cnt<=7)
  51.     {
  52.         //cout<<s<<endl;
  53.         v.push_back(s);
  54.         while(1)
  55.         {
  56.             s[s.size()-1]='1';
  57.             if(countone(s)==s.size())
  58.             {
  59.                 break;
  60.             }
  61.             v.push_back(s);
  62.             s=leftshift(s);
  63.             v.push_back(s);
  64.         }
  65.         cnt++;
  66.         s=reset(s,cnt);
  67.         //cout<<s<<endl;
  68.     }
  69.  
  70.     while(getline(cin,input))
  71.     {
  72.         //cout<<input<<endl;
  73.         m.clear();
  74.         result.clear();
  75.         for(int i=0; i<input.size(); i++)
  76.         {
  77.             m[v[i]]=input[i];
  78.             //cout<<m[i]<<endl;
  79.         }
  80.         input.clear();
  81.         string input2;
  82.         char c,c1,c2;
  83.         while(1)
  84.         {
  85.             cin>>c;
  86.             while(c=='\n')
  87.             {
  88.                 cin>>c;
  89.             }
  90.             cin>>c1;
  91.             while(c1=='\n')
  92.             {
  93.                 cin>>c1;
  94.             }
  95.             cin>>c2;
  96.             while(c2=='\n')
  97.             {
  98.                 cin>>c2;
  99.             }
  100.             //cout<<c<<" "<<c1<<" "<<c2<<endl;
  101.             if(c=='0' && c1=='0' && c2=='0')
  102.             {
  103.                 break;
  104.             }
  105.             else if(c=='0' && c1=='0' && c2=='1')
  106.             {
  107.                 while(countone(input2)!=1)
  108.                 {
  109.                     input2.clear();
  110.                     while(input2.size()!=1)
  111.                     {
  112.                         cin>>c;
  113.                         while(c=='\n')
  114.                         {
  115.                             cin>>c;
  116.                         }
  117.                         input2.push_back(c);
  118.                     }
  119.                     if(countone(input2)==1)
  120.                     {
  121.                         break;
  122.                     }
  123.                     result.push_back(m[input2]);
  124.                 }
  125.  
  126.  
  127.             }
  128.             else if(c=='0' && c1=='1' && c2=='0')
  129.             {
  130.  
  131.                 while(countone(input2)!=2)
  132.                 {
  133.                     input2.clear();
  134.                     while(input2.size()!=2)
  135.                     {
  136.                         cin>>c;
  137.                         while(c=='\n')
  138.                         {
  139.                             cin>>c;
  140.                         }
  141.                         input2.push_back(c);
  142.                     }
  143.                     if(countone(input2)==2)
  144.                     {
  145.                         break;
  146.                     }
  147.                     result.push_back(m[input2]);
  148.                 }
  149.  
  150.  
  151.             }
  152.             else if(c=='0' && c1=='1' && c2=='1')
  153.             {
  154.                 while(countone(input2)!=3)
  155.                 {
  156.                     input2.clear();
  157.                     while(input2.size()!=3)
  158.                     {
  159.                         cin>>c;
  160.                         while(c=='\n')
  161.                         {
  162.                             cin>>c;
  163.                         }
  164.                         input2.push_back(c);
  165.                     }
  166.                     if(countone(input2)==3)
  167.                     {
  168.                         break;
  169.                     }
  170.                     result.push_back(m[input2]);
  171.  
  172.  
  173.                 }
  174.  
  175.  
  176.             }
  177.              else if(c=='1' && c1=='0' && c2=='0')
  178.             {
  179.                 while(countone(input2)!=4)
  180.                 {
  181.                     input2.clear();
  182.                     while(input2.size()!=4)
  183.                     {
  184.                         cin>>c;
  185.                         while(c=='\n')
  186.                         {
  187.                             cin>>c;
  188.                         }
  189.                         input2.push_back(c);
  190.                     }
  191.                     if(countone(input2)==4)
  192.                     {
  193.                         break;
  194.                     }
  195.                     result.push_back(m[input2]);
  196.  
  197.  
  198.                 }
  199.  
  200.  
  201.             }
  202.              else if(c=='1' && c1=='0' && c2=='1')
  203.             {
  204.                 while(countone(input2)!=5)
  205.                 {
  206.                     input2.clear();
  207.                     while(input2.size()!=5)
  208.                     {
  209.                         cin>>c;
  210.                         while(c=='\n')
  211.                         {
  212.                             cin>>c;
  213.                         }
  214.                         input2.push_back(c);
  215.                     }
  216.                     if(countone(input2)==5)
  217.                     {
  218.                         break;
  219.                     }
  220.                     result.push_back(m[input2]);
  221.  
  222.  
  223.                 }
  224.  
  225.  
  226.             }
  227.              else if(c=='1' && c1=='1' && c2=='0')
  228.             {
  229.                 while(countone(input2)!=6)
  230.                 {
  231.                     input2.clear();
  232.                     while(input2.size()!=6)
  233.                     {
  234.                         cin>>c;
  235.                         while(c=='\n')
  236.                         {
  237.                             cin>>c;
  238.                         }
  239.                         input2.push_back(c);
  240.                     }
  241.                     if(countone(input2)==6)
  242.                     {
  243.                         break;
  244.                     }
  245.                     result.push_back(m[input2]);
  246.  
  247.  
  248.                 }
  249.  
  250.  
  251.             }
  252.              else if(c=='1' && c1=='1' && c2=='1')
  253.             {
  254.                 while(countone(input2)!=7)
  255.                 {
  256.                     input2.clear();
  257.                     while(input2.size()!=7)
  258.                     {
  259.                         cin>>c;
  260.                         while(c=='\n')
  261.                         {
  262.                             cin>>c;
  263.                         }
  264.                         input2.push_back(c);
  265.                     }
  266.                     if(countone(input2)==7)
  267.                     {
  268.                         break;
  269.                     }
  270.                     result.push_back(m[input2]);
  271.  
  272.  
  273.                 }
  274.  
  275.  
  276.             }
  277.         }
  278.         cout<<result<<endl;
  279.         cin.ignore();
  280.     }
  281. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement