99 bottles of beer: Difference between revisions

{{trans|Python}}

 

print(i‘ bottles of beer on the wall’)

print(i‘ bottles of beer’)

 

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

\ 99 bottles of beer on the wall:

: allout "no more bottles" ;

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program bootleBeer64.s */

</syntaxhighlight>

=={{header|ABAP}}==

 

DATA lv_no_bottles(2) TYPE n VALUE 99.

or (With ABAP 7.40)

 

 

DATA it_99_bottles TYPE TABLE OF string WITH EMPTY KEY.

 

=={{header|Action!}}==

IF i=0 THEN

Print("No more")

 

=={{header|ActionScript}}==

{

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

=={{header|Ada}}==

===Simple version===

procedure Bottles is

===Concurrent version===

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

 

procedure Tasking_99_Bottles is

 

=={{header|Aime}}==

 

bottles = 99;

 

=={{header|Algae}}==

# 99 Bottles of Beer on the Wall

# in Algae

 

=={{header|ALGOL 60}}==

integer n;

 

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

 

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

BEGIN

 

 

=={{header|AmigaE}}==

DEF t: PTR TO CHAR,

s: PTR TO CHAR,

=={{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">

 

 

=={{header|Apex}}==

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

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

===Iteration===

 

set bottles to "bottles"

if beerCount < 99 then

 

===Declaration===

on run

set localisations to ¬

 

=={{header|Arbre}}==

bottle(x):

template: '

 

=={{header|Argile}}==

 

let X be an int

=={{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

=={{header|Arturo}}==

 

 

loop 99..1 'i [

 

=={{header|AsciiDots}}==

/>*$_#-$_" bottles of beer on the wall, "-$_#-$" bottles of beer."\

|[-]1#-----" ,dnuora ti ssap dna nwod eno ekaT"_$-----------------/

 

=={{header|Astro}}==

(0) => "No more bottles"

(1) => "1 bottle"

 

=={{header|Asymptote}}==

// by Jjuanhdez, 05/2022

 

 

=={{header|ATS}}==

#include

"share/atspre_staload.hats"

For example, just a sixpack:

 

 

function bb(n) {

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"

 

=={{header|Babel}}==

 

{b " bottles of beer" <

 

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

const bottle = " bottle"

const plural = "s"

{{works with|GNU bc|1.06}}

 

while ( 1 ) {

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

 

=={{header|BCPL}}==

 

let number(n) be

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

Output is the same as in the straightforward version.

 

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

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

 

=={{header|BlitzMax}}==

 

repeat

=={{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

 

Code to save to BottlesOfBeer.bra:

 

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

 

=={{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."

 

=={{header|BQN}}==

{𝕨∾(@+10)∾𝕩}´{(•Fmt 𝕨)∾" "∾𝕩}´¨∾{

⟨

{{trans|C++}}

=== The simple solution ===

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

*/

 

=== A recursive solution ===

 

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

 

=== 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"

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

 

#include <stdio.h>

 

 

===The bottled version===

#include<stdio.h>

char *d[16],y[]

 

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

 

class Program

=== C#6 Implementation ===

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

class Program

{

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

 

using System.Linq;

 

 

=== Flexible Version ===

using System.Globalization;

class Program

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

 

{

static void Main(string[] args)

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

 

using System.Linq;

 

 

=== A Fun One ===

"Abita Amber",

"Adams Broadside Ale",

 

=== Using recursion ===

{

if (numberOfBottles > 0)

 

=== Using a While Loop ===

{

int numBottles = 99;

=== The simple solution ===

{{works with|g++|4.8.1}}

using std::cout;

 

Of course, the output of the program always looks the same. One may therefore question why the program has to do all that tedious subtracting during runtime. Couldn't the compiler just generate the code to output the text, with ready-calculated constants? Indeed, it can, and the technique is called template metaprogramming. The following short code gives the text without containing a single variable, let alone a loop:

 

 

template<int max, int min> struct bottle_countdown

=== A function template solution ===

Function templates are a different approach to template metaprogramming:

 

template<unsigned int N> void bottles(){

 

=== A Recursive solution ===

using namespace std;

void rec(int bottles)

Of course, with the template metaprogramming solution, the program has still do the conversion of numbers to strings at runtime, and those function calls also cost unnecessary time. Couldn't we just compose the complete text at compile time, and just output it at run time? Well, with the preprocessor, that's indeed possible:

 

#include <ostream>

 

=== Bottled Version ===

 

//Beer Song>,_

#include <iostream>

 

=={{header|Ceylon}}==

String bottles(Integer count) =>

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"

=={{header|Cind}}==

 

execute() {

 

=={{header|Clay}}==

 

numeric type; but here I just let it go -- that way it'll work with anything

that compares with 1 and that printTo knows how to convert to a string. And

 

=={{header|Clio}}==

n -> if = 0: 'no more bottles'

elif = 1: n + ' bottle'

=={{header|CLIPS}}==

 

(bottles 99))

 

 

=={{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

 

=={{header|CLU}}==

if n<0 then return("99 bottles")

elseif n=0 then return("No more bottles")

{{works with|OpenCOBOL|1.1}}

Free form version.

program-id. ninety-nine.

environment division.

 

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

program-id. ninety-nine.

environment division.

 

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

data division.

working-storage section.

 

=={{header|CoffeeScript}}==

bottlesOfBeer = (n) ->

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

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]

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"))>

 

=== CFScript ===

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

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

 

=={{header|Comal}}==

0020 itone$(0):="one";itone$(1):="it"

0030 FOR b#:=99 TO 1 STEP -1 DO

=={{header|Comefrom0x10}}==

 

remaining = 99

one_less_bottle = remaining

 

=={{header|Cowgol}}==

 

sub Bottles(n: uint8) is

 

=={{header|Crystal}}==

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

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

 

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

 

void main() {

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 {

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

 

module bottles;

 

=={{header|Dart}}==

// Making use of polymorphism

BeerSong beerSong = BeerSong();

//pass a 'starting point' and 'end point' as parameters respectively

{{works with|GNU dc}}

{{works with|OpenBSD dc}}

dnrpr

dnlBP

 

{{works with|AT&T dc}}

plAP

plBP

 

=={{header|DBL}}==

;===============================================================================

; Oringinal Author: Bob Welton (welton@pui.com)

 

=={{header|Draco}}==

if b=0 then write("No more") else write(b) fi;

write(" bottle");

=={{header|Dyalect}}==

{{trans|Swift}}

print("\(i) bottles of beer on the wall, \(i) bottles of beer.")

let next = i is 1 ? "no" : i - 1

 

=={{header|Dylan}}==

define method bottles (n :: <integer>)

for (n from 99 to 1 by -1)

 

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

if = 1 i "" "s"

 

 

=={{header|DIBOL-11}}==

;

;===============================================================================

</syntaxhighlight>

=={{header|E}}==

return switch (n) {

match ==0 { "No bottles" }

 

=={{header|ECL}}==

Layout := RECORD

UNSIGNED1 RecID1;

 

=={{header|Egel}}==

import "prelude.eg"

import "io.ego"

 

=={{header|EGL}}==

function main()

 

=={{header|Eiffel}}==

class

APPLICATION

 

An alternative version written using the across-loop construct.

output_lyrics

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

=={{header|Ela}}==

 

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

=={{header|Elena}}==

ELENA 5.0 :

import extensions;

import extensions'routines;

 

=={{header|Elixir}}==

def run do

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

 

=={{header|Elm}}==

 

import Html

 

=={{header|Emacs Lisp}}==

(while (> i 0)

(message "%d bottles of beer on the wall" i)

 

=={{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

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

bottles = "bottles",

bottle = "bottle"

end for</syntaxhighlight>

 

 

include std/console.e

end for</syntaxhighlight>

 

 

include std/console.e

 

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

let rec bottles n =

let (before, after) = match n with

 

=={{header|Factor}}==

 

: bottle ( -- quot )

 

=={{header|Falcon}}==

> i, " bottles of beer on the wall"

> i, " bottles of beer"

 

A more robust version to handle plural/not plural conditions

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

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

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

 

 

number bottles = 99;

 

=={{header|Fexl}}==

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

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

 

=={{header|FOCAL}}==

01.15 D 2;T " OF BEER ON THE WALL,",!

01.20 D 2;T " OF BEER,",!

 

=={{header|Forth}}==

:noname ." 1 bottle" ;

:noname ." no more bottles" ;

 

Version 2: create a beer language and write the program

: BOTTLES ( n -- )

DUP

 

Forth Console Output

2 bottles of beer on the wall,

2 bottles of beer ,

=={{header|Fortran}}==

===F90 version===

 

implicit none

 

===MPI version===

 

implicit none

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

Works with GNU gfortran 5.0.0 and Intel ifort 15.0.2

module song_typedefs

implicit none

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

 

 

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

=={{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]

 

=={{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'}

 

=={{header|FutureBasic}}==

include "NSLog.incl"

 

Implementation of the code '99 bottles of beer' written in Visual Basic. Code tested in Gambas 3.15.2

 

 

Public Const bottlesofbeer As String = " bottles of beer."

 

=={{header|GAP}}==

local line, i, j, u;

line := function(n)

 

=={{header|Genie}}==

def plural(n:uint):string

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

 

=={{header|gnuplot}}==

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

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

=={{header|Go}}==

===No sense of humor===

 

import "fmt"

===Typoglycemic===

With code from RC tasks Number names, Knuth shuffle.

 

import (

=={{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

 

=={{header|Golfscript}}==

 

=={{header|Golo}}==

 

augment java.lang.Integer {

 

=={{header|Gosu}}==

for (i in 99..0) {

 

===Basic Solution===

With a closure to handle special cardinalities of bottles.

 

99.downto(1) { i ->

=== 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" +

===Bottomless Beer Solution===

Using more closures to create a richer lyrical experience.

 

def initialState = {

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

 

=={{header|Halon}}==

$x = 99;

while ($x > 0) {

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."

As a list comprehension:

 

 

main = putStr $ concat

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

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

[ "on the wall",

=={{header|Haxe}}==

=== Simple solution ===

{

static public function main()

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"

 

=={{header|HicEst}}==

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

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

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

 

=={{header|Hoon}}==

:- %say

|= [* * [bottles=_99 ~]]

=={{header|Hope}}==

El código es de Wolfgang Lohmann (wlohmann@informatik.uni-rostock.de)

dec i2c : num -> char;

dec i2s : num -> list(char);

 

=={{header|Huginn}}==

exec huginn --no-argv -E "${0}" "${@}"

#! huginn

=={{header|HyperTalk}}==

El código es de Eric Carlson eric@bungdabba.com

BottlesOfBeer 99

end BeerSong99

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)

 

=={{header|IDL}}==

 

for i=1,99 do begin

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

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

 

=={{header|Idris}}==

beerSong : Fin 100 -> String

beerSong x = verses x where

 

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

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

 

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

=== Programmatic solution ===

 

When play begins:

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.

 

=={{header|Io}}==

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

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

 

=={{header|Ioke}}==

case(i,

0, "no more bottles of beer",

=={{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@<:

===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;

 

'''Recursive'''

public static void main(String args[]) {

song(99);

{{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 = [

 

===ES6===

while (beer > 0) {

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

 

===Functional / Recursive===

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

"{X} bottles of beer \n"+

 

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".

var beer; while ((beer = typeof beer === "undefined" ? 99 : beer) > 0) document.write( beer + " bottle" + (beer != 1 ? "s" : "") + " of beer on the wall<br>" + beer + " bottle" + (beer != 1 ? "s" : "") + " of beer<br>Take one down, pass it around<br>" + (--beer) + " bottle" + (beer != 1 ? "s" : "") + " of beer on the wall<br>" );</syntaxhighlight>

 

 

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

 

 

Object Oriented

this.count = count || 99;

}

An alternative version:

 

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

var a = '%% bottles of beer',

 

=={{header|Joy}}==

 

_beerlib == true;

=={{header|jq}}==

'''Minimalist:'''

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

| "

\(.) bottles of beer on the wall"</syntaxhighlight>

{{out}}

...

 

0 bottles of beer on the wall</syntaxhighlight>

'''Variant''':

def s: if . == 1 then "" else "s" end;

def bottles:

$bottles | tonumber | sing</syntaxhighlight>

{{out}}

...

2 bottles of beer on the wall

 

=={{header|Jsish}}==

function plural(n:number):string { return (bottles == 1) ? "" : "s"; }

function no(n:number):string { return (bottles == 0) ? "No" : n.toString(); }

=={{header|Julia}}==

'''one-liner'''

another solution, handling grammar cases "No more bottles", "1 bottle", "<n> bottles"

n==1 ? "1 bottle" :

"$n bottles"

end</syntaxhighlight>

shorter, but more cryptic, version of the previous `bottles` function

 

=={{header|K}}==

 

=={{header|Kabap}}==

// Loop that spits lyrics to "99 Bottles of Beer"

 

=={{header|Kitten}}==

 

 

define bottles_of_beer_on_the_wall (Int32 -> +IO):

 

=={{header|Klingphix}}==

 

:bottles

 

=={{header|Klong}}==

itone::{:[x=1;"it";"one"]}

numno::{:[x=0;"no";x]}

 

=={{header|Kotlin}}==

for (i in 99.downTo(1)) {

println("$i bottles of beer on the wall")

 

The signature file:

 

type println string -> o.

 

The module file:

 

println Str :- print Str, print "\n".

Then we produce the desired output by setting the system to solve for this goal:

 

 

=={{header|Lambdatalk}}==

{def beer

{lambda {:i}

 

=={{header|lang5}}==

: verses(*)

dup " bottles of beer on the wall\n" ~ .

=== Simple loop ===

 

beer = 99,

song = ''

=== Query Expression ===

 

#beer + ' bottles of beer on the wall' +

#beer + ' bottles of beer\n' +

=== Query Expression with Autocollect ===

 

 

local(s = 's')

=={{header|LaTeX}}==

===Recursive===

\newcounter{beer}

\newcommand{\verses}[1]{

Just for fun, this version uses Roman numerals.

 

\newcounter{beer}

\newcounter{showC}

 

=={{header|LDPL}}==

DATA:

bottles-in-the-wall is number

 

=={{header|Lhogho}}==

if :i = 0 [output "|No more bottles of beer|]

if :i = 1 [output "|One bottle of beer|]

 

=={{header|Limbo}}==

implement Beer;

 

 

=={{header|Lingo}}==

put i & " bottles of beer on the wall"

put i & " bottles of beer"

 

=={{header|Logo}}==

if :n = 0 [output [No more bottles]]

if :n = 1 [output [1 bottle]]

 

=={{header|Logtalk}}==

 

:- initialization(sing(99)).

 

=={{header|Lua}}==

 

local function plural (bottles) if bottles == 1 then return '' end return 's' end

With a numeric for-loop and string formatting:

 

%i bottle%s of beer

Take one down, pass it around

Using Lua relational operators and multiple return values:

 

local s = i == 1 and "1 bottle of beer" or

i == 0 and "no more bottles of beer" or

 

=={{header|Lucid}}==

// The print out is a list of lines. So the output is not separated by new lines, rather

// by '[' and ']' -- I cant figure out how to do string concatenation with numbers in lucid.

=={{header|NATURAL}}==

El código es de Chris Bednara

LOCAL

01 #BOTTLES (I2)

 

=={{header|M4}}==

define(`BOTTLE', `bottle of beer')dnl

define(`WALL', `on the wall')dnl

=={{header|MACRO-11}}==

 

;

; 99 BOTTLES OF BEER

=={{header|MAD}}==

 

BOTLES = 99

{{libheader|jot}}

{{works with|BSD make}}

UP != jot - 2 `expr $(START) - 1` 1

 

=== GNU make ===

{{works with|GNU make|3.81}}

 

1-bottles: 1-beer pass

===== Without using a shell command to decrement the counter =====

{{works with|GNU make|3.81}}

numbers:=$(foreach x,$(filter-out 0,$(digits)),$(foreach y,$(digits),$x$y))

numbers+=$(digits)

 

'''Long version''' (a real loop version made by Hisashi Iizawa)''':'''

S(bt<%@#!7~|4{y1xv.us+rp(om%lj"ig}fd"cx``uz]rwvYnslkTonPfOjiKgJeG]\EC_X]@[Z<R;VU7S6QP2N1LK-I

,GF(D'BA#?>7~;:9y16w43s10)p-,l*#(i&%e#d!~``{tyxZpuXsrTTongOkdMhg`Hd]ba`_^W@[ZYXW9UNSRQPOHMLK

 

'''Short version''' (a just printing out the lyrics version made by Johannes E. Schindelin)''':'''

R5nO2~L/JzHe@ED'`N$?\7<;:W87C54us1N`.-nm*GF43gU#dRx=_N)sK&vo4Vrqji.z,Odvh'&e7Fb"

DlkAVhZS+Q9(7M_$o"110EhzgxFccbBNqLo\}}Y9z7gT4us1*/LKn87G(!&VeT/c?w|_M(xwY5XmVTjo

 

=={{header|Maple}}==

i, `if`( i<>1, "bottles", "bottle" ),

i, `if`( i<>1, "bottles", "bottle" ),

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

BottleSong[n_] := Speak[

 

=={{header|MATLAB}}==

 

disp( [ sprintf(['%d bottles of beer on the wall, %d bottles of beer.\n'...

 

=={{header|Maxima}}==

printf(true, "~d bottle~p of beer on the wall~%", i, i),

printf(true, "~d bottle~p of beer~%", i, i),

 

=={{header|MAXScript}}==

resetMaxFile #noPrompt

viewport.setType #view_top

Since MAXscript is an expression based language (everything returns a value), it is relatively easy to write long expressions that are only one line long. the following single-line snippet (broken for clarity on the webpage) produces a grammatically correct printout of the song.

 

(if i == 1 then " bottle" else " bottles") + " of beer\nTake one down, pass it around\n" + (i - 1) as string + (if i - 1 == 1 then "\

bottle" else " bottles") + " of beer on the wall\n" + (if i - 1 == 0 then "\nno more beer" else "")))</syntaxhighlight>

 

=={{header|Mercury}}==

% file: beer.m

% author:

=={{header|min}}==

{{works with|min|0.19.3}}

 

(

=={{header|MiniScript}}==

Going for the simple/obvious solution here...

if n == 0 then return "no bottles"

if n == 1 then return "1 bottle"

 

=={{header|MIPS Assembly}}==

##################################

# 99 bottles of beer on the wall #

 

=={{header|Mirah}}==

99.downto(1) do |i|

puts "#{i} bottle#{plural} of beer on the wall,"

 

=={{header|mIRC Scripting Language}}==

while (%x) {

echo -ag %x bottles of beer on the wall

=={{header|ML/I}}==

=== Simple iterative version ===

"" 99 bottles - simple iterative version

MCSKIP MT,<>

 

=== Recursive version ===

"" 99 bottles - recursive version

MCSKIP MT,<>

Internal macros define English word replacements for decimal numbers from 0 to 99.

 

MCSKIP - WITH - NL

-- The line above defines the comment syntax: -- through to newline is completely deleted.

 

=== Output: ===

Ninety nine bottles of beer on the wall,

Ninety nine bottles of beer.

 

=={{header|mLite}}==

 

fun itone 1 = "it"

 

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

IMPORT InOut;

 

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt;

 

=={{header|MontiLang}}==

 

WHILE i

Another way to solve the task that shows some more features of the language.

 

 

def rima

Infinite loop

 

 

def rima /# n -- n #/

 

=={{header|MOO}}==

while (bottles > 0)

unit = (bottles == 1 ? "bottle" | "bottles");

 

=={{header|MoonScript}}==

i != 1 and 's' or ''

 

=={{header|MUMPS}}==

===Recursive===

Write !!,n," bottle",$Select(n=1:"",1:"s")," of beer on the wall."

Write !,n," bottle",$Select(n=1:"",1:"s")," of beer."

 

===Iterative===

Write !!,n," bottle",$Select(n=1:"",1:"s")," of beer on the wall."

Write !,n," bottle",$Select(n=1:"",1:"s")," of beer."

 

===Brain-damaging===

set template1="i_n_""of beer on the wall. ""_i_n_"" of beer. """

set template2="""Take""_n2_""down, pass it around. """

It outputs bottles.txt, which contains the lyrics.

 

$(for:i in 99-1)

$(i) bottles of beer on the wall

 

{{works with|All TROFF}}

.de L1

.ie \\n(BS>1 \{ \

 

{{works with|GNU TROFF|1.22.2}}

.nf

.while \n[beers]>0 \{ \

=={{header|Nanoquery}}==

{{trans|Ursa}}

// 99 bottles of beer

//

 

=={{header|NASL}}==

repeat {

display(bottles, ' bottles of beer on the wall\n');

 

=={{header|Neko}}==

<doc>

<h3>Rosetta Code, 99 bottles of beer on the wall, in Neko</h3>

 

=={{header|Nemerle}}==

using System.Console;

 

 

=={{header|NetRexx}}==

beer = "bottles of beer on the wall"

removeOne = "Take one down, pass it arround,"

 

=={{header|Nial}}==

0=, 'No more bottles of beer' first,

1=, 'One bottle of beer' first,

 

=={{header|Night}}==

if(x == 1) {

print("1 bottle of beer on the wall,\n");

 

=={{header|Nim}}==

case n

of 0:

other:

 

for i in countdown(99, 1):

compact:

 

 

proc pluralize(a: int): string =

organized:

 

 

var verse = """$1 bottle$3 of beer on the wall

 

=={{header|Nix}}==

let

bottle = x: "${toString x} bottle${if (x == 1) then "" else "s"} of beer";

=={{header|NS-HUBASIC}}==

With grammatical support for "1 bottle of beer"

20 FOR BOTTLES=99 TO 1 STEP -1

30 BOTTLES$=" BOTTLES OF BEER"

 

Without grammatical support for "1 bottle of beer"

20 WALL$=" ON THE WALL"

30 FOR BOTTLES=99 TO 1 STEP -1

 

=={{header|OASYS}}==

class player {}

 

 

=={{header|Oberon-2}}==

 

IMPORT Out;

 

=={{header|Objeck}}==

class Bottles {

function : Main(args : String[]) ~ Nil {

 

=={{header|Objective-C}}==

 

int main()

=={{header|OCaml}}==

===For-loop===

Printf.printf "%d bottles of beer on the wall\n" n;

Printf.printf "%d bottles of beer\n" n;

Recursive version that handles plurals.

 

let

line2 = function

Monadic version, expressing actions which evolve the program state and log output. Special cases and grammar rules are handled.

 

module Writer = struct

type 'a t = 'a * string

Output for initial beer-count of two:

 

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.

 

=={{header|Octave}}==

bottle = "bottle";

ofbeer = "of beer";

bottles(99);</syntaxhighlight>

=={{header|Odin}}==

 

import "core:fmt"

=={{header|Oforth}}==

 

"bottles of beer\nTake one down, pass it around\n" const: T

=={{header|Onyx}}==

 

dup cvs ` bottle' cat exch 1 ne {`s' cat} if

` of beer' cat

 

=={{header|OOC}}==

sing_line: func (b: Int, suffix: Bool) {

"#{b > 0 ? "#{b}" : "No more"} bottle#{b == 1 ? "" : "s"}" print()

 

=={{header|OpenEdge/Progress}}==

&GLOBAL-DEFINE bbm bottles of beer

&GLOBAL-DEFINE bbs bottle of beer

=={{header|Openscad}}==

El código es de Marc Vanlindt (marc@vanlindt.be)

s1 = " of beer";

s2 = " on the wall";

==="Pure" Order===

This solution uses only Order language constructs to generate and manipulate tokens:

 

ORDER_PP

===C Preprocessor===

...but since most of the logic is simple substitution, it makes more sense (and is significantly more efficient) to make the C Preprocessor do most of the work without the help of the Order interpreter. This version shows how to integrate normal C Preprocessor macros into an Order program:

 

#define GEN_phrase(N_bottles, N_minus_1_bottles) \

 

=={{header|Oxygene}}==

namespace ConsoleApplication2;

 

=== Constraint Programming ===

Note: In real life, you would never solve a simple iterative task like this with constraint programming. This is just for fun.

%% describe the possible solutions of the beer 'puzzle'

proc {BeerDescription Solution}

 

=== Iterative ===

fun {Bottles N}

if N == 1 then "1 bottle"

 

=={{header|PARI/GP}}==

print(n" bottles of beer on the wall");

print(n" bottles of beer");

 

=={{header|Perl}}==

 

my $verse = <<"VERSE";

 

Alternatively:

{

$bottles = sprintf("%s bottle%s of beer on the wall\n",(($n==0)?"No":$n), (($n==1)?"":"s"));

 

Correct grammar and nice spacing in modern perl:

 

$num = 99;

 

Using perl5 as a DSL factory leveraging $_'s global nature:

#!/usr/bin/env perl

use strict;

 

=={{header|Phix}}==

<span style="color: #008080;">constant</span> <span style="color: #000000;">ninetynine</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">99</span> <span style="color: #000080;font-style:italic;">-- (set to 9 for testing)</span>

 

=={{header|Phixmonti}}==

dup if

dup 1 == if

for verse . endfor</syntaxhighlight>

With syntactic sugar

def bottles

{{trans|C}}

 

extern printf;

 

 

=={{header|PHP}}==

$plural = 's';

foreach (range(99, 1) as $i) {

 

===shorter way===

foreach(range(99,1) as $i) {

$p = ($i>1)?"s":"";

 

===Tag syntax===

<?=$i?> bottle<?=$i==1 ? '' : 's'?> of beer on the wall,

<?=$i?> bottle<?=$i==1 ? '' : 's'?> of beer!

 

===modifing way===

$verse = <<<VERSE

100 bottles of beer on the wall,

supports grammar and has no leading and trailing new lines or spaces.

Also one does not have to close the <?php tag, it is even recommended not to close it, if closing it is not necessary

for($i=100;$i>0;$i--){

$p2=$i." bottle".(($i>1)?"s":"")." of beer";

supports grammar and translations.

 

 

$bottles = 99;

Fun with HEREDOC and printf placeholders

 

 

$lyrics = <<<ENDVERSE

 

=={{header|Picat}}==

beer1(N) =>

Beer = N,

 

=={{header|Pike}}==

for(int i = 99; i > 0; i--){

write(i + " bottles of beer on the wall, " + i + " bottles of beer.\n");

 

alternate version:

 

void main()

=={{header|PILOT}}==

El código es de Akira KIDA (SDI00379@niftyserve.or.jp)

 

U : *beers

{{works with|Parrot|Tested with 2.4.0}}

 

.param int b

if b == 1 goto ONE

 

=={{header|PlainTeX}}==

\def\beers{

\par\ifbeer>0 \the\bottles~\else No more \fi

 

=={{header|PL/I}}==

nBottles: procedure(n);

declare n fixed;

 

=={{header|PL/M}}==

 

BDOS: PROCEDURE(F,PARAM); /* CALL CP/M BDOS */

=={{header|Pointless}}==

 

-- Print the lyrics to the song '99 bottles of beer'

 

=={{header|Pony}}==

=== Recursive ===

let _env: Env

new create(env: Env) =>

end</syntaxhighlight>

=== Iterative ===

let _env: Env

new create(env: Env) =>

 

=={{header|Pop11}}==

while n > 0 do

printf(n, '%p bottles of beer on the wall\n');

 

=={{header|PostScript}}==

/Helvetica findfont 9 scalefont setfont

 

No extra credit.

 

verse = (n) :

(n, " bottles of beer on the wall\n"

 

Immediately prints all output to the console.

print(i + " bottles of beer on the wall\n"

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

 

This approach uses Processing's draw loop to display text on the sketch canvas, with a global counter for bottles--draw() is called at the default 60fps, and acts as the for loop. One round of lyrics is displayed at a time, and the counter advances by checking Processing's built-in frameCount. Lyrics may also be advanced manually by clicking the mouse on the canvas.

void setup() {

size(200, 140);

==={{header|Processing Python mode}}===

{{trans|Processing}}

def setup():

size(200, 140)

'''Console output'''

 

stdout$print(bottlesong(99))

}

Quite a short, one-line version.

 

</syntaxhighlight>

 

Version with correct grammar and correct ending ("no more bottles ..."). The problem that has not been solved is that the number of bottles is written in numbers, not in words. The program is '''PEP8 compliant''' and remains readable even to those unfamiliar with Python.

 

# -*- coding: utf-8 -*-

 

{{Trans|Haskell}}

{{Works with|Python|3.7+}}

 

 

Inspired by [[99_Bottles_of_Beer#Functional|Functional version]]

 

99 Bottles of Beer on the Wall made functional

Inspired by the [[99_Bottles_of_Beer#Python_3.2C_functional.2C_pythonic_version|Functional Pythonic Version]]

 

Excercise of style. An overkill for the task :-D

 

 

=={{header|Q}}==

-1 bobw each reverse 1 + til 99</syntaxhighlight>

 

'''[NOTE]:''' The code below is an amazing, full-on media event! For a simpler version, click [[99_Bottles_of_Beer/Basic#QB64 | HERE.]]

----

CONST BottleSpeed = 3

PLAY "<"

===Simple Solution===

 

 

%enable-all-warnings

===Concurrent (Unordered) Solution===

 

%enable-all-warnings

 

=={{header|Quackery}}==

[ stack ] is bottles ( --> [ )

 

 

=={{header|Quill}}==

(count > 0) if {

new_count := count - 1;

=={{header|Quite BASIC}}==

With grammatical support for "1 bottle of beer"

20 for n=99 to 1 step -1

30 let b=" bottles of beer"

 

Without grammatical support for "1 bottle of beer"

20 let w=" on the wall"

30 for n=99 to 1 step -1

===Simple looping solution===

 

 

song = function(bottles){

 

===Vector solutions===

cat(paste(99:1,ifelse((99:1)!=1," bottles"," bottle")," of beer on the wall\n",99:1,ifelse((99:1)!=1," bottles"," bottle")," of beer\n","Take one down, pass it around\n",98:0,ifelse((98:0)!=1," bottles"," bottle")," of beer on the wall\n\n",sep=""),sep="")

 

 

=={{header|Ra}}==

class BottlesOfBeer

**Prints the "99 Bottles of Beer" song"**

 

=={{header|Racket}}==

#lang racket

(define (sing bottles)

=== A Simple Way ===

 

 

repeat while --$b {

Similar to "A Simple Way", but with proper variable and subroutine naming, declarator documentation, strongly-typed function definition, better code reuse, and external ternary logic.

 

sing $bottles, :wall;

sing $bottles;

 

{{works with|Rakudo|2015.09}}

my @bottles = flat 'bottles' xx 98, 'bottle', 'bottles' xx 2;

my @actions = flat 'Take one down, pass it around' xx 99,

 

=={{header|RapidQ}}==

dim nBott as integer

nBott = 99

 

=={{header|Rascal}}==

module demo::basic::Bottles

 

 

=={{header|Raven}}==

$i 1 = if

"bottle" as $b

 

=={{header|REBOL}}==

Title: "99 Bottles of Beer"

URL: http://rosettacode.org/wiki/99_Bottles_of_Beer

This one prints with proper grammar. "Bottles" changed to "bottle" at the end of the 2 line, and throughout the 1 line. 0 changed to "No" in the last line:

 

x: rejoin [

i b: " bottles of beer" o: " on the wall. " i b

Here's a simple 1 line console version:

 

=={{header|Red}}==

Title: "99 Bottles of Beer"

Original-Author: oofoe

 

=={{header|Relation}}==

program beer(n)

if n>1

This is based on the [[Forth]] example.

 

 

Display the text for the *99 Bottles of Beer* song.

=={{header|REXX}}==

Complete with a PSA &nbsp; (<u>P</u>ublic <u>S</u>ervice <u>A</u>nnouncement) &nbsp; comment.

parse arg N .; if N=='' | N=="," then N=99 /*allow number of bottles be specified.*/

/* [↓] downward count of beer bottles.*/

=={{header|Ring}}==

This is a simple solution

switch i

on 0

Rockstar solution without special cases for the last 2 verses.

 

Problems are " bottles of beer"

Carol says Take one down, pass it around

{{works with|RPGIII|}}

 

F********************************************************************

F*

=={{header|RPL/2}}==

===Simple solution===

<<

99 do

 

===Recursive and multithreaded solution===

<<

// Child process is started.

 

=={{header|Ruby}}==

99.downto(1) do |i|

puts "#{i} bottle#{plural} of beer on the wall,"

 

Ruby has variable traces, so we can do

$bottles = %Q{#{val == 0 ? 'No more' : val.to_s} bottle#{val == 1 ? '' : 's'}}

end

end</syntaxhighlight>

or...

puts "#{of_beer} bottle#{ending} of beer on the wall,"

puts "#{of_beer} bottle#{ending} of beer"

end</syntaxhighlight>

or...

"#{beer>0 ? beer : "no more"} bottle#{"s" if beer!=1} of beer#{" on the wall" if wall}"

end

 

===Simple solution===

99.downto(1) do |bottles|

puts "#{bottles} bottle#{"s" if bottles != 1} of beer on the wall.",

 

===Simple Solution===

for n in (0..100).rev() {

match n {

 

===Using a trait and impl===

fn bottles_of_beer(&self) -> Self;

fn on_the_wall(&self);

 

=={{header|S-BASIC}}==

rem - print lyrics to "99 Bottles of Beer on the Wall"

 

 

=={{header|Sather}}==

main is

s :STR;

=={{header|Scheme}}==

 

(define (sing)

(define (sing-to-x n)

 

=={{header|sed}}==

h

: b

 

=={{header|Seed7}}==

 

const proc: main is func

Below is a straightforward implementation in SenseTalk. A completely fanciful version (which also works!) can be found here: http://www.99-bottles-of-beer.net/language-sensetalk-1794.html

 

set bottleCount to 99

set bottleCount's format to "Words"

</syntaxhighlight>

Output:

Ninety-Nine bottles of beer on the wall,

Ninety-Nine bottles of beer!

 

=={{header|SequenceL}}==

import <Utilities/Sequence.sl>;

 

 

=={{header|Set lang}}==

set s 32

set m 44

 

=={{header|Shiny}}==

s: if i > 1 's' end

 

 

=={{header|Sidef}}==

var bottles = "#{i == 0 ? 'No' : i} bottle#{i == 1 ? '' : 's'}"

var sentence = "#{bottles} of beer on the wall" -> say

 

'''Simpler:'''

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

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

 

=={{header|Simula}}==

COMMENT AUTHOR: TIM GOODWIN ;

COMMENT DATE: 04/20/05 ;

</syntaxhighlight>

'''Simpler:'''

author: Jack Leunissen

date: 03/10/07;

=={{header|SkookumScript}}==

 

99.to 1

[

 

=={{header|Slate}}==

[| nprinted |

nprinted: n printString ; ' bottle' ; (n > 1 ifTrue: ['s'] ifFalse: ['']) ; ' of beer'.

99 bottles.</syntaxhighlight>

=={{header|Slope}}==

;; 99 bottles of beer

;;

=={{header|Smalltalk}}==

A straightforward approach:

sr := Dictionary new.

sr at: 0 put: ' bottle' ;

=={{header|SmileBASIC}}==

Pretty comical version. MML tunes based on QB64 version.

IF N==-1 THEN

RETURN "99"

 

=={{header|SNOBOL4}}==

again output = X " bottles of beer on the wall"

output = X " bottles of beer" ?eq(X,0) :s(zero)

{{works with|CSnobol}}

Function version with string composition. Function returns one verse for x bottles. Correctly handles bottle/bottles.

nl = char(13) char(10) ;* Win/DOS, change as needed

s2 = ' of beer'; s3 = ' on the wall'

=={{header|Sparkling}}==

 

 

do {

=={{header|SQL}}==

 

select

( 100 - level ) || ' bottle' || case when level != 99 then 's' end || ' of beer on the wall'

</syntaxhighlight>

 

 

 

This Statement does also work with T-SQL, but only up to 32 beers

 

CREATE PROCEDURE bottles

@bottle_count int,

</syntaxhighlight>

 

 

/*These statements work in PostgreSQL (tested in 9.4)*/

 

=={{header|Squirrel}}==

function rec(bottles)

{

 

=={{header|Standard ML}}==

| bottles x = ( print (Int.toString x ^ " bottles of beer on the wall\n");

print (Int.toString x ^ " bottles of beer\n");

)</syntaxhighlight>

The following code outputs the [https://99-bottles-of-beer.net/lyrics.html full lyrics], generating duplicate text blocks only once.

(str o Char.toUpper o String.sub) (s, 0) ^ String.extract (s, 1, NONE)

 

 

=={{header|Stata}}==

local s s

forvalues i=`1'(-1)0 {

 

=={{header|Suneido}}==

while (i > 0)

{

 

=={{header|SuperCollider}}==

(

(99..0).do { |n|

 

=={{header|xTalk}}==

function beerMe numberOfBottles

   put "XX bottles of beer on the wall" into verseA

</syntaxhighlight>

 

on mouseup

 

 

=={{header|Swift}}==

for i in (1...99).reversed() {

print("\(i) bottles of beer on the wall, \(i) bottles of beer.")

=={{header|Symsyn}}==

 

BBW : ' Bottles of beer on the wall '

TOD : 'Take one down and pass it around '

 

=={{header|Tailspin}}==

templates sayBottleCount

when <=1> do

 

=={{header|TIScript}}==

var beer = 99;

while (beer > 0)

=={{header|TMG}}==

Unix TMG:

line1: beer = { 1 < on the wall, > 1 <.> * };

line2: beer = { <If one of those bottles should happen to fall, > 1 < on the wall.> * };

 

=={{header|TorqueScript}}==

for(%i = 99; %i >= 0; %i--)

{

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

LOOP bottle=1,100

The <code>(range 99 -1 -1)</code> expression produces a lazy list of integers from 99 down to -1. The <code>mapcar*</code> function lazily maps these numbers to strings, and the rest of the code treats this lazy list as text stream to process, extracting the numbers with some pattern matching cases and interpolating them into the song's text. Functional programming with lazy semantics meets text processing, pattern matching and here documents.

 

@(collect)

@number

To make the song repeat indefinitely, change the first line to:

 

 

Now it's processing an infinite lazy lists consisting of

 

=={{header|TypeScript}}==

function nbottles(howMany:number){

return `${howMany?howMany:'no'} bottle${howMany!=1?'s':''}`;

=={{header|uBasic/4tH}}==

A very vanilla BASIC implementation.

0006 PRINT "Lyrics of the song 99 Bottles of Beer"

 

0052 PRINT "Go to the store and buy some more...99 bottles of beer."</syntaxhighlight>

And a more structured version.

print n;" bottles of beer on the wall, ";n;" bottles of beer!"

print "Take one down, pass it around, ";n-1;" bottle";

 

=={{header|Ursa}}==

#

# 99 bottles of beer

 

=={{header|Ursala}}==

 

# each function takes a natural number to a block of text

 

=={{header|UTFool}}==

···

http://rosettacode.org/wiki/99_Bottles_of_Beer

 

=={{header|V}}==

[newline '' puts].

[beer

 

=={{header|Vala}}==

uint bottles = 99;

do {

Most of the keywords in Vedit macro language have both short and long format.

Normally, long format is used here in Rosetta Code for clarity, so here is an example using the short keywords.

RS(2, " bottles of beer")

RS(3, " on the wall")

 

=={{header|Verbexx}}==

 

@LOOP init:{@VAR n = 99} until:(n == 0)

 

=={{header|Verilog}}==

module beer;

integer i;

=={{header|Viua VM assembly}}==

 

.function: bottles_of_beer_text/1

.name: %iota number_of_bottles

Fails the task definition for more song, includes the no beer verse.

 

module main

 

 

=={{header|Vox}}==

// translated from <http://rosettacode.org/wiki/99_Bottles_of_Beer#JavaScript>

 

 

=={{header|VTL-2}}==

20 #=200

30 ?=" of beer on the wall,"

 

=={{header|Wortel}}==

0 "0 bottles of beer on the wall\n0 bottles of beer\nbetter go to the store and buy some more."

"{@x} bottle{@?@x{1 @e 's}} of beer on the wall\n{@x} bottle{@?@x{1 @e 's}} of beer\nTake one down, pass it around"

 

=={{header|Wrapl}}==

 

IMP IO.Terminal USE Out;

 

=={{header|Wren}}==

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

System.print("%(i) bottles of beer,")

 

=={{header|X10}}==

public static def main(args: Rail[String]){

val beerSong: NinetyNineBottles = NinetyNineBottles.make(99);

 

=={{header|XBS}}==

while (Bottles > 0){

log(Bottles+" bottles of beer on the wall,");

=={{header|Xojo}}==

Place the following in the '''Run''' event handler of a Console application:

While bottles > 0

Print(bottles.ToText + " bottles of beer on the wall,")

A solution written in pure XPath 3.0 (using XSLT as a host language).

 

<xsl:output method="text"/>

<xsl:template match="/">

 

=={{header|XPL0}}==

int B;

[B:= 99;

To run, transform any document with this stylesheet (the input document is ignored).

 

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

<xsl:output method="text" encoding="utf-8"/>

* use of text value templates (using "{ XPath code }") [first available XSLT 3, see https://www.w3.org/TR/xslt-30/#text-value-templates]

 

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

xmlns:xs="http://www.w3.org/2001/XMLSchema" exclude-result-prefixes="xs" version="3.0">

 

=={{header|Yabasic}}==

if i=0 return "no more bottles of beer"

if i=1 return "1 bottle of beer"

 

=={{header|Yacas}}==

For (b := 99, b > 0, b--)

Echo({b, "bottle(s) of beer on the wall," : Nl(),

 

=== Looped version ===

while(bottles) {

write, format=" %d bottles of beer on the wall\n", bottles;

 

=== Vectorized version ===

song += "%d bottles of beer\n";

song += "Take one down, pass it around\n";

 

=={{header|zkl}}==

println(beers(n), " on the wall, ", beers(n).toLower(), ".\n",

n==0 and ("Go to the store and buy some more, 99 bottles of beer") or