#/usr/bin/env python
# -*- coding: utf-8 -*-
 
import random
import string
 
def throw_coin():
  '''Head is 0, Tail is 1'''
  return random.randint(0, 1)
 
 
def main():
 
  games = raw_input('Number of games: ')
  payment = 100 # This is to define the money the player has to pay to be hable
                # to play the game
 
  print "Initial player payment is %d" % payment
  cash = 0
 
  for i in range(int (games)):
    throws = 0
    throws = throws + 1
    while (throw_coin() != 0): # throw coin until head comes up
      throws = throws + 1
 
    cash = cash + 2 ** (throws - 1) # Equivalent to  2^(i-1)
    print "Throws %d" % throws
    print "You have wone: %d euros so far!" % cash
 
  print "You won %d €! You payed %d in advance. You result was %d €!" % (cash
  , payment, cash - payment)
 
if __name__ == "__main__":
  main()

#/usr/bin/env/python
# -*- coding: utf-8 -*-
 
#Copyright (C) 2011 António Lima
#amrlima AT gmail.com
 
# This program is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
# A copy of this license can be obtained at http://www.gnu.org/copyleft/gpl.html
 
class GameKey(object):
  """A euromillion key"""
  def __init__(self, key = [], stars = []):
    self._numbers = key
    self._stars = stars
 
  def get_numbers(self):
    """Get bet numbers"""
    return self._numbers
 
  def get_stars(self):
    """Get bet stars"""
    return self._stars
 
  def set_numbers(self, numbers):
    self._numbers = numbers
 
  def set_stars(self, stars):
    self._stars = stars
 
  def read(self):
    """Reads bet from terminal"""
    line = raw_input('Type this weeks key separating each mumber with a space.'\
    ' Two Stars last\n>>> ')
    numbers = line.split(' ')
 
    #cast input values to int and push then to list
    for n in numbers:
      self._numbers.append(int(n))
 
    if len(self._numbers) != 7:
      raise ValueError('Not enought values read') 
 
    self._stars = [] # pop stars from regular numbers to stars list
    self._stars.append(self._numbers.pop(6))
    self._stars.append(self._numbers.pop(5))
 
################################################################################
 
class Bet(GameKey):
  """A euromillion bet"""
  def __init__(self, key = [], stars = []):
    GameKey.__init__(self, key, stars)
    self._numbers_hit = 0
    self._stars_hit = 0
 
  def __check_numbers(self, numbers):
    """Check how many numbers where hit"""
    # check for numbers
    for a in self._numbers:
      for b in numbers:
        if a == b:
          self._numbers_hit = self._numbers_hit + 1
 
  def __check_stars(self, stars):
    """Check how many stars where hit"""
    # check for stars
    for a in self._stars:
      for b in stars:
        if a == b:
          self._stars_hit = self._stars_hit + 1
 
  def check_result_parts(self, numbers, stars):
    """Check euromillion result. This version takes two lists as arguments"""
    self.__check_numbers(numbers)
    self.__check_stars(stars)
 
  def check_result(self, week_key):
    """Check euromillion result. This version takes a Bet object as argument"""
    self.__check_numbers(week_key.get_numbers())
    self.__check_stars(week_key.get_stars())
 
  def get_numbers_hit(self):
    """Get the number of correct numbers. Always call check_result() fist"""
    return self._numbers_hit
 
  def get_stars_hit(self):
    """Get the number of correct stars. Always call check_result() fist"""
    return self._stars_hit
 
############################ Utility functions ################################
 
def read_bets(filename):
  """Reads a serie of bets from a filename and creates Bet objects. Returns
  a list of Bet objects"""
  bet_lines = [] # File lines containing bets
  bets = [] # for Bet objects
 
  # Open file and read bets
  f = open(filename)
  for line in f:
    bet_lines.append(line)
  f.close()
 
  for b in bet_lines:
    numbers_str = b.split(' ') # tokenize input
    numbers = []
    stars = []
 
    for n in numbers_str:
      numbers.append(int (n))
 
    # Move stars from regular numbers to stars list
    stars.append(numbers.pop(6))
    stars.append(numbers.pop(5))
 
    new_bet = Bet(numbers, stars)
    bets.append(new_bet)
 
  return bets
 
################################## Main program ################################
 
def main():
 
  week_key = GameKey()
 
   # read user's keys from file
  try:
    my_bets = read_bets("chaves.txt")
  except IOError:
    print 'chaves.txt not found! Create the file, write your keys there and '\
    'try again'
    return
 
  # read this week's key from keyboad. Exit on fail
  try:
    week_key.read()
  except ValueError:
    print 'Invalid euromilion key size, please try again'
    return
 
  i = 1
  for bet in my_bets:
    bet.check_result(week_key)
    print "-----Bet #%d------\n%d numbers hit " % (i, bet.get_numbers_hit() )
    print "%d stars hit" % bet.get_stars_hit()
    i += 1
 
if __name__ == "__main__":
	main()

class Agent{
 	private $_browser;
 	private $_os;
 	private $_browsers = array("firefox", "msie", "chrome", "opera", "safari", "mozilla");
 	private $_OS = array("windows", "win32", "linux", "machintosh");
 
 	public function __Construct(){
 		//Get user agent
 		$info = $_SERVER['HTTP_USER_AGENT'];
 
 		//Lower string case for easier matches
 		$info = strtolower($info);
 		print $info."";
 
 		//Search for browser
 		foreach ($this->gt;_browsers as $browser){
 
 			 if (strpos($info, $browser) === false){
 			 	continue;
 			 }
 
 			 else{
 			 	$this->_browser = $browser;
 
 			 	//We need to change the name os IE from msie to IE
 			 	if ($this->_browser === "msie") $this->_browser = "Internet " .
 			 			"Explorer";
 
 			 	break;// We've found the browser, leave the loop
 			 }
 		}
 
 		//Search for OS
 		foreach ($this->gt;_OS as $os){
 
 			 if (strpos($info, $os) === false)
 			 	continue;
 			 else{
 			 	$this->_os = $os;
 
 			 	//If windows identifies as win32 we change it to Windows
 			 	if ($this->_os == "win32") $this->_os = "Windows";
 
 			 	break; //We've found our OS, leave loop
 			 }
 		}
 
 	//Make first letter of browser and OS uppercase
 	$this->_browser = ucfirst($this->_browser);
 	$this->_os = ucfirst($this->_os);
 
 	}
 
 	//Selector that returns browser type. The b in Browser is capitalized because of the
 	//library funtion get_browser
 	function get_Browser(){
 		return $this->_browser;
 	}
 
 	//Selector returns os
 	function get_os(){
 		return $this->_os;
 	}
 
 	//Browser modifier
 	function set_browser(string $browser){
 		$this->_browser = $browser;
 	}
 
 	//Os modifier
 	function set_os(string $os){
 		$this->_os = $os;
 	}
 
 	//Print browser and OS
 	function print_agent(){
 		print $this->_browser."@".$this->_os;
 	} 
 
 }

#include <stdio.h>
#include <stdlib.h>
 
/*Create a n sized array*/
int* makearray(int n)
{
    int* v;
    int i;
 
    v = (int*) malloc(n*sizeof(int)); /*Alocates n int numbers*/
    printf("Array elements:\n");
    for (i = 0; i < n; i++){ /*Fill the array with user input*/
        scanf("%d", &v[i]);
    }
 
    return v;    
}
 
/*Get the size of an array*/
int arraylen(int v[])
{
    int i=0;
    while(v[i]) i++;
    return i;
}
 
/*Count how many times a given element is repeated in an array*/
int countelem(int v[], int num)
{
    int i, n=0;
 
    for (i=0; i < arraylen(v); i++){
        if (v[i] == (int) num){
            n++;
        }
    }
    return n;
}
 
int main()
{
    int n, i, count = 0, mode;
    int* v;
 
    printf("Size of the array?\n");
    /*We don't wan't anyone creating a oversized array: DANGER'*/
    /*So we limit it's' size. Here I randomly defined 100*/
    do{
        scanf("%d", &n);
 
    } while(n > 100);
 
    v = makearray(n);
    /*Update the wich value is repeated more ofted -> Mode*/
    for (i = 0; i < n; i++){
        if (countelem(v, v[i]) > count){
            count = countelem(v, v[i]); /*Update the value of the maximum number of repeats*/
            printf("%d\n", count);
            mode = v[i]; /*Update mode*/
        } 
 
 
    }
 
    printf("Mode: %d\n", mode);
    return 0;
 
}

#!/bin/sh python
#-*- coding: utf-8 -*-
 
 
def makearray(v):
  """Creates the dictionary with the elements input by the user
  """
  print "Array elements (end with empty line):"
  while(1):
    s = raw_input("-> ")    # get an element
    if not s:
      break
    try:
      i = int(s)
      if v.has_key(i):      # if already exists, increment frequency
        v[i] += 1
      else:                 # if not, create it
        v[i] = 1
    except:                 # error handling
       print "not an integer"
 
 
#-----------------------------------------------------------------------
# program
 
# instead of a vector or array, we do this with a dictionary
# that way we can keep the frequency count with each entry
v = {}
makearray(v)
 
# get the mode
if len(v):
  mode = 0
  maxfreq = 0
 
  for i in v.keys():
    if v[i] > maxfreq:
      mode = i
      maxfreq = v[i]
 
  print "Mode %d, with frequency %d" % (mode, maxfreq)
 
else:
  print "Empty array"

#include <stdio.h>
#define VMAX 25
 
int main()
{
    /*Prime numbers < 100 */
    int primes[VMAX] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};
    int factors[VMAX] = {}; /*Prime factors*/
    int repeat[VMAX] = {}; /*Store times each factor repeats*/
    int a, i, n=0;
 
    printf("Type a number to find it's prime factors: \n");
    scanf("%d", &a);
 
    /*Start to divide the number by prime numbers while a is not 1*/
    for (i=0; i<VMAX; i++){
        while ((a != 1) && (a % primes[i] == 0)){ 
 
            a = a / primes[i];
            factors[i] = primes[i]; /*The prime factor is the one being used*/
            n++; /*Count how many times each prime is used*/
            } 
        if ((a % primes[i] == 0) ) n = 0; 
        repeat[i] = n;
        n = 0; /*Reinitialize counter*/
 
    }
    printf("Prime factors:\n");
    for (i=0; i<VMAX; i++){
 
        /*Print all factors in the array != 0*/
        if (factors[i] !=0){
            /*Since x ^ 0 = 1, we have to print x ^ 1 instead*/
            if (repeat[i] == 0) printf("%d ^ 1\n", factors[i]);
            else printf("%d ^ %d\n", factors[i], repeat[i]);
        }    
    }       
 
    return 0;
 
}

#! /usr/bin/env/python
VMAX = 25
 
#Prime numbers < 100
primes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]
factors = [0]*VMAX #Prime factors
repeat = [0]*VMAX #Store times each factor repeats
i = 0
n = 0
k = 0
 
a = raw_input("Type a number to find it's prime factors:")
 
#Start to divide the number by prime numbers while a is not 1
for i in range(VMAX): 
 
    while ((a != 1) & (int (a) % primes[i] == 0)):
 
        a = int (a) / primes[i]
 
        print primes[i]
        factors[i] = primes[i] # The prime factor is the one being used
 
        n = n + 1 #*Count how many times each prime is used
        print n
    if (int (a) % primes[i] == 0):
        n = 0 #Reinitialize counter
    repeat[k] = n
    n = 0
    k = k + 1
 
print "Prime factors:"
 
#Print all factors in the array != 0
for i in range(VMAX):
 
    if (factors[i] !=0):
    #Since x ^ 0 = 1, we have to print x ^ 1 instead
        if (repeat[i] == 0):
            print factors[i]
        else: print "%s ^ %s " % (factors[i], repeat[i])

#!/usr/bin/env/python
 
# Copyright (C) 2009 Antonio Lima
# http://www.amrlima.info
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or any later version.
 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
 
import dbus
bus = dbus.SessionBus()
 
banshee = bus.get_object("org.bansheeproject.Banshee", "/org/bansheeproject/Banshee/PlayerEngine")
pidgin = bus.get_object("im.pidgin.purple.PurpleService", "/im/pidgin/purple/PurpleObject")
purple = dbus.Interface(pidgin, "im.pidgin.purple.PurpleInterface")
 
currentTrack = banshee.GetCurrentTrack()
 
artist = str(currentTrack[u'album-artist'])
album = str(currentTrack[u'album'])
track = str(currentTrack[u'name'])
 
trackinfo = " %s - %s  [%s]" %(track, artist, album )
print trackinfo
 
account = purple.PurpleAccountsFind('username@xmppserver.com/Home', '')
buddy = purple.PurpleFindBuddy(account, 'update@identi.ca')
PURPLE_CONV_TYPE_IM = 1
buddy_name = purple.PurpleBuddyGetName(buddy)
 
im = purple.PurpleConvIm(purple.PurpleConversationNew(PURPLE_CONV_TYPE_IM, account, buddy_name))
purple.PurpleConvImSend(im, "!listening to " + trackinfo)

#!/usr/bin/env/python
 
# Copyright (C) 2009 Antonio Lima
# http://www.amrlima.info
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or any later version.
 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
 
import dbus, gobject
from dbus.mainloop.glib import DBusGMainLoop
loop = gobject.MainLoop()
 
DBusGMainLoop(set_as_default=True)
 
bus = dbus.SessionBus()
banshee = bus.get_object("org.bansheeproject.Banshee", "/org/bansheeproject/Banshee/PlayerEngine")
purple = bus.get_object("im.pidgin.purple.PurpleService", "/im/pidgin/purple/PurpleObject")
pidgin = dbus.Interface(purple, "im.pidgin.purple.PurpleInterface")
 
STATUS_AVAILABLE = dbus.UInt32(2)
STATUS_AWAY = dbus.UInt32(5)
 
def checkState(state):
	currentTrack = banshee.GetCurrentTrack()
	print "State Changed: %s" % state
	if state == 'playing':
		artist = str(currentTrack[u'album-artist'])
		album = str(currentTrack[u'album'])
		track = str(currentTrack[u'name'])
		trackinfo = " %s - %s  [%s]" %(track, artist, album)
		old_status = purple.PurpleSavedstatusGetCurrent()		# get current status
		status_type = purple.PurpleSavedstatusGetType(old_status)	# get current status type
		new_status = purple.PurpleSavedstatusNew("", STATUS_AVAILABLE)	# create new status with old status type
		purple.PurpleSavedstatusSetMessage(new_status, trackinfo)	# fill new status with status message
		purple.PurpleSavedstatusActivate(new_status, trackinfo)		# activate new status
	if state == 'paused':
		old_status = purple.PurpleSavedstatusGetCurrent()		# get current status
		status_type = purple.PurpleSavedstatusGetType(old_status)	# get current status type
		new_status = purple.PurpleSavedstatusNew("", STATUS_AWAY)	# create new status with old status type
		purple.PurpleSavedstatusSetMessage(new_status, "Banshee is paused. I'm probably not here now")	# fill new status with status message
		purple.PurpleSavedstatusActivate(new_status)			# activate new status
 
bus.add_signal_receiver(checkState, dbus_interface="org.bansheeproject.Banshee.PlayerEngine", signal_name="StateChanged")
 
mainloop = gobject.MainLoop()
mainloop.run()

#!/bin/sh
/usr/bin/python /scriptlocation/musictracker.py