Advent of Code 2022

Es gibt 85 Antworten in diesem Thema. Der letzte Beitrag () ist von Elanda.

    Day 12:
    Spoiler anzeigen

    C#-Quellcode

    1. [b]
    2. [/b]namespace Twelve;
    4. using System.Diagnostics;
    5. using System.Numerics;
    7. public class Program
    8. {
    9. static Grid _grid = null;
    11. static void Main(string[] args)
    12. {
    13. IEnumerable<string> data = File.ReadAllLines("input.txt");
    15. _grid = new Grid(data);
    16. Log(_grid.FindAPathAtAll(1));
    17. Log(_grid.FindAPathAtAll(2));
    18. }
    20. static void Log(object message) => Console.WriteLine(message);
    21. }
    23. class Node
    24. {
    25. public int X { get; set; }
    26. public int Y { get; set; }
    27. public char Value { get; set; }
    28. public int Distance { get; set; }
    29. public int NextDistance { get; set; }
    31. public Node(int x, int y, char value) => (x, y, value) = (this.X = x, this.Y = y, this.Value = value);
    32. }
    34. class Grid
    35. {
    36. public Node[,] Nodes { get; set; }
    38. private Node _startNode = null;
    39. private Node _endNode = null;
    41. public Grid(IEnumerable<string> data)
    42. {
    43. this.Nodes = new Node[data.ElementAt(0).Count(), data.Count()];
    45. for (int y = 0; y < data.Count(); y++)
    46. for (int x = 0; x < data.ElementAt(0).Count(); x++)
    47. {
    48. this.Nodes[x, y] = new Node(x, y, data.ElementAt(y).ElementAt(x));
    50. if (data.ElementAt(y).ElementAt(x) == 'S')
    51. {
    52. _startNode = this.Nodes[x, y];
    53. this.Nodes[x, y].Value = 'a';
    54. }
    56. if (data.ElementAt(y).ElementAt(x) == 'E')
    57. {
    58. _endNode = this.Nodes[x, y];
    59. this.Nodes[x, y].Value = 'z';
    60. }
    62. this.Nodes[x, y].Distance = 0;
    63. }
    64. }
    66. //"Wave-propagation algo
    67. public int FindAPathAtAll(int part)
    68. {
    69. List<Node> workingNodes = new();
    71. _endNode.NextDistance = 1;
    72. workingNodes.Add(_endNode);
    74. while (true)
    75. {
    76. List<Node> newNodes = new();
    78. foreach (var node in workingNodes)
    79. {
    80. node.Distance = node.NextDistance;
    82. var neighbours = GetNeighbours(node);
    84. foreach (var neighbour in neighbours)
    85. {
    86. if (neighbour.Distance != 0) continue;
    88. if (node.Value - neighbour.Value < 2)
    89. {
    90. neighbour.NextDistance = node.Distance + 1;
    91. newNodes.Add(neighbour);
    92. }
    93. }
    94. }
    96. if (newNodes.Count == 0) break;
    98. workingNodes.Clear();
    99. workingNodes.AddRange(newNodes.Distinct().ToList());
    100. }
    102. if (part == 1) return _startNode.Distance - 1;
    104. if (part == 2)
    105. {
    106. int min = int.MaxValue;
    108. foreach (var node in this.Nodes)
    109. {
    110. if (node.Value == 'a' && node.Distance != 0 && node.Distance < min)
    111. min = node.Distance - 1;
    112. }
    114. return min;
    115. }
    117. return 0;
    118. }
    120. public List<Node> GetNeighbours(Node node)
    121. {
    122. List<Node> result = new();
    124. if (IsOnGrid(node.X - 1, node.Y))
    125. result.Add(this.Nodes[node.X - 1, node.Y]);
    126. if (IsOnGrid(node.X + 1, node.Y))
    127. result.Add(this.Nodes[node.X + 1, node.Y]);
    128. if (IsOnGrid(node.X, node.Y - 1))
    129. result.Add(this.Nodes[node.X, node.Y - 1]);
    130. if (IsOnGrid(node.X, node.Y + 1))
    131. result.Add(this.Nodes[node.X, node.Y + 1]);
    133. return result;
    134. }
    136. public Node GetNode(int x, int y)
    137. {
    138. if (IsOnGrid(x, y))
    139. return this.Nodes[x, y];
    141. return null;
    142. }
    144. public bool IsOnGrid(int x, int y)
    145. {
    146. return (x >= 0 && x < this.Nodes.GetLength(0) &&
    147. y >= 0 && y < this.Nodes.GetLength(1));
    148. }
    150. public bool IsOnGrid(Node node) => IsOnGrid(node.X, node.Y);
    151. }


    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    Tag 12
    Spoiler anzeigen

    finally - der hat mich echt aufgehalten... Der Code ist super schlecht aber funktioniert. Berechnen von Part 2 dauert gefühlt ewig.kann man sicher noch besser machen.... saß da nun gestern und heute paar stunden dran und ja aber endlich mal selbst implementiert das zeug für den Tag und keine fertige lib benutzt das war mir wichtig. danke an @SpaceyX der mir gestern abend noch nen kleinen Tipp gegeben hat sonst wär ich sicher nicht drauf gekommen.
    Gerne per PN oder so noch Vorschläge warum das ganze so lange dauert wo ich etwas verbessern könnte.

    C#-Quellcode

    1. using System.Drawing;
    2. string[] lines = File.ReadAllLines("Input.txt");
    3. Map map2 = new Map(lines);
    4. map2.Initilize();
    5. map2.CalculateNeighbours();
    6. map2.getShortestPathFromStartingNode(map2.Nodes.FirstOrDefault(x => x.IsStart == true));
    7. List<long> shortestPaths = new List<long>();
    8. long shortestPathCost = 0;
    10. shortestPathCost = 0;
    11. List<Knoten> kleinsterweg = new List<Knoten>();
    12. kleinsterweg.Add(map2.Nodes.FirstOrDefault(x => x.IsEnd));
    13. getShortestPath(kleinsterweg, map2.Nodes.FirstOrDefault(x => x.IsEnd));
    14. Console.WriteLine($"Part 1: {kleinsterweg.Count() - 1}");
    15. Console.WriteLine($"checking {map2.Nodes.Where(x => x.Letter == 'a').Count()} Nodes for Part 2");
    17. int counter = 0;
    18. Parallel.ForEach(map2.Nodes.Where(x => x.Letter == 'a' && x.HasValidNeighbours == true), k =>
    19. {
    20. Map map = new Map(lines);
    21. map.Initilize();
    22. map.CalculateNeighbours();
    23. if (!map.getShortestPathFromStartingNode(map.Nodes.FirstOrDefault(x=>x.ID == k.ID))) return;
    25. shortestPathCost = 0;
    26. List<Knoten> kleinsterweg = new List<Knoten>();
    27. kleinsterweg.Add(map.Nodes.FirstOrDefault(x => x.IsEnd));
    28. getShortestPath(kleinsterweg, map.Nodes.FirstOrDefault(x => x.IsEnd));
    30. shortestPaths.Add(kleinsterweg.Count());
    31. });
    33. Console.WriteLine($"Part 2: {shortestPaths.Min()}");
    35. void getShortestPath(List<Knoten> tkn, Knoten node)
    36. {
    37. if (node.LastKnoten == null) return;
    38. tkn.Add(node.LastKnoten);
    39. shortestPathCost += node.Verbindungen.FirstOrDefault(x => x.ConnectedKnoten.ID == node.LastKnoten.ID).Cost;
    40. getShortestPath(tkn, node.LastKnoten);
    41. }
    42. Console.WriteLine("fertig");
    44. public class Map
    45. {
    46. public List<Knoten> Nodes { get; set; } = new List<Knoten>();
    47. public int Rows { get; set; }
    48. public int Cols { get; set; }
    49. public string[] Grid { get; private set; }
    51. public Map(string[] lines)
    52. {
    53. Rows = lines.Count();
    54. Cols = lines[0].Length;
    55. Grid = lines;
    56. }
    58. public void Initilize()
    59. {
    60. int knotenId = 0;
    61. for (int i = 0; i < Rows; i++)
    62. {
    63. for (int x = 0; x < Cols; x++)
    64. {
    65. Knoten k = new Knoten();
    66. int actual = Grid[i][x];
    67. k.Letter = (char)actual;
    68. if ((char)actual == 'S')
    69. {
    70. k.Letter = 'a';
    71. k.IsStart = true;
    72. k.Cost = 0;
    73. }
    75. if ((char)actual == 'E')
    76. {
    77. k.Letter = 'z';
    78. k.IsEnd = true;
    79. }
    80. k.ID = knotenId;
    81. k.Coordinates = new Point(i, x);
    82. knotenId++;
    83. Nodes.Add(k);
    84. }
    85. }
    86. }
    88. public void CalculateNeighbours()
    89. {
    90. foreach (Knoten k in Nodes)
    91. {
    92. Knoten kUp = Nodes.FirstOrDefault(x => x.Coordinates.X == k.Coordinates.X - 1 && x.Coordinates.Y == k.Coordinates.Y);
    93. Knoten kDown = Nodes.FirstOrDefault(x => x.Coordinates.X == k.Coordinates.X + 1 && x.Coordinates.Y == k.Coordinates.Y);
    94. Knoten kLeft = Nodes.FirstOrDefault(x => x.Coordinates.X == k.Coordinates.X && x.Coordinates.Y == k.Coordinates.Y - 1);
    95. Knoten kRight = Nodes.FirstOrDefault(x => x.Coordinates.X == k.Coordinates.X && x.Coordinates.Y == k.Coordinates.Y + 1);
    97. int result = 0;
    98. if (kUp != null)
    99. {
    100. result = ((k.Letter + 1) >= kUp.Letter) ? 1 : 9999;
    101. if (result < 9999) k.HasValidNeighbours = true;
    102. Verbindung v = new Verbindung();
    103. v.Cost = result;
    104. v.ConnectedKnoten = kUp;
    105. k.Verbindungen.Add(v);
    107. }
    108. if (kDown != null)
    109. {
    110. result = ((k.Letter + 1) >= kDown.Letter) ? 1 : 9999;
    111. if (result < 9999) k.HasValidNeighbours = true;
    112. Verbindung v = new Verbindung();
    113. v.Cost = result;
    114. v.ConnectedKnoten = kDown;
    115. k.Verbindungen.Add(v);
    117. }
    118. if (kLeft != null)
    119. {
    120. result = ((k.Letter + 1) >= kLeft.Letter) ? 1 : 9999;
    121. if (result < 9999) k.HasValidNeighbours = true;
    122. Verbindung v = new Verbindung();
    123. v.Cost = result;
    124. v.ConnectedKnoten = kLeft;
    125. k.Verbindungen.Add(v);
    127. }
    128. if (kRight != null)
    129. {
    130. result = ((k.Letter + 1) >= kRight.Letter) ? 1 : 9999;
    131. if (result < 9999) k.HasValidNeighbours = true;
    132. Verbindung v = new Verbindung();
    133. v.Cost = result;
    134. v.ConnectedKnoten = kRight;
    135. k.Verbindungen.Add(v);
    137. }
    138. }
    139. }
    141. public bool getShortestPathFromStartingNode(Knoten start)
    142. {
    143. List<Knoten> queue = new List<Knoten>();
    144. queue.Add(start);
    145. while (queue.Any())
    146. {
    147. Knoten current = queue.OrderBy(x => x.Cost).ToList().First();
    148. queue.Remove(current);
    150. foreach (Verbindung currentConnection in current.Verbindungen.OrderBy(x => x.Cost))
    151. {
    152. Knoten currentChild = currentConnection.ConnectedKnoten;
    153. if (currentChild.Visited) continue;
    155. if (currentChild.Letter > current.Letter + 1) continue;
    156. if (currentChild.Cost == null || current.Cost + currentConnection.Cost < currentChild.Cost)
    157. {
    158. currentChild.Cost = current.Cost + currentConnection.Cost;
    159. currentChild.LastID = current.ID;
    160. currentChild.LastKnoten = current;
    162. if (!queue.Contains(currentChild))
    163. {
    164. queue.Add(currentChild);
    165. }
    166. }
    167. }
    169. current.Visited = true;
    171. if (current.IsEnd)
    172. {
    173. return true;
    174. }
    177. }
    178. return false;
    179. }
    181. }
    183. public class Knoten
    184. {
    185. public bool IsStart { get; set; } = false;
    186. public bool IsShortestStart { get; set; } = false;
    187. public bool IsEnd { get; set; } = false;
    188. public Point Coordinates { get; set; } = Point.Empty;
    189. public bool Visited { get; set; } = false;
    190. public int ID { get; set; }
    191. public long? Cost { get; set; }
    192. public char Letter { get; set; }
    193. public int LastID { get; set; } = 0;
    194. public bool HasValidNeighbours { get; set; } = false;
    195. public Knoten LastKnoten { get; set; }
    197. public List<Verbindung> Verbindungen { get; set; } = new List<Verbindung>();
    198. }
    200. public class Verbindung
    201. {
    202. public long Cost { get; set; }
    203. public Knoten ConnectedKnoten { get; set; }
    205. }


    Tag 13 - C# Part 1 und 2
    Spoiler anzeigen

    Heute war recht easy - statt auf Newtonsoft.Json zu setzen ( weil FremdLib ) mal System.Text.Json benutzt. Ging ganz gut die Inputs konnte man schön einfach in Json laden und dann braucht man nur noch vergleichen.
    Ein wenig bei Microsoft gelesen wie man System.Text.Json so nutzten kann + die Default Comparer angeschaut. Wieder viel gelernt heute.

    C#-Quellcode

    1. using System.Text.Json;
    2. string[] lines = File.ReadAllLines("Input.txt").Where(x=> String.IsNullOrEmpty(x) == false).ToArray();
    3. List<Packet> leftPackets = new List<Packet>();
    4. List<Packet> rightPackets = new List<Packet>();
    5. int indexCounter = 0;
    6. List<int> pairIndexRightOrder = new List<int>();
    7. foreach (string[] pair in lines.Chunk(2))
    8. {
    9. string left = pair[0];
    10. string right = pair[1];
    12. JsonElement jsonLeft = JsonSerializer.Deserialize<JsonElement>(left);
    13. JsonElement jsonRight = JsonSerializer.Deserialize<JsonElement>(right);
    15. indexCounter++;
    16. Packet leftPacket = new Packet(indexCounter, jsonLeft);
    17. Packet rightPacket = new Packet(indexCounter, jsonRight);
    19. leftPackets.Add(leftPacket);
    20. rightPackets.Add(rightPacket);
    21. }
    23. List<Packet>.Enumerator leftPacketsArray = leftPackets.GetEnumerator();
    24. List<Packet>.Enumerator rightPacketsArray = rightPackets.GetEnumerator();
    26. while (leftPacketsArray.MoveNext() && rightPacketsArray.MoveNext())
    27. {
    28. Packet leftPacket = leftPacketsArray.Current;
    29. Packet rightPacket = rightPacketsArray.Current;
    31. if(Packet.ComparePackets(leftPacket.packet,rightPacket.packet)<0 )
    32. {
    33. pairIndexRightOrder.Add(leftPacket.Index);
    35. }
    36. }
    37. Console.WriteLine($"Part 1: {pairIndexRightOrder.Sum()}");
    38. List<Packet> packetsSorted = new List<Packet>();
    39. foreach (string[] pair in lines.Chunk(2))
    40. {
    41. string left = pair[0];
    42. string right = pair[1];
    44. JsonElement jsonLeft = JsonSerializer.Deserialize<JsonElement>(left);
    45. JsonElement jsonRight = JsonSerializer.Deserialize<JsonElement>(right);
    47. indexCounter++;
    48. Packet leftPacket = new Packet(indexCounter, jsonLeft);
    49. Packet rightPacket = new Packet(indexCounter, jsonRight);
    51. packetsSorted.Add(leftPacket);
    52. packetsSorted.Add(rightPacket);
    53. }
    54. JsonElement additionalPacketTwo = JsonSerializer.Deserialize<JsonElement>("[[2]]");
    55. JsonElement additionalPacketSix = JsonSerializer.Deserialize<JsonElement>("[[6]]");
    56. packetsSorted.Add( new Packet(2, additionalPacketTwo) );
    57. packetsSorted.Add( new Packet(4, additionalPacketSix) );
    58. Packet.SortPackets(packetsSorted);
    59. int additionalPacketTwoIndex = 0;
    60. int additionalPacketSixIndex = 0;
    61. int currentIndex = 1;
    62. foreach (Packet p in packetsSorted)
    63. {
    64. if (Packet.ComparePackets(p.packet, additionalPacketTwo) == 0)
    65. {
    66. additionalPacketTwoIndex = currentIndex;
    67. }
    68. if (Packet.ComparePackets(p.packet, additionalPacketSix) == 0)
    69. {
    70. additionalPacketSixIndex = currentIndex;
    71. }
    72. currentIndex++;
    73. }
    75. Console.WriteLine($"Part 2: {additionalPacketTwoIndex * additionalPacketSixIndex}");
    76. public class Packet
    77. {
    78. public JsonElement packet{ get; set; }
    79. public int Index { get; set; }
    81. public Packet(int index, JsonElement newPacket)
    82. {
    83. packet = newPacket;
    84. Index = index;
    86. }
    87. public static int ComparePackets(JsonElement leftPacket, JsonElement rightPacket)
    88. {
    89. JsonElement tmpPacket;
    91. if(leftPacket.ValueKind == JsonValueKind.Null && rightPacket.ValueKind != JsonValueKind.Null)
    92. {
    93. return -1;
    94. }
    95. if (leftPacket.ValueKind != JsonValueKind.Null && rightPacket.ValueKind == JsonValueKind.Null)
    96. {
    97. return 1;
    98. }
    99. if(leftPacket.ValueKind == JsonValueKind.Array && rightPacket.ValueKind == JsonValueKind.Number)
    100. {
    101. tmpPacket = JsonSerializer.Deserialize<JsonElement>("[" + rightPacket.GetInt32() + "]");
    102. return ComparePackets(leftPacket, tmpPacket);
    103. }
    104. if (leftPacket.ValueKind == JsonValueKind.Number && rightPacket.ValueKind == JsonValueKind.Array)
    105. {
    106. tmpPacket = JsonSerializer.Deserialize<JsonElement>("[" + leftPacket.GetInt32() + "]");
    107. return ComparePackets(tmpPacket, rightPacket);
    108. }
    109. if(leftPacket.ValueKind == JsonValueKind.Number && rightPacket.ValueKind == JsonValueKind.Number)
    110. {
    111. return Comparer<int>.Default.Compare(leftPacket.GetInt32(), rightPacket.GetInt32());
    112. }
    114. if(leftPacket.ValueKind == JsonValueKind.Array && rightPacket.ValueKind == JsonValueKind.Array)
    115. {
    116. JsonElement.ArrayEnumerator leftPacketArray = leftPacket.EnumerateArray();
    117. JsonElement.ArrayEnumerator rightPacketArray = rightPacket.EnumerateArray();
    119. while (leftPacketArray.MoveNext() && rightPacketArray.MoveNext())
    120. {
    121. JsonElement leftPacket2 = leftPacketArray.Current;
    122. JsonElement rightPacket2 = rightPacketArray.Current;
    124. int result = ComparePackets(leftPacket2, rightPacket2);
    126. if (result != 0)
    127. {
    128. return result;
    129. }
    130. }
    131. int countPackets = leftPacketArray.Count() - rightPacketArray.Count();
    132. if (countPackets == 0) return 0;
    133. if (countPackets < 0) return -1;
    134. return 1;
    135. }
    136. return 0;
    137. }
    139. public static void SortPackets(List<Packet> packets)
    140. {
    141. packets.Sort(Comparer);
    142. }
    144. public static int Comparer(Packet p1, Packet p2)
    145. {
    146. return Packet.ComparePackets(p1.packet, p2.packet);
    147. }
    148. }

    Grüße , xChRoNiKx

    Nützliche Links:
    Visual Studio Empfohlene Einstellungen | Try-Catch heißes Eisen

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „xChRoNiKx“ ()

    Leute viel Spaß noch, ich bin raus. Tag 12 könnte ich noch angehen, mit mehr Zeit. Wird mir im Moment zu viel.
    War schön Code von euch mit dem eigenen Zeug zu vergleichen. Und so ein zwei Sachen hab ich aufgeschnappt.

    Und an @BornToBeRoot
    PowerShell > C#
    war mir vorher auch nicht klar :thumbsup:
    codewars.com Rank: 4 kyu

    Day 12 to Day 15 and only the first task in each case.

    Day12

    C#-Quellcode

    1. private static void Part01()
    2. {
    3. //char lowlevel = 'a',mostlevel = 'z';
    4. char startsignal = 'S', endsignal = 'E';
    5. var steps = ToDijkstraShortPath(Source(), startsignal, endsignal);
    7. Console.WriteLine($"The goal is reached in {steps} steps.");
    9. Console.WriteLine();
    10. Console.ReadLine();
    11. }
    13. private static int ToDijkstraShortPath(string[] grid, char startsignal, char endsignal)
    14. {
    15. var queue = new Queue<PointEx>();
    16. var distances = ToDistances(grid);
    17. var endpoint = ToPoint(grid, endsignal);
    18. var startpoint = ToPoint(grid, startsignal);
    19. var elevations = ToElevations(grid, startsignal, endsignal, 'a');
    21. distances[startpoint] = 0;
    22. queue.Enqueue(new PointEx(startpoint, 0));
    24. while (queue.Count > 0)
    25. {
    26. var pointex = queue.Dequeue();
    27. var point = pointex.Point;
    29. if (point == endpoint)
    30. return distances[endpoint];
    32. foreach (var neighbor in ToNeighbors(elevations, point))
    33. {
    34. var distance = distances[point] + 1;
    35. if (distance < distances[neighbor])
    36. {
    37. distances[neighbor] = distance;
    38. queue.Enqueue(new PointEx(neighbor, distance));
    39. //queue = SortQueue(queue); // Is not required.
    40. }
    41. }
    42. }
    43. return distances[endpoint];
    44. }

    Methodes

    C#-Quellcode

    1. private static Queue<PointEx> SortQueue(Queue<PointEx> queue)
    2. {
    3. if (queue.Count < 2) return queue;
    4. //This is sufficient for smaller queues.
    5. var result = new Queue<PointEx>();
    7. var distance = 0;
    8. while (queue.Count > 0)
    9. {
    10. for (var i = 0; i < queue.Count; i++)
    11. {
    12. if (queue.ElementAt(i).Distance == distance)
    13. {
    14. result.Enqueue(queue.Dequeue());
    15. i--;
    16. }
    17. }
    18. distance++;
    19. }
    20. return result;
    21. }
    23. private static Point[] ToNeighbors(Dictionary<Point, int> elevations, Point point)
    24. {
    25. var c = point.X;
    26. var r = point.Y;
    28. //Without diagonals ..
    29. var result = new Point[]
    30. {
    31. new(c, r - 1), new(c, r + 1),
    32. new(c - 1, r), new(c + 1, r)
    33. };
    35. // .. and only points with diff-distance <= 1.
    36. // (0,0) = 0 is the current point, and therefore must not be used.
    37. var pointdistance = elevations[point];
    38. return result
    39. .Where(n => elevations
    40. .ContainsKey(n) && elevations[n] - pointdistance <= 1)
    41. .ToArray();
    42. }
    44. private static Dictionary<Point, int> ToElevations(
    45. string[] grid, char start, char end, char beginlevel)
    46. {
    47. var rlength = grid.Length;
    48. var clength = grid[0].Length;
    49. var result = new Dictionary<Point, int>();
    50. for (var r = 0; r < rlength; r++)
    51. for (var c = 0; c < clength; c++)
    52. if (grid[r][c] == start)
    53. result.Add(new Point(c, r), 0);
    54. else if (grid[r][c] == end)
    55. result.Add(new Point(c, r), 25);
    56. else result.Add(new Point(c, r), grid[r][c] - beginlevel);
    57. return result;
    58. }
    60. private static Dictionary<Point, int> ToDistances(string[] grid)
    61. {
    62. var rlength = grid.Length;
    63. var clength = grid[0].Length;
    64. var result = new Dictionary<Point, int>();
    66. for (var r = 0; r < rlength; r++)
    67. for (var c = 0; c < clength; c++)
    68. result.Add(new Point(c, r), int.MaxValue);
    69. return result;
    70. }
    72. private static Point ToPoint(string[] grid, char searchchar)
    73. {
    74. var rlength = grid.Length;
    75. var clength = grid[0].Length;
    77. for (var r = 0; r < rlength; r++)
    78. for (var c = 0; c < clength; c++)
    79. if (grid[r][c] == searchchar)
    80. return new Point(c, r);
    81. return new Point();
    82. }

    Class and Source

    C#-Quellcode

    1. private class PointEx
    2. {
    3. public Point Point { get; set; }
    4. public int Distance { get; set; } = int.MaxValue;
    6. public PointEx() { }
    7. public PointEx(int x, int y) { this.Point = new Point(x, y); }
    8. public PointEx(Point start, int distance)
    9. {
    10. this.Point = start;
    11. this.Distance = distance;
    12. }
    13. }
    15. private static string[] Source()
    16. {
    17. return new string[]
    18. {
    19. "Sabqponm",
    20. "abcryxxl",
    21. "accszExk",
    22. "acctuvwj",
    23. "abdefghi"
    24. };
    25. }

    Day13

    C#-Quellcode

    1. private static void Part01_B()
    2. {
    3. //Hab eine konventionelle Lösung mir gemacht, nur die
    4. //gefällt mir gar nicht, darum setze ich sie nicht hier rein.
    6. //Andere Möglichkeit mit Json. Bin jedoch noch nicht
    7. //so fit mit diesem Features.
    8. var jnodes = new List<JsonNode>();
    9. Array.ForEach(Source(), item =>
    10. {
    11. if (!string.IsNullOrEmpty(item))
    12. jnodes.Add(JsonNode.Parse(item));
    13. });
    15. //Habe jetzt einen geeigneten Comparer gefunden.
    16. var sum = jnodes
    17. .Chunk(2)
    18. .Select((pair, idx) =>
    19. Comparer(pair) < 0 ? idx + 1 : 0)
    20. .Sum();
    21. }

    Comparer

    C#-Quellcode

    1. private static int Comparer(JsonNode[] pair) =>
    2. Comparer(pair[0], pair[1]);
    4. private static int Comparer(JsonNode leftnode, JsonNode rightnode)
    5. {
    6. if (leftnode is JsonValue && rightnode is JsonValue)
    7. return (int)leftnode - (int)rightnode;
    9. JsonArray jsonarrayleft, jsonarrayright;
    10. if (leftnode is JsonArray)
    11. jsonarrayleft = leftnode.AsArray();
    12. else jsonarrayleft = new JsonArray((int)leftnode);
    13. if (rightnode is JsonArray)
    14. jsonarrayright = rightnode.AsArray();
    15. else jsonarrayright = new JsonArray((int)rightnode);
    16. var result = Enumerable.Zip(jsonarrayleft, jsonarrayright)
    17. //synchrone Weitergabe der jeweiligen X-Elemente beider Jsonarrays als pair.
    18. .Select(pair => Comparer(pair.First, pair.Second)); //recursiv
    19. return result.FirstOrDefault(x => x != 0, jsonarrayleft.Count - jsonarrayright.Count);
    20. }

    Source

    C#-Quellcode

    1. private static string[][] SourcePair()
    2. {
    3. return Source()
    4. .Where(str => !string.IsNullOrEmpty(str))
    5. .Chunk(2)
    6. .ToArray();
    7. }
    9. private static string[] Source()
    10. {
    11. return new string[]
    12. {
    13. "[1,1,3,1,1]",
    14. "[1,1,5,1,1]",
    15. "",
    16. "[[1],[2,3,4]]",
    17. "[[1],4]",
    18. "",
    19. "[9]",
    20. "[[8,7,6]]",
    21. "",
    22. "[[4,4],4,4]",
    23. "[[4,4],4,4,4]",
    24. "",
    25. "[7,7,7,7]",
    26. "[7,7,7]",
    27. "",
    28. "[]",
    29. "[3]",
    30. "",
    31. "[[[]]]",
    32. "[[]]",
    33. "",
    34. "[1,[2,[3,[4,[5,6,7]]]],8,9]",
    35. "[1,[2,[3,[4,[5,6,0]]]],8,9]",
    36. ""
    37. };
    38. }

    Day14

    C#-Quellcode

    1. public static void Part01()
    2. {
    3. //https://www.reddit.com/r/dailyprogrammer/comments/1rdtky/comment/cdma9n0/?utm_source=share&utm_medium=web2x&context=3
    4. var grid = new Dictionary<Point, char>();
    5. foreach (var item in Source())
    6. {
    7. var pts = item.Split(
    8. new string[] { " -> ", "," },
    9. StringSplitOptions.RemoveEmptyEntries)
    10. .Chunk(2)
    11. .Select(pair => new Point(int.Parse(pair[0]), int.Parse(pair[1])))
    12. .ToArray();
    14. for (var i = 1; i < pts.Length; i++)
    15. SetGridRocks(grid, pts[i - 1], pts[i]);
    16. }
    18. var maxy = grid.Keys.Select(pos => pos.Y).Max();
    19. var result = SetGridSands(grid, new Point(500, 0), maxy);
    21. Console.WriteLine($"There are {result} grains of sand come to rest");
    23. Console.WriteLine();
    24. Console.ReadLine();
    25. }

    Methodes

    C#-Quellcode

    1. private static Point Addition(Point p1, Point p2) =>
    2. new(p1.X + p2.X, p1.Y + p2.Y);
    4. private static int SetGridSands(
    5. Dictionary<Point, char> grid, Point sandpoint, int maxy)
    6. {
    7. while (true)
    8. {
    9. var current = DrawFallingSand(grid, sandpoint, maxy);
    10. if (grid.ContainsKey(current)) break;
    11. if (current.Y == maxy + 1) break;
    12. grid[current] = 'o';
    13. }
    14. return grid.Values.Count(x => x == 'o');
    15. }
    17. private static int SetGridRocks(
    18. Dictionary<Point, char> grid, Point start, Point end)
    19. {
    20. var count = 0;
    21. var step =
    22. new Point(Math.Sign(end.X - start.X), Math.Sign(end.Y - start.Y));
    23. var target = Addition(end, step);
    24. for (var p = start; p != target; p = Addition(p, step), count++)
    25. grid[p] = '#';
    26. return count;
    27. }
    29. private static Point DrawFallingSand(
    30. Dictionary<Point, char> grid, Point sandpoint, int maxy)
    31. {
    32. Point d = new(0, 1),
    33. l = new(-1, 1),
    34. r = new(1, 1);
    36. while (sandpoint.Y < maxy + 1)
    37. //Observe handing sequence. First down ...
    38. if (!grid.ContainsKey(Addition(sandpoint, d)))
    39. sandpoint = Addition(sandpoint, d);
    40. //than left ...
    41. else if (!grid.ContainsKey(Addition(sandpoint, l)))
    42. sandpoint = Addition(sandpoint, l);
    43. //then right ...
    44. else if (!grid.ContainsKey(Addition(sandpoint, r)))
    45. sandpoint = Addition(sandpoint, r);
    46. else break;
    47. return sandpoint;
    48. }

    Source

    C#-Quellcode

    1. private static string[] Source()
    2. {
    3. return new string[]
    4. {
    5. "498,4 -> 498,6 -> 496,6",
    6. "503,4 -> 502,4 -> 502,9 -> 494,9"
    7. };
    8. }

    Day15
    ​

    C#-Quellcode

    1. public static void Part01()
    2. {
    3. var src = Source();
    4. var rects = src.Select(pair => ToRect(pair)).ToArray();
    5. var left = rects.Select(rct => rct.Left).Min();
    6. var right = rects.Select(rct => rct.Right - 1).Max();
    8. var y = 10;
    9. var x = left;
    10. var result = 0;
    11. while (x <= right)
    12. {
    13. var visitpoint = new Point(x++, y);
    14. if (src.Any(pair =>
    15. pair[1] != visitpoint &&
    16. IsInGrid(pair, visitpoint)))
    17. result++;
    18. }
    19. Console.WriteLine($"In y = {y}, {result} positions cannot contain a beacon.");
    21. x = left;
    22. result = 0;
    23. y = 2_000_000;
    24. while (x <= right)
    25. {
    26. var visitpoint = new Point(x++, y);
    27. if (src.Any(pair =>
    28. pair[1] != visitpoint &&
    29. IsInGrid(pair, visitpoint)))
    30. result++;
    31. }
    32. Console.WriteLine($"In y = {y}, {result} positions cannot contain a beacon.");
    34. Console.WriteLine();
    35. Console.ReadLine();
    36. }​

    Methodes
    ​

    C#-Quellcode

    1. private static bool IsInGrid(Point[] pair, Point pos) =>
    2. ToMetric(pos, pair[0]) <= ToMetric(pair);
    4. private static Rectangle ToRect(Point[] pair) =>
    5. ToRect(pair[0], ToMetric(pair));
    7. private static Rectangle ToRect(Point sensor, int radius) =>
    8. new(sensor.X - radius, sensor.Y - radius, 2 * radius + 1, 2 * radius + 1);
    10. private static int ToMetric(Point[] pair) =>
    11. ToMetric(pair[0], pair[1]);
    13. private static int ToMetric(Point sensor, Point beacon) =>
    14. //https://en.wikipedia.org/wiki/Taxicab_geometry
    15. Math.Abs(sensor.X - beacon.X) + Math.Abs(sensor.Y - beacon.Y);​

    Source
    ​

    C#-Quellcode

    1. ​ private static Point[][] Source()
    2. {
    3. return SourceText()
    4. .Select(line => line
    5. .Split(new string[] { "x=", ", ", "y=", ": ", },
    6. StringSplitOptions.RemoveEmptyEntries))
    7. .Select(split =>
    8. new Point[] {
    9. new(int.Parse(split[1]), int.Parse(split[2])),
    10. new(int.Parse(split[4]), int.Parse(split[5]))})
    11. .ToArray();
    12. }
    14. private static string[] SourceText()
    15. {
    16. return new string[]
    17. {
    18. "Sensor at x=2, y=18: closest beacon is at x=-2, y=15",
    19. "Sensor at x=9, y=16: closest beacon is at x=10, y=16",
    20. "Sensor at x=13, y=2: closest beacon is at x=15, y=3",
    21. "Sensor at x=12, y=14: closest beacon is at x=10, y=16",
    22. "Sensor at x=10, y=20: closest beacon is at x=10, y=16",
    23. "Sensor at x=14, y=17: closest beacon is at x=10, y=16",
    24. "Sensor at x=8, y=7: closest beacon is at x=2, y=10",
    25. "Sensor at x=2, y=0: closest beacon is at x=2, y=10",
    26. "Sensor at x=0, y=11: closest beacon is at x=2, y=10",
    27. "Sensor at x=20, y=14: closest beacon is at x=25, y=17",
    28. "Sensor at x=17, y=20: closest beacon is at x=21, y=22",
    29. "Sensor at x=16, y=7: closest beacon is at x=15, y=3",
    30. "Sensor at x=14, y=3: closest beacon is at x=15, y=3",
    31. "Sensor at x=20, y=1: closest beacon is at x=15, y=3",
    32. };
    33. }

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „exc-jdbi“ ()

    Ein bischen verspätet, aber vielen Dank, für alle Leute die mitgemacht haben.
    Es war wirklich Spaßig.

    Ich war zwar nur bis Tag 7 oder so dabei, aber die hab ich gefeiert.
    Außerdem finde ich es schön das es jetzt so viele Beispiele gibt, an denen sich Leute möglicherweiße ein wenig orientieren können? Wer weiß?

    Ich hoffe nächstes Jahr halte ich länger durch, aber frohe verspätete Weihnachtswünsche! (Dann halt schon mal für's nächste Jahr)
    ----------------------------------------------------------------------------------------------------------------------

    Hier könnte meine Signatur stehen, aber die ist mir abfußen gekommen.

    ----------------------------------------------------------------------------------------------------------------------