A little node.js script containing answers to practice problems for a freshman programming class I teach

freshman-practice.js

// These are answers to practice problems for the freshmen.
//
// Note they mignt not be the fanciest possible solutions because they are
// problems for a beginner class.

var sameLength = function (a, b) {
    return a.length === b.length;
}

var evenlyDivides = function (x, y) {
    return y % x === 0;
}

var isInteger = function (x) {
    return x % 1 === 0;
}

var uppercaseName = function (p) {
    p.name = p.name.toUpperCase();
}

var roots = function (a, b, c) {
    var d = Math.sqrt(b*b - 4*a*c);
    return [(-b + d) / 2*a, (-b - d) / 2*a];
}

var midpoint = function (p, q) {
    return new Point((p.x+q.x)/2, (p.y+q.y)/2);
}

var allAreSquares = function (a) {
    return a.every(function (x) {return isInteger(Math.sqrt(x))});
}

var haveSameSetOfCharacters = function (s, t) {
    // This is the straightforward, not-necessarily-fast, solution
    // It is awful because it is not DRY.  But sometimes, on a timed
    // quiz, students can get away with this.
    for (var i = 0; i < s.length; i++) {
        if (t.indexOf(s[i]) < 0) {
            return false;
        }
    }
    for (var i = 0; i < t.length; i++) {
        if (s.indexOf(t[i]) < 0) {
            return false;
        }
    }
    return true;
}

var earliest = function (firstDate, secondDate) {
    if (firstDate.year < secondDate.year) {
        return firstDate;
    } else if (secondDate.year < firstDate.year) {
        return secondDate;
    } else if (firstDate.month < secondDate.month) {
        return firstDate;
    } else if (secondDate.month < firstDate.month) {
        return secondDate;
    } else if (firstDate.day < secondDate.day) {
        return firstDate;
    } else {
        return secondDate;
    }
}

var chain = function (functions, value) {
    var result = value;
    for (var i = 0; i < functions.length; i++) {
        result = functions[i](result);
    }
    return result;
}

// Now here are some tests. I didn't teach the freshmen Mocha. I probably
// should have.

var assert = function (condition, message) {
    if (!condition) {
        console.error('FAIL' + (message ? ': message' : ''));
        process.exit(1);
    }
}

var assertEquals = function (actual, expected) {
    if (actual.toString() != expected.toString()) {
        console.error('FAIL: expected ' + expected + ', got ' + actual);
        process.exit(1);
    }
}

assert(sameLength([], []));
assert(sameLength([4], [false]));
assert(sameLength([[], [], []], [null, undefined, {}]));
assert(!sameLength([], [2]));
assert(!sameLength("abc", "ab"));
assert(!sameLength([[], [], []], "33"));

assert(evenlyDivides(1, 4));
assert(evenlyDivides(8, -64));
assert(evenlyDivides(1.5, 3));
assert(evenlyDivides(66, 132));
assert(evenlyDivides(1e9, 1e12));
assert(!evenlyDivides(66, 1328793));

assert(isInteger(-34785445))
assert(!isInteger(-34785445.003))
assert(isInteger(785445))
assert(!isInteger(NaN))
assert(!isInteger(Infinity))

var p = {name: 'Rex'}
uppercaseName(p);
assert(p.name === 'REX');

assertEquals(roots(1, -5, 6), [3,2]);
assertEquals(roots(1, -5, -6), [6,-1]);
assertEquals(roots(1, 0, 2), [NaN, NaN]);

var Point = function (x, y) {this.x = x; this.y = y;}
var m = midpoint(new Point(8,3), new Point(2,17));
assertEquals([m.x, m.y], [5,10]);

assert(allAreSquares([]))
assert(allAreSquares([4, 1, 100]))
assert(!allAreSquares([4, 2, 100]))

assert(haveSameSetOfCharacters("aaaaaa", "aa"));
assert(haveSameSetOfCharacters("aaaabaa", "baa"));
assert(haveSameSetOfCharacters("#$%", "%%%$%%#"));
assert(!haveSameSetOfCharacters("aaaaaa", "aab"));
assert(!haveSameSetOfCharacters("aaabaaa", "aa"));
assert(!haveSameSetOfCharacters("xy", "z"));

assertEquals(earliest({year: 5, month: 3, day: 7}, {year: 4, month: 2, day: 8}),
    {year: 4, month: 2, day: 8})
assertEquals(earliest({year: 5, month: 3, day: 7}, {year: 6, month: 1, day: 9}),
    {year: 5, month: 3, day: 7})
assertEquals(earliest({year: 5, month: 3, day: 7}, {year: 5, month: 2, day: 8}),
    {year: 5, month: 2, day: 8})
assertEquals(earliest({year: 5, month: 3, day: 7}, {year: 5, month: 4, day: 9}),
    {year: 5, month: 3, day: 7})
assertEquals(earliest({year: 5, month: 3, day: 7}, {year: 5, month: 3, day: 5}),
    {year: 5, month: 3, day: 5})
assertEquals(earliest({year: 5, month: 3, day: 7}, {year: 5, month: 3, day: 8}),
    {year: 5, month: 3, day: 7})

var square = function (x) {return x * x}
var half = function (x) {return x / 2}
var plusTwo = function (x) {return x + 2}
assertEquals(chain([square, half, plusTwo], 5), 14.5)

console.log('OK');