About The Contest
The first ever Olympiad of Misguided Geeks contest at Worse Than Failure (or OMGWTF for short) is a new kind of programming contest. Readers are invited to be creative with devising a calculator with the craziest code they can write. One lucky and potentially insane winner will get either a brand new MacBook Pro or comparable Sony VAIO laptop.
#100002 — OptCalcMasterC17W32-20070424-Subm-w-MasterOp
#100004 — The OMGWTF Rube Goldberg calculator
by Chris Byrne
Doesn't actually perform the calculations itself, and instead relies upon Window's calc.exe for that functionality.
#100006 — Highly Efficient Architecture for Value Yielding 0.1
by Bert Peers
Order now !!! Highlights include !! - extensible set of operations - optimized math ! - avoid math if possible - fully debugged and exception safe - follows all the industry guidelines - free t-shirt I even think it works ...sometimes. Warranty is void when compiled in release mode !
#100008 — StackCalc
All calculators looks the same to the user, what's special about this one is how easy it is to implement new functions for the programmer! Just use the function "GetNumber()" to get the next available number on the stack and you're ready to implement complex math function. I.e addition is simply done by using "GetNumber() + GetNumber()". What could be simpler? And we all know simple code means less bug fixing and a easier job for the maintainer... Hangs his head in same, Henrik
#100011 — 100%
by Frans Lategan
100% of the test cases pass, 100% worthless....
#100013 — Petes Pants Calc
by Pete Bassett
Powered by batch files and cscript.exe. Not expected to win, just something fun to fill 30 mins.
#100014 — FooCalc
by Adam C.
FooCalc is a paragon of "thinking inside the box" and ushers in the latest hot software engineering fad, Test Case Driven Development.
#100018 — OMGWTF SecureCalc
by Chris Doggett
I wanted to build a secure calculator to keep prying eyes from seeing the results of the calculations. What I came up with should easily surpass Dept. of Defense standards for data security. Features include: STL maps for optimization STL strings and stringstreams! O(n) in-place string reversal!! Pointer arithmetic!!! Test-driven development (Red-Green-Repeat)!!!! Palindrome checker?(!^5) Reckless conversion between STL strings and char arrays(!factorial) Overuse of exclamation points!!!!!!!!!!!!!!!!!!!!!!! Also, in true hacker fashion, I have add
#100019 — en.wikipedia.org\SUPAR_CALCULATOR
A well commented calculator. Very fast except on division operations, give it a few minutes it'll figure it out. Requires at least a Pentium IV 2.3 GHz machine to run smoothly.
#100020 — Reliable Calculator(tm]
This is a really small calculator made by modifying the Win32 skeleton code a bit. It is guaranteed to pass the test cases, sometimes even by correcting user input.
#100021 — BasiCalc
by Yngve Ådlandsvik
This is a very simple calculator. So simple, in fact, that it doesn't use anything other than increments/decrements and compares for calculations.
#100022 — Hardcode
I'm sure lots of people are doing something like this, but what the heck. The results of the tests are hardcoded, spitting out the answers at the correct times. Since the results it gives are independent of what you press, I simplified the interface by putting all the labels on the same button. Also, intermediate numbers appearing when you press buttons are not part of the specification, so you don't get them. There should be the answer only when you press '=' as you run through the test cases.
#100023 — FileCalc
A file-based calculator. Its database is infinitely extensible, if enough disk space is available! (Hardware or O.S. limitations may apply).
#100030 — Structural Programming
by John Millikin
One of the benefits of coding in Python or Lisp is nested functions. Unfortunately, the designers of C didn't see fit to include the glorious nested function in their language! Luckily, the designers of C++ saw fit to include them - sort of.
#100031 — The Decapitator
Featuring a new, sophisticated key layout, the Decapitator is a new, stunning way to calculate numbers. Internally, the calculator works brilliantly as well.
#100032 — String Theory
by Ben Groves
Uses strings where they shouldn't be used. This is my first submission, mainly to get the gtk part running. Feel free to use it as the skeleton.
#100035 — PITAcalc Enterprise Edition
by Donald Straney
PITAcalc Enterprise Edition is an enterprise-ready, productivity-enhancing web-enabled calculator application which utilizes the very latest exciting technologies, including web services, distributed computing, and XML.
#100038 — Extreme WTF Calculator
Code is only as good as its test cases.
#100040 — Test Driven Development EXXXTREME!
by Douglas Mayle
Test 1... passed Test 2... passed ... What happens when your tests define your code???
#100043 — Buggy 4-Function Calculator
by Stephen Oberholtzer
What makes this special? Well, for one thing, it leaks memory, which is pretty impressive for something that shouldn't need to *allocate* any memory. The first input is converted four times: from string, to float, back to string, to float. The second input is only converted from string to float. Then each input is converted to a horrible fixed-point format. Computations are performed on this new format, then converted back to float, then converted back to a string for display.
#100044 — The Overkill 4-Function Calculator
by Stephen Oberholtzer
This calculator evaluates quite differently from most: The only button that does any work is the "Equals" button. All the others just build up a string in the edit box. Upon hitting Equals, however, an insane set of operations are performed. Read the Full Description for the list.
#100045 — The SQL-Based Calculator
by Stephen Oberholtzer
This is the ultimate nightmare. For a short description, a line from the README file sums this up: I would not force my own worst enemy to maintain this code.
#100046 — ParasiteCalc
Why spend hours crafting handmade addition, subtraction, multiplication and division functions when Windows can already do it for you. Or at least, Windows Calculator can do it for you.... So, ladies and gentlemen, I give you - ParasiteCalc! A calculator so lazy it outsources all of its calculations. Consider it an example of current business practices...
#100047 — Computer Program
by Morten Hustveit
Four-function calculator implemented without using any multiply, division or shift operators, all i O(1)! Needs to have access to the URL http://omg.worsethanfailure.com/Entries/Requirements/TestCases.aspx
#100049 — OMG Enterprise edition
by Peter Gordon
* No arithmetic operators used * XML operator configuration
#100050 — aoneillomgwtf
by Andy O'Neill
Aside from some poorly written code, this calculator determines the solution by loading http://omg.worsethanfailure.com/Entries/Requirements/TestCases.aspx and searching for the solution on the page. It reloads the page every time the equal key is pressed and does a simple string search for the first occurrence of the entered calculation, grabbing the solution that is a fixed number of characters after this location.
#100051 — How Machines Probably Do It
by Andrew M. Kasper
This solution implements in software what machines probably do in hardware.
#100054 — Calc.WTF
by Cole I
This calculator should have never left Visual Studio. The main functionality takes place in CalcMaestro.(cpp/h), which is a template based class which will operate with any integer or floating-point type as a template parameter (constrained by type size limits). For the operators + and -, we use increments instead of using these operators. For operators / and *, we use some fun things in math.h, because who knows if / and * are reliable?
#100059 — By-Parts High-Precision Calculator
The By-Parts High-Precision Calculator is the ideal in calculation technology.
#100060 — CalcWrapper (first update)
by Badr Z.
CalcWrapper is a proof of concept and a clever solution for a simple problem: making the 4 basic operations. The way it works is “easy”. First, it launches Calculator (calc.exe) and then simulates typing using SendMessage. Finally, it retrieves the result value and displays it after closing Calculator. You see, CalcWrapper is a wrapper that combines the power of the too-much-complicated Ms Calculator and an easy-to-use Win32-based GUI.
#100061 — Outsourcing Calculator
by John McCloskey
If you can't beat windows calculator, why not use it? My calculator shells out to the windows calc.exe and makes it do the work. Simple and stupid!
#100064 — ChickenCalc
by Chicken Little
This calculator is text based, all calculations are done in "long hand". With additions its "Add the two digits; carry the one" etc. Subtraction is similiar. Multiplication is achieved by adding the first number to itself the specified number of times. Division is even worse, subtracting the denominator from the numerator until the numerator is less then the denominator, and counting the number of subtractions needed. Because of the requirements presented, the ChickenCalc only works with positive integers. ps. I am resubmitting this entry, I want it to replace my previous submission. Tha
#100066 — FileSystemHashMapNotepadCalculator
by Dan U
FileSystemHashMap + Notepad + Calc
#100070 — Calculated
by Drake Williams
Calculator. Does most everything via multiple calls to the poorly thought through addition function. Does division properly. 'Author' is crazy, and converses with him/herself throughout the code, among worse possibilities.
#100071 — Strainu's Calculator
Basicly, my program does all the operations as defined by the IEEE 754 standard. It extracts the sign, exponent and mantissa from the parameters, then makes the operation. If you don't know how this works, you can find the exact steps I followed at http://meseec.ce.rit.edu/eecc250-winter99/250-1-27-2000.pdf .
#100073 — Corned beef and hash
by Matthew Hui
Precomputes the test cases for speed reasons.
#100074 — APLPCOLPISC: The Arbitrary Precision, Lexing, Parsing, Compiling, Optimizing, Le xing, Parsing, Int
by Todd Neal
* Gui is written in pure Xlib and resembles Windows Calc.exe * ...using only arcs,lines, and rects * ...and only means "only" (Who needs fonts? Check out Util.h) * Hand implemented lexer and recursive descent parser for arithmetic expressions * Arithmetic expressions are compiled to assembly for a non-existent CPU * This assembly is then optimized with a peephole optimizer * Since the CPU doesn't exist we need an emulator for it, so the emulator is provided in a lispy language (source in CPU.cpp) * Since gcc unfortunately doesn't provide a frontend for "Todd's m
#100075 — WTCalc
by Damir Kasipovic
My calculator is so special because it is first thing I've written in visual c++. I have done few things in bloodshed c++ but nothing in this MS. I am more of a Pascal guy myself.
#100077 — Infinite-Precision Calculator 1.0
by Mike Marsh
The Infinite-Precision Calculator 1.0 is capable of representing real numbers with as many decimal places as your machine has the memory to store. The future of computation is now.
#100079 — ASMCalc
A really fast calculator, using ASSEMBLY! Well, sort of...
#100081 — PaulaCalc v1.0
by Tony Sherwood
Remember the grade school algorithms for doing stuff? Neither did I. Then this damned contest came along, and all the sudden I'm searching the net for instructions on how to do long division.
#100084 — Calc a la WTF
by Bertho Stultiens
A simple calculator with a definite preference for the ultimate answer.
#100085 — Calc a la WTF too
by Bertho Stultiens
A simple calculator with a slightly overengineered design. The calculator can, theoretically, process any size numbers in base 10 using ASCII BigEndian BCD encoded strings.
#100086 — Bizinary
by Lee Crabtree
I saw a bunch of suggestions involving ridiculously overcomplicated solutions, but they all looked like they would take me more than an hour to code up, so they were quickly discarded. I took the route of doing everything in binary arithmetic, and through a curious quirk, only division supports floating-point answers (for example: "1/2" produces "0.5" as instructed, but if you turn around and try to multiply that by "1", you get "0"). Actually, it's not really that curious a quirk. I got lazy in the middle and just started casting everything to integers after seeing that none of the test
#100088 — bincalc
This calculator is designed to be expandible and portable. It accepts input in binary form, which can be entered by any device. Two sample implementations are included, one graphical, and one console-based. Note: the gui requires gtkmm [See README file for more information]
#100091 — ChickenCalc II
A very simple implementation, should have been my first entry!
#100094 — Data Driven Calculator
by Mike Young
Normal calculators are fine as long as the rules of mathematics don't change. But what if you want 1+1 to equal something other than 2, while keeping all other results the same? By making the calculator data driven, I have allowed it greater flexibility and expanded its function beyond mere number processing. Also, it goes to 11.
#100097 — sparcocalc
This calculator emulates the Sparco Handheld Calculator (SPR02196). Its interface consists of a graphic of the calculator. It accepts input in binary form. To enter a zero, click in either of the round, zero-shaped handles. To enter a one, click in the one-shaped blade. Output is displayed via a dialog box. Sparcocalc is an alternate version of my "bincalc" program, demonstrating its versatility and portability. sparcocalc requires gtkmm to build.
#100099 — estimator
by Keith Lucas
It has a stupid client-server model. The first function call is to fork(). The number is encoded in an IP address to be sent to the server. The mathematic operations are converted to LISP. The result is calculate with mini-"LISP" interpreter. The results are sent to the client via the X11 protocol in XML. There are really stupid re-implementations of standard C functions. It passed the test cases.
#100100 — WTFCalc
by Anthony Bellissimo
The only calculator program out there (hopefully) that doesn't work properly with 16-bit color depth or less. Many other WTFs inside!
#100101 — The OOMGWTFFFC (Optimized Oh My God Worst Than Failure Four Function Calculator)
by Ronald Chen
A highly paid consultant takes a shot at making his own four function calculator. Using his "optimization geniusness", he bangs out a calculator with Infinite Performance!
#100102 — Overrated
I wanted to create an application worthy of a large corporation, which wouldn't settle for consumer-grade stuff. To avoid giving them what an average guy would get, I had to redefine some of the basics of programming. For example, I avoid using parameters and return values. I also avoid using local variables, because it takes a lot of time to initialize them every time a function is called. A lot of time. Instead, I use a set of global variables, which only have to be initialized once.
#100103 — TerseCalc
TerseCalc is a design based on a few flawed assumptions. The most important assumption is that +, -, /, * are not available on all machine, and so they need to be implemented with other, "simpler" operations, like <<, & and ^. In fact, +, -, /, * are not used anywhere in this application as arithmetic operations. See the design document (TerseCalc.pdf) for more details from the point of view of the designer who made these assumptions.
#100104 — Bitwise is fastest calculator
by Peter Cawley
Company policy is to avoid slow operators (eg + - / = * < >) and use only fast operators (>>= <<= ^=). As such, valid operators are: ( ) >>= <<= ^= , [ ] -> . And invalid operators: all others, including: + - = / * & | && || -- ++ == != < > <= >= % Not only is the main calculator logic done totally with just the valid operators, so is everything else.
#100108 — ChickenCalc
by Chicken Little
This is my last update (hopefully). This is a text based calculator. See Readme.txt and CalcFunc.cpp.
#100109 — Calc a la WTF (4) VUI(TM)
by Bertho Stultiens
A small gtk2 calculator with a VUI(TM) (Variable User Interface) design.
#100114 — WTFCalculator
A simple implementation that only works on the given test cases. Also has a particularly unfriendly user interface.
#100115 — Recursive Calculator
by Grant Johnson
Each arithmetic operation is implemented using recursion. As a consequence, the program requires 1GB of memory to run.
#100117 — YatCalc 7.0 Pro
YatCalc 7.0 Pro: Calculator of your dreams.
#100118 — Perfect calculator
Perfectly passes all test cases, at least once..
#100119 — The Decimal to Binary to Decimal Calculator
by David Bry
First converts your input to a float, to an integer, and to a string representing the binary equivalent. Reverses the string and performs the necessary calculations with the quickness (and lots of "trickery"). Reverses again and returns a string, that gets converted back to an integer (or a float in division) that is displayed back.
#100120 — The Theoretically Efficient Calculator
by Marc Gabriele
All arithmetic operations are implemented using only ++, --, and the efficiency of functional recursion. In addition, calculation results are cached for later retrieval, for even more efficient operation. Unfortunately, several compromises needed to be made in the design, as present-day computers are incapable of handling the level of efficiency produced by this code without adverse effects.
#100121 — SQLiteCalc
by Jarmo Torvinen
SQLiteCalc is the first interactive calculator with inbuilt database of known results! In soviet Russia, the calculator asks the results from YOU!
#100122 — Imaginary Numbers
by Kyle Cunningham
This calculator was made with the intention of being a WTF calculator that one would see in the wild. It works, but it just barely works. It seems like it will pass most normal test cases, but there are mysterious crashes and bugs. The calculator will give the right answers, but is the right question being asked?
#100123 — WTF Web Calc
by Dave C.
A web-server that launches Firefox to generate the UI. and forwards calculation processing off to Google calculator. It acts both as a web server (to Firefox) and a web client (to Google) - WTF?
#100124 — IzzyCalc
by Israel Brewster
Features of my "special" calculator include a modified key layout for "improved entry efficiency", improved "security features" added "function" keys, and special calculation algorithms. Also designed to minimize screen usage.
#100125 — As specified
by Andrew Sobala
Possibly the simplest way of conforming to the test cases yet coming up with a calculator that gives some really quite random output
#100126 — Crash Calculator
by Tyler Krpata
The code is not changed much from the GTK skeleton code. The big difference is that DoOperation() is now a void function. The function performs the appropriate calculation, then attempts to access the memory location at the floating-point representation of the answer, then we handle SIGSEGV to find the answer. There is also a SIGFPE handler to catch divide-by-zero. I LOLed
#100127 — Super Awesome 4th Grade Calculator
The basic premise was to do math in the way that it is taught in primary school. The long way.
#100130 — Linear Interpolation!
by Brad Bax
It reminds me of sex on a beach... the drink, not the act. Filled with sexy goodness (I was too lazy to type out the old description again)
#100131 — It's a calculater!
by Brett Harrison
This submission requires the internet. When the user types in the numbers and presses enter the program loads http://omg.worsethanfailure.com/Entries/Requirements/TestCases.aspx and tries to find the answer in the html. If it cannot find the answer, it then asks google if it knows how to do the math. If that fails it you get a special surprise.
#100133 — The Random Result Calculator
This calculator sometimse provides the correct answer, sometimes provides an incorrect answer, and sometimes causes a segmentation fault.
#100137 — Human style calculator
by Jonathan Camacho
Includes 255-digit precision, and support for entering negative and decimal numbers, such as -12.75.
#100138 — Ultra-Portable WTFCalc
by Dark Shikari
The purpose of this code is to provide a calculator function set for what I call "integer floating point". That is, to avoid the uncertainty and inaccuracy of floating point operations, it uses integer operations on the various parts of the floating point number to ensure high accuracy. There are some limits to this: some platforms don't have integer arithmetic functions available. Other platforms have very slow bit shifts, like the Pentium 4. To resolve this, I have made it so that the program only uses five operations: a) = assignments b) == comparison c) Bitwise NOT d) Bitwise
#100139 — half-ass-expr
by Steve Hawley
A fully reprogrammable calculator based on an standards-non-compliant, half-assed implementation of something not enitrely unlike lisp.
#100141 — Fuzzy Calculator
by The Great Aaron Hill
I'm in ur calculatr, guessin ur ansewrs!
#100142 — The Inconceivable Calculator
The most valuable discoveries in the field of mathematics is now made available to the serious mathematician requiring critically accurate results with the first ever version of The Inconceivable Calculator. Whether you want to +, -, x or even /, The Inconceivable Calculator provides the accuracy you need. Using never-before-implemented scientific and philosophical algorithms, the Inconceivable Calculator is your primary number choice in floating point arithmetic.
#100145 — Stocalculator
by Jacob Haqq-Misra
The Stocalculator is a four-function calculator based on the C Standard Library random number generator. By the rules of the contest, the Stocalculator is considered a fully-functioning calculator by passing the official test cases in sequential order. The Stocalculator is only guaranteed to pass these cases in the month of May, 2007. If you wish to reproduce the above test cases at another time, you must adjust your system clock accordingly. This is a feature, not a bug.
#100146 — CalcCalc
by Matthew Hooker
CalcCalc takes code reuse to it's absurd conclusion. Why write a calculator from scratch when Windows already provides a fully functioning one! Download CalcCalc and see how you can leverage already existing technologies and maximize enterprise synergy throughput. To get some background on the project, please read what Joe, the author, has to say in the full description.
#100147 — Number-Thinker GTI Ultra Elite
by Harry Denholm
NTGTIUE is based on a foundational programming concept - do not re-invent the wheel if you can avoid it. The windows calculator and Google are both perfectly good at adding numbers together. So NTGTIUE uses *them* instead of bothering with using a from-scratch unproven floating-point arithmetic processing core. Less risk, right?
#100149 — calc
by Bernie Whalen
For my calculator program, calc, I had two requirements, use C strings and use C rather than C++ as much as possible. I figured this would guarantee that I would introduce a few unintentional bugs. It does pass all test cases and returns a result quicker than I had expected given the rather inefficient algorithm for multiplying and dividing.
#100150 — No math, no brainer.
This calculator uses no mathematical operations. Most of the WTFs are from ignorance, and this takes that to the limit. Certified as cliché-free. Uses the provided framework and GUI.
#100151 — Calcemulator
by Jirí Havel
All fpu operations are emulated. Or I think so, because I didn't check it. I think, I'm too conservative programmer, to write anything really evil.
#100152 — SpinCalc
It uses the unique entry method of using a spinbox instead of having the users press number buttons. Also, it redefines a lot of basic functionality of arithmetic.
#100153 — SeCa (Secure Calculator)
If you use the valgrind certified "SeCa" you can be sure that all your results are correct because of its internal correctness. The fact that it uses its own (secure) calculating engine makes it independent of CPU errors.
#100154 — ASCII calc
by jj the monkey wrench
ASCII calc is special because the source can easily be manipulated to fill out any ascii picture you want (more or less).
#100155 — Calc Server / Client
by Mark Collier
This is a client / server calculator in a single (Win32) program - The client side of the program has a unique "easy to use" and effeciant interface that sorts the buttons in the order of most used, while the server uses highly optimized code to deliver the results as quickly as possible. Communication between the server and client uses encryption and MD5 to ensure the security and integrity of the calculation data.
#100159 — neuralator
by troy d. straszheim
Calculator with bug count approaching infinity. It gets the test set right, but everything else.... wtf?
#100160 — EnterpriseCalc Pro 2
by Frederick Cheung
This supersedes the entry named EnterpriseCalc Pro. Like its predecessor, it requires net access to www.google.com and search.yahoo.com. It lives by the motto '"If you can't beat it, screenscrape it"
#100163 — Binary Mathness
by Steven Truelove
I decided that it would be best to use C++ STL strings containing the characters '0' and '1' for all computation. Floats are converted into twos complement integers, operated on, and then back. You just can't trust those damn built-in operators, am I right? So I built a binary adder, implemented binary long division with it, and then implement subtraction with the adder and multiplication with the divider.
#100164 — Calculator Ann
by Patrick Moroney
It uses an advanced back propagating artificial neural network to calculate all the answers. The calculator does take a while to load as it trains the neural net with a few example equations, but once it has been trained the answers come quickly. It has the ability to show and calculate multiple operations such as '38+56-2' or '1/0+2/0'. This calculator is easily updated if the values to any equations change.
#100167 — GoogleCalc
by Hanoch Freund
GoogleCalc is a simple, yet powerful, windows calculator. Best of all, like more and more other applications these days, it's powered by Google!
#100169 — TOC (The Omgwtf Calculator)
by Fajar Endra Nusa
TOC GUI is your nightmare.. it would be appearing in your every single night..=)) TOC code can increase your brain power to do better than ever, it's like a gorgeous inspiration for you.. even it would be your dinner friend ;D
#100170 — StackCalc 070511
All calculators looks the same to the end user. What matters to programmers is how easy it is to maintain the application and add new functionality. This implementation has a simple framework that allow just that.
#100171 — Calculator
by Malte Wedel
Nothing special, just works exactly as specified.
#100173 — SuperCaching Calculator (tm)
by Petr Kadlec
Thanks to a unique caching framework, every calculation needs to be done only once! After that, it is stored in the file system and requires only a few Win32 API calls to retrieve the cached result. See readme.txt for further detail.
#100174 — Calc-Q
by Dominic Scheirlinck
If you're going to use an inner platform, you might as well use one that's mathematically sound. My calculator makes us of a formal axiomatic system known as Robinson arithmetic, or Q, to figure out sums, differences and products. Add a pinch of Newton-Raphson, for division, and you have a working calculator.
#100175 — OMG!OCRCAL
by Ivan Milyakov
OMG!OCRCAL has following notable features: * main input mode is handwriting * fully customizable character shapes * calculation performed on character strings using good old school methods
#100176 — The Calculator that doesn't calculate
by Kelly Hamilton
This calculator creates a system calculator, clones's its UI and drives it automatically. The only calculation it does is in trying to figure out where to put the buttons.
#100179 — SuperCalcFX with 3 Function Arbitrary Precision Arithmetic
by Antony S.
From README.txt: * Arbitrary precision arithmetic (up to 254 digits) for addition, subtraction, and multiplication. * Results are cached to improve performance when the same calculation is requested by the user. A .vcproject file is included for building in Visual C++ Express.
#100181 — misguided
by Kevin Vigor
This is a very simple derivation of the GTK sample. Main.cpp is completely unaltered. All the interesting code is in CalcFunc.cpp. You would be well advised not to believe any of the comments. It does pass all test test cases yet contains at least one very significant bug. Spoilers available on request.
#100182 — Claculator
The concept of Claculator is an implementation by an I'm-better-than-anyone-else kind of coder, who scoffs at his compiler, operating system, processor architecture, colleagues, etc. As a result, pretty much everything needs to be rewritten or worked around, to achieve the best performance possible.
#100183 — The Astounding WTFulator
by Sami Kyöstilä
This calculator is based on the principle of outsourcing all the difficult operations to a dedicated computation engine.
#100185 — Xomgwtf:Big Buggy Quackulater
Turn your C++ compiler into an INTERCAL compiler! This is a tech demo which implements a calculator and shows the basics of porting your legacy INTERCAL code to modern C++ compilers!
#100189 — Romanorum Computus
by Michael Ensly
This calculator makes use of theoretically almost-fully-functional algorithms to compute answers using roman numerals stored in enormous string buffers. The user is not exposed to roman numerals at any stage, however, as the answers are converted back when the answer is reached. The GUI also features images that depict what button is being pressed.
#100190 — Don't Trust The Hardware
by Jeffery C. May
Modern CPUs are complex and buggy. I've got an uncle that told me that all Intel CPUs, for instance, can't divide two numbers and produce the correct quotient. I therefore assure correct answers by avoiding all CPU-based arithmetic, and do it all myself. I think that this is the safest way to produce accurate results.
#100191 — PolyCalc
This calculator uses POLYMORPHISM. It *really* uses it. We could say it pushes C++'s polymorphic capabilities to their limit. Good luck understanding what it does... and surviving the shock ;-)
#100192 — OMGWFT-u-tron
by Andrew G
See the included text file for a "technical description". This calculator is modular - in all the wrong ways. Of course, actual documentation is part of the WTF. (Ok, each operation is a seperate class, but the only math that is actually performed is Division - aside from a single decrement.) It was designed using the GTK, and should build with a simple "make"
#100193 — StringCalc
Re-submit of StringCalc due to a little bugfix.
#100194 — DIYDIA - Do It Yourself and Do It Again
Imagine a consultant with a big ego who doesnt like floats writing a calculator app... based on a true story... Main features are: * Ad-hoc debugging and optimization. * Misunderstanding of programming guidelines (code reuse etc). * Partial testing. Test only what is needed and fix the rest later... * Unlimited patching. Never re-design. Just patch it up and send it out again.
#100195 — The Magic Calculator v6.0949164139895907e-8
by Huw Pryce
Does the maths using maths that I thought was the furthest away from the maths it was meant to be doing possible, as well as the expected WTFs.
#100197 — Don't Trust the Hardware
by Jennifer Elaan
When all you have is Verilog, everything starts looking like programmable hardware. This code assumes the underlying CPU has a very primitive ALU that supports only bit operations (bit shift, XOR, AND and OR), lacking any form of integer arithmetic. There are no instances of +,-,*,or /, used as operators, in the entire body of CalcFunc.cpp.
#100198 — Enterprisey Code that Smokes Hash
by Jennifer Elaan
A simple version of the hard-coded test cases calculator, with a bit of "how not to parse command line options" tossed in. Simply hashes the operation in progress, switches on the hash value, and returns the appropriate result. This code likely requires gcc, but since it's built with the gtk template, that should be obvious.
#100199 — CatchEverything
by Tobias Neukom
"Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified bug-ridden slow implementation of half of Common Lisp." (Philip Greenspun) That's certainly a very good advise. But to get better performance than a LISP interpreter I wrote a LISP Compiler in C++ template code instead of direct code. Since all code is translated at compile time the performance is much better (the C++ Compiler can optimize the resulting code).
#100200 — Intermediate Enterprise Expression Evaluator (IEEE)
This calculator is extensible through plugins. It has a very sophisticated interface and the calculation engine is highly optimized by avoiding slow down factors like negative numbers and alike.
#100202 — No floating point
Implemented my own floating point operator (except fdiv, because I ran out of time, and Intel can't get it wrong twice right?). I've implemented my own adder, and used it for the fp functions, but quite happily use the normal maths functions in the rest of the code. Also just for fun I've got a settings.xml file to define where the buttons go, what function they have, and the text on them. You know, just in case you wanted to have two "5" buttons or something. Seeing as it's an xml file, I just have a couple of xml nodes, which contain ":" delimited strings. Kind of like wrapping an ini f
#100204 — Ecumenicalculator
by Paul Kuliniewicz
I was dismayed that the GTK-based submissions will be tested on NetBSD. As a user of Debian, how can I be sure my code will work on NetBSD? I know next to nothing to NetBSD. Apparently it has a C++ compiler, and runs GTK. But what else? Does it suffer from the infamous FDIV bug? Can it do floating point? What about integer arithmetic? Heck, what about integers? Deciding to play it safe, I implemented my own numbers. Nowhere in the backend files that get linked in will you find *any* ints, shorts, longs, floats, or doubles, or any operations on them. I use what the STL provides,
#100206 — Rube Goldberg's Calculator
by Charles Nadolski
Some of the features of this project: -Caching of final values in xml for "faster" access later. -Pointless use of inline assembly. I hope the test machine has SSE2 instructions available. -Conversion of floats to fractions for "faster" and "more accurate" results -Abuse of bitfield types. -Storing positive and negative as enumerations... Divide by zero is the equivalent of FILE_NOT_FOUND -A homegrown XML parser.
#100207 — William's Totally Funky Calculator
by William Rose
In a sentence: my calculator is about effective reuse; a commoditised, component-driven, meta-programming approach that assembles small blocks of code (e.g. Windows' calc.exe) and makes a less functional whole. Of course, there's always got to be provision for extensibility! And easy deployment and maintenance!
#100209 — Calcohol 2
by Henrik Alsing Pedersen
This is one of those codes you just can never fully understand -- and yes, that was ment as a challenge for you ;D In short: - A Fully functional calculator - Buttons move around when you click them - Each digit uses half a byte of memory obtained through lowlevel byte manipulation - Awful usage of operation overloading, polymorphism, templates, exceptions and win32 API calls A success? Yes, and it's worse than failure..
#100212 — Google Math
by Steven Truelove
So web services are the future, right? Pretty soon, every program will just ask Google to do the heavy lifting, and this program is just one more step towards Sergei's inevitable global domination. Wait, one of the judges for the contest works for Microsoft -- and another works for Yahoo?
#100213 — OMGWTF Windows Calculator
by James Ng
There is no finer concept in Software Engineering than Code Re-use. After all, why re-write new code to do something that's been done before. Especially since many bugs would've been fixed. Well, this calculator takes that concept to heart.
#100216 — ToTheSpec
by Julian Biddle
Like many programmer tests I've had to check, this calculator will pass all the test cases exactly as required. The code however, is not terribly calculator like. ;)
#100217 — mmucalc
by Christian Söderström
mmucalc uses low level linux system memory handling capabilities to perform hardware (MMU) accelerated arithmetic operations.
#100218 — WtfCalc
This calculator, although it gives the correct results for the test case, is rather buggy, and can't really cope with advanced operations like dividing 2 by 0, or lots of decimal places, or the 'C' button. Debugging it would probably be easier if the debug build didn't crash. In order to save time calculating the string representation of numbers, the results of these are cached, although the method of caching may cause more problems than it solves.
#100219 — NumberMuncher
by T. Karpiniec
NumberMuncher is a highly advanced GTK+ calculator which contains special features such as automatic real number domain restriction and built in times tables. This software also allows gives your double precision memory allocations some decent exercise -- most calculator programs will severely under-utilise the space available. Come on, when's the last time you took your RAM for a walk anyway? Do it a favour. Use NumberMuncher.
#100224 — NuMath
by Pieter Bootsma (GeniusDex)
Compilation instructions and a sort of technical talk are in docs/README (hint: it's based on a NFA)
#100225 — The Calculator
I didn't try too hard to make it wtfish...
#100226 — DL's OMGWTF Calc
by David Lees
A windows based calculator using string processing instead of numbers to do the calculations. Complete with badly implemented wooden table interface and insulting error messages. Basic addition/subtraction done with singly digit loopup tables (case statements). Long multiplication done by lookup and addition. A division function that takes a simple method (www.doubledivision.org) and implements it in a overly complex and buggy way.
#100227 — The Way Web 2.0 Calculator
by Silverback Coder
Hardly any effort at all went into this baby, but it is pure genius, yes sir, enterprisey and web, heck, 3.0, and so simple. Couldn't be prouder of my little calculator. (Hoping for an honorable mention based on the "clever" design).
#100229 — Preschool emulation calculator
by Geert & Bertrand
Our mission in creating this calculator was to create a calculator that doesn't use + or - that uses calculating algorithms as they are taught to (dutch) kids. The secondary objective was to make it as buggy as possible without resorting to artificially putting in bugs. We wanted our calculator to be something that could be created by a bad programmer, not a calculator that was created by a good programmer trying to make a buggy application.
#100232 — SecureCalculator
by Gerco Dries
This calculator is designed to be ultimately secure. Various operations on the x86 processor can overflow and overflows can cause buffer overruns and other bad things. There is no other way to avoid this then to not use an x86 processor...
#100234 — contrivia calc
by Jan Willem
Instead of doing one incredibly weird way of calculating, I tried to fit in as many omg-instances as I could. Adding is (mostly) done at compile time, using templates. All others depend on the add operation. A pointer to the result (as a magic integer, causing 6/4 to be .15) is written to a log. The result is then replaced in place by a string representation. Afterwards, the string representation is retreived by parsing the log, and crudely casting it (pointer - 8) to the right type.
#100235 — XXXCalc
by Meir Maor
the eXcessively eXtensible Xml Calculator, Allows defining new operations in Xml file by [recursivly] using other operations. Supports using various mathematical systems as a compile time option. Solves arithmetic by repeatedly simplifying expressions. more details in README.txt/full description
#100236 — Laziness
by Tony Rudd
This calculator is meant to leak a lot of memory. For no reason at all. That's all I've got.
#100237 — The 4th Grader Calculator
by Andres I
A calculator that works with arbitrarily large numbers
#100238 — OMGWTF Calc!
by David Martens and Floris van Zonneveld
Floris had the brilliant idea to make an image based calculator, and so I (David) implemented it while Floris was drawing images in MS Paint. This release of the calculator comes with 121 images that display various states of the calculator. It is even possible to add your own states, and the calculator will automatically use them! Isn't that great?
#100239 — The Beast 101
Finally getting a serious project, the junior programmer remembers all those introduction classes into enterprise-level subjects like Model View Controller, Backus-Naur form, how efficient it is to calculate with a stack, the wonders of Reverse Polish Notation and how to automatically generate that from mere infix input. The results were... interesting. Maybe it was his misunderstanding of most subjects, maybe it was the C++ tactics applied in plain C. Either way, the project worked and a shining example of his enthousiasm. He was fired the next day. Attached is his calculator, which
#100242 — Recurecurecurecurculator
by Evert Koopman
Look mom, I just figured out how recursion works :D.
#100243 — Crapulator 2
by Peter K
It's still ass. I used codeblocks to code this then i tried compiling with that VC++ Express but it won't work and I'm going crazy. I just saved it. I hate computers and I hate programming.
#100244 — my first(and last) calc
This calculator assures you that the result is right, and it has got a new algorithm that allows you to have up to 2 decimals digits precission(version 2 will have 4)
#100248 — Metacalculator
by Ismael Barros (RazZziel)
Client-server calculator with realtime module compilation. And improved memory management. And a README thing.
#100249 — CalcUi/CalcServer
by Travis Miller
I have pushed the Model View Controller design pattern to its ultimate end. I have separated the model from the view by placing them in separate programs. My calculator is a pair of executables: calcui and calcserver, which communicate via tcp/ip. And in addition the calcui program is smart enough to start the server if it can't find one to communicate with. The communication between the two uses xml which makes it very cool too.
#100250 — Infinite Arithmetic Implementations* (*possible; 12 provided)
by Jonathan Pryor
The WTF is that it's well designed and isn't a WTF. :-) Declares an abstract base class for calculator operations and provides 12 different implementations (some less working than others). Calculator operation implementation can be specified via program parameter at program startup, and a set of unit tests exists (from the OMGWTF Test Cases page) to test all of the included implementations. Calculator implementations can also be hosted in a shared library so that additional implementations can be easily used in the future.
#100251 — OmGalculator
by Cory Burgett
OmGalculator is an extremely configurable standard-use calculator that can be configured for nonstandard use.
#100252 — Universal Calculator
by Greg D
Unlike traditional calculators which restrict you to working with only numeric values through hard-coding, the Universal Calculator features a robust plugin system that allows you to add, subtract, multiply, or divide anything...with anything! Includes plugins for numbers, colors, and pictures!
#100253 — Terry's Calculator
by Terry Lyons
The user interface was inspired by a post in the forums, someone wanted to see somebody do it and I couldn't resist the challenge. It leaks like a sieve, but doesn't use new/malloc/etc (not directly) and it only requires ~100MB of memory to run. It uses a mouse hook, XML and memory mapped files for no good reason. It uses a thread to do the calculations but ignores thread safety.
#100255 — true story
I've tried to imagine a true process of creating calc. As a result I have a calc which works in Fibonacci notation (storing fractional part in decimal). Uses parsing algorithm with errors and a bit strange UI. See full story in Full description. Sorry for poor english and thanks for such a funny contest.
#100257 — CalcFunc
Takes advantage of new technology including rand() to ensure the correct answer will eventually be found, and goto to speed up the program.
#100259 — IzzyCalc2
by Israel Brewster
Colorful and innovative two-button interface. Security features and interface design inspired by a major software maker. New back-end design utilizing chars and recursive functions rather than memory-hoging ints and boring loops. Build instructions: Designed for a *BSD system, simply cd into the source directory and type "make". Operations instructions: Simply press the left button until the desired number/operation is displayed in the upper box, then press the right button ("E") to accept the value/operation. Couldn't be simpler :) p.s.-this submission supersedes my previous submissi
#100262 — CircuitSimulation
by Gregory Lee
Simulates all calculation as basic logic gate inter-connections.
#100263 — jta_calc
by James Ahlborn
The underlying Number class encapsulates an arbitrary precision decimal number. This class combines the power of arbitrary precision with the speed of table based lookups creating the ultimate number class!
#100264 — HashCalc Pro
by Michael Quinn
HashCalc Pro initially does calculations the same way you learned in elementary school, but the real efficiency comes from the hash table. Every time you perform a calculation, the result is stored in a hash table for efficient calculation later. Even better, no memory or CPU time is wasted checking for hash table collisions; that stuff never happens anyway when you have a 317-element hash table. As for the name of the calculator, it was originally going to be HashCalc but I added "Pro" because "Pro" makes it sound important.
#100265 — FerronCalc
by Dennis Ferron
Why this is worth a look: - Every Number from 0 to 99 is implemented as a different class! -Numbers are defined by their prime factors, using some very bizarre template inheritance. - You could probably patent my "reverse-virtual" functions and sue me for infringing myself. - Funny code comments.
#100267 — | WS_TINY |
by Ametheus Inurbanus
An extremely small calculator. Uses an implementation of early 17th century English Poetry, along with a Befunge/Brainfuck hybrid language.
#100268 — The Highly-Intelligent-Autolearning OMGWTF Calulator
The calculator uses neural networks for learning the AND, OR and XOR functions. From these a binary full-adder is built, which is used for all calculations.
#100270 — JASP aka Just Another Skeleton Project
by Alexia Death
Well, since only bug I know well enough to generate feely is memory leaking, it leaks a lot, in fact every time you calculate something it leaks. It also features some pointles arbitraition and some rewriting of standard functions in a nonstandard way and some "ergonomics" based on Google contest :D... Its my third ever C++ program so there may be some authentic bugs aswell:P Enjoy!
#100271 — Third Grade Computing
This caluclator does its calculating using the same methods taught in the third grade.
#100272 — Unholy Waste of CPU Power
This calculator calculates by setting a temporary variable to -9999999, and increasing it by one until it equals to the right answer.
#100273 — OMGWTFCalc
by Rev. Johnny Healey
My calculator uses a revolutionary button optimizer that moves the most useful buttons to the top. This is implemented with my patented FastSort(TM) algorithm that always outperforms quicksort.
#100275 — Forth Calculator
by Steve Burnap
A calculator back end using what one programmer thinks is an interesting Forth implementation.
#100279 — Calculate
A bad program.
#100280 — conditionals are for wusses, real programmers use goto!
the name says it all! (Plus some other fun stuff ;)
#100281 — NQAPLPCOLPISC
by Todd Neal
NQAPLPCOLPISC: The N-Queen, Arbitrary Precision, Lexing, Parsing, Compiling, Optimizing, Lexing, Parsing, Interpreting, Simulating, Calculator From digits represented as chess boards (represented as solutions to a particular N-queen problem), an optimizing compiler, virtual machine, an interpreter for a lisp-like language to arbitrary precision math and animated scissors and running men, NQAPLPCOLPISC pretty much includes it all.
#100283 — Ultra-Compatible WTFCalc 1.01
by Dark Shikari
Many platforms don't support floating point arithmetic. Some don't support integer arithmetic. Some don't support logical operations. Some might not even support bitshifts. The WTFCalc is here to solve this problem: it only uses five operations: &, ==, !=, =, and ~. All floating point operations are done using integer operations which are reimplemented using these operators which are... you get the idea! Much more information is available in the comments in CalcFunc.cpp.
#100285 — The OMGWTF Calculator Left-Handed Edition
I modified the Win32 skeleton UI a bit to make it easier to be used by left-handed persons.
#100286 — The OMG-WTF-ulator
The omg-wtf-ulator is a fully featured calculator which, working along the greatest principals of wtf-ery is primed to meet the needs of each test case exactly, and using a method fond to the programmer but probably otherwise unheard of.
#100289 — ParanoiaCalc
by Vita Szabolcs
The paranoia in this calculator is that we cannot assume that every computer and every compiler works with the IEEE 754 floating-point standard. So extra care was taken to make it as platform-independent as possible. (yes, of course..) I was not aiming at the 2. criteria (buggy), but mostly at the 3rd one (clever) I did not want to obfuscate with #defines, neither to create threads and stuff like that just to add new sources of WTFs and bugs. Everything, every (khmmm.. well.. almost every) line in the program has a USEFUL purpose, and addig more would decrease the efficiency! And the t
#100290 — ConveyorCalc
by Jesse Merriman
My submission tries to use the idea of conveyor belts that get boxes dropped on them, do something with the boxes, and haul the result off to another belt (or output it). Why? Never ask that. Some belts accept two numbers, perform an operation on them, and spit out the result. Others handle user input or output. See my Readme file for more info.
#100291 — The Scalable Calculator
by Håvard Skinnemoen
This simple calculator uses a tabbed GUI with one operator (+, -, *, /) per tab. Each tab has a thread controlling it and a number of vertical sliders that are used to enter digits into the calculator. Each vertical slider has its own thread as well. A horizontal slider at the bottom of each tab controls the number of vertical sliders available for entering number. With the maximum of 10 sliders per tab and four tabs, the calculator may spawn up to 46 threads.
#100294 — Brainfsk Variation
by Kellen Mickley
Emulates a faux-accumulator architecture instruction set and a brainfsk interpreter. Doesn't handle division well.
#100295 — Caching Google-Leveraging Calculator
by Rod McFarland
The calculator saves processing time by a) caching the results of expensive arithmetic operations in a linked list, and b) leveraging Google (if available) to perform the actual calculation. For caching simplicity all operations are converted to additions, via logarithms if necessary. The use of the false-if-not-zero operator (!!!) is featured in the DoDiv function.
#100297 — math is hard
by Kevin Vigor
Templates, RTTI, on-the-fly compilation and a rule based system, oh my!
#100298 — 26in HD Ready LCD TV
by Raja Mukherji
High Definition (HD) TV
#100299 — Calculon
by Andre Weßeling
This is the second try. Please use the description from the first try.
#100300 — LOLculator
Why reinvent the wheel when Windows already comes bundled with a calculator capable of doing basic calculations? This program acts as an innovative wrapper for the Windows Calculator.
#100301 — Calc
by Jason Patterson
Abides by the quintessential OMGWTF patterns and practices.
#100302 — Operator OCD
by Lee Crabtree
After my first entry, I decided I could do worse. So I rolled up my sleeves and attempted to remove all mathematical operators (+, -, *, /) from my code. Unfortunately, I failed completely. But hey, that's what the site is about, isn't it? This builds off the ludicrous base I started with, doing as much arithmetic as possible in binary. That's probably the cause for my desire to never see another document outlining the IEEE 754 standard for storing floating-point numbers.
#100305 — The String calculator
by Tatu Lahtela
All good programmers know that the best way to calculate is to use strings and string comparisons. So basic operations are done with strings. Badly. Inconsistently. Only an implementation of the CalcFunc.cpp
#100306 — Enterprise Turing Machine Calculator
by Pretty Hate Machine
Enterprise Turing Machine Calculator is a general purpose calculator program based on Object-Oriented Turing Machines. During calculations everything is an object and there is no memory deallocation. Did I mention that this is my first C++ program? So much Enterprise!
#100308 — CalcFS 1.1
Slightly updated version of CalcFS 1.0, based on the same (mis)usage of the file system. Added some extra template / typeid code that should never have seen the light of day.
#100312 — The Written to Spec Calculator
by Mark Brents
This calculator will pass all the test cases (but isn't guaranteed to do much else!)
#100313 — Iterative-recursive-greedy-binary-calculator.
by Sebastián Santisi
Iterative addition. Recursive subtraction. Greedy multiplication. Divide & conquer division. The iterative-recursive-greedy-binary-calculator takes the worst of every simple case.
#100314 — POS
by Free Beer
I based the solution on solving a real world in a real world manner. However, I can only count by using my fingers. Naturally, this made division quite difficult.
#100315 — NOOB-Calc
by Adam Shelly
The Numeric Object Oriented Button Calculator (NOOB-Calc) is designed based on one simple theory: Objects are good, but c++ numbers are not objects. So they must be replaced with a well designed number class. Therefore, I have created class Number, and it's subclasses One, Two, Three, etc. There are no digits in the source or headers for these classes. Known bugs: Too many to list, but mainly: -doesn't handle long division -has trouble with decimal points -leaks memory like crazy.
#100316 — Calc - OMGWTF Edition
by John Skoda
My calculator uses bit-shifting, bitwise operations, and a few other things to accomplish what it does. It may take a bit of work to maintain the code...which I suppose was half the point in the first place.
#100317 — Calculator 2.0 Notwork Edition
by Max Rabkin
C2NE is an Enterprise-level Numerical Productivity Suite C2NE leverages proven technologies from Artificial Intelligence, Enterprise Software Design and Calculus-based Management. It cuts through the S-Expression vs. XML debate by using both, combined in an XML Lisp interpreter, in which database routines are written for RAD advantage. C2NE uses cutting-edge techniques for speed and accuracy. It will be a valuable addition to any software portfolio
#100318 — Roman Calculator
by Gregor X Stocks
The new Roman Calculator from Proprietech. Unlike some unreliable, insecure calculator applications, the Roman Calculator uses a proprietary, yet portable, roman-numeral based format for internal representations of numbers. This means that hackers can't steal your valuable numbers, but you can still share them across machines.
#100319 — XP-WTF
Extreme Programming gone extreme - took the provided gtk-skeleton as the base, threw out lots of redundant and superflous code in CalcFunc.cpp (switch/case, more functions than any sane person could need) and added The One Line that does all the 'magic' - voila! Testcode/Skeleton/'real'-code-ratio: ca 350/120/1 (calculation done with submission-tool, so no guarantees on exact numbers) All WTF-testcases are included, so you just have to 'make', read '0 fails' and send 1st price to my email.
#100320 — ChickenCalc
by Chicken Little
A text based calculator. All calculations are done using text only.
#100323 — Calc
by Daniel Ray
All but division limited to integer results. Bit-level for addition, multiplication.
#100324 — The UnLogic Calculator
This calculator is based on some very simple digital circuit simulator, so its internals works somewhat like a real hardware calculator does. But not the whole calculator is simulated, some parts are implemented in native software, interacting with the simulated parts in "interesting" ways.
#100328 — goplatcalc
It seems native code is falling out of favor these days -- virtual machines like Java and .NET are all the rage. But most of them are still too tightly coupled to the host CPU, since of course the VM itself must be written natively. So I decided to take the abstraction up another notch and make the core of my interpreter be an ASCII diagram of logic gates. It runs a little slow now, but hopefully decreasing font sizes will take care of that.
#100330 — The Rembinator
by Rembrand van Lakwijk
This OMGWTF calculator was implemented without using the ++, --, +, -, / and * operators, while and for loops, and if statements that do anything more than goto or return (well there are a few exceptions, but that's just because nested, indented if-blocks look so damn sexy). Each of the 4 operations is implemented differently, each WTF-y in it's own way. All I can say is that it needs to be able to access www.google.com/search, and it uses calc.exe. The rest is in the readme and comments. Enjoy!
#100331 — MetaCalc
by Tom Felker
I based this entry, MetaCalc, on a project I was recently involved in, and it suffers many of the same problems. Labor was prematurely and poorly divided between many teams, feature creep was rampant, and implementation was delayed until last minute, with predictable results. There is some pretty interesting code, some which is very flexible, some which is very fragile, and all of which is pretty convoluted and stupid, though hopefully readable and maintainable. The framework remains largely unchanged, as the various groups were somewhat rushed, and didn't communicate their changes to the
#100332 — Pandoora's Calculator #4
Inspired by IBM's Pandoora architecture, with specialized DWIM-based Programmer Error mitigation logic, a custom high accuracy math library, gratuitous namespace pollution, and const incorrectness.
#100333 — Automated Calc
#100334 — Malificent Calculatory Strithmatic
The dark art of strithmatic prevails. Turd-polishing at its worst. The intent was to capture the essence of some of the spectacular work done by one of the "talent" at my work. Creating solutions to problems that weren't problems until the solutions were written.
#100335 — TextCalc
Text-based GUI calculator (think VB/Dos; Alex confirmed this is legal) with a wide assortment of memory leaks, gratuitous abuse of const/mutable, and some terrible math algorithms.
#100336 — VICE, Virtual Integrated Circuit Engine
by Randolpho St. John
This contest entry makes use of the Virtual Integrated Circuit Engine (or VICE) for arithmetic calculation. VICE is an integrated circuit simulation engine. At its heart are two main components: the VirtualTransistor, which simulates the switch-like qualities of a transistor, and the VirtualConnection, which simulates the current and voltage that flows through the wires of an Integrated Circuit. From these are built logic gates, which in turn are components for binary adders, and so forth.
#100337 — Worthwhile Thingie Formulationator
by Anthony Galica
A nice calculator that uses a lot of addition and stuff.
#100338 — YanaX4
by Yana Malysheva
The calculator uses 4 different computation methods and averages the results together. (See comments inside code for detailed explanation of the methods)
#100341 — SneakyCalc
by Nate Jones
Nate's OMGWTF Calculator. My rationale: Good programmers follow the following guidelines: 1) Work smarter, not harder. 2) Math is hard. 3) If possible, have a trusted 3rd party do the heavy lifting. (In this case, that means making someone else do the math for me).
#100342 — ExtensibleCalc
by James Ng
In the year 3000, the world has ended twice, and then rebuilt itself. (Cue Futurama theme). One of the many things that the alien invaders have done is re-write the rules of mathematics. A scroll from the year 3000 details this new math. The elite software consultants decided to ensure the software will work all the way through the year 3000. To facilitate this, they insist that everything be extensible. So when the rules of mathematics are re-written, this calculator will work.
#100343 — calc
by Raymond Martineau
This calculator meets the requirements using an arbitrary precision number system, built from scratch.
#100344 — Confuggle
by Chris A
I tried to keep things as simple as possible!
#100346 — #define NUMBER calculator
by S Greene
#if char* were NUMBERs... Math operations performed with strings (digit by digit) with some interesting side effects/broken operations.
#100348 — VertexCalc
by Paul Gaspardo
This calculator was supposed to do its math mostly by following paths between nodes on a graph. Nodes are managed on a statically allocated heap using a garbage collection scheme, with the help of a bunch of C macros shadowing various common control structures and statements, forming a sort of VB-like FrankenC. In the end I ran out of time, and was left with an uncommented, unfinished, not totally tested slab of code in which not even addition worked completely.
#100349 — ConsoleCalc V3
by Joe Bott
This calculator is a console application, with a Windows-ish GUI hacked on with some trickery. Most drawing code was some by hand instead of using Win32 API functions. A genetic algorithm was used to create the font. When the program is first started, you'll be presented with a blank black console window. Left-click in the window to get the calculator rolling. Try clicking in other windows with "ConsoleCalc" in the name for more fun!
#100351 — The OMGWTF Calculator Add-On
by Tborg Poppodopolus
This calculator is special because it makes use of the PC Speaker. It also has great delegation skills. Please see OMGWTF_CALCULATOR_DOCUMENTATION.doc in the .zip file for screenshots.
#100352 — c^3!
by Michael Wozniak
multi threaded super calculator this calculator never does a calculation twice, it caches all the calculations