Dans l'interprétation musicale des Misérables, une chanson apparaît intitulée "Rouge et noir". Voici une partie de cette chanson:

Rouge - le sang des hommes en colère!

Noir - l'obscurité des âges passés!

Rouge - un monde sur le point de l'aube!

Noir - la nuit qui se termine enfin!

La source.

Votre tâche consiste à transformer l'entrée en un hymne retentissant «rouge et noir».

Contribution

Texte délimité par des retours à la ligne ou une saisie de texte appropriée similaire. Par exemple,

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

L'entrée vide n'est pas définie (hors de portée).

Production

Si la longueur (nombre de lignes, ou longueur du tableau d'entrée, ou similaire) de l'entrée est impaire, sortez rien ou sortez falsey. Votre soumission peut ne pas générer d'erreurs ou tenter de produire la sortie correcte.

Sinon, transformez l'entrée en paroles lyriques rouge / noir. Mettez toutes les lettres majuscules au début d'une ligne en minuscules. Ajoutez Redplus un délimiteur à l'avant des lignes impaires et Blackplus un délimiteur (visible) à l'avant des lignes paires. Le délimiteur doit également être entouré d'espaces, de sorte que la sortie semble peu fréquentée (et non golfée;)).

Vous avez maintenant votre sortie.

Cas de test

Le délimiteur de sortie est -.

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 octets

Code:

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

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication:

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

êuòIRed - 
IBlack - 
òñFRdH

Essayez-le en ligne!

Hexdump:

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

C'est trivial dans V, mais le cas de bord des entrées impaires le rend difficile parce que V n'a pas vraiment de conditions. Heureusement, nous pouvons gérer cela au coût relativement faible d' +6octets.

Haskell , 104 120 113 112 111 110 octets

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

Essayez-le en ligne!

Non golfé avec explication

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

fest une fonction qui prend une liste de chaînes (alias une liste de listes de Chars), et renvoie Maybela même chose. Les fonctions de Haskell sont assez "pures", et nous devons donc préciser que cette fonction peut ne rien retourner. (Une fonction de type Maybe arenvoie soit Nothingou Just a).

L' |opérateur est un gardien - une sorte de conditionnel. La première branche est suivie si even $ length $ x(qui est une autre façon d'écrire even (length x)) l'est True. Sinon, le second ( 1<2dans l'exemple golfé, qui est bien sûr toujours vrai) est suivi et nous revenons Nothing.

zipWithprend une fonction à deux arguments et l'applique à chaque élément de deux listes. La fonction que nous utilisons ici est \(h : t) x -> x ++ toLower h : t. h : tsépare implicitement le premier caractère de notre premier argument, qui est le genre de bonne chose que vous pouvez faire dans Haskell. La première liste est l'entrée (dont nous savons déjà qu'elle contient un nombre pair de lignes), et la seconde est juste alternant infiniment "Rouge -" et "Noir -" (les listes infinies sont une autre bonne chose qui est possible, cette fois parce que Haskell est paresseux - il ne se soucie que de quelque chose que vous utilisez).

Gelée , 29 octets

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

Un programme complet.
Utilise l'option de sortie "falsey" pour les entrées avec un nombre impair de lignes.

Essayez-le en ligne!

Comment?

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 octets

Sorties 0pour false. Comprend un non imprimable après la seconde R.

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

Essayez-le en ligne

C, 112 107 105 103 103 99 octets

^{-4 grâce à ASCII uniquement
-2 grâce à 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);}

Prend un "tableau" en entrée. Exemple:

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!

Comment ça fonctionne

• icrée une variable en idehors de toutes les fonctions, ce qui signifie qu'elle est automatiquement initialisée à 0.
• main(a,s)char**s;{déclare la fonction principale, qui prend deux arguments - un int a(# d'arguments de ligne de commande) et un char ** s(tableau d'arguments de ligne de commande).
• for(;a%2&++i<a;)est une boucle qui vérifie si aest even ( a%2) et s'il est inférieur au nombre d'arguments de ligne de commande passés ( i<a).
• printf("%s - %c%s\n",i%2"Red":"Black",tolower(*s[i]),s[i]+1 impressions:
  • "Rouge" si iest impair, "Noir" si iest pair ( i%2?"Red":"Black")
  • La première lettre de l'argument de ligne de commande en cours en minuscule ( tolower(*s[i]))
  • La chaîne, sans la première lettre ( s[i]+1)

Essayez-le en ligne!

Röda , 97 octets

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

Essayez-le en ligne!

Gelée , 30 octets

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

Essayez-le en ligne!

Rétine , 58 octets

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

Essayez-le en ligne!

CJam, 41 octets

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

JavaScript (ES6), 93 octets

Prend la chanson comme un tableau de lignes.

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 octets

Enregistré 31 octets selon le commentaire de Stephen S

Challenger5 est descendu à 165 octets

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

Essayez-le en ligne!

Javascript, 118 octets

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

Tester

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