Advent of Code 2022

BornToBeRoot · 7. Dezember 2022, 20:39

Lösung Tag 7 in PowerShell

Quellcode

[System.Collections.ArrayList]$Folders = @()
$CurrentFolder = ""
foreach ($Line in Get-Content -Path $PSScriptRoot\day07_input.txt) {
if ($Line.StartsWith("$ cd")) {
$CommandArray = $Line.Split(" ")
switch ($CommandArray[2]) {
"/" { $CurrentFolder = $CommandArray[2] }
".." { $CurrentFolder = $CurrentFolder.Substring(0, $CurrentFolder.TrimEnd("/").LastIndexOf("/")) + "/" }
default { $CurrentFolder += $CommandArray[2] + "/" }
}
}
elseif (-not $Line.StartsWith("$")) {
$FileOrDir = $Line.Trim().Split(" ")
if ($FileOrDir -match "^\d+$") {
$FileSize = [int]$FileOrDir[0]
$TempFolder = ""
$PathSplit = $CurrentFolder.Split("/")
foreach ($Sub in $PathSplit[0..($PathSplit.Count - 2)]) {
$TempFolder += $Sub + "/"
$x = $Folders | Where-Object { $_.Folder -eq $TempFolder }
$TempSize = $FileSize
# Remove existing entry / update
if ($null -ne $x) {
$TempSize += $x.Size
[void]$Folders.Remove($x)
}
[void]$Folders.Add([pscustomobject]@{
Folder = $TempFolder
Size = $TempSize
})
}
}
}
}
# Part 1
($Folders | Where-Object { $_.Size -le 100000 } | Measure-Object -Sum Size).Sum
# Part 2
$DiffFreeSpace = 70000000 - ($Folders | Where-Object { $_.Folder -eq "/" }).Size
$RequiredSpace = (30000000 - $DiffFreeSpace)
($Folders | Where-Object { $_.Size -ge $RequiredSpace } | Sort-Object -Property Size | Select-Object -First 1).Size

Alle meine Lösungen für PowerShell findet ihr auf GitHub: github.com/BornToBeRoot/AdventOfCode

xChRoNiKx · 7. Dezember 2022, 21:55

Tag 07 C# Part 1 und 2
Da gibt es nen kleines Ding was man beachten sollte.. habs mal kommentiert aber nicht wirklich ausführlich.

Spoiler anzeigen

C#-Quellcode

string[] commands = System.IO.File.ReadAllLines("Input.txt");
Directory RootDirectory = new Directory("/", null);
Directory CurrentDirectory = null;
foreach (string command in commands)
{
string[] cmdParts = command.Split(' ');
if (cmdParts[0] == "$")
{
if (cmdParts[1] == "cd")
{
if (cmdParts[2] == "/")
{
CurrentDirectory = RootDirectory;
}
else if (cmdParts[2] == "..")
{
CurrentDirectory = CurrentDirectory.Parent;
}
else
{
CurrentDirectory = CurrentDirectory.Directories.FirstOrDefault(d => d.Name == cmdParts[2]);
}
}
else
{
continue;
}
}
else if (cmdParts[0] == "dir")
{
Directory tDir = new Directory(cmdParts[1], CurrentDirectory);
CurrentDirectory.AddDirectory(tDir);
}
else
{
File tFile = new File(cmdParts[1], Int32.Parse(cmdParts[0]));
CurrentDirectory.AddFile(tFile);
}
}
Console.WriteLine($"Part 1: {RootDirectory.GetDirectorysSmallerThanSize(100000).Sum(x => x.TotalFileSize)}");
int total = 70000000;
int req = 30000000;
int used = RootDirectory.TotalFileSize;
int free = total - used;
int need = req - free;
Console.WriteLine($"Part 2: { RootDirectory.GetDirectorysSmallerThanSize(Int32.MaxValue).OrderBy(d => d.TotalFileSize).Where(d => d.TotalFileSize >= need).First().TotalFileSize }");
public class Directory
{
public string Name { get; set; }
public Directory Parent { get; set; }
public List<Directory> Directories { get; private set; } = new List<Directory>();
public int TotalFileSize => Files.Sum(f => f.Filesize) + Directories.Sum(d => d.TotalFileSize);
public List<File> Files { get; set; } = new List<File>();
public Directory(string name, Directory parent)
{
Name = name;
Parent = parent;
}
public void AddDirectory(Directory newDir)
{
Directories.Add(newDir);
}
public void AddFile(File file)
{
Files.Add(file);
}
public List<Directory> GetDirectorysSmallerThanSize(int size)
{
List<Directory> result = new List<Directory>();
foreach (var directory in Directories)
{
if(directory.TotalFileSize <= size)
{
result.Add(directory);
}
//else // Nice BAIT --- man muss alle Ordner beachten also auch Unter-Unter-Unter Ordner im Ordner. Lesen muss man richtig.
//{
// result.AddRange(directory.Value.GetDirectorysSmallerThanSize(size));
//}
result.AddRange(directory.GetDirectorysSmallerThanSize(size));
}
return result;
}
}
public class File
{
public string Filename { get; set; } = "";
public int Filesize { get; set; } = 0;
public File(string fileName, int size)
{
Filename = fileName;
Filesize = size;
}
}

SpaceyX · 7. Dezember 2022, 23:13

Day 7:

Spoiler anzeigen

C#-Quellcode

namespace SevenA;
public class Program
{
static void Main(string[] args)
{
IEnumerable<string> data = System.IO.File.ReadAllLines("input.txt");
FilesystemU fileSystem = new();
for (int i = 0; i < data.Count(); i++)
{
IEnumerable<string> tokens = data.ElementAt(i).Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
if (tokens.ElementAt(0) == "$" && tokens.ElementAt(1) == "cd")
fileSystem.Execute(tokens);
if (tokens.ElementAt(0) == "$" && tokens.ElementAt(1) == "ls")
{
List<string> listing = new();
while (true)
{
i++;
if (i >= data.Count()) break;
if (data.ElementAt(i).StartsWith("$"))
{
i--;
break;
}
listing.Add(data.ElementAt(i));
}
fileSystem.ExecuteListing(listing);
}
}
//Für Part1
Console.WriteLine(fileSystem.Directories.Where(x => x.TotalSize <= 100000).Sum(x => x.TotalSize));
//Für Part2
long totalSpace = 70000000;
long spaceNeeded = 30000000;
long unused = totalSpace - fileSystem.Directories[0].TotalSize;
long needed = spaceNeeded - unused;
var candidates = fileSystem.Directories.Where(x => x.TotalSize >= needed);
candidates = candidates.OrderBy(x => x.TotalSize);
Console.WriteLine($"{candidates.ElementAt(0).Name} - {candidates.ElementAt(0).TotalSize}");
}
}
class FilesystemU
{
public List<FileU> Files { get; set; } = new();
public List<DirectoryU> Directories { get; set; } = new();
public List<DirectoryU> CurrentPath { get; set; } = new();
public void Execute(IEnumerable<string> command)
{
if (command.ElementAt(0) == "$")
{
if (command.ElementAt(1) == "cd")
{
if (command.ElementAt(2) != "..")
{
DirectoryU dir = CheckDirectory(command.ElementAt(2), this.CurrentPath.Count > 0 ? this.CurrentPath.Last() : null);
if (!this.Directories.Contains(dir))
this.Directories.Add(dir);
this.CurrentPath.Add(dir);
}
if (command.ElementAt(2) == "..")
{
this.CurrentPath.RemoveAt(this.CurrentPath.Count - 1);
}
}
}
}
public void ExecuteListing(IEnumerable<string> data)
{
for (int i = 0; i < data.Count(); i++)
{
IEnumerable<string> tokens = data.ElementAt(i).Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
if (tokens.ElementAt(0) == "dir")
{
var dir = CheckDirectory(tokens.ElementAt(1), this.CurrentPath.Last());
if (!this.Directories.Contains(dir))
this.Directories.Add(dir);
this.CurrentPath.Last().Directories.Add(dir);
}
else
{
FileU file = new();
file.Name = tokens.ElementAt(1);
file.Size = long.Parse(tokens.ElementAt(0));
file.Parent = this.CurrentPath.Last();
this.Files.Add(file);
this.CurrentPath.Last().Files.Add(file);
}
}
}
private DirectoryU CheckDirectory(string name, DirectoryU parent)
{
DirectoryU dir = null;
if (this.CurrentPath.Count() > 0)
dir = this.CurrentPath.Last().Directories.Where(x => x.Name == name).FirstOrDefault();
if (dir == null)
{
dir = new DirectoryU()
{
Name = name,
Parent = parent
};
}
return dir;
}
}
class DirectoryU
{
public string Name { get; set; }
public DirectoryU Parent { get; set; }
public List<DirectoryU> Directories { get; set; } = new();
public List<FileU> Files { get; set; } = new();
public long Size { get => this.Files.Sum(x => x.Size); set => this.Size = value; }
public long TotalSize { get => CalculateTotalSize(); set => this.TotalSize = value; }
private long CalculateTotalSize()
{
List<DirectoryU> tmp = new(this.Directories);
long result = 0;
while (tmp.Count > 0)
{
List<DirectoryU> tmp1 = new();
for (int i = 0; i < tmp.Count; i++)
{
tmp1.AddRange(tmp[i].Directories);
result += tmp[i].Size;
}
tmp.Clear();
tmp.AddRange(tmp1);
}
return result + this.Size;
}
}
class FileU
{
public string Name { get; set; }
public DirectoryU Parent { get; set; }
public long Size { get; set; }
}

EaranMaleasi · 8. Dezember 2022, 17:39

Tag 8:

Spoiler anzeigen

C#-Quellcode

public static class AoC_D8
{
public static TreeGrid MainGrid { get; } = new TreeGrid();
public static int VisibleTrees { get; private set; }
public static int HighestScenicScore { get; private set; }
public static void ReadInputAndCalculate()
{
using StreamReader streamReader = new StreamReader("AoC_8_input.txt");
do
{
string line = streamReader.ReadLine();
if (string.IsNullOrWhiteSpace(line))
continue;
MainGrid.AddRowFromLine(line);
} while (!streamReader.EndOfStream);
CalculateVisibleTrees();
CalculateScenicScores();
HighestScenicScore = MainGrid.AllTrees.Max(x => x.ScenicScore);
}
private static void CalculateVisibleTrees()
{
foreach (var rows in MainGrid.Rows)
foreach (var tree in rows.Trees)
if (tree.CalculateTreeVisibility())
VisibleTrees++;
}
private static void CalculateScenicScores()
{
foreach (var rows in MainGrid.Rows)
foreach (var tree in rows.Trees)
tree.CalculateScore();
}
}
public class Tree
{
public int Size { get; set; }
public int Row { get; set; }
public int Column { get; set; }
public TreeGrid Grid { get; set; }
public int ScenicScore { get; set; }
public void CalculateScore()
{
if (Row == 0 || Row == 98 || Column == 0 || Column == 98)
ScenicScore = 0;
ScenicScore = CalculateScoreAbove() *
CalculateScoreBelow() *
CalculateScoreLeft() *
CalculateScoreRight();
}
public bool CalculateTreeVisibility()
{
if (Row == 0 || Row == 98 || Column == 0 || Column == 98)
return true;
return IsTreeVisibleFromAbove() ||
IsTreeVisibleFromBelow() ||
IsTreeVisibleFromLeft() ||
IsTreeVisibleFromRight();
}
private int CalculateScoreLeft()
{
for (int searchColumn = Column - 1; searchColumn >= 0; searchColumn--)
{
int searchSize = Grid[Row][searchColumn].Size;
if (searchSize >= Size)
return Column - searchColumn;
}
return Column;
}
private int CalculateScoreRight()
{
for (int searchColumn = Column + 1; searchColumn < 99; searchColumn++)
{
int searchSize = Grid[Row][searchColumn].Size;
if (searchSize >= Size)
return searchColumn - Column;
}
return 98 - Column;
}
private int CalculateScoreAbove()
{
for (int searchRow = Row - 1; searchRow >= 0; searchRow--)
{
int searchSize = Grid[searchRow][Column].Size;
if (searchSize >= Size)
return Row - searchRow;
}
return Row;
}
private int CalculateScoreBelow()
{
for (int searchRow = Row + 1; searchRow < 99; searchRow++)
{
int searchSize = Grid[searchRow][Column].Size;
if (searchSize >= Size)
return searchRow - Row;
}
return 98 - Row;
}
private bool IsTreeVisibleFromLeft()
{
for (int searchColumn = Column - 1; searchColumn >= 0; searchColumn--)
{
int searchSize = Grid[Row][searchColumn].Size;
if (searchSize >= Size)
return false;
}
return true;
}
private bool IsTreeVisibleFromRight()
{
for (int searchColumn = Column + 1; searchColumn < 99; searchColumn++)
{
int searchSize = Grid[Row][searchColumn].Size;
if (searchSize >= Size)
return false;
}
return true;
}
private bool IsTreeVisibleFromAbove()
{
for (int searchRow = Row - 1; searchRow >= 0; searchRow--)
{
int searchSize = Grid[searchRow][Column].Size;
if (searchSize >= Size)
return false;
}
return true;
}
private bool IsTreeVisibleFromBelow()
{
for (int searchRow = Row + 1; searchRow < 99; searchRow++)
{
int searchSize = Grid[searchRow][Column].Size;
if (searchSize >= Size)
return false;
}
return true;
}
}
public class TreeGrid
{
private int rowNo = 0;
public List<TreeRow> Rows { get; } = new List<TreeRow>();
public List<Tree> AllTrees { get; } = new List<Tree>();
public TreeRow this[int i] => Rows[i];
public void AddRowFromLine(string line)
{
TreeRow current = new TreeRow(rowNo);
for (int column = 0; column < line.Length; column++)
{
current.Trees.Add(new Tree
{
Column = column,
Row = rowNo,
Grid = this,
Size = int.Parse(line[column].ToString())
});
AllTrees.Add(current.Trees.Last());
}
Rows.Add(current);
rowNo++;
}
}
public class TreeRow
{
public int RowNo { get; }
public List<Tree> Trees { get; } = new List<Tree>();
public Tree this[int i] => Trees[i];
public TreeRow(int rowNo)
{ RowNo = rowNo; }
}

Zudem hab ich jetzt auch ein GitHub Repo dafür angelegt:
github.com/EaranMaleasi/AoC_Projects_2022

xChRoNiKx · 8. Dezember 2022, 19:34

Tag 8 C# - Das geht noch schöner allerdings heute keine Lust mehr

Part 1 und 2

Spoiler anzeigen

C#-Quellcode

string[] lines = File.ReadAllLines("Input.txt");
int rows = lines.Length;
int cols = lines[0].ToCharArray().Count();
int[,] field = new int[rows,cols];
List<int> scenicScores = new List<int>();
int rowCount = 0;
int colCount = 0;
int visibleTrees = 0;
foreach (string line in lines)
{
colCount = 0;
char[] chars = line.ToCharArray();
foreach (char c in chars)
{
field[rowCount,colCount] = Int32.Parse(c.ToString());
colCount++;
}
rowCount++;
}
for (int row = 0; row < rows; row++)
{
for (int col = 0; col < cols; col++)
{
scenicScores.Add(calculateTopScenicScore(row, col) * calculateBottomScenicScore(row, col) * calculateLeftScenicScore(row, col) * calculateRightScenicScore(row, col));
if (IsVisible(row, col)) visibleTrees++;
}
}
Console.WriteLine($"Part 1: {visibleTrees}");
Console.WriteLine($"Part 2: {scenicScores.Max()}");
bool IsVisible(int x, int y)
{
if (x == 0 || y == 0 || x == rows - 1 || y == cols - 1) return true;
if (checkLeft(x, y)) return true;
if (checkRight(x, y)) return true;
if (checkTop(x, y)) return true;
if (checkBottom(x, y)) return true;
return false;
}
int calculateLeftScenicScore(int x, int y)
{
int height = field[x, y];
int score = 0;
for (int i = y - 1; i >= 0; i--)
{
int curHeight = field[x, i];
if (curHeight >= height) return score +1;
score++;
}
return score;
}
int calculateRightScenicScore(int x, int y)
{
int height = field[x, y];
int score = 0;
for (int i = y + 1; i < cols; i++)
{
int curHeight = field[x, i];
if (curHeight >= height) return score + 1;
score++;
}
return score;
}
int calculateTopScenicScore(int x, int y)
{
int height = field[x, y];
int score = 0;
for (int i = x - 1; i >= 0; i--)
{
int curHeight = field[i, y];
if (curHeight >= height) return score + 1;
score++;
}
return score;
}
int calculateBottomScenicScore(int x, int y)
{
int height = field[x, y];
int score = 0;
for (int i = x + 1; i < cols; i++)
{
int curHeight = field[i, y];
if (curHeight >= height) return score + 1;
score++;
}
return score;
}
bool checkLeft(int x, int y)
{
int height = field[x,y];
for (int i = y -1; i >= 0; i--)
{
int curHeight = field[x, i];
if (curHeight >= height) return false;
}
return true;
}
bool checkRight(int x, int y)
{
int height = field[x, y];
for (int i = y + 1; i < cols; i++)
{
int curHeight = field[x, i];
if (curHeight >= height) return false;
}
return true;
}
bool checkTop(int x, int y)
{
int height = field[x, y];
for (int i = x - 1; i >= 0; i--)
{
int curHeight = field[i, y];
if (curHeight >= height) return false;
}
return true;
}
bool checkBottom(int x, int y)
{
int height = field[x, y];
for (int i = x + 1; i < cols; i++)
{
int curHeight = field[i, y];
if (curHeight >= height) return false;
}
return true;
}

nogood · 8. Dezember 2022, 22:39

Tag 8
Teil 1 und 2 C#
(wie ich das Debuggen mit Indizes etc. dislike

)

Spoiler anzeigen

C#-Quellcode

using System.Linq;
using System.Text.RegularExpressions;
var Lines = File.ReadAllLines("CodeAdvent_8.txt");
var YMax = Lines.Length;
var XMax = Lines[0].Length;
List <List<int>> Rows = new();
List <List<int>> Columns = new();
List<Tree> Trees = new();
foreach (var line in Lines)
{
var nrs = Regex.Matches(line, @"\d").ToList();
List<int> Row= new ();
foreach (var nr in nrs)
{
Row.Add(int.Parse(nr.Value));
}
Rows.Add(Row);
}
var TreeCount = 0;
for (int x = 0; x < XMax; x++)
{
List<int> Column= new();
for (int y = 0; y < YMax; y++)
{
TreeCount++;
Column.Add(Rows[y].ElementAt(x));
Trees.Add(new(y, x, Rows[x].ElementAt(y), TreeCount));
}
Columns.Add(Column);
}
foreach (var tree in Trees)
{
tree.SetIsVisible(Rows[tree.PosY], Columns[tree.PosX]);
tree.SetScenicScore(Rows[tree.PosY], Columns[tree.PosX]);
}
Console.WriteLine($"Visible Trees: {Trees.Where(x => x.IsVisible).Count()}");
Console.WriteLine($"MaxScenicScore: {Trees.MaxBy(x => x.ScenicScore).ScenicScore}");
class Tree
{
public Tree(int posX, int posY, int height, int id)
{
PosX = posX;
PosY = posY;
Height = height;
Id= id;
}
public int Id { get; set; } = 0;
public int Height = 0;
public int PosX { get; set; } = 0;
public int PosY { get; set; } = 0;
public int ScenicScore { get; set; } = 0;
public bool XVisible { get; set; } = false;
public bool YVisible { get; set; } = false;
public bool IsVisible { get { return XVisible || YVisible; } }
public void SetScenicScore(List<int> row, List<int> column)
{
List<int> rLeft = row.GetRange(0, PosX);
List<int> rRight = row.GetRange(PosX + 1, row.Count - PosX - 1);
rLeft.Reverse();
int scoreLeftR = 0;
int scoreRightR = 0;
if (rLeft.Count == 0)
{
scoreLeftR = 0;
}
else
{
var keepLooking = true;
foreach (var t in rLeft)
{
if (keepLooking)
{
scoreLeftR++;
}
if (t >= Height)
{
keepLooking = false;
}
}
}
if (rRight.Count == 0)
{
scoreRightR = 0;
}
else
{
var keepLooking = true;
foreach (var t in rRight)
{
if (keepLooking)
{
scoreRightR++;
}
if (t >= Height)
{
keepLooking = false;
}
}
}
var cLeft = column.GetRange(0, PosY);
var cRight = column.GetRange(PosY + 1, column.Count - PosY - 1);
cLeft.Reverse();
int scoreLeftC = 0;
int scoreRightC = 0;
if (cLeft.Count == 0)
{
scoreLeftC = 0;
}
else
{
var keepLooking = true;
foreach (var t in cLeft)
{
if (keepLooking)
{
scoreLeftC++;
}
if (t >= Height)
{
keepLooking = false;
}
}
}
if (cRight.Count == 0)
{
scoreRightC = 0;
}
else
{
var keepLooking = true;
foreach (var t in cRight)
{
if (keepLooking)
{
scoreRightC++;
}
if (t >= Height)
{
keepLooking = false;
}
}
}
ScenicScore = scoreRightC * scoreLeftC * scoreRightR * scoreLeftR;
}
public void SetIsVisible(List<int> row, List<int> column)
{
var rLeft = row.GetRange(0, PosX);
var rRight = row.GetRange(PosX+1, row.Count - PosX - 1);
bool visibleFromLeft = false;
bool visibleFromRight = false;
if (rLeft.Count == 0)
{
visibleFromLeft = true;
}
else
{
var res = rLeft.Max() ;
visibleFromLeft = res < Height;
}
if (rRight.Count == 0)
{
visibleFromRight = true;
}
else
{
var res = rRight.Max();
visibleFromRight = res < Height;
}
XVisible = visibleFromLeft || visibleFromRight;
var cLeft = column.GetRange(0, PosY);
var cRight = column.GetRange(PosY + 1, column.Count - PosY - 1);
bool visibleFromLeftc = false;
bool visibleFromRightc = false;
if (cLeft.Count == 0)
{
visibleFromLeftc = true;
}
else
{
var res = cLeft.Max();
visibleFromLeftc = res < Height;
}
if (cRight.Count == 0)
{
visibleFromRightc = true;
}
else
{
var res = cRight.Max();
visibleFromRightc = res < Height;
}
YVisible = visibleFromLeftc || visibleFromRightc;
}
}

ISliceUrPanties · 8. Dezember 2022, 22:45

Tag 7 war irgendwie nervig. Lag vielleicht auch an einem generell bescheidenen Tag gestern

Part 1

Spoiler anzeigen

C#-Quellcode

using System.Text.RegularExpressions;
using StreamReader sr = new(File.OpenRead(@"input.txt"));
const int threshold = 100_000;
Regex commandRegex = new("(\\$).(\\w+).?(\\/|\\w+|\\.\\.)*", RegexOptions.Compiled);
Regex listingRegex = new("(dir|\\d+).(\\w+)", RegexOptions.Compiled);
bool listMode = false;
D rootDir = new() { Name = "/" };
D workingDir = new();
while (!sr.EndOfStream)
{
var line = sr.ReadLine()!;
if (listMode)
{
if (listingRegex.IsMatch(line))
{
foreach (Match m in listingRegex.Matches(line))
{
if (m.Groups[1].Value == "dir")
{
workingDir.Subdirs.Add(new() { Name = m.Groups[2].Value });
}
else
{
workingDir.Files.Add(new() { Name = m.Groups[2].Value, Size = int.Parse(m.Groups[1].Value) });
}
}
}
}
if (commandRegex.IsMatch(line))
{
foreach (Match m in commandRegex.Matches(line))
{
switch (m.Groups[2].Value)
{
case "cd":
listMode = false;
D currentDir = workingDir;
workingDir = m.Groups[3].Value switch
{
"/" => rootDir,
".." => workingDir!.Parent,
_ => workingDir.Subdirs.First(d => d.Name!.Equals(m.Groups[3].Value))
};
if (workingDir!.Parent is null)
{
workingDir!.Parent = currentDir;
}
break;
case "ls":
listMode = true;
break;
}
}
}
}
List<int> sizes = new();
foreach (var dir in rootDir.Subdirs)
{
TotalSizeD(dir);
}
Console.WriteLine(sizes.Sum());
int TotalSizeD(D dir)
{
int total = 0;
if (dir.Subdirs.Count > 0)
{
for (int i = 0; i < dir.Subdirs.Count; ++i)
{
total += TotalSizeD(dir.Subdirs[i]);
}
}
total += dir.Size;
if (total <= threshold)
{
sizes.Add(total);
}
return total;
}
class D
{
public string? Name { get; set; }
public int Size => Files.Sum(f => f.Size);
public List<F> Files { get; init; } = new();
public List<D> Subdirs { get; set; } = new();
public D? Parent { get; set; }
}
struct F
{
public string Name;
public int Size;
}

Part 2

Spoiler anzeigen

C#-Quellcode

using System.Text.RegularExpressions;
using StreamReader sr = new(File.OpenRead(@"input.txt"));
const int maxAvailable = 70_000_000;
const int minAvailableForUpdate = 30_000_000;
Regex commandRegex = new("(\\$).(\\w+).?(\\/|\\w+|\\.\\.)*", RegexOptions.Compiled);
Regex listingRegex = new("(dir|\\d+).(\\w+)", RegexOptions.Compiled);
bool listMode = false;
D rootDir = new() { Name = "/" };
D workingDir = new();
while (!sr.EndOfStream)
{
var line = sr.ReadLine()!;
if (listMode)
{
if (listingRegex.IsMatch(line))
{
foreach (Match m in listingRegex.Matches(line))
{
if (m.Groups[1].Value == "dir")
{
workingDir.Subdirs.Add(new() { Name = m.Groups[2].Value });
}
else
{
workingDir.Files.Add(new() { Name = m.Groups[2].Value, Size = int.Parse(m.Groups[1].Value) });
}
}
}
}
if (commandRegex.IsMatch(line))
{
foreach (Match m in commandRegex.Matches(line))
{
switch (m.Groups[2].Value)
{
case "cd":
listMode = false;
D currentDir = workingDir;
workingDir = m.Groups[3].Value switch
{
"/" => rootDir,
".." => workingDir!.Parent,
_ => workingDir.Subdirs.First(d => d.Name!.Equals(m.Groups[3].Value))
};
if (workingDir!.Parent is null)
{
workingDir!.Parent = currentDir;
}
break;
case "ls":
listMode = true;
break;
}
}
}
}
List<int> sizes = new();
int total = rootDir.Size;
foreach (var dir in rootDir.Subdirs)
{
total += TotalSize(dir);
}
int freeSpace = maxAvailable - total;
foreach (var dir in rootDir.Subdirs)
{
FindDForEnoughSpace(dir);
}
Console.WriteLine(sizes.Min());
int TotalSize(D dir)
{
int total = dir.Size;
if (dir.Subdirs.Count > 0)
{
for (int i = 0; i < dir.Subdirs.Count; ++i)
{
total += TotalSize(dir.Subdirs[i]);
}
}
return total;
}
int FindDForEnoughSpace(D dir)
{
int size = dir.Size;
if (dir.Subdirs.Count > 0)
{
for (int i = 0; i < dir.Subdirs.Count; ++i)
{
size += FindDForEnoughSpace(dir.Subdirs[i]);
}
}
if ((size + freeSpace) >= minAvailableForUpdate)
{
sizes.Add(size);
}
return size;
}
class D
{
public string? Name { get; set; }
public int Size => Files.Sum(f => f.Size);
public List<F> Files { get; init; } = new();
public List<D> Subdirs { get; set; } = new();
public D? Parent { get; set; }
}
struct F
{
public string Name;
public int Size;
}

Tag 8
Part 1

Spoiler anzeigen

C#-Quellcode

using StreamReader sr = new(File.OpenRead(@"input.txt"));
HashSet<P> points = new();
int currentRow = 0;
int maxCols = 0;
int maxRows = 0;
int visibleTrees = 0;
while (!sr.EndOfStream)
{
var lineSpan = sr.ReadLine().AsSpan();
if (maxCols == 0)
{
maxCols = lineSpan.Length - 1;
}
for (int i = 0; i < lineSpan.Length; ++i)
{
points.Add(new() { X = i, Y = currentRow, Height = int.Parse(lineSpan.Slice(i, 1)) });
}
++currentRow;
}
sr.Close();
maxRows = currentRow - 1;
int[,] matrix = new int[99, 99];
foreach (P p in points)
{
matrix[p.X, p.Y] = p.Height;
}
for (int i = 0; i <= maxRows; ++i)
{
for (int j = 0; j <= maxCols; ++j)
{
if ((i == 0) || (j == 0) || (i == maxRows) || (j == maxCols))
{
++visibleTrees;
}
else
{
int h = matrix[j, i];
if (((i > 0) && CheckIfVisible(h, j, i - 1, points.Where(s => s.Y < i && s.X == j).Max(s => s.Height))) ||
((j > 0) && CheckIfVisible(h, j - 1, i, points.Where(s => s.Y == i && s.X < j).Max(s => s.Height))) ||
((i < maxRows) && CheckIfVisible(h, j, i + 1, points.Where(s => s.Y > i && s.X == j).Max(s => s.Height))) ||
((j < maxCols) && CheckIfVisible(h, j + 1, i, points.Where(s => s.Y == i && s.X > j).Max(s => s.Height))))
{
++visibleTrees;
}
}
}
}
Console.WriteLine(visibleTrees);
bool CheckIfVisible(int h, int x, int y, int heighest)
{
return (h > matrix[x, y]) && (h > heighest);
}
struct P
{
public int X;
public int Y;
public int Height;
}

Part 2

Spoiler anzeigen

C#-Quellcode

using StreamReader sr = new(File.OpenRead(@"input.txt"));
HashSet<P> points = new();
int currentRow = 0;
int maxCols = 0;
int maxRows = 0;
while (!sr.EndOfStream)
{
var lineSpan = sr.ReadLine().AsSpan();
if (maxCols == 0)
{
maxCols = lineSpan.Length - 1;
}
for (int i = 0; i < lineSpan.Length; ++i)
{
points.Add(new() { X = i, Y = currentRow, Height = int.Parse(lineSpan.Slice(i, 1)) });
}
++currentRow;
}
sr.Close();
maxRows = currentRow - 1;
int maxScore = 0;
int[,] matrix = new int[99, 99];
foreach (P p in points)
{
matrix[p.X, p.Y] = p.Height;
}
for (int i = 0; i <= maxRows; ++i)
{
for (int j = 0; j <= maxCols; ++j)
{
int score = CalculateScore(matrix[j, i], j, i);
maxScore = score > maxScore ? score : maxScore;
}
}
Console.WriteLine(maxScore);
int CalculateScore(int h, int x, int y)
{
int score = 1;
if (x > 0)
{
score *= TreeCountLeft(h, x, y);
}
score *= TreeCountRight(h, x, y);
score *= TreeCountUp(h, x, y);
if (y > 0)
{
score *= TreeCountDown(h, x, y);
}
return score;
}
int TreeCountLeft(int h, int x, int y)
{
int treeCount = 0;
for (int i = x - 1; i >= 0; --i)
{
treeCount++;
if (h <= matrix[i, y])
{
break;
}
}
return treeCount;
}
int TreeCountRight(int h, int x, int y)
{
int treeCount = 0;
for (int i = x + 1; i <= maxCols; ++i)
{
treeCount++;
if (h <= matrix[i, y])
{
break;
}
}
return treeCount;
}
int TreeCountDown(int h, int x, int y)
{
int treeCount = 0;
for (int i = y + 1; i <= maxRows; ++i)
{
treeCount++;
if (h <= matrix[x, i])
{
break;
}
}
return treeCount;
}
int TreeCountUp(int h, int x, int y)
{
int treeCount = 0;
for (int i = y - 1; i >= 0; --i)
{
treeCount++;
if (h <= matrix[x, i])
{
break;
}
}
return treeCount;
}
struct P
{
public int X;
public int Y;
public int Height;
}

BornToBeRoot · 8. Dezember 2022, 22:57

Tag 8 / PowerShell

Spoiler anzeigen

Quellcode

# https://adventofcode.com/2022/day/8
# Build input array
[System.Collections.ArrayList]$Row = @()
foreach ($Line in Get-Content -Path $PSScriptRoot\day08_input.txt) {
[System.Collections.ArrayList]$Column = @()
foreach ($Char in $Line.ToCharArray()) {
[void]$Column.Add([int]$Char.ToString())
}
[void]$Row.Add($Column)
}
# Ignore borders, so we can ignore the first and last row and column
# when iterating over the array
$VisibleTrees = ($Row.Count * 2) + ($Row[0].Count * 2) - 4
$TreeScenicScore = 0
# Go through each row
for ($i = 1; $i -lt $Row.Count - 1; $i++) {
# Go through each column
for ($y = 1; $y -lt $Row[$i].Count - 1; $y++) {
$CurrentTree = $Row[$i][$y]
Write-Host "Current tree is [$i,$y] with value $CurrentTree"
# Left
$LeftVisible = $true
$LeftCount = 0
foreach($l in $Row[$i][($y - 1)..0]) {
$LeftCount++
if ($l -ge $CurrentTree) {
$LeftVisible = $false
break
}
}
# Right
$RightVisible = $true
$RightCount = 0
foreach($r in $Row[$i][($y + 1)..$($Row[$y].Count)]) {
$RightCount++
if ($r -ge $CurrentTree) {
$RightVisible = $false
break
}
}
# Top
$TopVisible = $true
$TopCount = 0
foreach($t in $Row[($i - 1)..0]) {
$TopCount++
if($($t[$y]) -ge $CurrentTree) {
$TopVisible = $false
break
}
}
# Bottom
$BotVisible = $true
$BotCount = 0
foreach($b in $Row[($i + 1)..$($Row[$i].Count)]) {
$BotCount++
if($($b[$y]) -ge $CurrentTree) {
$BotVisible = $false
break
}
}
# Check if tree is visible
if ($LeftVisible -or $TopVisible -or $RightVisible -or $BotVisible) {
$VisibleTrees++
}
# Check scenic score
$CurrentTreeScenicScore = $TopCount * $LeftCount * $BotCount * $RightCount
if ($CurrentTreeScenicScore -gt $TreeScenicScore) {
$TreeScenicScore = $CurrentTreeScenicScore
}
}
}
Write-Host "Part 1: $VisibleTrees"
Write-Host "Part 2: $TreeScenicScore"

exc-jdbi · 9. Dezember 2022, 10:56

Day 5 to Day 9 and only the first task in each case.

Day05

C#-Quellcode

private static void Part01()
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static void move_operations(Stack<char>[] stack, int[] operation)
{
for (var i = 0; i < operation[0]; i++)
stack[operation[2] - 1].Push(stack[operation[1] - 1].Pop());
}
var stacks = SourceStacks();
var operations = Operations();
foreach (var op in operations)
move_operations(stacks, op);
Console.Write("message = ");
Array.ForEach(stacks, stc => Console.Write(stc.First()));
Console.WriteLine();
Console.ReadLine();
}

Sources

Day06

Day07

C#-Quellcode

private static void Part01()
{
var space = ToSpaceSource();
string command = string.Empty;
var currentdir = space.Root[0];
while (command.ToLower().Trim() != "$ exit" ||
command.ToLower().Trim() != "exit")
{
command = Console.ReadLine().ToLower().Trim();
if (command == "$ cls")
{
Console.Clear();
continue;
}
if (command.StartsWith("$"))
{
var cmd = command.Split(new[] { " ", "=" }, StringSplitOptions.RemoveEmptyEntries);
if (cmd[1] == "cd")
{
currentdir = cmd[2] switch
{
"/" => space.Root[0],
".." => currentdir?.Parent,
_ => space.SearchDirectory(cmd[2]),
};
continue;
}
if (cmd[1] == "ls")
{
if (currentdir is null)
currentdir = space.Root[0];
foreach (var dir in currentdir.Directories)
Console.WriteLine($"dir {dir.Name}");
foreach (var file in currentdir.Files)
Console.WriteLine($"{file.Size} {file.Name}");
continue;
}
if (cmd[1] == "dirsize")
{
if (currentdir is null)
currentdir = space.Root[0];
var size = 0;
Space.DirSize(currentdir, ref size);
Console.WriteLine($"dir {currentdir?.Name} dirsize = {size}");
continue;
}
if (cmd[1] == "assignment01")
{
if (currentdir is null)
currentdir = space.Root[0];
var spacesize = 0;
var folders = new List<DirectoryEx>();
if (cmd[2] == "min")
{
try
{
var sminsize = command.Split("min=", StringSplitOptions.RemoveEmptyEntries);
var minsize = int.Parse(sminsize[1]);
Space.FindFolderMin(currentdir, minsize, folders);
var size = 0;
foreach (var folder in folders)
{
size = 0;
Space.DirSize(folder, ref size);
spacesize += size;
}
Console.WriteLine($"Find {folders.Count} directory with total = {spacesize}");
}
catch { }
continue;
}
if (cmd[2] == "max")
{
try
{
var smaxsize = command.Split("max=", StringSplitOptions.RemoveEmptyEntries);
var maxsize = int.Parse(smaxsize[1]);
Space.FindFolderMax(currentdir, maxsize, folders);
var size = 0;
foreach (var folder in folders)
{
size = 0;
Space.DirSize(folder, ref size);
spacesize += size;
}
Console.WriteLine($"Find {folders.Count} directory with total = {spacesize}");
}
catch { }
continue;
}
}
}
}
}

Sources

C#-Quellcode

private static Space ToSpaceSource()
{
var src = Sources();
var rootname = src[0].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
var root = new DirectoryEx(rootname, null);
var result = new Space(root);
var dirname = src[1].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
var dir = new DirectoryEx(dirname, root);
result.Add(dir, root.Name);
result.Add(new DirectoryEx(src[2].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1], dir), dir.Name);
var filename = src[3].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
var filesize = int.Parse(src[3].Split(new[] { " ", "(", ")", "=", "," }, StringSplitOptions.RemoveEmptyEntries)[4]);
result.Add(new FileEx(filename, filesize), src[2].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1]);
filename = src[4].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
filesize = int.Parse(src[4].Split(new[] { " ", "(", ")", "=", "," }, StringSplitOptions.RemoveEmptyEntries)[4]);
result.Add(new FileEx(filename, filesize), dir.Name);
filename = src[5].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
filesize = int.Parse(src[5].Split(new[] { " ", "(", ")", "=", "," }, StringSplitOptions.RemoveEmptyEntries)[4]);
result.Add(new FileEx(filename, filesize), dir.Name);
filename = src[6].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
filesize = int.Parse(src[6].Split(new[] { " ", "(", ")", "=", "," }, StringSplitOptions.RemoveEmptyEntries)[4]);
result.Add(new FileEx(filename, filesize), dir.Name);
filename = src[7].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
filesize = int.Parse(src[7].Split(new[] { " ", "(", ")", "=", "," }, StringSplitOptions.RemoveEmptyEntries)[4]);
result.Add(new FileEx(filename, filesize), "/");
filename = src[8].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
filesize = int.Parse(src[8].Split(new[] { " ", "(", ")", "=", "," }, StringSplitOptions.RemoveEmptyEntries)[4]);
result.Add(new FileEx(filename, filesize), "/");
dirname = src[9].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
dir = new DirectoryEx(dirname, root);
result.Add(dir, root.Name);
filename = src[10].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
filesize = int.Parse(src[10].Split(new[] { " ", "(", ")", "=", "," }, StringSplitOptions.RemoveEmptyEntries)[4]);
result.Add(new FileEx(filename, filesize), dirname);
filename = src[11].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
filesize = int.Parse(src[11].Split(new[] { " ", "(", ")", "=", "," }, StringSplitOptions.RemoveEmptyEntries)[4]);
result.Add(new FileEx(filename, filesize), dirname);
filename = src[12].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
filesize = int.Parse(src[12].Split(new[] { " ", "(", ")", "=", "," }, StringSplitOptions.RemoveEmptyEntries)[4]);
result.Add(new FileEx(filename, filesize), dirname);
filename = src[13].Split(' ', StringSplitOptions.RemoveEmptyEntries)[1];
filesize = int.Parse(src[13].Split(new[] { " ", "(", ")", "=", "," }, StringSplitOptions.RemoveEmptyEntries)[4]);
result.Add(new FileEx(filename, filesize), dirname);
return result;
}
private static string[] Sources()
{
return new string[]
{
"- / (dir)",
" - a (dir)",
" - e (dir)",
" - i (file, size=584)",
" - f (file, size=29116)",
" - g (file, size=2557)",
" - h.lst (file, size=62596)",
" - b.txt (file, size=14848514)",
" - c.dat (file, size=8504156)",
" - d (dir)",
" - j (file, size=4060174)",
" - d.log (file, size=8033020)",
" - d.ext (file, size=5626152)",
" - k (file, size=7214296)"
};
}

Classes

C#-Quellcode

private class Space
{
public string Name { get; set; } = string.Empty;
public List<DirectoryEx> Root { get; set; } = new List<DirectoryEx>();
public Space(DirectoryEx directory, string name = "System")
{
this.Root.Add(directory);
this.Name = name is null ? "System" : name;
}
public void Add(DirectoryEx directory, string dirname)
{
var dir = this.SearchDirectory(dirname);
if (dir is not null) dir.Add(directory);
}
public void Add(FileEx file, string dirname)
{
var dir = this.SearchDirectory(dirname);
if (dir is not null) dir.Add(file);
}
public DirectoryEx? SearchDirectory(string dirname)
{
foreach (var dir in this.Root)
if (dirname.ToLower() == dir.Name.ToLower())
return dir;
foreach (var dir in this.Root)
{
var result = SearchDirectory(dir, dirname);
if (result is not null) return result;
}
return default;
}
public static void DirSize(DirectoryEx? directory, ref int spacesize)
{
if (directory is null) return;
spacesize += directory.Files.Sum(x => x.Size);
foreach (var dir in directory.Directories)
DirSize(dir, ref spacesize);
}
public static DirectoryEx? SearchDirectory(DirectoryEx directory, string dirname)
{
DirectoryEx? result = null;
if (directory.Name.ToLower() == dirname.ToLower()) return directory;
foreach (var dir in directory.Directories)
{
if (dir.Name.ToLower() == dirname.ToLower()) return dir;
result = SearchDirectory(dir, dirname);
if (result?.Name.ToLower() == dirname.ToLower()) return result;
}
return result;
}
public static void FindFolderMin(DirectoryEx? directory, int minsize, List<DirectoryEx> directories)
{
var spacesize = 0;
DirSize(directory, ref spacesize);
if (spacesize >= minsize && directory is not null)
directories.Add(directory);
if (directory?.Directories.Count() > 0)
foreach (var dir in directory.Directories)
FindFolderMin(dir, minsize, directories);
}
public static void FindFolderMax(DirectoryEx? directory, int maxsize, List<DirectoryEx> directories)
{
var spacesize = 0;
DirSize(directory, ref spacesize);
if (spacesize <= maxsize && directory is not null)
directories.Add(directory);
if (directory?.Directories.Count() > 0)
foreach (var dir in directory.Directories)
FindFolderMax(dir, maxsize, directories);
}
}
private class DirectoryEx
{
public DirectoryEx? Parent { get; set; }
public string Name { get; set; } = string.Empty;
public List<FileEx> Files { get; set; } = new List<FileEx>();
public List<DirectoryEx> Directories { get; set; } = new List<DirectoryEx>();
public DirectoryEx(string name, DirectoryEx? parent)
{
this.Name = name;
this.Parent = parent;
}
public void Add(DirectoryEx directory)
{
if (directory.Parent is null)
directory.Parent = this;
this.Directories.Add(directory);
}
public void Add(FileEx file)
{
this.Files.Add(file);
}
}
private class FileEx
{
public int Size { get; set; } = -1;
public string Name { get; set; } = string.Empty;
public FileEx(string name, int size)
{
this.Name = name;
this.Size = size;
}
}

Day08

C#-Quellcode

private static void Part01()
{
var src = Sources()
.Select(str => str
.Select(s => int.Parse(s.ToString()))
.ToArray())
.ToArray();
//In the beginning 16 trees are visible
var result = 2 * src.Length + 2 * (src.Length - 2);
for (var r = 1; r < src.Length - 1; r++)
for (var c = 1; c < src[r].Length - 1; c++)
{
if (FromTop(src, c, r)) { result += 1; continue; }
if (FromBottom(src, c, r)) { result += 1; continue; }
if (FromLeft(src, c, r)) { result += 1; continue; }
if (FromRigth(src, c, r)) { result += 1; continue; }
}
Console.WriteLine($"From outside are {result} trees visible.");
Console.WriteLine();
Console.ReadLine();
}
private static bool FromTop(int[][] grid, int x, int y)
{
var value = grid[x][y];
for (var i = y - 1; i >= 0; i--)
if (value <= grid[x][i])
return false;
return true;
}
private static bool FromBottom(int[][] grid, int x, int y)
{
var value = grid[x][y];
for (var i = y + 1; i < grid.Length; i++)
if (value <= grid[x][i])
return false;
return true;
}
private static bool FromLeft(int[][] grid, int x, int y)
{
var value = grid[x][y];
for (var i = x - 1; i >= 0; i--)
if (value <= grid[i][y])
return false;
return true;
}
private static bool FromRigth(int[][] grid, int x, int y)
{
var value = grid[x][y];
for (var i = x + 1; i < grid[x].Length; i++)
if (value <= grid[i][y])
return false;
return true;
}

Day 09

Würde auch ohne Adjacent-Liste (in der Klasse Tail) funktionieren. Der Code müsste leicht angepasst werden.

C#-Quellcode

private static void Part01()
{
var visittail = new List<Point>();
var head = new Head();
var tail = new Tail();
var cmds = CommandSource();
Console.WriteLine($"head = {head.Value}");
Console.WriteLine($"tail = {tail.Value}");
Console.WriteLine();
foreach (var cmd in cmds)
SetCommand(head, tail, cmd, visittail);
Console.WriteLine($"visite from tail: count = {visittail.Count}");
visittail.ForEach(xy => Console.WriteLine(xy));
Console.WriteLine();
Console.ReadLine();
}
private static void SetCommand(Head head, Tail tail, string command, List<Point> visittail)
{
Console.WriteLine($"command = {command}");
var tmp = command.Split(" ", StringSplitOptions.RemoveEmptyEntries);
var cmd = tmp[0][0];
var count = int.Parse(tmp[1]);
for (var i = 0; i < count; i++)
{
head.SetCommand(cmd);
tail.SetTail(head.Value);
Console.WriteLine($"head = {head.Value}; tail = {tail.Value}");
if (!visittail.Contains(tail.Value))
visittail.Add(tail.Value);
}
Console.WriteLine();
}

Classes

C#-Quellcode

private class Head
{
public Point Value = Point.Empty;
public Head() { }
public Head(Point start) { this.Value = start; }
public void SetCommand(char command)
{
switch (command)
{
case 'U': this.Value.Y = this.Value.Y + 1 ; return;
case 'D': this.Value.Y = this.Value.Y - 1 ; return;
case 'R': this.Value.X = this.Value.X + 1 ; return;
case 'L': this.Value.X = this.Value.X - 1 ; return;
}
}
}
private class Tail
{
private Point MValue = Point.Empty;
public Point Value
{
get => this.MValue;
set
{
this.MValue = value;
this.SetAdjacent();
}
}
public Point[] Adjacent { get; set; } = Array.Empty<Point>();
private decimal Sqrt5() => (decimal)Math.Sqrt(5.0);
public Tail()
{
this.Adjacent = new Point[8];
this.Value = Point.Empty;
}
public Tail(Point start):this()
{
this.Value = start;
}
public void SetTail(Point headvalue)
{
if (headvalue == this.MValue) return;
if (this.Adjacent.Contains(headvalue)) return;
var nf = this.NormalForm(headvalue);
if (nf == 2M || nf == this.Sqrt5())
this.Follow(headvalue);
}
private void Follow(Point headvalue)
{
var dif = this.Difference(headvalue);
switch (dif.X)
{
case 2:
this.MValue.Y = headvalue.Y;
this.MValue.X = headvalue.X - 1;
SetAdjacent();
return;
case -2:
this.MValue.Y = headvalue.Y;
this.MValue.X = headvalue.X + 1;
SetAdjacent();
return;
}
switch (dif.Y)
{
case 2:
this.MValue.X = headvalue.X;
this.MValue.Y = headvalue.Y - 1;
SetAdjacent();
return;
case -2:
this.MValue.X = headvalue.X;
this.MValue.Y = headvalue.Y + 1;
SetAdjacent();
return;
}
}
private void SetAdjacent()
{
int x = this.MValue.X, y = this.MValue.Y;
this.Adjacent[0].X = x - 1; this.Adjacent[0].Y = y - 1;
this.Adjacent[1].X = x; this.Adjacent[1].Y = y - 1;
this.Adjacent[2].X = x + 1; this.Adjacent[2].Y = y - 1;
this.Adjacent[3].X = x - 1; this.Adjacent[3].Y = y;
this.Adjacent[4].X = x + 1; this.Adjacent[4].Y = y;
this.Adjacent[5].X = x - 1; this.Adjacent[5].Y = y + 1;
this.Adjacent[6].X = x; this.Adjacent[6].Y = y + 1;
this.Adjacent[7].X = x + 1; this.Adjacent[7].Y = y + 1;
}
private decimal NormalForm(Point headvalue)
{
var dif = this.Difference(headvalue);
return (decimal)Math.Sqrt(dif.X * dif.X + dif.Y * dif.Y);
}
private Point Difference(Point headvalue)
{
var result = Point.Empty;
result.X = headvalue.X - this.MValue.X;
result.Y = headvalue.Y - this.MValue.Y;
return result;
}
}

nogood · 9. Dezember 2022, 21:36

Tag 9
Nach viel Nachdenken hab ich meiner Meinung nach eine ~~clevere~~ Lösung für Teil 1 gefunden.
2 Koordinatensysteme zusammen genutzt. Einmal ein ganz normales X-Achse/Y-Achse mit 0/0 im Ursprung etc. und noch ein 5x5 Kästchen-Block durchnummeriert von 0-24 wobei das 12te Kästchen dem Ursprung des X-Y Systems gleich ist (siehe Foto). Nach dem Spielzug ist T automatisch wieder auf ID = 12 und H wird mit dem entsprechenden Offset neu positioniert (siehe Code

). Mich schon gefreut, da Teil 2 ja meist einfacher war. Jetzt erstmal frustriert aufgehört. Teil 2 auf den ersten kurzen Blick => WallOfText.

AdventOfCode9.jpg

Teil 1 C#

Spoiler anzeigen

C#-Quellcode

using System.Drawing;
var Lines = File.ReadAllLines("CodeAdvent_9.txt");
int HeadId = 12;
Point T_Coordinate = new(0,0);
List<Point> TPoints = new();
foreach (var line in Lines)
{
var MoveCmd = line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < int.Parse(MoveCmd[1]); i++)
{
Move activMove = new (MoveCmd[0], HeadId, T_Coordinate);
T_Coordinate = activMove.T_Coordinate_AfterMove;
HeadId = activMove.HeadId_AfterMove;
TPoints.Add(T_Coordinate);
}
}
Console.WriteLine($"Nr of fileds T visited at leaset once: {TPoints.Distinct().Count()}");
class Move
{
public Move(string moveCmd, int headId_BeforeMove, Point t_coordinate_BeforeMove)
{
MoveCmd = moveCmd;
HeadId_BeforeMove = headId_BeforeMove;
T_Coordinate_BeforeMove = t_coordinate_BeforeMove;
MoveHead();
CheckIf_T_HasToMove();
}
private string MoveCmd { get; set; } = "";
private int HeadId_BeforeMove { get; set; } = 0;
public int HeadId_AfterMove { get; set; } = 0;
//T shall always be ID=12
private Point T_Coordinate_BeforeMove { get; set; } = new (0, 0);
public Point T_Coordinate_AfterMove { get; set; } = new(0, 0);
private int IdChangeBack_T_To12 = 0;
private void MoveHead()
{
switch (MoveCmd)
{
case "U":
HeadId_AfterMove = HeadId_BeforeMove - 5;
break;
case "D":
HeadId_AfterMove = HeadId_BeforeMove + 5;
break;
case "L":
HeadId_AfterMove = HeadId_BeforeMove - 1;
break;
case "R":
HeadId_AfterMove = HeadId_BeforeMove + 1;
break;
default:
break;
}
}
private void CheckIf_T_HasToMove()
{
if (new List<int> { 6, 7, 8, 11, 12, 13, 16, 17, 18 }.Contains(HeadId_AfterMove))
{//H stays in the 8 sourounding fields from T
T_Coordinate_AfterMove = T_Coordinate_BeforeMove;
IdChangeBack_T_To12 = 0;
}//No Change--------------
if (HeadId_AfterMove == 14)
{//2xRight
T_Coordinate_AfterMove = new Point(T_Coordinate_BeforeMove.X + 1, T_Coordinate_BeforeMove.Y);
IdChangeBack_T_To12 = - 1;
}
if (HeadId_AfterMove == 10)
{//2xLeft
T_Coordinate_AfterMove = new Point(T_Coordinate_BeforeMove.X - 1, T_Coordinate_BeforeMove.Y);
IdChangeBack_T_To12 = + 1;
}
if (HeadId_AfterMove == 2)
{//2xUp
T_Coordinate_AfterMove = new Point(T_Coordinate_BeforeMove.X, T_Coordinate_BeforeMove.Y + 1);
IdChangeBack_T_To12 = + 5;
}
if (HeadId_AfterMove == 22)
{//2xDown
T_Coordinate_AfterMove = new Point(T_Coordinate_BeforeMove.X, T_Coordinate_BeforeMove.Y - 1);
IdChangeBack_T_To12 = - 5;
}/////////////////////////////////////////////////////////
if (HeadId_AfterMove == 9 || HeadId_AfterMove == 3)
{//1xRight1xUp1xRight //1xRight1xUp1xUp
T_Coordinate_AfterMove = new Point(T_Coordinate_BeforeMove.X + 1, T_Coordinate_BeforeMove.Y + 1);
IdChangeBack_T_To12 = + 4;
}
if (HeadId_AfterMove == 19 || HeadId_AfterMove == 23)
{//1xRight1xDown1xRight
T_Coordinate_AfterMove = new Point(T_Coordinate_BeforeMove.X + 1, T_Coordinate_BeforeMove.Y - 1);
IdChangeBack_T_To12 = - 6 ;
}
if (HeadId_AfterMove == 5 || HeadId_AfterMove == 1)
{//1xLeft1xUp1xLeft
T_Coordinate_AfterMove = new Point(T_Coordinate_BeforeMove.X - 1, T_Coordinate_BeforeMove.Y + 1);
IdChangeBack_T_To12 = + 6;
}
if (HeadId_AfterMove == 15 || HeadId_AfterMove == 21)
{//1xLeft1xDown1xLeft
T_Coordinate_AfterMove = new Point(T_Coordinate_BeforeMove.X - 1, T_Coordinate_BeforeMove.Y - 1);
IdChangeBack_T_To12 = - 4;
}
//RESET GRIT: Finaly if T has moved -> move T and H back to Origin 0/0 --- T is auto back at 0/0 -- H has to keep its offset
HeadId_AfterMove += IdChangeBack_T_To12;
}
}

xChRoNiKx · 9. Dezember 2022, 22:02

Tag 09 - C# - Part 1 und 2:

Spoiler anzeigen

Ich hatte für Teil 1 die innere For für die Tails nicht und hatte nachdem ich teil 1 fertig gemacht habe dann einfach direkt alles in eine schleife gepackt.
Man könnte natürlich auch 2 getrennte schleifen machen aber so ist das alles in einem. Geht sicherlich noch etwas eleganter.
Am meisten Zeit hat mich tatsächlich gekostet wie ich hier ein ordentlichen Datentyp bekomme den ich NICHT vorher irgendwie festlegen muss wie groß er ist ( für X und Y ).
Irgendwann ist der Groschen gefallen das es doch den Point gibt der genau das macht. Gibt es noch andere Datentypen?
Bin offen für Vorschläge da mich das hier zum lösen des ersten Teils echt etwas kopfweh gemacht hat doch der 2 Part dann recht einfach war.

C#-Quellcode

using System.Drawing;
string[] lines = File.ReadAllLines("Input.txt");
Point Head = Point.Empty;
int TailCount = 9;
Point[] Tails = new Point[TailCount];
List<Point> VisitedPointsFirstTail = new List<Point>();
List<Point> VisitedPointsLastTail = new List<Point>();
for (int i = 0; i < TailCount; i++)
{
Tails[i] = Point.Empty;
}
foreach (string line in lines)
{
string[] parts = line.Split(' ');
Point MoveTo = Point.Empty;
MoveTo = parts[0] switch
{
"R" => new Point(1, 0),
"L" => new Point(-1, 0),
"D" => new Point(0, -1),
"U" => new Point(0, 1)
};
int Movements = Int32.Parse(parts[1]);
for (int i = 0; i < Movements; i++)
{
Head.X += MoveTo.X;
Head.Y += MoveTo.Y;
for (int counter = 0; counter < TailCount; counter++)
{
int distanceToLastKnotX = 0;
int distanceToLastKnotY = 0;
if(counter == 0)
{
distanceToLastKnotX = Head.X - Tails[counter].X;
distanceToLastKnotY = Head.Y - Tails[counter].Y;
} else
{
distanceToLastKnotX = Tails[counter -1 ].X - Tails[counter].X;
distanceToLastKnotY = Tails[counter -1 ].Y - Tails[counter].Y;
}
if (Math.Abs(distanceToLastKnotX) > 1 || Math.Abs(distanceToLastKnotY) > 1)
{
int absoluteX = Math.Sign(distanceToLastKnotX);
int absoluteY = Math.Sign(distanceToLastKnotY);
Tails[counter].X += absoluteX;
Tails[counter].Y += absoluteY;
}
}
VisitedPointsFirstTail.Add(Tails[0]);
VisitedPointsLastTail.Add(Tails[TailCount - 1]);
}
}
Console.WriteLine($"Part 1 First Tail: {VisitedPointsFirstTail.Distinct().Count()}");
Console.WriteLine($"Part 2 Last Tail: {VisitedPointsLastTail.Distinct().Count()}");

BornToBeRoot · 10. Dezember 2022, 05:13

Tag 9 / PowerShell

Spoiler anzeigen

Quellcode

# https://adventofcode.com/2022/day/9
# Repeat for each part
foreach ($Part in @(2, 10)) {
# Init hash set for positions
[System.Collections.Generic.HashSet[String]]$Positions = @()
# Init array list with knots
[System.Collections.ArrayList]$Knots = @()
for ($i = 0; $i -lt $Part; $i++) {
[void]$Knots.Add([pscustomobject]@{
Y = 0
X = 0
})
}
# Go through each line in input file
foreach ($Line in Get-Content -Path $PSScriptRoot\day09_input.txt) {
$LineValues = $Line.Split(" ")
# Set direction to move
$Y = 0
$X = 0
switch ($LineValues[0]) {
"R" { $X = 1 }
"L" { $X = -1 }
"U" { $Y = 1 }
"D" { $Y = -1 }
}
# Repeat movement for number of steps
for ($n = 0; $n -lt [int]$LineValues[1]; $n++) {
$Knots[0].Y = $Knots[0].Y + $Y
$Knots[0].X = $Knots[0].X + $X
# Update position for each knot
for ($i = 1; $i -lt $Knots.Count; $i++) {
$DiffY = $Knots[$i - 1].Y - $Knots[$i].Y
$DiffX = $Knots[$i - 1].X - $Knots[$i].X
if ([Math]::Abs($DiffX) -gt 1 -or [Math]::Abs($DiffY) -gt 1) {
$Knots[$i].X = $Knots[$($i)].X + [Math]::Sign($DiffX)
$Knots[$i].Y = $Knots[$($i)].Y + [Math]::Sign($DiffY)
}
}
# Add last knot to hash set
[void]$Positions.Add("[$($Knots[$($Knots.Count-1)].Y),$($Knots[$($Knots.Count-1)].X)]")
}
}
# Result
Write-Host "Part $Part result: $($Positions.Count)"
}

exc-jdbi · 10. Dezember 2022, 08:25

Day10

C#-Quellcode

private static void Part01()
{
var instructions = Source();
var cycle = 0;
var value = 1; //start
var check_cycle = 20;
var check_cycle_step = 40;
var sum_signal_strength = 0;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static void to_signal_strength(
int signal_strength, int cycle, ref int sum_signal_strength,
ref int check_cycle, int check_cycle_step = 40)
{
Console.WriteLine($"cycle: {cycle};\tsignal strength = {signal_strength}");
sum_signal_strength += signal_strength;
check_cycle += check_cycle_step;
}
foreach (var instruction in instructions)
{
if (instruction.StartsWith("noop"))
{
cycle++;
if (cycle == check_cycle)
to_signal_strength(value * cycle, cycle, ref sum_signal_strength, ref check_cycle, check_cycle_step);
continue;
}
if (instruction.StartsWith("addx"))
{
var splitvalue = int.Parse(instruction.Split(" ")[1]);
for (var i = 0; i < 2; i++)
{
cycle++;
if (cycle == check_cycle)
to_signal_strength(value * cycle, cycle, ref sum_signal_strength, ref check_cycle, check_cycle_step);
}
value += splitvalue;
}
}
Console.WriteLine();
Console.WriteLine($"sum of signal strengths is {sum_signal_strength}");
Console.WriteLine();
Console.ReadLine();
}

Optimation

nogood · 10. Dezember 2022, 09:48

Tag 10

Teil 1 C#

Spoiler anzeigen

Teil 2 C# (im Moment versteh ich die Frage nicht)

SpaceyX · 10. Dezember 2022, 15:00

Day 10 Part 1 & Part 2 (war ne schöne Aufgabe)

Spoiler anzeigen

C#-Quellcode

namespace Ten;
using System.Diagnostics;
public class Program
{
static List<Op> Ops = new();
static CRT crt = new();
static int X = 1;
static void Main(string[] args)
{
IEnumerable<string> data = File.ReadLines("input.txt");
for (int i = 0; i < data.Count(); i++)
{
var elements = data.ElementAt(i).SplitBy(" ");
string opCode = elements.ElementAt(0);
int value = elements.Count() > 1 ? int.Parse(elements.ElementAt(1)) : 0;
Ops.Add(new Op(opCode, value));
}
int cycle = 1;
//Für part 1
// int result = 0;
crt.SetX(X);
while (true)
{
Op current = Ops.First();
current.Cycles--;
crt.DrawPixel(cycle);
//Für part 1
// if (cycle == 20 || cycle == 60 || cycle == 100 || cycle == 140 || cycle == 180 | cycle == 220)
// result += cycle * X;
if (current.Cycles == 0)
{
X += current.Value; //noop has value 0, so its ok.
crt.SetX(X);
Ops.RemoveAt(0);
}
cycle++;
if (Ops.Count == 0)
{
//Für part 1
// Log($"Execution finished, result={result}");
crt.Output();
break;
}
}
}
static void Log(string message) => Console.WriteLine(message);
}
public static class Extensions
{
public static IEnumerable<string> SplitBy(this string s, string d, bool keepEmpty = false)
{
if (keepEmpty)
return s.Split(new string[] { d }, StringSplitOptions.None);
else
return s.Split(new string[] { d }, StringSplitOptions.RemoveEmptyEntries);
}
}
class Op
{
public string OpCode { get; set; }
public int Value { get; set; }
public int Cycles { get; set; }
public Op(string opCode, int value)
{
this.OpCode = opCode;
this.Value = value;
if (opCode == "noop") this.Cycles = 1;
if (opCode == "addx") this.Cycles = 2;
}
public override string ToString() => $"{this.OpCode} {this.Value}";
}
class CRT
{
private string _display = string.Empty;
private List<int> _pixelPositions = new();
private int _position = 0;
public void DrawPixel(int cycle)
{
if (_pixelPositions.Contains(_position))
_display += "#";
else
_display += ".";
_position++;
if (cycle % 40 == 0)
{
_display += "\n";
_position = 0;
}
}
public void SetX(int x)
{
_pixelPositions.Clear();
_pixelPositions.AddRange(new int[] { x - 1, x, x + 1 });
}
public void Output() => Console.WriteLine(_display);
}

xChRoNiKx · 10. Dezember 2022, 19:35

C# Tag 10 Part 1 und 2 zusammen

Spoiler anzeigen

C#-Quellcode

string[] instructions = File.ReadAllLines("Input.txt");
int X = 1;
int cyclesDone = 0;
int crtCycle = 1;
List<int> whenToCheckSignalStrength = new List<int>() { 20, 60, 100, 140, 180, 220 };
List<int> signalStrenthChecks = new List<int>();
Console.WriteLine("Part 2 Output:");
foreach (string instruction in instructions)
{
int cyclesNeeded = 0;
string[] instructionParts = instruction.Split(' ');
if (instructionParts[0].StartsWith("noop"))
{
cyclesNeeded = 1;
}
if (instructionParts[0].StartsWith("addx"))
{
cyclesNeeded = 2;
}
for (int i = 0; i < cyclesNeeded; i++)
{
if(crtCycle -1 >= X - 1 && crtCycle -1 <= X + 1)
{
Console.Write("#");
} else
{
Console.Write(".");
}
if(crtCycle % 40 == 0 && crtCycle != 0)
{
Console.Write(Environment.NewLine);
crtCycle = 0;
}
cyclesDone++;
crtCycle++;
if (whenToCheckSignalStrength.Contains(cyclesDone))
{
signalStrenthChecks.Add(cyclesDone * X);
}
if (i == cyclesNeeded - 1)
{
if (instructionParts.Length > 1)
{
X += Int32.Parse(instructionParts[1]);
}
}
}
}
Console.WriteLine($"Part 1: {signalStrenthChecks.Sum()} ");

exc-jdbi · 11. Dezember 2022, 10:09

Day11

C#-Quellcode

private static void Part01()
{
var rounds = 20;
var worry_factor = 3;
var monkeys = MonkeySource();
for (var i = 0; i < rounds; i++)
{
foreach (var monkey in monkeys)
{
var count = monkey.Items.Count;
for (var j = 0; j < count; j++)
{
var itm = monkey.Items.Dequeue();
int worry_level = 0;
var opn = monkey.OperationNumber != 0 ? monkey.OperationNumber : itm;
switch (monkey.Operation)
{
case Operation.A: worry_level = itm + opn; break;
case Operation.S: worry_level = itm - opn; break;
case Operation.M: worry_level = itm * opn; break;
case Operation.D: worry_level = itm / opn; break;
}
worry_level /= worry_factor;
if (worry_level % monkey.DivisibleNumber == 0)
monkeys[monkey.DivisibleTrueId].Items.Enqueue(worry_level);
else monkeys[monkey.DivisibleFalseId].Items.Enqueue(worry_level);
monkey.InspectedItems++;
}
}
}
var monkeyssort = monkeys.OrderByDescending(x=>x.InspectedItems).ToArray();
var monkey_business = monkeyssort[0].InspectedItems * monkeyssort[1].InspectedItems;
Console.WriteLine($"monkey business after {rounds} is {monkey_business}");
Console.WriteLine();
Console.ReadLine();
}

Sources

C#-Quellcode

private static Monkey[] MonkeySource()
{
var id = 0;
var result = new List<Monkey>();
Operation op = Operation.A;
int opnumber = 0, divnumber = 0, trueid = 0, falseid = 0;
foreach (var line in Source())
{
if (line.StartsWith("Monkey"))
{
result.Add(new Monkey(id++));
continue;
}
if (line.Contains("Starting"))
{
var split = line.Split(new[] { " ", ":", "," }, StringSplitOptions.RemoveEmptyEntries);
if (split is null) continue;
var monkey = result.Last();
for (var i = 2; i < split.Length; i++)
monkey.Items.Enqueue(int.Parse(split[i]));
continue;
}
if (line.Contains("Operation"))
{
var split = line.Split(new[] { " ", ":", "=" }, StringSplitOptions.RemoveEmptyEntries);
if (split is null) continue;
switch (split[3][0])
{
case '+': op = Operation.A; break;
case '-': op = Operation.S; break;
case '*': op = Operation.M; break;
case '/': op = Operation.D; break;
}
if (int.TryParse(split[4], out int opn))
opnumber = opn;
else opnumber = 0;
continue;
}
if (line.Contains("Test"))
{
var split = line.Split(new[] { " ", ":" }, StringSplitOptions.RemoveEmptyEntries);
divnumber = int.Parse(split.Last());
continue;
}
if (line.Contains("true: throw"))
{
var split = line.Split(new[] { " ", ":" }, StringSplitOptions.RemoveEmptyEntries);
trueid = int.Parse(split.Last());
continue;
}
if (line.Contains("false: throw"))
{
var split = line.Split(new[] { " ", ":" }, StringSplitOptions.RemoveEmptyEntries);
falseid = int.Parse(split.Last());
if (result.Count > 0)
result.Last().SetParameters(op, opnumber, divnumber, trueid, falseid);
}
}
return result.ToArray();
}
private static string[] Source()
{
return new string[]
{
"Monkey 0:",
" Starting items: 79, 98",
" Operation: new = old * 19",
" Test: divisible by 23",
" If true: throw to monkey 2",
" If false: throw to monkey 3",
"Monkey 1:",
" Starting items: 54, 65, 75, 74",
" Operation: new = old + 6",
" Test: divisible by 19",
" If true: throw to monkey 2",
" If false: throw to monkey 0",
"Monkey 2:",
" Starting items: 79, 60, 97",
" Operation: new = old * old",
" Test: divisible by 13",
" If true: throw to monkey 1",
" If false: throw to monkey 3",
"Monkey 3:",
" Starting items: 74",
" Operation: new = old + 3",
" Test: divisible by 17",
" If true: throw to monkey 0",
" If false: throw to monkey 1"
};
}

Classes

Optimation

C#-Quellcode

private static void Part01_Optimation()
{
var rounds = 20;
var worry_factor = 3;
var monkeys = MonkeyOptSource();
for (var i = 0; i < rounds; i++)
foreach (var monkey in monkeys)
{
var count = monkey[1].Count;
for (var j = 0; j < count; j++)
{
int worry_level = 0;
var itm = monkey[1][0];
monkey[1].RemoveAt(0);
var opn = monkey[0][2] != 0 ? monkey[0][2] : itm;
switch ((Operation)monkey[0][1])
{
case Operation.A: worry_level = itm + opn; break;
case Operation.S: worry_level = itm - opn; break;
case Operation.M: worry_level = itm * opn; break;
case Operation.D: worry_level = itm / opn; break;
}
worry_level /= worry_factor;
if (worry_level % monkey[0][3] == 0)
monkeys[monkey[0][4]][1].Add(worry_level);
else monkeys[monkey[0][5]][1].Add(worry_level);
monkey[0][6]++;
}
}
var monkeyssort = monkeys.OrderByDescending(x => x[0][6]).ToArray();
var monkey_business = (ulong)monkeyssort[0][0][6] * (ulong)monkeyssort[1][0][6];
Console.WriteLine($"monkey business after {rounds} rounds is {monkey_business}");
Console.WriteLine();
Console.ReadLine();
}

Source

xChRoNiKx · 11. Dezember 2022, 15:14

Tag 11 C# - Part 1 und 2 in einem. Mehr dazu im Spoiler

Spoiler anzeigen

Kleine andere Frage dazu: WARUM kann ich nicht eine Liste für beide Aufrufe nutzen?
Wenn ich in der Function SolvePuzzle etwas ändere an der Liste innerhalb dann verändert dies meine Liste von außerhalb. Ich hatte was gelesen von reference typen die nicht gecopy'd werden.
Wie kann ich das verhindern? Das Problem ist mir jetzt seit mehreren Jahren C# noch nie untergekommen da ich meist immer eine Liste habe und diese auch verändern muss nur hier müsste ich ja mit einer Liste 2x eine Funktion mit anderen
Parametern ausführen und da darf sich natürlich die Quellliste nicht ändern.

Anfangs hatte ich mit LONG gearbeitet und nicht verstanden warum mein Ergebnis für Part 2 falsch ist. Gemerkt habe ich dann das Long wohl nicht ausreicht.
Also habe ich dann BigInteger genommen. Problem -> Nach 3 Minuten rechnen war ich noch in Runde 900 ca.
Irgendwie Multithreading geht ja nicht da die Operationen ja schon nacheinander ausgeführt werden müssen und nicht gleichzeitig laufen können.
Dann eine Erkenntnis alle Zahlen mit denen ich teilen muss für das testen sind Primzahlen.
Das heißt ich kann alle Primzahlen zusammen multiplizieren und dann das aktuelle WorryLevel modulo dieser zusammen multiplizierten Primzahl nehmen.
So arbeite ich mit kleineren zahlen und alles ist schneller... Jetzt braucht das ganze nur ein paar Sekunden statt vorher wahrscheinlich Stunden.
Wahrscheinlich kann ich jetzt dann auch wieder mit Long arbeiten allerdings hatte ich jetzt keine Lust mehr das zu ändern. Hauptsache gelöst.
Geht sicher auch eleganter.

C#-Quellcode

using System.Numerics;
List<Monkey> LMonkeys = File.ReadAllLines("Input.txt").Chunk(7).Select(m => new Monkey(m)).ToList();
List<Monkey> LMonkeys2 = File.ReadAllLines("Input.txt").Chunk(7).Select(m => new Monkey(m)).ToList();
BigInteger part1 = SolvePuzzle(LMonkeys, 20).OrderByDescending(x => x.InspectedItems).Take(2).Select(x => x.InspectedItems).Aggregate((current, next) => current * next);
BigInteger part2 = SolvePuzzle(LMonkeys2, 10000, false).OrderByDescending(x => x.InspectedItems).Take(2).Select(x => x.InspectedItems).Aggregate((current, next) => current * next);
Console.WriteLine($"Part 1: {part1}");
Console.WriteLine($"Part 2: {part2}");
List<Monkey> SolvePuzzle(List<Monkey> originalMonkeys, int rounds, bool isPart1 = true)
{
BigInteger mod = 1;
List<Monkey> monkeys = originalMonkeys;
foreach (Monkey monkey in monkeys)
{
mod *= monkey.CheckingDivisor;
}
for (int i = 1; i < rounds +1; i++)
{
for (int monkeyNumber = 0; monkeyNumber < monkeys.Count; monkeyNumber++)
{
if (monkeys[monkeyNumber].Items.Count == 0) continue;
for (int itemNumber = 0; itemNumber < monkeys[monkeyNumber].Items.Count; itemNumber++)
{
BigInteger newItemWorryLevel = monkeys[monkeyNumber].CalculateNewWorryLevel(monkeys[monkeyNumber].Items[itemNumber] % mod);
if (isPart1)
{
newItemWorryLevel = newItemWorryLevel / monkeys[monkeyNumber].MonkeyBoredDivisor;
}
if (newItemWorryLevel % monkeys[monkeyNumber].CheckingDivisor == 0)
{
monkeys[monkeys[monkeyNumber].IfTrueThrowTo].Items.Add(newItemWorryLevel);
}
else
{
monkeys[monkeys[monkeyNumber].IfFalseThrowTo].Items.Add(newItemWorryLevel);
}
}
monkeys[monkeyNumber].InspectedItems += monkeys[monkeyNumber].Items.Count;
monkeys[monkeyNumber].Items.Clear();
}
if (i % 1000 == 0 || i == 1 || i == 20)
{
Console.WriteLine($"== After round {i} ==");
for (int m = 0; m < monkeys.Count; m++)
{
Console.WriteLine($"Monkey {m} inspected items {monkeys[m].InspectedItems} times.");
}
}
}
return monkeys;
}
public class Monkey
{
public List<BigInteger> Items { get; set; } = new List<BigInteger>();
public BigInteger CheckingDivisor { get; set; }
public int MonkeyBoredDivisor { get; set; } = 3;
public int IfTrueThrowTo { get; set; }
public int IfFalseThrowTo { get; set; }
public BigInteger InspectedItems { get; set; } = 0;
private string Operant = "";
private string WorryLevelToAdd = "";
public Monkey(string[] monkeyPropertys)
{
Items.AddRange(monkeyPropertys[1].Split(':')[1].Split(',').Select(i => BigInteger.Parse(i.Trim())));
CheckingDivisor = BigInteger.Parse(monkeyPropertys[3].Replace(" Test: divisible by ",""));
IfTrueThrowTo = Int32.Parse(monkeyPropertys[4].Replace(" If true: throw to monkey ", ""));
IfFalseThrowTo = Int32.Parse(monkeyPropertys[5].Replace(" If false: throw to monkey ", ""));
string[] operations = monkeyPropertys[2].Replace(" Operation: new = ", "").Split(' ');
Operant = operations[1];
WorryLevelToAdd = operations[2];
}
public BigInteger CalculateNewWorryLevel(BigInteger worryLevel)
{
BigInteger secondNumber = 0;
if (WorryLevelToAdd.Contains("old"))
{
secondNumber = worryLevel;
} else
{
secondNumber = BigInteger.Parse(WorryLevelToAdd);
}
return Operant switch
{
"*" => worryLevel * secondNumber,
"/" => worryLevel / secondNumber,
"+" => worryLevel + secondNumber,
"-" => worryLevel - secondNumber,
};
}
}

nogood · 11. Dezember 2022, 19:00

Tag 11

Teil 1 C#

Spoiler anzeigen

C#-Quellcode

#region Main
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
var Lines = File.ReadAllLines("CodeAdvent_11T.txt");
List<Monkey> Monkeys = new();
var rounds = 20;
for (int i = 0; i < Lines.Count(); i++)
{
if (Regex.IsMatch(Lines[i], @"Monkey"))
{//Create Obj Monkey from input.txt add to List
var id = int.Parse(Regex.Match(Lines[i], @"\d+").Value);
var itemsMatches = Regex.Matches(Lines[i + 1], @"\d+").ToList();
List<long> items = new();
foreach (var item in itemsMatches)
{
items.Add(int.Parse(item.Value));
}
var isMultiply = Regex.IsMatch(Lines[i + 2], @"\*");
var operatorFactor = Lines[i + 2].Split(' ').Last();
var divisor = int.Parse(Regex.Match(Lines[i + 3], @"\d+").Value);
var targetMonkeyId_True = int.Parse(Regex.Match(Lines[i + 4], @"\d+").Value);
var targetMonkeyId_False = int.Parse(Regex.Match(Lines[i + 5], @"\d+").Value);
Monkeys.Add(new Monkey(id, items, isMultiply, operatorFactor, divisor, targetMonkeyId_True, targetMonkeyId_False));
}
}
for (int i = 0; i < rounds; i++)
{
foreach (var m in Monkeys)
{
var throwObjs = m.InspectItemThrowTo();
foreach (var item in throwObjs)
{
var targetMonkey = Monkeys.Where(x => x.Id == item.TargetMonkeyIds).First();
targetMonkey.Items.Add(item.Item);
}
}
}
foreach (var m in Monkeys)
{
Console.WriteLine(m.InspectionCount);
}
var res = Monkeys.OrderBy(x => x.InspectionCount).ToList();
res.Reverse();
Console.WriteLine($"\n{res[0].InspectionCount * res[1].InspectionCount}");
#endregion ^^Main
#region Classes
class Monkey
{
public Monkey(int id, List<long> items, bool isMultiply, string operationFactor, int divisor, int targetMonkeyId_True, int targetMonkeyId_False)
{
Id = id;
Items = items;
IsMultiply = isMultiply;
OperationFactor = operationFactor;
Divisor = divisor;
TargetMonkeyId_True = targetMonkeyId_True;
TargetMonkeyId_False = targetMonkeyId_False;
}
public int Id { get; set; } = 0;
public List<long> Items { get; set; } = new();
private bool IsMultiply { get; set; } = false;
private string OperationFactor { get; set; } = string.Empty;
private int Divisor { get; set; } = 0;
private int TargetMonkeyId_True { get; set; } = 0;
private int TargetMonkeyId_False { get; set; } = 0;
public long InspectionCount { get; set; } = 0;
public List<MonkeyTarget> InspectItemThrowTo()
{
List<MonkeyTarget> monkeyTargets = new();
foreach (var item in Items)
{
long factor = 0;
if (OperationFactor == "old")
factor = item;
else
factor = int.Parse(OperationFactor);
decimal worryValue = IsMultiply ? item * factor : item + factor;
var newWorryValue = (int)Math.Floor(worryValue / 3);
//long newWorryValue = IsMultiply ? item * factor : item + factor;
////das geht bis 1000 Runden dann falsche Werte
if (newWorryValue % Divisor == 0)
{
monkeyTargets.Add(new(TargetMonkeyId_True, newWorryValue));
}
else
{
monkeyTargets.Add(new(TargetMonkeyId_False, newWorryValue));
}
InspectionCount++;
}
Items.Clear();
return monkeyTargets;
}
}
class MonkeyTarget
{
public MonkeyTarget(int targetMonkeyIds, long item)
{
TargetMonkeyIds = targetMonkeyIds;
Item = item;
}
public int TargetMonkeyIds { get; set; } = 0;
public long Item { get; set; } = 0;
}
#endregion Classes

Teil 2# (bis 1000 Runden geht alles noch dann werden die Zahlen zu groß)

@xChRoNiKx So wie ich deine Zusatzfrage verstanden habe, hast Du die Antwort schon gefunden. Listen sind ReferenceType und im Speicher liegen an der Adresse die Daten. Egal wie häufig Du die kopierst etc. Es gibt denke ich keinen einfachen Weg das zu umgehen, ala AsValue.
Hab es selber nochmal probiert:

Spoiler anzeigen

C#-Quellcode

List<Kunde> Kunden1 = new List<Kunde>
{
new("Anton"),
new("Bernd"),
new("Cecil"),
new("Donna"),
new("Ernie")
};
List<Kunde> Kunden2 = new();
Kunden2 = Kunden1;
foreach (var k in Kunden1)
{
Console.WriteLine(k.Name);
}
//List 3 wird nicht geändert
List<Kunde> Kunden3 = new();
foreach (var k in Kunden1)
{
Kunden3.Add(k);
}
ChangeLists(Kunden2);
Console.WriteLine($"\n----List1 ist auch reverse----");
foreach (var k in Kunden1)
{
Console.WriteLine(k.Name);
}
Console.WriteLine("-----------");
foreach (var k in Kunden2)
{
Console.WriteLine(k.Name);
}
Console.WriteLine("-----------");
foreach (var k in Kunden3)
{
Console.WriteLine(k.Name);
}
Console.WriteLine("-----------");
//Methode
void ChangeLists(List<Kunde> kunden)
{
kunden.Reverse();
}
///Class
class Kunde
{
public Kunde(string name)
{
Name = name;
}
public Guid Id { get; set; } = Guid.NewGuid();
public string Name { get; set; } = string.Empty;
}

Output:

Spoiler anzeigen

BornToBeRoot · 11. Dezember 2022, 22:51

Tag 10 / PowerShell

Spoiler anzeigen

Quellcode

# https://adventofcode.com/2022/day/10
$X = 1
$Loops = 0
$CyclesToCheck = @(20, 60, 100, 140, 180, 220)
[System.Collections.ArrayList]$SignalStrengths = @()
function LoopAction() {
# Part 1
if ($CyclesToCheck.Contains($Loops)) {
[void]$SignalStrengths.Add($Loops * $X)
}
# Part 2
$CrtPixel = ($Loops - 1) % 40
$PrintValue = "."
if ([Math]::Abs($CrtPixel - $X) -lt 2) {
$PrintValue = "X"
}
Write-Host $PrintValue -NoNewline
if ($CrtPixel -eq 39) {
Write-Host ""
}
}
foreach ($Line in Get-Content $PSScriptRoot\input.txt) {
$LineValues = $Line.Split(" ")
if ($LineValues[0] -eq "noop") {
$Loops++
LoopAction
continue
}
if ($LineValues[0] -eq "addx") {
for ($i = 0; $i -lt 2; $i++) {
$Loops++
LoopAction
if ($i -eq 0) { continue }
$X += [Int]::Parse($LineValues[1])
}
}
}
# Part 1
Write-Host "Part 1: $(($SignalStrengths | Measure-Object -Sum).Sum)"

Tag 11 / PowerShell

Part 1

Spoiler anzeigen

Quellcode

# https://adventofcode.com/2022/day/11
$Text = Get-Content -Path $PSScriptRoot\input.txt
[System.Collections.ArrayList]$Monkeys = @()
<#
Example monkey in the list:
Monkey : 0
Items : {79, 98}
Operation : *,19
Test : 23
NextMonkeyTrue : 2
NextMonkeyFalse : 3
#>
for($i = 0; $i -lt $Text.Count; $i += 7) {
[System.Collections.ArrayList]$Items = @()
$($Text[$i+1].Trim().Split(":")[1].Replace(" ","").Split(",")) | ForEach-Object { [void]$Items.Add([int]$_) }
[void]$Monkeys.Add([pscustomobject]@{
Monkey = $Text[$i].Trim().Split(" ")[1].Split(":")[0]
Items = $Items
Operation = $Text[$i+2].Trim().Split("=")[1].Trim().Split(" ")[1..2] -join ","
Test = [int]$($Text[$i+3].Trim().Split(" ")[3])
NextMonkeyTrue = [int]$($Text[$i+4].Trim().Split(" ")[5])
NextMonkeyFalse = [int]$($Text[$i+5].Trim().Split(" ")[5])
Inspected = 0
})
}
for($i = 0; $i -lt 20; $i++) {
foreach($Monkey in $Monkeys) {
$Operations = $Monkey.Operation.Split(",")
foreach($Item in $Monkey.Items) {
$Monkey.Inspected++
$OperationValue = $Operations[1]
if($OperationValue -eq "old") {
$OperationValue = $Item
}
switch($Operations[0]) {
"+" { $Result = $Item + $OperationValue }
"*" { $Result = $Item * $OperationValue }
}
$NewWorryLevel = [Math]::Floor($Result / 3)
$NewMonkey = $NewWorryLevel%$Monkey.Test -eq 0 ? $Monkey.NextMonkeyTrue : $Monkey.NextMonkeyFalse
[void]$Monkeys[$NewMonkey].Items.Add($NewWorryLevel)
}
$Monkey.Items.Clear()
}
}
$MonkeysInspected = ($Monkeys.Inspected | Sort-Object -Descending)[0..1]
Write-Host "Part 1: $($MonkeysInspected[0] * $MonkeysInspected[1])"

Part 2

Für die Berechnung des Worry Levels gibt es hier eine sehr gute Erklärung: reddit.com/r/adventofcode/comm…tm_medium=web2x&context=3

Spoiler anzeigen

Quellcode

# https://adventofcode.com/2022/day/11
function Gcd($a, $b) {
if ($a -eq 0) { $b }
elseif ($b -eq 0) { $a }
else { Gfc -a ($b % $a) -b $a }
}
function Lcm($a, $b) {
($a * $b) / $(Gcd -a $a -b $b)
}
$Text = Get-Content -Path $PSScriptRoot\input.txt
[System.Collections.ArrayList]$Monkeys = @()
<#
Example monkey in the list:
Monkey : 0
Items : {79, 98}
Operation : *,19
Test : 23
NextMonkeyTrue : 2
NextMonkeyFalse : 3
#>
for ($i = 0; $i -lt $Text.Count; $i += 7) {
[System.Collections.ArrayList]$Items = @()
$($Text[$i + 1].Trim().Split(":")[1].Replace(" ", "").Split(",")) | ForEach-Object { [void]$Items.Add([int64]$_) }
[void]$Monkeys.Add([pscustomobject]@{
Monkey = $Text[$i].Trim().Split(" ")[1].Split(":")[0]
Items = $Items
Operation = $Text[$i + 2].Trim().Split("=")[1].Trim().Split(" ")[1..2] -join ","
Test = [int]$($Text[$i + 3].Trim().Split(" ")[3])
NextMonkeyTrue = [int]$($Text[$i + 4].Trim().Split(" ")[5])
NextMonkeyFalse = [int]$($Text[$i + 5].Trim().Split(" ")[5])
Inspected = 0
})
}
# Get the Least Common Multiple of all monkeys
$LCM = $Monkeys[0].Test
for ($i = 1; $i -lt $Monkeys.Count; $i++) {
$LCM = Lcm -a $LCM -b $Monkeys[$i].Test
}
for ($i = 0; $i -lt 10000; $i++) {
foreach ($Monkey in $Monkeys) {
$Operations = $Monkey.Operation.Split(",")
foreach ($Item in $Monkey.Items) {
$Monkey.Inspected++
$OperationValue = $Operations[1]
if ($OperationValue -eq "old") {
$OperationValue = $Item
}
switch ($Operations[0]) {
"+" { $Result = $Item + $OperationValue }
"*" { $Result = $Item * $OperationValue }
}
# Mod by the LCM to get the new worry level and keep the number low
$NewWorryLevel = $Result % $LCM
$NewMonkey = $NewWorryLevel % $Monkey.Test -eq 0 ? $Monkey.NextMonkeyTrue : $Monkey.NextMonkeyFalse
[void]$Monkeys[$NewMonkey].Items.Add($NewWorryLevel)
}
$Monkey.Items.Clear()
}
}
$MonkeysInspected = ($Monkeys.Inspected | Sort-Object -Descending)[0..1]
Write-Host "Part 2: $($MonkeysInspected[0] * $MonkeysInspected[1])"

Edit: OK den ggT und kgV zu berechnen ist unnötig. Sind ja bereits Primzahlen.

Das hier reicht um auf Mod zu kommen:

Spoiler anzeigen

Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

C#-Quellcode

Quellcode

Quellcode

Quellcode

Quellcode

Tags

Ähnliche Themen

13 Benutzer haben hier geschrieben