Here's some programs to generate BuzzwordBingo cards for everyone in your group. We use different buzzwords depending on what kind of meeting we're going to; the examples shown use words for Marketing.
----
'''MicrosoftWord Macro'''
Option Explicit
Private Const USE_WILD = True
Private Const NO_WILD = False
Public Sub MarketingBingoC''''''ard()
Const Count = 25
Dim Words(Count) As String
Words(1) = "Synergy"
Words(2) = "Strategic Fit"
Words(3) = "Gap Analysis"
Words(4) = "Best Practice"
Words(5) = "Bottom Line"
Words(6) = "Revisit"
Words(7) = "Bandwidth"
Words(8) = "Hardball"
Words(9) = "Out of the Loop"
Words(10) = "Benchmark"
Words(11) = "Value-Added"
Words(12) = "Proactive"
Words(13) = "Win-Win"
Words(14) = "Think Outside the Box"
Words(15) = "Fast Track"
Words(16) = "Result-Driven"
Words(17) = "Empower [or] Empowerment"
Words(18) = "Knowledge Base"
Words(19) = "Total Quality [or] Quality Driven"
Words(20) = "Touch Base"
Words(21) = "Mindset"
Words(22) = "Client Focus[ed]"
Words(23) = "Ball Park"
Words(24) = "Game Plan"
Words(25) = "Leverage"
MakeBingoC''''''ard Words(), NO_WILD
End Sub
Private Sub MakeBingoC''''''ard(By''''''Ref Words() As String, Use''''''Wild As Boolean)
Dim myRange As Range
Set myRange = ActiveD''''''ocument.Range(Start:=Active''''''Document.Range().End - 1, End:=Active''''''Document.Range().End - 1)
ActiveD''''''ocument.Tables.Add Range:=myRange, Num''''''Rows:=5, Num''''''Columns:=5
Dim i As Integer
Dim j As Integer
Dim Count As Integer
Count = UBound(Words)
Randomize
For i = 1 To 5
ActiveD''''''ocument.Tables(1).Rows(i).Height = 64
For j = 1 To 5
Dim Word As String
Word = ""
If Use''''''Wild And i = 3 And j = 3 Then
Word = "*WILD*"
Else
Do While Len(Word) = 0
Dim Word''''''Index As Integer
Word''''''Index = Int((Count * Rnd) + 1)
If Len(Words(Word''''''Index)) > 0 Then
Word = Words(Word''''''Index)
Words(Word''''''Index) = ""
End If
Loop
End If
With Active''''''Document.Tables(1).Cell(i, j)
.Range.Insert''''''After Word
.Range.Font.Name = "Arial"
.Range.Font.Size = 12
.Vertical''''''Alignment = wdCellAlignVerticalCenter
.Range.Paragraph''''''Format.Alignment = wdAlignParagraphCenter
End With
Next j
Next i
End Sub
----
'''RubyLanguage'''
# create a shuffled word list, including wild padding to fill holes
words = ["Synergy","Strategic Fit","Gap Analysis","Best Practice","Bottom Line",
"Revisit","Bandwidth","Hard Ball","Out of the Loop","Benchmark",
"Value-Added","Proactive","Win-Win","Think Outside the Box","Fast Track",
"Result Driven","Empower","Knowledge Base","Total Quality","Mindset",
"Client Focus[ed]","Ball Park","Game Plan","Leverage","Utilize",
"Irregardless","Self-Starter"]
numberOfColumns = 5
(numberOfColumns - words.size()%numberOfColumns).times { words << "Wild!"}
#thanks to http://wiki.rubygarden.org/Ruby/page/show/ArrayShuffle
class Array
def shuffle
each_index {|j| i = rand(size-j); self[j], self[j+i] = self[j+i], self[j]}
end
end
srand = Time.now.to_i #seems to be a good enough seed
words.shuffle
#come up with some lines and values to make the table print cleanly
columnWidth = 0
words.each{|word|
if( word.length > columnWidth) then columnWidth = word.length end
}
totalPadding = 2
columnWidth = columnWidth + totalPadding
header = "."
footer = "'"
midline = " "
numberOfColumns.times {
columnWidth.times { header << "-"
footer << "-"
midline << "-"
}
header << "."
footer << "'"
midline << " "
}
# create the card
File.open("bingoCard.txt","w") do |outFile|
columnCount = 0
outFile << header << "\n"
#prints the word, along with horizontal padding and separators
words.each {|word|
if(5 <= columnCount)
outFile << "|\n"
outFile << midline << "\n"
columnCount = 0
end
needToFill = columnWidth - word.length
leftFill = needToFill/2
rightFill = leftFill + (needToFill%2)
outFile << "|"
leftFill.times{ outFile << " " }
outFile << "#{word}"
rightFill.times{ outFile << " " }
columnCount = columnCount + 1
}
outFile << "|\n" << footer
end
Small differences include using Wild! as a filler, rather than optional. This allows wordlists to be of 'unaligned' size. I didn't bother with vertical pretty printing, so I shaved some buzzword names.
''Even this small task kept hitting me over the head with CreepingFeaturitis (especially prettier printing and word list management) and the urge to further generalize and objectify. Doctor Yagni, I need a pill, please.''
Why *that* shuffle? I love sort_by{rand} :)
''sort_by{rand} is nicer. I'm still getting used to Ruby and didn't know that was an option. I even missed the giant notice at the top of the page explaining the sort I did use trying to educate me about about sort_by{rand}. Oh, and anyone who lets the browser do the table layout for them is a pansy ;)''
----
A nicer, more idiomatic RubyLanguage script:
WORDS = [
"Synergy", "Strategic Fit", "Gap Analysis", "Best Practice",
"Bottom Line", "Revisit", "Bandwidth", "Hard Ball",
"Out of the Loop", "Benchmark", "Value-Added", "Proactive",
"Win-Win", "Think Outside the Box","Fast Track", "Result Driven",
"Empower", "Knowledge Base", "Total Quality", "Mindset",
"Client Focus[ed]","Ball Park", "Game Plan", "Leverage",
"Utilize", "Irregardless", "Self-Starter",
]
COLUMNS = 5
words = WORDS.dup
words << "Wild!" until (words.size % COLUMNS).zero?
words = words.sort_by { rand }
pad = words.map { |w| w.size }.max + 2
words.map! { |w| w.center pad }
def seperator(pad, string)
string + Array.new(COLUMNS) { "-" * pad }.join(string) + string
end
head = seperator pad, "."
line = seperator pad, " "
foot = seperator pad, "'"
puts head
(words.size / COLUMNS).times { |a|
puts line unless a.zero?
print "|"
COLUMNS.times { |b|
print words[COLUMNS*a + b], "|"
}
puts
}
puts foot
Should output the same as above Ruby script.
----
This seems like a good candidate for DivisionOfLabor. The following PerlLanguage script produces HyperTextMarkupLanguage. ''I mussed with this for List::Util::shuffle.''
#!/usr/bin/perl
use List::Util qw(shuffle);
open(WORDS, "bingo.dat") || die("Can't open bingo.dat");
@allwords = <WORDS>;
close(WORDS);
$rows = 5;
$cols = 5;
@shuffled = shuffle(@allwords);
sub getword {
$word = pop(@shuffled);
chomp($word);
$word;
}
print "<table border=1>\n";
for (1..$rows) {
print " <tr>\n";
for(1..$cols) {
my $word = getword();
print " <td align=center width=100 height=100>$word</td>\n"
}
print " </tr>\n";
}
print "</table>\n";
----
PythonLanguage:
import random
import os
class Card''''''Maker(object):
# Tweaked so that it will fit in 80 columns...
words = ["Synergy", "Strategic Fit", "Gap Analysis", "Best Practice",
"Bottom Line", "Revisit", "Bandwidth", "Hardball", "The Loop",
"Benchmark", "Value-Add", "Proactive", "Win-Win",
"Think Big", "Fast Track", "Result-Driven", "Empower",
"Knowledge Base", "Total Quality", "Touch Base", "Mindset",
"Client Focus", "Ball Park", "Game Plan", "Leverage"]
maxlen = max([len(w) for w in words])
row = "|" + ("%%%ss|"%maxlen)*5 +"\n"
spacer = "+" + ("-"*maxlen + "+")*5 + "\n"
template = (spacer + row)*5 + spacer
def __call__(self, use_wild=False, template=None):
if not template:
template = self.template
words = self.words[:]
random.shuffle(words)
if use_wild:
words[12] = "*WILD*"
return template % tuple(words)
''Quick and dirty usage examples - may need to fix file paths:''
def make_one_file():
make_card = Car''''''dMaker()
people = ["John", "Jane", "Sally", "Mark"]
f = open("C:/bingo.txt", "w")
for person in people:
print>>f, "%s:"%person
print>>f, make_card(use_wild=True)
make_one_file()
def make_one_webpage():
row = "<tr>" + "<td align=center width=100 height=100>%s</td>"*5 + "</tr>"
template = "<HTML><table border=1>" + row*5 + "</table>"+"</HTML>"
make_card = Card''''''Maker()
print>>open("C:/bingo.htm", "w"), make_card(template=template)
make_one_webpage()
----
CommonLisp:
(use-package :com.gigamonkeys.html)
(defparameter *phrases*
#("Synergy" "Strategic Fit" "Gap Analysis" "Best Practice" "Bottom Line"
"Revisit" "Bandwidth" "Hardball" "Out of the Loop" "Benchmark" "Value-Added"
"Proactive" "Win-Win" "Think Outside the Box" "Fast Track" "Result-Driven"
"Empower [or] Empowerment" "Knowledge Base" "Total Quality [or] Quality Driven"
"Touch Base" "Mindset" "Client Focus[ed]" "Ball Park" "Game Plan" "Leverage"))
(defun randomize (vector)
(loop for i from (length vector) downto 1
do (rotatef (aref vector (1- i))
(aref vector (random i))))
vector)
(defun print-bingo-card (phrases row-length)
(when (< (length phrases) (expt row-length 2))
(error "Only received ~S phrases. Need at least ~S."
(length phrases) (expt row-length 2)))
(html
(:html ((:table :border 1)
(loop with index = 0
with random-phrases = (randomize (copy-seq phrases))
repeat row-length
do (html (:tr
(loop repeat row-length
do (html ((:td :align :center :width 100 :height 100)
(:format "~A" (svref random-phrases index))))
do (incf index)))))))))
(print-bingo-card *phrases* 5)
Things to keep in mind:
* Arrays were used. Not lists.
* Iteration loops were used. Not recursion. Not functional programming.
* Macros were used. This uses the HTML mini-language from PracticalCommonLisp. Which means "extensions" to the language can come from third parties. New paradigms. No fussing with strings and end-tags.
* Errorhandling. Here it was just very simple, but Common Lisp has something more powerful and safer than exceptions, the ConditionSystem.
----
CeePlusPlus:
#include <iostream>
#include <fstream>
#include <algorithm>
#include <iterator>
#include <string>
#include <vector>
using namespace std;
int main(int argc, char **argv){
vector<string> words;
ifstream in("bingo.dat");
string line;
while(getline(in, line))
words.push_back(string(line));
srand(time(0));
random_shuffle(words.begin(), words.end());
cout << "<html><head><title>Buzzword Bingo</title>" << endl
<< "<style>td { text-align: center; width: 6em; height: 6em; border: solid 2px black } </style>" << endl
<< "</head><body><table>" << endl;
for(int row = 0; row < 5; row++){
cout << "<tr>" << endl;
for(int col = 0; col < 5; col++){
cout << "<td>"
<< (row == 2 && col == 2 ? "FREE" : words[row * 5 + col])
<< "</td>" << endl;
}
cout << "</tr>" << endl;
}
cout << "</table></body></html>" << endl;
}
* Nice, formatted output without hardcoded font sizes
* Same input file (and format) as PerlLanguage entry
* STL doesn't lend much except random_shuffle
----
OcamlLanguage:
open Printf
let phrases =
["Synergy"; "Strategic Fit"; "Gap Analysis"; "Best Practice";
"Bottom Line"; "Revisit"; "Bandwidth"; "Hardball"; "Out of the Loop";
"Benchmark"; "Value-Added"; "Proactive"; "Win-Win";
"Think Outside the Box"; "Fast Track"; "Result-Driven"; "Empower[ment]";
"Knowledge Base"; "Total Quality"; "Touch Base";
"Mindset"; "Client Focus[ed]"; "Ball Park"; "Game Plan"; "Leverage"]
let max_phrase_length =
(List.fold_left
(fun max str ->
let len = (String.length str) in
if len > max then len else max)
0 phrases) + 3
let list_extract_nth list n =
let rec continue list acc n =
match n, list with
(_, []) -> raise (Failure "nth")
| (0, hd :: tl) -> (hd, (List.rev_append acc tl))
| (_, hd :: tl) -> continue tl (hd :: acc) (pred n)
in continue list [] n
let shuffle list =
let rec continue list acc n =
match n with
0 -> acc
| _ ->
let i = (Random.int n) in
let (elt, rest) = (list_extract_nth list i) in
continue rest (elt :: acc) (pred n)
in continue list [] (List.length list)
let matrix_of_list list x y =
let array = Array.of_list list and matrix = Array.make x [||] in
let _ = for i = 0 to x-1 do matrix.(i) <- Array.sub array (i*y) y done in
matrix
let print_bingo use_wild width matrix =
Array.iteri (fun i row -> begin
Array.iteri (fun j cell -> begin
let string =
match (i, j, use_wild) with
(2, 2, true) -> "*WILD*" | _ -> cell
in printf "%*s" width string
end) row;
print_endline "";
end) matrix
;;
let _ = Random.self_init () in
(print_bingo true max_phrase_length (matrix_of_list (shuffle phrases) 5 5))
----
See: CategoryInManyProgrammingLanguages, ProgrammingChrestomathy