Create your own Red and Black

V, 31, 30 bytes

êuòIRed - 
IBlack - 
òñFRdH

Try it online!

Hexdump:

00000000: 16ea 75f2 4952 6564 202d 201b 0a49 426c  ..u.IRed - ..IBl
00000010: 6163 6b20 2d20 1b0a f2f1 4652 6448       ack - ....FRdH

This is trivial in V, but the edge case of odd inputs makes it tricky because V doesn't really have conditionals. Thankfully, we can handle this at the relatively small cost of +6 bytes.

Haskell, 104 120 113 112 111 110 bytes

import Data.Char
f x|odd$length$x=mempty|1<2=Just$zipWith(\(h:t)x->x++toLower h:t)x$cycle["Red - ","Black - "]

Try it online!

Ungolfed with explanation

import Data.Char

f :: [String] -> Maybe [String]
f x
  | even $ length $ x = Just $ zipWith (\(h : t) x -> x ++ toLower h : t) x $ cycle ["Red - ","Black - "]
  | otherwise         = Nothing

f is a function that takes a list of strings (a.k.a. a list of lists of Chars), and returns Maybe the same. Haskell's functions are quite "pure", and so we need to make it clear that this function may not return anything. (A function of type Maybe a returns either Nothing or Just a).

The | operator is a guard - a kind of conditional. The first branch is followed if even $ length $ x (which is another way of writing even (length x)) is True. Otherwise, the second one (1<2 in the golfed example, which is of course always true) is followed and we return Nothing.

zipWith takes a two-argument function and applies it to each element of two lists. The function we're using here is \(h : t) x -> x ++ toLower h : t. h : t implicitly splits the first character off our first argument, which is the kind of nice thing you can do in Haskell. The first list is the input (which we already know contains an even number of lines), and the second is just infinitely alternating "Red - " and "Black - " (infinite lists are another nice thing that's possible, this time because Haskell is lazy - it only cares about as much of something as you use).

05AB1E, 26 bytes

Code:

|©v”†¾ƒÏ”#Nè… - yćlìJ®gÈ×,

Uses the 05AB1E encoding. Try it online!

Explanation:

|                               # Take the input as an array of inputs
 ©                              # Keep a copy of this in the register
  v                             # Map over the array
   ”†¾ƒÏ”#                      #   Push the array ["Red", "Black"]
          Nè                    #   Get the Nth element (where N is the iteration index)
            … -                 #   Push the string " - "
                yć              #   Push the current element and extract the first element
                  lì            #   Convert to lowercase and prepend back to it's
                                    original place
                    J           #   Join the entire stack into a single string
                     ®g         #   Get the length of the input
                       È        #   Check if it is even (results in 1 or 0)
                        ×       #   String multiply the result by the string
                         ,      #   Pop and print with a newline

Tags:

String

Code Golf

Related