TheSwamp

Code Red => AutoLISP (Vanilla / Visual) => Topic started by: irneb on August 21, 2014, 02:49:19 PM

Title: =={challenge}== Programmer Test - Fizz/Buzz
Post by: irneb on August 21, 2014, 02:49:19 PM

Here's a test some employers use to see if someone can actually think about a program. Mind you it's considered an "entry-level" test, so any decent programmer should be able to get it. Yet even many "professionals" tend to fail because there's a few "tricks" which you need to think about.

The task is as such:

• You're supposed to write a function which accepts a positive integer
• The function needs to return a value depending on that integer in the following ways:
  
  • If the number is divisible by 3 it should return "Fizz"
  • If the number is divisible by 5 it should return "Buzz"
  • If the number is divisible by both 3 and 5 it should return "FizzBuzz"
  • Else it should return the number

There are many ways you can achieve this. The point is usually not to try and get the fastest and/or most novel way, but just to show you can get it "correct".

Example output for 1 through 30:

Code: [Select]

(mapcar 'FizzBuzz '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30))
(1 2 "Fizz" 4 "Buzz" "Fizz" 7 8 "Fizz" "Buzz" 11 "Fizz" 13 14 "FizzBuzz" 16 17 "Fizz" 19 "Buzz" "Fizz" 22 23 "Fizz" "Buzz" 26 "Fizz" 28 29 "FizzBuzz")

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: snownut2 on August 21, 2014, 03:25:43 PM

irne,

Why no negative or real numbers in the test list ?

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ChrisCarlson on August 21, 2014, 03:58:49 PM

Code - Auto/Visual Lisp: [Select]

1. (defun c:FizzFuzzBuzz (/ a b c)
2.         (initget 4)
3.         (setq a (getint "\n Enter Numero: "))
4.         (if (= (* (fix (/ a 3)) 3) a)
5.                 (setq c "Fizz")
6.                 (princ)
7.                 ) : _end if    
8.         (if (= (* (fix (/ a 5)) 5) a)
9.                 (setq c "Buzz")
10.                 (princ)
11.         ) : _end if    
12.         (if (and (= (* (fix (/ a 3)) 3) a) (= (* (fix (/ a 5)) 5) a))
13.                 (setq c "FizzBuzz")
14.                 (princ)
15.         ) ;_end if     
16.         (if (or (= c "Fizz") (= c "Buzz") (= c "FizzBuzz"))
17.                 (princ (strcat "\n" c))
18.                 (princ (strcat "\nUhOh You Chose: " (rtos a 2 0)))
19.         ) ; _end if    
20.         (princ)
21. ) ; _end fun

My attempt

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ronjonp on August 21, 2014, 04:18:33 PM

Mine:

Code - Auto/Visual Lisp: [Select]

1.  
2. (defun _fb (n)
3.   (cond ((and (zerop (- (fix (/ n 3.)) (/ n 3.))) (zerop (- (fix (/ n 5.)) (/ n 5.)))) "FizzBuzz")
4.         ((zerop (- (fix (/ n 3.)) (/ n 3.))) "Fizz")
5.         ((zerop (- (fix (/ n 5.)) (/ (float n) 5.))) "Buzz")
6.         (n)
7.   )
8. )(mapcar '_fb '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30))
9.  

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: CAB on August 21, 2014, 04:23:41 PM

Code - Auto/Visual Lisp: [Select]

1. (defun FizzBuzz(n / )
2.  (cond
3.    ((and (= (/ n 3.) (/ n 3))(= (/ n 5.) (/ n 5))) "FizzBuzz")
4.    ((= (/ n 3.) (/ n 3)) "Fizz")
5.    ((= (/ n 5.) (/ n 5)) "Buzz")
6.    (t n)
7. )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Stefan on August 21, 2014, 04:28:03 PM

Code - Auto/Visual Lisp: [Select]

1. (defun ph:FB2 (n)
2.   (if
3.     (zerop (rem n 3))
4.     (strcat
5.       "Fizz"
6.       (if
7.         (zerop (rem n 5))
8.         "Buzz"
9.         ""
10.       )
11.     )
12.     (if
13.       (zerop (rem n 5))
14.       "Buzz"
15.       n
16.     )
17.   )
18. )

Code - Auto/Visual Lisp: [Select]

1. (defun ph:FB4 (n)
2.   (cond
3.     ((zerop (rem n 15)) "FizzBuzz")
4.     ((zerop (rem n  5)) "Buzz")
5.     ((zerop (rem n  3)) "Fizz")
6.     (n)
7.   )
8. )

Code - Auto/Visual Lisp: [Select]

1. (defun ph:FB5 (n)
2.   (cond
3.     ((nth (rem n 15) '("FizzBuzz" nil nil "Fizz" nil "Buzz" "Fizz" nil nil "Fizz" "Buzz" nil "Fizz" nil nil)))
4.     (n)
5.     )
6.   )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Marc'Antonio Alessi on August 21, 2014, 04:51:03 PM

; CAB modified

Code: [Select]

(defun FizzBuzz_A (n / f b)
  (setq f (= (/ n 3.) (/ n 3))  b (= (/ n 5.) (/ n 5)))
  (cond
    ( (and f b) "FizzBuzz")
    ( f "Fizz" )
    ( b "Buzz" )
    ( n )
  )
); from others...

Code: [Select]

(defun FizzBuzz_A2 (n / f b)
  (setq f (zerop (rem n 3))  b (zerop (rem n 5)))
  (cond
    ( (and f b) "FizzBuzz")
    ( f "Fizz" )
    ( b "Buzz" )
    ( n )
  )
)

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Kerry on August 21, 2014, 05:04:00 PM

Code - Auto/Visual Lisp: [Select]

1. (defun FizzBuzz (n)
2.   (cond
3.     ((zerop (rem n 15)) "FizzBuzz")
4.     ((zerop (rem n 5)) "Buzz")
5.     ((zerop (rem n 3)) "Fizz")
6.     (n)
7.   )
8. )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Tharwat on August 21, 2014, 05:31:38 PM

My variation  :-)

Code - Auto/Visual Lisp: [Select]

1. (defun FizzBuzz (l / pick)
2.   (defun pick (i / r)
3.     (cond ((and (zerop (rem i 3)) (zerop (rem i 5))) (setq r "FizzBuzz"))
4.           ((zerop (rem i 3)) (setq r "Fizz"))
5.           ((zerop (rem i 5)) (setq r "Buzz"))
6.           (t (setq r i)))
7.     r
8.   )
9.   (if l (cons (pick (car l)) (FizzBuzz (cdr l))))
10. )
11.  

To test :

Code - Auto/Visual Lisp: [Select]

1. (FizzBuzz '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30))
2.  

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Lee Mac on August 21, 2014, 06:07:53 PM

Another, similar to those posted:

Code - Auto/Visual Lisp: [Select]

1. (defun fizzbuzz ( n / r )
2.     (setq r "")
3.     (if (zerop (rem n 3)) (setq r "Fizz"))
4.     (if (zerop (rem n 5)) (setq r (strcat r "Buzz")))
5.     (if (= "" r) n r)
6. )
7.  

Just to be different:

Code - Auto/Visual Lisp: [Select]

1. (defun fizzbuzz ( n )
2.     (cdr
3.         (assoc (mapcar '(lambda ( x ) (zerop (rem n x))) '(3 5))
4.             (list
5.                '((t  t ) . "FizzBuzz")
6.                '((t nil) . "Fizz")
7.                '((nil t) . "Buzz")
8.                 (cons '(nil nil) n)
9.             )
10.         )
11.     )
12. )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Jeff H on August 21, 2014, 08:33:52 PM

Just farting around and total noob but trying to get familiar with Vlide editor and just messing with it to rebuild  the list.

Code - Auto/Visual Lisp: [Select]

1. (defun bizzFizz (lst / num)
2.   (setq num (car lst))
3.   (cond
4.     ((equal '() lst) nil)
5.     ((zerop (rem num 15)) (cons "FizzBuzz" (bizzFizz (cdr lst))))
6.     ((zerop (rem num 3)) (cons "Fizz" (bizzFizz (cdr lst))))
7.     ((zerop (rem num 5)) (cons "Buzz" (bizzFizz (cdr lst))))
8.     (T (cons num (bizzFizz (cdr lst))))
9.   )
10. )
11.  

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Jeff H on August 21, 2014, 08:35:56 PM

Speaking of which is there a 'endp' in AutoLisp or a predicate to test if a empty list?

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Keith™ on August 21, 2014, 08:56:37 PM

Here is a different approach

Code - Auto/Visual Lisp: [Select]

1. (defun fb (n)
2.   (nth (logior (min (rem n 3) 1) (lsh (min (rem n 5) 1) 1))
3.        (list "FizzBuzz" "Buzz" "Fizz" n)
4.   )
5. )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Kerry on August 21, 2014, 09:38:05 PM

Quote from: Jeff H on August 21, 2014, 08:35:56 PM

Speaking of which is there a 'endp' in AutoLisp or a predicate to test if a empty list?

Code - Auto/Visual Lisp: [Select]

1.  
2. (setq emptylist '())
3.  
4.  
5. (if (not emptylist)
6.   (alert "Blah\nBlah")
7. )
8. (if  emptylist
9.   (alert "Blah\nBlah\nBlah")
10.   ;;else
11.   (alert "The list empty list equates to nil")
12. )
13.  
14.  
15. (if (listp emptylist)
16.   (alert
17.     "Danger Will Robinson\nAn empty list is still a list\nIn fact, nil is a list ..."
18.   )
19. )
20.  
21. (if (listp nil)
22.   (alert "See ... ")
23. )
24.  

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Kerry on August 21, 2014, 10:37:55 PM

Bench the routines posted.

Code - Auto/Visual Lisp: [Select]

1. ;;;------------------------------------------------------------------
2. ;;;
3. (defun benchmark ;;=================================================================
4.                  ;;
5.                  ;;  Benchmark.lsp | © 2005 Michael Puckett | All Rights Reserved
6.                  ;;
7.                  ;; Mods by KWB 2005  Ordered with fastest as relative speed 1.00
8.                  ;;=================================================================
9.                  ;;
10.                  ;;  Purpose:
11.                  ;;
12.                  ;;      Compare the performance of various statements.
13.                  ;;
14.                  ;;  Notes:
15.                  ;;
16.                  ;;      I make no claims that this is definitive benchmarking. I
17.                  ;;      wrote this utility for my own purposes and thought I'd
18.                  ;;      share it. Many considerations go into evaluating the
19.                  ;;      performance or suitability of an algorythm for a given
20.                  ;;      task. Raw performance as profiled herein is just one.
21.                  ;;
22.                  ;;      Please note that background dramatically affect results.
23.                  ;;
24.                  ;;  Disclaimer:
25.                  ;;
26.                  ;;      This program is flawed in one or more ways and is not fit
27.                  ;;      for any particular purpose, stated or implied. Use at your
28.                  ;;      own risk.
29.                  ;;
30.                  ;;=================================================================
31.                  ;;
32.                  ;;  Syntax:
33.                  ;;
34.                  ;;      (Benchmark statements)
35.                  ;;
36.                  ;;          Where statements is a quoted list of statements.
37.                  ;;
38.                  ;;=================================================================
39.                  ;;
40.                  ;;  Example:
41.                  ;;
42.                  ;;      (BenchMark
43.                  ;;         '(
44.                  ;;              (1+ 1)
45.                  ;;              (+ 1 1)
46.                  ;;              (+ 1 1.0)
47.                  ;;              (+ 1.0 1.0)
48.                  ;;          )
49.                  ;;      )
50.                  ;;
51.                  ;;=================================================================
52.                  ;;
53.                  ;;  Output:
54.                  ;;
55.                  ;;      Elapsed milliseconds / relative speed for 32768 iteration(s):
56.                  ;;
57.                  ;;    (+ 1 1.0).......1452 / 1.1152 <slowest>
58.                  ;;    (+ 1.0 1.0).....1412 / 1.0845
59.                  ;;    (+ 1 1).........1332 / 1.023
60.                  ;;    (1+ 1)..........1302 / 1 <fastest>
61.                  ;;
62.                  ;; Mods by KWB 2005
63.                  ;;
64.                  ;;=================================================================
65.                  (statements / _lset _rset _tostring _eval _princ _main)
66.   ;;=================================================================
67.   ;;
68.   ;;  (_LSet text len fillChar)
69.   ;;
70.   ;;=================================================================
71.   (defun _lset (text len fillchar / padding result)
72.     (setq padding (list (ascii fillchar))
73.           result  (vl-string->list text)
74.     )
75.     (while (< (length (setq padding (append padding padding))) len))
76.     (while (< (length (setq result (append result padding))) len))
77.     (substr (vl-list->string result) 1 len)
78.   )
79.   ;;=================================================================
80.   ;;
81.   ;;  (_RSet text len fillChar)
82.   ;;
83.   ;;=================================================================
84.   (defun _rset (text len fillchar / padding result)
85.     (setq padding (list (ascii fillchar))
86.           result  (vl-string->list text)
87.     )
88.     (while (< (length (setq padding (append padding padding))) len))
89.     (while (< (length (setq result (append padding result))) len))
90.     (substr (vl-list->string result) (1+ (- (length result) len)))
91.   )
92.   ;;=================================================================
93.   ;;
94.   ;;  (_ToString x)
95.   ;;
96.   ;;=================================================================
97.   (defun _tostring (x / result)
98.     (if (< (strlen (setq result (vl-prin1-to-string x))) 40)
99.       result
100.       (strcat (substr result 1 36) "..." (chr 41))
101.     )
102.   )
103.   ;;=================================================================
104.   ;;
105.   ;;  (_Eval statement iterations)
106.   ;;
107.   ;;=================================================================
108.   (defun _eval (statement iterations / start)
109.     (gc)
110.     (setq start (getvar "millisecs"))
111.     (repeat iterations (eval statement))
112.     (- (getvar "millisecs") start)
113.   )
114.   ;;=================================================================
115.   ;;
116.   ;;  (_Princ x)
117.   ;;
118.   ;;=================================================================
119.   (defun _princ (x)
120.     (princ x)
121.     (princ)
122.     ;; forces screen update
123.   )
124.   ;;=================================================================
125.   ;;
126.   ;;  (_Main statements)
127.   ;;
128.   ;;=================================================================
129.   (defun _main (statements /
130.                 boundary   iterations
131.                 timings    slowest
132.                 fastest    lsetlen
133.                 rsetlen    index
134.                 count
135.                )
136.     (setq boundary 200                       ; 1000
137.           iterations 1
138.     )
139.     (_princ "Benchmarking [M.P. 2005 < revised kdub 2005>] ...")
140.     (while (or (< (apply 'max
141.                          (setq timings
142.                                 (mapcar '(lambda (statement) (_eval statement iterations))
143.                                         statements
144.                                 )
145.                          )
146.                   )
147.                   boundary
148.                )
149.                (< (apply 'min timings) boundary)
150.            )
151.       (setq iterations (* 2 iterations))
152.       (_princ ".")
153.     )
154.     (_princ (strcat "\nElapsed milliseconds for "
155.                     (itoa iterations)
156.                     " iteration(s)"
157.                     "/ relative Timing :\n\n"
158.             )
159.     )
160.     (setq slowest (float (apply 'max timings))
161.           fastest (float (apply 'min timings))
162.     )
163.     (setq lsetlen
164.            (+ 5
165.               (apply 'max
166.                      (mapcar 'strlen
167.                              (setq statements (mapcar '_tostring statements))
168.                      )
169.               )
170.            )
171.     )
172.     (setq
173.       rsetlen (apply 'max (mapcar '(lambda (ms) (strlen (itoa ms))) timings))
174.     )
175.     (setq index 0
176.           count (length statements)
177.     )
178.     (foreach pair (vl-sort (mapcar 'cons statements timings)
179.                            '(lambda (a b) (> (cdr a) (cdr b)))
180.                   )
181.       ((lambda (pair / ms)
182.          (_princ (strcat "    "
183.                          (_lset (car pair) lsetlen ".")
184.                          (_rset (itoa (setq ms (cdr pair))) rsetlen ".")
185.                          " / "
186.                          (rtos (/ ms fastest) 2 4)
187.                          (cond ((eq 1 (setq index (1+ index))) " <slowest>")
188.                                ((eq index count) " <fastest>")
189.                                ("")
190.                          )
191.                          "\n"
192.                  )
193.          )
194.        )
195.         pair
196.       )
197.     )
198.     (princ)
199.   )
200.   ;;=================================================================
201.   ;;
202.   ;;  Program is defined, let's rock and roll ...
203.   ;;
204.   ;;=================================================================
205.   (_main statements)
206. )
207.  
208.  

Code - Auto/Visual Lisp: [Select]

1. (setq FizzList '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30))
2.  
3.       (benchmark
4.         '((mapcar 'ronjonp:_fb fizzlist)
5.           (mapcar 'cab:fizzbuzz fizzlist)
6.           (mapcar 'ph:fb2 fizzlist)
7.           (mapcar 'ph:fb4 fizzlist)
8.           (mapcar 'ph:fb5 fizzlist)
9.           (mapcar 'fizzbuzz_a fizzlist)
10.           (mapcar 'fizzbuzz_a2 fizzlist)
11.           (mapcar 'kb:fizzbuzz fizzlist)
12.           (tharwat:fizzbuzz fizzlist)
13.           (mapcar 'lm:fizzbuzz1 fizzlist)
14.           (mapcar 'lm:fizzbuzz2 fizzlist)
15.           (jh:bizzfizz fizzlist)
16.           ;(* 1 1)
17.          )
18.       )
19.  
20.  

_1$
Benchmarking [M.P. 2005 < revised kdub 2005>] ...............
Elapsed milliseconds for 4096 iteration(s)/ relative Timing :

    (MAPCAR (QUOTE LM:FIZZBUZZ2) FIZZLIST).....780 / 3.8424 <slowest>
    (MAPCAR (QUOTE RONJONP:_FB) FIZZLIST)......546 / 2.6897
    (THARWAT:FIZZBUZZ FIZZLIST)................514 / 2.5320
    (MAPCAR (QUOTE CAB:FIZZBUZZ) FIZZLIST).....344 / 1.6946
    (JH:BIZZFIZZ FIZZLIST).....................328 / 1.6158
    (MAPCAR (QUOTE FIZZBUZZ_A) FIZZLIST).......297 / 1.4631
    (MAPCAR (QUOTE LM:FIZZBUZZ1) FIZZLIST).....297 / 1.4631
    (MAPCAR (QUOTE KB:FIZZBUZZ) FIZZLIST)......266 / 1.3103
    (MAPCAR (QUOTE PH:FB2) FIZZLIST)...........265 / 1.3054
    (MAPCAR (QUOTE PH:FB4) FIZZLIST)...........265 / 1.3054
    (MAPCAR (QUOTE FIZZBUZZ_A2) FIZZLIST)......249 / 1.2266
    (MAPCAR (QUOTE PH:FB5) FIZZLIST)...........203 / 1.0000 <fastest>

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Kerry on August 21, 2014, 10:51:25 PM

Stefan,
ph:FB5 is faster than I'd anticipated. I thought the nth would slow it down a little.
Well done !!

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Keith™ on August 21, 2014, 11:02:03 PM

I'd be interested to see how the various attempts benchmark when utilizing any two random divisors

Something like this:

Code - Auto/Visual Lisp: [Select]

1. (defun fb (n d1 d2)
2.   (nth (logior (min (rem n d1) 1) (lsh (min (rem n d2) 1) 1))
3.        (list "FizzBuzz" "Buzz" "Fizz" n)
4.   )
5. )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Kerry on August 22, 2014, 04:30:07 AM

Javascript in Chrome Console API

Code - Javascript: [Select]

1. for (i = 0; i < 30;)console.log((++i % 3 ? '' : 'Fizz') + (i % 5 ? '' : 'Buzz') || i)
2.  

Difficult to get it any tighter than this I think.

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Kerry on August 22, 2014, 04:51:18 AM

And some C# options
courtesy of stackoverflow :)

Code - C#: [Select]

1. using System;
2.  
3. namespace FizzyButt
4. {
5.     internal class Program
6.     {
7.         private static void Main(string[] args)
8.         {
9.             FizzyButt01();
10.             FizzyButt02();
11.         }
12.  
13.         public static void FizzyButt01()
14.         {
15.             for (int i = 1; i <= 30; i++)
16.             {
17.                 bool fizz = i%3 == 0;
18.                 bool buzz = i%5 == 0;
19.                 if (fizz && buzz) {Console.WriteLine("FizzBuzz");}
20.                 else if (fizz)    {Console.WriteLine("Fizz");}
21.                 else if (buzz)    {Console.WriteLine("Buzz");}
22.                 else              {Console.WriteLine(i);}
23.             }
24.         }
25.  
26.         public static void FizzyButt02()
27.         {
28.             for (int i = 1; i < 31; i++)
29.             {
30.                 Console.WriteLine(
31.                                   "{0:#;}{1:;;Fizz}{2:;;Buzz}",
32.                                   i%3*i%5 == 0 ? 0 : i,
33.                                   i%3,
34.                                   i%5);
35.             }
36.         }
37.     }
38. }
39.  

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Kerry on August 22, 2014, 05:17:06 AM

This will probably keep any propellerheads happy over the weekend :-D

http://rosettacode.org/wiki/FizzBuzz

//--------------------
piccy stolen from www.propellerhead.com.au

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Lee Mac on August 22, 2014, 05:20:41 AM

Powershell:

Code - PowerShell: [Select]

1. function fizzbuzz ( $n )
2. {      
3.     if (($f = ($n%3 -eq 0)) -and ($b = ($n%5 -eq 0))) { write-host 'FizzBuzz' }
4.     else
5.     {
6.         if ($f) { write-host 'Fizz' }
7.         else
8.         {
9.             if ($b) { write-host 'Buzz' }
10.             else
11.             {
12.                 write-host $n
13.             }
14.         }
15.     }
16. }
17.  
18. (1..30) | % {fizzbuzz $_}

EDIT: Oops - forget elseif was available in PowerShell :oops:

Though, the PowerShell code on Rosetta could be shortened slightly to:

Code - PowerShell: [Select]

1. 1..100 | % {
2.     if ($_ % 15 -eq 0) {
3.         "FizzBuzz"
4.     } elseif ($_ % 5 -eq 0) {
5.         "Buzz"
6.     } elseif ($_ % 3 -eq 0) {
7.         "Fizz"
8.     } else {
9.         $_
10.     }
11. }

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Lee Mac on August 22, 2014, 06:19:32 AM

Quote from: Stefan on August 21, 2014, 04:28:03 PM

Code - Auto/Visual Lisp: [Select]

1. (defun ph:FB5 (n)
2.   (cond
3.     ((nth (rem n 15) '("FizzBuzz" nil nil "Fizz" nil "Buzz" "Fizz" nil nil "Fizz" "Buzz" nil "Fizz" nil nil)))
4.     (n)
5.     )
6.   )

Another couple of variations of this method:

Code - Auto/Visual Lisp: [Select]

1. (defun fizzbuzz ( n )
2.     (cond ((nth (gcd n 15) '(nil nil nil "Fizz" nil "Buzz" nil nil nil nil nil nil nil nil nil "FizzBuzz"))) (n))
3. )

Code - Auto/Visual Lisp: [Select]

1. (defun fizzbuzz ( n )
2.     (nth (gcd n 15) (list nil n nil "Fizz" nil "Buzz" nil nil nil nil nil nil nil nil nil "FizzBuzz"))
3. )

Code - Auto/Visual Lisp: [Select]

1. (defun fizzbuzz ( n / g )
2.     (if (= 1 (setq g (gcd n 15))) n (nth (/ g 5) '("Fizz" "Buzz" nil "FizzBuzz")))
3. )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Stefan on August 22, 2014, 06:35:32 AM

Something stolen from rosettacode.org (the gcd thing)

Code - Auto/Visual Lisp: [Select]

1. (defun ph:fb8 (n / r)
2.   (cond
3.     ((=  3 (setq r (gcd 15 n))) "Fizz")
4.     ((=  5 r) "Buzz")
5.     ((= 15 r) "FizzBuzz")
6.     (n)
7.   )
8. )

And a variant

Code - Auto/Visual Lisp: [Select]

1. (defun ph:fb9 (n)
2.   (or *lst2* (setq *lst2* '((3 . "Fizz") (5 . "Buzz") (15 . "FizzBuzz"))))
3.   (cond
4.     ((cdr (assoc (gcd 15 n) *lst2*)))
5.     (n)
6.   )
7. )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Lee Mac on August 22, 2014, 11:50:28 AM

I considered using assoc, but thought it may be slow given the benchmark of my earlier function...  :|

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: pBe on August 23, 2014, 11:27:40 PM

a different approach to add to the table  ;D

Code: [Select]

(Defun _fizzybuzzy (n / _n n_ nl _3 _5)
  (setq   n_ n
   _n (vl-string->list (itoa n))
  )
  (Setq   _5 (or (= (setq nl (last _n)) 48)
          (= nl 53)
      )
  )
  (cond
    ((and (setq   _3 (= (Setq n
              (/ (apply '+ (mapcar '(lambda (m) (- m 48)) _n)) 3.0)
            )
            (fix n)
         )
     )
     _5
     )
     "FizzBuzz"
    )
    (_3 "Fizz")
    (_5 "Buzz")
    (T n_)
  )
)
EDIT: Bummer, there's something wrong with the Math.. hang on. editing.....

Code modified

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: gile on August 24, 2014, 05:52:23 AM

Hi,

My F# attempt (written before reading Kerry's link)

Code - F#: [Select]

1. let fizzBuzz n =
2.     match n % 3, n % 5 with
3.     | 0, 0 -> "FizzBuzz"
4.     | 0, _ -> "Fizz"
5.     | _, 0 -> "Buzz"
6.     | _ -> string n
7.    
8. [1 .. 30] |> List.map fizzBuzz

This is very closed to the following LISP code:

Code - Auto/Visual Lisp: [Select]

1. (defun fizzBuzz (n / l)
2.   (setq l (list (rem n 3) (rem n 5)))
3.   (cond
4.     ((equal l '(0 0)) "FizzBuzz")
5.     ((zerop (car l)) "Fizz")
6.     ((zerop (cadr l)) "Buzz")
7.     (T (itoa n))
8.   )
9. )
10.  
11. (mapcar 'fizzBuzz  '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30))

You can try the F# code in Try F# (http://www.tryfsharp.org/Create)

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Tharwat on August 24, 2014, 06:25:04 AM

This should be fast and unique  :-)

Code - Auto/Visual Lisp: [Select]

1. (defun FizzBuzz (l)
2.   (mapcar '(lambda (i)(if (zerop (rem i 15))    "FizzBuzz"
3.                         (if (zerop (rem i 5))   "Buzz"
4.                           (if (zerop (rem i 3)) "Fuzz"
5.                             i)
6.                           )
7.                         )
8.              )
9.           l
10.           )
11.   )
12.  

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: irneb on August 25, 2014, 05:00:37 AM

So far it seems as if everyone's is passing the test! Great one guys! The level of programming here is obviously "better" than some other places! https://news.ycombinator.com/item?id=3354027

Makes me weep for the "future" of programming! And probably understand why we get so many bugs in our programs.

Anyhoo ... my first "obvious" attempt (i.e. literally following the description of the question):

Code - Auto/Visual Lisp: [Select]

1. (defun IB:FizzBuzz (n)
2.   (cond ((= (rem n 3) (rem n 5) 0) "FizzBuzz")
3.         ((= (rem n 3) 0) "Fizz")
4.         ((= (rem n 5) 0) "Buzz")
5.         (n)))

Obviously very inefficient as it does at least 2 (on average nearly 4) division operations (which is one of the slowest CPU instructions you can give). I think that's why that benchmark shows such good results even for the nth version: nth is reasonably fast of short lists (which this definitely is).

So omitting one division (I think most of you got this one):

Code - Auto/Visual Lisp: [Select]

1. (defun IB:FizzBuzz0 (n)
2.   (cond ((= (rem n 15) 0) "FizzBuzz")
3.         ((= (rem n 3) 0) "Fizz")
4.         ((= (rem n 5) 0) "Buzz")
5.         (n)))

Trying to reduce on the number of divisions and using assoc instead of nth ... ehhh ... don't truly know which "should" be better

Code - Auto/Visual Lisp: [Select]

1. (defun IB:FizzBuzz1  (n)
2.   (cond ((cdr (assoc (rem n 15) '((0 . "FizzBuzz") (3 . "Fizz") (5 . "Buzz") (6 . "Fizz")
3.                                   (9 . "Fizz") (10 . "Buzz") (12 . "Fizz")))))
4.         (n)))

And then rather using member instead

Code - Auto/Visual Lisp: [Select]

1. (defun IB:FizzBuzz2 (n / r)
2.   (cond ((= (setq r (rem n 15)) 0) "FizzBuzz")
3.         ((member r '(3 6 9 12)) "Fizz")
4.         ((member r '(5 10)) "Buzz")
5.         (n)))

Of course the nth function would make it lots less circuitous. ... uh! ... scratch that my FizzBuzz3 is the exact same thing as ph:fb5 ... and I thought I got it so well!

I think none of mine is bringing anything "new" to the table. You guys already covered everything I had thought of myself, and then some!

Actually ... just though of another:

Code - Auto/Visual Lisp: [Select]

1. (defun IB:FizzBuzz4 (n / L)
2.   (if (setq L (vl-remove nil (mapcar '(lambda (d s) (cond ((= (rem n d) 0) s))) '(3 5) '("Fizz" "Buzz"))))
3.     (apply 'strcat L)
4.     n))

Sorry, it's probably been thought of by some of yourselves as well! Not that it's doing much different really - still performing 2 division operations and then all sorts of list manipulations, so speedwise I'd not hold my breath.

Anyhow, I've recently started looking into Haskell. Here's my first "very obvious" try (i.e. same as my FizzBuzz0 routine):

Code - Haskell: [Select]

1. fizzBuzz :: Integer -> String
2. fizzBuzz n | n `mod` 15 == 0 = "FizzBuzz"
3.            | n `mod` 5  == 0 = "Fizz"
4.            | n `mod` 3  == 0 = "Buzz"
5.            | otherwise       = show n

Well ... not "exactly" the same since Haskell is static typed it's a bit difficult making a list with a mix of ints and strings like the Lisp does. I'm probably just not knowledgeable enough yet to get to the point fo doing it "properly" idiomatically! Definitely not to the degree in rosetacode, actually it's "exactly" the same as the 1st one there  :-o! I actually like that lazy infinite list approach ... wonder if it would be much faster since it never uses any divisions.

That drives me to wish we had lazy eval in AutoLisp ... another thing ADesk removed from the XLisp core they stole. I suppose one could simulate it by using a cached list, but it would be much less than optimal as it would need to grow at the end (not at the front, so either lots of reverses or lots of appends). Not to mention it would start degrading on larger numbers due to nth being a bit slow when the list is long.

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Marc'Antonio Alessi on August 25, 2014, 05:08:40 AM

IMHO,
from my tests is the best version is Stefan's:

Code: [Select]

(defun ph:FB5 (n)
  (cond
    ( (nth (rem n 15) '("FizzBuzz" nil nil "Fizz" nil "Buzz" "Fizz" nil nil "Fizz" "Buzz" nil "Fizz" nil nil)))
       (n)
  )
)
originality 10
concision  10
speed      10

Last tests:

Code: [Select]

Benchmarking [M.P. 2005 < revised kdub 2005>] ...............
Elapsed milliseconds for 4096 iteration(s)/ relative Timing :

    (MAPCAR (QUOTE FIZZBUZZL2) FIZZLIST).....250 / 1.1416 <slowest>
    (MAPCAR (QUOTE FIZZBUZZL2) FIZZLIST).....250 / 1.1416
    (MAPCAR (QUOTE FIZZBUZZL2) FIZZLIST).....249 / 1.137
    (MAPCAR (QUOTE PH:FB5) FIZZLIST).........234 / 1.0685
    (MAPCAR (QUOTE PH:FB5) FIZZLIST).........234 / 1.0685
    (MAPCAR (QUOTE PH:FB5) FIZZLIST).........219 / 1 <fastest>

Code: [Select]

;Lee
 (defun fizzbuzzL2 ( n / g )
           (if (= 1 (setq g (gcd n 15))) n (nth (/ g 5) '("Fizz" "Buzz" nil "FizzBuzz")))
)

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Lee Mac on August 25, 2014, 05:47:43 AM

Quote from: irneb on August 25, 2014, 05:00:37 AM

The level of programming here is obviously "better" than some other places! https://news.ycombinator.com/item?id=3354027

 :-o

---

Great challenge Irné - although relatively simple, I've enjoyed this thread  :-)

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: irneb on August 25, 2014, 06:33:01 AM

Quote from: Marc'Antonio Alessi on August 25, 2014, 05:08:40 AM

IMHO,
from my tests is the best version is Stefan's:

Actually, it seems you're correct. I was hoping my IB:FizzBuzz1 would outperform it since it uses assoc instead of nth on the exact same algorithm. But from tests it seems to be about on par with each other (and as stated my IB:FizzBuzz3 is the exact same algorithm):

Code: [Select]

Benchmarking .................... done for 32768 iterations. Sorted from fastest.
Statement                                Increment  Time(ms) Normalize  Relative
--------------------------------------------------------------------------------
(MAPCAR (QUOTE IB:FIZZBUZZ3) FIZZLIST)       32768      1607      1607      1.00
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             32768      1654      1654      1.03
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)       32768      1716      1716      1.07
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)       32768      1919      1919      1.19
(MAPCAR (QUOTE PH:FB4) FIZZLIST)             32768      2012      2012      1.25
(MAPCAR (QUOTE PH:FB2) FIZZLIST)             32768      2043      2043      1.27
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)        16384      1030      2060      1.28
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)     16384      1030      2060      1.28
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)     16384      1045      2090      1.30
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)        16384      1185      2370      1.47
(MAPCAR (QUOTE MAA:FIZZBUZZ_A) FIZZL...)     16384      1202      2404      1.50
(MAPCAR (QUOTE IB:FIZZBUZZ2) FIZZLIST)       16384      1310      2620      1.63
(MAPCAR (QUOTE CAB:FIZZBUZZ) FIZZLIST)       16384      1326      2652      1.65
(JH:BIZZFIZZ FIZZLIST)                       16384      1341      2682      1.67
(MAPCAR (QUOTE KEITH:FB) FIZZLIST)           16384      1607      3214      2.00
(MAPCAR (QUOTE CHRISCARLSON:FIZZFUZZ...)     16384      1669      3338      2.08
(THARWAT:FIZZBUZZ FIZZLIST)                  16384      1966      3932      2.45
(MAPCAR (QUOTE RONJONP:_FB) FIZZLIST)         8192      1029      4116      2.56
(MAPCAR (QUOTE LM:FIZZBUZZ1) FIZZLIST)        8192      1576      6304      3.92
(MAPCAR (QUOTE IB:FIZZBUZZ4) FIZZLIST)        8192      6552     26208     16.31
--------------------------------------------------------------------------------What does surprise me though is how much slower the member version is (even in comparison to the "naive" IB:FizzBuzz and IB:FizzBuzz0. And as I expected that convoluted IB:FizzBuzz4 of mine is rather silly-slow!

Quote from: Lee Mac on August 25, 2014, 05:47:43 AM

Great challenge Irné - although relatively simple, I've enjoyed this thread  :-)

My pleasure! It's a very simplistic challenge, but I thought it might be good since there are so many ways to achieve it.

:-o It's scary if you see that something this simple is failed by 99% of programming job candidates (i.e. they're UNABLE to write even the naive one)! It's even more scary when you consider most of those guys have at least some accreditation for being "programmers" behind their names - ouch for the "level" of their teaching if this is the case!

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Marc'Antonio Alessi on August 25, 2014, 08:43:46 AM

as has been said many times it is not easy to test the speed,
better to exclude the slower  functions and do at least two tests:

Code: [Select]

Benchmarking .................... done for 32768 iterations. Sorted from fastest.
Statement                                Increment  Time(ms) Normalize  Relative
--------------------------------------------------------------------------------
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             32768      1904      1904      1.00
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)       16384      1030      2060      1.08
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)       16384      1107      2214      1.16
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)       16384      1154      2308      1.21
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)     16384      1186      2372      1.25
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)        16384      1232      2464      1.29
(MAPCAR (QUOTE PH:FB2) FIZZLIST)             16384      1232      2464      1.29
(MAPCAR (QUOTE PH:FB4) FIZZLIST)             16384      1248      2496      1.31
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)        16384      1373      2746      1.44
(MAPCAR (QUOTE PH:FB2) FIZZLIST)             16384      1514      3028      1.59
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)        16384      1544      3088      1.62
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)     16384      1638      3276      1.72
(MAPCAR (QUOTE PH:FB4) FIZZLIST)             16384      1731      3462      1.82
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)        16384      1904      3808      2.00
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)     16384      2028      4056      2.13
(MAPCAR (QUOTE PH:FB5) FIZZLIST)              8192      1077      4308      2.26
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)        8192      1124      4496      2.36
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)      8192      1154      4616      2.42
--------------------------------------------------------------------------------

Comando: (LOAD "E:/___DaSvuotare/FizzBuzz.LSP")
Benchmarking .................... done for 32768 iterations. Sorted from fastest.
Statement                                Increment  Time(ms) Normalize  Relative
--------------------------------------------------------------------------------
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             32768      1965      1965      1.06
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)       16384      1170      2340      1.26
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)     16384      1201      2402      1.29
(MAPCAR (QUOTE PH:FB4) FIZZLIST)             16384      1233      2466      1.33
(MAPCAR (QUOTE PH:FB2) FIZZLIST)             16384      1248      2496      1.34
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)        16384      1295      2590      1.39
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)       32768      2621      2621      1.41
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             16384      1373      2746      1.48
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)      8192      1030      4120      2.22
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)        8192      1046      4184      2.25
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)     16384      2153      4306      2.32
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)        16384      2231      4462      2.40
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)       16384      2434      4868      2.62
(MAPCAR (QUOTE PH:FB4) FIZZLIST)              8192      1372      5488      2.96
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)      8192      1373      5492      2.96
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)         8192      1513      6052      3.26
(MAPCAR (QUOTE PH:FB2) FIZZLIST)              8192      1513      6052      3.26
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)         8192      1560      6240      3.36
--------------------------------------------------------------------------------

Benchmarking ...... done for 32768 iterations. Sorted from fastest.
Statement                                Increment  Time(ms) Normalize  Relative
--------------------------------------------------------------------------------
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             32768      1903      1903      1.00
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)     16384      1186      2372      1.25
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)       16384      1201      2402      1.26
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)       16384      1263      2526      1.33
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             16384      1607      3214      1.69
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)     16384      1841      3682      1.93
--------------------------------------------------------------------------------

Benchmarking ...... done for 16384 iterations. Sorted from fastest.
Statement                                Increment  Time(ms) Normalize  Relative
--------------------------------------------------------------------------------
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)       16384      1388      1388      1.00
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             16384      1435      1435      1.03
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             16384      1529      1529      1.10
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)     16384      1591      1591      1.15
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)       16384      1716      1716      1.24
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)      8192      1060      2120      1.53
--------------------------------------------------------------------------------

Benchmarking ...... done for 32768 iterations. Sorted from fastest.
Statement                                Increment  Time(ms) Normalize  Relative
--------------------------------------------------------------------------------
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             32768      2013      2013      1.00
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)       16384      1108      2216      1.10
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)     16384      1186      2372      1.18
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             16384      1762      3524      1.75
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)      8192      1326      5304      2.63
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)        8192      1373      5492      2.73
--------------------------------------------------------------------------------

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: irneb on August 25, 2014, 08:55:11 AM

True! Benchmarking's not exactly a perfect idea anyway.

Anyhow, this C# version should probably do much faster as it uses the compiler's built-in hashmap for the switch statement: http://ideone.com/EDf0iZ

And of course the C version of the same is rather verbose in the extreme! http://ideone.com/5A7uUd

Just got a hell of a shock! Read the comments here: http://raganwald.com/2007/01/dont-overthink-fizzbuzz.html

Then go and try them out on http://ideone.com

Just look at how many of those guys give code which simply doesn't work!

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: irneb on August 25, 2014, 09:17:09 AM

Quote from: snownut2 on August 21, 2014, 03:25:43 PM

irne,

Why no negative or real numbers in the test list ?

That's because you then tend to get into a bit more "advanced" ideas which differ between languages, operators and functions. And that's not what the test is about, it's more about can you think about the logic of what needs to happen instead of the nuances for any detail involved.

E.g. you could obtain inaccurate results depending on the type of float the program uses - floating point division is rather inconsistent especially when using equality comparisons. Negatives are also a bit weird as some languages implement the modulo operator in a different way than others when it comes to negative numbers. Thus by enforcing only positive integers the test is much simplified and more consistent for any language, system, environment, etc.

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Lee Mac on August 25, 2014, 09:30:33 AM

FWIW, ph:FB5 could be made marginally more concise as the last two nils aren't required:

Code - Auto/Visual Lisp: [Select]

1. (defun ph:FB5 ( n )
2.     (cond ((nth (rem n 15) '("FizzBuzz" nil nil "Fizz" nil "Buzz" "Fizz" nil nil "Fizz" "Buzz" nil "Fizz"))) (n))
3. )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Marc'Antonio Alessi on August 25, 2014, 09:37:07 AM

True, how many things are not seen at first glance!
Thanks Lee.  8)

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ElpanovEvgeniy on August 25, 2014, 11:36:24 AM

my variant:

Code - Auto/Visual Lisp: [Select]

1. (defun eea (l)
2.   (if l
3.     (append (mapcar (function (lambda (a b)
4.                                 (cond (a)
5.                                       (b)
6.                                 )
7.                               )
8.                     )
9.                     '(nil nil "Fizz" nil "Buzz" "Fizz" nil nil "Fizz" "Buzz" nil "Fizz" nil nil "FizzBuzz")
10.                     l
11.             )
12.             (eea (cddddr (cddddr (cddddr (cdddr l)))))
13.     )
14.   )
15. )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Lee Mac on August 25, 2014, 12:21:15 PM

Oustanding as always Evgeniy  :coolsmiley:

Code - Auto/Visual Lisp: [Select]

1. _$ l
2. (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
3. _$ (benchmark '((eea l) (mapcar 'ph:fb5 l)))
4. Benchmarking .................Elapsed milliseconds / relative speed for 16384 iteration(s):
5.  
6.     (EEA L).......................1014 / 1.26 <fastest>
7.     (MAPCAR (QUOTE PH:FB5) L).....1279 / 1.00 <slowest>

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ElpanovEvgeniy on August 25, 2014, 01:22:53 PM

Thank you!
But my code is adapted to the current sort lists. :-(

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Lee Mac on August 25, 2014, 01:41:27 PM

Quote from: ElpanovEvgeniy on August 25, 2014, 01:22:53 PM

Thank you!
But my code is adapted to the current sort lists. :-(

Nevertheless, it meets the criteria set by the challenge  :-P

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Stefan on August 25, 2014, 03:29:07 PM

Quote from: Lee Mac on August 25, 2014, 01:41:27 PM

Nevertheless, it meets the criteria set by the challenge  :-P

eea takes a list as an argument; all others (with a few exceptions) takes an integer, as in OP. So you have comparing two different things.
Even so, try it on a larger list (say 1 ... 1000).

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ElpanovEvgeniy on August 27, 2014, 04:55:53 AM

my new version for a large list:

Code - Auto/Visual Lisp: [Select]

1. (defun eea1 (l / a)
2.   ;; for a large list
3.   (while l
4.     (setq a (cons (mapcar (function (lambda (a b)
5.                                       (cond (a)
6.                                             (b)
7.                                       )
8.                                     )
9.                           )
10.                           '(nil nil      "Fizz"   nil      "Buzz"   "Fizz"   nil      nil      "Fizz"   "Buzz"
11.                                 nil      "Fizz"   nil      nil      "FizzBuzz"        nil      nil      "Fizz"
12.                                 nil      "Buzz"   "Fizz"   nil      nil      "Fizz"   "Buzz"   nil      "Fizz"
13.                                 nil      nil      "FizzBuzz"
14.                                )
15.                           l
16.                   )
17.                   a
18.             )
19.           l (cddr (cddddr (cddddr (cddddr
20.                                       (cddddr (cddddr (cddddr (cddddr l))))))))
21.     )
22.   )
23.   (apply (function append) (reverse a))
24. )

test:

Code - Auto/Visual Lisp: [Select]

1. (defun eea (l)
2.   ;; for a small list
3.   (if l
4.     (append (mapcar (function (lambda (a b)
5.                                 (cond (a)
6.                                       (b)
7.                                 )
8.                               )
9.                     )
10.                     '(nil nil "Fizz" nil "Buzz" "Fizz" nil nil "Fizz" "Buzz" nil "Fizz" nil nil "FizzBuzz")
11.                     l
12.             )
13.             (eea (cddddr (cddddr (cddddr (cdddr l)))))
14.     )
15.   )
16. )
17. (defun eea1 (l / a)
18.   ;; for a large list
19.   (while l
20.     (setq a (cons (mapcar (function (lambda (a b)
21.                                       (cond (a)
22.                                             (b)
23.                                       )
24.                                     )
25.                           )
26.                           '(nil nil      "Fizz"   nil      "Buzz"   "Fizz"   nil      nil      "Fizz"   "Buzz"
27.                                 nil      "Fizz"   nil      nil      "FizzBuzz"        nil      nil      "Fizz"
28.                                 nil      "Buzz"   "Fizz"   nil      nil      "Fizz"   "Buzz"   nil      "Fizz"
29.                                 nil      nil      "FizzBuzz"
30.                                )
31.                           l
32.                   )
33.                   a
34.             )
35.           l (cddr (cddddr (cddddr (cddddr
36.                                       (cddddr (cddddr (cddddr (cddddr l))))))))
37.     )
38.   )
39.   (apply (function append) (reverse a))
40. )
41. (defun ph:FB5 (n)
42.   (cond ((nth (rem n 15)
43.               '("FizzBuzz" nil nil "Fizz" nil "Buzz" "Fizz" nil nil "Fizz" "Buzz" nil "Fizz" nil nil)
44.          )
45.         )
46.         (n)
47.   )
48. )
49. (defun c:test (/ l)
50.   (foreach i '(30 300 3000)
51.     (princ (strcat "\n\nList length " (itoa i) "\n"))
52.     (setq l nil)
53.     (repeat i
54.       (setq l (cons i l)
55.             i (1- i)
56.       )
57.     )
58.     (benchmark '((mapcar (function ph:fb5) l) (eea l) (eea1 l)))
59.   )
60.   (princ)
61. )

result:

Code: [Select]

List length 30
Elapsed milliseconds / relative speed for 65536 iteration(s):

    (EEA1 L).........................1997 / 1.23 <fastest>
    (EEA L)..........................2106 / 1.16
    (MAPCAR (FUNCTION PH:FB5) L).....2449 / 1 <slowest>


List length 300
Elapsed milliseconds / relative speed for 8192 iteration(s):

    (EEA1 L).........................1451 / 2.57 <fastest>
    (MAPCAR (FUNCTION PH:FB5) L).....1840 / 2.03
    (EEA L)..........................3729 / 1 <slowest>


List length 3000
Elapsed milliseconds / relative speed for 1024 iteration(s):

    (EEA1 L)..........................1607 / 14.35 <fastest>
    (MAPCAR (FUNCTION PH:FB5) L)......2075 / 11.11
    (EEA L)..........................23057 / 1 <slowest>


Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ElpanovEvgeniy on August 27, 2014, 06:03:21 AM

whole the test:

Code: [Select]

Command: TEST

List length 30
Elapsed milliseconds / relative speed for 32768 iteration(s):

    (EEA1 L).....................................1108 / 7.62 <fastest>
    (EEA L)......................................1154 / 7.31
    (MAPCAR (QUOTE PH:FB5) L)....................1279 / 6.6
    (MAPCAR (QUOTE IB:FIZZBUZZ3) L)..............1310 / 6.44
    (MAPCAR (QUOTE MAA:FIZZBUZZ_A2) L)...........1684 / 5.01
    (MAPCAR (QUOTE PH:FB2) L)....................1825 / 4.62
    (MAPCAR (QUOTE PH:FB4) L)....................1841 / 4.58
    (MAPCAR (QUOTE KERRY:FIZZBUZZ) L)............1904 / 4.43
    (MAPCAR (QUOTE MAA:FIZZBUZZ_A) L)............1981 / 4.26
    (MAPCAR (QUOTE LM:FIZZBUZZ) L)...............2043 / 4.13
    (MAPCAR (QUOTE IB:FIZZBUZZ2) L)..............2137 / 3.95
    (MAPCAR (QUOTE CAB:FIZZBUZZ) L)..............2372 / 3.56
    (MAPCAR (QUOTE IB:FIZZBUZZ1) L)..............2606 / 3.24
    (MAPCAR (QUOTE IB:FIZZBUZZ0) L)..............2714 / 3.11
    (JH:BIZZFIZZ L)..............................2808 / 3.01
    (MAPCAR (QUOTE IB:FIZZBUZZ) L)...............2917 / 2.89
    (MAPCAR (QUOTE CHRISCARLSON:FIZZFUZZ...).....3073 / 2.75
    (MAPCAR (QUOTE KEITH:FB) L)..................3307 / 2.55
    (THARWAT:FIZZBUZZ L).........................3588 / 2.35
    (MAPCAR (QUOTE RONJONP:_FB) L)...............3744 / 2.25
    (MAPCAR (QUOTE LM:FIZZBUZZ1) L)..............6162 / 1.37
    (MAPCAR (QUOTE IB:FIZZBUZZ4) L)..............8440 / 1 <slowest>


List length 300
Elapsed milliseconds / relative speed for 8192 iteration(s):

    (EEA1 L)......................................1560 / 12.68 <fastest>
    (MAPCAR (QUOTE PH:FB5) L).....................1887 / 10.48
    (MAPCAR (QUOTE IB:FIZZBUZZ3) L)...............1903 / 10.39
    (MAPCAR (QUOTE IB:FIZZBUZZ1) L)...............2324 / 8.51
    (MAPCAR (QUOTE IB:FIZZBUZZ0) L)...............2808 / 7.04
    (MAPCAR (QUOTE MAA:FIZZBUZZ_A2) L)............2964 / 6.67
    (MAPCAR (QUOTE IB:FIZZBUZZ) L)................3245 / 6.1
    (MAPCAR (QUOTE PH:FB2) L).....................3260 / 6.07
    (MAPCAR (QUOTE PH:FB4) L).....................3323 / 5.95
    (MAPCAR (QUOTE KERRY:FIZZBUZZ) L).............3323 / 5.95
    (MAPCAR (QUOTE MAA:FIZZBUZZ_A) L).............3635 / 5.44
    (MAPCAR (QUOTE LM:FIZZBUZZ) L)................3775 / 5.24
    (MAPCAR (QUOTE IB:FIZZBUZZ2) L)...............3931 / 5.03
    (EEA L).......................................3978 / 4.97
    (JH:BIZZFIZZ L)...............................4540 / 4.36
    (MAPCAR (QUOTE CAB:FIZZBUZZ) L)...............4587 / 4.31
    (MAPCAR (QUOTE CHRISCARLSON:FIZZFUZZ...)......6349 / 3.12
    (THARWAT:FIZZBUZZ L)..........................6817 / 2.9
    (MAPCAR (QUOTE KEITH:FB) L)...................6942 / 2.85
    (MAPCAR (QUOTE RONJONP:_FB) L)................7972 / 2.48
    (MAPCAR (QUOTE LM:FIZZBUZZ1) L)..............15663 / 1.26
    (MAPCAR (QUOTE IB:FIZZBUZZ4) L)..............19781 / 1 <slowest>


List length 3000
Elapsed milliseconds / relative speed for 1024 iteration(s):

    (EEA1 L)......................................1701 / 14.19 <fastest>
    (MAPCAR (QUOTE IB:FIZZBUZZ3) L)...............2121 / 11.38
    (MAPCAR (QUOTE PH:FB5) L).....................2137 / 11.29
    (MAPCAR (QUOTE IB:FIZZBUZZ1) L)...............2668 / 9.05
    (MAPCAR (QUOTE IB:FIZZBUZZ0) L)...............3276 / 7.37
    (MAPCAR (QUOTE MAA:FIZZBUZZ_A2) L)............3432 / 7.03
    (MAPCAR (QUOTE PH:FB2) L).....................3853 / 6.26
    (MAPCAR (QUOTE IB:FIZZBUZZ) L)................3854 / 6.26
    (MAPCAR (QUOTE KERRY:FIZZBUZZ) L).............3915 / 6.16
    (MAPCAR (QUOTE PH:FB4) L).....................3916 / 6.16
    (MAPCAR (QUOTE MAA:FIZZBUZZ_A) L).............4353 / 5.54
    (MAPCAR (QUOTE LM:FIZZBUZZ) L)................4446 / 5.43
    (MAPCAR (QUOTE IB:FIZZBUZZ2) L)...............4649 / 5.19
    (MAPCAR (QUOTE CAB:FIZZBUZZ) L)...............5491 / 4.4
    (JH:BIZZFIZZ L)...............................5522 / 4.37
    (MAPCAR (QUOTE CHRISCARLSON:FIZZFUZZ...)......7800 / 3.09
    (MAPCAR (QUOTE KEITH:FB) L)...................7862 / 3.07
    (THARWAT:FIZZBUZZ L)..........................8362 / 2.89
    (MAPCAR (QUOTE RONJONP:_FB) L)................9719 / 2.48
    (MAPCAR (QUOTE LM:FIZZBUZZ1) L)..............18845 / 1.28
    (MAPCAR (QUOTE IB:FIZZBUZZ4) L)..............24071 / 1
    (EEA L)......................................24134 / 1 <slowest>

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ElpanovEvgeniy on August 27, 2014, 07:01:42 AM

test code  :-)

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: Kerry on August 27, 2014, 07:35:33 AM

Evgeniy,

The specification was to pass a number, not a list.

and I think your routine will fail if the list is anything other than a sequential list of numbers starting at 1.

... the function should return the correct results if called as :

Code - Auto/Visual Lisp: [Select]

1. (mapcar 'FizzBuzz '(3 2 1 300 1500 120 42 50)

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: irneb on August 27, 2014, 09:18:21 AM

While strictly speaking Kerry is correct if read to my OP, I feel ElpanovEvgeniy's code is acceptable in the spirit of the test. Especially since it works for most the original wordings when it is stated as a programming test:

"An algorithm to print the 1st 100 positive integers replacing each divisible by 3 with Fizz, each divisible by 5 by Buzz and each divisible by both 3 and 5 by FizzBuzz".

It doesn't state what inputs, though the understanding is that it has no inputs. Most solutions are not even using a function, but rather just looping inside the main program entry-point.

Anyhow, my OP was more intended to show a function which acts like a player in the FizzBuzz game: http://en.wikipedia.org/wiki/Fizz_buzz

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: pBe on August 28, 2014, 02:26:50 AM

Nice challenge Irné , Couldn't have chosen a better place to post it.

BTW: the code i posted trumps anyone else's in terms of speed  :lmao:

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: irneb on August 28, 2014, 05:49:09 AM

Quote from: pBe on August 28, 2014, 02:26:50 AM

Nice challenge Irné , Couldn't have chosen a better place to post it.

Don't I know it! The level of abilities here at the swamp is way higher than in some other places!

Anyhow trying the imperative version of eea ... I thought using append might degrade performance, but it seems not too bad:

Code - Auto/Visual Lisp: [Select]

1. (defun IB:FizzBuzzList  (L / band result)
2.   (setq band '(nil nil "Fizz" nil "Buzz" "Fizz" nil nil "Fizz" "Buzz" nil "Fizz" nil nil "FizzBuzz"))
3.   (while L
4.     (setq result (append result (mapcar (function (lambda (a b) (cond (a) (b)))) band L))
5.           L (cddddr (cddddr (cddddr (cdddr L))))))
6.   result)

Of course benchmarking only the calculation ... not benchmarking the generation of the list from 1 to N (which is unnecessary for the other functions) might skew it to eea and mine. And it does seem to be the case (as I'd expect).

Code: [Select]

Benchmarking on numbers from 1 to 30.
Benchmarking ............................................ done for 16384 iterations. Sorted from fastest.
Statement                                Increment  Time(ms) Normalize  Relative
--------------------------------------------------------------------------------
(MAPCAR (QUOTE IB:FIZZBUZZ3) FIZZLIST)       16384      1918      1918      1.00
(IB:FIZZBUZZLIST FIZZLIST)                   16384      1919      1919      1.00
(EEA FIZZLIST)                               16384      1919      1919      1.00
(EEA FIZZLIST)                               16384      1935      1935      1.01
(MAPCAR (QUOTE IB:FIZZBUZZ3) FIZZLIST)       16384      1950      1950      1.02
(IB:FIZZBUZZLIST FIZZLIST)                   16384      1966      1966      1.03
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             16384      1982      1982      1.03
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)        8192      1014      2028      1.06
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             16384      2028      2028      1.06
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)        8192      1045      2090      1.09
(MAPCAR (QUOTE PH:FB2) FIZZLIST)              8192      1139      2278      1.19
(MAPCAR (QUOTE PH:FB2) FIZZLIST)              8192      1170      2340      1.22
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)        8192      1232      2464      1.28
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)        8192      1232      2464      1.28
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)      8192      1264      2528      1.32
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)      8192      1264      2528      1.32
(MAPCAR (QUOTE PH:FB4) FIZZLIST)              8192      1279      2558      1.33
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)      8192      1294      2588      1.35
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)         8192      1295      2590      1.35
(MAPCAR (QUOTE PH:FB4) FIZZLIST)              8192      1295      2590      1.35
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)         8192      1326      2652      1.38
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)      8192      1326      2652      1.38
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)         8192      1373      2746      1.43
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)         8192      1389      2778      1.45
(MAPCAR (QUOTE IB:FIZZBUZZ2) FIZZLIST)        8192      1419      2838      1.48
(MAPCAR (QUOTE IB:FIZZBUZZ2) FIZZLIST)        8192      1436      2872      1.50
(JH:BIZZFIZZ FIZZLIST)                        8192      1513      3026      1.58
(MAPCAR (QUOTE KEITH:FB) FIZZLIST)            8192      1513      3026      1.58
(MAPCAR (QUOTE MAA:FIZZBUZZ_A) FIZZL...)      8192      1529      3058      1.59
(JH:BIZZFIZZ FIZZLIST)                        8192      1544      3088      1.61
(MAPCAR (QUOTE KEITH:FB) FIZZLIST)            8192      1575      3150      1.64
(MAPCAR (QUOTE MAA:FIZZBUZZ_A) FIZZL...)      8192      1622      3244      1.69
(MAPCAR (QUOTE CAB:FIZZBUZZ) FIZZLIST)        8192      1654      3308      1.72
(MAPCAR (QUOTE CAB:FIZZBUZZ) FIZZLIST)        8192      1716      3432      1.79
(MAPCAR (QUOTE CHRISCARLSON:FIZZFUZZ...)      8192      1950      3900      2.03
(THARWAT:FIZZBUZZ FIZZLIST)                   8192      1965      3930      2.05
(MAPCAR (QUOTE CHRISCARLSON:FIZZFUZZ...)      4096      1014      4056      2.11
(THARWAT:FIZZBUZZ FIZZLIST)                   4096      1030      4120      2.15
(MAPCAR (QUOTE RONJONP:_FB) FIZZLIST)         4096      1123      4492      2.34
(MAPCAR (QUOTE RONJONP:_FB) FIZZLIST)         4096      1124      4496      2.34
(MAPCAR (QUOTE LM:FIZZBUZZ1) FIZZLIST)        2048      1670     13360      6.97
(MAPCAR (QUOTE LM:FIZZBUZZ1) FIZZLIST)        2048      1716     13728      7.16
(MAPCAR (QUOTE IB:FIZZBUZZ4) FIZZLIST)        1024      1154     18464      9.63
(MAPCAR (QUOTE IB:FIZZBUZZ4) FIZZLIST)        1024      1185     18960      9.89
--------------------------------------------------------------------------------
But it seems that both eea and my imperative alternative perform a bit better on the 1st 100 integers.

Code: [Select]

Benchmarking on numbers from 1 to 100.
Benchmarking ............................................ done for 16384 iterations. Sorted from fastest.
Statement                                Increment  Time(ms) Normalize  Relative
--------------------------------------------------------------------------------
(EEA FIZZLIST)                               16384      1576      1576      1.00
(EEA FIZZLIST)                               16384      1591      1591      1.01
(IB:FIZZBUZZLIST FIZZLIST)                   16384      1623      1623      1.03
(IB:FIZZBUZZLIST FIZZLIST)                   16384      1623      1623      1.03
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             16384      1763      1763      1.12
(MAPCAR (QUOTE PH:FB5) FIZZLIST)             16384      1763      1763      1.12
(MAPCAR (QUOTE IB:FIZZBUZZ3) FIZZLIST)       16384      1779      1779      1.13
(MAPCAR (QUOTE IB:FIZZBUZZ3) FIZZLIST)       16384      1779      1779      1.13
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)       16384      1966      1966      1.25
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)       16384      1981      1981      1.26
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)        8192      1139      2278      1.45
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)        8192      1139      2278      1.45
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)         8192      1264      2528      1.60
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)         8192      1264      2528      1.60
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)      8192      1279      2558      1.62
(MAPCAR (QUOTE PH:FB4) FIZZLIST)              8192      1279      2558      1.62
(MAPCAR (QUOTE PH:FB2) FIZZLIST)              8192      1279      2558      1.62
(MAPCAR (QUOTE PH:FB2) FIZZLIST)              8192      1279      2558      1.62
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)      8192      1280      2560      1.62
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)      8192      1280      2560      1.62
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)      8192      1295      2590      1.64
(MAPCAR (QUOTE PH:FB4) FIZZLIST)              8192      1295      2590      1.64
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)         8192      1544      3088      1.96
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)         8192      1545      3090      1.96
(MAPCAR (QUOTE MAA:FIZZBUZZ_A) FIZZL...)      8192      1575      3150      2.00
(MAPCAR (QUOTE MAA:FIZZBUZZ_A) FIZZL...)      8192      1591      3182      2.02
(MAPCAR (QUOTE IB:FIZZBUZZ2) FIZZLIST)        8192      1701      3402      2.16
(MAPCAR (QUOTE IB:FIZZBUZZ2) FIZZLIST)        8192      1716      3432      2.18
(MAPCAR (QUOTE CAB:FIZZBUZZ) FIZZLIST)        8192      1794      3588      2.28
(JH:BIZZFIZZ FIZZLIST)                        8192      1825      3650      2.32
(JH:BIZZFIZZ FIZZLIST)                        8192      1825      3650      2.32
(MAPCAR (QUOTE CAB:FIZZBUZZ) FIZZLIST)        8192      1841      3682      2.34
(MAPCAR (QUOTE KEITH:FB) FIZZLIST)            4096      1092      4368      2.77
(MAPCAR (QUOTE KEITH:FB) FIZZLIST)            4096      1092      4368      2.77
(MAPCAR (QUOTE CHRISCARLSON:FIZZFUZZ...)      4096      1202      4808      3.05
(THARWAT:FIZZBUZZ FIZZLIST)                   4096      1388      5552      3.52
(THARWAT:FIZZBUZZ FIZZLIST)                   4096      1388      5552      3.52
(MAPCAR (QUOTE RONJONP:_FB) FIZZLIST)         4096      1529      6116      3.88
(MAPCAR (QUOTE CHRISCARLSON:FIZZFUZZ...)      4096      2247      8988      5.70
(MAPCAR (QUOTE RONJONP:_FB) FIZZLIST)         2048      1170      9360      5.94
(MAPCAR (QUOTE LM:FIZZBUZZ1) FIZZLIST)        2048      1201      9608      6.10
(MAPCAR (QUOTE LM:FIZZBUZZ1) FIZZLIST)        2048      1217      9736      6.18
(MAPCAR (QUOTE IB:FIZZBUZZ4) FIZZLIST)        2048      1560     12480      7.92
(MAPCAR (QUOTE IB:FIZZBUZZ4) FIZZLIST)        2048      1560     12480      7.92
--------------------------------------------------------------------------------
Though my guess is that on larger lists it might go another way

Code: [Select]

Benchmarking on numbers from 1 to 1000.
Benchmarking ............................................ done for 1024 iterations. Sorted from fastest.
Statement                                Increment  Time(ms) Normalize  Relative
--------------------------------------------------------------------------------
(MAPCAR (QUOTE IB:FIZZBUZZ3) FIZZLIST)        1024      1825      1825      1.00
(MAPCAR (QUOTE PH:FB5) FIZZLIST)              1024      1841      1841      1.01
(MAPCAR (QUOTE PH:FB5) FIZZLIST)              1024      1841      1841      1.01
(MAPCAR (QUOTE IB:FIZZBUZZ3) FIZZLIST)        1024      1857      1857      1.02
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)         512      1029      2058      1.13
(MAPCAR (QUOTE IB:FIZZBUZZ1) FIZZLIST)         512      1030      2060      1.13
(MAPCAR (QUOTE PH:FB2) FIZZLIST)               512      1264      2528      1.39
(MAPCAR (QUOTE PH:FB2) FIZZLIST)               512      1264      2528      1.39
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)         512      1466      2932      1.61
(MAPCAR (QUOTE IB:FIZZBUZZ0) FIZZLIST)         512      1467      2934      1.61
(MAPCAR (QUOTE PH:FB4) FIZZLIST)               512      1529      3058      1.68
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)       512      1544      3088      1.69
(MAPCAR (QUOTE KERRY:FIZZBUZZ) FIZZL...)       512      1560      3120      1.71
(MAPCAR (QUOTE PH:FB4) FIZZLIST)               512      1576      3152      1.73
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)       512      1638      3276      1.80
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)          512      1638      3276      1.80
(MAPCAR (QUOTE MAA:FIZZBUZZ_A2) FIZZ...)       512      1654      3308      1.81
(MAPCAR (QUOTE IB:FIZZBUZZ) FIZZLIST)          512      1669      3338      1.83
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)          512      1778      3556      1.95
(MAPCAR (QUOTE LM:FIZZBUZZ) FIZZLIST)          512      1778      3556      1.95
(MAPCAR (QUOTE IB:FIZZBUZZ2) FIZZLIST)         512      1856      3712      2.03
(MAPCAR (QUOTE IB:FIZZBUZZ2) FIZZLIST)         512      1887      3774      2.07
(MAPCAR (QUOTE MAA:FIZZBUZZ_A) FIZZL...)       256      1014      4056      2.22
(MAPCAR (QUOTE MAA:FIZZBUZZ_A) FIZZL...)       512      2044      4088      2.24
(MAPCAR (QUOTE KEITH:FB) FIZZLIST)             256      1045      4180      2.29
(MAPCAR (QUOTE KEITH:FB) FIZZLIST)             256      1045      4180      2.29
(MAPCAR (QUOTE CAB:FIZZBUZZ) FIZZLIST)         256      1123      4492      2.46
(MAPCAR (QUOTE CAB:FIZZBUZZ) FIZZLIST)         256      1154      4616      2.53
(JH:BIZZFIZZ FIZZLIST)                         256      1217      4868      2.67
(JH:BIZZFIZZ FIZZLIST)                         256      1232      4928      2.70
(EEA FIZZLIST)                                 256      1264      5056      2.77
(EEA FIZZLIST)                                 256      1264      5056      2.77
(IB:FIZZBUZZLIST FIZZLIST)                     256      1294      5176      2.84
(IB:FIZZBUZZLIST FIZZLIST)                     256      1310      5240      2.87
(MAPCAR (QUOTE CHRISCARLSON:FIZZFUZZ...)       256      1482      5928      3.25
(MAPCAR (QUOTE CHRISCARLSON:FIZZFUZZ...)       256      1513      6052      3.32
(THARWAT:FIZZBUZZ FIZZLIST)                    256      1685      6740      3.69
(THARWAT:FIZZBUZZ FIZZLIST)                    256      1685      6740      3.69
(MAPCAR (QUOTE RONJONP:_FB) FIZZLIST)          256      1732      6928      3.80
(MAPCAR (QUOTE RONJONP:_FB) FIZZLIST)          256      1747      6988      3.83
(MAPCAR (QUOTE LM:FIZZBUZZ1) FIZZLIST)          64      1622     25952     14.22
(MAPCAR (QUOTE LM:FIZZBUZZ1) FIZZLIST)          64      1653     26448     14.49
(MAPCAR (QUOTE IB:FIZZBUZZ4) FIZZLIST)          32      1138     36416     19.95
(MAPCAR (QUOTE IB:FIZZBUZZ4) FIZZLIST)          32      1139     36448     19.97
--------------------------------------------------------------------------------Not tested eea1 yet ... will do in due course.

Anyhow, here's my helper functions to perform the test.

Code - Auto/Visual Lisp: [Select]

1. (defun Make-FizzBuzz-Result-List (size / result)
2.   (repeat size
3.     (setq result (cons (cond ((= (rem size 15) 0) "FizzBuzz")
4.                              ((= (rem size 5) 0) "Buzz")
5.                              ((= (rem size 3) 0) "Fizz")
6.                              (size))
7.                        result)
8.           size (1- size)))
9.   result)
10.  
11. (defun range (from to / result)
12.   (while (>= to from)
13.     (setq result (cons to result)
14.           to (1- to)))
15.   result)
16.  
17. (defun string-space  (str1 str2 fill len / s)
18.   (setq s   str1
19.         len (- len (strlen str2)))
20.   (while (< (strlen s) len) (setq s (strcat s fill)))
21.   (strcat s str2))
22.  
23. (defun test-fizzbuzz-map-show  (func size)
24.   (print (vl-symbol-name func))
25.   (setq func (eval func))
26.   (vl-every '(lambda (n m) (print (cons (setq n (func n)) m)) (equal n m))
27.             (range 1 size)
28.             (Make-FizzBuzz-Result-List size)))
29.  
30. (defun test-fizzbuzz-map  (func size)
31.   (string-space
32.     (vl-symbol-name func)
33.     (if (vl-every '(lambda (n m) (equal ((eval func) n) m)) (range 1 size)
34.                   (Make-FizzBuzz-Result-List size))
35.       "Pass"
36.       "Fail")
37.     "."
38.     60))
39.  
40. (defun test-fizzbuzz-list-show  (func size)
41.   (print (vl-symbol-name func))
42.   (setq func (eval func))
43.   (vl-every '(lambda (n m) (print (cons n m)) (equal n m))
44.             (Make-FizzBuzz-Result-List size)
45.             (func (range 1 size))))
46.  
47. (defun test-fizzbuzz-list  (func size)
48.   (string-space
49.     (vl-symbol-name func)
50.     (cond ((equal ((eval func) (range 1 size)) (Make-FizzBuzz-Result-List size)) "Pass")
51.           (t "Fail"))
52.     "."
53.     60))
54.  
55. (defun test-fizzbuzz  (size)
56.   (foreach func  '(ChrisCarlson:FizzFuzzBuzz             ronjonp:_fb        CAB:FizzBuzz       ph:FB2
57.                    ph:FB4             ph:FB5             MAA:FizzBuzz_A     MAA:FizzBuzz_A2    Kerry:FizzBuzz
58.                    LM:fizzbuzz        LM:fizzbuzz1       Keith:fb           IB:FizzBuzz        IB:FizzBuzz0
59.                    IB:FizzBuzz1       IB:FizzBuzz2       IB:FizzBuzz3       IB:FizzBuzz4)
60.     (print (test-fizzbuzz-map func size)))
61.   (foreach func '(Tharwat:FizzBuzz JH:bizzFizz eea IB:FizzBuzzList IB:FizzBuzzList1)
62.     (print (test-fizzbuzz-list func size)))
63.   (princ))
64.  
65. (defun bench-fizzbuzz  (size / fizzlist)
66.   (setq fizzlist (range 1 size))
67.   (princ "Benchmarking on numbers from 1 to ")
68.   (princ size)
69.   (princ ".\n")
70.   (QBench '((mapcar 'ChrisCarlson:FizzFuzzBuzz fizzlist)
71.             (mapcar 'ronjonp:_fb fizzlist)
72.             (mapcar 'CAB:FizzBuzz fizzlist)
73.             (mapcar 'ph:FB2 fizzlist)
74.             (mapcar 'ph:FB4 fizzlist)
75.             (mapcar 'ph:FB5 fizzlist)
76.             (mapcar 'MAA:FizzBuzz_A fizzlist)
77.             (mapcar 'MAA:FizzBuzz_A2 fizzlist)
78.             (mapcar 'Kerry:FizzBuzz fizzlist)
79.             (mapcar 'LM:fizzbuzz fizzlist)
80.             (mapcar 'LM:fizzbuzz1 fizzlist)
81.             (mapcar 'Keith:fb fizzlist)
82.             (Tharwat:FizzBuzz fizzlist)
83.             (JH:bizzFizz fizzlist)
84.             (eea fizzlist)
85.             (mapcar 'IB:FizzBuzz fizzlist)
86.             (mapcar 'IB:FizzBuzz0 fizzlist)
87.             (mapcar 'IB:FizzBuzz1 fizzlist)
88.             (mapcar 'IB:FizzBuzz2 fizzlist)
89.             (mapcar 'IB:FizzBuzz3 fizzlist)
90.             (mapcar 'IB:FizzBuzz4 fizzlist)
91.             (IB:FizzBuzzList fizzlist)
92.             (mapcar 'ChrisCarlson:FizzFuzzBuzz fizzlist)
93.             (mapcar 'ronjonp:_fb fizzlist)
94.             (mapcar 'CAB:FizzBuzz fizzlist)
95.             (mapcar 'ph:FB2 fizzlist)
96.             (mapcar 'ph:FB4 fizzlist)
97.             (mapcar 'ph:FB5 fizzlist)
98.             (mapcar 'MAA:FizzBuzz_A fizzlist)
99.             (mapcar 'MAA:FizzBuzz_A2 fizzlist)
100.             (mapcar 'Kerry:FizzBuzz fizzlist)
101.             (mapcar 'LM:fizzbuzz fizzlist)
102.             (mapcar 'LM:fizzbuzz1 fizzlist)
103.             (mapcar 'Keith:fb fizzlist)
104.             (Tharwat:FizzBuzz fizzlist)
105.             (JH:bizzFizz fizzlist)
106.             (eea fizzlist)
107.             (mapcar 'IB:FizzBuzz fizzlist)
108.             (mapcar 'IB:FizzBuzz0 fizzlist)
109.             (mapcar 'IB:FizzBuzz1 fizzlist)
110.             (mapcar 'IB:FizzBuzz2 fizzlist)
111.             (mapcar 'IB:FizzBuzz3 fizzlist)
112.             (mapcar 'IB:FizzBuzz4 fizzlist)
113.             (IB:FizzBuzzList fizzlist)))
114.   (princ))

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ur_naz on August 28, 2014, 12:19:28 PM

The main problem of eea1 function is that it must accept the list with zero in the head. in other case it returns wrong result. but the task says clearly about positive value to accept :-P

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ElpanovEvgeniy on August 29, 2014, 05:03:04 AM

Quote from: ur_naz on August 28, 2014, 12:19:28 PM

The main problem of eea1 function is that it must accept the list with zero in the head. in other case it returns wrong result. but the task says clearly about positive value to accept :-P

on my computer eea1 work correctly! (http://www.theswamp.org/index.php?topic=47689.msg527313#msg527313)

Code - Auto/Visual Lisp: [Select]

1. (eea1 '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30))
2.  
3. (1 2 "Fizz" 4 "Buzz" "Fizz" 7 8 "Fizz" "Buzz" 11 "Fizz" 13 14 "FizzBuzz" 16 17 "Fizz" 19 "Buzz" "Fizz" 22 23 "Fizz" "Buzz" 26 "Fizz" 28 29 "FizzBuzz")

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ElpanovEvgeniy on August 29, 2014, 05:08:29 AM

Other two variants, using local and global variables.  8-)

Perhaps this trick is useful to you for your code...
 :-)

Code - Auto/Visual Lisp: [Select]

1. (defun eea2 (l)
2.   (mapcar (function
3.             (lambda (n)
4.               (nth (rem n 15)
5.                    (list "FizzBuzz" n n "Fizz" n "Buzz" "Fizz" n n "Fizz" "Buzz" n "Fizz" n n)
6.               )
7.             )
8.           )
9.           l
10.   )
11. )

Code - Auto/Visual Lisp: [Select]

1. (defun eea3 (l)
2.   (mapcar (function
3.             (lambda (n)
4.               (eval
5.                 (nth (rem n 15) '("FizzBuzz" n n "Fizz" n "Buzz" "Fizz" n n "Fizz" "Buzz" n "Fizz" n n))
6.               )
7.             )
8.           )
9.           l
10.   )
11. )

Title: Re: =={challenge}== Programmer Test - Fizz/Buzz
Post by: ur_naz on August 30, 2014, 07:45:37 AM

Quote from: ElpanovEvgeniy on August 29, 2014, 05:03:04 AM

on my computer eea1 work correctly! (http://www.theswamp.org/index.php?topic=47689.msg527313#msg527313)

hmm, perhaps i missed some digits :embarrassed: