Fix this code so that it will run with proper answers, please dont u.pdf
•
0 likes•3 views
Fix this code so that it will run with proper answers, please dont use chatgpt and please test your code before submitting: import sys import heapq import copy class PriorityQueue(): def __init__(self): self.thisQueue = [] def push(self, thisNode): heapq.heappush(self.thisQueue, (thisNode.val, -thisNode.id, thisNode)) def pop(self): return heapq.heappop(self.thisQueue)[2] def isEmpty(self): return len(self.thisQueue) == 0 def length(self): return len(self.thisQueue) class Set(): def __init__(self): self.thisSet = set() def add(self, entry): if entry is not None: self.thisSet.add(entry.__hash__()) def length(self): return len(self.thisSet) def isMember(self, query): return query.__hash__() in self.thisSet class Node(): def __init__(self, val, startstate, endstate, depth): global nodeid self.id = nodeid nodeid += 1 self.val = val self.state = startstate self.endstate = endstate self.depth = depth def __str__(self): return 'Node: id=%d val=%d' % (self.id, self.val) def expand(current_node, closedlist, goal_state): closedlist.add(current_node.state) successors = [] up_child = current_node.state.up() down_child = current_node.state.down() right_child = current_node.state.right() left_child = current_node.state.left() children = [left_child, right_child, up_child, down_child] for child in children: if child is not None and not closedlist.isMember(child): s = Node(0, child, None, current_node.depth + 1) s.parent_node = current_node if child == left_child: s.action = "left" elif child == right_child: s.action = "right" elif child == up_child: s.action = "up" elif child == down_child: s.action = "down" successors.append(s) return successors def h0(currenttiles, stiles): misplaced = 0 for i in range(len(stiles)): for j in range(len(currenttiles)): if stiles[i][j] != currenttiles[i][j]: misplaced += 1 return misplaced def manhattan(currenttiles, stiles): total = 0 for i in range(len(stiles)): for j in range(len(currenttiles)): if stiles[i][j] != currenttiles[i][j]: y = stiles[i][j] a = i b = j for k in range(len(stiles)): for l in range(len(stiles)): if currenttiles[k][l] == y: d = k e = l count = (abs(d - a) + abs(e - b)) total += count return total class State(): def __init__(self): self.xpos = 0 self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] def left(self): if self.ypos == 0: return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def right(self): if self.ypos == 2: return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1 s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0: return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos] s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if self.xpos == 2: return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos + 1][s.ypos] s.xpos += 1 s.tiles[s.xpos][s.ypos] = 0 return s def __hash__(self): return (tuple(self.tiles[.
Report
Share
Report
Share
Download to read offline
![Fix this code so that it will run with proper answers, please dont use chatgpt and please test your
code before submitting:
import sys
import heapq
import copy
class PriorityQueue():
def __init__(self):
self.thisQueue = []
def push(self, thisNode):
heapq.heappush(self.thisQueue, (thisNode.val, -thisNode.id, thisNode))
def pop(self):
return heapq.heappop(self.thisQueue)[2]
def isEmpty(self):
return len(self.thisQueue) == 0
def length(self):
return len(self.thisQueue)
class Set():
def __init__(self):
self.thisSet = set()
def add(self, entry):
if entry is not None:
self.thisSet.add(entry.__hash__())
def length(self):
return len(self.thisSet)
def isMember(self, query):
return query.__hash__() in self.thisSet
class Node():
def __init__(self, val, startstate, endstate, depth):
global nodeid
self.id = nodeid
nodeid += 1
self.val = val
self.state = startstate
self.endstate = endstate
self.depth = depth](https://image.slidesharecdn.com/fixthiscodesothatitwillrunwithproperanswerspleasedontu-231007064636-288b4176/85/Fix-this-code-so-that-it-will-run-with-proper-answers-please-dont-u-pdf-1-320.jpg)
![def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val)
def expand(current_node, closedlist, goal_state):
closedlist.add(current_node.state)
successors = []
up_child = current_node.state.up()
down_child = current_node.state.down()
right_child = current_node.state.right()
left_child = current_node.state.left()
children = [left_child, right_child, up_child, down_child]
for child in children:
if child is not None and not closedlist.isMember(child):
s = Node(0, child, None, current_node.depth + 1)
s.parent_node = current_node
if child == left_child:
s.action = "left"
elif child == right_child:
s.action = "right"
elif child == up_child:
s.action = "up"
elif child == down_child:
s.action = "down"
successors.append(s)
return successors
def h0(currenttiles, stiles):
misplaced = 0
for i in range(len(stiles)):
for j in range(len(currenttiles)):
if stiles[i][j] != currenttiles[i][j]:
misplaced += 1
return misplaced
def manhattan(currenttiles, stiles):
total = 0
for i in range(len(stiles)):
for j in range(len(currenttiles)):
if stiles[i][j] != currenttiles[i][j]:](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
Will upvote Please fix the following code and post your inputs and o.pdf
Will upvote Please fix the following code and post your inputs and outputs please run your code
to make sure it works
import sys
import heapq
import copy
class PriorityQueue():
def __init__(self):
self.thisQueue = []
def push(self, thisNode):
heapq.heappush(self.thisQueue, (thisNode.val, -thisNode.id, thisNode))
def pop(self):
return heapq.heappop(self.thisQueue)[2]
def isEmpty(self):
return len(self.thisQueue) == 0
def length(self):
return len(self.thisQueue)
class Set():
def __init__(self):
self.thisSet = set()
def add(self, entry):
if entry is not None:
self.thisSet.add(entry.__hash__())
def length(self):
return len(self.thisSet)
def isMember(self, query):
return query.__hash__() in self.thisSet
class Node():
def __init__(self, val, startstate, endstate, depth):
global nodeid
self.id = nodeid
nodeid += 1
self.val = val
self.state = startstate
self.endstate = endstate
self.depth = depth
def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val)
def expand(current_node, closedlist, goal_state):
closedlist.add(current_node.state)
successors = []
up_child = current_node.state.up()
down_child = current_node.state.down()
right_child = current_node.state.right()
left_child = current_node.state.left()
children = [left_child, right_child, up_child, down_child]
for child in children:
if child is not None and not closedlist.isMember(child):
s = Node(0, child, None, current_node.depth + 1)
s.parent_node = current_node
if child == left_child:
s.action = "left"
elif child == right_child:
s.action = "right"
elif child == up_child:
s.action = "up"
elif child == down_child:
s.action = "down"
successors.append(s)
return successors
def h0(currenttiles, stiles):
misplaced = 0
for i in range(len(stiles)):
for j in range(len(currenttiles)):
if stiles[i][j] != currenttiles[i][j]:
misplaced += 1
return misplaced
def manhattan(currenttiles, stiles):
total = 0
for i in range(len(stiles)):
for j in range(len(currenttiles)):
if stiles[i][j] != currenttiles[i][j]:
y = stiles[i][j]
a = i
b = j
for k in range(len(stiles)):
for l in range(len(stiles)):
if currenttiles[k][l] == y:
d = k
e = l
count = (abs(d - a) + abs(e - b))
total += count
return total
class State():
def __init__(self):
self.xpos = 0
self.ypos = 0
self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
def left(self):
if self.ypos == 0:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1]
s.ypos -= 1
s.tiles[s.xpos][s.ypos] = 0
return s
def right(self):
if self.ypos == 2:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1]
s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0
return s
def up(self):
if self.xpos == 0:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1
s.tiles[s.xpos][s.ypos] = 0
return s
def down(self):
if self.xpos == 2:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos + 1][s.ypos]
s.xpos += 1
s.tiles[s.xpos][s.ypos] = 0
return s
def __hash__(self):
return (tuple(self.tiles[0]), t.
Will upvote asapPlease help my code gives me incorrect val.pdf
Will upvote asap******
Please help my code gives me incorrect values for heuristics in java:
This code should solve the 8 puzzle in java
Please do not use chatGPT and please run your code before sending it to me as I have gotten
multiple wrong answers
import sys
import heapq
import copy
class PriorityQueue():
def __init__(self):
self.thisQueue = []
def push(self, thisNode):
heapq.heappush(self.thisQueue, (thisNode.val, -thisNode.id, thisNode))
def pop(self):
return heapq.heappop(self.thisQueue)[2]
def isEmpty(self):
return len(self.thisQueue) == 0
def length(self):
return len(self.thisQueue)
class Set():
def __init__(self):
self.thisSet = set()
def add(self, entry):
if entry is not None:
self.thisSet.add(entry.__hash__())
def length(self):
return len(self.thisSet)
def isMember(self, query):
return query.__hash__() in self.thisSet
class Node():
def __init__(self, val, startstate, endstate, depth):
global nodeid
self.id = nodeid
nodeid += 1
self.val = val
self.state = startstate
self.endstate = endstate
self.depth = depth
depth+=1
def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val)
def expand(current_node, closedlist, goal_state):
closedlist.add(current_node.state)
successors = []
up_child = current_node.state.up()
down_child = current_node.state.down()
right_child = current_node.state.right()
left_child = current_node.state.left()
children = [left_child, right_child, up_child, down_child]
for child in children:
if child is not None and not closedlist.isMember(child):
s = Node(0, child, None, current_node.depth + 1)
s.parent_node = current_node
if child == left_child:
s.action = "left"
elif child == right_child:
s.action = "right"
elif child == up_child:
s.action = "up"
elif child == down_child:
s.action = "down"
successors.append(s)
return successors
def h0(currenttiles, stiles):
misplaced = 0
for i in range(len(stiles)):
for j in range(len(currenttiles)):
if stiles[i][j] != currenttiles[i][j]:
misplaced += 1
return misplaced
def manhattan(currenttiles, stiles):
total = 0
for i in range(len(stiles)):
for j in range(len(currenttiles)):
if stiles[i][j] != currenttiles[i][j]:
y = stiles[i][j]
a = i
b = j
for k in range(len(stiles)):
for l in range(len(stiles)):
if currenttiles[k][l] == y:
d = k
e = l
count = (abs(d - a) + abs(e - b))
total += count
return total
class State():
def __init__(self):
self.xpos = 0
self.ypos = 0
self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
def left(self):
if self.ypos == 0:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1]
s.ypos -= 1
s.tiles[s.xpos][s.ypos] = 0
return s
def right(self):
if self.ypos == 2:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1]
s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0
return s
def up(self):
if self.xpos == 0:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1
s.tiles[s.xpos][s.ypos] = 0
return s
def down(self):
if self.xpos == 2:
return None
s = self.copy()
s.tiles[s.x.
Please help this code is supposed to evaluate current node state and i.pdf
Please help this code is supposed to evaluate current node state and if its not the goal state create
children nodes. It is then supposed evaluate which node has the shortest manhattan distance and
then select it as the current node import sys import heapq import copy class PriorityQueue():
def __init__(self): self.thisQueue = [] def push(self, thisNode):
heapq.heappush(self.thisQueue, (thisNode.val, -thisNode.id, thisNode)) def pop(self):
return heapq.heappop(self.thisQueue)[2] def isEmpty(self): return len(self.thisQueue) == 0
def length(self): return len(self.thisQueue) class Set(): def __init__(self): self.thisSet
= set() def add(self, entry): if entry is not None: self.thisSet.add(entry.__hash__())
def length(self): return len(self.thisSet) def isMember(self, query): return
query.__hash__() in self.thisSet class Node(): def __init__(self, val, startstate, endstate, depth,
cost): global nodeid self.id = nodeid nodeid += 1 self.val = val self.state =
startstate self.endstate = endstate self.depth = 0 self.cost = cost def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val) class State(): def __init__(self):
self.xpos = 0 self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost=
cost def left(self): if self.ypos == 0: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos]
= 0 return s def right(self): if self.ypos == 2: return None s =
self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if
self.xpos == 2: return None s = self.copy() s.tiles[s.xpos][s.ypos] =
s.tiles[s.xpos + 1][s.ypos] s.xpos += 1 s.tiles[s.xpos][s.ypos] = 0 return s
def __hash__(self): return (tuple(self.tiles[0]),tuple(self.tiles[1]),tuple(self.tiles[2]))
def __str__(self): return '%d %d %d\n%d %d %d\n%d %d %d\n'%(
self.tiles[0][0],self.tiles[0][1],self.tiles[0][2],
self.tiles[1][0],self.tiles[1][1],self.tiles[1][2],
self.tiles[2][0],self.tiles[2][1],self.tiles[2][2]) def copy(self): s = copy.deepcopy(self)
return s def __eq__(self, other): if other is None: return False
return self.tiles == other.tiles class State(): def __init__(self): self.xpos = 0
self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost= 0 def
left(self): if self.ypos == 0: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos]
= 0 return s def right(self): if self.ypos == 2: return None s =
self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if
self.xpos == 2: .
Please help me fix this code! will upvote. The code needs to produce .pdf
Please help me fix this code! will upvote. The code needs to produce nodes for the current state.
and when the current state isnt the goal state, its supposed to create child nodes and pick the node
with the smallest manhattan distance and make that the next node in the list. Then print all of the
states of the board until the goal state class PriorityQueue(): def __init__(self):
self.thisQueue = [] def push(self, thisNode): heapq.heappush(self.thisQueue,
(thisNode.val, -thisNode.id, thisNode)) def pop(self): return
heapq.heappop(self.thisQueue)[2] def isEmpty(self): return len(self.thisQueue) == 0 def
length(self): return len(self.thisQueue) class Set(): def __init__(self): self.thisSet =
set() def add(self, entry): if entry is not None: self.thisSet.add(entry.__hash__())
def length(self): return len(self.thisSet) def isMember(self, query): return
query.__hash__() in self.thisSet class Node(): def __init__(self, val, startstate, endstate, depth,
cost): global nodeid self.id = nodeid nodeid += 1 self.val = val self.state =
startstate self.endstate = endstate self.depth = 0 self.cost = cost def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val) class State(): def __init__(self):
self.xpos = 0 self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost=
cost def left(self): if self.ypos == 0: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos]
= 0 return s def right(self): if self.ypos == 2: return None s =
self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if
self.xpos == 2: return None s = self.copy() s.tiles[s.xpos][s.ypos] =
s.tiles[s.xpos + 1][s.ypos] s.xpos += 1 s.tiles[s.xpos][s.ypos] = 0 return s
def __hash__(self): return (tuple(self.tiles[0]),tuple(self.tiles[1]),tuple(self.tiles[2]))
def __str__(self): return '%d %d %d\n%d %d %d\n%d %d %d\n'%(
self.tiles[0][0],self.tiles[0][1],self.tiles[0][2],
self.tiles[1][0],self.tiles[1][1],self.tiles[1][2],
self.tiles[2][0],self.tiles[2][1],self.tiles[2][2]) def copy(self): s = copy.deepcopy(self)
return s def __eq__(self, other): if other is None: return False
return self.tiles == other.tiles class State(): def __init__(self): self.xpos = 0
self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost= 0 def left(self):
if self.ypos == 0: return None s = self.copy() s.tiles[s.xpos][s.ypos]
= s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s
def right(self): if self.ypos == 2: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.
# Imports# Include your imports here, if any are used. import.pdf
The document contains code for solving three puzzles: (1) the N-Queens puzzle using backtracking to find all solutions, (2) the Lights Out puzzle using breadth-first search to find a solution, and (3) the Linear Disk Movement puzzle to rearrange disks in a line using breadth-first search. Common data structures like queues and sets are used. Puzzles are modeled as classes with methods to get valid moves, check for solutions, and search the state space.
Introduction to Python
Seminar on the Python Programming language done for iCell introductory meet.
Covers all the basic concepts in Python.
python3 HashTableSolutionmain.pyfrom ChainingHashTable impor.pdf
python3 HashTable
Solution
main.py
from ChainingHashTable import ChainingHashTable
def TestHashTable():
h_table = ChainingHashTable(5)
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
h_table[10] = \"Mouse\"
h_table[5] = \"Rat\"
h_table[2] = \"Dog\"
h_table[1] = \"Cat\"
h_table[3] = \"Rhino\"
h_table[9] = \"Eagle\"
h_table[14] = \"Condor\"
h_table[4] = \"Hawk\"
print()
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
print()
for i in range(10):
if i in h_table:
print(h_table[i],end = \" \")
print()
del h_table[5]
del h_table[2]
del h_table[9]
h_table[4] = \"Falcon\"
print()
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
def main():
TestHashTable()
main()
ChainingHashTable.py
from OrderedList import OrderedList
from Node import Node
class ChainingHashTable:
def __init__(self, size):
self.__size = size
self.__count = 0
self.__slots = [OrderedList()] * self.__size
self.__deleted = \"\\0\"
def hash_function(self, key, size):
return key % size
def rehash(self, old_hash,size):
return (old_hash + 1) % size
def get_data(self):
return self.__count
def getitem(self, key):
start_slot = self.hash_function(key,len(self.__slots))
position = start_slot
while self.__slots[position] != None:
if self.__slots[position] == key:
return self.__data[position]
else:
position = self.rehash(position, len(self.__slots))
if position == start_slot:
return None
return None
def __getitem__(self, key):
return self.get(key)
def put(self, key, value):
hash_value = self.hash_function(key,len(self.__slots))
if self.__slots[hash_value] == None or \\
self.__slots[hash_value] == self.__deleted:
self.__slots[hash_value] = key
self.__data[hash_value] = data
elif self.__slots[hash_value] == key:
self.__data[hash_value] = data
else:
next_slot = self.rehash(hash_value, len(self.__slots))
while self.__slots[next_slot] != None\\
and self.__slots[next_slot] != self.__deleted \\
and self.__slots[next_slot] != key:
next_slot = self.rehash(next_slot,len(self.__slots))
if next_slot == hash_value:
return
if self.__slots[next_slot] == None or \\
self.__slots[next_slot] == self.__deleted:
self.__slots[next_slot] = key
self.__data[next_slot] = data
else:
self.__data[next_slot] = data
def __setitem__(self, key, value):
return self.put(key, value)
def delete(self, key):
start_slot = self.hash_function(key, len(self.__slots))
position = start_slot
key_in_slot = self.__slots[position]
while key_in_slot != None:
if key_in_slot == key:
self.__slots[position] = self.deleted
self.__data[position] = self.deleted
return None
else:
position = self.rehash(position, len(self.__slots))
key_in_slot = self.__slots[position]
if position == start_slot:
return None
def __delitem__(self, key):
return self.delete(key)
def __len__(self):
count = 0
for value in self.__slots:
if value != None and value != self.__deleted:
count += 1
return count
def __contains__(self, key):
return self.getitem(key) != None
def __str__(self):
count = 0
for x in self.__slots:
print.
DjangoCon US 2011 - Monkeying around at New Relic
The document discusses various techniques for instrumenting Python code to collect performance timing data using the New Relic agent. It describes using context managers, decorators, monkey patching, and custom import hooks to trace functions, WSGI applications, and database queries. The goal is to capture metrics like response times, trace function calls, exceptions and other events to provide performance monitoring and debugging information within the New Relic web UI.
Recommended
Will upvote Please fix the following code and post your inputs and o.pdf
Will upvote Please fix the following code and post your inputs and outputs please run your code
to make sure it works
import sys
import heapq
import copy
class PriorityQueue():
def __init__(self):
self.thisQueue = []
def push(self, thisNode):
heapq.heappush(self.thisQueue, (thisNode.val, -thisNode.id, thisNode))
def pop(self):
return heapq.heappop(self.thisQueue)[2]
def isEmpty(self):
return len(self.thisQueue) == 0
def length(self):
return len(self.thisQueue)
class Set():
def __init__(self):
self.thisSet = set()
def add(self, entry):
if entry is not None:
self.thisSet.add(entry.__hash__())
def length(self):
return len(self.thisSet)
def isMember(self, query):
return query.__hash__() in self.thisSet
class Node():
def __init__(self, val, startstate, endstate, depth):
global nodeid
self.id = nodeid
nodeid += 1
self.val = val
self.state = startstate
self.endstate = endstate
self.depth = depth
def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val)
def expand(current_node, closedlist, goal_state):
closedlist.add(current_node.state)
successors = []
up_child = current_node.state.up()
down_child = current_node.state.down()
right_child = current_node.state.right()
left_child = current_node.state.left()
children = [left_child, right_child, up_child, down_child]
for child in children:
if child is not None and not closedlist.isMember(child):
s = Node(0, child, None, current_node.depth + 1)
s.parent_node = current_node
if child == left_child:
s.action = "left"
elif child == right_child:
s.action = "right"
elif child == up_child:
s.action = "up"
elif child == down_child:
s.action = "down"
successors.append(s)
return successors
def h0(currenttiles, stiles):
misplaced = 0
for i in range(len(stiles)):
for j in range(len(currenttiles)):
if stiles[i][j] != currenttiles[i][j]:
misplaced += 1
return misplaced
def manhattan(currenttiles, stiles):
total = 0
for i in range(len(stiles)):
for j in range(len(currenttiles)):
if stiles[i][j] != currenttiles[i][j]:
y = stiles[i][j]
a = i
b = j
for k in range(len(stiles)):
for l in range(len(stiles)):
if currenttiles[k][l] == y:
d = k
e = l
count = (abs(d - a) + abs(e - b))
total += count
return total
class State():
def __init__(self):
self.xpos = 0
self.ypos = 0
self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
def left(self):
if self.ypos == 0:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1]
s.ypos -= 1
s.tiles[s.xpos][s.ypos] = 0
return s
def right(self):
if self.ypos == 2:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1]
s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0
return s
def up(self):
if self.xpos == 0:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1
s.tiles[s.xpos][s.ypos] = 0
return s
def down(self):
if self.xpos == 2:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos + 1][s.ypos]
s.xpos += 1
s.tiles[s.xpos][s.ypos] = 0
return s
def __hash__(self):
return (tuple(self.tiles[0]), t.
Will upvote asapPlease help my code gives me incorrect val.pdf
Will upvote asap******
Please help my code gives me incorrect values for heuristics in java:
This code should solve the 8 puzzle in java
Please do not use chatGPT and please run your code before sending it to me as I have gotten
multiple wrong answers
import sys
import heapq
import copy
class PriorityQueue():
def __init__(self):
self.thisQueue = []
def push(self, thisNode):
heapq.heappush(self.thisQueue, (thisNode.val, -thisNode.id, thisNode))
def pop(self):
return heapq.heappop(self.thisQueue)[2]
def isEmpty(self):
return len(self.thisQueue) == 0
def length(self):
return len(self.thisQueue)
class Set():
def __init__(self):
self.thisSet = set()
def add(self, entry):
if entry is not None:
self.thisSet.add(entry.__hash__())
def length(self):
return len(self.thisSet)
def isMember(self, query):
return query.__hash__() in self.thisSet
class Node():
def __init__(self, val, startstate, endstate, depth):
global nodeid
self.id = nodeid
nodeid += 1
self.val = val
self.state = startstate
self.endstate = endstate
self.depth = depth
depth+=1
def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val)
def expand(current_node, closedlist, goal_state):
closedlist.add(current_node.state)
successors = []
up_child = current_node.state.up()
down_child = current_node.state.down()
right_child = current_node.state.right()
left_child = current_node.state.left()
children = [left_child, right_child, up_child, down_child]
for child in children:
if child is not None and not closedlist.isMember(child):
s = Node(0, child, None, current_node.depth + 1)
s.parent_node = current_node
if child == left_child:
s.action = "left"
elif child == right_child:
s.action = "right"
elif child == up_child:
s.action = "up"
elif child == down_child:
s.action = "down"
successors.append(s)
return successors
def h0(currenttiles, stiles):
misplaced = 0
for i in range(len(stiles)):
for j in range(len(currenttiles)):
if stiles[i][j] != currenttiles[i][j]:
misplaced += 1
return misplaced
def manhattan(currenttiles, stiles):
total = 0
for i in range(len(stiles)):
for j in range(len(currenttiles)):
if stiles[i][j] != currenttiles[i][j]:
y = stiles[i][j]
a = i
b = j
for k in range(len(stiles)):
for l in range(len(stiles)):
if currenttiles[k][l] == y:
d = k
e = l
count = (abs(d - a) + abs(e - b))
total += count
return total
class State():
def __init__(self):
self.xpos = 0
self.ypos = 0
self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
def left(self):
if self.ypos == 0:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1]
s.ypos -= 1
s.tiles[s.xpos][s.ypos] = 0
return s
def right(self):
if self.ypos == 2:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1]
s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0
return s
def up(self):
if self.xpos == 0:
return None
s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1
s.tiles[s.xpos][s.ypos] = 0
return s
def down(self):
if self.xpos == 2:
return None
s = self.copy()
s.tiles[s.x.
Please help this code is supposed to evaluate current node state and i.pdf
Please help this code is supposed to evaluate current node state and if its not the goal state create
children nodes. It is then supposed evaluate which node has the shortest manhattan distance and
then select it as the current node import sys import heapq import copy class PriorityQueue():
def __init__(self): self.thisQueue = [] def push(self, thisNode):
heapq.heappush(self.thisQueue, (thisNode.val, -thisNode.id, thisNode)) def pop(self):
return heapq.heappop(self.thisQueue)[2] def isEmpty(self): return len(self.thisQueue) == 0
def length(self): return len(self.thisQueue) class Set(): def __init__(self): self.thisSet
= set() def add(self, entry): if entry is not None: self.thisSet.add(entry.__hash__())
def length(self): return len(self.thisSet) def isMember(self, query): return
query.__hash__() in self.thisSet class Node(): def __init__(self, val, startstate, endstate, depth,
cost): global nodeid self.id = nodeid nodeid += 1 self.val = val self.state =
startstate self.endstate = endstate self.depth = 0 self.cost = cost def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val) class State(): def __init__(self):
self.xpos = 0 self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost=
cost def left(self): if self.ypos == 0: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos]
= 0 return s def right(self): if self.ypos == 2: return None s =
self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if
self.xpos == 2: return None s = self.copy() s.tiles[s.xpos][s.ypos] =
s.tiles[s.xpos + 1][s.ypos] s.xpos += 1 s.tiles[s.xpos][s.ypos] = 0 return s
def __hash__(self): return (tuple(self.tiles[0]),tuple(self.tiles[1]),tuple(self.tiles[2]))
def __str__(self): return '%d %d %d\n%d %d %d\n%d %d %d\n'%(
self.tiles[0][0],self.tiles[0][1],self.tiles[0][2],
self.tiles[1][0],self.tiles[1][1],self.tiles[1][2],
self.tiles[2][0],self.tiles[2][1],self.tiles[2][2]) def copy(self): s = copy.deepcopy(self)
return s def __eq__(self, other): if other is None: return False
return self.tiles == other.tiles class State(): def __init__(self): self.xpos = 0
self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost= 0 def
left(self): if self.ypos == 0: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos]
= 0 return s def right(self): if self.ypos == 2: return None s =
self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if
self.xpos == 2: .
Please help me fix this code! will upvote. The code needs to produce .pdf
Please help me fix this code! will upvote. The code needs to produce nodes for the current state.
and when the current state isnt the goal state, its supposed to create child nodes and pick the node
with the smallest manhattan distance and make that the next node in the list. Then print all of the
states of the board until the goal state class PriorityQueue(): def __init__(self):
self.thisQueue = [] def push(self, thisNode): heapq.heappush(self.thisQueue,
(thisNode.val, -thisNode.id, thisNode)) def pop(self): return
heapq.heappop(self.thisQueue)[2] def isEmpty(self): return len(self.thisQueue) == 0 def
length(self): return len(self.thisQueue) class Set(): def __init__(self): self.thisSet =
set() def add(self, entry): if entry is not None: self.thisSet.add(entry.__hash__())
def length(self): return len(self.thisSet) def isMember(self, query): return
query.__hash__() in self.thisSet class Node(): def __init__(self, val, startstate, endstate, depth,
cost): global nodeid self.id = nodeid nodeid += 1 self.val = val self.state =
startstate self.endstate = endstate self.depth = 0 self.cost = cost def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val) class State(): def __init__(self):
self.xpos = 0 self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost=
cost def left(self): if self.ypos == 0: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos]
= 0 return s def right(self): if self.ypos == 2: return None s =
self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if
self.xpos == 2: return None s = self.copy() s.tiles[s.xpos][s.ypos] =
s.tiles[s.xpos + 1][s.ypos] s.xpos += 1 s.tiles[s.xpos][s.ypos] = 0 return s
def __hash__(self): return (tuple(self.tiles[0]),tuple(self.tiles[1]),tuple(self.tiles[2]))
def __str__(self): return '%d %d %d\n%d %d %d\n%d %d %d\n'%(
self.tiles[0][0],self.tiles[0][1],self.tiles[0][2],
self.tiles[1][0],self.tiles[1][1],self.tiles[1][2],
self.tiles[2][0],self.tiles[2][1],self.tiles[2][2]) def copy(self): s = copy.deepcopy(self)
return s def __eq__(self, other): if other is None: return False
return self.tiles == other.tiles class State(): def __init__(self): self.xpos = 0
self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost= 0 def left(self):
if self.ypos == 0: return None s = self.copy() s.tiles[s.xpos][s.ypos]
= s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s
def right(self): if self.ypos == 2: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.
# Imports# Include your imports here, if any are used. import.pdf
The document contains code for solving three puzzles: (1) the N-Queens puzzle using backtracking to find all solutions, (2) the Lights Out puzzle using breadth-first search to find a solution, and (3) the Linear Disk Movement puzzle to rearrange disks in a line using breadth-first search. Common data structures like queues and sets are used. Puzzles are modeled as classes with methods to get valid moves, check for solutions, and search the state space.
Introduction to Python
Seminar on the Python Programming language done for iCell introductory meet.
Covers all the basic concepts in Python.
python3 HashTableSolutionmain.pyfrom ChainingHashTable impor.pdf
python3 HashTable
Solution
main.py
from ChainingHashTable import ChainingHashTable
def TestHashTable():
h_table = ChainingHashTable(5)
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
h_table[10] = \"Mouse\"
h_table[5] = \"Rat\"
h_table[2] = \"Dog\"
h_table[1] = \"Cat\"
h_table[3] = \"Rhino\"
h_table[9] = \"Eagle\"
h_table[14] = \"Condor\"
h_table[4] = \"Hawk\"
print()
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
print()
for i in range(10):
if i in h_table:
print(h_table[i],end = \" \")
print()
del h_table[5]
del h_table[2]
del h_table[9]
h_table[4] = \"Falcon\"
print()
print(\"Hash Table:\")
print(h_table)
print(\"Size:\",len(h_table))
def main():
TestHashTable()
main()
ChainingHashTable.py
from OrderedList import OrderedList
from Node import Node
class ChainingHashTable:
def __init__(self, size):
self.__size = size
self.__count = 0
self.__slots = [OrderedList()] * self.__size
self.__deleted = \"\\0\"
def hash_function(self, key, size):
return key % size
def rehash(self, old_hash,size):
return (old_hash + 1) % size
def get_data(self):
return self.__count
def getitem(self, key):
start_slot = self.hash_function(key,len(self.__slots))
position = start_slot
while self.__slots[position] != None:
if self.__slots[position] == key:
return self.__data[position]
else:
position = self.rehash(position, len(self.__slots))
if position == start_slot:
return None
return None
def __getitem__(self, key):
return self.get(key)
def put(self, key, value):
hash_value = self.hash_function(key,len(self.__slots))
if self.__slots[hash_value] == None or \\
self.__slots[hash_value] == self.__deleted:
self.__slots[hash_value] = key
self.__data[hash_value] = data
elif self.__slots[hash_value] == key:
self.__data[hash_value] = data
else:
next_slot = self.rehash(hash_value, len(self.__slots))
while self.__slots[next_slot] != None\\
and self.__slots[next_slot] != self.__deleted \\
and self.__slots[next_slot] != key:
next_slot = self.rehash(next_slot,len(self.__slots))
if next_slot == hash_value:
return
if self.__slots[next_slot] == None or \\
self.__slots[next_slot] == self.__deleted:
self.__slots[next_slot] = key
self.__data[next_slot] = data
else:
self.__data[next_slot] = data
def __setitem__(self, key, value):
return self.put(key, value)
def delete(self, key):
start_slot = self.hash_function(key, len(self.__slots))
position = start_slot
key_in_slot = self.__slots[position]
while key_in_slot != None:
if key_in_slot == key:
self.__slots[position] = self.deleted
self.__data[position] = self.deleted
return None
else:
position = self.rehash(position, len(self.__slots))
key_in_slot = self.__slots[position]
if position == start_slot:
return None
def __delitem__(self, key):
return self.delete(key)
def __len__(self):
count = 0
for value in self.__slots:
if value != None and value != self.__deleted:
count += 1
return count
def __contains__(self, key):
return self.getitem(key) != None
def __str__(self):
count = 0
for x in self.__slots:
print.
DjangoCon US 2011 - Monkeying around at New Relic
The document discusses various techniques for instrumenting Python code to collect performance timing data using the New Relic agent. It describes using context managers, decorators, monkey patching, and custom import hooks to trace functions, WSGI applications, and database queries. The goal is to capture metrics like response times, trace function calls, exceptions and other events to provide performance monitoring and debugging information within the New Relic web UI.
Djangocon11: Monkeying around at New Relic
The document discusses various techniques for instrumenting Python code to trace function calls and collect performance metrics. It describes using context managers and decorators to time code blocks and functions. It also covers how to instrument WSGI applications and middleware using wrappers, monkey patching, and the New Relic agent API. The goal is to capture traces of functions, database calls, external requests and other events to provide visibility into application performance.
밑바닥부터 시작하는 의료 AI
발표자: 김준호(Lunit)
발표일: 2018.1.
의료 AI 관련 중, nodule detection 문제에 대해 다뤄보고자 합니다.
의료 AI에서는 어떠한 방식으로 classication을 하고, preprocessing은 어떤식으로 진행되는지 LUNA16이라는 의료 challenge에 이용되는 데이터를 가지고 발표를 진행해보고자 합니다.
이후, 이 데이터를 이용해서 최근 2017 MICCAI (의료 영상학회에서는 높은 수준의 학회)에서 발표된 "curriculum adaptive sampling for extreme data imbalance"를 실제 구현해서 적용해보고 이 때 발생할 수 있는 문제를 어떤식으로 해결할 수 있는지에 대한 tip도 제공할 예정입니다. (Python multi-processing data load, input-pipeline)
위 논문을 선정한 이유는, 단순한 classification이 아닌, nodule이 있는 위치도 정확하게 catch하는 논문 중, performance가 상당히 높기 때문입니다.
ScalaBlitz
Scala eXchange 2013 presentation of the ScalaBlitz - a highly optimized data-parallel collection framework for Scala.
Implemeting queue in python.pptx
This document provides code for implementing a queue data structure in Python. The code defines functions for enqueueing (adding) an item to the rear of the queue, dequeuing (removing) an item from the front of the queue, and getting the front and rear items. It also includes sample output showing items being added and removed from the queue and the front and rear items being retrieved.
goal_state = [1, 8, 7, 2, 0, 6, 3, 4, 5] #goal_state = [1, 0, 7, 2, .pdf
goal_state = [1, 8, 7, 2, 0, 6, 3, 4, 5] #goal_state = [1, 0, 7, 2, 8, 6, 3, 4, 5] import sys global
count def display_board( state ): #print \"-------------\" print \" %i %i %i \" %
(state[0], state[3], state[6]) #print \"-------------\" print \" %i %i %i \" % (state[1],
state[4], state[7]) #print \"-------------\" print \" %i %i %i \" % (state[2], state[5],
state[8]) #print \"-------------\" def move_up( state ): new_state = state[:] index =
new_state.index( 0 ) if index not in [0, 3, 6]: temp = new_state[index - 1]
new_state[index - 1] = new_state[index] new_state[index] = temp return
new_state else: return None def move_down( state ): new_state = state[:]
index = new_state.index( 0 ) if index not in [2, 5, 8]: temp = new_state[index + 1]
new_state[index + 1] = new_state[index] new_state[index] = temp
return new_state else: return None def move_left( state ): new_state = state[:]
index = new_state.index( 0 ) if index not in [0, 1, 2]: temp = new_state[index
- 3] new_state[index - 3] = new_state[index] new_state[index] = temp
return new_state else: return None def move_right( state ): new_state =
state[:] index = new_state.index( 0 ) if index not in [6, 7, 8]: temp =
new_state[index + 3] new_state[index + 3] = new_state[index]
new_state[index] = temp return new_state else: return None def
create_node( state, parent, operator, depth, cost ): return Node( state, parent, operator,
depth, cost ) def expand_node( node, nodes ): expanded_nodes = []
expanded_nodes.append( create_node( move_up( node.state ), node, \"u\", node.depth + 1, 0 ) )
expanded_nodes.append( create_node( move_down( node.state ), node, \"d\", node.depth + 1,
0 ) ) expanded_nodes.append( create_node( move_left( node.state ), node, \"l\", node.depth
+ 1, 0 ) ) expanded_nodes.append( create_node( move_right( node.state), node, \"r\",
node.depth + 1, 0 ) ) # Filter the list and remove the nodes that are impossible (move
function returned None) expanded_nodes = [node for node in expanded_nodes if node.state
!= None] #list comprehension! expanded_nodes = [node for node in expanded_nodes if
node not in nodes] #list comprehension! #expanded_nodes = [node for node in
expanded_nodes if node.state!= ((node.parent).parent).state] #list comprehension!
expanded_nodes1 = [] for node in expanded_nodes: temp=node
temp=temp.parent temp=temp.parent if temp==None:
expanded_nodes1.extend(expanded_nodes) break if node.state
!=temp.state: expanded_nodes1.append(node) return
expanded_nodes1 def bfs( start, goal ): nodes = [] count=0 # Create the queue
with the root node in it. nodes.append( create_node( start, None, None, 0, 0 ) ) while
True: # We\'ve run out of states, no solution. if len( nodes ) == 0:
return None # take the node from the front of the queue node = nodes.pop(0)
count=count+1 #display_board(node.state) # Append the move we made to
moves # if this node is the goal, return the moves it took to get here. if node.state
== goal: #display_board(node.state) moves = []
temp = node print cou.
"Subclassing and Composition – A Pythonic Tour of Trade-Offs", Hynek Schlawack
Ever seen a code base where understanding a simple method meant jumping through tangled class hierarchies? We all have! And while "Favor composition over inheritance!" is almost as old as object-oriented programming, strictly avoiding all types of subclassing leads to verbose, un-Pythonic code. So, what to do?
The discussion on composition vs. inheritance is so frustrating because far-reaching design decisions like this can only be made with the ecosystem in mind – and because there's more than one type of subclassing!
Let's take a dogma-free stroll through the types of subclassing through a Pythonic lens and untangle some patterns and trade-offs together. By the end, you'll be more confident in deciding when subclassing will make your code more Pythonic and when composition will improve its clarity.
A Taste of Python - Devdays Toronto 2009
Explores Peter Norvig's spell corrector written in Python as an example of the language's elegance and readability
Beyond Scala Lens
A Lens is a functional concept which solves a very common problem: how to update a complex immutable structure. This is probably the reason why Lenses are relatively well known in functional programming languages such as Haskell or Scala. However, there are far less resources available on the generalization of Lenses known as "optics".
In this slides, I would like to go through a few of these optics namely Iso, Prism and Optional, by showing how they relate to each other as well as how to use optics in a day to day programming job.
This assignment is about creating and using heaps. Implement a heap .docx
The document describes implementing a heap data structure using an array in Python. It provides the method signatures needed for a heap class, including init, str, makenull, insert, parent, left, right, swap, upheap, downheap, inorder, preorder, postorder, min, and deletemin methods. It then provides an implementation of the HeapImp class with these methods. Additional code is included to test the heap implementation and provide a command line interface for sorting and traversing the heap.
Python magicmethods
• http://docs.python.org/2/reference/datamodel.html
• A Guide to Python's Magic Methods - Rafe Kettler
http://www.rafekettler.com/magicmethods.html
• Pickle: An interesting stack language - Alexandre
http://peadrop.com/blog/2007/06/18/pickle-an-interesting-stack-language/
• Flask, Django, Tornado, sh, Pipe, Gunicorn, Sqlalchemy
Monadologie
This document discusses monads and continuations in functional programming. It provides examples of using monads like Option and List to handle failure in sequences of operations. It also discusses delimited continuations as a low-level control flow primitive that can implement exceptions, concurrency, and suspensions. The document proposes using monads to pass implicit state through programs by wrapping computations in a state transformer (ST) monad.
Implement the following sorting algorithms Bubble Sort Insertion S.pdf
Implement the following sorting algorithms: Bubble Sort Insertion Sort. Selection Sort.
Merge Sort. Heap Sort. Quick Sort. For each of the above algorithms, measure the execution
time based on input sizes n, n + 10(i), n + 20(i), n + 30(i), .. ., n + 100(i) for n = 50000 and i =
100. Let the array to be sorted be randomly initialized. Use the same machine to measure all the
algorithms. Plot a graph to compare the execution times you collected in part(2).
Solution
This code wil create a graph for each plots comparing time for different sorting methods and also
save those plots in the current directory.
from random import shuffle
from time import time
import numpy as np
import matplotlib.pyplot as plt
def bubblesort(arr):
for i in range(len(arr)):
for k in range(len(arr)-1, i, -1):
if (arr[k] < arr[k-1]):
tmp = arr[k]
arr[k] = arr[k-1]
arr[k-1] = tmp
return arr
def selectionsort(arr):
for fillslot in range(len(arr)-1,0,-1):
positionOfMax=0
for location in range(1,fillslot+1):
if arr[location]>arr[positionOfMax]:
positionOfMax = location
temp = arr[fillslot]
arr[fillslot] = arr[positionOfMax]
arr[positionOfMax] = temp
return arr
def insertionsort(arr):
for i in range( 1, len( arr ) ):
tmp = arr[i]
k = i
while k > 0 and tmp < arr[k - 1]:
arr[k] = arr[k-1]
k -= 1
arr[k] = tmp
return arr
# def mergesort(arr):
#
# if len(arr)>1:
# mid = len(arr)//2
# lefthalf = arr[:mid]
# righthalf = arr[mid:]
#
# mergesort(lefthalf)
# mergesort(righthalf)
#
# i=0
# j=0
# k=0
# while i < len(lefthalf) and j < len(righthalf):
# if lefthalf[i] < righthalf[j]:
# arr[k]=lefthalf[i]
# i=i+1
# else:
# arr[k]=righthalf[j]
# j=j+1
# k=k+1
#
# while i < len(lefthalf):
# arr[k]=lefthalf[i]
# i=i+1
# k=k+1
#
# while j < len(righthalf):
# arr[k]=righthalf[j]
# j=j+1
# k=k+1
#
# return arr
def mergesort(x):
result = []
if len(x) < 2:
return x
mid = int(len(x)/2)
y = mergesort(x[:mid])
z = mergesort(x[mid:])
i = 0
j = 0
while i < len(y) and j < len(z):
if y[i] > z[j]:
result.append(z[j])
j += 1
else:
result.append(y[i])
i += 1
result += y[i:]
result += z[j:]
return result
def quicksort(arr):
less = []
equal = []
greater = []
if len(arr) > 1:
pivot = arr[0]
for x in arr:
if x < pivot:
less.append(x)
if x == pivot:
equal.append(x)
if x > pivot:
greater.append(x)
return quicksort(less)+equal+quicksort(greater) # Just use the + operator to join lists
else:
return arr
#### Heap sort
def heapsort(arr): #convert arr to heap
length = len(arr) - 1
leastParent = length / 2
for i in range(leastParent, -1, -1):
moveDown(arr, i, length)
# flatten heap into sorted array
for i in range(length, 0, -1):
if arr[0] > arr[i]:
swap(arr, 0, i)
moveDown(arr, 0, i - 1)
def moveDown(arr, first, last):
largest = 2 * first + 1
while largest <= last: #right child exists and is larger than left child
if (largest < last) and(arr[largest] < arr[largest + 1]):
largest += 1
# right child is larger than parent
if arr[largest] > arr[first]:
swap(arr, largest, first)# move down to largest child
first = largest
lar.
Python programming : Inheritance and polymorphism
Inheritance and Polymorphism in Python. Inheritance is a mechanism which allows us to create a new class – known as child class – that is based upon an existing class – the parent class, by adding new attributes and methods on top of the existing class.
SDC - Einführung in Scala
The document introduces Scala and provides an overview of Scala basics including variables, functions, objects, classes, traits, pattern matching, for-comprehensions and more. It also discusses Scala's capabilities for generic programming, lazy evaluation, and integration with Java. Examples are provided throughout to demonstrate Scala concepts.
Testing My Patience
A survey of tools and techniques for automated testing of Python projects. Given at the Portland Python Users Group, 2009-08-11.
Unit test
This document contains code for unit testing in Python. It defines a TestFixture class that sets up test data, and includes TestCases that validate functions by asserting expected results. A TestSuite is built by adding TestCases, and a TestRunner executes the suite and outputs results.
python within 50 page .ppt
This document provides an overview of the Python programming language. It begins with an introduction to why Python is a good choice. It then outlines a tutorial on Python's basic types like numbers, strings, lists, dictionaries, variables, control structures, functions, classes, modules, exceptions, and files. It encourages downloading the latest Python version and using the interactive shell or IDLE to experiment. The bulk of the document then provides details on Python's core concepts like numbers, strings, lists, dictionaries, tuples, variables, control structures, functions, classes, modules, exceptions, and files. It concludes by discussing new features in Python 2.0 and 2.1.
Object Orientation vs Functional Programming in Python
This document compares and contrasts object-oriented programming and functional programming, and discusses how Python supports both paradigms. It provides examples of common patterns like inheritance, composition, decorators, and callbacks in both styles. The conclusion is that Python facilitates using either paradigm depending on needs, and the two approaches complement each other.
Py Die R E A D M E
pyDie is a library designed to simulate dice of various types and the random rolls of such. It has been designed to be reusable and with some intelligent decision making capabilities.
Python Unit Test
The document describes how to write unit tests in Python using the unittest module. It includes examples of setting up test fixtures, writing test cases that assert conditions, organizing test cases into test suites, and running the test suites with a test runner.
Critical Thinking 10-7 Dynamic Mobile AccessThere are so many o.pdf
Critical Thinking 10-7: Dynamic Mobile Access
There are so many opportunities now for people to allow constant and dynamic connection
between their mobile phone and an external (often unregulated) app. These range from scanning
QR codes to downloading an app at a national park or attraction that tracks where you are and
relays historical or additional information about the item at your location.
Use the Internet to research two incidents where users phones or information was affected by
using such a dynamic access point. Describe what happened. What was done about it? How can
such incursions be prevented.
Critical Thinking 10-7: Dynamic Mobile Access
There are so many opportunities now for people to allow constant and dynamic connection
between their mobile phone and an external (often unregulated) app. These range from scanning
QR codes to downloading an app at a national park or attraction that tracks where you are and
relays historical or additional information about the item at your location.
Use the Internet to research two incidents where users phones or information was affected by
using such a dynamic access point. Describe what happened. What was done about it? How can
such incursions be prevented..
Crisis Response Instructions In Module 4, you learned that e.pdf
Crisis Response
Instructions
In Module 4, you learned that every day, organizations are impacted by incidents and crises;
some even threaten the integrity and survivability of their brand. How they respond will
determine how consumers respond. Recent examples such as flight cancellations stranding
passengers over the holidays and celebrity spokespeople making inflammatory statements or
acting improperly come to mind. For this assignment, identify a real-world example of a public
relations crisis which required an organization to address and respond.
1. Briefly describe the situation. Include a link to the story (optional).
2. What issues specifically concern the organization, brand, product, or service?
3. What communication/marketing channels did the organization use to advise customers of the
situation?
4. How did the organization mitigate the problem and demonstrate customer care?
5. Do you believe they handled the situation effectively?
6. What would you have done differently?.
More Related Content
Similar to Fix this code so that it will run with proper answers, please dont u.pdf
Djangocon11: Monkeying around at New Relic
The document discusses various techniques for instrumenting Python code to trace function calls and collect performance metrics. It describes using context managers and decorators to time code blocks and functions. It also covers how to instrument WSGI applications and middleware using wrappers, monkey patching, and the New Relic agent API. The goal is to capture traces of functions, database calls, external requests and other events to provide visibility into application performance.
밑바닥부터 시작하는 의료 AI
발표자: 김준호(Lunit)
발표일: 2018.1.
의료 AI 관련 중, nodule detection 문제에 대해 다뤄보고자 합니다.
의료 AI에서는 어떠한 방식으로 classication을 하고, preprocessing은 어떤식으로 진행되는지 LUNA16이라는 의료 challenge에 이용되는 데이터를 가지고 발표를 진행해보고자 합니다.
이후, 이 데이터를 이용해서 최근 2017 MICCAI (의료 영상학회에서는 높은 수준의 학회)에서 발표된 "curriculum adaptive sampling for extreme data imbalance"를 실제 구현해서 적용해보고 이 때 발생할 수 있는 문제를 어떤식으로 해결할 수 있는지에 대한 tip도 제공할 예정입니다. (Python multi-processing data load, input-pipeline)
위 논문을 선정한 이유는, 단순한 classification이 아닌, nodule이 있는 위치도 정확하게 catch하는 논문 중, performance가 상당히 높기 때문입니다.
ScalaBlitz
Scala eXchange 2013 presentation of the ScalaBlitz - a highly optimized data-parallel collection framework for Scala.
Implemeting queue in python.pptx
This document provides code for implementing a queue data structure in Python. The code defines functions for enqueueing (adding) an item to the rear of the queue, dequeuing (removing) an item from the front of the queue, and getting the front and rear items. It also includes sample output showing items being added and removed from the queue and the front and rear items being retrieved.
goal_state = [1, 8, 7, 2, 0, 6, 3, 4, 5] #goal_state = [1, 0, 7, 2, .pdf
goal_state = [1, 8, 7, 2, 0, 6, 3, 4, 5] #goal_state = [1, 0, 7, 2, 8, 6, 3, 4, 5] import sys global
count def display_board( state ): #print \"-------------\" print \" %i %i %i \" %
(state[0], state[3], state[6]) #print \"-------------\" print \" %i %i %i \" % (state[1],
state[4], state[7]) #print \"-------------\" print \" %i %i %i \" % (state[2], state[5],
state[8]) #print \"-------------\" def move_up( state ): new_state = state[:] index =
new_state.index( 0 ) if index not in [0, 3, 6]: temp = new_state[index - 1]
new_state[index - 1] = new_state[index] new_state[index] = temp return
new_state else: return None def move_down( state ): new_state = state[:]
index = new_state.index( 0 ) if index not in [2, 5, 8]: temp = new_state[index + 1]
new_state[index + 1] = new_state[index] new_state[index] = temp
return new_state else: return None def move_left( state ): new_state = state[:]
index = new_state.index( 0 ) if index not in [0, 1, 2]: temp = new_state[index
- 3] new_state[index - 3] = new_state[index] new_state[index] = temp
return new_state else: return None def move_right( state ): new_state =
state[:] index = new_state.index( 0 ) if index not in [6, 7, 8]: temp =
new_state[index + 3] new_state[index + 3] = new_state[index]
new_state[index] = temp return new_state else: return None def
create_node( state, parent, operator, depth, cost ): return Node( state, parent, operator,
depth, cost ) def expand_node( node, nodes ): expanded_nodes = []
expanded_nodes.append( create_node( move_up( node.state ), node, \"u\", node.depth + 1, 0 ) )
expanded_nodes.append( create_node( move_down( node.state ), node, \"d\", node.depth + 1,
0 ) ) expanded_nodes.append( create_node( move_left( node.state ), node, \"l\", node.depth
+ 1, 0 ) ) expanded_nodes.append( create_node( move_right( node.state), node, \"r\",
node.depth + 1, 0 ) ) # Filter the list and remove the nodes that are impossible (move
function returned None) expanded_nodes = [node for node in expanded_nodes if node.state
!= None] #list comprehension! expanded_nodes = [node for node in expanded_nodes if
node not in nodes] #list comprehension! #expanded_nodes = [node for node in
expanded_nodes if node.state!= ((node.parent).parent).state] #list comprehension!
expanded_nodes1 = [] for node in expanded_nodes: temp=node
temp=temp.parent temp=temp.parent if temp==None:
expanded_nodes1.extend(expanded_nodes) break if node.state
!=temp.state: expanded_nodes1.append(node) return
expanded_nodes1 def bfs( start, goal ): nodes = [] count=0 # Create the queue
with the root node in it. nodes.append( create_node( start, None, None, 0, 0 ) ) while
True: # We\'ve run out of states, no solution. if len( nodes ) == 0:
return None # take the node from the front of the queue node = nodes.pop(0)
count=count+1 #display_board(node.state) # Append the move we made to
moves # if this node is the goal, return the moves it took to get here. if node.state
== goal: #display_board(node.state) moves = []
temp = node print cou.
"Subclassing and Composition – A Pythonic Tour of Trade-Offs", Hynek Schlawack
Ever seen a code base where understanding a simple method meant jumping through tangled class hierarchies? We all have! And while "Favor composition over inheritance!" is almost as old as object-oriented programming, strictly avoiding all types of subclassing leads to verbose, un-Pythonic code. So, what to do?
The discussion on composition vs. inheritance is so frustrating because far-reaching design decisions like this can only be made with the ecosystem in mind – and because there's more than one type of subclassing!
Let's take a dogma-free stroll through the types of subclassing through a Pythonic lens and untangle some patterns and trade-offs together. By the end, you'll be more confident in deciding when subclassing will make your code more Pythonic and when composition will improve its clarity.
A Taste of Python - Devdays Toronto 2009
Explores Peter Norvig's spell corrector written in Python as an example of the language's elegance and readability
Beyond Scala Lens
A Lens is a functional concept which solves a very common problem: how to update a complex immutable structure. This is probably the reason why Lenses are relatively well known in functional programming languages such as Haskell or Scala. However, there are far less resources available on the generalization of Lenses known as "optics".
In this slides, I would like to go through a few of these optics namely Iso, Prism and Optional, by showing how they relate to each other as well as how to use optics in a day to day programming job.
This assignment is about creating and using heaps. Implement a heap .docx
The document describes implementing a heap data structure using an array in Python. It provides the method signatures needed for a heap class, including init, str, makenull, insert, parent, left, right, swap, upheap, downheap, inorder, preorder, postorder, min, and deletemin methods. It then provides an implementation of the HeapImp class with these methods. Additional code is included to test the heap implementation and provide a command line interface for sorting and traversing the heap.
Python magicmethods
• http://docs.python.org/2/reference/datamodel.html
• A Guide to Python's Magic Methods - Rafe Kettler
http://www.rafekettler.com/magicmethods.html
• Pickle: An interesting stack language - Alexandre
http://peadrop.com/blog/2007/06/18/pickle-an-interesting-stack-language/
• Flask, Django, Tornado, sh, Pipe, Gunicorn, Sqlalchemy
Monadologie
This document discusses monads and continuations in functional programming. It provides examples of using monads like Option and List to handle failure in sequences of operations. It also discusses delimited continuations as a low-level control flow primitive that can implement exceptions, concurrency, and suspensions. The document proposes using monads to pass implicit state through programs by wrapping computations in a state transformer (ST) monad.
Implement the following sorting algorithms Bubble Sort Insertion S.pdf
Implement the following sorting algorithms: Bubble Sort Insertion Sort. Selection Sort.
Merge Sort. Heap Sort. Quick Sort. For each of the above algorithms, measure the execution
time based on input sizes n, n + 10(i), n + 20(i), n + 30(i), .. ., n + 100(i) for n = 50000 and i =
100. Let the array to be sorted be randomly initialized. Use the same machine to measure all the
algorithms. Plot a graph to compare the execution times you collected in part(2).
Solution
This code wil create a graph for each plots comparing time for different sorting methods and also
save those plots in the current directory.
from random import shuffle
from time import time
import numpy as np
import matplotlib.pyplot as plt
def bubblesort(arr):
for i in range(len(arr)):
for k in range(len(arr)-1, i, -1):
if (arr[k] < arr[k-1]):
tmp = arr[k]
arr[k] = arr[k-1]
arr[k-1] = tmp
return arr
def selectionsort(arr):
for fillslot in range(len(arr)-1,0,-1):
positionOfMax=0
for location in range(1,fillslot+1):
if arr[location]>arr[positionOfMax]:
positionOfMax = location
temp = arr[fillslot]
arr[fillslot] = arr[positionOfMax]
arr[positionOfMax] = temp
return arr
def insertionsort(arr):
for i in range( 1, len( arr ) ):
tmp = arr[i]
k = i
while k > 0 and tmp < arr[k - 1]:
arr[k] = arr[k-1]
k -= 1
arr[k] = tmp
return arr
# def mergesort(arr):
#
# if len(arr)>1:
# mid = len(arr)//2
# lefthalf = arr[:mid]
# righthalf = arr[mid:]
#
# mergesort(lefthalf)
# mergesort(righthalf)
#
# i=0
# j=0
# k=0
# while i < len(lefthalf) and j < len(righthalf):
# if lefthalf[i] < righthalf[j]:
# arr[k]=lefthalf[i]
# i=i+1
# else:
# arr[k]=righthalf[j]
# j=j+1
# k=k+1
#
# while i < len(lefthalf):
# arr[k]=lefthalf[i]
# i=i+1
# k=k+1
#
# while j < len(righthalf):
# arr[k]=righthalf[j]
# j=j+1
# k=k+1
#
# return arr
def mergesort(x):
result = []
if len(x) < 2:
return x
mid = int(len(x)/2)
y = mergesort(x[:mid])
z = mergesort(x[mid:])
i = 0
j = 0
while i < len(y) and j < len(z):
if y[i] > z[j]:
result.append(z[j])
j += 1
else:
result.append(y[i])
i += 1
result += y[i:]
result += z[j:]
return result
def quicksort(arr):
less = []
equal = []
greater = []
if len(arr) > 1:
pivot = arr[0]
for x in arr:
if x < pivot:
less.append(x)
if x == pivot:
equal.append(x)
if x > pivot:
greater.append(x)
return quicksort(less)+equal+quicksort(greater) # Just use the + operator to join lists
else:
return arr
#### Heap sort
def heapsort(arr): #convert arr to heap
length = len(arr) - 1
leastParent = length / 2
for i in range(leastParent, -1, -1):
moveDown(arr, i, length)
# flatten heap into sorted array
for i in range(length, 0, -1):
if arr[0] > arr[i]:
swap(arr, 0, i)
moveDown(arr, 0, i - 1)
def moveDown(arr, first, last):
largest = 2 * first + 1
while largest <= last: #right child exists and is larger than left child
if (largest < last) and(arr[largest] < arr[largest + 1]):
largest += 1
# right child is larger than parent
if arr[largest] > arr[first]:
swap(arr, largest, first)# move down to largest child
first = largest
lar.
Python programming : Inheritance and polymorphism
Inheritance and Polymorphism in Python. Inheritance is a mechanism which allows us to create a new class – known as child class – that is based upon an existing class – the parent class, by adding new attributes and methods on top of the existing class.
SDC - Einführung in Scala
The document introduces Scala and provides an overview of Scala basics including variables, functions, objects, classes, traits, pattern matching, for-comprehensions and more. It also discusses Scala's capabilities for generic programming, lazy evaluation, and integration with Java. Examples are provided throughout to demonstrate Scala concepts.
Testing My Patience
A survey of tools and techniques for automated testing of Python projects. Given at the Portland Python Users Group, 2009-08-11.
Unit test
This document contains code for unit testing in Python. It defines a TestFixture class that sets up test data, and includes TestCases that validate functions by asserting expected results. A TestSuite is built by adding TestCases, and a TestRunner executes the suite and outputs results.
python within 50 page .ppt
This document provides an overview of the Python programming language. It begins with an introduction to why Python is a good choice. It then outlines a tutorial on Python's basic types like numbers, strings, lists, dictionaries, variables, control structures, functions, classes, modules, exceptions, and files. It encourages downloading the latest Python version and using the interactive shell or IDLE to experiment. The bulk of the document then provides details on Python's core concepts like numbers, strings, lists, dictionaries, tuples, variables, control structures, functions, classes, modules, exceptions, and files. It concludes by discussing new features in Python 2.0 and 2.1.
Object Orientation vs Functional Programming in Python
This document compares and contrasts object-oriented programming and functional programming, and discusses how Python supports both paradigms. It provides examples of common patterns like inheritance, composition, decorators, and callbacks in both styles. The conclusion is that Python facilitates using either paradigm depending on needs, and the two approaches complement each other.
Py Die R E A D M E
pyDie is a library designed to simulate dice of various types and the random rolls of such. It has been designed to be reusable and with some intelligent decision making capabilities.
Python Unit Test
The document describes how to write unit tests in Python using the unittest module. It includes examples of setting up test fixtures, writing test cases that assert conditions, organizing test cases into test suites, and running the test suites with a test runner.
Similar to Fix this code so that it will run with proper answers, please dont u.pdf (20)
goal_state = [1, 8, 7, 2, 0, 6, 3, 4, 5] #goal_state = [1, 0, 7, 2, .pdf
goal_state = [1, 8, 7, 2, 0, 6, 3, 4, 5] #goal_state = [1, 0, 7, 2, .pdf
"Subclassing and Composition – A Pythonic Tour of Trade-Offs", Hynek Schlawack
"Subclassing and Composition – A Pythonic Tour of Trade-Offs", Hynek Schlawack
This assignment is about creating and using heaps. Implement a heap .docx
This assignment is about creating and using heaps. Implement a heap .docx
Implement the following sorting algorithms Bubble Sort Insertion S.pdf
Implement the following sorting algorithms Bubble Sort Insertion S.pdf
Object Orientation vs Functional Programming in Python
Object Orientation vs Functional Programming in Python
More from txkev
Critical Thinking 10-7 Dynamic Mobile AccessThere are so many o.pdf
Critical Thinking 10-7: Dynamic Mobile Access
There are so many opportunities now for people to allow constant and dynamic connection
between their mobile phone and an external (often unregulated) app. These range from scanning
QR codes to downloading an app at a national park or attraction that tracks where you are and
relays historical or additional information about the item at your location.
Use the Internet to research two incidents where users phones or information was affected by
using such a dynamic access point. Describe what happened. What was done about it? How can
such incursions be prevented.
Critical Thinking 10-7: Dynamic Mobile Access
There are so many opportunities now for people to allow constant and dynamic connection
between their mobile phone and an external (often unregulated) app. These range from scanning
QR codes to downloading an app at a national park or attraction that tracks where you are and
relays historical or additional information about the item at your location.
Use the Internet to research two incidents where users phones or information was affected by
using such a dynamic access point. Describe what happened. What was done about it? How can
such incursions be prevented..
Crisis Response Instructions In Module 4, you learned that e.pdf
Crisis Response
Instructions
In Module 4, you learned that every day, organizations are impacted by incidents and crises;
some even threaten the integrity and survivability of their brand. How they respond will
determine how consumers respond. Recent examples such as flight cancellations stranding
passengers over the holidays and celebrity spokespeople making inflammatory statements or
acting improperly come to mind. For this assignment, identify a real-world example of a public
relations crisis which required an organization to address and respond.
1. Briefly describe the situation. Include a link to the story (optional).
2. What issues specifically concern the organization, brand, product, or service?
3. What communication/marketing channels did the organization use to advise customers of the
situation?
4. How did the organization mitigate the problem and demonstrate customer care?
5. Do you believe they handled the situation effectively?
6. What would you have done differently?.
Create a Schedule D and schedule 1 for this information, and the cor.pdf
Create a Schedule D and schedule 1 for this information, and the corresponding line 7 value on
the 1040 form.
Assuming, Rhonda is filing head of household with an AGI of 72,000 before the capital gain/loss
information.
3. Rhonda received $250 in interest from Tulsa City bonds, $120 interest from IBM bonds,
and $15 from her savings account at UCU Credit Union. She also received a $460
dividend from Huggies Company and $500 from Bicker Corporation. Both dividends are
qualified dividends.
4. Rhonda sold 200 shares of DM stock for $18 a share on June 15, 2023. She purchased the
stock on December 12, 2014, for $10 a share. She also sold 50 shares of RSA stock for
$15 a share on October 2, 2023. She purchased the stock for $65 a share on February 2,
2023. Stock basis amounts and proceeds have been reported to the IRS with no
adjustments required.
Five areas that financial ratios concentrate on area) liquidity.pdf
Five areas that financial ratios concentrate on are:
a) liquidity, profitability, debt, efficiency, market related;
b) profitability, strategy, liquidity, auditing, share prices;
c) liquidity, current ratio, quick ratio, interest cover, dividend cover;
d) market related, share prices, dividend policy, debt policy, strategy;
e) none of the above.
Question 2:
Ratios that measure the ability of the company to pay its short-term debts are called:
a) debt ratios;
b) cover ratios;
c) liquidity ratios;
d) profitability ratios;
e) none of the above.
Question 3:
Current assets divided by current liabilities is the definition of the:
a) interest cover ratio;
b) dividend cover ratio;
c) quick ratio;
d) current ratio;
e) none of the above.
Question 4:
The quick ratio is defined as:
a) current assets divided by current liabilities;
b) current assets divided by total debt;
c) current assets less inventory, divided by total liabilities;
d) current assets less inventory, divided by current liabilities;
e) none of the above.
Question 5:
Return on sales, return on assets and return on equity are examples of:
a) liquidity ratios;
b) profitability ratios;
c) debt ratios;
d) efficiency ratios;
e) market-related ratios.
Question 6:
Return on assets is defined as:
a)operating income divided by owners equity;
b) operating income divided by sales;
c) operating income divided by total assets;
d) operating income divided by long-term assets plus debt;
e) none of the above.
Question 7:
Net income divided by shareholders equity is the definition of:
a) return on sales;
b) return on assets;
c) return on equity;
d) asset turnover;
e) none of the above.
Question 8:
The debt to equity ratio measures;
a) the likelihood of the company going bankrupt in the short term;
b) the efficiency of the company;
c) the relative proportions of debt and equity in the capital structure;
d) liquidity;
e) none of the above.
Question 9:
The interest cover ratio measures:
a) the leverage of the company;
b) the efficiency of debt;
c) the weighted average cost of capital;
d) the relationship between interest and profit;
e) none of the above.
Question 10:
Total asset turnover, receivables turnover and inventory turnover ratios measure:
a) liquidity;
b) profitability;
c) efficiency;
d) debt;
e) market related factors.
Question 11:
The receivables turnover ratio is defined as:
a) sales divided by receivables;
b) receivables divided by sales;
c) receivables divided by one days sales;
d) receivables plus bad debt allowances.
e) none of the above.
Question 12:
To measure the efficiency with which inventory is used the following ratio should be used:
a) inventory turnover ratio;
b) inventory holding period;
c) lower of cost or market valuation of inventory;
d) a or b, but not c;
e) a, b or c.
Question 13:
Earnings per share is affected by:
a) net income;
b) number of shares;
c) dividends;
d) a & b, but not c;
e) a, b & c.
Question 14:
The price to earnings ratio measures:
a) the rationality of the stock.
double Skiplist code below#include iostream#include vector.pdf
double Skiplist code below
#include
#include
#include
#include
#include
#include
#include "Node.h"
#ifndef SKIPLIST_H
#define SKIPLIST_H
using namespace std;
class SkipList{
public:
// Maximum number of levels allowed for this skip list
int MAXIMUM_ALLOWED_LEVELS;
// current maximum level amongst the inserted nodes
int level;
// the head node's next links are connected to the first node at every level
Node *head;
SkipList(int maxLevels){
MAXIMUM_ALLOWED_LEVELS = maxLevels;
// initially we have the bottom-most level only
level = 0;
// create the header node, value is irrelevant (as long as it doesn't match an inserted value -
NO REPEATS), number of next links is important (this node is connected to the first node at
every level)
head = new Node(INT_MIN, MAXIMUM_ALLOWED_LEVELS);
}
int RandomLevel(){
float probablity = (float)rand()/RAND_MAX; // flip a coin
int lvl = 0;
/*Olog(n) */while (probablity < 0.5 && lvl < MAXIMUM_ALLOWED_LEVELS){
lvl++; // landed heads so increase level by 1
probablity = (float)rand()/RAND_MAX; // flip a coin again
}
return lvl;
}
Node* CreateNode(int value, int level){
// create a new node with next links for every level that this node will be part of
// it will use these links to connect to the next node at each level
return new Node(value, level);
}
void InsertElement(int value)/*Olog(n) becuase all the functions in it are Olog(n) */{
/**
* THIS CODE HAS A BUG,
*
* ***********FIND THE BUG,
* *************EXPLAIN THE WHY THE BUG EXIST
* AND
* **********************SUGGEST A FIX *
*
*/
//w
Node *current = head; // start at head node at the toppest level
/*Olog(n)*/vector update(MAXIMUM_ALLOWED_LEVELS+1, nullptr); // this will hold
the nodes that need updating at every level after the insert takes place
/*BIG Olog(n)*/for (int i = level; i >= 0; i--){ //level is the current maximum level
// for level i, if value is to be inserted here then find out where (i.e. after which node)
/*O(1) constant */ while (current->next[i] != nullptr && current->next[i]->value <
value){ //the while loop is saying keep moving right until null or the current.value > value
current = current->next[i];
}
// found the node after which the value is to be placed at level i
update[i] = current;
}
//if
current = current->next[0]; // current moves bcoz we need to check if the value exists
if (current == nullptr || current->value != value){
/*Olog(n) */int ranLevel = RandomLevel(); // choose a random level upto where the new
node will be placed
if (ranLevel > level){
// if random level for current node is higher than the current maximum level for the
existing nodes then set updates for each level over current maximum to head (since there are no
nodes at these levels yet).
/*Olog(n)*/for (int i=level+1;i<=ranLevel;i++){
update[i] = head;
}
// also change the current maximum level for the existing nodes
level = ranLevel;
}
// create new node with next links for every level from ranLevel to zero
/*Olog(n) */Node* n = CreateNode(value, ranLevel);
// placi.
Draw a class diagram for the following scenario The following are t.pdf
Draw a class diagram for the following scenario: The following are the requirements for a
Society Membership System: The society has 10,000 members. For purposes of identification,
each member has a unique membership number. It is important to know the following about each
member : his/her Title, Name, Surname, Gender, Age. Each member of the society may or may
not be related to other members, e.g, a Brother, or a sister. It is important to know who is related
to whom and the nature of the relationship. The society consists of a number of chapters (each
with a chapter number). Each member belongs to only one chapter at a time. The society has
several special interest groups (SIGs) which are identified by a group number and have a
description. The same group could exist in more than one chapter and a chapter could have many
groups in it..
Discuss the structure of intelligent agents in artificial intelligen.pdf
Discuss the structure of intelligent agents in artificial intelligence systems. Explain the key
components and their roles in designing an agent-based system. Consider the following
components: perception, knowledge representation, decision-making, and action. Provide a
detailed explanation of each component, including how they interact and contribute to the overall
functioning of an intelligent agent. Additionally, describe different types of agent architectures,
such as simple reflex agents, model- based agents, goal-based agents, and utility-based agents.
Compare and contrast these architectures in terms of their strengths, weaknesses, and suitability
for different problem domains. Finally, discuss the challenges associated with designing and
implementing intelligent agent systems and propose potential solutions or strategies to address
these challenges effectively..
Consider the following game in which Sally can play T or B and John .pdf
Consider the following game in which Sally can play T or B and John chooses between L or R.
Each player makes their choice simultaneously. If Sally chooses T and John chooses L, Sally
gets a payoff of 5 and John has a payoff of 4. If Sally plays T and John R, Sallys payoff is 8 and
John gets 3. If Sally Chooses B and John L, the payoffs are 3 to Sally and 2 to John. Finally, if
Sally chooses B and John R, the payoffs are 7 to Sally and 0 to John. Which statement is true?
Group of answer choices
a) The Nash equilibrium is (B,R); this is a prisoners dilemma
b) The Nash equilibrium is (T,R); this is a prisoners dilemma
c) The Nash equilibrium is (T,R); this is not dominant strategy equilibrium
d) The Nash equilibrium is (T,L); this is a dominant strategy equilibrium
e) None of the above.
Computer NetworksConsider the following scenario involving a.pdf
***Computer Networks***
Consider the following scenario involving a TCP connection with Host A and Host B.
Manu wants to visualize the interactions involved when Host A sends four consecutive TCP
packets containing 50 bytes each to Host B. He knows that due to network delays, Host A will
finish sending these small packets before any reply can be received from Host B. Complete the
diagram below (except on your own paper, of course), showing Manu all of the relevant data for
the four packets sent and any relevant replies sent by Host B. Assume no packets are lost, and a
reply is sent as soon as a packet is received.
Please answer with a diagram with arrows between host A and host B with the SEQ, ACK, and
LENS label on each one. Thank you!!.
Character.cpphpp givenCharacter.cpp#include Character.hp.pdf
The Character.cpp and Character.hpp files define a Character class with default and parameterized constructors. The default constructor initializes all member variables to default values, while the parameterized constructor allows setting the name, race, vitality, armor, level, and enemy status. Getter and setter methods are provided to access and modify the private member variables.
The ArrayBag.cpp and ArrayBag.hpp files define a generic ArrayBag class that implements a bag data structure using an array. Methods are provided to add, remove, and retrieve items from the bag. The class is modified to add operator overloading for the += and /= operators to combine the contents of two bags.
The Tavern.cpp and Tavern
CNA STB 14 July 2022, STB said � visitor arrival to Singapore are ex.pdf
CNA STB 14 July 2022, STB said visitor arrival to Singapore are expected to increase to
between 4 milion and 6 milion this year as global travel pick up pace the projection comes amid
the easing of COVID 19 related border restriction globally, and pent up demand for travel." The
following show various drawing of Singapore traval Cruise Terminal at Marina Bay South. The
inisitutional property has 5 zone which are zone 1: roads leading into external driveway, drop off
points, ingress, egress. Zone 2: Terminal buildings; zone 3- Carpark and coach for both 1st and
2nd floor, zone 4 - arrival and departure processing and zone 5: terminal buildings. You are
require to do a goal setting and analysis can contribute to strategizing the increase in visitors at
the Terminal which include, goals, anaylze current situation's, SWOT anaysis, Sky Key
performance Indicator, Segment your audience and develop Strategies..
Directions# Caesar Cipher ImplementationYour task in this homew.pdf
The document provides instructions for implementing a Caesar cipher class in Python. It describes initializing the class with a key, and implementing encrypt, decrypt, encrypt_file, and decrypt_file methods. The encrypt and decrypt methods encrypt and decrypt a plaintext/ciphertext string. The encrypt_file and decrypt_file methods take a file, encrypt/decrypt its contents using the cipher, and write it to a new file. Sample code is given to test the class.
Describe the leadership of Captain Michael Davidson and second mate .pdf
Describe the leadership of Captain Michael Davidson and second mate Danielle Randolph in
light of theory. Consider the following questions in your description: Why did the captain ignore
warnings about the threat that the hurricane posed to the ship? Identify quotes from the
transcripts that reinforce your answers Why did the second mate not speak up more forcefully?
Could she have changed the outcomes? What aspects of her past experience prevented her from
asserting herself? Why didn't the crew challenge the commanding officer's decisions in spite of
their concerns and level of expertise in the matter? What was the impact of the company's
policies on the decision-making process? What other factors contributed to the failure of the
captain and his subordinates to use their collective expertise to prevent disaster? Have you ever
had a work experience where you can identify organizational cultural issues that create
conditions and dynamics similar to El Faro's? If so, describe. In conclusion, what can we learn
about this case that will make us better organizational managers and leaders?.
More from txkev (13)
Critical Thinking 10-7 Dynamic Mobile AccessThere are so many o.pdf
Critical Thinking 10-7 Dynamic Mobile AccessThere are so many o.pdf
Crisis Response Instructions In Module 4, you learned that e.pdf
Crisis Response Instructions In Module 4, you learned that e.pdf
Create a Schedule D and schedule 1 for this information, and the cor.pdf
Create a Schedule D and schedule 1 for this information, and the cor.pdf
Five areas that financial ratios concentrate on area) liquidity.pdf
Five areas that financial ratios concentrate on area) liquidity.pdf
double Skiplist code below#include iostream#include vector.pdf
double Skiplist code below#include iostream#include vector.pdf
Draw a class diagram for the following scenario The following are t.pdf
Draw a class diagram for the following scenario The following are t.pdf
Discuss the structure of intelligent agents in artificial intelligen.pdf
Discuss the structure of intelligent agents in artificial intelligen.pdf
Consider the following game in which Sally can play T or B and John .pdf
Consider the following game in which Sally can play T or B and John .pdf
Computer NetworksConsider the following scenario involving a.pdf
Computer NetworksConsider the following scenario involving a.pdf
Character.cpphpp givenCharacter.cpp#include Character.hp.pdf
Character.cpphpp givenCharacter.cpp#include Character.hp.pdf
CNA STB 14 July 2022, STB said � visitor arrival to Singapore are ex.pdf
CNA STB 14 July 2022, STB said � visitor arrival to Singapore are ex.pdf
Directions# Caesar Cipher ImplementationYour task in this homew.pdf
Directions# Caesar Cipher ImplementationYour task in this homew.pdf
Describe the leadership of Captain Michael Davidson and second mate .pdf
Describe the leadership of Captain Michael Davidson and second mate .pdf
Recently uploaded
Leveraging Generative AI to Drive Nonprofit Innovation
In this webinar, participants learned how to utilize Generative AI to streamline operations and elevate member engagement. Amazon Web Service experts provided a customer specific use cases and dived into low/no-code tools that are quick and easy to deploy through Amazon Web Service (AWS.)
Gender and Mental Health - Counselling and Family Therapy Applications and In...
A proprietary approach developed by bringing together the best of learning theories from Psychology, design principles from the world of visualization, and pedagogical methods from over a decade of training experience, that enables you to: Learn better, faster!
RHEOLOGY Physical pharmaceutics-II notes for B.pharm 4th sem students
Physical pharmaceutics notes for B.pharm students
ANATOMY AND BIOMECHANICS OF HIP JOINT.pdf
it describes the bony anatomy including the femoral head , acetabulum, labrum . also discusses the capsule , ligaments . muscle that act on the hip joint and the range of motion are outlined. factors affecting hip joint stability and weight transmission through the joint are summarized.
How to deliver Powerpoint Presentations.pptx
"How to make and deliver dynamic presentations by making it more interactive to captivate your audience attention"
Advanced Java[Extra Concepts, Not Difficult].docx
This is part 2 of my Java Learning Journey. This contains Hashing, ArrayList, LinkedList, Date and Time Classes, Calendar Class and more.
Walmart Business+ and Spark Good for Nonprofits.pdf
"Learn about all the ways Walmart supports nonprofit organizations.
You will hear from Liz Willett, the Head of Nonprofits, and hear about what Walmart is doing to help nonprofits, including Walmart Business and Spark Good. Walmart Business+ is a new offer for nonprofits that offers discounts and also streamlines nonprofits order and expense tracking, saving time and money.
The webinar may also give some examples on how nonprofits can best leverage Walmart Business+.
The event will cover the following::
Walmart Business + (https://business.walmart.com/plus) is a new shopping experience for nonprofits, schools, and local business customers that connects an exclusive online shopping experience to stores. Benefits include free delivery and shipping, a 'Spend Analytics” feature, special discounts, deals and tax-exempt shopping.
Special TechSoup offer for a free 180 days membership, and up to $150 in discounts on eligible orders.
Spark Good (walmart.com/sparkgood) is a charitable platform that enables nonprofits to receive donations directly from customers and associates.
Answers about how you can do more with Walmart!"
Solutons Maths Escape Room Spatial .pptx
Solutions of Puzzles of Mathematics Escape Room Game in Spatial.io
Philippine Edukasyong Pantahanan at Pangkabuhayan (EPP) Curriculum
(𝐓𝐋𝐄 𝟏𝟎𝟎) (𝐋𝐞𝐬𝐬𝐨𝐧 𝟏)-𝐏𝐫𝐞𝐥𝐢𝐦𝐬
𝐃𝐢𝐬𝐜𝐮𝐬𝐬 𝐭𝐡𝐞 𝐄𝐏𝐏 𝐂𝐮𝐫𝐫𝐢𝐜𝐮𝐥𝐮𝐦 𝐢𝐧 𝐭𝐡𝐞 𝐏𝐡𝐢𝐥𝐢𝐩𝐩𝐢𝐧𝐞𝐬:
- Understand the goals and objectives of the Edukasyong Pantahanan at Pangkabuhayan (EPP) curriculum, recognizing its importance in fostering practical life skills and values among students. Students will also be able to identify the key components and subjects covered, such as agriculture, home economics, industrial arts, and information and communication technology.
𝐄𝐱𝐩𝐥𝐚𝐢𝐧 𝐭𝐡𝐞 𝐍𝐚𝐭𝐮𝐫𝐞 𝐚𝐧𝐝 𝐒𝐜𝐨𝐩𝐞 𝐨𝐟 𝐚𝐧 𝐄𝐧𝐭𝐫𝐞𝐩𝐫𝐞𝐧𝐞𝐮𝐫:
-Define entrepreneurship, distinguishing it from general business activities by emphasizing its focus on innovation, risk-taking, and value creation. Students will describe the characteristics and traits of successful entrepreneurs, including their roles and responsibilities, and discuss the broader economic and social impacts of entrepreneurial activities on both local and global scales.
Recently uploaded (20)
Leveraging Generative AI to Drive Nonprofit Innovation
Leveraging Generative AI to Drive Nonprofit Innovation
Gender and Mental Health - Counselling and Family Therapy Applications and In...
Gender and Mental Health - Counselling and Family Therapy Applications and In...
B. Ed Syllabus for babasaheb ambedkar education university.pdf
B. Ed Syllabus for babasaheb ambedkar education university.pdf
RHEOLOGY Physical pharmaceutics-II notes for B.pharm 4th sem students
RHEOLOGY Physical pharmaceutics-II notes for B.pharm 4th sem students
NEWSPAPERS - QUESTION 1 - REVISION POWERPOINT.pptx
NEWSPAPERS - QUESTION 1 - REVISION POWERPOINT.pptx
Liberal Approach to the Study of Indian Politics.pdf
Liberal Approach to the Study of Indian Politics.pdf
Walmart Business+ and Spark Good for Nonprofits.pdf
Walmart Business+ and Spark Good for Nonprofits.pdf
Philippine Edukasyong Pantahanan at Pangkabuhayan (EPP) Curriculum
Philippine Edukasyong Pantahanan at Pangkabuhayan (EPP) Curriculum
Film vocab for eal 3 students: Australia the movie
Film vocab for eal 3 students: Australia the movie
Fix this code so that it will run with proper answers, please dont u.pdf
- 1. Fix this code so that it will run with proper answers, please dont use chatgpt and please test your code before submitting: import sys import heapq import copy class PriorityQueue(): def __init__(self): self.thisQueue = [] def push(self, thisNode): heapq.heappush(self.thisQueue, (thisNode.val, -thisNode.id, thisNode)) def pop(self): return heapq.heappop(self.thisQueue)[2] def isEmpty(self): return len(self.thisQueue) == 0 def length(self): return len(self.thisQueue) class Set(): def __init__(self): self.thisSet = set() def add(self, entry): if entry is not None: self.thisSet.add(entry.__hash__()) def length(self): return len(self.thisSet) def isMember(self, query): return query.__hash__() in self.thisSet class Node(): def __init__(self, val, startstate, endstate, depth): global nodeid self.id = nodeid nodeid += 1 self.val = val self.state = startstate self.endstate = endstate self.depth = depth
- 2. def __str__(self): return 'Node: id=%d val=%d' % (self.id, self.val) def expand(current_node, closedlist, goal_state): closedlist.add(current_node.state) successors = [] up_child = current_node.state.up() down_child = current_node.state.down() right_child = current_node.state.right() left_child = current_node.state.left() children = [left_child, right_child, up_child, down_child] for child in children: if child is not None and not closedlist.isMember(child): s = Node(0, child, None, current_node.depth + 1) s.parent_node = current_node if child == left_child: s.action = "left" elif child == right_child: s.action = "right" elif child == up_child: s.action = "up" elif child == down_child: s.action = "down" successors.append(s) return successors def h0(currenttiles, stiles): misplaced = 0 for i in range(len(stiles)): for j in range(len(currenttiles)): if stiles[i][j] != currenttiles[i][j]: misplaced += 1 return misplaced def manhattan(currenttiles, stiles): total = 0 for i in range(len(stiles)): for j in range(len(currenttiles)): if stiles[i][j] != currenttiles[i][j]:
- 3. y = stiles[i][j] a = i b = j for k in range(len(stiles)): for l in range(len(stiles)): if currenttiles[k][l] == y: d = k e = l count = (abs(d - a) + abs(e - b)) total += count return total class State(): def __init__(self): self.xpos = 0 self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] def left(self): if self.ypos == 0: return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def right(self): if self.ypos == 2: return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1 s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0: return None s = self.copy()
- 4. s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos] s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if self.xpos == 2: return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos + 1][s.ypos] s.xpos += 1 s.tiles[s.xpos][s.ypos] = 0 return s def __hash__(self): return (tuple(self.tiles[0]), tuple(self.tiles[1]), tuple(self.tiles[2])) def __str__(self): return '%d %d %dn%d %d %dn%d %d %dn' % ( self.tiles[0][0], self.tiles[0][1], self.tiles[0][2], self.tiles[1][0], self.tiles[1][1], self.tiles[1][2], self.tiles[2][0], self.tiles[2][1], self.tiles[2][2]) def copy(self): s = State() s.xpos = self.xpos s.ypos = self.ypos s.tiles = [row[:] for row in self.tiles] return s def astar(initial_state, goal_state, closedlist, heuristic_type): initial_node = Node(0, initial_state, goal_state, 0) print(initial_node.val) frontier = PriorityQueue() frontier.push(initial_node) V = 0 N = 0 d = 0 while not frontier.isEmpty(): if frontier.length() > N: N = frontier.length()
- 5. current_node = frontier.pop() V += 1 if current_node.state == goal_state: d = current_node.depth # Found the solution return current_node, V, N, d expanded = expand(current_node, closedlist, goal_state) for node in expanded: if heuristic_type == 0: f_val = h0(node.state.tiles, goal_state.tiles) + node.depth elif heuristic_type == 1: f_val = manhattan(node.state.tiles, goal_state.tiles) + node.depth node.val=f_val frontier.push(node) return None, V, N, d def main(): global nodeid nodeid = 0 inputs = [] for line in sys.stdin: inputs += line.split() array = [ [int(inputs[0]), int(inputs[1]), int(inputs[2])], [int(inputs[3]), int(inputs[4]), int(inputs[5])], [int(inputs[6]), int(inputs[7]), int(inputs[8])] ] goal_state = State() goal_state.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] s = State() current = State() current.tiles = array s.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] print(array) printMan = manhattan(array, goal_state.tiles) print("Initial State:")
- 6. print(s) print("Goal State:") print(goal_state) print("Manhattan Distance:", printMan) for heuristic_type in range(2): closedlist = Set() nodeid = 0 d, N, V,_ = astar(current, goal_state, closedlist, heuristic_type) print("nHeuristic", heuristic_type) print("Nodes Visited/Expanded (V):", V) print("Maximum Nodes Stored in Memory (N):", N) print("Depth of Optimal Solution (d):", d) if __name__ == "__main__": main() Current output results in a ton of unprecedented values for V, d, and N like 39,423