En la interpretación musical de Les Miserables, aparece una canción llamada "Red and Black". Aquí hay parte de esa canción:

Rojo: ¡la sangre de los hombres enojados!

Negro: ¡la oscuridad del pasado!

Rojo: ¡un mundo a punto de amanecer!

Negro: ¡la noche que termina por fin!

Fuente.

Su tarea es convertir la entrada en un himno rotundo "rojo y negro".

Entrada

Texto delimitado por nuevas líneas o una entrada de texto adecuada similar. Por ejemplo,

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

La entrada vacía no está definida (fuera de alcance).

Salida

Si la longitud (número de líneas, o la longitud de la matriz de entrada, o similar) de la entrada es impar, no envíe nada o envíe falsey. Su envío puede no generar errores o intentar generar el resultado correcto.

De lo contrario, convierta la entrada en una letra roja / negra. Convierta las letras mayúsculas al comienzo de una línea en minúsculas. Agregue Redmás un delimitador al frente de las líneas impares, y Blackmás un delimitador (visible) al frente de las líneas pares. El delimitador también debe estar rodeado de espacios, por lo que la salida parece no estar abarrotada (y sin campos).

Ahora tienes tu salida.

Casos de prueba

El delimitador de salida es -.

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È×,

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación:

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

Pruébalo en línea!

Hexdump:

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

Esto es trivial en V, pero el caso límite de entradas impares lo hace complicado porque V realmente no tiene condicionales. Afortunadamente, podemos manejar esto a un costo relativamente pequeño 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 - "]

Pruébalo en línea!

Sin disculpas con la explicación

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

fes una función que toma una lista de cadenas (también conocida como una lista de listas de Chars) y devuelve Maybela misma. Las funciones de Haskell son bastante "puras", por lo que debemos dejar en claro que esta función puede no devolver nada. (Una función de tipo Maybe adevuelveNothing o Just a).

El |operador es un guardia, una especie de condicional. La primera rama se sigue si even $ length $ x(que es otra forma de escritura even (length x)) es True. De lo contrario, 1<2se sigue el segundo ( en el ejemplo de golf, que por supuesto siempre es cierto) y regresamos Nothing.

zipWithtoma una función de dos argumentos y la aplica a cada elemento de dos listas. La función que estamos usando aquí es \(h : t) x -> x ++ toLower h : t. h : timplícitamente divide el primer personaje de nuestro primer argumento, que es el tipo de cosa buena que puedes hacer en Haskell. La primera lista es la entrada (que ya sabemos contiene un número par de líneas), y la segunda es simplemente alternando infinitamente "Rojo -" y "Negro -" (las listas infinitas son otra cosa buena que es posible, esta vez porque Haskell es perezoso: solo le importa la cantidad de algo que usa).

Jalea , 29 bytes

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

Un programa completo
Utiliza la opción de salida "falsey" para entradas con un número impar de líneas.

Pruébalo en línea!

¿Cómo?

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.

Japt , 36 35 34 bytes

Salidas 0para false. Incluye un no imprimible después del segundo R.

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

Pruébalo en línea

C, 112 107 105 103 99 bytes

^{-4 gracias a ASCII-only
-2 gracias a 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 una "matriz" como entrada. Ejemplo:

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!

Cómo funciona

• i crea una variable i fuera de todas las funciones, lo que significa que se inicializa automáticamente a 0.
• main(a,s)char**s;{declara la función principal, que toma dos argumentos: un int a(# de argumentos de línea de comando) y unchar ** s (conjunto de argumentos de línea de comando).
• for(;a%2&++i<a;)es un bucle que comprueba si aes par ( a%2) y si es menor que el número de argumentos de línea de comando pasadosi<a ).
• printf("%s - %c%s\n",i%2"Red":"Black",tolower(*s[i]),s[i]+1 huellas dactilares:
  • "Rojo" si ies impar, "Negro" si ies par (i%2?"Red":"Black" )
  • La primera letra del argumento actual de la línea de comandos en minúsculas (tolower(*s[i]) )
  • La cadena, sin la primera letra ( s[i]+1)

Pruébalo en línea!

Röda , 97 bytes

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

Pruébalo en línea!

Jalea , 30 bytes

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

Pruébalo en línea!

Retina , 58 bytes

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

Pruébalo en línea!

CJam, 41 bytes

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

JavaScript (ES6), 93 bytes

Toma la canción como una serie de líneas.

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

Guardado 31 bytes según el comentario de Stephen S

Challenger5 lo bajó a 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:]

Pruébalo en línea!

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

Prueba

//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) );