Nella resa musicale di Les Miserables, appare una canzone chiamata "Red and Black". Ecco parte di quella canzone:

Rosso: il sangue degli uomini arrabbiati!

Nero: il buio dei secoli passati!

Rosso: un mondo che sta per sorgere!

Nero: la notte che finisce finalmente!

Fonte.

Il tuo compito è trasformare l'input in un clamoroso inno "rosso e nero".

Ingresso

Testo delimitato da newline o un input di testo adatto simile. Per esempio,

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

L'input vuoto non è definito (al di fuori dell'ambito).

Produzione

Se la lunghezza (numero di righe, o lunghezza dell'array di input o simile) dell'input è dispari, o output nulla o output false. L'invio potrebbe non generare errori o tentare di produrre l'output corretto.

Altrimenti, trasforma l'ingresso in un testo rosso / nero. Trasforma le lettere maiuscole all'inizio di una riga in minuscolo. Aggiungi Redpiù un delimitatore nella parte anteriore delle linee dispari e Blackpiù un delimitatore (visibile) nella parte anteriore delle linee pari. Il delimitatore deve anche essere circondato da spazi, quindi l'output sembra non affollato (e non rigato;)).

Ora hai il tuo output.

Casi test

Il delimitatore di output è -.

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 byte

Codice:

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

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione:

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

êuòIRed - 
IBlack - 
òñFRdH

Provalo online!

hexdump:

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

Questo è banale in V, ma il caso limite di input dispari lo rende difficile perché V non ha davvero dei condizionali. Per fortuna, possiamo gestirlo al costo relativamente piccolo di +6byte.

Haskell , 104 120 113 112 111 110 byte

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

Provalo online!

Ungolfed con spiegazione

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è una funzione che accetta un elenco di stringhe (ovvero un elenco di elenchi di Chars) e restituisce Maybelo stesso. Le funzioni di Haskell sono piuttosto "pure", quindi è necessario chiarire che questa funzione potrebbe non restituire nulla. (Una funzione di tipo Maybe arestituisce o Nothingo Just a).

L' |operatore è una guardia - una sorta di condizionale. Il primo ramo è seguito se even $ length $ x(che è un altro modo di scrivere even (length x)) è True. Altrimenti, viene seguito il secondo ( 1<2nell'esempio del golf, che ovviamente è sempre vero) e torniamo Nothing.

zipWithaccetta una funzione a due argomenti e la applica a ciascun elemento di due elenchi. La funzione che stiamo usando qui è \(h : t) x -> x ++ toLower h : t. h : tdivide implicitamente il primo personaggio dal nostro primo argomento, che è il tipo di cosa carina che puoi fare in Haskell. Il primo elenco è l'input (che già sappiamo contiene un numero pari di righe), e il secondo alterna all'infinito "Rosso -" e "Nero -" (gli elenchi infiniti sono un'altra cosa carina che è possibile, questa volta perché Haskell è pigro - si preoccupa solo di qualcosa che usi).

Gelatina , 29 byte

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

Un programma completo.
Utilizza l'opzione di output "falsey" per input con un numero dispari di righe.

Provalo online!

Come?

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 byte

Uscite 0per false. Include un non stampabile dopo il secondo R.

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

Provalo online

C, 112 107 105 103 99 byte

^{-4 grazie solo a ASCII
-2 grazie 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);}

Accetta un "array" come input. Esempio:

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!

Come funziona

• icrea una variabile ial di fuori di tutte le funzioni, il che significa che viene inizializzata automaticamente su 0.
• main(a,s)char**s;{dichiara la funzione principale, che accetta due argomenti: un int a(numero di argomenti della riga di comando) e un char ** s(array di argomenti della riga di comando).
• for(;a%2&++i<a;)è un ciclo che controlla se aè pari ( a%2) e se è inferiore al numero di argomenti della riga di comando passati ( i<a).
• printf("%s - %c%s\n",i%2"Red":"Black",tolower(*s[i]),s[i]+1 stampe:
  • "Rosso" se iè dispari, "Nero" se iè pari ( i%2?"Red":"Black")
  • La prima lettera dell'attuale argomento della riga di comando in lettere minuscole ( tolower(*s[i]))
  • La stringa, senza la prima lettera ( s[i]+1)

Provalo online!

Röda , 97 byte

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

Provalo online!

Gelatina , 30 byte

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

Provalo online!

Retina , 58 byte

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

Provalo online!

CJam, 41 byte

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

JavaScript (ES6), 93 byte

Prende la canzone come una matrice di linee.

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 byte

Salvataggio di 31 byte secondo il commento di Stephen S.

Challenger5 è arrivato a 165 byte

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

Provalo online!

Javascript, 118 byte

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

Test

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