monkeymusic 0.0.14 → 0.1.1

data/demo_players/java/DemoPlayer.java

@@ -0,0 +1,250 @@
+import java.util.Set;
+import java.util.List;
+import java.util.Map;
+import java.util.HashSet;
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Scanner;
+import java.io.Serializable;
+import java.io.ObjectOutputStream;
+import java.io.FileOutputStream;
+import java.io.ObjectInputStream;
+import java.io.FileInputStream;
+
+public class DemoPlayer {
+  public static void main(String[] args) throws Exception {
+    Scanner sc = new Scanner(System.in);
+    String roundType = sc.nextLine();
+    String id = sc.nextLine();
+    Monkey monkey;
+    if (roundType.equals("INIT")) {
+      monkey = new Monkey(id);
+      monkey.init(sc);
+    } else {
+      monkey = Monkey.readFromCache(id);
+      monkey.turn(sc);
+    }
+    sc.close();
+    monkey.writeToCache();
+  }
+}
+
+class Monkey implements Serializable {
+  public static final long serialVersionUID = 0;
+
+  static final String CACHE_PREFIX = "cache_";
+
+  final String id;
+  // Position
+  int x, y;
+  // Toplists
+  int topDecade;
+  Set<String> topTracks = new HashSet<String>(), 
+              topAlbums = new HashSet<String>(), 
+              topArtists = new HashSet<String>(), 
+              dislikedArtists = new HashSet<String>();
+  // URI dictionary
+  Map<String, Track> knownURIs = new HashMap<String, Track>();
+  // Tracks
+  List<Track> unknownTracks;
+  List<Track> knownTracks;
+  int turn, turnLimit;
+  int width, height;
+  int remainingCapacity, remainingExecutionTime, boostCooldown;
+  String[][] level;
+
+  Monkey(String id) {
+    this.id = id;
+  }
+
+  void init(Scanner sc) {
+    parseInit(sc);
+    parseToplists(sc);
+  }
+
+  void turn(Scanner sc) {
+    parseTurn(sc);
+    parseMetadata(sc);
+    parseLevel(sc);
+  }
+
+  void parseInit(Scanner sc) {
+    width = sc.nextInt();
+    height = sc.nextInt();
+    turnLimit = sc.nextInt();
+    level = new String[width][height];
+  }
+
+  void parseToplists(Scanner sc) {
+    List<Integer> decades = new ArrayList<Integer>();
+    // Top tracks
+    int numTracks = sc.nextInt();
+    sc.nextLine();
+    for (int i = 0; i < numTracks; i++) {
+      String entry = sc.nextLine();
+      // 0:[track],1:[album],2:[artist],3:[year]
+      String[] parts = entry.split(",");
+      topTracks.add(parts[0]);
+      int decade = Util.toDecade(Integer.parseInt(parts[3]));
+      decades.add(decade);
+    }
+    // Top albums
+    int numAlbums = sc.nextInt();
+    sc.nextLine();
+    for (int i = 0; i < numAlbums; i++) {
+      String entry = sc.nextLine();
+      // 0:[album],1:[artist],2:[year]
+      String[] parts = entry.split(",");
+      topAlbums.add(parts[0]);
+      int decade = Util.toDecade(Integer.parseInt(parts[2]));
+      decades.add(decade);
+    }
+    // Top decade
+    topDecade = Util.getPopularElement(
+        decades.toArray(new Integer[decades.size()]));
+    // Top artists
+    int numArtists = sc.nextInt();
+    sc.nextLine();
+    for (int i = 0; i < numArtists; i++) {
+      // 0:[artist]
+      String entry = sc.nextLine();
+      topArtists.add(entry);
+    }
+    // Disliked artists
+    int numDislikedArtists = sc.nextInt();
+    sc.nextLine();
+    for (int i = 0; i < numDislikedArtists; i++) {
+      // 0:[artist]
+      String entry = sc.nextLine();
+      dislikedArtists.add(entry);
+    }
+  }
+
+  void parseTurn(Scanner sc) {
+    turn = sc.nextInt();
+    remainingCapacity = sc.nextInt();
+    remainingExecutionTime = sc.nextInt();
+    boostCooldown = sc.nextInt();
+  }
+
+  void parseMetadata(Scanner sc) {
+    int numResults = sc.nextInt();
+    sc.nextLine();
+    for (int i = 0; i < numResults; i++) {
+      String metadata = sc.nextLine();
+      Track knownTrack = Track.fromMetadata(metadata);
+      // 0:[uri],1:[[track],[album],[artist],[year]]
+      String[] parts = metadata.split(",", 1);
+      knownURIs.put(parts[0], knownTrack);
+    }
+  }
+
+  void parseLevel(Scanner sc) {
+    unknownTracks = new ArrayList<Track>();
+    knownTracks = new ArrayList<Track>();
+    for (int y = 0; y < height; y++) {
+      String row = sc.nextLine();
+      String[] cells = row.split(",");
+      for (int x = 0; x < width; x++) {
+        level[x][y] = cells[x];
+        if (Util.isURI(cells[x])) {
+          String uri = cells[x];
+          if (!knownURIs.containsKey(uri)) {
+            unknownTracks.add(new Track(uri).place(x, y));
+          } else {
+            knownTracks.add(knownURIs.get(uri).copy().place(x, y)); 
+          }
+        }
+      }
+    }
+  }
+
+  void writeToCache() throws Exception {
+    ObjectOutputStream out = 
+      new ObjectOutputStream(new FileOutputStream(CACHE_PREFIX + id));
+    out.writeObject(this);
+    out.close();
+  }
+
+  static Monkey readFromCache(String id) throws Exception {
+    ObjectInputStream in =
+      new ObjectInputStream(new FileInputStream(CACHE_PREFIX + id));
+    Monkey monkey = (Monkey) in.readObject();
+    in.close();
+    return monkey;
+  }
+
+}
+
+class Track implements Cloneable, Serializable {
+  public static final long serialVersionUID = 0;
+
+  String uri, name, album, artist, year;
+  int x, y;
+  int value;
+
+  Track (String uri) {
+    this.uri = uri;
+  }
+
+  static Track fromMetadata(String metadata) {
+    // 0:[uri],1:[name],2:[album],3:[artist],4:[year]
+    String[] parts = metadata.split(","); 
+    Track track = new Track(parts[0]);
+    track.name = parts[1];
+    track.album = parts[2];
+    track.artist = parts[3];
+    track.year = parts[4];
+    return track;
+  }
+
+  Track place(int x, int y) {
+    this.x = x;
+    this.y = y;
+    return this;
+  }
+
+  Track copy() {
+    Track copy = new Track(uri);
+    copy.name = name;
+    copy.album = album;
+    copy.artist = artist;
+    copy.year = year;
+    copy.value = value;
+    return copy;
+  }
+
+  @Override public int hashCode() { return uri.hashCode(); }
+}
+
+class Util {
+  /** 
+  * http://stackoverflow.com/questions/8545590/java-find-the-most-popular-element-in-int-array
+  */
+  static int getPopularElement(Integer[] a) {
+    int count = 1, tempCount;
+    int popular = a[0];
+    int temp = 0;
+    for (int i = 0; i < (a.length - 1); i++) {
+      temp = a[i];
+      tempCount = 0;
+      for (int j = 1; j < a.length; j++) {
+        if (temp == a[j])
+          tempCount++;
+      }
+      if (tempCount > count) {
+        popular = temp;
+        count = tempCount;
+      }
+    }
+    return popular;
+  }
+
+  static int toDecade(int year) {
+    return (year % 100) / 10;
+  }
+
+  static boolean isURI(String s) {
+    return s.length() == 36 && s.substring(0, 14).equals("spotify:track:");
+  }
+}

data/demo_players/java/install

@@ -0,0 +1,2 @@
+#!/bin/sh
+javac DemoPlayer.java

data/demo_players/java/runme

@@ -0,0 +1,2 @@
+#!/bin/sh
+java -cp $(dirname $0) DemoPlayer "$@"

data/demo_players/python/install

@@ -0,0 +1,2 @@
+#!/bin/sh
+echo "No installation steps required."

data/demo_players/python/monkey.py

@@ -0,0 +1,111 @@
+import logging
+import os.path
+import pickle
+import sys
+
+import util
+
+STATE_FILENAME = 'state.pickle'
+TRACK_URI_HEADER = 'spotify:track:'
+
+class Monkey(object):
+    def __init__(self):
+        self._id = 0
+        self._w = 0
+        self._h = 0
+        self._turn_limit = 0
+        self._turn = 0
+        self._capacity = 0
+        self._time_left = 0
+        self._top_tracks = None
+        self._top_albums = None
+        self._top_artists = None
+        self._bad_artists = None
+        self._bad_tracks = set()
+        self._map = {}
+        self._pos = None
+        self._user = None
+        self._boost_cooldown = 0
+        self._track_pos = {} # pos -> uri
+        self._metadata = {} # uri -> metadata
+        self._objective = None
+        
+    @classmethod
+    def process_input(cls, stream):
+        monkey = None
+        line = stream.readline().strip()
+        if line == 'INIT':
+            logging.basicConfig(filename='monkey.log', filemode='w', level=logging.DEBUG)
+            monkey = cls()
+            monkey.initialize(stream)
+        else:
+            logging.basicConfig(filename='monkey.log', filemode='a', level=logging.DEBUG)
+            monkey = cls.load()
+            monkey.update(stream)
+        return monkey
+            
+    def initialize(self, stream):
+        self._id = stream.readline().strip()
+        self._w = util.get_int(stream)
+        self._h = util.get_int(stream)
+        self._turn_limit = util.get_int(stream)
+        self._top_tracks = util.get_set(stream)
+        self._top_albums = util.get_set(stream)
+        self._top_artists = util.get_set(stream)
+        self._bad_artists = util.get_set(stream)
+        
+    def update(self, stream):
+        self._id = stream.readline().strip()
+        self._turn = util.get_int(stream)
+        self._capacity = util.get_int(stream)
+        self._time_left = util.get_int(stream)
+        self._boost_cooldown = util.get_int(stream)
+        self._track_pos = {}
+        self.browse_result(sys.stdin)
+        for y in xrange(self._h):
+            line = stream.readline().strip()
+            for x, square in enumerate(line.split(',')):
+
+                self._map[x, y] = square
+                if square == self._id:
+                    self._pos = (x, y)
+                elif square == 'U':
+                    self._user = (x, y)
+                elif square.startswith(TRACK_URI_HEADER):
+                    self._track_pos[x, y] = square
+                    try:
+                        metadata = self._metadata[square]
+                        self._map[x, y] = '+' if self.track_value(metadata) > 0 else '-'
+                    except KeyError:
+                        self._map[x, y] = '?'
+                        
+    def action(self):
+        if self._turn >= 1:
+          print 'W'
+                                
+    def browse_result(self, stream):
+        browsed_tracks = util.get_set(sys.stdin)
+        for track in browsed_tracks:
+            logging.debug('[%d] Browsed track: %s', self._turn, track)
+            uri, metadata = track.split(',', 1)
+            self._metadata[uri] = metadata
+        
+    def save(self):
+        with open(self.save_path(), 'wb') as f:
+            pickle.dump(self, f, pickle.HIGHEST_PROTOCOL)
+    
+    @classmethod
+    def load(cls):
+        with open(cls.save_path(), 'rb') as f:
+            return pickle.load(f)
+    
+    @classmethod
+    def save_path(cls):
+        dir_path = os.path.dirname(__file__)
+        return os.path.join(dir_path, STATE_FILENAME)
+
+if __name__ == '__main__':
+    monkey = Monkey.process_input(sys.stdin)
+    monkey.action()
+    monkey.save()
+    sys.stdout.flush()

data/demo_players/python/runme

@@ -0,0 +1,2 @@
+#!/bin/sh
+python $(dirname $0)/monkey.py "$@"

data/demo_players/python/util.py

@@ -0,0 +1,29 @@
+import re
+
+INTEGER = re.compile(r'(\d+).*')
+
+D_POS = {'W': (-1, 0), 'N': (0, -1), 'E': (1, 0), 'S': (0, 1)}
+MOVES = dict([(v, k) for k, v in D_POS.iteritems()])
+
+def distance(p0, p1):
+    return abs(p0[0] - p1[0]) + abs(p0[1] - p1[1])
+    
+def move(p_from, p_to):
+    dx = p_to[0] - p_from[0]
+    dy = p_to[1] - p_from[1]
+    return MOVES[dx, dy]
+    
+def follow_path(self, path):
+    return move(path[0], path[1])
+    
+def get_int(stream):
+    line = stream.readline().strip()
+    match = INTEGER.match(line)
+    return int(match.group(1))
+    
+def get_set(stream):
+    s = set()
+    size = get_int(stream)
+    for ix in xrange(size):
+        s.add(stream.readline().strip())
+    return s

data/{demo_player → demo_players/ruby/demo_player.rb}

@@ -61,12 +61,13 @@ class DemoPlayer
     @turn = Integer($stdin.gets.chomp)
     @remaining_capacity = Integer($stdin.gets.chomp)
     @remaining_time = Integer($stdin.gets.chomp)
+    @boost_cooldown = Integer($stdin.gets.chomp)
     # Read metadata query responses
     num_responses = Integer($stdin.gets.chomp)
     num_responses.times do
       response = $stdin.gets.chomp.split(",")
       uri = response.unshift
-      @known_tracks[uri][response]
+      @known_tracks[uri] = response
     end
   end
 
@@ -76,7 +77,7 @@ class DemoPlayer
       row = $stdin.gets.chomp.split(',')
       @width.times do |x|
         case row[x]
-        when "M#{@id}" then @x, @y = x, y
+        when @id then @x, @y = x, y
         when /spotify:track/ then @track_positions << [x, y]
         when "U" then @user_position = [x, y]
         end

data/levels/demo_level.rb

@@ -1,6 +1,7 @@
 carrying_capacity 5
 turn_limit 500
 time_limit 20000
+boost_cooldown 15
 
 legend "1" => Monkey.player(1),
        "2" => Monkey.player(2),