Na versão musical de Les Miserables, uma música aparece chamada "Red and Black". Aqui está parte dessa música:

Vermelho - o sangue de homens furiosos!

Preto - a escuridão das eras passadas!

Vermelho - um mundo prestes a amanhecer!

Preto - a noite que termina finalmente!

Fonte.

Sua tarefa é transformar a entrada em um hino retumbante "Vermelho e Preto".

Entrada

Texto delimitado por novas linhas ou uma entrada de texto adequada semelhante. Por exemplo,

The blood of angry men!
The dark of ages past!
A world about to dawn!
The night that ends at last!

A entrada vazia está indefinida (fora do escopo).

Resultado

Se o comprimento (número de linhas, comprimento da matriz de entrada ou similar) da entrada for ímpar, não produza nada ou produza falsey. Seu envio pode não gerar erros ou tentar gerar a saída correta.

Caso contrário, transforme a entrada em uma letra vermelha / preta. Vire todas as letras maiúsculas no início de uma linha para minúsculas. Adicione Redmais um delimitador à frente das linhas ímpares e Blackmais um delimitador (visível) à frente das linhas pares. O delimitador também deve estar entre espaços, para que a saída pareça não aglomerada (e não destruída;)).

Agora você tem sua saída.

Casos de teste

O delimitador de saída é -.

In:
The blood of angry men!
The dark of ages past!
A world about to dawn!
The night that ends at last!

Out:
Red - the blood of angry men!
Black - the dark of ages past!
Red - a world about to dawn!
Black - the night that ends at last!

In:
test test
1
[][][]
BBB

Out:
Red - test test
Black - 1
Red - [][][]
Black - bBB

In:
I feel my soul on fire!
The color of desire!
The color of despair!
Out:
falsey OR nothing

In:
Red - I feel my soul on fire!
Black - My world if she's not there!

Out:
Red - red - I feel my soul on fire!
Black - black - My world if she's not there!

05AB1E , 26 bytes

Código:

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

Usa a codificação 05AB1E . Experimente online!

Explicação:

|                               # 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

V , 31 , 30 bytes

êuòIRed - 
IBlack - 
òñFRdH

Experimente online!

Hexdump:

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

Isso é trivial em V, mas o caso extremo de entradas ímpares torna complicado porque V realmente não tem condicionais. Felizmente, podemos lidar com isso com um custo relativamente pequeno de +6bytes.

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 - "]

Experimente online!

Ungolfed com explicação

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é uma função que pega uma lista de strings (também conhecida como lista de Chars) e retorna Maybea mesma. As funções de Haskell são bastante "puras" e, portanto, precisamos deixar claro que essa função pode não retornar nada. (Uma função do tipo Maybe aretorna Nothingou Just a).

O |operador é um guarda - uma espécie de condicional. O primeiro ramo é seguido se even $ length $ x(que é outra maneira de escrever even (length x)) for True. Caso contrário, o segundo ( 1<2no exemplo do golfe, que é sempre verdadeiro) é seguido e retornamos Nothing.

zipWithpega uma função de dois argumentos e a aplica a cada elemento de duas listas. A função que estamos usando aqui é \(h : t) x -> x ++ toLower h : t. h : tsepara implicitamente o primeiro caractere do nosso primeiro argumento, que é o tipo de coisa agradável que você pode fazer em Haskell. A primeira lista é a entrada (que já sabemos que contém um número par de linhas) e a segunda alterna infinitamente "Vermelho -" e "Preto -" (listas infinitas são outra coisa interessante que é possível, desta vez porque Haskell é preguiçoso - ele só se importa com o que você usa).

Gelatina , 29 bytes

0
“ZœĠk»ḲṁJżj€“ - ”Y
ỴŒl1¦€LĿ

Um programa completo.
Usa a opção de saída "falsey" para entradas com um número ímpar de linhas.

Experimente online!

Como?

0 - Link 1, return a falsey value: no arguments
0 - well, yeah, zero - that's falsey.

“ZœĠk»ḲṁJżj€“ - ”Y - Link 2, format the lines: list of lists of characters, the lines
“ZœĠk»             - "Red Black"
      Ḳ            - split at spaces -> ["Red","Black"]
        J          - range(length(lines)) -> [1,2,3,...,nLines]
       ṁ           - mould -> ["Red","Black","Red","Black",...,"Red","Black"]
         ż         - zip with lines -> [["Red",l1],["Black",l2],...]
            “ - ”  - " - " (really I cant find any save :/)
          j€       - join for each -> ["Red - l1","Black - l2",...]
                 Y - join with newlines

ỴŒl1¦€LĿ - Main link: string
Ỵ        - split at newlines
   1¦€   - apply to index 1:
 Œl      -   convert to lower case
       Ŀ - call link at index:
      L  -   length - Note: this is modular, so:
         -                  link 2 is called for even, and
         -                  link 1 is called for odd.

Japonês , 36 35 34 bytes

Saídas 0para false. Inclui um imprimível após o segundo R.

èR u ©¡[`R Black`¸gY '-XhXg v]¸}R

Experimente online

C, 112 107 105 103 99 bytes

^{-4 graças ao ASCII-apenas
-2 graças ao Mego}

i;main(a,s)char**s;{for(;a%2&++i<a;)printf("%s - %c%s\n",i%2?"Red":"Black",tolower(*s[i]),s[i]+1);}

Toma uma "matriz" como entrada. Exemplo:

bash$ ./a.out "The blood of angry men!" "The dark of ages past!" "A world about to dawn!"
bash$ ./a.out "The blood of angry men!" "The dark of ages past!" "A world about to dawn!" "The night that ends at last!"                                                 
Red - the blood of angry men!
Black - the dark of ages past!
Red - a world about to dawn!
Black - the night that ends at last!

Como funciona

• icria uma variável ifora de todas as funções, o que significa que é automaticamente inicializado como 0.
• main(a,s)char**s;{declara a função principal, que recebe dois argumentos - um int a(número de argumentos da linha de comando) e um char ** s(conjunto de argumentos da linha de comando).
• for(;a%2&++i<a;)é um loop que verifica se aé par ( a%2) e se é menor que o número de argumentos da linha de comando passados ​​( i<a).
• printf("%s - %c%s\n",i%2"Red":"Black",tolower(*s[i]),s[i]+1 impressões:
  • "Vermelho" se i for ímpar, "Preto" se ifor par ( i%2?"Red":"Black")
  • A primeira letra do argumento da linha de comando atual em minúsculas ( tolower(*s[i]))
  • A sequência, sem a primeira letra ( s[i]+1)

Experimente online!

Röda , 97 bytes

f a{seq 0,#a-1|[_,a[_1]/""]|[["Red","Black"][_%2],` - `,lowerCase(_[0]),_2[1:]&"",`
`]if[#a%2<1]}

Experimente online!

Gelatina , 30 bytes

LḂṆẋ@Ỵµ“ZœĠk»ḲṁL;€“ - ”żŒl1¦€Y

Experimente online!

Retina , 58 bytes

Tm`L`l`^.
m`^
Red - 
(Red - .*¶)Red
$1Black
^(.*¶.*¶)*.*$

Experimente online!

CJam, 41 bytes

qN/{(el\+}%2/"Red - 
Black - "N/f.\:~2/N*

JavaScript (ES6), 93 bytes

Toma a música como uma matriz de linhas.

S=>S.length%2?0:S.map((L,i)=>(i%2?'Black':'Red')+' - '+L[0].toLowerCase()+L.slice(1)).join`
`

f=
S=>S.length%2?0:S.map((L,i)=>(i%2?'Black':'Red')+' - '+L[0].toLowerCase()+L.slice(1)).join`
`

console.log(f([
  'The blood of angry men!',
  'The dark of ages past!',
  'A world about to dawn!',
  'The night that ends at last!'
]))

console.log(f([
  'The blood of angry men!',
  'The dark of ages past!',
  'A world about to dawn!'
]))

Python 2 , 215-> 184-> 165 bytes

Salva 31 bytes de acordo com o comentário de Stephen S '

Challenger5 reduziu para 165 bytes

l=[]
b=["Red","Black"]
d=" - "
while 1:
 a=raw_input()
 if a:l.append(a)
 else:break
q=len(l)
if q%2<1:
 for i in range(q):n=l[i];print b[i%2]+d+n[0].lower()+n[1:]

Experimente online!

Javascript, 118 bytes

v=s=>(s=s.split`\n`).length%2==0?s.map((l,i)=>(i%2==0?'Red':'Black')+' - '+l[0].toLowerCase()+l.substr`1`).join`\n`:!1

Teste

//code
v=s=>(s=s.split`\n`).length%2==0?s.map((l,i)=>(i%2==0?'Red':'Black')+' - '+l[0].toLowerCase()+l.substr`1`).join`\n`:!1


//tests
t0 = "The blood of angry men!\nThe dark of ages past!\nA world about to dawn!\nThe night that ends at last!";
t1 = "test test\n1\n[][][]\nBBB";
t2 = "I feel my soul on fire!\nThe color of desire!\nThe color of despair!";
t3 = "Red - I feel my soul on fire!\nBlack - My world if she's not there!";

console.log( v(t0) );
console.log( v(t1) );
console.log( v(t2) );
console.log( v(t3) );