In der musikalischen Wiedergabe von Les Miserables erscheint ein Lied namens "Red and Black". Hier ist ein Teil dieses Liedes:

Rot - das Blut wütender Männer!

Schwarz - die Dunkelheit vergangener Zeiten!

Rot - eine Welt, die kurz vor dem Morgengrauen steht!

Schwarz - die Nacht, die endlich endet!

Quelle.

Ihre Aufgabe ist es, Input in eine durchschlagende "Rot und Schwarz" -Hymne zu verwandeln.

Eingang

Durch Zeilenumbrüche begrenzter Text oder eine ähnliche geeignete Texteingabe. Beispielsweise,

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

Leere Eingaben sind undefiniert (außerhalb des Gültigkeitsbereichs).

Ausgabe

Wenn die Länge (Anzahl der Zeilen oder Länge des Eingabearrays oder ähnlich) der Eingabe ungerade ist, geben Sie entweder nichts aus oder geben Sie Falsey aus. Ihre Übermittlung gibt möglicherweise keine Fehler aus oder versucht nicht, die richtige Ausgabe auszugeben.

Andernfalls verwandeln Sie den Eingang in einen rot / schwarzen Text. Drehen Sie alle Großbuchstaben am Zeilenanfang in Kleinbuchstaben. Fügen Sie Redplus ein Trennzeichen vor ungeraden Linien und Blackplus ein (sichtbares) Trennzeichen vor geraden Linien ein. Das Trennzeichen muss auch von Leerzeichen umgeben sein, damit die Ausgabe nicht überfüllt (und nicht überfüllt) aussieht.

Sie haben jetzt Ihre Ausgabe.

Testfälle

Ausgangsbegrenzer ist -.

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

Code:

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

Verwendet die 05AB1E- Codierung. Probieren Sie es online aus!

Erläuterung:

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

Probieren Sie es online aus!

Hexdump:

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

Dies ist in V trivial, aber der Randfall von ungeraden Eingaben macht es schwierig, weil V nicht wirklich Bedingungen hat. Zum Glück können wir dies zu relativ geringen Kosten für +6Bytes erledigen .

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

Probieren Sie es online aus!

Ungolfed mit Erklärung

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

fist eine Funktion, die eine Liste von Zeichenfolgen (auch als Liste von Listen von Chars bezeichnet) verwendet und Maybedieselbe zurückgibt . Haskells Funktionen sind ziemlich "rein", und deshalb müssen wir klarstellen, dass diese Funktion möglicherweise nichts zurückgibt. (Eine Funktion vom Typ Maybe agibt entweder Nothingoder zurück Just a).

Der |Bediener ist ein Wachmann - eine Art Bedingung. Dem ersten Zweig folgt if even $ length $ x(was eine andere Schreibweise ist even (length x)) True. Ansonsten 1<2folgt der zweite ( im Golfbeispiel, was natürlich immer zutrifft) und wir kehren zurück Nothing.

zipWithNimmt eine Funktion mit zwei Argumenten und wendet sie auf jedes Element von zwei Listen an. Die Funktion, die wir hier verwenden, ist \(h : t) x -> x ++ toLower h : t. h : tspaltet implizit das erste Zeichen von unserem ersten Argument ab, was eine nette Sache ist, die Sie in Haskell tun können. Die erste Liste ist die Eingabe (von der wir bereits wissen, dass sie eine gerade Anzahl von Zeilen enthält), und die zweite ist nur unendlich abwechselnd "Rot -" und "Schwarz -" (unendliche Listen sind eine weitere nette Sache, die möglich ist, diesmal, weil Haskell es ist faul - es kümmert sich nur um so viel von etwas, wie Sie verwenden).

Gelee , 29 Bytes

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

Ein vollständiges Programm.
Verwendet die Ausgabeoption "falsey" für Eingaben mit einer ungeraden Anzahl von Zeilen.

Probieren Sie es online aus!

Wie?

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

Ausgänge 0für false. Beinhaltet eine nicht druckbare nach der Sekunde R.

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

Probieren Sie es online aus

C 112 107 105 103 99 Bytes

^{-4 dank ASCII-only
-2 dank 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);}

Nimmt ein "Array" als Eingabe. Beispiel:

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!

Wie es funktioniert

• iErstellt eine Variable iaußerhalb aller Funktionen, dh sie wird automatisch auf 0 initialisiert.
• main(a,s)char**s;{deklariert die Hauptfunktion, die zwei Argumente akzeptiert - ein (Anzahl der Befehlszeilenargumente int a) und ein char ** s(Array der Befehlszeilenargumente).
• for(;a%2&++i<a;)ist eine Schleife, die prüft, ob agerade ( a%2) ist und weniger als die Anzahl der übergebenen Befehlszeilenargumente ( i<a).
• printf("%s - %c%s\n",i%2"Red":"Black",tolower(*s[i]),s[i]+1 Drucke:
  • "Rot" wenn iungerade, "Schwarz" wenn igerade ( i%2?"Red":"Black")
  • Der erste Buchstabe des aktuellen Befehlszeilenarguments in Kleinbuchstaben ( tolower(*s[i]))
  • Die Zeichenfolge ohne den ersten Buchstaben ( s[i]+1)

Probieren Sie es online aus!

Röda , 97 Bytes

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

Probieren Sie es online aus!

Gelee , 30 Bytes

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

Probieren Sie es online aus!

Netzhaut , 58 Bytes

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

Probieren Sie es online aus!

CJam, 41 Bytes

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

JavaScript (ES6), 93 Byte

Nimmt das Lied als eine Reihe von Zeilen.

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

Gespeichert 31 Bytes gemäß Stephen S 'Kommentar

Challenger5 hat es auf 165 Bytes reduziert

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

Probieren Sie es online aus!

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

Prüfung

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