W muzycznym wykonaniu Les Miserables pojawia się piosenka zatytułowana „Red and Black”. Oto część tej piosenki:

Czerwony - krew gniewnych ludzi!

Czarny - ciemność minionych wieków!

Czerwony - świat o świcie!

Czarny - noc, która w końcu się kończy!

Źródło.

Twoim zadaniem jest przekształcenie wkładu w hymn „Czerwony i czarny”.

Wejście

Tekst rozdzielany znakami nowej linii lub podobny odpowiedni sposób wprowadzania tekstu. Na przykład,

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

Puste wejście jest niezdefiniowane (poza zakresem).

Wynik

Jeśli długość (liczba linii, długość tablicy wejściowej lub podobna) danych wejściowych jest nieparzysta, albo nic nie wysyłaj, albo wyjściowy falsey. Przesłanie może nie powodować wyświetlania błędów lub próby uzyskania prawidłowego wyniku.

W przeciwnym razie zmień dane wejściowe na tekst czerwony / czarny. Zmień dowolne wielkie litery na początku wiersza na małe. Dodaj Redplus separator z przodu linii nieparzystych i Blackplus (widoczny) separator z przodu linii parzystych. Separator musi być również otoczony spacjami, aby wynik wyglądał na niezatłoczony (i niespokojny;)).

Masz teraz swój wynik.

Przypadki testowe

Ogranicznikiem wyjścia jest -.

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 bajtów

Kod:

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

Wykorzystuje kodowanie 05AB1E . Wypróbuj online!

Wyjaśnienie:

|                               # 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 bajtów

êuòIRed - 
IBlack - 
òñFRdH

Wypróbuj online!

Hexdump:

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

Jest to trywialne w V, ale przypadek na krawędzi nieparzystych danych wejściowych sprawia, że ​​jest to trudne, ponieważ V tak naprawdę nie ma warunków warunkowych. Na szczęście możemy sobie z tym poradzić przy stosunkowo niewielkim koszcie +6bajtów.

Haskell , 104 120 113 112 111 110 bajtów

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

Wypróbuj online!

Nie obeznany z wyjaśnieniem

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

fjest funkcją, która pobiera listę ciągów znaków (zwaną także listą list Chars) i zwraca Maybeto samo. Funkcje Haskella są dość „czyste”, dlatego musimy wyjaśnić, że ta funkcja może niczego nie zwracać. (Funkcja typu Maybe azwraca albo Nothingalbo Just a).

|Operator jest strażnik - rodzaj warunkowe. Pierwszy oddział następuje, jeśli even $ length $ x(co jest innym sposobem pisania even (length x)) True. W przeciwnym razie następuje drugi ( 1<2w golfowym przykładzie, który oczywiście jest zawsze prawdziwy) i wracamy Nothing.

zipWithprzyjmuje funkcję dwóch argumentów i stosuje ją do każdego elementu dwóch list. Używamy tutaj funkcji \(h : t) x -> x ++ toLower h : t. h : tdomyślnie dzieli pierwszą postać od naszego pierwszego argumentu, co jest przyjemną rzeczą, którą możesz zrobić w Haskell. Pierwsza lista to dane wejściowe (które, jak już wiemy, zawierają parzystą liczbę linii), a druga to po prostu nieskończenie naprzemienne „czerwone -” i „czarne -” (nieskończone listy to kolejna fajna rzecz, która jest możliwa, tym razem ponieważ Haskell jest leniwy - troszczy się tylko o tyle, ile używasz).

Galaretka , 29 bajtów

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

Pełny program.
Używa opcji wyjściowej „falsey” dla danych wejściowych o nieparzystej liczbie linii.

Wypróbuj online!

W jaki sposób?

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 bajtów

Wyjścia 0dla false. Obejmuje niedrukowalne po drugim R.

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

Wypróbuj online

C, 112 107 105 103 99 bajtów

^{-4 dzięki tylko ASCII
-2 dzięki 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);}

Pobiera „tablicę” jako dane wejściowe. Przykład:

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!

Jak to działa

• itworzy zmienną ipoza wszystkimi funkcjami, co oznacza, że ​​jest automatycznie inicjowana na 0.
• main(a,s)char**s;{deklaruje funkcję główną, która przyjmuje dwa argumenty - an int a(liczba argumentów wiersza poleceń) i a char ** s(tablica argumentów wiersza poleceń).
• for(;a%2&++i<a;)to pętla, która sprawdza, czy ajest parzysta ( a%2) i czy jest mniejsza niż liczba przekazanych argumentów wiersza poleceń ( i<a).
• printf("%s - %c%s\n",i%2"Red":"Black",tolower(*s[i]),s[i]+1 drukuje:
  • „Czerwony”, jeśli ijest nieparzysty, „Czarny”, jeśli ijest parzysty ( i%2?"Red":"Black")
  • Pierwsza litera bieżącego argumentu wiersza poleceń małymi literami ( tolower(*s[i]))
  • Ciąg bez pierwszej litery ( s[i]+1)

Wypróbuj online!

Röda , 97 bajtów

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

Wypróbuj online!

Galaretka , 30 bajtów

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

Wypróbuj online!

Siatkówka , 58 bajtów

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

Wypróbuj online!

CJam, 41 bajtów

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

JavaScript (ES6), 93 bajty

Traktuje utwór jako szereg linii.

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 bajtów

Zapisano 31 bajtów zgodnie z komentarzem Stephena S.

Challenger5 obniżył go do 165 bajtów

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

Wypróbuj online!

JavaScript, 118 bajtów

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