Old lady swallowed a fly: Difference between revisions

{{trans|Python}}

 

(‘fly’, ‘I don't know why she swallowed a fly, perhaps she'll die.’),

(‘spider’, ‘It wiggled and jiggled and tickled inside her.’),

I animal != ‘fly’

print(animals[0][1])

 

=={{header|8080 Assembly}}==

mvi c,-1 ; C = verse counter

verse: inr c

swlw1: db 'She swallowed the $'

swlw2: db ' to catch the $'

 

=={{header|Ada}}==

 

procedure Swallow_Fly is

Put_Line("There was an old lady who swallowed a horse ...");

Put_Line("She's dead, of course!");

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

STRING sw=" swallow ",swd=sw[:UPB sw-1]+"ed ", tsa=". To"+sw+"a";

vs("Cow",("I don't know how",tsa));

vs("Donkey",("It was rather wonky",tsa));

 

===Using a dictionary===

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

STRING a="WBXAY",b="WCXBY",c="WDXCY",d="WEXDY",

OD;

print(new line)

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

, ["spider", "That wriggled and jiggled and tickled inside her"]

, ["bird", "Quite absurd"]

}

 

 

=={{header|AWK}}==

# syntax: GAWK -f OLD_LADY_SWALLOWED_A_FLY.AWK

BEGIN {

exit(0)

}

 

=={{header|Babel}}==

 

(fly

("spider" "That wriggled and jiggled and tickled inside her")

("fly" " "))))

 

=={{header|Batch File}}==

setlocal enabledelayedexpansion

 

)

:done

 

=={{header|BBC BASIC}}==

This prints the lyrics from the Wikipedia page, more or less. I don't know anything about goats and donkeys and the like.

DIM swallowings$(6, 1)

swallowings$() = "fly", "+why", "spider", "That wriggled and wiggled and tickled inside her", "bird", ":How absurd", "cat", ":Fancy that", "dog", ":What a hog", "cow", "+how", "horse", "She's dead, of course"

PRINT observation$; "!"

ENDCASE

 

=={{header|Befunge}}==

We start with a collection of reusable phrases stored as a linked list. We then build up the sequence of indices into that list necessary to produce the song (this step is largely programmatic, because of the repetitive nature, although some of the verses require special case handling). Finally we iterate over the indices and print out the associated phrases.

 

>-#2:#\8#1`#:|#-1:-1\7_^#`g00:+<>\#%"O"/#::$#<3#$+g48*-v^\,+*+ 55!:*!!-"|":g+3<

>$ 36 26 58 49 81 36 26 10 \1-:#^\_^#:-1\+<00_@#:>#<$<

.|Fancy that$Dog-.|What a hog$Pig7.|Her mouth was so big%Goat=.|She just opened

her throat$Cow3.|I don't know how'Donkey6.|It was rather wonky&Horse:.|She's d

 

=={{header|C}}==

static char const *animals[] = {

"fly",

}

}

 

=={{header|C sharp|C#}}==

 

namespace OldLady

}

}

 

=={{header|C++}}==

{{trans|C#}}

 

const char *CREATURES[] = { "fly", "spider", "bird", "cat", "dog", "goat", "cow", "horse" };

 

return 0;

{{out}}

<pre>There was an old lady who swallowed a fly

There was an old lady who swallowed a horse

She's dead of course</pre>

 

=={{header|COBOL}}==

PROGRAM-ID. OLD-LADY.

 

DISPLAY LINE-OUT.

 

=={{header|Commodore BASIC}}==

 

===Commodore BASIC (No Sound)===

1 rem rosetta code

2 rem old lady who swallowed a fly

1070 data "cow","I don't know how she swallowed a cow!"

1080 data "horse","...She died, of course!"

 

===Commodore 64===

Sound must be played to the Commodore 64 SID chip through direct register access, therefore, the sound table is two-dimensional to account for the high byte and low byte of the appropriate frequencies.

1 rem rosetta code

2 rem old lady who swallowed a fly - c64

2550 for i=1 to 8:for j=1 to 3:read mu$(i,j):next j:next i

2599 return

 

===Commodore Plus/4===

BASIC 3.5 on the Commodore Plus/4 at least features the SOUND command which simplifies getting the sound processor to play notes, however, a "tuned" sound table still needs to be defined with the appropriate frequencies.

1 rem rosetta code

2 rem old lady who swallowed a fly - plus/4

2550 for i=1 to 8:for j=1 to 3:read mu$(i,j):next j:next i

2599 return

 

===Commodore 128===

BASIC 7.0 on the Commodore 128 features a robust PLAY command which will interpret strings of macro commands for commanding the SID processor. This all but eliminates the bulk of the note playing routines. Note the data statements are slightly different as the macros for note duration are different. The 128 uses '''i''', '''q''', and '''h''' for ''eighth'', ''quarter'', and ''half'' notes respectively, while the 64 and Plus/4 examples were coded to use '''8''', '''4''', and '''2''' as it was simpler to use for math operations, rather than an additional look-up table.

1 rem rosetta code

2 rem old lady who swallowed a fly - c128

2520 play "v1o4t0u5"

2599 return

 

=={{header|Common Lisp}}==

A rather iterative, rather than recursive solution. The lyrics match the original Burl Ives recording (not the later animated cartoon):

 

(defun what (verse) (first verse))

(defun remark (verse) (second verse))

(if (always v)

(format t "~a~a~%" (if (= j 0) "But " "") (remark v))))))

 

{{Out}}

 

=={{header|Cowgol}}==

 

var animals: [uint8][] := {

i := i + 1;

 

=={{header|D}}==

{{trans|C}}

 

immutable data = [

void main() {

data[0].oldLady;

 

A more structured alternative version:

 

immutable struct T {

"Perhaps she'll die.\n".writeln;

}

 

=={{header|Elena}}==

const Creatures = new string[]{"fly", "spider", "bird", "cat", "dog", "goat", "cow", "horse"};

public program()

{

{

console

if(i != 0 && i != Creatures.Length - 1)

{

{

console.printLineFormatted("She swallowed the {0} to catch the {1}",Creatures[j],Creatures[j - 1])

console.writeLine()

}

 

=={{header|Elixir}}==

{{trans|Ruby}}

@descriptions [

fly: "I don't know why S",

end

 

 

=={{header|Factor}}==

Windows users should put zlib1.dll[http://downloads.factorcode.org/dlls/] to factor folder.

 

"c%1E4%WlIU5WMphn^P`UexSD=s^-?Jk$NVE7-Gs=fQ9_`T}Y~ggi4hvMSb{SX}vpQXJ;^Yqok7%xd(0

<}rUt#FCDtKB9S`Y4jg+0PuB?Qt-&(11p?caq^S=1C`$D1fa<y6|YD*77a{4949T_-MVet;6abaEn"

 

 

=={{header|Forth}}==

swallow-addr is obviously a good candidate for an object, but Forth has many OO candidates - we won't settle that argument here.

dup c, here swap dup allot move ;

 

first @ begin dup verse cr >next dup 0= until drop

cr ." There was an old lady who swallowed a horse..."

 

=={{header|Fortran}}==

program fly

!A program to print the "Old lady swallowed a fly" poem

end program fly

 

=={{header|Free Pascal}}==

in Rosetta Code. It formats the lyrics like the Wikipedia one *)

program OldLady;

PrintSong;

end.

 

=={{header|Frege}}==

Nearly identical to the Haskell. Only the first line of the program is different.

 

 

import Data.List

song = concatMap verse $ tail $ reverse $ tails animals

 

 

=={{header|Go}}==

[https://play.golang.org/p/OV3YJSWxaJP Go Playground]

 

import "fmt"

fmt.Println(animals[0][lyric] + "\n")

}

 

=={{header|Haskell}}==

 

 

animals :: [String]

putStr $

concatMap unlines $

{{out}}<pre>There was an old lady who swallowed a fly.

I don't know why she swallowed a fly.

And a variation on this theme (a little more disaggregated):

 

import Data.Map.Strict (Map, fromList, lookup)

import Data.List (inits, intercalate)

 

comments :: Map String String

{{Out}}

<pre>There was an old lady who swallowed a fly;

=={{header|Icon}} and {{header|Unicon}}==

This version isn't as compressed as some of the others but it is very straightforward to modify. Just add a new long and terse verse entry and amend the line marked order. This uses a feature of Icon/Unicon that allows procedures to be called with a list datatype instead of an argument list, so we just pre-build argument lists for printf.

 

verse := table() # arglists for printf - [1] long asides and [2] terse joiners

end

 

Sample output omitted.

 

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/procs/printf.icn printf.icn provides printf formatting]

 

=={{header|J}}==

This defines T to be the required text.

e=:3 :'T=:T,y,LF'

E=:e@,&'.'

'Donkey'N'It was rather wonky'

O'Horse'

 

=={{header|Java}}==

{{Trans|C| via [[#D|D]]}}

 

final static String[] data = {

oldLady(data[0], false);

}

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

b64 = b"""eNrtVE1rwzAMvedXaKdeRn7ENrb21rHCzmrs1m49K9gOJv9+cko/HBcGg0LHcpOfnq2np0QL

Mz3XkPBc/TSN3yxGiqMiipHRekycK0ZwMhM8jerGC9zuZaoTho3kMKSfJjLaF8v8wLzmXMqM

zJvGew/jnZPzclA08yAkikegDTTUMfzwDXBcwoE="""

 

("fly", "I don't know why she swallowed a fly, perhaps she'll die."),

("spider", "It wiggled and jiggled and tickled inside her."),

if animal != "fly" println(animals[1][2]) end # fly lyric

println() # new line

 

=={{header|Kotlin}}==

 

val animals = listOf("fly", "spider", "bird", "cat","dog", "goat", "cow", "horse")

fun main(args: Array<String>) {

sing()

 

=={{header|Lambdatalk}}==

{def A {A.new fly spider bird cat dog goat cow horse}}

-> A

There was an old lady who swallowed a horse

She's dead of course

 

=={{header|Liberty BASIC}}==

'[RC] Old lady swallowed a fly

'http://rosettacode.org/wiki/Old_lady_swallowed_a_fly

 

end

 

=={{header|Logo}}==

; animal inc comment

[fly 2 [I don't know why she swallowed that fly]]

]

 

 

=={{header|Lua}}==

phrases = {

"",

end

io.write("I don't know why she swallowed a fly - Perhaps she'll die!\n\n")

 

=={{header|MAD}}==

INTERNAL FUNCTION(V)

VERSE WHENEVER J.LE.2, VERSE.(J-1)

 

=={{header|Maple}}==

phrases := ["I don't know why she swallowed a fly, perhaps she'll die!",

"That wriggled and wiggled and tiggled inside her.",

printf("\n");

end if;

{{out}}

<pre>

</pre>

 

"horse"};

notes = {"", "That wiggled and jiggled and tickled inside her.\n",

StringJoin @@ ("She swallowed the " <> animals[[#]] <>

" to catch the " <> animals[[# - 1]] <> ".\n" & /@

{{out}}

<pre>There was an old lady who swallowed a fly.

 

=={{header|Mercury}}==

:- interface.

:- import_module io.

 

main(!IO) :-

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|Nanoquery}}==

{{trans|Ursa}}

creatures = {"fly", "spider", "bird", "cat", "dog", "goat", "cow", "horse"}

comments = {"I don't know why she swallowed that fly.\nPerhaps she'll die\n",\

end

 

 

=={{header|Nim}}==

{{trans|Python}}

 

const b64 = """

zJvGew/jnZPzclA08yAkikegDTTUMfzwDXBcwoE="""

 

 

=={{header|OCaml}}==

===Using a dictionary===

Only one minimalist line of code (the last line):

"I know an old lady who swallowed a "; "fly"; ".\n";

"I don't know why she swallowed the fly.\nPerhaps she'll die.\n\n";

[23] ;;

 

===Using dictionary based decompression===

{{trans|D}}

Here we use the function <code ocaml>String.fold_left</code> [http://ocaml-extlib.googlecode.com/svn/doc/apiref/ExtString.String.html#VALfold_left 1] which is not available in the standard library but in the [http://code.google.com/p/ocaml-extlib/ extlib]:

"_ha _c _e _p,\nQuite absurd_f_p;_`cat,\nFancy that_fcat;_j`dog,\nWhat a hog_\

fdog;_l`pig,\nHer mouth_qso big_fpig;_d_r,\nShe just opened her throat_f_r;_i\

let _ =

===Using Logic===

[| "fly"; "spider"; "bird"; "cat"; "dog"; "pig"; "goat"; "cow"; "donkey" |]

 

for i = 0 to 8 do f i done;

p "There was an old lady who swallowed a horse...\n\

 

=={{header|Perl}}==

"fly",

"spider/That wriggled and jiggled and tickled inside her.\n",

s/:.*/--\nShe's dead, of course!\n/s;

print;

Using compression:

(Assumes a Unix-like OS and the availability of the uudecode and bunzip2 utilities).

print OUT <DATA> and

close OUT;

FeXUOI8486Wvor1zajqPDfpwnrn2jOzvo8hkOPrpVajlwnjqPfIry5c0TbKL

559fx8xqpsquRaFYV9I9fT6p7RrI/Gv/F3JFOFCQRJtf/Q==

 

=={{header|Phix}}==

{{Trans|Ada}}

 

=={{header|PHP}}==

 

$swallowed = array(

else

print "Perhaps she'll die." . "\n\n";

 

=={{header|PicoLisp}}==

{{trans|C}}

`(chop

"_ha _c _e _p,/Quite absurd_f_p;_`cat,/Fancy that_fcat;_j`dog,\

Flg )

 

 

=={{header|PowerShell}}==

$lines = @(

'fly/'

"Perhaps she'll die."

""

 

=={{header|Python}}==

 

b64 = b'''

Mz3XkPBc/TSN3yxGiqMiipHRekycK0ZwMhM8jerGC9zuZaoTho3kMKSfJjLaF8v8wLzmXMqM

zJvGew/jnZPzclA08yAkikegDTTUMfzwDXBcwoE='''

 

("fly", "I don't know why she swallowed a fly, perhaps she'll die."),

("spider", "It wiggled and jiggled and tickled inside her."),

 

for i, (animal, lyric) in enumerate(animals):

 

if animal == "horse": break

 

for (predator, _), (prey, _) in zip(animals[i:0:-1], animals[i-1::-1]):

 

 

=={{header|Racket}}==

#lang at-exp racket

 

@line{}

(loop more (cons animal seen)))])))

Alternative solution:

#lang s-exp framework/private/decode

7VK7TsQwEOz9FcM1AcncZyCoQaLey/piCyuObJ+s/D3rXHj4lIIKgaCItJkZ7cyOfM0uTZ5m

U+SaYuVXditxxdu8b338rOvEUas7GvuVa44Tcuu2/qz7CHuu6PeWwGHQ6rmiBCtz24KwWy0I

3KZdqvwDbfWhXPhY+S59RLX5dkTapF66/2/3fYMNMZklVJfAhlgjHKW2k8B7tbtRrw==

 

=={{header|Raku}}==

(formerly Perl 6)

fly => " I don't know why S—",

spider => " That wriggled and jiggled and tickled inside her.",

@history.unshift($_) if @history < 5;

@history.unshift("X to catch the $victim,");

And that's how I larned it!

 

=={{header|REXX}}==

sw= 79 /*the width of the terminal screen, -1.*/

@.=; @.1 = "I don't know why she swallowed a fly,"

say center(@.1, sw)

say center("I guess she'll die.", sw)

{{out|output|text=&nbsp; (with the lyrics being centered):}}

<pre>

 

=={{header|Ruby}}==

:fly => "I don't know why S",

:spider => "That wriggled and jiggled and tickled inside her.",

 

print "Perhaps she'll die.\n\n"

 

=={{header|Rust}}==

[https://play.rust-lang.org/?gist=294c9e29f206d7c8d8028aa5e7002d9a&version=nightly Rust Playground]

use Action::*;

 

println!("Perhaps she'll die.\n");

}

 

=={{header|Scala}}==

 

val verses = List(

println

}

{{out}}

<pre>There was an old lady who swallowed a fly,

 

=={{header|Seed7}}==

 

const array array string: verses is [] (

end if;

end for;

 

=={{header|Sidef}}==

{{trans|Raku}}

:fly: " I don't know why S—",

:spider: " That wriggled and jiggled and tickled inside her.",

history.len < 5 && history.unshift(verse);

history.unshift("X to catch the #{victim},");

 

=={{header|Tcl}}==

Because the song is highly repetitive, it compresses wonderfully.

 

puts [zlib inflate [binary decode base64 "

nCtGcDITPI3qxgvc7mWqE4aN5DCknyYy2hfL/MC85lzKjMybxnsP452T83JQNPMg

JIpHoA001DH88A0=

 

=={{header|TXR}}==

Note one detail: in the first verse we have "... don't know why she swallowed the fly". But in subsequent verses it is

"that fly" not "the fly". So we do a lookup on the fly also to substitute the appropriate line, and in the fly case we skip the original line (see the first <code>@(maybe)</code>).

("IK" "I know an old lady who swallowed a") ("SW" "She swallowed the")

("SS" "she swallowed") ("CA" "to catch the") ("XX" "Perhaps she'll die")

@(bind lastverse

("IK C"

"SW C CA G"

"SW G CA D"

"But I don't know why SS that F"

"XX"

("G: Opened her throat and down went the G!"

"D: What a hog to swallow a D!"

"R: How absurd to swallow a R!"

"F: But I don't know why SS the F"))

@(define expand_backwards (song lengthened_song done))

@song

@ (end)

 

=={{header|UNIX Shell}}==

{{works_with|Bash}}

comments=("I don't know why she swallowed that fly"

"That wriggled and jiggled and tickled inside her"

echo

fi

 

=={{header|Ursa}}==

{{trans|C#}}

append "She swallowed the " " to catch the " reason

append "fly" "spider" "bird" "cat" "dog" "goat" "cow" "horse" creatures

end for

end for

 

=={{header|Wren}}==

{{trans|Kotlin}}

 

var phrases = [

}

 

 

=={{header|zkl}}==

{{trans|Tcl}}

Uncompresses the base64 encoded gziped text of the song. Uses shared libraries zlib and msg hashing for the codecs.

text:=

"eJztlE1uwyAQhdflFOOVNyhXyLap1FV7AWKIoaFMBFjIt++M7YVpLfVHilQp2cHMg3l8T+IA"

 

MsgHash.base64decode(text) :

{{out}}

<pre>