Øystein Bjørkeng Haugen C#3

exercise.main/Card.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace exercise.main
+{
+    public class Card
+    {
+        private string _suit;
+        private string _value;
+        public Card(string Suit, string Value ) { 
+            _value = Value;
+            _suit = Suit;
+        }
+        public string Suit { get { return _suit;  } set { _suit = value; } }
+        public string Value { get { return _value; } set { _value = value; } }
+    }
+}

exercise.main/Core.cs

@@ -15,18 +15,62 @@ public class Core
         //TODO: complete the following method, keeping the signature the same
         public bool winningPair(IEnumerable<Tuple<string, string>> hand, out Tuple<string, string> result)
         {
-            result = new Tuple<string,string>(string.Empty, string.Empty);
-
+            //result = new Tuple<string,string>(string.Empty, string.Empty);
+            result = iterateHands(hand);
 
-
+            return result.Item1!=string.Empty ? true : false;
+        }
 
-
+        public Tuple<string, string> iterateHands(IEnumerable<Tuple<string, string>> hand)
+        {
+            Dictionary<Tuple<string, string>, int> pairs = new Dictionary<Tuple<string, string>, int>(); 
+            foreach (var item in hand)
+            {
+                if (decidePair(item.Item1, item.Item2).Item1)
+                {
+                    pairs.Add(item, decidePair(item.Item1, item.Item2).Item2);
+                }
+            }
+            if(pairs.Count == 0) {
+                return new Tuple<string, string>(string.Empty, string.Empty);
+            }
+            return pairs.OrderByDescending(i => i.Value).First().Key;
+
+        }
 
-            return result.Item1!=string.Empty ? true : false;
+        public Tuple<bool,int> decidePair(string card1, string card2)
+        {
+            int card1Value = GetValueOfCard(card1);
+            int card2Value = GetValueOfCard(card2);
+
+            return Tuple.Create(card1Value == card2Value, card1Value + card2Value);
         }
+
         public int GetValueOfCard(string card)
         {
-            return  0;           
+            int value = 0;
+            try
+            {
+                value = Int32.Parse(card);
+            }
+            catch(FormatException) {
+                switch(card)
+                {
+                    case "A":
+                        value = 14;
+                        break;
+                    case "K":
+                        value = 13;
+                        break;
+                    case "Q":
+                        value = 12;
+                        break;
+                    case "J":
+                        value = 11;
+                        break;
+                }
+            }
+            return value;           
         }
     }
 }

exercise.main/Deck.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace exercise.main
+{
+    public class Deck
+    {
+        private List<Card> _cardList = new ();
+        public Deck() { }
+
+        public void Shuffle()
+        {
+            for(int i = CardList.Count - 1; i >= 0; i--)
+            {
+                Random r = new Random();
+                int j = r.Next(0, i);
+                Card temp = CardList[i];
+                CardList[i] = CardList[j];
+                CardList[j] = temp;
+            }
+        }
+
+        public Card Deal()
+        {
+            return CardList[-1];
+        }
+
+        public List<Card> CardList { get { return _cardList; } set { _cardList = value; } }
+
+    }
+}

exercise.main/Extension.cs

@@ -11,9 +11,65 @@ public class Extension
         //TODO: complete the following method, keeping the signature the same
         public bool winningThree(IEnumerable<Tuple<string, string, string>> hand, out Tuple<string, string, string> result)
         {
-            result = new Tuple<string, string, string>(string.Empty, string.Empty, string.Empty);
+            result = iterateHands(hand);
+            return result.Item1 != string.Empty ? true : false ;
+        }
+
+        public Tuple<string, string, string> iterateHands(IEnumerable<Tuple<string, string, string>> hand)
+        {
+            Dictionary<Tuple<string, string, string>, int> pairs = new Dictionary<Tuple<string, string, string>, int>();
+            foreach (var item in hand)
+            {
+                if (decideThrees(item.Item1, item.Item2, item.Item3).Item1)
+                {
+                    pairs.Add(item, decideThrees(item.Item1, item.Item2, item.Item3).Item2);
+                }
+            }
+            if (pairs.Count == 0)
+            {
+                return new Tuple<string, string, string>(string.Empty, string.Empty, string.Empty);
+            }
+            return pairs.OrderByDescending(i => i.Value).First().Key;
+
+        }
+
+        public Tuple<bool, int> decideThrees(string card1, string card2, string card3)
+        {
+            int card1Value = GetValueOfCard(card1);
+            int card2Value = GetValueOfCard(card2);
+            int card3Value = GetValueOfCard(card3);
+
+            return Tuple.Create(card1Value == card2Value && card2Value == card3Value, card1Value + card2Value + card3Value);
+        }
 
-            return false;
+
+
+        public int GetValueOfCard(string card)
+        {
+            int value = 0;
+            try
+            {
+                value = Int32.Parse(card);
+            }
+            catch (FormatException)
+            {
+                switch (card)
+                {
+                    case "A":
+                        value = 14;
+                        break;
+                    case "K":
+                        value = 13;
+                        break;
+                    case "Q":
+                        value = 12;
+                        break;
+                    case "J":
+                        value = 11;
+                        break;
+                }
+            }
+            return value;
         }
 
     }

exercise.main/Player.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace exercise.main
+{
+    public class Player
+    {
+        private string _name;
+        private List<Card> _hand;
+
+        public void addToHand(Card card)
+        {
+            Hand.Add(card);
+        }
+
+        public void removeFromHand(Card card)
+        {
+            Hand.Remove(card);
+        }
+
+        public void clearHand()
+        {
+            Hand.Clear();
+        }
+
+        public List<Card> showHands()
+        {
+            return Hand;
+        }
+
+        public string Name { get { return _name; } set { _name = value; } } 
+        public List<Card> Hand { get { return _hand; } set { _hand = value; } } 
+    }
+}

exercise.main/PokerGame.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace exercise.main
+{
+    public class PokerGame
+    {
+        private Player _player1;
+        private Player _player2;
+
+        private Deck _deck = new Deck();
+        private List<Card> _boardState = new List<Card>();
+        private List<Card> _discardPile = new List<Card>();
+
+        public void addToBoardState(Card card)
+        {
+            BoardState.Add(card);
+        }
+
+        public void initialDeal()
+        {
+            Player1.addToHand(Deck.Deal());
+            Player2.addToHand(Deck.Deal());
+            Player1.addToHand(Deck.Deal());
+            Player2.addToHand(Deck.Deal());
+        }
+
+        public void flop()
+        {
+            DiscardPile.Add(Deck.Deal());
+            BoardState.Add(Deck.Deal());
+            BoardState.Add(Deck.Deal());
+            BoardState.Add(Deck.Deal());
+        }
+
+        public void turn()
+        {
+            DiscardPile.Add(Deck.Deal());
+            BoardState.Add(Deck.Deal());
+        }
+
+        public void river()
+        {
+            DiscardPile.Add(Deck.Deal());
+            BoardState.Add(Deck.Deal());
+        }
+
+        public Player Player1 { get { return _player1; } set { _player1 = value; } }
+        public Player Player2 { get { return _player2; } set { _player2 = value; } }
+        public Deck Deck { get { return Deck; } set { Deck = value; } }
+
+        public List<Card> BoardState { get { return BoardState;  } set { BoardState = value; } }
+        public List<Card> DiscardPile { get { return _discardPile;  } set { _discardPile = value; } }
+    }
+}

exercise.tests/ExtensionTests.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using exercise.main;
+
+
+namespace exercise.tests;
+
+public class ExtensionTests
+{
+    [Test]
+    public void Scenario1()
+    {
+        Extension extension = new Extension();
+
+        List<Tuple<string, string, string>> hand = new List<Tuple<string, string, string>>
+        {
+            new Tuple<string, string, string>("K", "5", "7"),
+            new Tuple<string, string, string>("3","7", "7")
+        };
+        Tuple<string, string, string> winner;
+
+        bool result = extension.winningThree(hand, out winner);
+
+        Assert.That(result, Is.False);
+        Assert.That(winner.Item1, Is.EqualTo(String.Empty));
+        Assert.That(winner.Item2, Is.EqualTo(String.Empty));
+
+    }
+    [Test]
+    public void Scenario2()
+    {
+        Extension ext = new Extension();
+
+        List<Tuple<string, string, string>> hand = new List<Tuple<string, string, string>>
+        {
+            new Tuple<string, string, string>("K", "K", "K"),
+            new Tuple<string, string, string>("A","A", "A")
+        };
+        Tuple<string, string, string> winner;
+        bool result = ext.winningThree(hand, out winner);
+
+        Assert.That(result, Is.True);
+
+        Assert.IsTrue(winner.Item1 == "A" && winner.Item2 == "A" && winner.Item3 =="A");
+
+    }
+    [Test]
+    public void Scenario3()
+    {
+        Extension ext = new Extension();
+
+        List<Tuple<string, string, string>> hand = new List<Tuple<string, string, string>>
+        {
+            new Tuple<string, string, string>("8", "8", "8"),
+            new Tuple<string, string, string>("A","5", "A"),
+            new Tuple<string, string, string>("A","A", "3"),
+            new Tuple<string, string, string>("J","J", "J"),
+        };
+        Tuple<string, string, string> winner;
+        bool result = ext.winningThree(hand, out winner);
+
+        Assert.That(result, Is.True);
+
+        Assert.IsTrue(winner.Item1 == "J" && winner.Item2 == "J" && winner.Item3 == "J");
+
+    }
+}
+
+