LoadBalancingProblem/Leonardong - Revision history

Maintenance script: Repair MoniWiki formatting after migration

2026-03-29T00:34:24Z

Repair MoniWiki formatting after migration

← Older revision		Revision as of 00:34, 29 March 2026
Line 1:		Line 1:
	== LoadBalancingProblem ==		== [[LoadBalancingProblem]] ==
	----		----
	##1h 11m		##1h 11m

Maintenance script: Repair batch-0002 pages from live compare

2026-03-27T00:16:07Z

Repair batch-0002 pages from live compare

← Older revision		Revision as of 00:16, 27 March 2026
Line 12:		Line 12:

	def computeMinMaxWork(self):		def computeMinMaxWork(self):
	self.minWork = self.eachWork[0]		self.minWork = self.eachWork[0]
	self.maxWork = self.eachWork[0]		self.maxWork = self.eachWork[0]
	for i in range( 1, self.numOfCPU):		for i in range( 1, self.numOfCPU):
	if self.minWork > self.eachWork[i]:		if self.minWork > self.eachWork[i]:
	self.minWork = self.eachWork[i]		self.minWork = self.eachWork[i]
	if self.maxWork < self.eachWork[i]:		if self.maxWork < self.eachWork[i]:
	self.maxWork = self.eachWork[i]		self.maxWork = self.eachWork[i]

	def isCompelte(self):		def isCompelte(self):
Line 45:		Line 45:
	def getWork(self, aID):		def getWork(self, aID):
	assert 0 < aID <= self.numOfCPU		assert 0 < aID <= self.numOfCPU
	return self.eachWork[aID-1]		return self.eachWork[aID-1]

	def decreaseWork(self, aID):		def decreaseWork(self, aID):
	assert 0 < aID <= self.numOfCPU		assert 0 < aID <= self.numOfCPU
	self.eachWork[aID-1] = self.eachWork[aID-1] - 1		self.eachWork[aID-1] = self.eachWork[aID-1] - 1

	def increaseWork(self, aID):		def increaseWork(self, aID):
	assert 0 < aID <= self.numOfCPU		assert 0 < aID <= self.numOfCPU
	self.eachWork[aID-1] = self.eachWork[aID-1] + 1		self.eachWork[aID-1] = self.eachWork[aID-1] + 1

	def run(self):		def run(self):
Line 76:		Line 76:

	numOfCPU = 3		numOfCPU = 3
	eachWork = [0,0,0]		eachWork = [0,0,0]
	com.input( numOfCPU, eachWork )		com.input( numOfCPU, eachWork )
	self.assertEqual( com.isCompelte(), True )		self.assertEqual( com.isCompelte(), True )

	numOfCPU = 3		numOfCPU = 3
	eachWork = [0,99,3]		eachWork = [0,99,3]
	com.input( numOfCPU, eachWork )		com.input( numOfCPU, eachWork )
	self.assertEqual( com.isCompelte(), False )		self.assertEqual( com.isCompelte(), False )
Line 89:		Line 89:

	numOfCPU = 8		numOfCPU = 8
	eachWork = [16, 17, 15, 0, 20, 1, 1, 2]		eachWork = [16, 17, 15, 0, 20, 1, 1, 2]
	com.input( numOfCPU, eachWork )		com.input( numOfCPU, eachWork )

Line 105:		Line 105:

	numOfCPU = 10		numOfCPU = 10
	eachWork = [0, 0, 100, 0, 0, 0, 0, 0, 0, 0]		eachWork = [0, 0, 100, 0, 0, 0, 0, 0, 0, 0]
	com.input( numOfCPU, eachWork )		com.input( numOfCPU, eachWork )

Line 117:		Line 117:

	numOfCPU = 10		numOfCPU = 10
	eachWork = [0, 0, 100, 0, 0, 0, 0, 0, 0, 0]		eachWork = [0, 0, 100, 0, 0, 0, 0, 0, 0, 0]
	com.input( numOfCPU, eachWork )		com.input( numOfCPU, eachWork )
	com.run()		com.run()

imported>Unknown at 05:23, 7 February 2021

2021-02-07T05:23:40Z

New page

== LoadBalancingProblem ==
----
##1h 11m
import copy

class SuperComputer:
def __init__(self):
self.numOfCPU = 0
self.eachWork = list()
self.minWork = 0
self.maxWork = 0

def computeMinMaxWork(self):
self.minWork = self.eachWork[0]
self.maxWork = self.eachWork[0]
for i in range( 1, self.numOfCPU):
if self.minWork > self.eachWork[i]:
self.minWork = self.eachWork[i]
if self.maxWork < self.eachWork[i]:
self.maxWork = self.eachWork[i]

def isCompelte(self):
if self.maxWork - self.minWork > 1:
return False
return True
def input(self, aNumOfCPU, aEachWorks):
self.numOfCPU = aNumOfCPU
self.eachWork = copy.deepcopy(aEachWorks)
self.computeMinMaxWork()

def isThisOverWork(self, aID):
self.computeMinMaxWork()
if self.getWork(aID) > self.minWork:
return True
return False

def shareWork( self, aID ):
if aID != 1:
self.decreaseWork(aID)
self.increaseWork(aID-1)
if aID != self.numOfCPU:
self.decreaseWork(aID)
self.increaseWork(aID+1)

def getWork(self, aID):
assert 0 < aID <= self.numOfCPU
return self.eachWork[aID-1]

def decreaseWork(self, aID):
assert 0 < aID <= self.numOfCPU
self.eachWork[aID-1] = self.eachWork[aID-1] - 1

def increaseWork(self, aID):
assert 0 < aID <= self.numOfCPU
self.eachWork[aID-1] = self.eachWork[aID-1] + 1

def run(self):
round = 0
while not self.isCompelte():
for id in range( 1, self.numOfCPU+1 ):
if self.isThisOverWork(id):
self.shareWork(id)
print self.eachWork
round = round + 1

print self.eachWork
print "??"
print round

####################################################################
import unittest

class SuperComputerTestCase(unittest.TestCase):
def testIsComplete(self):
com = SuperComputer()

numOfCPU = 3
eachWork = [0,0,0]
com.input( numOfCPU, eachWork )
self.assertEqual( com.isCompelte(), True )

numOfCPU = 3
eachWork = [0,99,3]
com.input( numOfCPU, eachWork )
self.assertEqual( com.isCompelte(), False )

def testShareWork(self):
com = SuperComputer()

numOfCPU = 8
eachWork = [16, 17, 15, 0, 20, 1, 1, 2]
com.input( numOfCPU, eachWork )

id = 1
com.shareWork( id )

expected = 15
self.assertEqual( com.getWork(id), expected)
id = 2
expected = 18
self.assertEqual( com.getWork(id), expected)

def testIsThisOverWork(self):
com = SuperComputer()

numOfCPU = 10
eachWork = [0, 0, 100, 0, 0, 0, 0, 0, 0, 0]
com.input( numOfCPU, eachWork )

id = 3
self.assertEqual( com.isThisOverWork(id), True )
id = 1
self.assertEqual( com.isThisOverWork(id), False )

def testRun(self):
com = SuperComputer()

numOfCPU = 10
eachWork = [0, 0, 100, 0, 0, 0, 0, 0, 0, 0]
com.input( numOfCPU, eachWork )
com.run()

if __name__ == '__main__':
unittest.main()