The Name Game: Difference between revisions
Content deleted Content added
(48 intermediate revisions by 26 users not shown) | |||
Line 1:
{{task}}
Write a program that accepts a name as input and outputs the lyrics to the Shirley Ellis song "The Name Game".
The regular verse
Line 33 ⟶ 34:
In case of a 'B', an 'F' or an 'M' (e.g. Billy, Felix, Mary) there is a special rule.
The line which would 'rebuild' the name (e.g. bo-billy) is
The verse for the name Billy looks like this:
Line 47 ⟶ 48:
Fee-fi-mo-melix
Felix!
{{Template:Strings}}
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F print_verse(n)
V l = [String(‘b’), ‘f’, ‘m’]
V s = n[1..]
V? i = l.find(n[0].lowercase())
I i != N
l[i] = ‘’
E I n[0] C (‘A’, ‘E’, ‘I’, ‘O’, ‘U’)
s = n.lowercase()
print("#., #., bo-#.#.\nBanana-fana fo-#.#.\nFee-fi-mo-#.#.\n#.!\n".format(n, n, l[0], s, l[1], s, l[2], s, n))
L(n) [‘Gary’, ‘Earl’, ‘Billy’, ‘Felix’, ‘Mary’]
print_verse(n)</syntaxhighlight>
=={{header|Ada}}==
{{works with|Ada|Ada|2012}}
<
with Ada.Strings.Unbounded;
with Ada.Text_IO;
Line 103 ⟶ 123:
Lyrics(+name);
end loop;
end The_Name_Game;</
{{out}}
<pre>Gary, Gary, bo-bary
Line 134 ⟶ 154:
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G}}
<
main:(
PROC print lyrics = (STRING name) VOID:
Line 163 ⟶ 183:
OD
)
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">nameGame: function [Name][
L: take Name 1
name: lower Name
unless in? L "AEIOU" -> drop 'name
[B F M]: ["b" "f" "m"]
if L="B" -> B: ""
if L="F" -> F: ""
if L="M" -> M: ""
~{
|Name|, |Name|, bo-|B||name|
Banana-fana fo-|F||name|
Fee-fi-mo-|M||name|
|Name|!
}
]
["Gary" "Earl" "Billy" "Felicia" "Marissa" "Sarah"]
| map => nameGame
| loop => [print & ++ "\n"]</syntaxhighlight>
{{out}}
<pre>Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Felicia, Felicia, bo-belicia
Banana-fana fo-elicia
Fee-fi-mo-melicia
Felicia!
Marissa, Marissa, bo-barissa
Banana-fana fo-farissa
Fee-fi-mo-arissa
Marissa!
Sarah, Sarah, bo-barah
Banana-fana fo-farah
Fee-fi-mo-marah
Sarah!</pre>
=={{header|AutoHotkey}}==
<
BFM := false
if (SubStr(x, 1, 1) ~= "i)^[AEIOU]") ; Vowel
Line 181 ⟶ 247:
result .= output "`n`n"
}
MsgBox, 262144, ,% result</
{{out}}
<pre>Gary, Gary, bo-bary
Line 209 ⟶ 275:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f THE_NAME_GAME.AWK
BEGIN {
Line 227 ⟶ 293:
printf("%s!\n\n",x)
}
</syntaxhighlight>
{{out}}
<pre>
Line 259 ⟶ 325:
Fee-fi-mo-mhirley
Shirley!
</pre>
=={{header|BASIC256}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">subroutine TheGameName(nombre)
x = lower(nombre)
x = upper(mid(x,1,1)) + (mid(x,2,length(x)-1))
x0 = upper(mid(x,1,1))
if x0 = "A" or x0 = "e" or x0 = "I" or x0 = "O" or x0 = "U" then
y = lower(x)
else
y = mid(x,2,length(x)-1)
end If
b = "b" + y
f = "f" + y
m = "m" + y
begin case
case x0 = "B"
b = y
case x0 = "F"
f = y
case x0 = "M"
m = y
end case
print x + ", " + x + ", bo-" + b
print "Banana-fana fo-" + f
print "Fee-fi-mo-" + m
print x + "!" + chr(10)
end subroutine
dim listanombres[5]
listanombres = {"Gary", "EARL", "billy", "FeLiX", "Mary", "ShirleY"}
for i = 0 to listanombres[?]-1
call TheGameName(listanombres[i])
next i
end</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC.
</pre>
=={{header|C}}==
{{trans|Kotlin}}
<
#include <string.h>
Line 302 ⟶ 412:
for (i = 0; i < 6; ++i) print_verse(names[i]);
return 0;
}</
{{out}}
Line 339 ⟶ 449:
=={{header|C sharp|C#}}==
{{trans|Java}}
<
using System.Collections.Generic;
using System.Text;
Line 376 ⟶ 486:
}
}
}</
{{out}}
<pre>Gary, Gary, bo-bary
Line 410 ⟶ 520:
=={{header|C++}}==
{{trans|C#}}
<
#include <iostream>
#include <string>
Line 468 ⟶ 578:
return 0;
}</
{{out}}
<pre>Gary, Gary, bo-bary
Line 506 ⟶ 616:
Note also the code on lines 30 and 75 to convert the case of the first letter... On some Commodore machines, the default is to render text in ALL CAPS, shifted letters become graphic symbols. This program sets the mode to display mixed case [chr$(14)] and then converts the first letter of the name for the purpose of uniform pattern matching in case the user types the name properly with a capitalized first letter.
<
2 rem rosetta code
5 dim cn$(3),bl$(3,32):gosub 1000
Line 564 ⟶ 674:
2050 rem quadgraph
2060 data schr,schl
2069 data xx</
{{out}}
Line 625 ⟶ 735:
=={{header|D}}==
<
import std.array;
import std.conv;
Line 677 ⟶ 787:
printVerse(name);
}
}</
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
function WaitForString(Memo: TMemo; Prompt: string): string;
{Wait for key stroke on TMemo component}
var KW: TKeyWaiter;
begin
{Use custom object to wait and capture key strokes}
KW:=TKeyWaiter.Create(Memo);
try
Memo.Lines.Add(Prompt);
Memo.SelStart:=Memo.SelStart-1;
Memo.SetFocus;
Result:=KW.WaitForString;
finally KW.Free; end;
end;
procedure NameGame(Memo: TMemo);
var Name: string;
var Str2: string;
var FL: Char;
function GetPattern: string;
var BStr,FStr,MStr: string;
begin
if FL='b' then BStr:='bo-' else BStr:='bo-b';
if FL='f' then FStr:='fo-' else FStr:='fo-f';
if FL='m' then MStr:='mo-' else MStr:='mo-m';
Result:=Format('%S, %S, %S%S',[Name,Name,BStr,Str2])+CRLF;
Result:=Result+Format('Banana-fana %S%S',[FStr,Str2])+CRLF;
Result:=Result+Format('Fee-fi-%S%S',[MStr,Str2])+CRLF;
Result:=Result+Format('%S!',[Name])+CRLF;
end;
begin
while true do
begin
Name:=WaitForString(Memo,'Enter a name: ');
if Name='' then break;
Str2:=LowerCase(Name);
FL:=Str2[1];
if not (FL in ['a','e','i','o','u']) then Delete(Str2,1,1);
Memo.Lines.Add(GetPattern);
end;
end;
</syntaxhighlight>
{{out}}
<pre>
Enter a name:
Gary
Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-mary
Gary!
Enter a name:
Earl
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-mo-mearl
Earl!
Enter a name:
Billy
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Enter a name:
Felix
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-mo-melix
Felix!
Enter a name:
Mary
Mary, Mary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-ary
Mary!
Enter a name:
Elapsed Time: 01:18.249 min
</pre>
=={{header|Dyalect}}==
<syntaxhighlight lang="dyalect">func printVerse(name) {
let x = name[..1].Upper() + name[1..].Lower();
let y = "AEIOU".IndexOf(x[0]) > -1 ? x.Lower() : x[1..]
let b = x[0] is 'B' ? y : "b" + y
let f = x[0] is 'F' ? y : "f" + y
let m = x[0] is 'M' ? y : "m" + y
print("\(x), \(x), bo-\(b)")
print("Banana-fana fo-\(f)")
print("Fee-fi-mo-\(m)")
print("\(x)!", x)
print()
}
let seq = yields { "Gary", "Earl", "Billy", "Felix", "Mary", "Steve" }
for x in seq {
printVerse(x)
}</syntaxhighlight>
{{out}}
<pre>GAary, GAary, bo-bAary
Banana-fana fo-fAary
Fee-fi-mo-mAary
GAary!,GAary
EAarl, EAarl, bo-beaarl
Banana-fana fo-feaarl
Fee-fi-mo-meaarl
EAarl!,EAarl
BIilly, BIilly, bo-Iilly
Banana-fana fo-fIilly
Fee-fi-mo-mIilly
BIilly!,BIilly
FEelix, FEelix, bo-bEelix
Banana-fana fo-Eelix
Fee-fi-mo-mEelix
FEelix!,FEelix
MAary, MAary, bo-bAary
Banana-fana fo-fAary
Fee-fi-mo-Aary
MAary!,MAary
STteve, STteve, bo-bTteve
Banana-fana fo-fTteve
Fee-fi-mo-mTteve
STteve!,STteve</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang=text>
proc verse x$ . .
x1$ = substr x$ 1 1
y$ = substr x$ 2 99
if strpos "AEIOU" x1$ <> 0
h$ = strchar (strcode x1$ + 32)
y$ = h$ & y$
.
b$ = "b" & y$
f$ = "f" & y$
m$ = "m" & y$
if x1$ = "B"
b$ = y$
elif x1$ = "F"
f$ = y$
elif x1$ = "M"
m$ = y$
.
print x$ & ", " & x$ & ", bo-" & b$
print "Banana-fana fo-" & f$
print "Fee-fi-mo-" & m$
print x$ & "!"
.
for n$ in [ "Gary" "Earl" "Billy" "Felix" "Mary" ]
verse n$
print ""
.
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
===The function===
<
// The Name Game. Nigel Galloway: March 28th., 2018
let fN g =
Line 691 ⟶ 987:
|'m' -> fG ("b"+g.[1..]) ("f"+g.[1..]) (g.[1..])
|_ -> fG ("b"+g.[1..]) ("f"+g.[1..]) ("m"+g.[1..])
</syntaxhighlight>
===The Task===
<
fN "Nigel"
</syntaxhighlight>
{{out}}
<pre>
Line 703 ⟶ 999:
Nigel!
</pre>
<
fN "Earl"
</syntaxhighlight>
{{out}}
<pre>
Line 713 ⟶ 1,009:
Earl!
</pre>
<
fN "Billy"
</syntaxhighlight>
{{out}}
<pre>
Line 723 ⟶ 1,019:
Billy!
</pre>
<
fN "Fred"
</syntaxhighlight>
{{out}}
<pre>
Line 733 ⟶ 1,029:
Fred!
</pre>
<
fN "Mum"
</syntaxhighlight>
{{out}}
<pre>
Line 747 ⟶ 1,043:
{{trans|Kotlin}}
{{works with|Factor|0.98}}
<
pair-rocket qw sequences ;
IN: rosetta-code.name-game
Line 770 ⟶ 1,066:
${Name}!I] nl nl ;
qw{ Gary Earl Billy Felix Milton Steve } [ name-game ] each</
{{out}}
<pre>
Line 803 ⟶ 1,099:
Steve!
</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">Sub TheGameName(nombre As String)
Dim As String x = Lcase(nombre)
x = Ucase(Mid(x,1,1)) + (Mid(x,2,Len(x)-1))
Dim As String x0 = Ucase(Mid(x,1,1))
Dim As String y
If x0 = "A" Or x0 = "E" Or x0 = "I" Or x0 = "O" Or x0 = "U" Then
y = Lcase(x)
Else
y = Mid(x,2)
End If
Dim As String b = "b" + y, f = "f" + y, m = "m" + y
Select Case x0
Case "B" : b = y
Case "F" : f = y
Case "M" : m = y
End Select
Print x + ", " + x + ", bo-" + b
Print "Banana-fana fo-" + f
Print "Fee-fi-mo-" + m
Print x + "!" + Chr(10)
End Sub
Dim listanombres(5) As String = {"Gary", "EARL", "billy", "FeLiX", "Mary", "ShirlEY"}
For i As Integer = 0 To Ubound(listanombres)
TheGameName(listanombres(i))
Next i
Sleep</syntaxhighlight>
{{out}}
<pre>
Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-mo-mearl
Earl!
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-mo-melix
Felix!
Mary, Mary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-ary
Mary!
Shirley, Shirley, bo-bhirley
Banana-fana fo-fhirley
Fee-fi-mo-mhirley
Shirley!
</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/The_Name_Game}}
'''Solution'''
[[File:Fōrmulæ - The Name Game 01.png]]
'''Test cases'''
[[File:Fōrmulæ - The Name Game 02.png]]
[[File:Fōrmulæ - The Name Game 03.png]]
=={{header|Go}}==
{{trans|Kotlin}}
<
import (
Line 841 ⟶ 1,216:
printVerse(name)
}
}</
{{out}}
Line 877 ⟶ 1,252:
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">
-- The Name Game, Ethan Riley, 22nd May 2018
import Data.Char
Line 919 ⟶ 1,294:
main =
mapM_ (putStrLn . theNameGame) ["Gary", "Earl", "Billy", "Felix", "Mike", "Steve"]
</syntaxhighlight>
{{out}}
<pre>
Line 955 ⟶ 1,330:
=={{header|J}}==
Substitutions must conform to the region they replace. Cannot directly substitute 'Gary' where 'X' occurs in the template. Work instead with boxes, then at the end raze them to recover the verse.
<syntaxhighlight lang="j">
T=:TEMPLATE=: noun define
(X), (X), bo-b(Y)
Line 977 ⟶ 1,352:
; XBox
)
</syntaxhighlight>
<pre>
nameGame&> ;:'Gary Earl Billy Felix Mary'
Line 1,008 ⟶ 1,383:
=={{header|Java}}==
{{trans|Kotlin}}
<
public class NameGame {
Line 1,042 ⟶ 1,417:
Stream.of("Gary", "Earl", "Billy", "Felix", "Mary", "Steve").forEach(NameGame::printVerse);
}
}</
{{out}}
<pre>Gary, Gary, bo-bary
Line 1,073 ⟶ 1,448:
Fee-fi-mo-mteve
Steve!</pre>
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">function singNameGame(name) {
// normalize name
name = name.toLowerCase();
name = name[0].toUpperCase() + name.slice(1);
// ... and sometimes y
// let's pray this works
let firstVowelPos = (function() {
let vowels =
'aeiouàáâãäåæèéêëìíîïòóôõöøùúûüāăąēĕėęěĩīĭįıijōŏőœũūŭůűų'
.split('');
function isVowel(char) {
return vowels.indexOf(char) >= 0;
}
if (isVowel(name[0].toLowerCase())) return 0;
if (name[0] == 'Y' && !isVowel(name[1])) return 0;
if (name[0] == 'Y' && isVowel(name[1])) return 1;
vowels = vowels.concat(vowels, 'yÿý'.split(''));
for (let i = 1; i < name.length; i++)
if (isVowel(name[i])) return i;
})();
let init = name[0].toLowerCase(),
trunk = name.slice(firstVowelPos).toLowerCase(),
b = trunk, f = trunk, m = trunk;
switch (init) {
case 'b': f = 'f' + trunk; m = 'm' + trunk; break;
case 'f': b = 'b' + trunk; m = 'm' + trunk; break;
case 'm': b = 'b' + trunk; f = 'f' + trunk; break;
default: b = 'b' + trunk; f = 'f' + trunk; m = 'm' + trunk;
}
return `
<p>${name}, ${name}, bo-${b}<br>
Banana-fana fo-${f}<br>
Fee-fi-fo-mo-${m}<br>
${name}!<br></p>
`
}
// testing
let names =
'Gary Earl Billy Felix Mary Christine Brian Yvonne Yannick'.split(' ');
for (let i = 0; i < names.length; i++)
document.write(singNameGame(names[i]));</syntaxhighlight>
{{out}}<pre>
Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-fo-mo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-fo-mo-mearl
Earl!
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-fo-mo-milly
Billy!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-fo-mo-melix
Felix!
Mary, Mary, bo-bary
Banana-fana fo-fary
Fee-fi-fo-mo-ary
Mary!
Christine, Christine, bo-bistine
Banana-fana fo-fistine
Fee-fi-fo-mo-mistine
Christine!
Brian, Brian, bo-ian
Banana-fana fo-fian
Fee-fi-fo-mo-mian
Brian!
Yvonne, Yvonne, bo-byvonne
Banana-fana fo-fyvonne
Fee-fi-fo-mo-myvonne
Yvonne!
Yannick, Yannick, bo-bannick
Banana-fana fo-fannick
Fee-fi-fo-mo-mannick
Yannick!
</pre>
=={{header|jq}}==
'''Adapted from [[#Python]]'''
{{works with|jq}}
'''Also works with gojq, the Go implementation of jq, and with fq.'''
<syntaxhighlight lang=jq>
def capitalize:
if length==0 then .
else .[0:1] as $c
| ($c|ascii_upcase) as $C
| if $c == $C then .
else $C + .[1:]
end
end;
def printVerse:
{x: (ascii_downcase|capitalize)}
| .x[0:1] as $x0
| .y = (if $x0|test("[AEIOU]") then .x | ascii_downcase else .x[1:] end)
| .b = ((select($x0 == "B") | "") // "b")
| .f = ((select($x0 == "F") | "") // "f")
| .m = ((select($x0 == "M") | "") // "m")
| "\(.x), \(.x), bo-\(.b)\(.y)",
"Banana-fana fo-\(.f)\(.y)",
"Fee-fi-mo-\(.m)\(.y)",
"\(.x)!\n" ;
"Gary", "Earl", "Billy", "Felix", "Mary", "Steve"
| printVerse
</syntaxhighlight>
{{output}}
As for [[#Wren|Wren]].
=={{header|Julia}}==
<
function printverse(name::AbstractString)
Line 1,092 ⟶ 1,594:
end
foreach(TheNameGame.printverse, ("gARY", "Earl", "Billy", "Felix", "Mary", "sHIRley"))</
{{out}}
Line 1,126 ⟶ 1,628:
=={{header|Kotlin}}==
<
fun printVerse(name: String) {
Line 1,148 ⟶ 1,650:
fun main(args: Array<String>) {
listOf("Gary", "Earl", "Billy", "Felix", "Mary", "Steve").forEach { printVerse(it) }
}</
{{out}}
Line 1,185 ⟶ 1,687:
=={{header|Lua}}==
{{trans|C#}}
<
local sb = string.lower(name)
sb = sb:gsub("^%l", string.upper)
Line 1,222 ⟶ 1,724:
for _,name in pairs(nameList) do
printVerse(name)
end</
{{out}}
<pre>Gary, Gary, bo-bary
Line 1,259 ⟶ 1,761:
song$=format$("\r\n{0}, {0}, bo-{2}{1}\r\nBanana-fana fo-{3}{1}\r\nFee-fi-mo-{4}{1}\r\n{0}!\r\n")
<syntaxhighlight lang="m2000 interpreter">
Module The.Name.Game {
Flush
Line 1,286 ⟶ 1,788:
}
The.Name.Game
</syntaxhighlight>
{{out}}
Line 1,312 ⟶ 1,814:
Felix!
</pre >
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[NameGame]
NameGame[n_] := Module[{y, b, f, m},
If[StringStartsQ[ToLowerCase[n], "a" | "e" | "i" | "u" | "o"],
y = ToLowerCase[n]
,
y = StringDrop[n, 1]
];
b = "b" <> y;
f = "f" <> y;
m = "m" <> y;
Switch[ToLowerCase@StringTake[n, 1],
"b", b = y,
"f", f = y,
"m", m = y
];
StringReplace["(X), (X), bo-(B)\nBanana-fana fo-(F)\nFee-fi-mo-(M)\n(X)! ", {"(X)" -> n, "(B)" -> b, "(F)" -> f, "(M)" -> m}]
]
NameGame["Gary"]
NameGame["Earl"]
NameGame["Billy"]
NameGame["Felix"]
NameGame["Mary"]
NameGame["Steve"]</syntaxhighlight>
{{out}}
<pre>Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-mo-mearl
Earl!
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-mo-melix
Felix!
Mary, Mary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-ary
Mary!
Steve, Steve, bo-bteve
Banana-fana fo-fteve
Fee-fi-mo-mteve
Steve!</pre>
=={{header|min}}==
{{works with|min|0.19.3}}
{{trans|Factor}}
<
(
Line 1,334 ⟶ 1,891:
) :name-game
("Gary" "Earl" "Billy" "Felix" "Milton" "Steve") 'name-game foreach</
{{out}}
<pre>
Line 1,367 ⟶ 1,924:
Steve!
</pre>
=={{header|MIPS Assembly}}==
The cartridge header and print routines were omitted so that the reader can focus on the logic.
<syntaxhighlight lang="mips"> la $a0,theNameGame
la $s0,theName
jal PrintString_NameGame
nop
jal NewLine
nop
la $a0,theNameGame
la $s0,theName2
jal PrintString_NameGame
nop
jal NewLine
nop
la $a0,theNameGame
la $s0,theName3
jal PrintString_NameGame
nop
jal NewLine
nop
shutdown:
nop ;project 64 detects an infinite loop and throws an error, unless an extra nop is here.
b shutdown
nop
PrintString_NameGame:
pushall
DrawChars_NameGame:
lbu a1,0(a0) ;Load a character
.ifdef buildPSX
nop ;load delay slot - not needed on MIPS III or higher
.endif
beqz a1,PrintString_Done ;Done?
nop
li $a2,'%'
bne $a1,$a2,skip_NameGameLC
nop
jal insertNameLetterChange
nop
addiu a0,1
b DrawChars_NameGame
nop
skip_NameGameLC:
li $a2,'?'
bne $a1,$a2,skip_NameGameAsIs
nop
jal insertName
nop
addiu a0,1
b DrawChars_NameGame
nop
skip_NameGameAsIs:
li $a2,10
bne $a1,$a2,skip_Linefeed
nop
jal NewLine
nop
skip_Linefeed:
addiu a0,1 ;branch delay slot - Move to next Char
jal PrintChar ;Show Character A0 to the screen
nop
j DrawChars_NameGame ;Repeat
nop
PrintString_Done_NameGame:
popall
jr ra
nop
insertName:
push a0
push ra
move $a0,$s0
jal PrintString
nop
pop ra
pop a0
jr ra
nop
insertNameLetterChange:
push a0
push ra
subiu $a0,3
lbu $a1,($a0) ;we may need to replace the first letter of the name with this character.
.ifdef buildPSX
nop ;load delay slot - not needed on MIPS III or higher
.endif
move $a0,$s0
lbu $a2,($a0)
.ifdef buildPSX
nop ;load delay slot - not needed on MIPS III or higher
.endif
beq $a1,$a2,skipFirstLetter
nop
jal PrintChar
nop
skipFirstLetter:
;now we check if the $a2 is a vowel, if it is, skip the addiu
li $a3,'a'
beq $a3,$a2,FirstLetterIsVowel
nop
li $a3,'e'
beq $a3,$a2,FirstLetterIsVowel
nop
li $a3,'i'
beq $a3,$a2,FirstLetterIsVowel
nop
li $a3,'o'
beq $a3,$a2,FirstLetterIsVowel
nop
li $a3,'u'
beq $a3,$a2,FirstLetterIsVowel
nop
addiu $a0,1
FirstLetterIsVowel:
jal PrintString
nop
pop ra
pop a0
jr ra
nop
theName:
.ascii "gary"
.byte 0 ;null terminator
.align 4
theName2:
.ascii "earl"
.byte 0
.align 4
theName3:
.ascii "billy"
.byte 0
.align 4
theNameGame:
.ascii "?,?,bo-%"
.byte 10 ;line feed
.ascii "banana-fana fo-%"
.byte 10
.ascii "fee-fi-mo-%"
.byte 10
.ascii "?!"
.byte 0
.align 4</syntaxhighlight>
{{out}}
[https://ibb.co/V9GcTFV Screenshot of emulator]
<pre>gary,gary,bo-bary
banana-fana fo-fary
fee-fi-mo-mary
gary!
earl,earl,bo-bearl
banana-fana fo-fearl
fee-fi-mo-mearl
earl!
billy,billy,bo-illy
banana-fana fo-filly
fee-fi-mo-milly
billy!</pre>
=={{header|Modula-2}}==
<
FROM Strings IMPORT Concat;
FROM ExStrings IMPORT Lowercase;
Line 1,434 ⟶ 2,160:
ReadChar;
END NameGame.</
=={{header|Nanoquery}}==
{{trans|Python}}
<
l = {"b", "f", "m"}
s = n.substring(1)
Line 1,457 ⟶ 2,183:
for n in names
print_verse(n)
end</
=={{header|Nim}}==
<syntaxhighlight lang="nim">import strutils
const
StdFmt = "$1, $1, bo-b$2\nBanana-fana fo-f$2\nFee-fi-mo-m$2\n$1!"
WovelFmt = "$1, $1, bo-b$2\nBanana-fana fo-f$2\nFee-fi-mo-m$2\n$1!"
BFmt = "$1, $1, bo-$2\nBanana-fana fo-f$2\nFee-fi-mo-m$2\n$1!"
FFmt = "$1, $1, bo-b$2\nBanana-fana fo-$2\nFee-fi-mo-m$2\n$1!"
MFmt = "$1, $1, bo-b$2\nBanana-fana fo-f$2\nFee-fi-mo-$2\n$1!"
proc lyrics(name: string): string =
let tail = name[1..^1]
result = case name[0].toUpperAscii
of 'A', 'E', 'I', 'O', 'U', 'Y':
WovelFmt.format(name, name.toLowerAscii)
of 'B':
BFmt.format(name, tail)
of 'F':
FFmt.format(name, tail)
of 'M':
MFmt.format(name, tail)
else:
StdFmt.format(name, tail)
result = result.capitalizeAscii()
for name in ["Gary", "Earl", "Billy", "Felix", "Mary"]:
echo name.lyrics()
echo()</syntaxhighlight>
{{out}}
<pre>Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-mo-mearl
Earl!
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-mo-melix
Felix!
Mary, Mary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-ary
Mary!</pre>
=={{header|Perl}}==
{{trans|Lua}}
<
$x = ucfirst lc shift;
$x0 = substr $x, 0, 1;
Line 1,474 ⟶ 2,256:
}
printVerse($_) for <Gary Earl Billy Felix Mary Steve>;</
{{out}}
<pre>Gary, Gary, bo-bary
Line 1,508 ⟶ 2,290:
=={{header|Phix}}==
{{trans|Go}}
<!--<syntaxhighlight lang="phix">-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">fmt</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""
%s, %s, bo-%s
Fee-fi-mo-%s
%s!
"""</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">printVerse</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">name</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">lower</span><span style="color: #0000FF;">(</span><span style="color: #000000;">name</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">x1</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">upper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]),</span>
<span style="color: #000000;">vowel</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"AEIUO"</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">0</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">-</span><span style="color: #000000;">vowel</span><span style="color: #0000FF;">..$],</span>
<span style="color: #000000;">b</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">'b'</span><span style="color: #0000FF;">&</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">f</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">'f'</span><span style="color: #0000FF;">&</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">m</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">'m'</span><span style="color: #0000FF;">&</span><span style="color: #000000;">y</span>
<span style="color: #000000;">x</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">x1</span>
<span style="color: #008080;">switch</span> <span style="color: #000000;">x1</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">case</span> <span style="color: #008000;">'B'</span><span style="color: #0000FF;">:</span> <span style="color: #000000;">b</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">y</span>
<span style="color: #008080;">case</span> <span style="color: #008000;">'F'</span><span style="color: #0000FF;">:</span> <span style="color: #000000;">f</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">y</span>
<span style="color: #008080;">case</span> <span style="color: #008000;">'M'</span><span style="color: #0000FF;">:</span> <span style="color: #000000;">m</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">y</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">switch</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fmt</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">tests</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"gARY"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Earl"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Billy"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Felix"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Mary"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"SHIRley"</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span> <span style="color: #000000;">printVerse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,563 ⟶ 2,347:
Fee-fi-mo-mhirley
Shirley!
</pre>
=={{header|Picat}}==
{{works with|Picat}}
<syntaxhighlight lang="picat">
print_name_game(Name), Name = [V|Rest], membchk(V, ['A', 'E', 'I', 'O', 'U']) =>
L = to_lowercase(V),
Low = [L|Rest],
print_verse(Name, [b|Low], [f|Low], [m|Low]).
print_name_game(Name), Name = ['B'|Rest] =>
print_verse(Name, Rest, [f|Rest], [m|Rest]).
print_name_game(Name), Name = ['F'|Rest] =>
print_verse(Name, [b|Rest], Rest, [m|Rest]).
print_name_game(Name), Name = ['M'|Rest] =>
print_verse(Name, [b|Rest], [f|Rest], Rest).
print_name_game(Name), Name = [C|Rest] =>
print_verse(Name, [b|Rest], [f|Rest], [m|Rest]).
print_verse(Full, B, F, M) =>
printf("%w, %w, bo-%w\nBanana-fana fo-%w\nFee-fi-mo-%w\n%w!\n\n",
Full,
Full,
B,
F,
M,
Full
).
main(Args) =>
foreach (Name in Args)
print_name_game(Name)
end.
</syntaxhighlight>
{{out}}
<pre>
$ picat name_game.pi Gary Earl Billy Felix Mary
Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-mo-mearl
Earl!
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-mo-melix
Felix!
Mary, Mary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-ary
Mary!
</pre>
=={{header|PowerShell}}==
{{trans|Chris}}
<syntaxhighlight lang="powershell">
## Clear Host from old Ouput
Clear-Host
Line 1,621 ⟶ 2,469:
}
Write-Host "$Name"
</syntaxhighlight>
=={{header|Prolog}}==
<syntaxhighlight lang="prolog">map_name1(C, Cs, C, Cs).
map_name1(C, Cs, Fc, [Fc,C|Cs]) :- member(C, ['a','e','i','o','u']).
map_name1(C, Cs, Fc, [Fc|Cs]) :-
\+ member(C, ['a','e','i','o','u']),
dif(C, Fc).
map_name(C, Cs, Fc, Name) :-
map_name1(C, Cs, Fc, NChars),
atom_chars(Name, NChars).
song(Name) :-
string_lower(Name, LName),
atom_chars(LName, [First|Chars]),
map_name(First, Chars, 'b', BName),
map_name(First, Chars, 'f', FName),
map_name(First, Chars, 'm', MName),
maplist(write,
[Name, ", ", Name, ", bo-", BName, '\n',
"Banana-fana fo-", FName, '\n',
"Fee-fi-mo-", MName, '\n',
Name, "!\n\n"]).
test :-
maplist(song, ["Gary", "Earl", "Billy", "Felix", "Mary"]).</syntaxhighlight>
{{out}}
<pre>
1 ?- test.
Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-mo-mearl
Earl!
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-mo-melix
Felix!
Mary, Mary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-ary
Mary!
true
</pre>
=={{header|Python}}==
<
l = ['b', 'f', 'm']
s = n[1:]
Line 1,635 ⟶ 2,541:
# Assume that the names are in title-case and they're more than one character long
for n in ['Gary', 'Earl', 'Billy', 'Felix', 'Mary']:
print_verse(n)</
=={{header|q}}==
===String search and replace===
<syntaxhighlight lang="q">game_ssr:{[Name]
V:raze 1 lower\"AEIOUY"; / vowels
tn:lower((Name in V)?1b) _ Name; / truncated Name
s3:{1(-1_)\x,"o-",x}lower first Name; / 3rd ssr
s:"$1, $1, bo-b$2\nBanana-fana-fo-f$2\nFee-fimo-m$2\n$1!\n\n";
(ssr/).(s;("$1";"$2";s3 0);(Name;tn;s3 1)) }
</syntaxhighlight>
===Amend a list of strings===
<syntaxhighlight lang="q">game_amend:{[Name]
pfx:Name,", ",Name,", "; / prefix
n:lower Name;
sfx:((n in "aeiouy")?1b)_n; / suffix
s:("bo-b";"Banana-fana fo-f";"Fee-fimo-m";"!";""); / song template
@[;0;pfx,] @[;3;Name,] @[;0 1 2;,[;sfx]] @[;where n[0]=last each s;-1_] s }
// test
1 "\n"sv raze game_ssr each ("Gary";"Earl";"Felix";"Stephen";"Ryan";"Jo");
</syntaxhighlight>
{{out}}
<pre>Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fimo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fimo-mearl
Earl!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fimo-melix
Felix!
Stephen, Stephen, bo-bephen
Banana-fana fo-fephen
Fee-fimo-mephen
Stephen!
Ryan, Ryan, bo-byan
Banana-fana fo-fyan
Fee-fimo-myan
Ryan!
Jo, Jo, bo-bo
Banana-fana fo-fo
Fee-fimo-mo
Jo!
</pre>
* [https://code.kx.com/q/ref/ Language Reference]
* [https://code.kx.com/q/learn/pb/name-game/ The Q Playbook: The Name Game – analysis]
=={{header|Raku}}==
Line 1,642 ⟶ 2,602:
Meh. The rules leave out some corner cases (see Steve) but what the heck, technically correct is the best kind of correct.
<syntaxhighlight lang="raku"
my $fl = $name.lc.substr(0,1);
$fl ~~ /<[aeiou]>/
Line 1,660 ⟶ 2,620:
}
say .&name-game for <Gary Earl Billy Felix Mike Steve></
{{out}}
<pre>Gary, Gary, bo-bary
Line 1,696 ⟶ 2,656:
Extra code was added to the REXX program to capitalize the name (and lowercase all characters in the name except the 1<sup>st</sup> character).
<br>Also, dual names are supported (like Mary Ann).
<
/* 20230526 Walter Pachl refurbished Gerald Schildberger's original program */
Parse Arg namelist /*obtain optional argument(s) from C.L.*/
If namelist='' Then /*Not specified?
namelist="gAry, eARL, billy, FeLix,
Do While namelist>''
namelist=space(namelist) /*elide superfluous blanks from list. */
Parse Var namelist name',' namelist /*get name (could be 2 words) from list*/
call song name /*invoke subroutine to display lyrics. */
End
Exit /*stick a fork in it, we're all Done. */
/*---------------------------------------------------------------------------------*/
song:
Parse Arg name
Parse Value 'b f m' With bb ff
lowercase='abcdefghijklmnopqrstuvwxyz' /*build 2 alphabets*/
uppercase=translate(lowercase)
name =translate(left(name,1),uppercase,lowercase)||,
translate(substr(name,2),lowercase,uppercase)
namel=translate(name,lowercase,uppercase)
Parse Var name first +1 rest
Select
When pos(first,'AEIOU')>0 Then Do
Say name',' name", bo-b"namel
Say 'Banana-fana fo-f'namel
Say 'Fee-fi-mo-m'namel
End
When pos(first,'BFM')>0 Then Do
Select
When first=='B' Then
When first=='F' Then ff=''
When first=='M' Then mm=''
End
Say name',' name', bo-'bb||rest
Say 'Banana-fana fo-'ff||rest
Say 'Fee-fi-mo-'mm||rest
End
Otherwise Do
Say name',' name', bo-b'rest
Say 'Banana-fana fo-f'rest
Say 'Fee-fi-mo-m'rest
End
End /*select*/
Say name'!'
Say ''
Return
</syntaxhighlight>
{{out|output|text= when using the default (internal) names:}}
<pre>
Line 1,758 ⟶ 2,733:
=={{header|Ruby}}==
{{works with|Ruby|2.7.1}}
More idiomatic Ruby while not being object-oriented.
Also, like the Commodore Basic version, we handle consonants at the start of the name using a Regular Expression so we can handle appropriately names like Steve or Chris. Byron is an interesting edge-case because has a "y" and also starts with "b".
<syntaxhighlight lang="ruby">#!/usr/bin/env ruby
def print_verse(name)
first_letter_and_consonants_re = /^.[^aeiyou]*/i
full_name = name.capitalize # X
suffixed = case full_name[0] # Y
when 'A','E','I','O','U'
name.downcase
else
full_name.sub(first_letter_and_consonants_re, '')
end
b_name = "b#{suffixed}"
f_name = "f#{suffixed}"
m_name = "m#{suffixed}"
case full_name[0]
when 'B'
b_name = suffixed
when 'F'
f_name = suffixed
when 'M'
m_name = suffixed
end
puts <<~END_VERSE
#{full_name}, #{full_name}, bo-#{b_name}
Banana-fana fo-#{f_name}
Fee-fi-mo-#{m_name}
#{full_name}!
END_VERSE
end
end
</syntaxhighlight>
{{out}}
<pre>Gary, Gary, bo-bary
Line 1,809 ⟶ 2,802:
Mary!
Steve, Steve, bo-
Banana-fana fo-
Fee-fi-mo-
Steve!
Chris, Chris, bo-bis
Banana-fana fo-fis
Fee-fi-mo-mis
Chris!
Byron, Byron, bo-yron
Banana-fana fo-fyron
Fee-fi-mo-myron
Byron!
</pre>
=={{header|Scala}}==
<
private def printVerse(name: String): Unit = {
val x = name.toLowerCase.capitalize
Line 1,835 ⟶ 2,840:
Stream("gAry", "earl", "Billy", "Felix", "Mary", "Steve").foreach(printVerse)
}</
See it running in your browser by [https://scastie.scala-lang.org/UilFJ0zFSJu4Qk2xaw2r4A Scastie (JVM)].
=={{header|UNIX Shell}}==
This implements the required rules and also attempts to handle names that start with consonant clusters.
<syntaxhighlight lang="sh">#!/usr/bin/env bash
namegame() {
local name=$1 b=b f=f m=m
local rhyme=${name#[^AaEeIiOoUu]}
while [[ $rhyme == [^AaEeIiOoUuYy]* ]]; do
rhyme=${rhyme#?}
done
if [[ "$rhyme" == [AEIOU]* ]]; then
rhyme=$(tr A-Z a-z <<<"$rhyme")
fi
if [[ $name == [Bb]* ]]; then
b=
fi
if [[ $name == [Ff]* ]]; then
f=
fi
if [[ $name == [Mm]* ]]; then
m=
fi
printf '%s, %s, bo-%s%s\n' "$name" "$name" "$b" "$rhyme"
printf 'Banana-fana fo-%s%s\n' "$f" "$rhyme"
printf 'Fee-fi-mo-%s%s\n' "$m" "$rhyme"
printf '%s!\n' "$name"
}
for name in Gary Earl Billy Felix Mark Frank; do
namegame "$name"
echo
done</syntaxhighlight>
{{Out}}
<pre>Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-mo-mearl
Earl!
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-mo-melix
Felix!
Mark, Mark, bo-bark
Banana-fana fo-fark
Fee-fi-mo-ark
Mark!
Frank, Frank, bo-bank
Banana-fana fo-ank
Fee-fi-mo-mank
Frank!
</pre>
=={{header|VBA}}==
<
Sub Main()
Line 1,871 ⟶ 2,943:
Next
TheGameName = t
End Function</
{{out}}
<pre>Gary, Gary, bo-bary
Line 1,910 ⟶ 2,982:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Imports System.Text
Line 1,949 ⟶ 3,021:
End Sub
End Module</
{{out}}
<pre>Gary, Gary, bo-bary
Line 1,980 ⟶ 3,052:
Fee-fi-mo-mteve
Steve!</pre>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">fn main() {
list := ['Gary', 'Earl', 'Billy', 'Felix', 'Mary']
for name in list {verse(name)}
}
fn verse(name string) {
mut b, mut f, mut m, mut y :='','','',''
mut x := name.to_lower().title()
y = x.substr(1, x.len)
if 'AEIOU'.contains(x[0].ascii_str()) {y = x.to_lower()}
b = 'b' + y
f = 'f' + y
m = 'm' + y
match x[0].ascii_str() {
'B' {b = y}
'F' {f = y}
'M' {m = y}
else {}
}
println('$x, $x, bo-$b')
println('Banana-fana fo-$f')
println('Fee-fi-mo-$m')
println('$x!\n')
}</syntaxhighlight>
{{out}}
<pre>
Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-mo-mearl
Earl!
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-mo-melix
Felix!
Mary, Mary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-ary
Mary!
</pre>
=={{header|Wren}}==
{{trans|Kotlin}}
{{libheader|Wren-str}}
<syntaxhighlight lang="wren">import "./str" for Str
var printVerse = Fn.new { |name|
var x = Str.capitalize(Str.lower(name))
var z = x[0]
var y = "AEIOU".contains(z) ? Str.lower(x) : x[1..-1]
var b = "b%(y)"
var f = "f%(y)"
var m = "m%(y)"
if (z == "B") {
b = y
} else if (z == "F") {
f = y
} else if (z == "M") {
m = y
}
System.print("%(x), %(x), bo-%(b)")
System.print("Banana-fana fo-%(f)")
System.print("Fee-fi-mo-%(m)")
System.print("%(x)!\n")
}
["Gary", "Earl", "Billy", "Felix", "Mary", "Steve"].each { |name| printVerse.call(name) }</syntaxhighlight>
{{out}}
<pre>
Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-mo-mearl
Earl!
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-mo-melix
Felix!
Mary, Mary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-ary
Mary!
Steve, Steve, bo-bteve
Banana-fana fo-fteve
Fee-fi-mo-mteve
Steve!
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">proc PrintVerse(Name);
char Name;
int I, Vowel;
proc PrintLine(Str, Let);
int Str, Let;
[Text(0, Str);
if Name(0) # Let then ChOut(0, Let!$20); \bary
if Vowel then ChOut(0, Name(0)!$20); \earl
Text(0, Name+1);
CrLf(0);
];
[Name(0):= Name(0) & ~$20; \to uppercase
I:= 1;
while Name(I) do \to lowercase
[Name(I):= Name(I) ! $20; I:= I+1];
case Name(0) of
^A,^E,^I,^O,^U: Vowel:= true
other Vowel:= false;
Text(0, Name); Text(0, ", "); Text(0, Name);
PrintLine(", bo-", ^B);
PrintLine("Banana-fana fo-", ^F);
PrintLine("Fee-fi-mo-", ^M);
Text(0, Name); Text(0, "!^m^j^m^j");
];
int Names, I;
[Names:= ["gARY", "Earl", "Billy", "Felix", "Mary", "sHIRley"];
for I:= 0 to 6-1 do PrintVerse(Names(I));
]</syntaxhighlight>
{{out}}
<pre>
Gary, Gary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-mary
Gary!
Earl, Earl, bo-bearl
Banana-fana fo-fearl
Fee-fi-mo-mearl
Earl!
Billy, Billy, bo-illy
Banana-fana fo-filly
Fee-fi-mo-milly
Billy!
Felix, Felix, bo-belix
Banana-fana fo-elix
Fee-fi-mo-melix
Felix!
Mary, Mary, bo-bary
Banana-fana fo-fary
Fee-fi-mo-ary
Mary!
Shirley, Shirley, bo-bhirley
Banana-fana fo-fhirley
Fee-fi-mo-mhirley
Shirley!
</pre>
=={{header|Z80 Assembly}}==
{{trans|MIPS Assembly}}
<syntaxhighlight lang="z80">;;;;;;;;;;;;;;;;;;; HEADER ;;;;;;;;;;;;;;;;;;;
read "\SrcCPC\winape_macros.asm"
read "\SrcCPC\MemoryMap.asm"
read "\SrcALL\winapeBuildCompat.asm"
;;;;;;;;;;;;;;;;;;; PROGRAM ;;;;;;;;;;;;;;;;;;;
org &1000
ld hl,namegame
ld de,name1
call PrintString_NameGame
ld hl,namegame
ld de,name2
call PrintString_NameGame
ld hl,namegame
ld de,name3
call PrintString_NameGame
ret ;return to basic
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintString_NameGame:
ld a,(hl)
or a ;compare to zero
ret z ;exit on null terminator
cp '?'
jr z,printNameAsIs
cp '%'
jr z,insertName
;else, just print what you see.
call &bb5a ;amstrad CPC kernel will print the contents of A as an ascii character
continue_NameGame:
inc hl
jr PrintString_NameGame
;;;;;;;;;;;;;;;; execution will never fall through this line without a jump
printNameAsIs:
ex de,hl
push hl
call PrintString
pop hl
ex de,hl
jr continue_NameGame
;;;;;;;;;;;;;;;; execution will never fall through this line without a jump
insertName:
push hl
dec hl
dec hl
dec hl
ld c,(hl) ;get the b in "bo-%", or the f in "fo-%", etc.
pop hl
ex de,hl ;swap to the name we wish to print
push hl
ld a,(hl)
cp c
jr z,dontPrintC
cp 'a'
jr z,beginsWithVowel
cp 'e'
jr z,beginsWithVowel
cp 'i'
jr z,beginsWithVowel
cp 'o'
jr z,beginsWithVowel
cp 'u'
ld a,c
call PrintChar
dontPrintC:
inc hl
call PrintString
pop hl
ex de,hl
jr continue_NameGame
beginsWithVowel:
;if name begins with vowel, we print C then the name as-is
ld a,c
call PrintChar
call PrintString ;print name as is
pop hl
ex de,hl
jr continue_NameGame
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintString:
ld a,(hl)
or a
ret z
call &BB5A
inc hl
jr PrintString
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
name1:
db "gary",0
name2:
db "earl",0
name3:
db "billy",0
namegame:
db "?, ?, bo-%",13,10
db "banana-fana fo-%",13,10
db "fee-fi-mo-%",13,10
db "?!",13,10,13,10
db 0</syntaxhighlight>
{{out}}
<pre>gary, gary, bo-bary
banana-fana fo-fary
fee-fi-mo-mary
gary!
earl, earl, bo-bearl
banana-fana fo-fearl
fee-fi-mo-mearl
earl!
billy, billy, bo-illy
banana-fana fo-filly
fee-fi-mo-milly
billy!</pre>
=={{header|zkl}}==
{{trans|Kotlin}}
<
z,x := name[0].toLower(), z.toUpper() + name[1,*].toLower();
y:=( if("aeiou".holds(z)) name.toLower() else x[1,*] );
Line 1,991 ⟶ 3,370:
println("Fee-fi-mo-",m);
println(x,"!\n");
}</
<
{{out}}
<pre style="height:35ex">
|