99 bottles of beer: Difference between revisions

 

<blockquote>

</blockquote>

 

 

 

As with any puzzle, try to do it in as creative/concise/comical a way

 

 

 

 

=={{header|0815}}==

See [[99 Bottles of Beer/EsoLang]]

 

=={{header|360 Assembly}}==

 

=={{header|6800 Assembly}}==

See [[99 Bottles of Beer/Assembly]]

 

=={{header|8th}}==

\ 99 bottles of beer on the wall:

: allout "no more bottles" ;

 

' beers 1 99 loop- bye

 

=={{header|ABAP}}==

 

DATA lv_no_bottles(2) TYPE n VALUE 99.

WRITE ' bottles of beer on the wall'.

WRITE /.

 

or (With ABAP 7.40)

 

 

DATA it_99_bottles TYPE TABLE OF string WITH EMPTY KEY.

cl_demo_output=>write( it_99_bottles ).

cl_demo_output=>display( ).

 

=={{header|ACL2}}==

See [[99 Bottles of Beer/Lisp]]

 

=={{header|ActionScript}}==

{

trace(numBottles, " bottles of beer on the wall");

trace("Take one down, pass it around");

trace(numBottles - 1, " bottles of beer on the wall\n");

 

=={{header|Ada}}==

===Simple version===

procedure Bottles is

New_Line;

end loop;

===Concurrent version===

with 1 task to print out the information and 99 tasks to specify the number of bottles

 

procedure Tasking_99_Bottles is

Task_List(I) := new Counter(I);

end loop;

 

=={{header|Aime}}==

 

bottles = 99;

o_("Take one down, pass it around\n");

o_(bottles -= 1, " bottles of beer on the wall\n\n");

 

=={{header|Algae}}==

# 99 Bottles of Beer on the Wall

# in Algae

}

}

 

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

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

<!-- {{not works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - printf has been removed}} -->

FOR bottles FROM 99 TO 1 BY -1 DO

printf(($z-d" bottles of beer on the wall"l$, bottles));

printf(($z-d" bottles of beer on the wall"ll$, bottles-1))

OD

 

=={{header|ALGOL-M}}==

BEGIN

 

 

END

 

=={{header|AmigaE}}==

DEF t: PTR TO CHAR,

s: PTR TO CHAR,

IF i > 0 THEN WriteF(t)

ENDFOR

 

=={{header|Apache Ant}}==

Implementation in Apache Ant, due to the limitations of Ant, this requires ant-contrib for arithmetic operations and a dummy target to keep Ant from detecting the loop.

<project name="n bottles" default="99_bottles">

 

</target>

 

 

=={{header|Apex}}==

for(Integer i = 99; i=0; i--){

system.debug(i + ' bottles of beer on the wall');

system.debug('take one down, pass it around');

}

 

=={{header|APL}}==

{{works with|Dyalog APL}}

 

{{trans|J}}

bobw ← {(bob ⍵) , ' on the wall'}

beer ← { (bobw ⍵) , ', ', (bob ⍵) , '; take one down and pass it around, ', bobw ⍵-1}

 

=={{header|App Inventor}}==

===Iteration===

 

set bottles to "bottles"

if beerCount < 99 then

log "Take one down, pass it around"

end

 

 

===Declaration===

on run

set localisations to ¬

on unwords(xs)

intercalate(space, xs)

 

=={{header|Arbre}}==

bottle(x):

template: '

bottles(99) -> io

 

 

=={{header|Argile}}==

 

let X be an int

.:on the wall:. -> text {

X>17 ? "on the wall", (X>1 ? "on the bwall", "in the buttle")

 

=={{header|ARM Assembly}}==

=={{header|ArnoldC}}==

As ArnoldC does not feature string concatenation, the numbers of bottles and the rest of the parts of the lyrics are printed on separate lines.

HEY CHRISTMAS TREE is0

YOU SET US UP @NO PROBLEMO

ENOUGH TALK

CHILL

 

=={{header|Astro}}==

(0) => "No more bottles"

(1) => "1 bottle"

Take one down, pass it around

{bottles n-1} of beer on the wall\n

 

=={{header|ATS}}==

#include

"share/atspre_staload.hats"

(* ****** ****** *)

 

 

=={{header|AutoHotkey}}==

For example, just a sixpack:

 

 

function bb(n) {

}

print "Go to the store and buy some more!"

 

{{out}}

Pauses are added to accommodate the small calculator screen so all of the text can be read.

 

While B

Disp B▶Dec," BOTTLES OF","BEER ON THE WALL"

Disp B▶Dec," BOTTLES OF","BEER ON THE WALL",i

getKeyʳ

 

=={{header|Babel}}==

 

{b " bottles of beer" <

< }

 

 

=={{header|BASIC}}==

==={{header|BaCon}}===

See [[99 Bottles of Beer/Basic#BaCon]]

 

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

See [[99 Bottles of Beer/Basic#Commodore_BASIC]]

 

==={{header|FBSL}}===

 

==={{header|FUZE BASIC}}===

See [[99 Bottles of Beer/Basic]]

 

 

==={{header|Microsoft Small Basic}}===

See [[99 Bottles of Beer/Basic]]

 

 

==={{header|PureBasic}}===

See [[99 Bottles of Beer/Basic]]

 

 

==={{header|Run BASIC}}===

See [[99 Bottles of Beer/Basic]]

 

 

==={{header|TI-89 BASIC}}===

See [[99 Bottles of Beer/Basic]]

 

 

==={{header|Visual Basic .NET}}===

See [[99 Bottles of Beer/Basic]]

 

 

<!--- works with C syntax highlighting --->

const bottle = " bottle"

const plural = "s"

 

// vim: set syntax=c ts=4 sw=4 et:

 

=={{header|Bc}}==

{{works with|GNU bc|1.06}}

 

while ( 1 ) {

print i , " bottles of beer on the wall\n";

print i , " bottle of beer on the wall\n";

print i , " bottle of beer\nTake it down, pass it around\nno more bottles of beer on the wall\n";

 

=={{header|beeswax}}==

Straightforward implementation, displaying the full lyrics given on [ http://99-bottles-of-beer.net/ ]

 

> NN p

> d#_8~2~(P~3~.~1~>{` bottles of beer on the wall, `{` bottles of beer.`q

>N`No more bottles of beer on the wall, no more bottles of beer.`N q

;`.llaw eht no reeb fo selttob 99 ,erom emos yub dna erots eht ot oG`<

 

A much more “economic” version that tries to avoid repetition at the price of complicated conditional jumps and self-modifying code that takes up more place than the actual strings themselves.

Output is the same as in the straightforward version.

 

#D@.9~2~@M.7~P9zE `N`p

DMM@.9@.~2~.++~5zE `n`>`o`p

>^^^^^^^^^; .# b XgNN < bM` ,dnuora ti ssap`<

d^^^^^^^^^^^^^^^^X~3~P(~2~8` ,erom emos yub dna erots eht ot`` oG`<

 

=={{header|Befunge}}==

See [[99 Bottles of Beer/EsoLang]]

 

=={{header|BlooP}}==

Output is always in caps in the interpreter I use, but I typed the input in correct case to spare those whose interpreter might do lowercase and don't want to have this song shouted at them ;D.

DEFINE PROCEDURE ''MINUS'' [A,B]:

BLOCK 0: BEGIN

 

BOTTLES[99];

 

=={{header|Bracmat}}==

 

Code to save to BottlesOfBeer.bra:

 

See http://99-bottles-of-beer.net/}

 

new'X;

 

=={{header|Brainf***}}==

 

=={{header|Brat}}==

p "#{n} bottles of beer on the wall, #{n} bottles of beer!"

p "Take one down, pass it around, #{n - 1} bottle#{true? n > 2 's' ''} of beer on the wall."

 

p "One bottle of beer on the wall, one bottle of beer!"

 

=={{header|C}}==

{{trans|C++}}

=== The simple solution ===

* 99 Bottles, C, KISS (i.e. keep it simple and straightforward) version

*/

 

return 0;

 

=== A recursive solution ===

 

int main(int argc, char *argv[])

printf("%d bottle%c of beer on the wall\n\n", argc - 1, (argc - 1) == 1?'\0': 's');

return argc - 1;

 

=== Code golf ===

main(){_=100;while(--_)printf("%i bottle%s of beer in the wall,\n%i bottle%"

"s of beer.\nTake one down, pass it round,\n%s%s\n\n",_,_-1?"s":"",_,_-1?"s"

:"",_-1?(char[]){(_-1)/10?(_-1)/10+48:(_-1)%10+48,(_-1)/10?(_-1)%10+48:2+30,

 

=== A preprocessor solution ===

Well, with the preprocessor, that's indeed possible:

 

#include <stdio.h>

 

(void) printf(SONG);

return EXIT_SUCCESS;

 

An inspection of the generated executable proves that it indeed contains the complete text of the song in one block.

 

===The bottled version===

#include<stdio.h>

char *d[16],y[]

'S',!(++u % 3) * 32+ 78) or

('.', puts("."))}return c;}

 

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

 

class Program

}

}

 

=== C#6 Implementation ===

{{works with|C sharp|C#|6+}}

class Program

{

Console.WriteLine($"{f(i, true)}{f(i, false)}Take one down, pass it around\r\n{f(i - 1, true)}");

}

 

=== Linq Implementation ===

 

using System.Linq;

 

static void Main()

{

}

 

=== Flexible Version ===

using System.Globalization;

class Program

}

}

 

=== Using Formatting ===

{{works with|C sharp|C#|3+}}

 

{

static void Main(string[] args)

}

}

 

{{out}}

{{works with|C sharp|C#|3+}}

 

using System.Linq;

 

yield return String.Format(f, booze(i, true), booze(i, false), booze(i - 1, true));

}

 

=== A Fun One ===

"Abita Amber",

"Adams Broadside Ale",

Console.WriteLine();

Console.ReadLine();

 

=== Using recursion ===

{

if (numberOfBottles > 0)

BottlesSong(--numberOfBottles);

}

 

=== Using a While Loop ===

{

int numBottles = 99;

WriteLine("No more bottles of beer on the wall, no more bottles of beer.");

WriteLine("Go to the store to buy some more, 99 bottles of beer on the wall...");

 

=={{header|Ceylon}}==

String bottles(Integer count) =>

``bottles(i - 1)`` of beer on the wall!\n");

}

 

=={{header|Chapel}}==

copied from http://99-bottles-of-beer.net/language-chapel-1215.html, with minor modifications for chapel 1.7

{{works with|Chapel|1.7.0}}

/***********************************************************************

* Chapel implementation of "99 bottles of beer"

else "Take one down and pass it around, ";

}

 

=={{header|Chef}}==

See [[99 Bottles of Beer/EsoLang]]

 

=={{header|Cind}}==

 

execute() {

 

return 0;

}

 

=={{header|CLIPS}}==

 

(bottles 99))

 

(printout t "Take one down, pass it around," crlf)

(printout t (bottle-count (- ?count 1)) " on the wall." crlf crlf)

 

=={{header|Clojure}}==

(str num " bottles of beer on the wall\n"

num " bottles of beer\n"

 

 

 

Or, using cl-format:

{{trans|Common Lisp}}

true

"~{~[~^~]~:*~D bottle~:P of beer on the wall~%~:*~D bottle~:P of beer

Take one down, pass it around,~%~D bottle~:P~:* of beer on the wall.~2%~}"

 

=={{header|COBOL}}==

{{works with|OpenCOBOL|1.1}}

Free form version.

program-id. ninety-nine.

environment division.

 

100-end.

 

Another free-form version, without using <code>DISPLAY NO ADVANCING</code>.

program-id. ninety-nine.

environment division.

100-end.

 

A more concise version that adheres to the minimum guidelines. Leading zeros are not suppressed. (OpenCOBOL - 1.1.0)

data division.

working-storage section.

add 1 to cnt

display space

 

=={{header|CoffeeScript}}==

bottlesOfBeer = (n) ->

"#{n} bottle#{if n is 1 then '' else 's'} of beer"

#{bottlesOfBeer n - 1} on the wall

\n""" for n in [99..1]

 

With completely different approach...

 

x=''

x += [j,j-1,'\nTake one down, pass it around\n'," bottles of beer",' on the wall\n'][i] for i in [0,3,4,0,3,2,1,3,4]

console.log x.replace /(1.+)s/g, '$1'

 

or as a one liner...

 

 

or another completely different one liner

 

 

=={{header|ColdFusion}}==

=== Classic tag based CFML ===

<cfloop index="x" from="99" to="0" step="-1">

<cfset plur = iif(x is 1,"",DE("s"))>

#iif(x is 1,DE("No more"),"x-1")# bottle#iif(x is 2,"",DE("s"))# of beer on the wall<br><br>

</cfloop>

or if you prefer: (identical output, grammatically correct to the last stanza)

 

=== CFScript ===

for (x=99; x gte 1; x--) {

plur = iif(x==1,'',DE('s'));

WriteOutput("#x# bottle#plur# of beer on the wall<br>#x# bottle#plur# of beer<br>Take one down, pass it around<br>#iif(x is 1,DE('No more'),'x-1')# bottle#iif(x is 2,'',DE('s'))# of beer on the wall<br><br>");

}

 

=={{header|Comefrom0x10}}==

 

remaining = 99

one_less_bottle = remaining

 

comefrom if one_less_bottle is 0

 

{{out}}

=={{header|Component Pascal}}==

See [[99 Bottles of Beer/Pascal]]

 

=={{header|Crystal}}==

puts "#{n} bottle#{n > 1 ? "s" : ""} of beer on the wall"

puts "#{n} bottle#{n > 1 ? "s" : ""} of beer"

end

puts "No more bottles of beer on the wall"

 

=={{header|D}}==

 

Based on Steward Gordon's code at: [http://99-bottles-of-beer.net/language-d-721.html 99-bottles-of-beer.net].

 

void main() {

writeln("Go to the store and buy some more,");

writeln("99 bottles of beer on the wall.");

 

=== CTFE Solution ===

CTFE (Compile-Time Function Execution) is a feature of D that allows for pure functions of arbitrary complexity to be completely evaluated at compile time when every parameter is known. Note that this is distinct from the template meta-programming tricks used by some other languages, and this bottles() function could just as easily be executed during run-time. The compiled result of this program simply prints the pre-generated lyrics to the song, using a standard compiler pragma directive.

 

 

string bottles(in size_t num) pure {

 

pragma(msg, 99.bottles);

 

=== Template Meta-Programming Solution ===

Uses D template meta-programming and recursion to pre-generate the song lyrics and prints it at compile via pragma(msg,...)

 

module bottles;

 

 

void main(){}

 

=={{header|Dart}}==

}

 

=={{header|Dc}}==

{{works with|GNU dc}}

{{works with|OpenBSD dc}}

dnrpr

dnlBP

]P

[no more bottles of beer on the wall

 

Similar to the program above, but without 'n' and 'r' commands. It prints the numbers on separate lines than the strings.

 

{{works with|AT&T dc}}

plAP

plBP

]P

[no more bottles of beer on the wall

 

=={{header|Delphi}}==

See [[99 Bottles of Beer/Pascal]]

 

=={{header|Déjà Vu}}==

if = 1 i "" "s"

 

!print "Go to the store and buy some more, 99 bottles of beer on the wall."

 

 

 

 

=={{header|E}}==

return switch (n) {

match ==0 { "No bottles" }

${bottles(n.previous())} of beer on the wall.

`)

 

=={{header|ECL}}==

Layout := RECORD

UNSIGNED1 RecID1;

Rev := NORMALIZE(Beers,5,XF(LEFT,COUNTER));

OUTPUT(SORT(Rev,-Recid1,-RecID2),{txt},ALL);

 

=={{header|Egel}}==

import "prelude.eg"

import "io.ego"

 

def main = print_rhyme 99

 

=={{header|EGL}}==

function main()

end

end

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

 

An alternative version written using the across-loop construct.

output_lyrics

-- Output the lyrics to 99-bottles-of-beer.

end

 

 

=={{header|Ela}}==

 

beer 1 = "1 bottle of beer on the wall\n1 bottle of beer\nTake one down, pass it around"

++" bottles of beer\nTake one down, pass it around\n"

 

=={{header|Elena}}==

import extensions;

import extensions'routines;

= self.toPrintable() + (self != 1).iif(" bottles"," bottle");

{

^ new Enumerator

bool next() = n > 0;

.printLine(n.bottleDescription()," of beer on the wall")

.printLine(n.bottleDescription()," of beer")

.printLine("Take one down, pass it around")

reset() {}

}

};

var bottles := 99;

{{out}}

<pre>

0 bottles of beer on the wall

</pre>

 

=={{header|Elixir}}==

def run do

Enum.each 99..1, fn idx ->

end

 

 

=={{header|Erlang}}==

-export([sing/0]).

-define(TEMPLATE_0, "~s of beer on the wall, ~s of beer.~nGo to the store and buy some more, 99

spawn_singer(Bottle),

sing_verse(Bottle)

 

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

bottles = "bottles",

bottle = "bottle"

for a = 99 to 1 by -1 do

beers (a)

 

 

include std/console.e

howmany[(beer>2)+3]

})

 

 

=={{header|Extended BrainF***}}==

 

=={{header|F_Sharp|F#}}==

let rec bottles n =

let (before, after) = match n with

printfn "%d %s of beer on the wall\n" (n - 1) after

if n > 1 then

 

=={{header|Factor}}==

 

: bottle ( -- quot )

1 [a,b] bottle each last-verse ;

 

 

=={{header|Falcon}}==

> i, " bottles of beer on the wall"

> i, " bottles of beer"

> "Take one down, pass it around"

> i-1, " bottles of beer on the wall\n"

 

A more robust version to handle plural/not plural conditions

plural = (i != 1) ? 's' : ""

> @ "$i bottle$plural of beer on the wall"

> "Take one down, pass it around"

> i-1, @ " bottle$plural of beer on the wall\n"

 

=={{header|FALSE}}==

See [[99 Bottles of Beer/EsoLang]]

 

=={{header|ferite}}==

copied from [http://99-bottles-of-beer.net/language-ferite-1281.html?PHPSESSID=b563ec9a2791f6c3cc917c22b17dc542 99-bottles-of-beer.net].

 

 

number bottles = 99;

looping = counter.invoke();

 

=={{header|Fexl}}==

\suffix=(\n eq n 1 "" "s")

\sing_count=(\n put [n " bottle" (suffix n) " of beer"])

)

sing 3

 

{{out}}

 

</pre>

 

=={{header|Forth}}==

:noname ." 1 bottle" ;

:noname ." no more bottles" ;

: verses begin cr .verse ?dup 0= until ;

 

 

Version 2: create a beer language and write the program

: BOTTLES ( n -- )

DUP

ONELESS BOTTLES OF BEER ON THE WALL .

ANOTHER

 

Forth Console Output

2 bottles of beer on the wall,

2 bottles of beer ,

No more bottles of beer on the wall.

 

 

=={{header|Fortran}}==

===F90 version===

 

implicit none

end do

 

 

===MPI version===

 

implicit none

call mpi_finalize(ierr)

 

 

Usage:

===Fortran 2003/2008 OOP version===

Works with GNU gfortran 5.0.0 and Intel ifort 15.0.2

module song_typedefs

implicit none

 

end program bottles_song

 

=={{header|Frege}}==

{{Works with|Frege|3.21.586-g026e8d7}}

 

 

main = mapM_ (putStrLn . beer) [99, 98 .. 0]

++ show v

++ " bottles of beer\nTake one down, pass it around\n"

 

=={{header|friendly interactive shell}}==

=={{header|Frink}}==

Frink tracks units of measure through all calculations. It has a large library of built-in units of measure, including volume. The following program prints out the remaining volume of beer (assuming we start with 99 bottles of beer, each containing 12 fluid ounces) in different random units of volume, never repeating a unit.

units = array[units[volume]]

showApproximations[false]

 

getBottleString[n, unit] := format[n*12 floz, unit, 6] + "s"

 

Sample randomized output:

 

=={{header|FunL}}==

numbers = {1:'one', 2:'two', 3:'three', 4:'four', 5:'five', 6:'six', 7:'seven',

8:'eight', 9:'nine', 10:'ten', 11:'eleven', 12:'twelve'}

+ ' of beer on the wall.\n')

 

 

=={{header|FutureBasic}}==

 

 

for i = 99 to 1 step -1

next

 

 

=={{header|GAP}}==

local line, i, j, u;

line := function(n)

fi;

od;

 

=={{header|Genie}}==

def plural(n:uint):string

return (n == 1) ? "" : "s"

--bottles

print "%s bottle%s of beer on the wall\n", no(bottles), plural(bottles)

 

{{out}}

 

=={{header|gnuplot}}==

print sprintf("%i bottles of beer on the wall", bottles)

print sprintf("%i bottles of beer", bottles)

print sprintf("%i bottles of beer on the wall", bottles)

print ""

 

=={{header|Go}}==

===No sense of humor===

 

import "fmt"

fmt.Printf("%s of beer on the wall\n", bottles(i-1))

}

 

===Typoglycemic===

With code from RC tasks Number names, Knuth shuffle.

 

import (

w := strings.Fields(p[:1] + string(a) + p[len(p)-1:])

return strings.Join(w, " ")

{{out}}

Things start out pretty well...

=={{header|Go!}}==

Copied from [http://99-bottles-of-beer.net/language-go!-289.html The 99 Bottles of Beer web site] with a minor bug fix.

-- 99 Bottles of Beer in Go!

-- John Knottenbelt

bottles(1) => "1 bottle of beer".

bottles(i) => i^0 <> " bottles of beer".

 

=={{header|Golo}}==

 

augment java.lang.Integer {

println("--------------------------------------")

})

 

=={{header|Gosu}}==

for (i in 99..0) {

 

 

}

 

=={{header|Groovy}}==

===Basic Solution===

With a closure to handle special cardinalities of bottles.

 

99.downto(1) { i ->

${bottles(i-1)} of beer on the wall

"""

 

=== Single Print Version ===

Uses a single print algorithm for all four lines. Handles cardinality on bottles, uses 'No more' instead of 0.

def (m,d) = [it%3,(int)it/3]

print "${m==1?'\n':''}${d?:'No more'} bottle${d!=1?'s':''} of beer" +

"${m?' on the wall':'\nTake one down, pass it around'}\n"

 

===Bottomless Beer Solution===

Using more closures to create a richer lyrical experience.

 

def initialState = {

}

// Thread.sleep(1000)

 

=={{header|GUISS}}==

We will just use the calculator and keep taking one off. We do not get the full text here, but the number of the calculator shows how many bottles we still have left to drink:

 

Button:[hyphen],Button:1,Button:[equals],Button:[hyphen],Button:1,Button:[equals],

Button:[hyphen],Button:1,Button:[equals],Button:[hyphen],Button:1,Button:[equals],

Button:[hyphen],Button:1,Button:[equals],Button:[hyphen],Button:1,Button:[equals],

Button:[hyphen],Button:1,Button:[equals],Button:[hyphen],Button:1,Button:[equals]

We haven't drank all of the bottles at this point, but we can keep going, if we want.

 

=={{header|Halon}}==

$x = 99;

while ($x > 0) {

else

echo "No more bottles of beer on the wall!";

 

=={{header|Haskell}}==

A relatively concise solution:

 

beer 1 = "1 bottle of beer on the wall\n1 bottle of beer\nTake one down, pass it around"

beer 0 = "better go to the store and buy some more."

++ show v

++" bottles of beer\nTake one down, pass it around\n"

====List comprehension====

As a list comprehension:

 

 

main = putStr $ concat

num n = show n

s 1 = ""

 

====Writer monad and Template Haskell====

Another version, which uses a Writer monad to collect each part of the song. It also uses Template Haskell to generate the song at compile time.

 

-- build with "ghc --make beer.hs"

module Main where

in return $ LitE $ StringL $ song)

 

 

====Avoiding append by spelling bottle backwards====

Is there something just a little prickly and displeasing about (++) ?

Monoid (<>) is less spiky, but neither is needed when 'bottle' is written backwards.

[location, distribution, solution] =

]

 

asset :: Int -> String

| 1 == n = []

| otherwise = ['s']

 

main :: IO ()

 

=={{header|Haxe}}==

=== Simple solution ===

{

static public function main()

}

}

 

=== Macro solution ===

Let's generate that print with macro.

 

 

static public function main () : Void {

}

 

 

=={{header|hexiscript}}==

let bottle " bottles of "

if amount = 0; let amount "No more"

println take "one" "down" + pass "it" "around"

println bottles (--amount) "beer" "on the wall\n"

 

=={{header|HicEst}}==

WRITE() x , "bottles of beer on the wall"

BEEP("T16 be be be bH bH bH be be be 2be ")

WRITE() x , "bottles of beer on the wall"

BEEP("2p #A #A #A c c d #d #d #d 2#d 2p")

 

The default is 99 bottles, but it can be modified by the parameter.

 

// This is made I64 rather than U64

// Because, a U64 would overflow

// Calls the function, which goes to the default parameters

BottlesOfBeer;

 

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

The default is 99 bottles, but you can change this on the command line for

really long trips...

numBeers := integer(args[1]) | 99

drinkUp(numBeers)

write("Go to the store and buy some more, ",

beerMax," bottles of beer on the wall.")

 

=={{header|IDL}}==

 

for i=1,99 do begin

End

 

 

Since in IDL "FOR"-loops are the embodiment of pure evil (see http://www.idlcoyote.com/tips/forloops.html and http://www.idlcoyote.com/tips/forloops2.html) there is also a loop free IDL way:

 

b=(reverse(shift(sindgen(100),-1)))[1:99]

b2=reverse(sindgen(99))

takeT=replicate('Take one down, pass it around,', 100)

print, b+wallT+string(10B)+b+wallT2+string(10B)+takeT+string(10B)+b2+wallT+string(10B)

 

I found the above example very helpful but overdone. This is a more simple version:

 

n_bottles=99

b1 = reverse(SINDGEN(n_bottles,START=1))

takeT=replicate('Take one down, pass it around,', n_bottles)

print, b1+wallT+string(10B)+b1+wallT2+string(10B)+takeT+string(10B)+b2+wallT+string(10B)

 

=={{header|Idris}}==

beerSong : Fin 100 -> String

beerSong x = verses x where

verses fZ = ""

verses (fS n) = (verse (fS n)) ++ (verses n)

 

=={{header|Inform 6}}==

if(i == 1) return "bottle";

 

Beer(99);

];

 

=={{header|Inform 7}}==

=== Programmatic solution ===

 

When play begins:

say "Take one down, pass it around[line break]";

say "[N - 1] bottle[s] of beer on the wall[paragraph break]";

 

=== World model solution ===

This solution uses in-game objects to represent the wall and the bottles.

 

 

The plural of bottle of beer is bottles of beer. A bottle of beer is a kind of thing.

To say what's on the wall:

if more than one thing is on the wall, say list of things on the wall;

 

=={{header|Io}}==

if(i==0, return "no more bottles of beer")

if(i==1, return "1 bottle of beer")

bottles(i - 1), " on the wall.\n\n"

)

 

=={{header|Ioke}}==

case(i,

0, "no more bottles of beer",

"take one down, pass it around," println

"#{bottle(i - 1)} on the wall.\n" println

 

=={{header|J}}==

As posted at the [http://www.jsoftware.com/jwiki/Essays/99_Bottles_of_Beer J wiki]

bobw=: bob , ' on the wall'"_

beer=: bobw , ', ' , bob , '; take one down and pass it around, ' , bobw@<:

 

{{Out}}

2 bottles of beer on the wall, 2 bottles of beer; take one down and pass it around, 1 bottle of beer on the wall

1 bottle of beer on the wall, 1 bottle of beer; take one down and pass it around, 0 bottles of beer on the wall </pre>

 

=={{header|Java}}==

===Console===

MessageFormat's choice operator is used to properly format plurals.

 

public class Beer {

}

}

 

'''Optimized for speed and few I/O operations'''

public static void main(String[] args) {

int bottles = 99;

System.out.println(sb.append(verse3));

}

 

'''Recursive'''

public static void main(String args[]) {

song(99);

}

}

 

=== An object-oriented solution ===

{{libheader|AWT}}

This version requires user interaction. The first two lines are shown in a text area on a window. The third line is shown on a button which you need to click to see the fourth line in a message box. The numbers update and the process repeats until "0 bottles of beer on the wall" is shown in a message box, when the program ends.

import java.awt.event.ActionEvent;

import javax.swing.JButton;

}

}

 

=={{header|JavaScript}}==

===ES3-5===

while (beer > 0) {

var verse = [

beer--;

}

 

===ES6===

while (beer > 0) {

let verse = `${beer} bottles of beer on the wall,

console.log(verse);

beer--;

 

===Functional / Recursive===

var songTemplate = "{X} bottles of beer on the wall \n" +

"{X} bottles of beer \n"+

}

 

 

===Other Examples===

 

Comment: This being a "one-liner" is arguable. The author has chosen not to put a line break after the declaration of the <code>beer</code> variable. By using the authors definition, most of the other solutions could pass as a "one-liner".

 

 

Legitimate "one-liner" with grammar check, using declarative methods.

 

 

Object Oriented

this.count = count || 99;

}

 

var bar = new Bottles(99);

 

An alternative version:

 

if (!isFinite(Number(n)) || n == 0) n = 100;

var a = '%% bottles of beer',

}

 

 

=={{header|Joy}}==

 

 

HIDE

sing-verse == dup3 bottles beer wall comma

bottles beer ".\n" putchars

sing-verse-0 == "No more bottles of beer on the wall, no more bottles of beer\n" putchars

"Go to the store and buy some more, " putchars

 

IN

sing-verses == [null]

[sing-verse-0]

 

=={{header|jq}}==

'''Minimalist:'''

| (. - range(0;.+1) )

| "

\(.) bottles of beer