Justi/Advent2021
Justi
/
Advent2021
1
0
Fork 0
Code Releases Activity

Day 5-8 submissions

This commit is contained in:
Marcus Penate 2021-12-08 22:14:58 -05:00
parent 5689b82731
commit 533aae2f1c
8 changed files with 552 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
Day 5/Marcus/cpp/part1.cpp Normal file
View File

@ -0,0 +1,59 @@
#include <iostream>
#include <algorithm>
#include <set>
using namespace std;
struct Line
{
int x1,y1,x2,y2;
friend istream &operator>>( istream &input, Line &l ) {
input >> l.x1 >> l.y1 >> l.x2 >> l.y2;
return input;
}
};
inline constexpr int num_lines{500};
inline constexpr int grid_size{1000};
int main()
{
int grid[grid_size*grid_size] = {0};
Line line;
set<int> dangerous_locations;
for(int i = 0; i < num_lines; i++)
{
cin >> line;
if (line.x1 == line.x2)
{
for(int y = min(line.y1, line.y2); y <= max(line.y1, line.y2); y++)
{
grid[line.x1 + grid_size*y]++;
if (grid[line.x1+y*grid_size] >= 2)
{
dangerous_locations.insert(line.x1+y*grid_size);
}
}
}
else if (line.y1 == line.y2)
{
for(int x = min(line.x1, line.x2); x <= max(line.x1, line.x2); x++)
{
grid[x + line.y1*grid_size]++;
if (grid[x+line.y1*grid_size] >= 2)
{
dangerous_locations.insert(x+line.y1*grid_size);
}
}
}
}
cout << dangerous_locations.size() << endl;
return 0;
}

86
Day 5/Marcus/cpp/part2.cpp Normal file
View File

@ -0,0 +1,86 @@
#include <iostream>
#include <algorithm>
#include <set>
using namespace std;
struct Line
{
int x1,y1,x2,y2;
friend istream &operator>>( istream &input, Line &l ) {
input >> l.x1 >> l.y1 >> l.x2 >> l.y2;
return input;
}
};
inline constexpr int num_lines{500};
inline constexpr int grid_size{1000};
int main()
{
int grid[grid_size*grid_size] = {0};
Line line;
set<int> dangerous_locations;
for(int i = 0; i < num_lines; i++)
{
cin >> line;
if (line.x1 == line.x2)
{
for(int y = min(line.y1, line.y2); y <= max(line.y1, line.y2); y++)
{
grid[line.x1 + grid_size*y]++;
if (grid[line.x1+y*grid_size] >= 2)
{
dangerous_locations.insert(line.x1+y*grid_size);
}
}
}
else if (line.y1 == line.y2)
{
for(int x = min(line.x1, line.x2); x <= max(line.x1, line.x2); x++)
{
grid[x + line.y1*grid_size]++;
if (grid[x+line.y1*grid_size] >= 2)
{
dangerous_locations.insert(x+line.y1*grid_size);
}
}
}
else
{
if ((line.y2-line.y1)/(line.x2-line.x1) > 0)
{
for(int x = min(line.x1, line.x2), y = min(line.y1, line.y2); x <= max(line.x1, line.x2); x++, y++)
{
grid[x + y*grid_size]++;
if (grid[x+y*grid_size] >= 2)
{
dangerous_locations.insert(x+y*grid_size);
}
}
}
else
{
for(int x = min(line.x1, line.x2), y = max(line.y1, line.y2); x <= max(line.x1, line.x2); x++, y--)
{
grid[x + y*grid_size]++;
if (grid[x+y*grid_size] >= 2)
{
dangerous_locations.insert(x+y*grid_size);
}
}
}
}
}
cout << dangerous_locations.size() << endl;
return 0;
}

33
Day 6/Marcus/cpp/part1.cpp Normal file
View File

@ -0,0 +1,33 @@
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> fish(300);
for(int i = 0; i < 300; i++) cin >> fish[i];
for(int i = 0; i < 80; i++)
{
int new_fish_count = 0;
for(int j = 0; j < fish.size(); j++)
{
if (--fish[j] < 0)
{
fish[j] = 6;
new_fish_count++;
}
}
vector<int> new_fish(new_fish_count, 8);
fish.insert(fish.end(), new_fish.begin(), new_fish.end());
}
cout << fish.size() << endl;
return 0;
}

33
Day 6/Marcus/cpp/part2.cpp Normal file
View File

@ -0,0 +1,33 @@
#include <iostream>
using namespace std;
int main()
{
int next_fish;
unsigned long long fish[9] = {0};
for(int i = 0; i < 300; i++)
{
cin >> next_fish;
fish[next_fish]++;
}
unsigned long long total_fish = 300;
for(int i = 0; i < 256; i++)
{
unsigned long long spawning_fish = fish[0];
total_fish += spawning_fish;
for(int j = 1; j < 9; j++)
{
fish[j-1] = fish[j];
}
fish[6] += spawning_fish;
fish[8] = spawning_fish;
}
cout << total_fish << endl;
return 0;
}

23
Day 7/Marcus/cpp/part1.cpp Normal file
View File

@ -0,0 +1,23 @@
#include <iostream>
#include <algorithm>
#include <math.h>
using namespace std;
int main()
{
vector<int> crabs(1000);
for(int i = 0; i < 1000; i++) cin >> crabs[i];
sort(crabs.begin(), crabs.end());
int final_position = round(((float)crabs[499]+(float)crabs[500])/2.0f);
int fuel = 0;
for(int i = 0; i < 1000; i++) fuel += (int)abs((float)final_position-crabs[i]);
cout << fuel << endl;
return 0;
}

31
Day 7/Marcus/cpp/part2.cpp Normal file
View File

@ -0,0 +1,31 @@
#include <iostream>
#include <algorithm>
#include <math.h>
using namespace std;
int main()
{
vector<int> crabs(1000);
for(int i = 0; i < 1000; i++) cin >> crabs[i];
sort(crabs.begin(), crabs.end());
vector<int> costs(crabs[999],0);
for(int i = 0; i < costs.size(); i++)
{
for(int j = 0; j < 1000; j++)
{
int diff = (int)abs((float)i-crabs[j]);
costs[i] += (diff*(diff+1))/2;
}
}
sort(costs.begin(), costs.end());
cout << costs[0] << endl;
return 0;
}

51
Day 8/Marcus/cpp/part1.cpp Normal file
View File

@ -0,0 +1,51 @@
#include <iostream>
#include <algorithm>
#include <math.h>
#include <string>
using namespace std;
struct Note
{
string patterns[10];
string outputs[4];
friend istream &operator>>( istream &input, Note &n ) {
for(int i = 0; i < 10; i++)
{
input >> n.patterns[i];
}
for(int i = 0; i < 4; i++)
{
input >> n.outputs[i];
}
return input;
}
};
int main()
{
Note note;
int count = 0;
while (cin >> note)
{
for(int i = 0; i < 4; i++)
{
switch(note.outputs[i].size())
{
case 2:
case 3:
case 4:
case 7:
count++;
break;
default:
break;
}
}
}
cout << count << endl;
return 0;
}

236
Day 8/Marcus/cpp/part2.cpp Normal file
View File

@ -0,0 +1,236 @@
#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;
}