FizzBuzz Obsessions III: Battles in the vast underexplored world of Bash FizzBuzzing

#!/bin/bash

# This is FizzBuzz. We want to return numbers from a sequential list starting
# from 1, but replace them with some words. The number will be replaced with
# "Fizz" if divisible by 3 but not 5, with "Buzz" if by 5 but not 3, with
# "FizzBuzz" if by both, that is, 15.

# So first we do a loop, and test things as we go. I'm using seq to generate
# numbers.
all_numbers=`seq 1 $1`
for number in $all_numbers
do
    # We need to start with the 15, right? Let's use bc, our UNIX calculator.
    if test `echo $number%15 | bc` -eq 0
    then
        echo -n "FizzBuzz "
    # Now we test for 3
    elif test `echo $number%3 | bc` -eq 0
    then
        echo -n "Fizz "
    # Now we test for 5
    elif test `echo $number%5 | bc` -eq 0
    then
        echo -n "Buzz "
    # If none of these match, we just return the number.
    else
        echo -n "$number "
    fi
done

# That's it!

#!/bin/bash

# This is FizzBuzz. We return a sequence of numbers, but instead "Fizz" if
# divisible by 3 and not 5, "Buzz" if by 5 and not 3, and "FizzBuzz" if by
# both.

for num in $(seq 1 $1)
do
    if [ $(echo "$num % 15" | bc) -eq 0 ]
    then
        echo -n "FizzBuzz "
    elif [ $(echo "$num % 3" | bc) -eq 0 ]
    then
        echo -n "Fizz "
    elif [ $(echo "$num % 5" | bc) -eq 0 ]
    then
        echo -n "Buzz "
    else
        echo -n "$num "
    fi
done

#!/bin/bash

# This is FizzBuzz. We return a sequence of numbers, but instead "Fizz" if
# divisible by 3 and not 5, "Buzz" if by 5 and not 3, and "FizzBuzz" if by
# both.

for num in $(seq "$1")
do
    ((num % 15)) || { echo -n "FizzBuzz " ; continue ; }
    ((num % 3))  || { echo -n "Fizz "     ; continue ; }
    ((num % 5))  || { echo -n "Buzz "     ; continue ; }
                      echo -n "$num "
done | sed "s/ $/\n/"

#!/usr/bin/env bash

# This is FizzBuzz.

fizztest() { # MACRO! (Sort of. This is bash, after all.)
    echo "((num % $1)) || { echo -n '$2 '; continue; }"
}

fizzbuzz() { # Run MACRO!
    for num in $(seq "$1")
    do
        . <(fizztest 15 FizzBuzz
            fizztest  3 Fizz
            fizztest  5 Buzz
            fizztest  1 "$num")
    done | sed "s/ $/\n/"
}

fizzbuzz "$1"

#!/usr/bin/env bash

# This is FizzBuzz.

fizztest() {
    echo "((num % $1)) || { echo -n '$2 '; continue; }"
}

dofizztests() {
    local p
    p=$(($1*$2))
    . <(for d in "$p" "$1" "$2" 1; do
            case $d in
                "$p") : FizzBuzz ;;
                "$1") : Fizz     ;;
                "$2") : Buzz     ;;
                1)    : '$num'   ;;
            esac
            printf "%s\n" "fizztest $d $_"
        done)
}

fizzbuzz(){
    for num in $(seq "$1")
    do  . <(dofizztests 3 5)
    done | sed "s/ $/\n/"
}

fizzbuzz "$1"

#!/usr/bin/env bash

# This is FizzBuzz.

fizztest() {
    echo "((num % $1)) || { echo -n '$2 '; continue; }"
}

dofizztest() {
    declare -A fb
    fb[1]='"$num"'; fb[3]="Fizz"; fb[5]="Buzz"; fb[15]="FizzBuzz"
    . <(for d
        do  echo fizztest "$d" "${fb[$d]}"
        done)
}

fizzbuzz(){
    for num in $(seq "$1")
    do  . <(dofizztest 15 3 5 1)
    done | sed "s/ $/\n/"
}

fizzbuzz "$1"

#!/usr/bin/env bash

# This is FizzBuzz. We all know it.

whichfizz() {
    case "$(("$1" % 15))" in
        0) : "FizzBuzz" ;;
        *) case "$(("$1" % 3))" in
               0) : "Fizz" ;;
               *) case "$(("$1" % 5))" in
                      0) : "Buzz" ;;
                      *) : "$1"
                  esac
           esac
    esac
    echo -n "$_ "
}

fizzbuzz() {
    seq "$(($1-1))" |
        while read -r num
        do whichfizz "$num"
        done
    whichfizz "$1" | sed "s/ $/\n/"
    # ↑ So we can trim the trailing whitespace without "clogging the pipe".
    # Not that it makes any difference for small numbers. Not for 100.
    # But what if you want to watch a large stream of FizzBuzz numbers
    # flowing to STDOUT?
}

fizzbuzz "$1"

#!/usr/bin/env bash

# This is FizzBuzz. We all know it.

whichfizz() {
    case "$(("$1" % 3))$(("$1" % 5))" in
        [^0][^0]) : "$1"       ;;
        0[1-4])   : "Fizz"     ;;
        [1-2]0)   : "Buzz"     ;;
        00)       : "FizzBuzz" ;;
    esac
    echo -n "$_ "
}

fizzbuzz() {
    seq "$(($1-1))" |
        while read -r num
        do whichfizz "$num"
        done
    whichfizz "$1" | sed "s/ $/\n/"
}

fizzbuzz "$1"

#!/usr/bin/env bash

# This is FizzBuzz. We all know it.

en() { printf  "%s" "$*";}

whichfizz() {
    case "$(("$1" % 3))$(("$1" % 5))" in
        [^0][^0]) en "$1"   ;;
        0[0-4])   en "Fizz" ;;&
        [0-2]0)   en "Buzz" ;;
    esac
    en " "
}

fizzbuzz() {
    seq "$(($1-1))" |
        while read -r num
        do whichfizz "$num"
        done
    whichfizz "$1" | sed "s/ $/\n/"
}

fizzbuzz "$1"

#!/usr/bin/env bash

# This is FizzBuzz. We all know it.

whichfizz() {
    (($1%5!=0)) && {
        (($1%3!=0)) &&
            : "$1" ||
            : "Fizz"
    } || {
        (($1%3==0)) &&
            : "FizzBuzz" ||
            : "Buzz"
    }
    printf "%s " "$_"
}

natural() [[ "$1" =~ ^[0-9]+$ ]]

# We test only the main input, once: no need for testing repeatedly inside the
# loop in our particular case, since we know "$i" will be a natural.
fizzbuzz() {
    natural "$1" &&
        for ((i=1;i<=$1;i++))
            { whichfizz "$i";}
    echo
}

fizzbuzz "$1"

#!/usr/bin/env bash
# FizzBuzz.
fizzbuzz() (seq "$1" | sed '3~3 s/.*/Fizz/
                            5~5 s/.*/Buzz/
                          15~15 s/.*/FizzBuzz/' | xargs)
fizzbuzz "$1"

#!/usr/bin/env bash
# FizzBuzz.
fizzbuzz() (xargs <<< $(sed '3~3 s/.*/Fizz/
                             5~5 s/.*/Buzz/
                           15~15 s/.*/FizzBuzz/' <<< $(seq "$1")))
fizzbuzz "$1"

#!/usr/bin/env bash

# FizzBuzz.

prs() { printf '%s ' "$1";}

fizzify()
    if   (("$1"%15==0)); then prs "FizzBuzz"
    elif (("$1"% 3==0)); then prs "Fizz"
    elif (("$1"% 5==0)); then prs "Buzz"
    else                      prs "$1"
    fi

fizzbuzz()
    for ((i=1;i<"$1";i++))
    do  fizzify "$i"
    done

fizzbuzz  "$1"
: "$(fizzify "$1")"
printf "%s\n" "${_% }"

#!/usr/bin/env bash

# This is FizzBuzz. We all know it.

fizzbuzz() {
    printf "%s" "1"
    while read num
    do
        case $((num % 15)) in
            3|6|9|12) : "Fizz"     ;;
            5|10)     : "Buzz"     ;;
            0)        : "FizzBuzz" ;;
            *)        : "$num"
        esac
        printf "%s" " $_"
    done < <(seq 2 "$1")
    echo
}

fizzbuzz "$1"

#!/usr/bin/env bash
fizzbuzz()
 for((i=0;i++<"$1";))
  { ((r=i%3==0?i%5==0?3:1:i%5==0?2:0))
     case $r in
      0): "$i";;
      1): Fizz;;
      2): Buzz;;
      3): FizzBuzz
     esac; printf "%s " "$_";}
fizzbuzz "$1"

#!/usr/bin/env bash

# -- No Haskell in this machine, so it seems that I will need to use
# -- <contempt>bash</contempt>, of all things. Sigh.

# This is FizzBuzz. -- And to think it'd be only half a dozen lines
#                   -- in Haskell... sigh.

# -- Ok. Let's do it, hmm, the bash way.

# $ man bash<RET>
# /bananas<RET>
# Pattern not found
# -- !?

# /lenses<RET>
# Pattern not found
# -- !!! C'mon.

# /zygohistomorphic.prepromorphism<RET>
# Pattern not found
# -- SIGH... How boring.

# /monad<RET>
# Pattern not found
# -- You gotta be kidding me!

# /fmap<RET>
# Pattern not found
# -- The horror. The horror.

# *  *  *

# -- Let's pretend for a moment that this... "language"... can do functors.
# fmap :: Functor f => (a -> b) -> f a -> f b
fmap() {
  . <(sed -E \
          's/^(.*)[.](.*)/while read -r x; do \1 "$x"; done <<< "$\(\2\)"/' \
          <<< "$*"); }

# show :: Show a => a -> String
show() { printf '%s ' "$*"; }

# putStrLn :: String -> IO ()
putStrLn() { printf '%s\n' "$*"; }

# isNatural :: a -> Bool
isNatural() [[ "$1" =~ ^[0-9]+$ ]]

# isDivisible :: Natural -> Natural -> Bool
isDivisible() { (("$2"!=0)) && (("$1"%"$2"==0)) && true || false; }
#-- no "Justs", no "Maybes". sigh.

# makeSequence :: Natural -> [Natural]
makeSequence() { seq "$1"; }

# fizzify :: Int -> String
fizzify() if isNatural "$1"; then
              if   isDivisible "$1" 15; then show "FizzBuzz"
              elif isDivisible "$1"  3; then show "Fizz"
              elif isDivisible "$1"  5; then show "Buzz"
              else                           show "$1"
              fi
          fi

# -- Now, THAT looks almost decent!
# fizzbuzz :: Int -> [String]
fizzbuzz() (fmap fizzify . makeSequence "$1"
            putStrLn)

# -- Can't we change this prompt, maybe? Say:
# --   show "λ> fizzbuzz $1"; putStrLn
# -- Anyway:
fizzbuzz "$1"

fizzbuzz 300 | xargs -n15 | column -ts$' ' | grep -E '..zz|$'