Anonymous user
99 Bottles of Beer/Lisp: Difference between revisions
no edit summary
(new subpage) |
imported>Rowsety Moid No edit summary |
||
| (18 intermediate revisions by 8 users not shown) | |||
Line 4:
{{collection|99 Bottles of Beer}}
[[99 Bottles of Beer]] done in Lisp-languages
<!-- still missing:
Emacs Lisp
-->
__toc__
===ACL2===
<syntaxhighlight lang="lisp">(defun bottles-of-beer (n)
(if (zp n)
nil
(prog2$ (cw (concatenate 'string
"~%"
"~N0 bottle~#1~[~/s~] of beer on the wall,~%"
"~n0 bottle~#1~[~/s~] of beer.~%"
"Take one down, pass it around,~%"
"~n2 bottle~#3~[~/s~] of beer on the wall.~%")
n
(if (= n 1) 0 1)
(1- n)
(if (= n 2) 0 1))
(bottles-of-beer (- n 1)))))</syntaxhighlight>
===Acornsoft Lisp===
<syntaxhighlight lang="lisp">(defun bottles ((n . 99))
(loop
(bob n) (otw) (nl)
(bob n) (nl)
(tod-pia) (nl) (setq n (sub1 n))
(bob n) (otw) (nl)
(nl)
(until (zerop n))))
(defun nl ()
(printc))
(defun sing (w)
(princ w '! ))
(defun bob (n)
(map sing
(list (any? n) (plural? n 'bottle 'bottles) 'of 'beer)))
(defun otw ()
(map sing (list 'on 'the 'wall)))
(defun tod-pia ()
(map sing (list 'Take 'one 'down!, 'pass 'it 'around)))
(defun any? (n)
(cond ((zerop n) 'no)
(t n)))
(defun plural? (n sing plur)
(cond ((onep n) sing)
(t plur)))</syntaxhighlight>
===Common Lisp===
====Sensible solution====
<syntaxhighlight lang="lisp">(defun bottles (x)
(loop for bottles from x downto 1
do (format t "~a bottle~:p of beer on the wall~@
~:*~a bottle~:p of beer~@
Take one down, pass it around~@
~V[No more~:;~:*~a bottle~:p of~] beer on the wall~2%"
bottles (1- bottles))))
</syntaxhighlight>
and then just call
<syntaxhighlight lang="lisp">(bottles 99)</syntaxhighlight>
====Ridiculous====
<syntaxhighlight lang="lisp">(format t "~{~[~^~]~:*~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%~}"
(loop :for n :from 99 :downto 0 :collect n))</syntaxhighlight>
The [http://www.lispworks.com/documentation/HyperSpec/Body/22_c.htm FORMAT function] is probably the most baroque (i.e. featureful almost to a fault) function in Common Lisp.
To really drive this point home, try replacing each instance of <tt>~D</tt>
with <tt>~R</tt>, and then with <tt>~@R</tt>.
Yes, this is all standard and dependable (dys?)functionality.
Explanation of the format string for the uninitiated:
* <tt>~{<i>fmt</i>~}</tt> expects the next argument to be a list (which is of the integers from 99 down to 0), and executes the format string <i>fmt</i> on each element. It is essentially a map or foreach.
* <tt>~[...~]</tt> is a case/switch. It executes the <i>n</i>th clause, where <i>n</i> is taken from the next argument. Since there is only one clause here, it will be executed only when the argument is 0.
* <tt>~^</tt> will terminate formatting.
* <tt>~:*</tt> will back-up to the most-recently used argument.
* <tt>~D</tt> prints the next argument as a decimal number.
* <tt>~:P</tt> is for English plurals: it prints <tt>s</tt> if the last argument wasn't 1; it prints nothing otherwise. There's also <tt>~@P</tt> for <tt>y</tt>/<tt>ies</tt>, in case you were worried about that.
Note, by the way, how the emoticons <tt>:*~D</tt> and <tt>:P</tt> have shown up in the format string. FORMAT is so powerful, it's even self-aware about how silly it is.
====Alternate solution====
Bit of a beginner in Lisp, but this seems to work:
<syntaxhighlight lang="lisp">
(defun beer-verse (count)
"Recurses the verses"
(format t "~A bottle~:P of beer on the wall~%" count)
(format t "~A bottle~:P of beer~%" count)
(format t "Take one down, pass it round~%")
(format t "~A bottle~A of beer on the wall~%~%"
(if (= count 1)
"No"
(- count 1))
(if (/= count 2)
"s"
""))
(if (> count 1)
(beer-verse (- count 1))))
(beer-verse 99)
</syntaxhighlight>
<!-- missing here:
===Emacs Lisp===
-->
===newLISP===
<syntaxhighlight lang="newlisp">(for (n 99 1)
(println n " bottles of beer on the wall," n " bottles of beer. Take one down, pass it around. ")
(println (- n 1) "bottles of beer on the wall!"))
;;recursive
;;also shows list afterword
(define (rec bottles)
(if (!= 0 bottles) (print "/n" bottles " bottles of beer on the wall" bottles " bottles of beer.
\nTake one down, pass it around, " (- bottles 1)
" bottles of beer on the wall" (rec ( - bottles 1))))(list bottles))
(rec 99)</syntaxhighlight>
===Ol===
<syntaxhighlight lang="scheme">
(define nn 99)
(for-each (lambda (n)
(let ((bottle (lambda (n) (if (eq? n 1) " bottle" " bottles")))
(m (- n 1)))
(print
n (bottle n) " of beer on the wall, "
n (bottle n) " of beer." "\n"
"Take one down and pass it around, "
(if (eq? m 0) "no more" m)
(bottle m) " of beer on the wall.\n")))
(reverse (iota nn 1)))
(print
"No more bottles of beer on the wall, "
"no more bottles of beer." "\n"
"Go to the store and buy some more, "
nn " bottles of beer on the wall.")
</syntaxhighlight>
===PicoLisp===
<syntaxhighlight lang="picolisp">(de bottles (N)
(case N
(0 "No more beer")
(1 "One bottle of beer")
(T (cons N " bottles of beer")) ) )
(for (N 99 (gt0 N))
(prinl (bottles N) " on the wall,")
(prinl (bottles N) ".")
(prinl "Take one down, pass it around,")
(prinl (bottles (dec 'N)) " on the wall.")
(prinl) )</syntaxhighlight>
===Shen===
<syntaxhighlight lang="shen">(define bottles-h
{ number --> string }
0 -> "No more beer"
1 -> "One bottle of beer"
N -> (make-string "~A bottles of beer" N))
(define bottles
{ number --> number }
0 -> 0
X -> (let Msg (bottles-h X)
(do (output "~A on the wall~%~A~%Take one down, pass it around~%~A on the wall~%~%" Msg Msg (bottles-h (- X 1)))
(bottles (- X 1)))))</syntaxhighlight>
===Wart===
<syntaxhighlight lang="python">def (beer n)
when (n > 0)
prn n " bottles of beer on the wall"
prn n " bottles of beer"
prn "take one down, pass it around"
prn n-1 " bottles of beer on the wall"
prn ""
beer n-1</syntaxhighlight>
| |||