237 lines
6.7 KiB
C++
237 lines
6.7 KiB
C++
#include <iostream>
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <array>
|
|
#include <set>
|
|
#include <vector>
|
|
#include <cassert>
|
|
|
|
using namespace std;
|
|
|
|
struct compare_length {
|
|
inline bool operator()(const std::string& first,
|
|
const std::string& second) const
|
|
{
|
|
return first.size() < second.size();
|
|
}
|
|
};
|
|
|
|
struct Note
|
|
{
|
|
array<string,10> patterns;
|
|
array<string,4> outputs;
|
|
|
|
friend istream &operator>>( istream &input, Note &n ) {
|
|
for(int i = 0; i < 10; i++)
|
|
{
|
|
input >> n.patterns[i];
|
|
sort(n.patterns[i].begin(), n.patterns[i].end());
|
|
}
|
|
compare_length c;
|
|
sort(n.patterns.begin(), n.patterns.end(), c);
|
|
sort(n.patterns.begin()+3,n.patterns.begin()+6);
|
|
sort(n.patterns.begin()+6,n.patterns.begin()+9);
|
|
for(int i = 0; i < 4; i++)
|
|
{
|
|
input >> n.outputs[i];
|
|
sort(n.outputs[i].begin(), n.outputs[i].end());
|
|
}
|
|
return input;
|
|
}
|
|
};
|
|
|
|
int main()
|
|
{
|
|
Note note;
|
|
int result = 0;
|
|
for(int total_count = 0; total_count < 200; total_count++)
|
|
{
|
|
cin >> note;
|
|
int pattern_map[10] = {1,7,4,9,9,9,9,9,9,8};
|
|
vector<set<char>> pattern_sets(note.patterns.size());
|
|
for(int i = 0; i < note.patterns.size(); i++)
|
|
{
|
|
set<char> cur_set;
|
|
for(int j = 0; j < note.patterns[i].size(); j++)
|
|
{
|
|
cur_set.insert(note.patterns[i][j]);
|
|
}
|
|
pattern_sets[i] = cur_set;
|
|
}
|
|
|
|
set<char> top = pattern_sets[1];
|
|
for(set<char>::iterator it = pattern_sets[0].begin(); it != pattern_sets[0].end(); ++it) top.erase(*it);
|
|
|
|
set<char> middle = pattern_sets[2];
|
|
for(set<char>::iterator it = pattern_sets[0].begin(); it != pattern_sets[0].end(); ++it) middle.erase(*it);
|
|
set<char> left_top = middle;
|
|
for(set<char>::iterator it = middle.begin(); it != middle.end(); ++it)
|
|
{
|
|
while (middle.end() != it && (pattern_sets[3].end() == pattern_sets[3].find(*it) ||
|
|
pattern_sets[4].end() == pattern_sets[4].find(*it) ||
|
|
pattern_sets[5].end() == pattern_sets[5].find(*it)))
|
|
{
|
|
it = middle.erase(it);
|
|
}
|
|
}
|
|
left_top.erase(*middle.begin());
|
|
|
|
set<char> bottom = pattern_sets[9];
|
|
for(set<char>::iterator it = pattern_sets[1].begin(); it != pattern_sets[1].end(); ++it) bottom.erase(*it);
|
|
for(set<char>::iterator it = pattern_sets[2].begin(); it != pattern_sets[2].end(); ++it) bottom.erase(*it);
|
|
|
|
set<char> left_bottom = bottom;
|
|
|
|
for(set<char>::iterator it = bottom.begin(); it != bottom.end(); ++it)
|
|
{
|
|
while (bottom.end() != it && (pattern_sets[3].end() == pattern_sets[3].find(*it) ||
|
|
pattern_sets[4].end() == pattern_sets[4].find(*it) ||
|
|
pattern_sets[5].end() == pattern_sets[5].find(*it)))
|
|
{
|
|
it = bottom.erase(it);
|
|
}
|
|
}
|
|
|
|
left_bottom.erase(*bottom.begin());
|
|
|
|
set<char> x;
|
|
for(int i = 6; i <= 8; i++)
|
|
{
|
|
if (pattern_sets[i].find(*middle.begin()) != pattern_sets[i].end() &&
|
|
pattern_sets[i].find(*left_bottom.begin()) != pattern_sets[i].end())
|
|
{
|
|
x = pattern_sets[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
set<char> right_top = pattern_sets[0];
|
|
for(set<char>::iterator it = x.begin(); it != x.end(); ++it)
|
|
right_top.erase(*it);
|
|
|
|
set<char> right_bottom = pattern_sets[0];
|
|
right_bottom.erase(*right_top.begin());
|
|
|
|
string zero = "";
|
|
zero.append(1,*top.begin());
|
|
zero.append(1,*left_top.begin());
|
|
zero.append(1,*right_top.begin());
|
|
zero.append(1,*left_bottom.begin());
|
|
zero.append(1,*right_bottom.begin());
|
|
zero.append(1,*bottom.begin());
|
|
|
|
sort(zero.begin(),zero.end());
|
|
|
|
for(int i = 6; i <= 8; i++)
|
|
{
|
|
if (zero.compare(note.patterns[i]) == 0)
|
|
{
|
|
pattern_map[i] = 0;
|
|
}
|
|
}
|
|
|
|
string two = "";
|
|
two.append(1,*top.begin());
|
|
two.append(1,*right_top.begin());
|
|
two.append(1,*middle.begin());
|
|
two.append(1,*left_bottom.begin());
|
|
two.append(1,*bottom.begin());
|
|
|
|
sort(two.begin(), two.end());
|
|
|
|
for(int i = 3; i <= 5; i++)
|
|
{
|
|
if (two.compare(note.patterns[i]) == 0)
|
|
{
|
|
pattern_map[i] = 2;
|
|
}
|
|
}
|
|
|
|
string three = "";
|
|
three.append(1,*top.begin());
|
|
three.append(1,*right_top.begin());
|
|
three.append(1,*middle.begin());
|
|
three.append(1,*right_bottom.begin());
|
|
three.append(1,*bottom.begin());
|
|
|
|
sort(three.begin(), three.end());
|
|
|
|
for(int i = 3; i <= 5; i++)
|
|
{
|
|
if (three.compare(note.patterns[i]) == 0)
|
|
{
|
|
pattern_map[i] = 3;
|
|
}
|
|
}
|
|
|
|
string five = "";
|
|
five.append(1,*top.begin());
|
|
five.append(1,*left_top.begin());
|
|
five.append(1,*middle.begin());
|
|
five.append(1,*right_bottom.begin());
|
|
five.append(1,*bottom.begin());
|
|
|
|
sort(five.begin(), five.end());
|
|
|
|
for(int i = 3; i <= 5; i++)
|
|
{
|
|
if (five.compare(note.patterns[i]) == 0)
|
|
{
|
|
pattern_map[i] = 5;
|
|
}
|
|
}
|
|
|
|
string six = "";
|
|
six.append(1,*top.begin());
|
|
six.append(1,*left_top.begin());
|
|
six.append(1,*middle.begin());
|
|
six.append(1,*right_bottom.begin());
|
|
six.append(1,*left_bottom.begin());
|
|
six.append(1,*bottom.begin());
|
|
|
|
sort(six.begin(), six.end());
|
|
|
|
for(int i = 6; i <= 8; i++)
|
|
{
|
|
if (six.compare(note.patterns[i]) == 0)
|
|
{
|
|
pattern_map[i] = 6;
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < 10; i++)
|
|
{
|
|
bool found = false;
|
|
for(int j = 0; j < 10; j++)
|
|
{
|
|
if (pattern_map[j] == i)
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found)
|
|
{
|
|
cout << total_count << endl;
|
|
}
|
|
}
|
|
|
|
for(int i = 0, m = 1000; i < 4; i++, m/=10)
|
|
{
|
|
for(int j = 0; j < 10; j++)
|
|
{
|
|
if (0 == note.outputs[i].compare(note.patterns[j]))
|
|
{
|
|
result += m*pattern_map[j];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
cout << result << endl;
|
|
|
|
return 0;
|
|
}
|
|
|