Sebb

Sebb

can you show me those?

0
Post #21
zoedsoupe

zoedsoupe OP

Those test cases handle only the winner’s deck, so I modified your code a little

Here’s the code:

defmodule War do
  import Enum

  @trace false

  defp play(decks) do
    round_(:normal, decks, [])
  end

  defp round_(state, {deck_1, deck_2}, pot) do
    if @trace, do: dbg({state, {deck_1, deck_2}, pot})
    round(state, {deck_1, deck_2}, pot)
  end

  defp round(_, {[], []}, _), do: :draw
  defp round(_, {p1, []}, _), do: p1
  defp round(_, {[], p2}, _), do: p2

  defp round(:war, {[c, c1 | d1], [c, c2 | d2]}, pot) do
    round_(:war, {d1, d2}, pot ++ [c, c1, c, c2])
  end

  defp round(:war, {[c11, c12 | d1], [c21, c22 | d2]}, pot) do
    round_(:normal, decks(c11, c21, d1, d2, pot ++ [c11, c12, c21, c22]), [])
  end

  defp round(_, {[c | d1], [c | d2]}, pot) do
    round_(:war, {d1, d2}, pot ++ [c, c])
  end

  defp round(_, {[c1 | d1], [c2 | d2]}, pot) do
    round_(:normal, decks(c1, c2, d1, d2, [c1, c2]), pot)
  end

  defp decks(c1, c2, d1, d2, pot) do
    pot = sort(pot, :desc)
    if c1 > c2, do: {d1 ++ pot, d2}, else: {d1, d2 ++ pot}
  end

    defp apply_ace_weight(card) do
    (card == 1 && 14) || card
  end

  defp remove_ace_weight(card) do
    (card == 14 && 1) || card
  end

  def deal(deck) do
    deck
    |> Enum.map(&apply_ace_weight/1)
    |> split(length(deck) * 2)
    |> play()
    |> case do
      xs when is_list(xs) -> Enum.map(xs, &remove_ace_weight/1)
      r -> r
    end
  end
end

ExUnit.start()

defmodule WarTest do
    use ExUnit.Case

  describe "War" do
    test "deal_1" do
      t1 = [1,1,1,1,13,13,13,13,11,11,11,11,12,12,12,12,10,10,10,10,9,9,9,9,7,7,7,7,8,8,8,8,6,6,6,6,5,5,5,5,4,4,4,4,3,3,3,3,2,2,2,2]
      r1 = [1,1,1,1,13,13,13,13,12,12,12,12,11,11,11,11,10,10,10,10,9,9,9,9,8,8,8,8,7,7,7,7,6,6,6,6,5,5,5,5,4,4,4,4,3,3,3,3,2,2,2,2]
      assert War.deal(t1) == r1
    end

    test "deal_2" do
      t2 = [1,13,1,13,1,13,1,13,12,11,12,11,12,11,12,11,10,9,10,9,10,9,10,9,8,7,8,7,8,7,8,7,6,5,6,5,6,5,6,5,4,3,4,3,4,3,4,3,2,2,2,2]
      r2 = [4,3,2,2,2,2,4,3,4,3,4,3,6,5,6,5,6,5,6,5,8,7,8,7,8,7,8,7,10,9,10,9,10,9,10,9,12,11,12,11,12,11,12,11,1,13,1,13,1,13,1,13]
      assert War.deal(t2) == r2
    end

    test "deal_3" do
      t3 = [13,1,13,1,13,1,13,1,11,12,11,12,11,12,11,12,9,10,9,10,9,10,9,10,7,8,7,8,7,8,7,8,5,6,5,6,5,6,5,6,3,4,3,4,3,4,3,4,2,2,2,2]
      r3 = [4,3,2,2,2,2,4,3,4,3,4,3,6,5,6,5,6,5,6,5,8,7,8,7,8,7,8,7,10,9,10,9,10,9,10,9,12,11,12,11,12,11,12,11,1,13,1,13,1,13,1,13]
      assert War.deal(t3) == r3
    end

    test "deal_4" do
      t4 = [10,11,12,13,1,2,3,4,5,6,7,8,9,10,11,12,13,1,2,3,4,5,6,7,8,9,10,11,12,13,1,2,3,4,5,6,7,8,9,10,11,12,13,1,2,3,4,5,6,7,8,9]
      r4 = [1,1,13,12,9,5,11,4,9,3,8,7,7,2,13,10,12,5,10,4,9,6,8,3,1,1,13,12,7,5,11,4,9,3,8,6,7,2,13,10,12,5,11,11,10,8,6,4,6,3,2,2]
      assert War.deal(t4) == r4
    end

    test "deal_5" do
      t5 = [1,2,3,4,5,6,7,8,9,10,11,12,13,1,2,3,4,5,6,7,8,9,10,11,12,13,1,2,3,4,5,6,7,8,9,10,11,12,13,1,2,3,4,5,6,7,8,9,10,11,12,13]
      r5 = [1,10,13,8,11,9,8,7,11,8,13,7,13,6,12,6,9,5,8,5,7,4,7,4,11,6,12,10,6,3,2,2,12,5,9,3,10,4,9,2,10,3,5,2,1,1,1,13,12,11,4,3]
      assert War.deal(t5) == r5
    end

    defp create_deck do
      deck =
        for n <- 1..13, _ <- 1..4 do
          n
        end

      Enum.shuffle(deck)
    end

    test "should return the same number of cards after deal" do
      deck = create_deck()

      assert length(deck) == 52
      assert length(War.deal(deck)) == 52
    end

    test "should remove the ace weight after a win" do
      deck = create_deck()

      assert Enum.all?(War.deal(deck), &(&1 != 14))
    end
  end
end

And running with elixir war.ex:

  1) test War deal_5 (WarTest)
     war.ex:90
     Assertion with == failed
     code:  assert War.deal(t5) == r5
     left:  [
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13,
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13,
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13,
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13
            ]
     right: [
              1,
              10,
              13,
              8,
              11,
              9,
              8,
              7,
              11,
              8,
              13,
              7,
              13,
              6,
              12,
              6,
              9,
              5,
              8,
              5,
              7,
              4,
              7,
              4,
              11,
              6,
              12,
              10,
              6,
              3,
              2,
              2,
              12,
              5,
              9,
              3,
              10,
              4,
              9,
              2,
              10,
              3,
              5,
              2,
              1,
              1,
              1,
              13,
              12,
              11,
              4,
              3
            ]
     stacktrace:
       war.ex:93: (test)



  2) test War deal_2 (WarTest)
     war.ex:72
     Assertion with == failed
     code:  assert War.deal(t2) == r2
     left:  [
              1,
              13,
              1,
              13,
              1,
              13,
              1,
              13,
              12,
              11,
              12,
              11,
              12,
              11,
              12,
              11,
              10,
              9,
              10,
              9,
              10,
              9,
              10,
              9,
              8,
              7,
              8,
              7,
              8,
              7,
              8,
              7,
              6,
              5,
              6,
              5,
              6,
              5,
              6,
              5,
              4,
              3,
              4,
              3,
              4,
              3,
              4,
              3,
              2,
              2,
              2,
              2
            ]
     right: [
              4,
              3,
              2,
              2,
              2,
              2,
              4,
              3,
              4,
              3,
              4,
              3,
              6,
              5,
              6,
              5,
              6,
              5,
              6,
              5,
              8,
              7,
              8,
              7,
              8,
              7,
              8,
              7,
              10,
              9,
              10,
              9,
              10,
              9,
              10,
              9,
              12,
              11,
              12,
              11,
              12,
              11,
              12,
              11,
              1,
              13,
              1,
              13,
              1,
              13,
              1,
              13
            ]
     stacktrace:
       war.ex:75: (test)



  3) test War deal_3 (WarTest)
     war.ex:78
     Assertion with == failed
     code:  assert War.deal(t3) == r3
     left:  [
              13,
              1,
              13,
              1,
              13,
              1,
              13,
              1,
              11,
              12,
              11,
              12,
              11,
              12,
              11,
              12,
              9,
              10,
              9,
              10,
              9,
              10,
              9,
              10,
              7,
              8,
              7,
              8,
              7,
              8,
              7,
              8,
              5,
              6,
              5,
              6,
              5,
              6,
              5,
              6,
              3,
              4,
              3,
              4,
              3,
              4,
              3,
              4,
              2,
              2,
              2,
              2
            ]
     right: [
              4,
              3,
              2,
              2,
              2,
              2,
              4,
              3,
              4,
              3,
              4,
              3,
              6,
              5,
              6,
              5,
              6,
              5,
              6,
              5,
              8,
              7,
              8,
              7,
              8,
              7,
              8,
              7,
              10,
              9,
              10,
              9,
              10,
              9,
              10,
              9,
              12,
              11,
              12,
              11,
              12,
              11,
              12,
              11,
              1,
              13,
              1,
              13,
              1,
              13,
              1,
              13
            ]
     stacktrace:
       war.ex:81: (test)

.

  4) test War deal_1 (WarTest)
     war.ex:66
     Assertion with == failed
     code:  assert War.deal(t1) == r1
     left:  [
              1,
              1,
              1,
              1,
              13,
              13,
              13,
              13,
              11,
              11,
              11,
              11,
              12,
              12,
              12,
              12,
              10,
              10,
              10,
              10,
              9,
              9,
              9,
              9,
              7,
              7,
              7,
              7,
              8,
              8,
              8,
              8,
              6,
              6,
              6,
              6,
              5,
              5,
              5,
              5,
              4,
              4,
              4,
              4,
              3,
              3,
              3,
              3,
              2,
              2,
              2,
              2
            ]
     right: [
              1,
              1,
              1,
              1,
              13,
              13,
              13,
              13,
              12,
              12,
              12,
              12,
              11,
              11,
              11,
              11,
              10,
              10,
              10,
              10,
              9,
              9,
              9,
              9,
              8,
              8,
              8,
              8,
              7,
              7,
              7,
              7,
              6,
              6,
              6,
              6,
              5,
              5,
              5,
              5,
              4,
              4,
              4,
              4,
              3,
              3,
              3,
              3,
              2,
              2,
              2,
              2
            ]
     stacktrace:
       war.ex:69: (test)



  5) test War deal_4 (WarTest)
     war.ex:84
     Assertion with == failed
     code:  assert War.deal(t4) == r4
     left:  [
              10,
              11,
              12,
              13,
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13,
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13,
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13,
              1,
              2,
              3,
              4,
              5,
              6,
              7,
              8,
              9
            ]
     right: [
              1,
              1,
              13,
              12,
              9,
              5,
              11,
              4,
              9,
              3,
              8,
              7,
              7,
              2,
              13,
              10,
              12,
              5,
              10,
              4,
              9,
              6,
              8,
              3,
              1,
              1,
              13,
              12,
              7,
              5,
              11,
              4,
              9,
              3,
              8,
              6,
              7,
              2,
              13,
              10,
              12,
              5,
              11,
              11,
              10,
              8,
              6,
              4,
              6,
              3,
              2,
              2
            ]
     stacktrace:
       war.ex:87: (test)


Finished in 0.03 seconds (0.03s on load, 0.00s async, 0.00s sync)
7 tests, 5 failures
0
Post #22
Sebb

Sebb

Where are these tests from?
I do not see anything about an “ace weight” in the requirements.

What I did not consider is that the deck comes in already shuffled.
Its not clear to me whats happening here:

test "deal_4" do
      t4 = [10,11,12,13 ...]
      r4 = [1,1,13,12,9 ....]
      assert War.deal(t4) == r4
    end

what does deal do? It gets one list and returns it shuffled as it seems. How is that useful, how should that be testable?

0
Post #23
zoedsoupe

zoedsoupe OP

These tests already exist! They were provided to me

The deal function receives a shuffled deck and returns the winner’s deck.

The ace weight is needed because the provided shuffled deck has aces as 1, but it needs to be the highest rank

0
Post #24
Sebb

Sebb

OK, great naming… not.

|> split(length(deck) * 2)

The game starts with a shuffled deck of cards. The deck will be passed into your program already shuffled (details below). The cards are dealt in an alternating fashion to each player, so that each player has 26 cards.

I did just split the deck in two, because the alternated dealing does not add randomness. But if you get the deck from the test you have to do it, otherwise this cant succeed.

1
Post #25
zoedsoupe

zoedsoupe OP

the deck from tests are already shuffled

0
Post #26
Sebb

Sebb

yes, but feeding play with

iex(1)> [1,2,3,4] |> Enum.split(2)
{[1, 2], [3, 4]}

and

iex(2)> {[1,2,3,4] |> Enum.take_every(2), [1,2,3,4] |> Enum.drop_every(2)}
{[1, 3], [2, 4]}

will yield different results.

0
Post #27
zoedsoupe

zoedsoupe OP

yes, of course! the decks needs to be splitter by the second way

1
Post #28
zoedsoupe

zoedsoupe OP

I tried to dig on these test cases but no success :confused:

0
Post #29
Sebb

Sebb

how does your deal function look like now?

0
Post #30