Advent of Code 2022

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

    AoC Day 2

    Heute war es immer noch einfach, aber schon kniffliger. Dieses Puzzle hab ich in C++ gelöst.
    Spoiler anzeigen
    ​

    C-Quellcode

    1. ​
    2. #include <iostream>
    3. #include <fstream>
    4. #include <string>
    6. using namespace std;
    8. enum class Shapes
    9. {
    10. Rock = 1,
    11. Paper = 2,
    12. Scissors = 3,
    13. };
    15. class GameItem
    16. {
    17. public:
    18. Shapes Shape;
    19. GameItem(Shapes shape) : Shape(shape) {}
    20. GameItem(char input)
    21. {
    22. switch (input)
    23. {
    24. case 'A':
    25. case 'X':
    26. Shape = Shapes::Rock;
    27. break;
    28. case 'B':
    29. case 'Y':
    30. Shape = Shapes::Paper;
    31. break;
    32. case 'C':
    33. case 'Z':
    34. Shape = Shapes::Scissors;
    35. break;
    36. default:
    37. throw ("Illegal char");
    38. }
    39. }
    40. bool DefeatsShape(GameItem target)
    41. {
    42. switch (Shape)
    43. {
    44. case Shapes::Rock:
    45. return target.Shape == Shapes::Scissors;
    46. case Shapes::Paper:
    47. return target.Shape == Shapes::Rock;
    48. case Shapes::Scissors:
    49. return target.Shape == Shapes::Paper;
    50. default:
    51. return false;
    52. }
    53. }
    54. };
    56. int GetPoints(GameItem myItem, GameItem opponentItem)
    57. {
    58. if (myItem.Shape == opponentItem.Shape)
    59. {
    60. return (int)myItem.Shape + 3;
    61. }
    62. if (myItem.DefeatsShape(opponentItem))
    63. {
    64. return (int)myItem.Shape + 6;
    65. }
    66. return (int)myItem.Shape;
    67. }
    69. void ChangeShapeForForcedEnd(GameItem* myItem, GameItem opponentItem)
    70. {
    71. switch (myItem->Shape)
    72. {
    73. case Shapes::Paper://draw
    74. myItem->Shape = opponentItem.Shape;
    75. break;
    76. case Shapes::Rock: //lose
    77. switch (opponentItem.Shape)
    78. {
    79. case Shapes::Rock:
    80. myItem->Shape = Shapes::Scissors;
    81. break;
    82. case Shapes::Paper:
    83. myItem->Shape = Shapes::Rock;
    84. break;
    85. case Shapes::Scissors:
    86. myItem->Shape = Shapes::Paper;
    87. break;
    88. }
    89. break;
    90. case Shapes::Scissors://win
    91. switch (opponentItem.Shape)
    92. {
    93. case Shapes::Rock:
    94. myItem->Shape = Shapes::Paper;
    95. break;
    96. case Shapes::Paper:
    97. myItem->Shape = Shapes::Scissors;
    98. break;
    99. case Shapes::Scissors:
    100. myItem->Shape = Shapes::Rock;
    101. break;
    102. }
    103. break;
    104. }
    105. }
    107. int main()
    108. {
    109. std::ifstream inputFile("input.txt");
    110. if (!inputFile.is_open())
    111. {
    112. cout << "Can't open the file";
    113. return -1;
    114. }
    115. int myPointsPuzzle1 = 0;
    116. int myPointsPuzzle2 = 0;
    117. for (string line; getline(inputFile, line);)
    118. {
    119. GameItem opponentItem(line[0]);
    120. GameItem myItem(line[2]);
    121. myPointsPuzzle1 += GetPoints(myItem, opponentItem);
    122. ChangeShapeForForcedEnd(&myItem, opponentItem);
    123. myPointsPuzzle2 += GetPoints(myItem, opponentItem);
    124. }
    125. cout << myPointsPuzzle1 << endl << myPointsPuzzle2;
    126. return 0;
    127. }

    @BitBrösel da hatten wir ähnliche Gedanken:
    Spoiler anzeigen

    C#-Quellcode

    1. public static class StrategyConverter
    2. {
    3. public static int StrategyGuideScorePt1 { get; private set; }
    4. public static int StrategyGuideScorePt2 { get; private set; }
    6. public static void ReadDataAndCalculateOutcome()
    7. {
    8. using StreamReader sr = new("AoC_2 Data.txt");
    9. do
    10. {
    11. string line = sr.ReadLine();
    12. string[] strats = line.Split(' ');
    14. Game current = CalculateGameFromLinePt1(strats);
    15. StrategyGuideScorePt1 += (int)current.Me + (int)current.Outcome;
    17. current = CalculateGameFromLinePt2(strats);
    18. StrategyGuideScorePt2 += (int)current.Me + (int)current.Outcome;
    20. } while (!sr.EndOfStream);
    21. }
    23. private static Game CalculateGameFromLinePt1(string[] line)
    24. {
    25. Game current = new()
    26. {
    27. Oppopnent = line[0] switch
    28. {
    29. "A" => Handsign.Rock,
    30. "B" => Handsign.Paper,
    31. "C" => Handsign.Scissors,
    32. },
    33. Me = line[1] switch
    34. {
    35. "X" => Handsign.Rock,
    36. "Y" => Handsign.Paper,
    37. "Z" => Handsign.Scissors,
    38. }
    39. };
    40. current.Outcome = current.Oppopnent switch
    41. {
    42. Handsign.Rock => current.Me switch
    43. {
    44. Handsign.Rock => Result.Draw,
    45. Handsign.Paper => Result.Win,
    46. Handsign.Scissors => Result.Loss
    47. },
    48. Handsign.Paper => current.Me switch
    49. {
    50. Handsign.Rock => Result.Loss,
    51. Handsign.Paper => Result.Draw,
    52. Handsign.Scissors => Result.Win
    53. },
    54. Handsign.Scissors => current.Me switch
    55. {
    56. Handsign.Rock => Result.Win,
    57. Handsign.Paper => Result.Loss,
    58. Handsign.Scissors => Result.Draw
    59. }
    60. };
    61. return current;
    62. }
    64. private static Game CalculateGameFromLinePt2(string[] line)
    65. {
    66. Game current = new()
    67. {
    68. Oppopnent = line[0] switch
    69. {
    70. "A" => Handsign.Rock,
    71. "B" => Handsign.Paper,
    72. "C" => Handsign.Scissors,
    73. },
    74. Outcome = line[1] switch
    75. {
    76. "X" => Result.Loss,
    77. "Y" => Result.Draw,
    78. "Z" => Result.Win,
    79. }
    80. };
    81. current.Me = current.Oppopnent switch
    82. {
    83. Handsign.Rock => current.Outcome switch
    84. {
    85. Result.Draw => Handsign.Rock,
    86. Result.Win => Handsign.Paper,
    87. Result.Loss => Handsign.Scissors
    88. },
    89. Handsign.Paper => current.Outcome switch
    90. {
    91. Result.Draw => Handsign.Paper,
    92. Result.Win => Handsign.Scissors,
    93. Result.Loss => Handsign.Rock
    94. },
    95. Handsign.Scissors => current.Outcome switch
    96. {
    97. Result.Draw => Handsign.Scissors,
    98. Result.Win => Handsign.Rock,
    99. Result.Loss => Handsign.Paper
    100. }
    101. };
    102. return current;
    103. }
    104. }
    106. public class Game
    107. {
    108. public Handsign Oppopnent { get; set; }
    109. public Handsign Me { get; set; }
    110. public Result Outcome { get; set; }
    111. }
    113. public enum Handsign
    114. {
    115. Rock = 1,
    116. Paper,
    117. Scissors
    118. }
    120. public enum Result
    121. {
    122. Loss = 0,
    123. Draw = 3,
    124. Win = 6
    125. }

    C#-Quellcode

    1. static void Main(string[] args)
    2. {
    3. StrategyConverter.ReadDataAndCalculateOutcome();
    5. Console.WriteLine("Solution Day_2_P1:" + StrategyConverter.StrategyGuideScorePt1);
    6. Console.WriteLine("Solution Day_2_P2:" + StrategyConverter.StrategyGuideScorePt2);
    8. Console.ReadKey();
    9. }


    Edit: Auf den zweiten Blick ists doch ein wenig anders^^

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „EaranMaleasi“ ()

    Wobei mir dein Code irgendwie besser gefällt. Aber ich hab da noch eine Anmerkung zu deinem Code, den Schritt mit dem splitten kannst du einsparen.

    C#-Quellcode

    1. string s = "A B";
    2. char a = s[0];
    3. char b = s[2];


    PS: Doch ein unsinniger Gedanke, besser 1 Parameter für die Funktion beibehalten, immer besser als 2;

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „BitBrösel“ ()

    Stimmt schon, ich könnte einfach die ganze Zeilen unverändert in die Funktion geben und dann line[0] und line[2] benutzen. Jedoch macht das Split in meinen Augen eher klar, was hier passiert im Kontext mit dem restlichen Code. (Wenn ich jetzt noch die Funktionen und deren Argumente ein wenig umbenennen würde wäre es sogar Konsistent)

    Ich habe das einfach kurz runter geschrieben. Mich auch nicht ganz an die geforderten Angaben gehalten.

    Freundliche Grüsse

    exc-jdbi

    Spoiler anzeigen
    ​

    C#-Quellcode

    1. ​
    3. namespace AdventCalendar2022;
    5. using static RandomHolder;
    7. internal class Day02
    8. {
    9. public static void Start()
    10. {
    11. ProblemFormulation();
    12. RandomTest();
    13. }
    15. public static void RandomTest()
    16. {
    17. var count = 3;
    18. var games = new Game[count];
    19. var elements = ((Elements[])Elements.GetValues(typeof(Elements)));
    20. for (var i = 0; i < games.Length; i++)
    21. {
    22. var a = new Participant(elements[Rand.Next(elements.Length)]);
    23. var b = new Participant(elements[Rand.Next(elements.Length)]);
    24. games[i] = new Game(a, b);
    25. games[i].Score();
    26. games[i].PrintOut();
    27. }
    28. Console.WriteLine($"Result A = {games.Sum(x => x.A.Result)}; Result B = {games.Sum(x => x.B.Result)}");
    30. Console.WriteLine();
    31. Console.ReadLine();
    32. }
    34. public static void ProblemFormulation()
    35. {
    36. var games = new Game[3];
    37. var a = new Participant(Elements.Rock);
    38. var b = new Participant(Elements.Paper);
    39. games[0] = new Game(a, b);
    41. a = new Participant(Elements.Paper);
    42. b = new Participant(Elements.Rock);
    43. games[1] = new Game(a, b);
    45. a = new Participant(Elements.Scissors);
    46. b = new Participant(Elements.Scissors);
    47. games[2] = new Game(a, b);
    49. games[0].Score();
    50. games[1].Score();
    51. games[2].Score();
    53. games[0].PrintOut();
    54. games[1].PrintOut();
    55. games[2].PrintOut();
    57. Console.WriteLine($"Result A = {games.Sum(x=>x.A.Result)}; Result B = {games.Sum(x => x.B.Result)}");
    59. Console.WriteLine();
    60. Console.WriteLine();
    61. Console.ReadLine();
    62. }
    63. }
    65. internal enum Elements
    66. {
    67. Rock = 1,
    68. Paper = 2,
    69. Scissors = 3,
    70. }
    72. internal enum Assessment
    73. {
    74. Lost = 0,
    75. Drawn = 3,
    76. Win = 6,
    77. }
    80. internal class Game
    81. {
    82. public Participant A { get; private set; }
    83. public Participant B { get; private set; }
    85. public Game(Participant first, Participant seconde)
    86. {
    87. this.A = first;
    88. this.B = seconde;
    89. }
    91. public void Score()
    92. {
    93. if (A.Elements == B.Elements)
    94. {
    95. A.Assessment = B.Assessment = Assessment.Drawn;
    96. }
    97. else if (A.Elements == Elements.Rock && B.Elements == Elements.Paper)
    98. {
    99. A.Assessment = Assessment.Lost;
    100. B.Assessment = Assessment.Win;
    101. }
    102. else if (A.Elements == Elements.Rock && B.Elements == Elements.Scissors)
    103. {
    104. A.Assessment = Assessment.Win;
    105. B.Assessment = Assessment.Lost;
    106. }
    107. else if (A.Elements == Elements.Paper && B.Elements == Elements.Rock)
    108. {
    109. A.Assessment = Assessment.Win;
    110. B.Assessment = Assessment.Lost;
    111. }
    112. else if (A.Elements == Elements.Paper && B.Elements == Elements.Scissors)
    113. {
    114. A.Assessment = Assessment.Lost;
    115. B.Assessment = Assessment.Win;
    116. }
    117. else if (A.Elements == Elements.Scissors && B.Elements == Elements.Rock)
    118. {
    119. A.Assessment = Assessment.Lost;
    120. B.Assessment = Assessment.Win;
    121. }
    122. else if (A.Elements == Elements.Scissors && B.Elements == Elements.Paper)
    123. {
    124. A.Assessment = Assessment.Win;
    125. B.Assessment = Assessment.Lost;
    126. }
    127. A.Score();
    128. B.Score();
    130. }
    132. public void PrintOut()
    133. {
    134. if (A.Elements == B.Elements)
    135. {
    136. Console.WriteLine($"A: {A.Elements}; B: {B.Elements}");
    137. Console.Write($"A: Drawn: result = {A.Result}; ");
    138. Console.WriteLine($"B: Drawn: result = {B.Result}");
    139. Console.WriteLine();
    140. return;
    141. }
    143. Console.WriteLine($"A: {A.Elements}; B: {B.Elements}");
    144. var win = A.Assessment == Assessment.Win ? "A" : "B";
    145. var winassessment = A.Assessment == Assessment.Win ? A.Assessment : B.Assessment;
    146. var winresult = A.Assessment == Assessment.Win ? A.Result : B.Result;
    148. var lost = A.Assessment == Assessment.Win ? "B" : "A";
    149. var lostassessment = A.Assessment == Assessment.Win ?B.Assessment : A.Assessment;
    150. var lostresult = A.Assessment == Assessment.Win ? B.Result : A.Result;
    151. Console.WriteLine($"{win}: {winassessment}: result = {winresult}; {lost}: {lostassessment}: result = {lostresult}");
    153. Console.WriteLine();
    154. }
    155. }
    157. internal class Participant
    158. {
    159. public int Result = -1;
    160. public Elements Elements;
    161. public Assessment Assessment;
    163. public Participant(Elements element) { Elements = element; }
    164. public void Score()
    165. {
    166. Result = (int)Elements + (int)Assessment;
    167. }
    168. }
    170. internal class RandomHolder
    171. {
    172. public static Random Rand = new();
    174. public static int Next(int max)
    175. {
    176. return Next(0, max);
    177. }
    179. public static int Next(int min, int max)
    180. {
    181. return Rand.Next(min, max);
    182. }
    183. }

    Ich will mal versuchen, so weit wie möglich nur mit Expression Statements und LINQ Query Syntax zu kommen (keine Seiteneffekte/keinen imperativen Code mit Ausnahme der Ausgabe oder Assertions).

    Ich hab den Tipp gesehen, den ganzen Code mit einem Unit Test Projekt umzusetzen, damit man pro Tag einfach per VS Test Explorer den aktuellen Tag laufen lassen kann, ohne sich groß um verschiedene Projekte oder main Methoden kümmern zu müssen. Den Tipp fand ich gut - ich hab direkt mal umgestellt.

    Spoiler anzeigen

    C#-Quellcode

    1. namespace AdventOfCode2022;
    3. public sealed class Day02
    4. {
    5. private readonly ITestOutputHelper _output;
    6. public Day02(ITestOutputHelper log) => _output = log;
    8. [Theory]
    9. [InlineData("A Y\r\nB X\r\nC Z")]
    10. public void SolvePt1(string input) =>
    11. _output.WriteLine(
    12. from @in in new[] { input }
    13. let rounds =
    14. from round in input.Split("\r\n", StringSplitOptions.RemoveEmptyEntries)
    15. let other = MoveFromChar(round[0])
    16. let me = MoveFromChar(round[2])
    17. select new Round(other, me)
    18. select GetScore(rounds)
    19. );
    21. [Theory]
    22. [InlineData("A Y\r\nB X\r\nC Z")]
    23. public void SolvePt2(string input) =>
    24. _output.WriteLine(
    25. from @in in new[] { input }
    26. let rounds =
    27. from round in input.Split("\r\n", StringSplitOptions.RemoveEmptyEntries)
    28. let requiredResult = round[2] switch
    29. {
    30. 'X' => Winner.Other,
    31. 'Y' => Winner.Draw,
    32. 'Z' => Winner.Me,
    33. _ => throw new Exception(),
    34. }
    35. let other = MoveFromChar(round[0])
    36. let me = (other, requiredResult) switch
    37. {
    38. (Move.Rock, Winner.Other) => Move.Scissor,
    39. (Move.Rock, Winner.Draw) => Move.Rock,
    40. (Move.Rock, Winner.Me) => Move.Paper,
    42. (Move.Paper, Winner.Other) => Move.Rock,
    43. (Move.Paper, Winner.Draw) => Move.Paper,
    44. (Move.Paper, Winner.Me) => Move.Scissor,
    46. (Move.Scissor, Winner.Other) => Move.Paper,
    47. (Move.Scissor, Winner.Draw) => Move.Scissor,
    48. (Move.Scissor, Winner.Me) => Move.Rock,
    50. _ => throw new Exception(),
    51. }
    52. select new Round(other, me)
    53. select GetScore(rounds)
    54. );
    56. private static int GetScore(IEnumerable<Round> rounds) =>
    57. (from round in rounds
    58. let winner = round switch
    59. {
    60. { Other: Move.Rock, Me: Move.Rock } => Winner.Draw,
    61. { Other: Move.Rock, Me: Move.Paper } => Winner.Me,
    62. { Other: Move.Rock, Me: Move.Scissor } => Winner.Other,
    64. { Other: Move.Paper, Me: Move.Rock } => Winner.Other,
    65. { Other: Move.Paper, Me: Move.Paper } => Winner.Draw,
    66. { Other: Move.Paper, Me: Move.Scissor } => Winner.Me,
    68. { Other: Move.Scissor, Me: Move.Rock } => Winner.Me,
    69. { Other: Move.Scissor, Me: Move.Paper } => Winner.Other,
    70. { Other: Move.Scissor, Me: Move.Scissor } => Winner.Draw,
    72. _ => throw new Exception(),
    73. }
    74. let moveScore = (int)round.Me
    75. let resultScore = (int)winner
    76. let score = moveScore + resultScore
    77. select score).Sum();
    79. private static Move MoveFromChar(char c) =>
    80. c switch
    81. {
    82. 'X' => Move.Rock,
    83. 'Y' => Move.Paper,
    84. 'Z' => Move.Scissor,
    85. 'A' => Move.Rock,
    86. 'B' => Move.Paper,
    87. 'C' => Move.Scissor,
    88. _ => throw new Exception(),
    89. };
    91. private enum Winner
    92. {
    93. Other = 0,
    94. Draw = 3,
    95. Me = 6,
    96. }
    98. private enum Move
    99. {
    100. Rock = 1,
    101. Paper = 2,
    102. Scissor = 3,
    103. }
    105. private sealed record Round(Move Other, Move Me);
    106. }

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

    Part 1 straight forward runtergeschrieben:
    Spoiler anzeigen

    C#-Quellcode

    1. using FileStream fs = File.OpenRead("input.txt");
    2. using StreamReader sr = new StreamReader(fs);
    4. int score = 0;
    5. while (!sr.EndOfStream)
    6. {
    7. var line = sr.ReadLine()!.AsSpan();
    8. score += line[2] switch
    9. {
    10. 'X' => 1,
    11. 'Y' => 2,
    12. 'Z' => 3,
    13. _ => 0
    14. };
    16. if (RoundDraw(line[0], line[2]))
    17. {
    18. score += 3;
    19. }
    20. else if(RoundWon(line[0], line[2]))
    21. {
    22. score += 6;
    23. }
    24. }
    26. Console.WriteLine(score);
    28. sr.Close();
    29. fs.Close();
    31. bool RoundDraw(char a, char b) => (a == 'A' && b == 'X') || (a == 'B' && b == 'Y') || (a == 'C' && b == 'Z');
    33. bool RoundWon(char a, char b) => (a == 'C' && b == 'X') || (a == 'A' && b == 'Y') || (a == 'B' && b == 'Z');


    Ebenso Part 2
    Spoiler anzeigen

    C#-Quellcode

    1. using FileStream fs = File.OpenRead("input.txt");
    2. using StreamReader sr = new StreamReader(fs);
    4. int score = 0;
    5. while (!sr.EndOfStream)
    6. {
    7. var line = sr.ReadLine()!.AsSpan();
    8. score += line[2] switch
    9. {
    10. 'X' => Loose(line[0]),
    11. 'Y' => Draw(line[0]) + 3,
    12. 'Z' => Win(line[0]) + 6,
    13. _ => 0
    14. };
    15. }
    17. Console.WriteLine(score);
    19. sr.Close();
    20. fs.Close();
    22. int Loose(char a) => a switch
    23. {
    24. 'A' => 3,
    25. 'B' => 1,
    26. 'C' => 2,
    27. _ => 0
    28. };
    30. int Draw(char a) => a switch
    31. {
    32. 'A' => 1,
    33. 'B' => 2,
    34. 'C' => 3,
    35. _ => 0
    36. };
    38. int Win(char a) => a switch
    39. {
    40. 'A' => 2,
    41. 'B' => 3,
    42. 'C' => 1,
    43. _ => 0
    44. };


    Nichts besonderes, kann man bestimmt noch eindampfen :)

    Moin,

    mein 2. Tag - erster Versuch PT1 und PT2: (jetzt gehts ans kürzen)

    Spoiler anzeigen

    C#-Quellcode

    1. string[] games = File.ReadAllLines("Input.txt");
    2. int scorePt1 = 0;
    3. int scorePt2 = 0;
    4. foreach (string game in games)
    5. {
    6. scorePt1 += game[0] switch
    7. {
    8. 'A' => game[2] switch
    9. {
    10. 'X' => 1 + 3,
    11. 'Y' => 2 + 6,
    12. 'Z' => 3 + 0
    13. },
    15. 'B' => game[2] switch
    16. {
    17. 'X' => 1 + 0,
    18. 'Y' => 2 + 3,
    19. 'Z' => 3 + 6
    20. },
    21. 'C' => game[2] switch
    22. {
    23. 'X' => 1 + 6,
    24. 'Y' => 2 + 0,
    25. 'Z' => 3 + 3
    26. }
    27. };
    28. scorePt2 += game[0] switch
    29. {
    30. 'A' => game[2] switch
    31. {
    32. 'X' => 3 + 0,
    33. 'Y' => 1 + 3,
    34. 'Z' => 2 + 6
    35. },
    37. 'B' => game[2] switch
    38. {
    39. 'X' => 1 + 0,
    40. 'Y' => 2 + 3,
    41. 'Z' => 3 + 6
    42. },
    43. 'C' => game[2] switch
    44. {
    45. 'X' => 2 + 0,
    46. 'Y' => 3 + 3,
    47. 'Z' => 1 + 6
    48. }
    49. };
    50. }
    51. Console.WriteLine($"Total Day02-PT1: {scorePt1}");
    52. Console.WriteLine($"Total Day02-PT2: {scorePt2}");
    Grüße , xChRoNiKx

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

    Habs dann schlussendlich auch hinbekommen.
    Ohne jegliche explizite branching-statements. (ich musste mir ja unbedingt so ein doofes Handicap geben)

    Naja egal, AoC 2022 - Tag 2 (GitHub)
    Spoiler anzeigen

    C-Quellcode

    1. #include <array>
    2. #include <fstream>
    3. #include <iostream>
    4. #include <string>
    6. //**********************************************************************************************************************
    7. // region Namespace
    8. //======================================================================================================================
    9. namespace
    10. {
    11. //==================================================================================================================
    12. /** The character index of the opponents figure. */
    13. constexpr int offsetOpponent = 0;
    15. /** The character index of my figure. */
    16. constexpr int offsetMe = 2;
    18. //==================================================================================================================
    19. struct Round
    20. {
    21. //==============================================================================================================
    22. char opponent;
    23. char me;
    25. //==============================================================================================================
    26. [[nodiscard]]
    27. static Round fromInput(const std::string &input) noexcept
    28. {
    29. // This only works because we know that every line of input is consistent
    30. // Otherwise we would probably do this either by tokenisation or regexing
    31. return { static_cast<char>(input[offsetOpponent] - 'A' + 1), static_cast<char>(input[offsetMe] - 'X' + 1) };
    32. }
    33. };
    35. //==================================================================================================================
    36. // Today I learned, the modulo '%' operator is not actually doing "modulo" but "remainder" instead (this seems to be the case for every language)
    37. // So I had to search for a real modulo implementation on the webs: https://stackoverflow.com/a/12277233/13170332
    38. [[nodiscard]]
    39. constexpr long modulo(long a, long b) noexcept
    40. {
    41. return (a % b + b) % b;
    42. }
    44. //==================================================================================================================
    45. constexpr std::array<int(*)(int), 3> strategies {
    46. // lose
    47. [](int figure) -> int
    48. {
    49. return modulo((figure - 2), 3) + 1;
    50. },
    52. // draw
    53. [](int figure) -> int
    54. {
    55. return figure;
    56. },
    58. // win
    59. [](int figure) -> int
    60. {
    61. return ((figure % 3) + 1);
    62. }
    63. };
    65. //==================================================================================================================
    66. [[nodiscard]]
    67. constexpr int calculateResult(int figureOpponent, int figureMe) noexcept
    68. {
    69. const int factor = ::modulo(((figureOpponent % 3) - figureMe), 3) + 1;
    70. return 3 * (factor % 3);
    71. }
    72. }
    73. //======================================================================================================================
    74. // endregion Namespace
    75. //**********************************************************************************************************************
    76. // region Main
    77. //======================================================================================================================
    78. int main()
    79. {
    80. std::fstream file(INPUT_FILE);
    81. std::string input;
    83. int opponent_points = 0;
    84. int my_points = 0;
    86. int opponent_actual_points = 0;
    87. int my_actual_points = 0;
    89. while (std::getline(file, input))
    90. {
    91. const ::Round round = ::Round::fromInput(input);
    93. // The drama of guessing what a column means
    94. const int result = ::calculateResult(round.opponent, round.me);
    95. opponent_points += (round.opponent + result);
    96. my_points += (round.me + (6 - result));
    98. // The drama of then actually hearing what it really is about
    99. const int needed_fig = strategies[round.me - 1](round.opponent);
    101. // Would probably be better to cache all possible results inside a lookup table and make a lookup instead
    102. // of calculating it everytime again, but... idrc
    103. const int result_2 = ::calculateResult(round.opponent, needed_fig);
    105. opponent_actual_points += (round.opponent + result_2);
    106. my_actual_points += (needed_fig + (6 - result_2));
    107. }
    109. std::cout << "I have won with " << my_points << " points, hooray! (opponent has: " << opponent_points << ")\n";
    110. std::cout << "For real though, actually I won with " << my_actual_points
    111. << " points, hooray! (opponent has: " << opponent_actual_points << ')';
    113. return 0;
    114. }
    115. //======================================================================================================================
    116. // endregion Main
    117. //**********************************************************************************************************************

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

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

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

    Hab es jetzt erst gesehen und konnte nicht widerstehen || Tag 1 und Tag 2

    Tag 1

    Teil 1 C#
    Spoiler anzeigen

    C#-Quellcode

    1. List<int> ElvesCals= new List<int>();
    2. var CalCount = 0;
    3. foreach (var line in File.ReadAllLines("CodeAdvent_1.txt").ToList())
    4. {
    5. if (string.IsNullOrWhiteSpace(line))
    6. {
    7. ElvesCals.Add(CalCount);
    8. CalCount = 0;
    9. }
    10. else
    11. {
    12. CalCount += int.Parse(line);
    13. }
    14. }
    15. Console.WriteLine($"{ElvesCals.Max()}");


    Noch nicht schön da ​if (string.IsNullOrWhiteSpace(line)) noch darauf angewiesen ist, dass in der Textdatei am Ende noch eine Leerzeile angefügt werden muss. Da der letzte 'Block' sonst nicht gezählt wird.

    Teil 2 C#
    Spoiler anzeigen

    C#-Quellcode

    1. List<int> ElvesCals= new List<int>();
    2. var CalCount = 0;
    3. foreach (var line in File.ReadAllLines("CodeAdvent_1.txt").ToList())
    4. {
    5. if (string.IsNullOrWhiteSpace(line))
    6. {
    7. ElvesCals.Add(CalCount);
    8. CalCount = 0;
    9. }
    10. else
    11. {
    12. CalCount += int.Parse(line);
    13. }
    14. }
    16. for (int i = 0; i < 3; i++)
    17. {
    18. CalCount += ElvesCals.Max();
    19. _= ElvesCals.Remove(ElvesCals.Max());
    20. }
    21. Console.WriteLine($"{CalCount}");​


    Tag 2

    Teil 1 C#
    Spoiler anzeigen

    C#-Quellcode

    1. var Player2FinalScore = 0;
    2. foreach (var line in File.ReadAllLines("CodeAdvent_2.txt").ToList())
    3. {
    4. Player2FinalScore += CalcPlayer2Score(ConvertInput(line.Substring(0, 1)), ConvertInput(line.Substring(2, 1)));
    5. }
    6. Console.WriteLine($"MyScore: {Player2FinalScore}");
    7. Console.ReadLine();
    9. int ConvertInput(string input)
    10. {
    11. return input switch
    12. {
    13. "A" or "X" => 1,
    14. "B" or "Y" => 2,
    15. "C" or "Z" => 3,
    16. _ => 0,
    17. };
    18. }
    20. int CalcPlayer2Score(int player1Move, int player2Move)
    21. {
    22. var player2Score = player2Move;
    23. if (player1Move == player2Move)
    24. return player2Score + 3;
    25. if (player1Move - player2Move == -1 || player1Move - player2Move == 2)
    26. return player2Score + 6;
    27. return player2Score;
    28. }


    Teil 2 C#
    Etwas messy da ich Teil eins weiterverwendet habe.
    Spoiler anzeigen

    C#-Quellcode

    1. var Player2FinalScore = 0;
    2. foreach (var line in File.ReadAllLines("CodeAdvent_2.txt").ToList())
    3. {
    4. Player2FinalScore += CalcPlayer2Score(ConvertInput(line.Substring(0, 1)), ConvertInput(line.Substring(2, 1)));
    5. }
    6. Console.WriteLine($"MyScore: {Player2FinalScore}");
    7. Console.ReadLine();
    9. int ConvertInput(string input)
    10. {
    11. return input switch
    12. {
    13. "A" or "X" => 1,
    14. "B" or "Y" => 2,
    15. "C" or "Z" => 3,
    16. _ => 0,
    17. };
    18. }
    20. int CalcPlayer2Score(int player1Move, int player2Move)
    21. {
    22. if (player2Move == 1)
    23. {//X = 1 => Lose
    24. return player1Move switch
    25. {
    26. 1 => 3,
    27. 2 => 1,
    28. 3 => 2,
    29. _ => 0
    30. };
    31. }
    32. if (player2Move == 2)
    33. {//Y = 2 => Draw
    34. return player1Move switch
    35. {
    36. 1 => 1 + 3,
    37. 2 => 2 + 3,
    38. 3 => 3 + 3,
    39. _ => 0
    40. };
    41. }
    42. if (player2Move == 3)
    43. {//Z = 3 => Win
    44. return player1Move switch
    45. {
    46. 1 => 2 + 6,
    47. 2 => 3 + 6,
    48. 3 => 1 + 6,
    49. _ => 0
    50. };
    51. }
    52. return 0;
    53. }
    codewars.com Rank: 4 kyu

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „nogood“ ()

    AoC Day 3

    Die Erste ist funktional, und die zweite eine kleine LINQ-Variante.

    Nachtrag: LINQ-Variante

    Freundliche Grüsse

    exc-jdbi


    Spoiler anzeigen

    C#-Quellcode

    1. using System.Text;
    3. namespace AdventCalendar2022;
    5. using static RandomHolder;
    7. internal class Day03
    8. {
    9. private const string Chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    11. public static void Start()
    12. {
    13. Test01();
    14. RandomTest();
    15. }
    17. private static void RandomTest()
    18. {
    19. var src = RngSource(6);
    20. var commonsign = new StringBuilder();
    21. foreach (var str in src)
    22. commonsign.Append(CommonSign(str));
    23. var priority = CalcPriority(commonsign.ToString());
    25. Console.WriteLine($"Common Sign = {commonsign}; priority = {priority}");
    26. Console.WriteLine();
    27. Console.ReadLine();
    28. }
    30. private static void Test01()
    31. {
    32. var src = Source();
    33. var commonsign = new StringBuilder();
    34. foreach (var str in src)
    35. commonsign.Append(CommonSign(str));
    36. var priority = CalcPriority(commonsign.ToString());
    38. Console.WriteLine($"Common Sign = {commonsign}; priority = {priority}");
    39. Console.WriteLine();
    40. Console.ReadLine();
    41. }
    43. private static int CalcPriority(string source)
    44. {
    45. var result = 0;
    46. foreach (var c in source)
    47. result += Chars.IndexOf(c) + 1;
    48. return result;
    49. }
    51. private static char CommonSign(string source)
    52. {
    53. var split = HalfString(source);
    54. foreach (var c in split[0])
    55. if (split[1].Contains(c))
    56. return c;
    57. return char.MinValue;
    58. }
    60. private static string[] HalfString(string source)
    61. {
    62. var half = source.Length / 2;
    63. var str1 = source[..half]; //Substring(0, half);
    64. var str2 = source[half..]; //Substring(half);
    65. return new string[] { str1, str2 };
    66. }
    68. private static string[] RngSource(int knapsackcount, int min = 16, int max = 32)
    69. {
    70. var chars = Enumerable.Range(0, knapsackcount).Select(x => RngChars(Rand.Next(min, max))).ToArray();
    72. char ch;
    73. for (var i = 0; i < chars.Length; i++)
    74. {
    75. var halflength = chars[i].Length / 2;
    76. ch = chars[i][Rand.Next(halflength)];
    77. chars[i][halflength + Rand.Next(halflength)] = ch;
    78. }
    79. return ToStrings(chars);
    81. }
    83. private static string[] ToStrings(char[][] source)
    84. {
    85. var result = new string[source.Length];
    86. for (var i = 0; i < result.Length; i++)
    87. result[i] = string.Join(string.Empty, source[i]);
    88. return result;
    89. }
    91. private static char[] RngChars(int size)
    92. {
    93. if ((size & 1 )== 1) size += 1;
    94. return Chars.OrderBy(x => Rand.Next()).Take(size).ToArray();
    95. }
    97. private static string[] Source()
    98. {
    99. return new string[]
    100. {
    101. "vJrwpWtwJgWrhcsFMMfFFhFp",
    102. "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL",
    103. "PmmdzqPrVvPwwTWBwg",
    104. "wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn",
    105. "ttgJtRGJQctTZtZT",
    106. "CrZsJsPPZsGzwwsLwLmpwMDw"
    107. };
    108. }
    109. }


    Spoiler anzeigen

    C#-Quellcode

    1. private static void Start()
    2. {
    3. var src = Source();
    4. var data = src.Select(str =>
    5. {
    6. var c = str[..(str.Length / 2)].Where(ch => str[(str.Length / 2)..].Contains(ch)).First();
    7. var idx = (c > 96) ? c - 96 : c - 38;
    8. return (c, idx);
    9. });
    10. var priority = data.Sum(itm => itm.idx);
    11. var commonsign = string.Join(string.Empty, data.Select(d => d.c).ToArray());
    12. PrintOut(src, commonsign, priority);
    13. Console.ReadLine();
    14. }
    16. private static void PrintOut(string[] source, string commonsign, int priority)
    17. {
    18. Array.ForEach(source, str => Console.WriteLine(str));
    19. Console.WriteLine();
    20. Console.WriteLine($"Common Sign = {commonsign}; priority = {priority}");
    21. Console.WriteLine();
    22. Console.WriteLine();
    23. }
    25. private static string[] Source()
    26. {
    27. return new string[]
    28. {
    29. "vJrwpWtwJgWrhcsFMMfFFhFp",
    30. "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL",
    31. "PmmdzqPrVvPwwTWBwg",
    32. "wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn",
    33. "ttgJtRGJQctTZtZT",
    34. "CrZsJsPPZsGzwwsLwLmpwMDw"
    35. };
    36. }

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

    AoC Tag 3

    Tag 3

    Heute musste ich schon deutlich mehr Zeit ins Debugging und Aufgabenstellung lesen/verstehen stecken.

    Teil 1 C#
    Spoiler anzeigen

    C#-Quellcode

    1. var Lines = File.ReadAllLines("CodeAdvent_3.txt");
    2. var Sum = 0;
    3. foreach (var line in Lines)
    4. {
    5. var firstHalf = line.Substring(0, line.Length/2).ToCharArray().Distinct();
    6. var secondHalf = line.Substring((line.Length/2), line.Length/2).ToCharArray().Distinct();
    7. var res = firstHalf.Where(x => secondHalf.Contains(x)).First();
    8. var myint = (int)res;
    10. if (myint <= 90)
    11. myint -= 38;
    12. if (myint >= 97)
    13. myint -= 96;
    14. Sum += myint;
    15. }
    16. Console.WriteLine(Sum);


    Teil 2 C#
    Spoiler anzeigen

    C#-Quellcode

    1. var Lines = File.ReadAllLines("CodeAdvent_3.txt");
    2. var Sum = 0;
    3. for (int i = 0; i < Lines.Length; i+=3)
    4. {
    5. var elf1 = Lines[i+0].ToCharArray().Distinct();
    6. var elf2 = Lines[i+1].ToCharArray().Distinct();
    7. var elf3 = Lines[i+2].ToCharArray().Distinct();
    8. var elf1Andelf2Same = elf1.Where(x => elf2.Contains(x));
    9. var elfBadge = elf1Andelf2Same.Where(x => elf3.Contains(x)).First();
    10. var myInt = (int)elfBadge;
    11. if (myInt <= 90)
    12. myInt -= 38;
    13. if (myInt >= 97)
    14. myInt -= 96;
    15. Sum += myInt;
    16. }
    17. Console.WriteLine(Sum);


    Es riecht nach LINQ One-Liner ...
    codewars.com Rank: 4 kyu

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „nogood“ ()

    nogood schrieb:

    Es riecht nach LINQ One-Liner ...

    Ja so in der Art.

    Tag 03 Part 1 und 2:
    Spoiler anzeigen

    Wenn man sich die ASCI Tabelle anschaut: yorktown.cbe.wwu.edu/sandvig/shared/asciicodes.aspx
    Fällt einem sicher schnell auf das die Buchstaben a bis z die Zahlen 97 - 122 sind und A bis Z 65 - 90.
    Um also die Prio zu bekommen brauchen wir bei Buchstaben die einen Zahlenwert größer 96 haben immer nur MINUS 96 rechnen Beispiel: h = 104 - 96 = 8.

    Für den ersten Part machen wir die Zeile zu nem CharArray -> holen uns per Chunk genau die hälfte und haben damit 2 "chunks".
    Danach prüfen wir einfach welche Chars vom ersten Chunk sind auch im 2. Chunk vorhanden (Intersect) und holen uns davon den ersten ( es gibt immer nur einen ).
    Das summieren wir per Sum mit der Funktion score.

    Für den 2. Part holen wir uns uns immer 3 Zeilen nutzen Aggregate um mit Intersect für jede Zeile alle Buchstaben / Item types zu bekommen die in allen vorhanden sind.
    Ich kann Aggregate ganz schlecht selbst erklären dafür gibt es das: Aggregate im Prinzip führt Aggregate diese Funktion jetzt immer mit den Werten des Ergebnisses vom vorherigen Aufruf aus.
    Im Example auf der Seite haben wir ja folgende Lines:

    vJrwpWtwJgWrhcsFMMfFFhFp
    jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
    PmmdzqPrVvPwwTWBwg

    Jetzt prüft Aggregate erstmal welche gleichen Zeichen es gibt von der 1. und der 2. Zeile die übrig gebliebenen Zeichen ( hier jetzt "rsFMf" ) pack ich mit ToArray in ein char array.
    Nun nimmt Aggregate das CharArray vom ersten Aufruf "rsFMf" und vergleich das mit der 3. Zeile "PmmdzqPrVvPwwTWBwg". Jetzt bleib nur noch "r" übrig das geht in ein CharArray.
    Da hier dann nur noch eins möglich sein kann nehme ich mit First das erste und habe damit mein Ergebnis. Diesen Char pack ich wieder in die Score Funktion und habe damit das Ergebnis.

    Ich bin echt schlecht im erklären hoffe aber das dies etwas Licht ins dunkle bringt.

    C#-Quellcode

    1. string[] lines = File.ReadAllLines("Input.txt");
    2. int score(char c)
    3. {
    4. return (c > 96) ? c - 96 : c - 38;
    5. }
    6. Console.WriteLine(lines
    7. .Select(e => e.ToCharArray().Chunk(e.Length / 2))
    8. .Select(r => r.First().Intersect(r.Last()).First())
    9. .Sum(score));
    11. Console.WriteLine(lines
    12. .Select(e => e.ToCharArray()).Chunk(3)
    13. .Select(e => e.Aggregate((r, t) => r.Intersect(t).ToArray()).First())
    14. .Sum(score));
    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“ ()

    Part 1
    Spoiler anzeigen

    C#-Quellcode

    1. using var sr = new StreamReader(File.OpenRead("input.txt"));
    2. Stack<char> containing = new();
    3. while (!sr.EndOfStream)
    4. {
    5. var line = sr.ReadLine()!.AsSpan();
    6. var s = (line.Length / 2);
    7. var f = line[..s];
    8. var l = line[s..];
    10. for (int i = 0; i < f.Length; ++i)
    11. {
    12. if (l.Contains(f[i]))
    13. {
    14. containing.Push(f[i]);
    15. break;
    16. }
    17. }
    18. }
    20. int prio = 0;
    21. while (containing.Count > 0)
    22. {
    23. char c = containing.Pop();
    24. prio += c switch
    25. {
    26. >= (char)97 => (c - 97) + 1,
    27. >= (char)65 => (c - 65) + 27,
    28. _ => 0
    29. };
    30. }
    32. sr.Close();
    34. Console.WriteLine(prio);


    Und Part 2
    Spoiler anzeigen

    C#-Quellcode

    1. using var sr = new StreamReader(File.OpenRead(@"D:\Dev\net\AdventOfCode22\Day3\input.txt"));
    2. Stack<char> containing = new();
    3. Stack<string> group = new();
    4. while (!sr.EndOfStream)
    5. {
    6. group.Push(sr.ReadLine());
    8. if (group.Count == 3)
    9. {
    10. ReadOnlySpan<char> g1 = group.Pop().AsSpan();
    11. ReadOnlySpan<char> g2 = group.Pop().AsSpan();
    12. ReadOnlySpan<char> g3 = group.Pop().AsSpan();
    13. for (int i = 0; i < g3.Length; ++i)
    14. {
    15. if (g1.Contains(g3[i]) && g2.Contains(g3[i]))
    16. {
    17. containing.Push(g3[i]);
    18. break;
    19. }
    20. }
    21. }
    22. }
    24. int prio = 0;
    25. while (containing.Count > 0)
    26. {
    27. char c = containing.Pop();
    28. prio += c switch
    29. {
    30. >= (char)97 => (c - 97) + 1,
    31. >= (char)65 => (c - 65) + 27,
    32. _ => 0
    33. };
    34. }
    36. sr.Close();
    38. Console.WriteLine(prio);


    Edit: Ich habe mal Part 1 von diesem Tag in AL umgesetzt. :whistling:
    Spoiler anzeigen

    Quellcode

    1. codeunit 50100 Day3
    2. {
    3. trigger OnRun()
    4. var
    5. ServerFileName: Text;
    6. WindowTitleTxt: Label 'Choose Input File';
    7. begin
    8. // Dateien können nur auf dem Service-Tier verarbeitet werden
    9. ServerFileName := FileManagement.UploadFile(WindowTitleTxt, '');
    11. Message(
    12. Format(
    13. CalculatePriorityInRucksack(ServerFileName)));
    15. // Aufräumen
    16. FileManagement.DeleteServerFile(ServerFileName);
    17. end;
    19. var
    20. FileManagement: Codeunit "File Management";
    22. local procedure CalculatePriorityInRucksack(ServerFileName: Text): Integer
    23. var
    24. StreamReader: Codeunit DotNet_StreamReader;
    25. Encoding: Codeunit DotNet_Encoding;
    26. InputFile: File;
    27. FileInStream: InStream;
    28. Line: Text;
    29. Items: List of [Char];
    30. Priority: Integer;
    31. begin
    32. Priority := 0;
    34. if not InputFile.Open(ServerFileName) then
    35. exit;
    37. InputFile.CreateInStream(FileInStream);
    39. Encoding.UTF8();
    40. StreamReader.StreamReader(FileInStream, Encoding);
    41. while not StreamReader.EndOfStream() do begin
    42. Items.Add(CollectContainingItems(StreamReader.ReadLine()));
    43. end;
    45. Priority := CalculatePriority(Items);
    47. StreamReader.Close();
    48. StreamReader.Dispose();
    50. exit(Priority);
    51. end;
    53. local procedure CollectContainingItems(Line: Text) Item: Char
    54. var
    55. i: Integer;
    56. j: Integer;
    57. Len: Integer;
    58. FirstHalf: Text;
    59. SecondHalf: Text;
    60. begin
    61. Len := StrLen(Line) / 2;
    62. FirstHalf := CopyStr(Line, 1, Len);
    63. SecondHalf := CopyStr(Line, Len + 1);
    65. for i := 1 to StrLen(FirstHalf) do
    66. for j := 1 to StrLen(SecondHalf) do
    67. if FirstHalf[i] = SecondHalf[j] then
    68. exit(FirstHalf[i]);
    69. end;
    71. local procedure CalculatePriority(Items: List of [Char]) Priority: Integer
    72. var
    73. c: Char;
    74. begin
    75. Priority := 0;
    76. foreach c in Items do
    77. case true of
    78. c >= 97:
    79. Priority += (c - 97) + 1;
    80. c >= 65:
    81. Priority += (c - 65) + 27;
    82. end;
    83. end;
    84. }

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

    Heute mal wieder komplett übertrieben aber gut... mein Handicap heute war "nur C++ Templates" (es geht bestimmt auch kürzer, aber ich nehme immer das erste das funktioniert für AoC)

    AoC 2022 - Tag 3 (GitHub)
    Spoiler anzeigen

    C-Quellcode

    1. #include <algorithm>
    2. #include <array>
    3. #include <iostream>
    4. #include <string_view>
    6. //**********************************************************************************************************************
    7. // region Namespace
    8. //======================================================================================================================
    9. namespace
    10. {
    11. //==================================================================================================================
    12. // We include the input as an array
    13. constexpr std::array input {
    14. #include "input.txt"
    15. };
    17. constexpr std::size_t maxCompartmentSize = []()
    18. {
    19. std::size_t max = 0;
    21. for (const char *rucksack : input)
    22. {
    23. const std::string_view entry { rucksack };
    24. const std::size_t csize = (entry.length() / 2);
    26. if (csize > max)
    27. {
    28. max = csize;
    29. }
    30. }
    32. return max;
    33. }();
    35. constexpr std::size_t priorityOffsetLower = ('a' - 1);
    36. constexpr std::size_t priorityOffsetUpper = ('A' - 27);
    38. //==================================================================================================================
    39. using UniqueArray = std::array<char, maxCompartmentSize>;
    41. //==================================================================================================================
    42. [[nodiscard]]
    43. constexpr auto filterCompartmentDuplicates(std::string_view data)
    44. {
    45. UniqueArray buffer {};
    46. int index = 0;
    48. for (const char c : data)
    49. {
    50. auto it = buffer.begin();
    52. for (; *it != 0; ++it)
    53. {
    54. if (*it == c)
    55. {
    56. break;
    57. }
    58. }
    60. if (*it == 0)
    61. {
    62. buffer[index++] = c;
    63. }
    64. }
    66. return buffer;
    67. }
    69. //==================================================================================================================
    70. template<const auto &AllInputs, std::size_t Index>
    71. struct Group
    72. {
    73. //==============================================================================================================
    74. using NextGroup = std::conditional_t<((Index + 3) == AllInputs.size()), void, Group<AllInputs, Index + 3>>;
    76. //==============================================================================================================
    77. static constexpr std::array<std::string_view, 3> group {
    78. AllInputs[Index],
    79. AllInputs[Index + 1],
    80. AllInputs[Index + 2]
    81. };
    82. };
    84. template<const auto &AllInputs, std::size_t Index>
    85. struct Entry
    86. {
    87. static constexpr std::string_view value = AllInputs[Index];
    88. };
    90. template<class Input, std::size_t Offset, std::size_t Length>
    91. struct Compartment
    92. {
    93. static constexpr std::string_view inventory = std::string_view(Input::value).substr(Offset, Length);
    94. };
    96. template<class Input>
    97. struct Rucksack
    98. {
    99. //==============================================================================================================
    100. static constexpr std::string_view input { Input::value };
    101. static constexpr std::size_t inventoryOffset = (input.size() / 2);
    103. //==============================================================================================================
    104. using Compartment1 = Compartment<Input, 0, inventoryOffset>;
    105. using Compartment2 = Compartment<Input, inventoryOffset, (input.length() - inventoryOffset)>;
    107. //==============================================================================================================
    108. [[nodiscard]]
    109. static constexpr std::size_t calculatePriorities() noexcept
    110. {
    111. std::size_t priorities = 0;
    112. const UniqueArray filtered = filterCompartmentDuplicates(Compartment1::inventory);
    114. for (auto it = filtered.begin(); *it != 0; ++it)
    115. {
    116. const char c = *it;
    118. for (const char c2 : Compartment2::inventory)
    119. {
    120. if (c == c2)
    121. {
    122. // Upper
    123. if (c <= 'Z')
    124. {
    125. priorities += (c - priorityOffsetUpper);
    126. }
    128. // Lower
    129. else
    130. {
    131. priorities += (c - priorityOffsetLower);
    132. }
    134. break;
    135. }
    136. }
    137. }
    139. return priorities;
    140. }
    141. };
    143. template<std::size_t Size, std::size_t Offset, class Sequence = std::make_index_sequence<Size>>
    144. struct make_index_sequence_off;
    146. template<std::size_t Size, std::size_t ...Indices, std::size_t Offset>
    147. struct make_index_sequence_off<Size, Offset, std::index_sequence<Indices...>>
    148. {
    149. using type = std::index_sequence<Indices + Offset...>;
    150. };
    152. template<std::size_t Size, std::size_t Offset>
    153. using make_index_sequence_off_t = typename make_index_sequence_off<Size, Offset>::type;
    155. // A simple placeholder with a list of index sequences, we can unpack this one to make use of them individually
    156. template<class ...IndexSequences>
    157. struct ISeqArray {};
    159. // We want to split up our indices into several std::index_sequence types
    160. template<std::size_t Size, std::size_t LastSize, class ...Sequences>
    161. struct IndexSequenceSplitter
    162. : IndexSequenceSplitter<Size,
    163. LastSize + std::min<std::size_t>(Size - LastSize, 50),
    164. Sequences...,
    165. make_index_sequence_off_t<std::min<std::size_t>(Size - LastSize, 50), LastSize>>
    166. {};
    168. template<std::size_t Size, class ...Sequences>
    169. struct IndexSequenceSplitter<Size, Size, Sequences...>
    170. {
    171. using type = ISeqArray<Sequences...>;
    172. };
    174. // We want to split up our fold expressions to max 50 calculations, because there is a limit to them (which we are exceeding)
    175. template<const auto &AllInputs, std::size_t Result, class ...IndexSequences>
    176. struct FoldExpressionSplitter;
    178. template<const auto &AllInputs, std::size_t Result, class ...OtherSequences, std::size_t ...CurrentIndices>
    179. struct FoldExpressionSplitter<AllInputs, Result, std::index_sequence<CurrentIndices...>, OtherSequences...>
    180. : FoldExpressionSplitter<AllInputs,
    181. Result + (Rucksack<Entry<AllInputs, CurrentIndices>>::calculatePriorities() + ...),
    182. OtherSequences...>
    183. {};
    185. template<const auto &AllInputs, std::size_t Result, std::size_t ...CurrentIndices>
    186. struct FoldExpressionSplitter<AllInputs, Result, std::index_sequence<CurrentIndices...>>
    187. {
    188. static constexpr std::size_t value
    189. = (Result + (Rucksack<Entry<AllInputs, CurrentIndices>>::calculatePriorities() + ...));
    190. };
    192. // A tiny wrapper
    193. template<const auto &AllInputs, class IndexSequenceArray>
    194. struct PriorityEvaluator;
    196. template<const auto &AllInputs, class ...IndexSequences>
    197. struct PriorityEvaluator<AllInputs, ISeqArray<IndexSequences...>>
    198. {
    199. static constexpr int priorities = FoldExpressionSplitter<AllInputs, 0, IndexSequences...>::value;
    200. };
    202. // Evaluates all badge's priorities
    203. template<class Group>
    204. struct BadgeEvaluator
    205. {
    206. private:
    207. using Next = typename Group::NextGroup;
    209. //==============================================================================================================
    210. static constexpr std::size_t evaluateGroup()
    211. {
    212. for (const char c : Group::group[0])
    213. {
    214. for (const char c2 : Group::group[1])
    215. {
    216. if (c == c2)
    217. {
    218. for (const char c3 : Group::group[2])
    219. {
    220. if (c2 == c3)
    221. {
    222. // Upper
    223. if (c <= 'Z')
    224. {
    225. return (c - priorityOffsetUpper);
    226. }
    228. // Lower
    229. else
    230. {
    231. return (c - priorityOffsetLower);
    232. }
    234. break;
    235. }
    236. }
    237. }
    238. }
    239. }
    241. return 0;
    242. }
    244. static constexpr std::size_t getNext()
    245. {
    246. if constexpr (std::is_same_v<Next, void>)
    247. {
    248. return 0;
    249. }
    250. else
    251. {
    252. return BadgeEvaluator<Next>::priorities;
    253. }
    254. }
    256. public:
    257. static constexpr std::size_t priorities = evaluateGroup() + getNext();
    258. };
    259. }
    260. //======================================================================================================================
    261. // endregion Namespace
    262. //**********************************************************************************************************************
    263. // region Main
    264. //======================================================================================================================
    265. int main()
    266. {
    267. using IndexList = ::IndexSequenceSplitter<::input.size(), 0>::type;
    268. std::cout << "All duplicates priorities is: " << ::PriorityEvaluator<::input, IndexList>::priorities << '\n';
    270. std::cout << "All badge's priorities is: " << ::BadgeEvaluator<::Group<::input, 0>>::priorities << '\n';
    272. return 0;
    273. }
    274. //======================================================================================================================
    275. // endregion Main
    276. //**********************************************************************************************************************



    Edit: Wollte nur noch erwähnen, an die C++ devs die das hier lesen, bitte nehmt euch kein Beispiel an diesem Code.
    Dieser ist inkonsequent sowohl mit den Typen als auch den Entitäten, nicht geordnet und da ist viel unnötiger Clutter den es eigentlich nicht bräuchte.
    Ich wollte es, mit meinem Handicap, nur so schnell zum laufen bringen wie möglich.
    ----------------------------------------------------------------------------------------------------------------------

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

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

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

    nogood schrieb:

    Könntest Du noch ein, zwei Sätze zu Deiner Lösung schreiben. DANKE


    Hab ich oben mal hinzu editiert im Spoiler ich hoffe ist verständlich... Bin echt schlecht im Erklären mancher dinge. Zum Post
    Grüße , xChRoNiKx

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

    @nogood Jetzt wo du es erwähnst, villeicht hätte ich den Thread in "Weitere Sprachen und sprachübergreifende Themen" erstellen sollen, so off-topic is das ganze ja nun auch wieder nicht.

    @Marcus Gräfe, wäre das "thematisch" bitte möglich diesen Thread zu verschieben? Es ist ja eigentlich on-topic. (Dieses Wort hab ich auch noch nie verwendet)
    ----------------------------------------------------------------------------------------------------------------------

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

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

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Elanda“ ()

    Tag 4

    Teil1 & Teil2 C#
    Spoiler anzeigen

    C#-Quellcode

    1. using System.Text.RegularExpressions;
    2. //--Main
    3. List<Match> SectionLimits = new();
    4. List<ElfTeam> ElvesTeams = new();
    5. var Lines = File.ReadAllLines("CodeAdvent_4.txt");
    7. foreach (var line in Lines)
    8. {
    9. SectionLimits = Regex.Matches(line, @"\d+").ToList();
    10. ElvesTeams.Add(new ElfTeam(int.Parse(SectionLimits[0].Value), int.Parse(SectionLimits[1].Value), int.Parse(SectionLimits[2].Value), int.Parse(SectionLimits[3].Value)));
    11. }
    12. Console.WriteLine($"Is Overlapping: {ElvesTeams.Where(x => x.IsOverlapping).ToList().Count}");
    13. Console.WriteLine($"Is FullyOverlapping: {ElvesTeams.Where(x => x.IsFullyOverlapping).ToList().Count}");
    14. //--Class
    15. class ElfTeam
    16. {
    17. public ElfTeam(int elf1Low, int elf1High, int elf2Low, int elf2High)
    18. {
    19. Elf1Low = elf1Low;
    20. Elf1High = elf1High;
    21. Elf2Low = elf2Low;
    22. Elf2High = elf2High;
    23. SetIsOverlapping();
    24. SetIsFullyOverlapping();
    25. }
    27. public int Elf1Low { get; set; } = 0;
    28. public int Elf1High { get; set; } = 0;
    29. public int Elf2Low { get; set; } = 0;
    30. public int Elf2High { get; set; } = 0;
    31. public bool IsOverlapping { get; set; } = false;
    32. public bool IsFullyOverlapping { get; set; } = false;
    34. private void SetIsOverlapping()
    35. {
    36. if (Elf1Low <= Elf2Low && Elf1High >= Elf2Low || Elf1High >= Elf2High && Elf1High <= Elf2Low)
    37. IsOverlapping = true;
    38. if (Elf2Low <= Elf1Low && Elf2High >= Elf1Low || Elf2High >= Elf1High && Elf2High <= Elf1Low)
    39. IsOverlapping = true;
    40. }
    41. private void SetIsFullyOverlapping()
    42. {
    43. if (Elf1Low <= Elf2Low && Elf1High >= Elf2High)
    44. IsFullyOverlapping = true;
    45. if (Elf2Low <= Elf1Low && Elf2High >= Elf1High)
    46. IsFullyOverlapping = true;
    47. }
    48. }
    codewars.com Rank: 4 kyu

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „nogood“ ()

Facebook
Telefonspende