Heart plus diamond is spade-and-club: table puzzle

Question

I found this YouTube video with a table on it showing some card suits with ampersands. You might not understand what it is about, but I still want to make a challenge about it.

The input is two suits, being one of the following:

heart
diamond
spade
club

You can do anything for any other input.

Then the output is their 'game sum':

1. If both suits are red (heart/diamond), then:
   • Up to one heart promotes to a spade
   • Up to one diamond demotes to a club
2. Output in order of priority (spade > heart > diamond > club).

Leading and trailing whitespace is allowed.

Example input:

spade
heart

Example output:

spade and heart

Use any language. This is code-golf, so shortest code in bytes wins.

Answer 1

Retina 0.8.2, 58 bytes

O^`
h.+¶[hd]
spade $&
[td]¶d.+
$& club
( .+)?¶(.+ )?
 and 

Try it online! Takes input on separate lines but link is to test suite that splits on + for convenience. Explanation:

O^`

Sort in reverse order.

h.+¶[hd]
spade $&

Prefix spade if heart is followed by either heart or diamond.

[td]¶d.+
$& club

Suffix club if either heart or diamond are followed by diamond.

( .+)?¶(.+ )?
 and 

Keep only the first and last words and join them with and.

Answer 2

05AB1E, 33 bytes

„‰áš¸#©¢O<i®“spade†Ú“#.;}{R„ €ƒÀý

Input as a pair of strings.

Try it online or verify all test cases.

Explanation:

„‰áš¸                 # Push dictionary string "heart diamond"
     #                # Split it on spaces: ["heart","diamond"]
      ©               # Store this pair in variable `®` (without popping)
       ¢              # Count how many times each occurs in the (implicit) input-pair
        O             # Sum those counts together
         <i           # If it's 2:
                      # (this is only truthy for the following four pairs: dd,dh,hd,hh)
           ®          #  Push ["heart","diamond"] again from variable `®`
           “spade†Ú“  #  Push dictionary string "spade club"
                    # #  Split it on spaces as well: ["spade","club"]
           .;         #  Replace the first "heart" with "spade" and first "diamond"
                      #  with "club" in the (implicit) input-pair
          }           # Close the if-statement
                      # (the implicit else uses the implicit input-pair)
           {R         # Sort the pair in descending order (sort + reverse)
             „ €ƒ     # Push dictionary string "  and"
                 À    # Rotate it once to the left to " and "
                  ý   # Join the pair with " and " as delimiter
                      # (after which the result is output implicitly)

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why „‰áš¸ is "heart diamond"; “spade†Ú“ is "spade club"; and „ €ƒ is " and".

Answer 3

JavaScript (ES6), 80 bytes

-6 thanks to @tsh

Inspired by Neil's method.

Expects ([a, b]).

c=>(/[dt],h/.test([b,a]=c.sort())?"spade":a)+" and "+(/d,[dh]/.test(c)?"club":b)

Try it online!

Commented

c =>           // c[] = input array
(              //
  /[dt],h/     // if a is "heart" and b is
  .test(       // either "heart" or "diamond",
    [b, a] =   // where a and b are sorted such
      c.sort() // that a > b:
  ) ?          //
    "spade"    //   use "spade" as the left output
  :            // else:
    a          //   use a
) +            //
" and " +      // append " and "
(              //
  /d,[dh]/     // if b is "diamond" and a is
  .test(c) ?   // either "diamond" or "heart":
    "club"     //   use "club" as the right output
  :            // else:
    b          //   use b
)              //

Answer 4

Jelly, 34 bytes

ṢṚµĖ41,3ḥⱮỊẸoḂƲȧ"ȯ"“ɓ¤PⱮ»Ḳ¤j“ and 

• Try it online!

• Test suite

A full program that takes a single list of two strings and prints the result to STDOUT.

Thanks to @JonathanAllan for suggesting a technique that ultimately saved a byte!

Alternative Jelly, 35 bytes

ṢṚµOḢ€ọ2¬Ẹo_J$ƲḂȧ"ȯ"“ɓ¤PⱮ»Ḳ¤j“ and 

• Try it online!

• Test suite

A full program that takes a single list of two strings and prints the result to STDOUT.

Thanks to @JonathanAllan for pointing out a bug!

This works because of the following pattern:

╔═══════════════════════════╦════╦═════╦═════╦═════╗
║ First character           ║ c  ║ d   ║ h   ║ s   ║
╠═══════════════════════════╬════╬═════╬═════╬═════╣
║ Codepoint                 ║ 99 ║ 100 ║ 104 ║ 115 ║
╠═══════════════════════════╬════╬═════╬═════╬═════╣
║ ọ2                        ║ 0  ║ 2   ║ 3   ║ 0   ║
╠═══════════════════════════╬════╬═════╬═════╬═════╣
║ Subtract 1, or not, mod 2 ║ 1  ║ 1   ║ 0   ║ 1   ║
╠═══════════════════════════╬════╬═════╬═════╬═════╣
║ Subtract 2, or not, mod 2 ║ 1  ║ 0   ║ 1   ║ 1   ║
╚═══════════════════════════╩════╩═════╩═════╩═════╝

Explanation

Ṣ                                    | Sort
 Ṛ                                   | Reverse
  µ                                  | Start a new monadic chain
   O                                 | Convert to codepoints
    Ḣ€                               | Head of each
      ọ2                             | Number of times divisible by 2
              Ʋ                      | Following as a monad:
        ¬Ẹ                           | - Any non-zero
          o_J$                       | - Or (the result of ọ2 from before minus the indices)
               Ḃ                     | Mod 2
                ȧ"                   | And zipped (with the reverse sorted input)
                  ȯ"“ɓ¤PⱮ»Ḳ¤         | Or zipped with "spade club" split at spaces
                            j“ and   | Join with " and " (the last ” is implicit)

Answer 5

Perl 5 -n, 77 bytes

$,=" and ";/[dt] [dh]/&&s/heart/spade/+s/diamond/club/;say reverse sort/\S+/g

Try it online!

Answer 6

Charcoal, 52 49 bytes

Ｆ²⊞υＳ⪫Ｅ⌈⟦υ⮌υ⟧⎇›⁼§hdκ§ι⁰⊙sc№Συλ§⪪spadeclub⁵κι and 

Try it online! Link is to verbose version of code. Explanation:

Ｆ²⊞υＳ

Input the two strings.

Ｅ⌈⟦υ⮌υ⟧⎇›⁼§hdκ§ι⁰⊙sc№Συλ§⪪spadeclub⁵κι and 

Sort them in descending order, then unless one the two strings contains s or c, change the first string from heart to spade and the second from diamond to club, then join the results with and.

Answer 7

Uiua, 76 72 bytes

$"_ and _"⍜(⊟∩□|⊏⍖.)(∘|(⊙⊙;|⊙;)≍,,∩(("club"|"spade")=@h⊢),)×∩(∊:"hd"⊢),,

Test pad

Naïve solution to the problem (if anyone can golf this more, comment please)