def __init__(self, index: int):
self.index = index
self.passed = False
self.bindedVertexes = SingleArray()
self.incomingVertexes = SingleArray()
self.color = 'w'
self.incomingValue = 0
self.outgoingValue = 0
self.visited = False
def __init__(self, rows_count: int = None, vector: int = None):
self._array = SingleArray()
self._vector = vector if vector else 10
self._size = 0
self._rows_size = 0
if rows_count is not None:
for i in range(rows_count):
self._array.add(VectorArray(self._vector))
self._rows_size += 1
def get_unique_count(self):
uniqueVertexes = SingleArray()
for row in self._array:
if uniqueVertexes.getIndexByValue(row[0]) is None:
uniqueVertexes.add(row[0])
if uniqueVertexes.getIndexByValue(row[1]) is None:
uniqueVertexes.add(row[1])
return uniqueVertexes.size()
def get_figures_by_code(self, code: str):
res = SingleArray()
for i in range(self._figures.rows_size()):
row = self._figures.get_row(i)
for j in range(8):
figure = row.get(j)
if figure is None:
continue
if figure.code == code:
res.add(figure)
return res
def makeAdjacencyVector(vertexIndexes: []):
uniqueCount = 0
uniqueIndexes = SingleArray()
for slaveVertexes in vertexIndexes:
for vertexIndex in slaveVertexes:
if not uniqueIndexes.getIndexByValue(vertexIndex) is None:
continue
uniqueIndexes.add(vertexIndex)
uniqueCount += 1
return AdjacencyVector(uniqueCount)
def test_single_array(self):
singleArray = SingleArray()
for i in range(30):
singleArray.add(i)
print(singleArray.get(15))
print(singleArray.size())
singleArray.insert('test', 15)
print(singleArray.get(15))
print(singleArray.size())
print(singleArray.remove(15))
print(singleArray.get(15))
print(singleArray.size())
def get_table(self):
res = SingleArray()
all_count = 0
for j in range(8):
for move_key in self._moves:
if get_col_char(j) in move_key:
all_count += self._moves[move_key].size()
res.add(self._moves[move_key].join(' '))
res_all = "\n".join(res.get_all())
if len(res_all) > 0:
return str(all_count) + "\n" + res_all
else:
return str(all_count)
def __init__(self, rows_count: int):
self.vector = VectorArray(rows_count)
for i in range(rows_count):
self.vector.add(SingleArray())
def cosarayuIterative(vertexIndexes: []):
adjacencyVector = makeAdjacencyVector(vertexIndexes)
vertexes = makeVertexesArray(vertexIndexes, adjacencyVector)
invertedVector = adjacencyVector.getInvertedVector()
invertedVertexes = deepcopy(vertexes)
for rowVertexIndex, rowBindedVertexIndexes in enumerate(
invertedVector.vector):
invertedVertexes[rowVertexIndex].clearBindedIndexes()
for bindedVertexIndex in rowBindedVertexIndexes:
invertedVertexes[rowVertexIndex].addBindedVertex(
invertedVertexes[bindedVertexIndex])
components = Dictionary()
compVertexesQueue = BasicQueue()
compVertexesStack = BasicStack()
invertedMatrix = adjacencyVector.getInvertedVector()
for rowVertexIndex, rowBindedVertexIndexes in enumerate(
invertedMatrix.vector):
invertedVertexes[rowVertexIndex].clearBindedIndexes()
for bindedVertexIndex in rowBindedVertexIndexes:
invertedVertexes[rowVertexIndex].addBindedVertex(
invertedVertexes[bindedVertexIndex])
invertedVertexes[0].passed = True
cache = VectorArray()
for rowVertexIndex, rowBindedVertexIndexes in enumerate(
invertedMatrix.vector):
indexCachedVertex = cache.getIndexByValue(rowVertexIndex)
if indexCachedVertex is not None:
continue
cache.add(invertedVertexes[rowVertexIndex].index)
compVertexesQueue.enqueue(rowVertexIndex)
for vertexIndex in rowBindedVertexIndexes:
cachedVertex = cache.getIndexByValue(vertexIndex)
if cachedVertex is not None:
continue
vertex = invertedVertexes[vertexIndex]
if vertex.passed is False:
DFSIterative(vertex, compVertexesQueue, cache,
invertedVertexes)
while not compVertexesQueue.isEmpty():
compVertexesStack.push(compVertexesQueue.dequeue())
component_index = 0
cache = SingleArray()
while not compVertexesStack.isEmpty():
vertexIndex = compVertexesStack.pop()
if components[vertexIndex] is None:
DFS2Iterative(vertexIndex, components, component_index, vertexes,
cache)
component_index += 1
return components.get_all()
def __init__(self, index: int):
self.index = index
self.bindedVertexes = SingleArray()
self.label = float("inf")
def clearBindedIndexes(self):
self.bindedVertexes = SingleArray()
def __init__(self, index: int):
self.index = index
self.passed = False
self.bindedVertexes = SingleArray()
def __init__(self, index: int):
self.index = index
self.incidentEdges = SingleArray()
def clearIncidentEdges(self):
self.incidentEdges = SingleArray()
def add_move(self, from_pos: str, move: str):
if from_pos not in self._moves:
self._moves[from_pos] = SingleArray()
self._moves[from_pos].add(move)
