Information and communications technology
Answer:
class MarblesBoard(object):
def __init__(self, seq):
self.seq = list(seq)
def switch(self):
temp = self.seq[0]
self.seq[0] = self.seq[1]
self.seq[1] = temp
def rotate(self):
temp = self.seq[0]
for i in range(1, len(self.seq)):
self.seq[i-1] = self.seq[i]
self.seq[-1] = temp
def is_solved(self):
for i in range(len(self.seq)):
if i != self.seq[i]:
return False
return True
def __str__(self):
return ' '.join(list(map(str,self.seq)))
def __repr__(self):
return ' '.join(list(map(str,self.seq)))
class Solver(object):
def __init__(self, board):
self.board = board
def solve(self):
steps = 0
while not self.board.is_solved():
if self.board.seq[0] > self.board.seq[1] and self.board.seq[0] != len(self.board.seq) - 1:
self.board.switch()
else:
self.board.rotate()
print(self.board)
steps += 1
print('Total steps:', steps)
Explanation:
The Python class MarblesBoard creates an object of the board game used in the Solver class object instance and it holds data or attributes of the player piece movement and the magic methods (__str__ and __repr__). The Solver object gets the switch and rotate movementt of the player and displays the total steps at the end of the game.
Option B
Synchronous replication modes of replication requires a very low latency network connection and ensures data remains in synch with zero data loss in the event of a failure at the source site
<u>Explanation:</u>
Synchronous replication, information is replicated to a subsequent remote place at the identical period as fresh information is implying generated or renewed in the original datacenter. Actually, both master and target roots endure effectively synchronized, which is vital for triumphant crash restoration.
In the circumstances of synchronous replication, this indicates that the write is deemed ended barely when both local and isolated warehouses approve its fulfillment. Therefore, nullity data failure is assured, but the overall execution is regulated down.
<span>Selecting save from the file menu..</span>