Python codejam runner plus tongues solution

Author: ddamiani

.gitignore

@@ -0,0 +1,9 @@
+# Python stuff
+*.pyc
+*.egg-info/
+# Virtualenv stuff
+.Python
+bin/
+include/
+lib/
+man/

README.md

@@ -0,0 +1,6 @@
+Google CodeJam Solutions
+========================
+
+These are my solutions to some of the Google CodeJam problems from past
+contests that I did for fun. This repository contains Python (2.7)
+implementations of one I had previously done in Java.

script/run_tests

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Runs pep8, pylint, and unittests
+BASE_DIR="$( cd "$(dirname "$0")/.." ; pwd -P )"
+SRC_DIR="${BASE_DIR}/src"
+PACKAGES="codejam"
+STATUS=0
+
+exit_msg() {
+    if [ $? -eq 0 ]; then
+        echo "All tests succeeded."
+    else
+        echo "Exiting on test failures."
+    fi
+}
+
+# test if pep8 exists
+if ! hash pep8 2>/dev/null; then
+    echo "pep8 is not on the path!"
+    exit 1   
+fi
+
+# test if pylint exists
+if ! hash pylint 2>/dev/null; then
+    echo "pylint is not on the path!"
+    exit 1
+fi
+
+# test if nose exists
+if ! hash nosetests 2>/dev/null; then
+    echo "nosetests is not on the path!"
+    exit 1
+fi
+
+# Run all the tests
+trap exit_msg EXIT
+set -e
+for package in ${PACKAGES}
+do
+    pep8 "${SRC_DIR}/${package}"
+    pylint "${SRC_DIR}/${package}"
+    nosetests "${BASE_DIR}"
+done

script/setup_venv

@@ -0,0 +1,34 @@
+#!/bin/bash
+# Sets up a virtual env for the python code
+
+PACKAGE_DIR="$( cd "$(dirname "$0")/../" ; pwd -P )"
+ENV_DIR=".venv"
+SETUP_CMD="develop"
+PROMPT_NAME="(codejam-python)"
+
+cd -- "${PACKAGE_DIR}"
+
+# check if virtualenv is installed
+if ! hash virtualenv 2>/dev/null; then
+    echo "Virtualenv is not installed!"
+    exit 1
+fi
+
+# check if there is a valid python project
+if [ ! -f "${PACKAGE_DIR}/setup.py" ]; then
+    echo "The directory ${PACKAGE_DIR} doesn't appear to contain a Python project!"
+    exit 1
+fi
+
+# Remove existing virtualenv
+if [ -d "${ENV_DIR}" ]; then
+    rm -r -- "${ENV_DIR}"
+fi
+
+# setup the virtualenv and install the package
+set -e
+virtualenv --prompt="${PROMPT_NAME}" "${ENV_DIR}"
+source "${ENV_DIR}/bin/activate"
+# install pylint and pep8 in venv
+pip install pep8 pylint nose
+python setup.py "${SETUP_CMD}"

setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+setup(
+    name = "codejam",
+    version = "0.0.1",
+    author = "Daniel Damiani",
+    author_email = "dsdamiani@gmail.com",
+    description = ("Python versions of Google Codejam problems."),
+    license = "BSD",
+    keywords = "codejam google",
+    url = "None",
+    package_dir={'': 'src'},
+    packages=find_packages('src'),
+    entry_points={
+        'console_scripts': [
+            'codejam-runner = codejam.main:main',
+        ],
+    }
+)

src/codejam/__init__.py

@@ -0,0 +1,9 @@
+'''
+codejam - Package for all modules related to codejam solutions
+'''
+
+try:
+    __version__ = \
+        __import__('pkg_resources').get_distribution(__name__).version
+except ImportError:
+    __version__ = 'unknown'

src/codejam/codejambase.py

@@ -0,0 +1,63 @@
+'''
+The base input/output handling class for codejam problems
+'''
+
+
+class CodeJamBase(object):
+    '''
+    The base class for all codejam solutions
+    '''
+
+    def __init__(self, input_file, output_file, test_mode=False, line_case=1):
+        self.input_file = input_file
+        self.output_file = output_file
+        self.test_mode = test_mode
+        self.line_case = line_case
+        self.num_cases = 0
+        self.lines_consumed = 0
+        self.lines_emitted = 0
+
+    def solve(self):
+        '''
+        The function to call to kick off the solving of the problem
+        '''
+        try:
+            self.num_cases = int(self.input_file.readline())
+        except ValueError:
+            print 'The input file is malformed: No number of cases specified'
+            return 3
+        return self.run()
+
+    def run(self):
+        '''
+        Runs the actual implementation of the problem solving. This is meant to
+        be overridden in the inheiriting class
+        '''
+        self.output_file.write("Number of cases: %d\n" % self.num_cases)
+        self.output_file.write("No problem implemented\n")
+        return 1
+
+    def read_input_line(self):
+        '''
+        Reads of a line of input from the test input source.
+
+        It prints an error if more input lines have been read than expected
+        based on the config
+        '''
+        if self.line_case > 0 and self.lines_consumed > self.num_cases * \
+           self.line_case:
+            print 'All intended input lines (%d) have already been consumed!' \
+                  % self.num_cases * self.line_case
+
+        current_line = self.input_file.readline()
+        if current_line:
+            self.lines_consumed += 1
+            return current_line.rstrip()
+
+    def emit_output_line(self, output_line):
+        '''
+        Emits a single line of output in the appropriate format.
+        '''
+        self.output_file.write('Case #%d: %s\n' %
+                               (self.lines_emitted + 1, output_line))
+        self.lines_emitted += 1

src/codejam/main.py

@@ -0,0 +1,125 @@
+'''
+The main console script for the Python solutions to the Codejam problems
+'''
+import sys
+import inspect
+import pkgutil
+import importlib
+import argparse
+import codejam
+from codejam.codejambase import CodeJamBase
+
+
+def run_func(args):
+    '''
+    Runs the specified Codejam problem if it exists
+    '''
+    try:
+        proj_mod = importlib.import_module('codejam.%s.runner' % args.problem)
+
+        def valid_class(obj):
+            '''Simple predicate function used to inspect the module'''
+            return inspect.isclass(obj) \
+                and proj_mod.__name__ == obj.__module__ \
+                and issubclass(obj, CodeJamBase)
+
+        class_list = inspect.getmembers(proj_mod, valid_class)
+        if len(class_list) != 1:
+            print 'The chosen solution %s is invalid:' % args.problem, \
+                  'It contains %d CodeJamBase classes' % len(class_list)
+            return 2
+
+        print 'Running the \'%s\' Codejam solution:' % args.problem
+        if args.output_file != sys.stdout:
+            print 'Solution output written to \'%s\'' % args.output_file.name
+        # the class we want in the first entry in the list and 2nd in the tuple
+        solver = class_list[0][1](args.input_file, args.output_file)
+        return solver.solve()
+    except ImportError:
+        print 'No Codejam problem named \'%s\'' % args.problem
+        return 2
+
+
+def list_func(_):
+    '''
+    Lists all available Codejam solutions
+    '''
+
+    print 'Listing all available Codejam solutions:'
+
+    for _, modname, _ in pkgutil.iter_modules(codejam.__path__):
+        try:
+            importlib.import_module('codejam.%s.runner' % modname)
+            print modname
+        except ImportError:
+            pass
+        #print "Found submodule %s (is a package: %s)" % (modname, ispkg)
+
+
+def parse_cmdline():
+    '''
+    Parses the commandline args for the codejam problem
+    '''
+    parser = argparse.ArgumentParser(
+        description='Command line runner for Google Codejam solutions'
+    )
+
+    parser.add_argument(
+        '--version',
+        action='version',
+        version='%(prog)s ' + codejam.__version__
+    )
+
+    subparsers = parser.add_subparsers(title='subcommands')
+    parser_run = subparsers.add_parser(
+        'run',
+        description='Comand for running a specific Codejam solutions',
+        help='runs a specific Codejam solution',
+    )
+
+    parser_run.add_argument(
+        'problem',
+        metavar='PROBLEM_NAME',
+        help='the name of the Codejam problem to run'
+    )
+
+    parser_run.add_argument(
+        'input_file',
+        metavar='INPUT_FILE',
+        type=argparse.FileType('r'),
+        help='input file for the Codejam problem'
+    )
+
+    parser_run.add_argument(
+        'output_file',
+        metavar='OUTPUT_FILE',
+        nargs='?',
+        type=argparse.FileType('w'),
+        default=sys.stdout,
+        help='optional output file for the Codejam problem'
+    )
+
+    parser_run.set_defaults(func=run_func)
+
+    parser_list = subparsers.add_parser(
+        'list',
+        description='Comand for listing available Codejam solutions',
+        help='lists available Codejam solution'
+    )
+
+    parser_list.set_defaults(func=list_func)
+
+    return parser.parse_args()
+
+
+def main():
+    '''
+    Main function: parses the args and calls the proper codejam problem
+    '''
+    try:
+        args = parse_cmdline()
+        return args.func(args)
+        #for line in args.input_file:
+        #    args.output_file.write(line)
+    except KeyboardInterrupt:
+        return 1

src/codejam/tongues/__init__.py

@@ -0,0 +1,3 @@
+'''
+The package containing all the code for the Tongues Code Jam problem
+'''

src/codejam/tongues/data.py

@@ -0,0 +1,64 @@
+'''
+Module containing the translation data
+'''
+
+
+NORMAL_LETTERS = '''
+our language is impossible to understand
+there are twenty six factorial possibilities
+so it is okay if you want to just give up
+zq
+'''
+
+
+MUTATED_LETTERS = '''
+ejp mysljylc kd kxveddknmc re jsicpdrysi
+rbcpc ypc rtcsra dkh wyfrepkym veddknkmkrkcd
+de kr kd eoya kw aej tysr re ujdr lkgc jv
+qz
+'''
+
+
+class Translator(object):
+    '''
+    Class for performing translations
+    '''
+
+    def __init__(self):
+        self.normal_dict = None
+        self.mutated_dict = None
+
+    def _load(self):
+        '''
+        Loads an initializes the dictionaries
+        '''
+
+        self.normal_dict = {}
+        self.mutated_dict = {}
+
+        for norm, mut in zip(NORMAL_LETTERS, MUTATED_LETTERS):
+            self.normal_dict[norm] = mut
+            self.mutated_dict[mut] = norm
+
+    @classmethod
+    def _get(cls, translator, value):
+        '''
+        Function for performing the letter translation
+        '''
+        return "".join([translator.get(c) for c in value])
+
+    def get_mutated(self, value):
+        '''
+        Returns the mutated letter corresponding to the given normal letter
+        '''
+        if self.normal_dict is None:
+            self._load()
+        return self._get(self.normal_dict, value)
+
+    def get_normal(self, value):
+        '''
+        Returns the normal letter corresopnding to the given mutated letter
+        '''
+        if self.mutated_dict is None:
+            self._load()
+        return self._get(self.mutated_dict, value)