Last minute touchups

Author: dpatti

Rakefile

@@ -216,6 +216,47 @@ end
 task :brute, :slug do |t, args|
   config['problems'].each do |slug, cfg|
     if !args[:slug] || args[:slug] == slug
+      print "Brute-forcing #{ slug }"
+      require slug_dir.call(slug, 'problem.rb')
+      cls = ProgComp.const_get(slug.capitalize)
+      problem = cls.new
+
+      unless problem.respond_to?(:brute)
+        puts "...skipped"
+      end
+
+      require 'stringio'
+      input = StringIO.new("1\n" + problem.enum_for(:generate, {}).to_a.join("\n"))
+
+      require 'timeout'
+      begin
+        Timeout::timeout(5) do
+          problem.brute(input){}
+        end
+
+        # It... finished.
+        puts
+        raise Problem::GenerationError, "#{ slug.capitalize } finished a brute-force. Bad."
+      rescue Timeout::Error
+        # Good, it failed! Let's check how badly
+        if problem.bruted * 24 > 0.25
+          # It would have gotten a quarter of the way on this one; that's not a good sign
+          puts
+          raise Problem::GenerationError, "#{ slug.capitalize } needs more umph!"
+        end
+        puts "...success (#{problem.bruted * 24})"
+      end
     end
   end
 end
+
+task :solve, :slug do |t, args|
+  raise "Slug required" unless args[:slug]
+  require slug_dir.call(args[:slug], 'problem.rb')
+  cls = ProgComp.const_get(args[:slug].capitalize)
+  problem = cls.new
+
+  problem.solve(STDIN) do |s|
+    puts s
+  end
+end

config.yml

@@ -3,7 +3,7 @@ test_files: 50
 
 # Number of test cases to include per file (including edge cases)
 test_cases:
-  devel: 20
+  devel: 200
   prod: 200
 
 semester: spring2013
@@ -18,7 +18,8 @@ problems:
       - runner_andrew.py
 
   fitness:
-    runners: []
+    runners:
+      - runner_andrew.py
 
   shaving:
     runners:

spring2013/fitness/problem.rb

@@ -6,9 +6,9 @@
 module ProgComp
   class Fitness < Problem
     def generate args
-      depth = 3..6
+      depth = 5..6
       breadth = 2..3
-      value = 50..10000
+      value = 1..100000
 
       talents = {}
       talents[1] = [0, 0]
@@ -31,7 +31,7 @@ def generate args
 
       gen.call(1, 1)
 
-      yield "%d %d" % [talents.size, rand(3..leaf/2)]
+      yield "%d %d" % [talents.size, rand(3..leaf/3)]
       talents.each do |id, data|
         yield "%d %d %d" % [id, *data]
       end
@@ -98,19 +98,25 @@ def solve stdin
 end
 
 if __FILE__ == $0
-  ProgComp::Talent.new do |p|
+  ProgComp::Fitness.new do |p|
     p.solve(DATA) do |s|
       puts s
     end
   end
 end
 __END__
-1
+2
 7 2
-1 0 0
+1 0 10
 2 1 10
 3 1 10
 4 2 30
 5 2 25
 6 3 20
-7 3 20
+7 3 15
+5 2
+1 0 10
+2 1 10
+3 1 50
+4 3 5
+5 3 15

spring2013/fitness/runner_andrew.py

@@ -0,0 +1,69 @@
+"""
+Solution to the fitness problem in UPE's Spring 2013 programming competition
+
+@Author Andrew Karnani
+@Version 3/24/13
+"""
+
+
+import sys
+
+
+def readProblem():
+    tree = {}
+    leaves = set()
+
+    skills, choose = map(int, sys.stdin.readline().split(" "))
+
+
+    for i in range(skills):
+        skill = sys.stdin.readline()[:-1].split(" ")
+
+        tree[skill[0]] = (skill[1], int(skill[2]))
+        leaves.add(skill[0])
+        leaves.discard(skill[1])
+
+
+    return tree, leaves, choose
+
+def solve(tree, leaves, choose, used):
+
+    chosen = []
+
+    for i in range(choose):
+        result = []
+        for leaf in leaves:
+            result.append((leaf, value(leaf,tree, used)))
+
+        skill = max(result, key=lambda x: x[1])[0]
+
+        chosen.append(skill)
+
+        while skill != '0':
+            used.add(skill)
+            skill = tree[skill][0]
+
+    return chosen
+
+
+def value(skill, tree, used):
+    if skill not in tree:
+        return 0
+
+    if tree[skill][0] == 0:
+        return 0 if skill in used else tree[skill][1]
+
+    return (0 if skill in used else tree[skill][1]) + value(tree[skill][0], tree, used)
+
+
+
+
+
+num = int(sys.stdin.readline())
+
+for i in range(num):
+    tree, leaves, choose = readProblem()
+    chosen = solve(tree, leaves, choose, set())
+    print " ".join(sorted(chosen, key=lambda x: int(x)))
+
+

spring2013/shaving/problem.rb

@@ -4,14 +4,14 @@ module ProgComp
   class Shaving < Problem
 
     def generate args
-      days = rand(10..100)
+      days = rand(50..100)
       obs = days * 5 / 6 + rand(1..10)
-      const = rand(1000..3000)
+      const = rand(100000..300000)
       #  require 'prime'
       # const = Prime.take(20)[10..-1].sample
 
       yield "%d %d %d" % [days, const, obs]
-      obs.times.map { [rand(2..days), rand(100..const)] }.sort_by(&:first).each do |d, h|
+      obs.times.map { [rand(2..days), rand(10000..const)] }.sort_by(&:first).each do |d, h|
         yield "%d %d" % [d, h]
       end
     end

spring2013/shaving/runner_vera.py

@@ -0,0 +1,109 @@
+"""
+ Solution to 2013 Prog. Comp. shave problem
+ Brute force solution, checks every possibility
+ Days are indexed from 1
+
+ usage: python shave.py input.txt
+
+ Author: Vera Axelrod
+ Date: March 23, 2013
+"""
+
+import fileinput
+import sys
+from collections import defaultdict
+
+# read in the information
+def readInput():
+    result = []
+    obligations = defaultdict(lambda: 0)
+    seenInfo = False
+    M = -1
+    n = -1
+
+    probs = int(sys.stdin.readline())
+    for i in range(0, probs):
+        line = sys.stdin.readline()
+        L = line.rstrip('\n').split(' ')
+
+        if(len(L) == 3):
+            # add the old stuff
+            if (seenInfo):
+                result.append([n, M, obligations])
+                obligations = defaultdict(lambda: 0)
+
+            n = int(L[0])
+            M = int(L[1])
+            obs = int(L[2])
+            #ignore L[2] which is the number of obligations
+            seenInfo = True
+
+            for j in range(0, obs):
+              line = sys.stdin.readline()
+              L = line.rstrip('\n').split(' ')
+
+              if(len(L) == 2):
+                  obligations[int(L[0])] += int(L[1])
+
+    # add the last input if there was any input at all
+    if(seenInfo):
+        result.append([n, M, obligations])
+
+    return result
+
+
+
+def shave(n, M, obligations):
+    # create the set of all binary strings
+    binaryStrings = [];
+    upper = pow(2, n-1)
+
+    for i in range(0, upper):
+        binary = bin(i)
+        x = binary[2:len(binary)]
+
+        # need to pad the front with zeros
+        while ( len(x) < (n-1) ):
+            x = '0' + x
+
+        # we ignore the zeroth day so put an 'x' there
+        x = 'x1' + x
+        binaryStrings.append(x)
+
+    # python can actually go smaller than this, but lets assume the problem wont
+    bestHappiness = -sys.maxint
+
+    # try all possible combinations of shaving/not shaving
+    for x in binaryStrings:
+        happiness = 0
+        hairLength = 0
+        # skip the first day (1)
+        for d in range(2,n+1):
+            # shave today
+            if (x[d] == '1'):
+                happiness -= M
+                hairLength = 0
+            else:
+                hairLength = hairLength + 1
+
+            if ( d in obligations ):
+                happiness -= obligations[d] * hairLength
+
+        if (happiness >= bestHappiness):
+            bestHappiness = happiness
+            bestStrategy = x
+
+    # print out the best strategy
+    output = ''
+    for day in range(1,n+1):
+        if (bestStrategy[day] == '1'):
+            output = output + str(day)
+            output += ' '
+
+    print output.strip()
+
+
+
+result = readInput()
+for problem in result:
+    shave(problem[0], problem[1], problem[2])