नाम का खेल खेलना

Question

नाम का खेल खेलने के लिए एक कार्यक्रम लिखें ।

इनपुट

आपके प्रोग्राम को किसी भी तरह से उपयोगकर्ता से इनपुट के रूप में एक नाम स्वीकार करना चाहिए (जैसे मानक इनपुट से पढ़ा जाता है या कमांड-लाइन तर्क के रूप में)। आप मान सकते हैं कि नाम एक एकल शब्द है जिसमें एक ऊपरी मामले पत्र है जिसमें एक या एक से अधिक निचले अक्षर हैं।

उत्पादन

आपके कार्यक्रम को दिए गए नाम के लिए कविता को प्रिंट करना होगा, जैसा कि गीत में बताया गया है, निम्न टेम्पलेट को भरकर:

(X), (X), bo-b(Y)
Banana-fana fo-f(Y)
Fee-fi-mo-m(Y)
(X)!

यहाँ, (X)मूल नाम है, और (Y)किसी भी प्रारंभिक व्यंजन के साथ निचले मामले में नाम है।

हालाँकि, एक अपवाद है। यदि मूल नाम के साथ शुरू हुआ m, fया b, इसे इसी अक्षर के बिना इसी लाइन पर लिखा जाना चाहिए। उदाहरण के लिए, यदि नाम था Bob, "बी" लाइन के साथ समाप्त होना चाहिए bo-ob। ध्यान दें कि इस मामले में, किसी भी अन्य व्यंजन रखा जाता है, तो के लिए Fredयह है fo-red, नहीं fo-ed।

उदाहरण

शर्ली:

Shirley, Shirley, bo-birley
Banana-fana fo-firley
Fee-fi-mo-mirley
Shirley!

अर्नोल्ड:

Arnold, Arnold, bo-barnold
Banana-fana fo-farnold
Fee-fi-mo-marnold
Arnold!

बॉब:

Bob, Bob, bo-ob
Banana-fana fo-fob
Fee-fi-mo-mob
Bob!

फ्रेड:

Fred, Fred, bo-bed
Banana-fana fo-red
Fee-fi-mo-med
Fred!

स्कोरिंग

सबसे छोटा कोड जीतता है।

Comments

मुझे लगता Yहै कि एक मुखर के रूप में संभाला जाता है, इसलिए ऐसा Yvesहै Ivesया Arnold।

— उपयोगकर्ता अज्ञात

लेकिन येट्स, Yestin, Yolanda, या यूलिया के बारे में क्या?

— शाम

@ कुशल: मुझे लगता है कि आप Yकेवल एक स्वर के रूप में व्यवहार कर सकते हैं यदि यह एक व्यंजन द्वारा पीछा किया जाता है। उन मामलों को कम से कम कवर करना चाहिए।

— हमार

मुझे टकर पर तरस आता है।

— पीटर ओल्सन

Answer 1

vi, 118 115

Y2PA,<ESC>Ypj~Y2PIbo-b<c-o>wBanana-fana fo-f<c-o>wFee-fi-mo-m<c-o>2$!<ESC>HJJ:%s/\vo-(([bfm])\2([^aeiou]*))?([bfm]?)[^aeiou]*/o-\3\4
ZZ

कोड में 5 नियंत्रण वर्ण शामिल हैं, जिन्हें मैंने कोष्ठक में रखा है। प्रत्येक केवल वर्ण गणना के लिए एक एकल वर्ण के रूप में गिना जाता है।

EDIT: पहले ज्वाइन (J) को बाद में ले जाना और पेस्ट से पहले (P) को एक पेस्ट-आफ्टर (p) में बदलना 1 वर्ण को बचाया। इसके अलावा, ओ में कब्जा नहीं - रेगेक्स में मुझे 2 और पात्रों को बचाया।

Answer 2

SNOBOL4, 437 430 बाइट्स

 N = TRIM(INPUT)
 D = REPLACE(N,'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+'abcdefghijklmnopqrstuvwxyz')
 B = "b" D
 F = "f" D
 M = "m" D
 &ANCHOR = 1
 D SPAN('bcdfghjklmnpqrstvwxyz') . I REM . R :F(Y)
 B = "b" R
 F = "f" R
 M = "m" R
 I "b" :S(U)
 I "f" :S(V)
 I "m" :S(W) F(Y)
U D "b" REM . B :(Y)
V D "f" REM . F :(Y)
W D "m" REM . M
Y OUTPUT = N ", " N ", bo-" B
 OUTPUT = "Banana-fana fo-" F
 OUTPUT = "Fee-fi-mo-" M
 OUTPUT = N "!"
END

अनगुल्फेड (प्लस मैंने एक प्रॉम्प्ट जोड़ा, ऊपर वाला सिर्फ एक नाम टाइप करने के लिए इंतजार करता है):

      OUTPUT = "Please enter your name."
      Name = TRIM(INPUT)
      UC = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
      LC = 'abcdefghijklmnopqrstuvwxyz'
      Low = REPLACE(Name, UC, LC)
      BName = "b" Low
      FName = "f" Low
      MName = "m" Low
      Consonants = SPAN('bcdfghjklmnpqrstvwxyz')
      &ANCHOR = 1
      Low Consonants . First REM . Rest  :F(READY)
      BName = "b" Rest
      FName = "f" Rest
      MName = "m" Rest
      First "b"                   :S(BINIT)
      First "f"                   :S(FINIT)
      First "m"                   :S(MINIT) F(READY)
BINIT Low "b" REM . BName         :(READY)
FINIT Low "f" REM . FName         :(READY)
MINIT Low "m" REM . MName
READY OUTPUT = Name ", " Name ", bo-" BName
      OUTPUT = "Banana-fana fo-" FName
      OUTPUT = "Fee-fi-mo-" MName
      OUTPUT = Name "!"
END

यह पहला SNOBOL प्रोग्राम है जो मैंने कभी लिखा है।

SNOBOL FORTRAN, COBOL या BASIC जैसी एक लाइन-ओरिएंटेड भाषा है। प्रत्येक पंक्ति में कॉलम 1 में शुरू होने वाले एक वैकल्पिक लेबल होते हैं, लाइन के लिए कोड जिसमें असाइनमेंट और पैटर्न मिलान और एक वैकल्पिक शाखा शामिल हो सकती है। हां, लाइनें (वैकल्पिक) GOTO के साथ समाप्त होती हैं। वे दो रूपों में आते हैं:

        :(TARGET)

शाखाओं को लेबल करने के लिए TARGET, जबकि

        :S(SUCCESS) F(FAILURE)

शाखाएं SUCCESSयदि पैटर्न मैच सफल हुआ, या FAILUREअन्यथा। आप बस सफलता पर शाखा और असफलता पर अगली पंक्ति के माध्यम से गिर सकते हैं, या इसके विपरीत।

निरंतरता रेखाएं +या के साथ शुरू होती हैं .। टिप्पणियाँ एक के साथ शुरू होती हैं *।

यह कैसे काम करता है?

एक नाम में पढ़ें, इसे निचले मामले में बदलें। बी-, एफ-, और एम-नाम यह मानते हुए सेट करें कि यह एक स्वर से शुरू होता है। फिर जांचें कि क्या यह व्यंजन की अवधि से शुरू होता है। यदि नहीं, तो हम जाने के लिए तैयार हैं! यदि ऐसा है, तो अग्रणी व्यंजन को पट्टी करें और यह मान लें कि यह अक्षरों में से किसी के साथ शुरू नहीं होता है। अंत में, जाँच करें कि क्या यह बदले में प्रत्येक अक्षर से शुरू होता है, आवश्यकतानुसार नामों को ठीक करना। फिर हम नाम का खेल खेलने के लिए तैयार हैं!

नमूना रन:

 # $RUN *SNOBOL4 5=GOLF.SNO+*SOURCE* 6=*DUMMY*(1,28)+*SINK*(1,4)+*DUMMY*
 # Execution begins   16:57:25
   Snowman
   Snowman, Snowman, bo-bowman
   Banana-fana fo-fowman
   Fee-fi-mo-mowman
   Snowman!
 # Execution terminated   16:57:30  T=0.013

मैं पर इस भाग गया हरक्यूलिस एस / 370 मेनफ्रेम के 6.0a रिहाई चल एमुलेटर मिशिगन टर्मिनल प्रणाली 1 अप्रैल, 1973 1 मई 1975 पर एमटीएस के लिए बनाया से SNOBOL4 संस्करण 3.10 का उपयोग कर, लेकिन वहाँ चलाने के लिए शायद आसान तरीके हैं SNOBOL4 एक पर आधुनिक प्रणाली। :)

संपादित करें: एक निरर्थक सफलता शाखा को हटा दिया गया था जो एक गिरावट के बराबर था (मुझे नहीं पता था कि मैं केवल एक विफलता शाखा को अपने द्वारा डाल सकता हूं) जो एक अनावश्यक शाखा लेबल को समाप्त कर देती है, और बिना शर्त के गोटो को पूर्व पंक्ति में विफलता शाखा में बदल दिया। 7 बाइट की बचत के लिए।

अब जब TIO में SNOBOL4 समर्थन है तो आप इसे ऑनलाइन आज़मा सकते हैं ! नोट: यह आकार 430 के बजाय 429 के रूप में दिखाता है क्योंकि जब मैंने इसे वहां चिपकाया, तो अंतिम लाइनफीड हटा दिया गया। मैंने निरंतरता लाइन (एक शुरुआत +) को एक पंक्ति में बदलने की कोशिश की , जो मेनफ्रेम संस्करण पर कानूनी नहीं थी क्योंकि यह रेखा बहुत लंबी थी, और यह काम किया और इसे 427 तक लाया। जाहिर तौर पर CSNOBOL4 लंबी लाइनों की अनुमति देता है। मैं अपने स्कोर को 430 पर छोड़ने जा रहा हूं, हालांकि, क्योंकि मेरी मशीन पर स्क्रिप्ट कितनी बाइट्स थी, और इसके अलावा, SNOBOL बहुत गैर-प्रतिस्पर्धी है।

Comments

अब आप इसे ऑनलाइन

— Giuseppe

@Giuseppe वाह, यह अच्छा है! मुझे बताने के लिए धन्यवाद।

— डेविड कॉनरैड

CSNOBOL4 में कुछ अन्य अंतर हैं, क्योंकि असाइनमेंट में केवल अग्रणी स्थान की आवश्यकता होती है, इसलिए आपकी सभी पंक्तियाँ N = TRIM(INPUT)हो सकती हैं N =TRIM(INPUT)।

— Giuseppe

Answer 3

जे , 149 अक्षर

1!:2&2>|.(n,'!');('Fee-fi-mo-';'Banana-fana fo-';n,', ',n,', bo-'),&.>;/'mfb'(,`(}.@])`($:}.)@.((=+.2*5='aeiou'i.]){.)"0 _)a.{~32(23 b.)a.i.n=.1!:1]3

Answer 4

जावास्क्रिप्ट, 115 बाइट्स

r=x=>x.match(/[aeiou]\w*/i)[0];f=x=>`${x}, ${x}, bo-b${r(x)}\nBanana-fana fo-f${r(x)}\nFee-fi-mo-m${r(x)}\n${x}!`

स्पष्टीकरण:

यह फ़ंक्शन प्रारंभिक व्यंजन के बिना नाम लौटाता है

r=x=>x.match(/[aeiouAEIOU]\w*/)[0]

फिर बाकी स्ट्रिंग पूर्ण स्ट्रिंग को वापस करने वाला एक फ़ंक्शन है।

f=x=>`${x}, ${x}, bo-b${r(x)}\nBanana-fana fo-f${r(x)}\nFee-fi-mo-m${r(x)}\n${x}!`

संपादित करें: @Martin एंडर के लिए 119 से 115 बाइट्स के लिए धन्यवाद

Comments

PPCG में आपका स्वागत है! मेरा मानना ​​है कि आप उस रेगेक्स को छोटा कर सकते हैं /[aeiou]\w*/i।

— मार्टिन एंडर

आप मूल संस्करण को छोटे से बदल सकते हैं। पुराने को पोस्ट के संपादन इतिहास में संरक्षित किया जाएगा। यदि आप चाहते हैं कि आप पिछले अंकों JavaScript, <s>119</s> 115 bytesको हेडर में शामिल कर सकें, तो लोगों को यह संकेत देने के लिए कि मूल रूप से एक लंबा संस्करण है यदि वे रुचि रखते हैं।

— मार्टिन एंडर

आह कूल। संपादित फिर से :)

— एनियालेटर

Answer 5

क्लोजर , कम करने के बाद 292 वर्ण

यहाँ एक पहला प्रयास है, लगभग सकारात्मक मैं इसे और नीचे मिटा सकता हूं:

(defn name-game
  [n]
  (let [[b f m] (map (fn [x] (if (some #(= % (first n) (last x)) "bfm")
                              (str (apply str (butlast x)) (apply str (rest n)))
                              (str x (apply str (drop-while (fn [x] (not (some #(= % x) "aeiou"))) n))))) [", bo-b" "\nBanana-fana-fo-f" "\nFee-fi-mo-m"])]
    (str n ", " n b f m "\n" n "!")))

मैं सिर्फ क्लोजर सीख रहा हूं और सोचा कि यह शॉट देने में मजा आएगा। यहाँ मेरा तर्क है:

- स्ट्रिंग की शुरुआत से व्यंजन को बंद करने के लिए: (drop-while (fn [x] (not (some #(= % x) "aeiou"))) name)

- "बी", "एफ" और "एम" के लिए अतिरिक्त नियमों को संभालने के लिए, मैंने वाक्यांशों की सूची में पाठ को तोड़ दिया: [", bo-b" "\nBanana-fana-fo-f" "\nFee-fi-mo-m"]

- फिर, मैंने एक फ़ंक्शन लागू किया जो पूछता है कि क्या वाक्यांश समाप्त होता है उसी अक्षर के साथ जिसका नाम शुरू होता है, और इसका उपयोग पहेली के नियमों के आधार पर उन 3 वाक्यांशों को बदलने के लिए किया जाता है

- अंतिम चरण परिणामों के साथ एक स्ट्रिंग का निर्माण करना है

Answer 6

स्काला 281

मैंने (X) और (Y) को पैटर्न में #और के साथ बदल दिया 012। Sके लिए बस एक नया नाम है Stringऔर के a(b,c,d)लिए आशुलिपि परिभाषा हैb.replaceAll(c,d)

val v="""#, #, bo-b0
Banana-fana fo-f1
Fee-fi-mo-m2
#!"""
type S=String
def a(b:S,c:S,d:S)=b.replaceAll(c,d)
def r(t:S,n:S,i:Int)=if(n(0)=="bfm"(i).toUpper)a(t,"."+i,n.tail)else
a(t,""+i,a(n,"^[^AEIOUaeiou]*([aeiou].*)","$1")).toLowerCase
def x(n:S)=a(r(r(r(v,n,0),n,1),n,2),"#",n)

परीक्षण मंगलाचरण:

val l = List ("Shirley", "Arnold", "Bob", "Fred") 
for (n <- l) println (x (n) + "\n")

और अपुष्ट:

val templ = """#, #, bo-b0
Banana-fana fo-f1
Fee-fi-mo-m2
#!"""

val names = List ("Shirley", "Arnold", "Bob", "Fred") 
val keys = "bfm"

def recode (template: String, n: String, i: Int) = 
 if (n(0) == keys(i).toUpper)
   template.replaceFirst ("." + i, n.tail) else 
 template.replaceAll ("" + i, (n.replaceAll ("^[^AEIOUYaeiouy]*([aeiou].*)", "$1").toLowerCase))

for (name <- names)
  println (recode (recode (recode (templ, name, 0), name, 1), name, 2).replaceAll ("#", name) + "\n")

Answer 7

पायथन 3, 148 145 142 बाइट्स

हाँ मुझे पता है कि थोड़ी देर हो गई है लेकिन ...

n=input();i=0
r=n[i:].lower()
while n[i]not in'aeiouAEIOU':i+=1;r=n[i:]
print(f'{n}, {n}, bo-b{r}\nBanana-fana fo-f{r}\nFee-fi-mo-m{r}\n{n}!')

यह परिणामी स्ट्रिंग को प्रारूपित करने के लिए नए f- स्ट्रिंग्स का उपयोग करता है ।

मुझे नहीं लगता कि टीआईओ दुर्भाग्य से अभी तक एफ-स्ट्रिंग्स का समर्थन करता है।

पुराना संस्करण

def f(n,i=0):
 r=n[i:].lower()
 while n[i].lower()not in'aeiou':i+=1;r=n[i:]
 return f'{n}, {n}, bo-b{r}\nBanana-fana fo-f{r}\nFee-fi-mo-m{r}\n{n}!'

सहेजे गए 3 बाइट्स @officialaimm की बदौलत

Comments

'AEIOUaeiou' शाब्दिक का उपयोग कर और () कम में 3 लाइन से बचने के तीन बाइट्स बचाने

— officialaimm

Answer 8

एसडब्लू, 162 बाइट्स

sed 'h;G;G;G' |sed '1s/.*/&, &, bo-b\L&/i;2s/^.*/Banana-fana fo-f\L&/;3s/^.*/Fee-fi-mo-m\L&/;4s/$/!/;tx;:x;s/o-\([bfm]\)\1/o-/i;tz;s/\(o-[bfm]\)[^aeiou]\+/\1/;:z'

मुझे ऐसा करने से पहले बहुत अच्छी तरह से sed नहीं पता था। मैं, उह, इसे बहुत बेहतर जानता हूं , अब। पाइपलाइन में पहली सीड तीन बार नाम को डुप्लिकेट करती है, इसलिए यह केवल "बॉब" के बजाय "बॉब \ n \ _ \ n" \ n "" बन जाती है। अगली सीड हैवी लिफ्टिंग करती है।

स्टड पर इनपुट की तरह की उम्मीद है echo Name |sed ...

Ungolfed:

sed 'h                           ;# copy to hold buffer
G                                ;# append newline + hold buffer to pattern
G                                ;# ditto for next two G's
G' |sed '1s/.*/&, &, bo-b\L&/i   ;# 1st line -> X, X bo-bx (lowercase)
2s/^.*/Banana-fana fo-f\L&/      ;# 2nd line -> Banana-fana fo-fx
3s/^.*/Fee-fi-mo-m\L&/           ;# 3rd line -> Fee-fi-mo-mx
4s/$/!/                          ;# bang the 4th line!
tx                               ;# jump to :x if any s/// has matched
:x                               ;# spoiler alert: it has! reset t-flag
s/o-\([bfm]\)\1/o-/i             ;# match some o-cc where c = [bfm]
tz                               ;# if that matched, branch to :z
s/\(o-[bfm]\)[^aeiou]\+/\1/      ;# replace o-[bfm] plus consonants with o-[bfm]
:z                               ;# target of tz, skips over previous s///'

नोटों की एक जोड़ी। पहले चार मैच, 1s, 2s, 3s, 4s, आउटपुट को कुछ सही में बदल देते हैं। बॉब बो-बैबॉब बन गया है, फ्रेड फूफ हो गया है, और माइक मो-ममीक बन गया है। काये बनेंगे मो-मके, मके?

फिर, हमें बो-बैब के साथ बो-बब्ब या बो-बे के साथ बो-बके को बदलने की आवश्यकता है। ऐसा करने के लिए, हम एक सुविधा का उपयोग कर सकते हैं जहां हम एक s /// प्रतिस्थापन करते हैं, और फिर शाखा यदि यह सफल हुई, तो दूसरे को कूदते हुए जिसे हम अब छोड़ना चाहते हैं। लेकिन अगर यह चूक गया, तो हम शाखा के माध्यम से गिरना चाहते हैं और अगला प्रतिस्थापन करना चाहते हैं।

T [लेबल] कमांड करता है, ब्रांचिंग केवल अगर पिछले s /// से मेल खाता हो। लेकिन स्क्रिप्ट की शुरुआत में मैंने प्रत्येक पंक्ति के लिए पहले से ही एक s /// किया था (1s, 2s, इत्यादि में अग्रणी संख्याएं पते हैं; उनका मतलब है कि कमांड केवल तभी किया जाता है यदि पता मेल खाता है)। तो कोई बात नहीं, हम 1, 2, 3 या 4 पर हैं, कम से कम एक s /// से मेल खाता है। (मैंने इसे दूसरे तरीके से करने की कोशिश की, नामों की मालिश की और फिर "बनाना-आदि" जोड़ दिया, लेकिन इस तरह से अटक गया, और एक बार में यह सब करने की कोशिश करने से कुछ पुनरावृत्ति हो जाएगी।) सौभाग्य से, झंडा हो सकता है। शाखा लेने से साफ हो जाता है, इसलिए हम "tx ;: x" के साथ ऐसा करते हैं। टीएक्स शाखाएं एक्स लेबल के लिए, और: एक्स एक्स लेबल है।

वाह! यह अंतिम दो प्रतिस्थापन के लिए तालु को साफ करता है। हम एक कोशिश करते हैं, और अगर यह सफल होता है तो हम दूसरे पर शाखा लगाते हैं, अन्यथा हम दूसरा काम करते हैं। किसी भी तरह से हम समाप्त हो जाते हैं: z लेबल और पैटर्न बफर में गीतों की एक पंक्ति होती है जो कि stdout में मुद्रित होती है।

आखिरकार सेड मैन पेज और टेक्सिनफो मैनुअल के साथ पर्याप्त समय बिताने में मुझे धोखा देने के लिए धन्यवाद, आखिरकार यह समझने के लिए कि कैसे sed s / foo / bar / से अधिक है

Comments

ओह, मैं स्क्रिप्ट की पूरी लंबाई को sed कमांड |और सभी के साथ गिन रहा हूं । शायद मुझे इस बैश / सेड को कॉल करना चाहिए, या इसे अलग तरह से गिनना चाहिए? मुझे नहीं पता। मैं इसके साथ खुश हूं-लेकिन मुझे यह बताना चाहिए कि क्या यह पीपीसीजी के मानकों से अलग होना चाहिए।

— डेविड कॉनराड

Answer 9

अजगर, 161

x=raw_input('')
a,b,c=x[0],x[1:],'bfm'
if b[0] in c:b=b[1:]
d="X, X, bo-@\nBanana-fana fo-@\nFee-fi-mo-@\nX!".replace('X',a)
for y in c:d=d.replace('@',y+b,1)
print d

बस एहसास हुआ कि मेरा कोड फेल है ...
- शुरुआती कॉन्स्टेंट को नहीं हटाता।
- 'बो-ओब' व्यवसाय का प्रबंधन नहीं करता है।

यह मुझे सबसे दूर है, शायद कोई इसे खत्म कर सकता है।

Answer 10

ग्रूवी, 146

r={n->m={n[0]==it[0]?n[1..-1]:it[1]+(n.toLowerCase()=~'[aeiou].*')[0]};"$n, $n, bo-${m 'Bb'}\nBanana-fana fo-${m 'Ff'}\nFee-fi-mo-${m 'Mm'}\n$n!"}

assert ['Shirley', 'Arnold', 'Bob', 'Fred'].collect { r(it) } == [
'''Shirley, Shirley, bo-birley
Banana-fana fo-firley
Fee-fi-mo-mirley
Shirley!''',
'''Arnold, Arnold, bo-barnold
Banana-fana fo-farnold
Fee-fi-mo-marnold
Arnold!''',
'''Bob, Bob, bo-ob
Banana-fana fo-fob
Fee-fi-mo-mob
Bob!''',
'''Fred, Fred, bo-bed
Banana-fana fo-red
Fee-fi-mo-med
Fred!'''
]

Answer 11

आर, 189 वर्ण

x=scan(,'');f=function(b)if(grepl(b,x))sub('.','',x)else tolower(sub('^[^aoueiy]*',b,x,i=T));cat(sprintf('%s, %1$s, bo-%s\nBanana-fana fo-%s\nFee-fi-mo-%s\n%1$s!\n',x,f('B'),f('F'),f('M')))

लेकिन सिर्फ एक और चरित्र के साथ, आप एक बार में कई नाम दर्ज कर सकते हैं:

x=scan(,'');f=function(b)ifelse(grepl(b,x),sub('.','',x),tolower(sub('^[^aoueiy]*',b,x,i=T)));cat(sprintf('%s, %1$s, bo-%s\nBanana-fana fo-%s\nFee-fi-mo-%s\n%1$s!\n',x,f('B'),f('F'),f('M')))

Answer 12

Pyth , 111 बाइट्स ^SBCS

V"BFM"IqhzN=aYtrz0.?=aY+rN0:rz0"^[^aeiou]+"k))+%." s­ÞXY:lÍ"*]z2@Y0+." o1}1ÃЬÛJî½"@Y1+."-o Âkq°ë¹è"@Y2+z\!

परीक्षण सूट

कोड अनपेक्षित वर्णों का उपयोग करता है, और जैसा कि स्टैक एक्सचेंज पर ठीक से प्रदर्शित नहीं होता है। दिए गए लिंक में ये अक्षर हैं और यह कार्यक्रम का सही संस्करण है।

Answer 13

अजगर

n=raw_input('')
if n[0].lower() in ("m", "f", "b"): r=n[1:]
else:
    i = iter(n.lower())
    for a in range(len(n)):
        if i.next() in ("a","e","i","o","u"):
            r = n[a:]
            break
print "%s, %s, bo-b%s\nBanana-fana fo-f%s\nFee-fi-mo-m%s\n%s!" %(name,name,rhyme,rhyme,rhyme,name)