잊지 않겠습니다.

0003. The Trip

시끌벅적 2009. 1. 7. 11:59 
import unittest

class TheTrip:
    def __init__(self, count):
        self.count = count
        self.costs = []
        pass
    def inputCost(self, cost):
        self.costs.append( float(cost * 100) )
    def calculateAverageCost(self):
        return float( sum(self.costs) / len(self.costs) ) / 100.00
    def calculateMinCharge(self):
        average = self.calculateAverageCost() * 100.00
        diff_values = []
        for value in self.costs:
            differ = average - value
            diff_values.append(abs(differ))
        return sum(diff_values) / 2.00 / 100.00

class TheTripTest(unittest.TestCase):
    def setUp(self):
        pass
    def testInsertValue(self):
        t = TheTrip(3)
        t.inputCost(10.00)
        t.inputCost(20.00)
        t.inputCost(30.00)
        self.assertEqual(20.00, t.calculateAverageCost())
        self.assertEqual(10.00, t.calculateMinCharge())
    def testInsertValue2(self):
        t = TheTrip(4)
        t.inputCost(15.00)
        t.inputCost(15.01)
        t.inputCost(3.00)
        t.inputCost(3.01)
        self.assertEqual(11.99, t.calculateMinCharge())
if __name__ == '__main__':
    unittest.main()




require 'test/unit'

class TheTrip
attr_reader :member, :costs, :average
attr_writer :member, :costs

    def initialize(number)
        self.member = number
        self.costs = []
    end

    def input_cost(cost)
        self.costs << cost
        @average = 0
        self.costs.each {|value| @average += value }
        @average /= self.costs.length
    end

    def get_min_charge()
        charges = 0.00
        self.costs.each { |value| charges += (value - self.average).abs }
        return charges / 2.00
    end
    
end

class TheTripTest < Test::Unit::TestCase
    def test_case1
        t = TheTrip.new(3)
        t.input_cost(10.00)
        t.input_cost(20.00)
        t.input_cost(30.00)
        assert_equal(20.00, t.average)
        assert_equal(10.00, t.get_min_charge())
    end

    def test_case2
        t = TheTrip.new(4)
        t.input_cost(15.00)
        t.input_cost(15.01)
        t.input_cost(3.00)
        t.input_cost(3.01)
        assert_equal(11.99, t.get_min_charge())
    end
end
Posted by Y2K
,

0002. Minesweeper

시끌벅적 2009. 1. 7. 11:59 
import os

import unittest




class Minesweeper:

    def __init__(self):

        self.rows = []

        pass

    

    def clearRow(self):

        self.rows = []

    

    def insertRow(self, row):

        self.rows.append(row)

    

    def printArray2D(self, array_2d):

        for row in array_2d:

            for item in row:

                print item,

            print

    

    def printMine(self):

        self.printArray2D(self.rows)

    

    def initLocation(self):

        mine_locations = []

        for row in self.rows:

            row_locations = []

            for item in row:

                row_locations.append(0)

            mine_locations.append(row_locations)

        self.mine_locations = mine_locations

    

    def isInRange(self, row_location, col_location):

        if row_location >= 0 and col_location >= 0 and row_location < len(self.rows) and col_location < len(self.rows[0]):

            return True

        else:

            return False

        

    def getMineLocation(self):

        self.initLocation()        

        row_location = 0

        for row in self.rows:

            col_location = 0

            for item in row:

                if item == '*':

                    self.mine_locations[row_location][col_location] = '*'

                    for row_index in [-1, 0, 1]:

                        for col_index in [-1, 0, 1]:

                            if self.isInRange(row_location + row_index, col_location + col_index) and self.mine_locations[row_location + row_index][col_location + col_index] != '*':

                                self.mine_locations[row_location + row_index][col_location + col_index] += 1

                col_location += 1

            row_location += 1

    

    def printMineLocation(self):

        self.printArray2D(self.mine_locations)

    

class MinesweeperTest(unittest.TestCase):

    def setUp(self):

        pass

    def testCheckValue(self):

        m = Minesweeper()

        m.insertRow(['.','.','*','.'])

        m.insertRow(['.','*','.','.'])

        m.printMine()

        

        self.assertEqual(m.isInRange(0,0), True)

        self.assertEqual(m.isInRange(5,0), False)

        self.assertEqual(m.isInRange(1,0), True)

        self.assertEqual(m.isInRange(0,5), False)

        

        m.getMineLocation()

        m.printMineLocation() 

    

    def testCheckMine2(self):

        m = Minesweeper()

        m.insertRow(['*', '*', '.', '.', '.'])

        m.insertRow(['.', '.','.','.','.'])

        #m.insertRow(['.', '.','.','.','.'])

        m.insertRow(['.', '*','.','.','.'])


        m.getMineLocation()

        m.printMineLocation()

        self.assertEqual(True, True)

    #def tearDown(self):

    #    pass


if __name__ == '__main__':

    unittest.main()

  

require 'test/unit'


class Minesweeper

    attr_reader :rows, :calc_locations

    attr_writer :rows, :calc_locations

    

    def initialize

        self.rows = []

        self.calc_locations = []

    end

    

    def print_rows

        @rows.length.times do |row_index| 

            @rows[row_index].length.times {|col_index| print @rows[row_index][col_index].to_s() + ' ' }   

            puts ' ' 

        end

    end


    def calc_rows

        self.calc_locations = []

        rows.length.times do |row_index|

            row = []

            rows[row_index].length.times do |col_index|

               if rows[row_index][col_index] != '*' : row.push(0) 

               else  row.push('*')

               end

            end

            @calc_locations.push(row)

        end


        @rows.length.times do |row_index|

            @rows[row_index].length.times do |col_index|

                -1.upto(1) { |i| -1.upto(1) { |j| @calc_locations[i+row_index][j+col_index] += 1 if self.is_in_range(i+row_index,j+col_index) } } if @rows[row_index][col_index] == '*'

            end

        end

    end


    def is_in_range(row_index, col_index)

        return false if row_index < 0

        return false if col_index < 0 

        return false if row_index >= @calc_locations.length 

        return false if col_index >= @calc_locations[row_index].length

        return false if @rows[row_index][col_index] == '*'

        return true        

    end


    def print_calc_rows

        @calc_locations.length.times do |row_index| 

            @calc_locations[row_index].length.times {|col_index| print @calc_locations[row_index][col_index].to_s() + ' ' }   

            puts ' ' 

        end

    end    

end


class MinesweeperTest < Test::Unit::TestCase

    def test_case1

        mine = Minesweeper.new()

        mine.rows.push(['.', '*', '.', '.', '*'])

        mine.rows.push(['.', '.', '*', '.', '.'])

        mine.rows.push(['.', '.', '*', '.', '.'])

        mine.rows.push(['.', '.', '*', '.', '.'])

        mine.print_rows()

        mine.calc_rows()

        mine.print_calc_rows()

        assert_equal(1, 1)


        assert_equal(true, mine.is_in_range(0,0))

        assert_equal(false, mine.is_in_range(6, 0))

        assert_equal(false, mine.is_in_range(0, 1))

        assert_equal(1, mine.calc_locations[0][0])

        assert_equal(2, mine.calc_locations[0][2])

    end

end
Posted by Y2K
,

0001. Three plus one

시끌벅적 2009. 1. 7. 11:58

Python 

import sys
import unittest

class ThreePlusOne:
    def __init__(self):
        pass
    
    def getArray(self, number):
        return self.__calculateValues(number)

    def __calculateValues(self, number):
        current_value = number
        calculated_values = []
        calculated_values.append(current_value)
        
        while current_value != 1:
            if (current_value % 2) == 0:
                current_value = current_value / 2
            else:
                current_value = current_value * 3 + 1
            calculated_values.append(current_value)

        return calculated_values

    def getLength(self, number):
        return len(self.__calculateValues(number))
    
    def getMaxLengthWithRange(self, start_number, end_number):
        max_length = 0
        for current_number in range(start_number, end_number):
            length = self.getLength(current_number)
            if length > max_length:
                max_length = length
        return max_length
        
    def displayResult(self, start_number, end_number):
        max_length = self.getMaxLengthWithRange(start_number, end_number)
        print '%d %d %d' % (start_number, end_number, max_length)

class ThreePlusOneTest(unittest.TestCase):
    def setUp(self):
        pass

    def testCheckValue(self):
        correct_values = [22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
        t = ThreePlusOne()
        make_values = t.getArray(22)

        self.assertEqual(make_values, correct_values)
        
    def testCheckSize(self):
        correct_value = 16
        t = ThreePlusOne()
        make_value = t.getLength(22)
        self.assertEqual(make_value, correct_value)
    
    def testCheckRange(self):
        t = ThreePlusOne()
        
        result = t.getMaxLengthWithRange(1, 10)
        self.assertEqual(result, 20)
        
        result = t.getMaxLengthWithRange(100, 200)
        self.assertEqual(result, 125)

        result = t.getMaxLengthWithRange(201, 210)
        self.assertEqual(result, 89)

        result = t.getMaxLengthWithRange(900, 1000)
        self.assertEqual(result, 174)
    
    def testDisplay(self):
        t = ThreePlusOne()
        t.displayResult(1, 10)
        t.displayResult(100, 200)
        t.displayResult(201, 210)
        t.displayResult(900, 1000)
    
if __name__ == '__main__':
    unittest.main()

Ruby 

require 'test/unit'

class ThreePlusOne
    attr_reader :recent_results, :recent_number
    attr_writer :recent_results, :recent_number
    
    def getArray(number)
        self.calculate(number)
        return self.recent_results
    end
    
    def getLength(number)
        self.calculate(number)
        return  self.recent_results.length
    end
    
    def getMaxLengthWithRange(start_number, end_number)
        max_length = 0
        for i in start_number..end_number
            current_length = self.getLength(i)
            max_length = [max_length, current_length].max
        end
        return max_length
    end
    
    def calculate(number)
        @recent_number = number
        @recent_results = []
        current_value = number
        @recent_results.push(current_value)
        while current_value != 1
            if current_value % 2 == 0 : current_value = current_value / 2
            else current_value = current_value * 3 + 1
            end
            @recent_results.push(current_value)
        end
        return @recent_results
    end        
end

class TestThreePlusOne < Test::Unit::TestCase
    def test_case
        t = ThreePlusOne.new()
        assert_equal(t.getArray(22), [22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1])
        assert_equal(t.getLength(22), 16)
        assert_equal(t.getMaxLengthWithRange(1, 10), 20)
        assert_equal(t.getMaxLengthWithRange(100, 200), 125)
        assert_equal(t.getMaxLengthWithRange(201, 210), 89)
        assert_equal(t.getMaxLengthWithRange(900, 1000), 174)
    end
end

  

  

Posted by Y2K
,

티스토리툴바