ในการแสดงละครเพลงของ Les Miserables เพลงที่เรียกว่า "สีแดงและดำ" นี่คือส่วนหนึ่งของเพลงนั้น:

แดง - เลือดของคนโกรธ!

ดำ - ความมืดในอดีต!

แดง - โลกกำลังจะรุ่งเช้า!

ดำ - คืนที่สิ้นสุดในที่สุด!

แหล่ง

งานของคุณคือเปลี่ยนอินพุตให้เป็นเพลง "แดงและดำ" ดังก้อง

อินพุต

ข้อความถูกคั่นด้วยการขึ้นบรรทัดใหม่หรือการป้อนข้อความที่เหมาะสมคล้ายกัน ตัวอย่างเช่น,

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

อินพุตว่างไม่ได้ถูกกำหนด (อยู่นอกขอบเขต)

เอาท์พุต

หากความยาว (จำนวนบรรทัดหรือความยาวของอินพุตอาร์เรย์หรือคล้ายกัน) ของอินพุตเป็นเลขคี่ไม่ว่าเอาต์พุตหรือเอาต์พุตจะเป็นเท็จ การส่งของคุณอาจไม่ส่งออกข้อผิดพลาดหรือพยายามที่จะออกผลลัพธ์ที่ถูกต้อง

มิฉะนั้นเปลี่ยนอินพุตเป็นเนื้อเพลงสีแดง / ดำ เปลี่ยนอักษรตัวพิมพ์ใหญ่ใด ๆ ที่จุดเริ่มต้นของบรรทัดเป็นตัวพิมพ์เล็ก เพิ่มRedบวกตัวคั่นไปด้านหน้าของเส้นคู่และBlackบวกตัวคั่น (มองเห็นได้) ไปที่ด้านหน้าของเส้นคู่ ตัวคั่นจะต้องล้อมรอบในช่องว่างดังนั้นเอาต์พุตจะไม่ถูกแยกออก (และ ungolfed;))

ตอนนี้คุณมีผลงานของคุณ

กรณีทดสอบ

-คั่นเอาท์พุท

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 ไบต์

รหัส:

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

ใช้การเข้ารหัส05AB1E ลองออนไลน์!

คำอธิบาย:

|                               # 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 ไบต์

êuòIRed - 
IBlack - 
òñFRdH

ลองออนไลน์!

hexdump:

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

นี่เป็นเรื่องเล็กน้อยใน V แต่กรณีขอบของอินพุตแปลก ๆ ทำให้ยุ่งยากเนื่องจาก V ไม่มีเงื่อนไขจริงๆ โชคดีที่เราสามารถจัดการกับปัญหานี้ที่ค่าใช้จ่ายที่ค่อนข้างเล็กของ+6ไบต์

Haskell , 104 120 113 112 111 110 ไบต์

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

ลองออนไลน์!

ไม่พอใจกับคำอธิบาย

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เป็นฟังก์ชั่นที่รับรายการสตริง (หรือที่เรียกว่ารายการของChars) และส่งคืนค่าMaybeเดิม ฟังก์ชั่นของ Haskell นั้นค่อนข้าง "บริสุทธิ์" ดังนั้นเราต้องทำให้ชัดเจนว่าฟังก์ชั่นนี้อาจไม่ส่งคืนสิ่งใด (ฟังก์ชั่นของประเภทMaybe aผลตอบแทนอย่างใดอย่างหนึ่งNothingหรือJust a)

|ผู้ประกอบการเป็นยาม - ชนิดของเงื่อนไข สาขาแรกจะตามมาถ้าeven $ length $ x(ซึ่งเป็นวิธีการเขียนอีกeven (length x)) Trueเป็น มิฉะนั้นคนที่สอง ( 1<2ในตัวอย่างแข็งแรงเล่นกอล์ฟซึ่งเป็นหลักสูตรที่เป็นจริงเสมอ) Nothingจะตามมาและเรากลับมา

zipWithรับฟังก์ชั่นสองข้อโต้แย้งและนำไปใช้กับองค์ประกอบของสองรายการ \(h : t) x -> x ++ toLower h : tฟังก์ชั่นที่เรากำลังใช้ที่นี่เป็น h : tโดยปริยายแยกอักขระแรกออกจากอาร์กิวเมนต์แรกของเราซึ่งเป็นสิ่งที่ดีที่คุณสามารถทำได้ใน Haskell รายการแรกคืออินพุต (ซึ่งเรารู้อยู่แล้วว่ามีจำนวนคู่ของบรรทัด) และรายการที่สองเป็นเพียงสลับอนันต์ "Red -" และ "Black -" (รายการอนันต์เป็นอีกสิ่งที่ดีที่เป็นไปได้ในเวลานี้เนื่องจาก Haskell สันหลังยาว - มันให้ความสำคัญกับบางสิ่งเท่าที่คุณใช้)

เยลลี่ 29 ไบต์

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

โปรแกรมเต็มรูปแบบ
ใช้ตัวเลือกเอาต์พุต "falsey" สำหรับอินพุตที่มีจำนวนบรรทัดคี่

ลองออนไลน์!

อย่างไร?

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 ไบต์

ขาออกสำหรับ0 รวมถึงไม่สามารถพิมพ์หลังจากที่สองfalseR

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

ลองออนไลน์

C, 112 107 105 103 99 ไบต์

^{-4 ขอบคุณ ASCII-only
-2 ขอบคุณ 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);}

ใช้ "อาร์เรย์" เป็นอินพุต ตัวอย่าง:

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!

มันทำงานอย่างไร

• iสร้างตัวแปรiนอกฟังก์ชั่นทั้งหมดซึ่งหมายความว่ามันเริ่มต้นได้โดยอัตโนมัติถึง 0
• main(a,s)char**s;{ประกาศฟังก์ชั่นหลักซึ่งใช้เวลาสองข้อโต้แย้ง - int a(# ของอาร์กิวเมนต์บรรทัดคำสั่ง) และchar ** s(อาร์เรย์ของอาร์กิวเมนต์บรรทัดคำสั่ง)
• for(;a%2&++i<a;)เป็นลูปที่ตรวจสอบว่าaเป็นa%2เลขคู่ ( ) หรือไม่และถ้าน้อยกว่าจำนวนอาร์กิวเมนต์บรรทัดคำสั่งที่ส่งผ่าน ( i<a)
• printf("%s - %c%s\n",i%2"Red":"Black",tolower(*s[i]),s[i]+1 พิมพ์:
  • "Red" ถ้าiเป็นเลขคี่ "Black" ถ้าiเป็นเลขคู่( i%2?"Red":"Black")
  • ตัวอักษรตัวแรกของอาร์กิวเมนต์บรรทัดคำสั่งปัจจุบันเป็นตัวพิมพ์เล็ก ( tolower(*s[i]))
  • สตริงโดยไม่มีตัวอักษรตัวแรก ( s[i]+1)

ลองออนไลน์!

Röda , 97 ไบต์

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

ลองออนไลน์!

เยลลี่ 30 ไบต์

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

ลองออนไลน์!

เรติน่า 58 ไบต์

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

ลองออนไลน์!

CJam, 41 ไบต์

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

JavaScript (ES6), 93 ไบต์

ใช้เพลงเป็นชุดของเส้น

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

บันทึกแล้ว 31 ไบต์ตามความคิดเห็นของ Stephen S

ชาเลนเจอร์ 5 ทำให้มันลดลงเหลือ 165 ไบต์

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

ลองออนไลน์!

Javascript, 118 ไบต์

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

ทดสอบ

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