code-->
class Solution:
def isAnagram(self, s1: str,t1: str) -> bool:
flag=1
s = list(s1)
t = list(t1)
for i in range(len(s)):
for j in range(len(s)):
if s[i]==t[j]:
s[i]=t[j]='0'
break
for i in range(len(s)):
if s[i] !='0' :
flag=0
break
if flag:
print(True)
else:
print(False)
Constraints:
1 <= s.length, t.length <= 5 * 104
Please someone help to fix this code.
You could utilize the fact that two anagrams when sorted will be the same:
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
return sorted(s) == sorted(t)
Or that they would have the same counts of characters:
from collections import Counter
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
return Counter(s) == Counter(t)
The latter is more efficient since sorting is O(n log n), while constructing the Counter/Dictionary/Map/HashTable is linear time i.e., O(n).
If you don't want to use collections.Counter since it feels like it's abstracting away the core part of the problem, you could replicate its functionality with a list (assumes both strings will only contain lowercase characters):
class Solution:
def lowercase_counts(self, s: str) -> list[int]:
counts = [0] * 26
for ch in s:
counts[ord(ch) - ord('a')] += 1
return counts
def isAnagram(self, s: str, t: str) -> bool:
return self.lowercase_counts(s) == self.lowercase_counts(t)
Or more robustly supporting all Unicode characters using a dictionary:
class Solution:
def character_counts(self, s: str) -> dict[str, int]:
counts = {}
for ch in s:
counts[ch] = counts.get(ch, 0) + 1
return counts
def isAnagram(self, s: str, t: str) -> bool:
return self.character_counts(s) == self.character_counts(t)
Simply use a Counter.
from collections import Counter
def is_anagram(s1:str, s2:str) -> bool:
return Counter(s1) == Counter(s2)
I have created a Tree object with the following structure:
class Tree:
def __init__(self, data=None):
self.data = data
self.left_child = None
self.right_child = None
An instance of this object is:
tree = Tree("A")
tree.left_child = Tree("B")
tree.right_child = Tree("C")
tree.left_child.left_child = Tree("D")
tree.left_child.right_child = Tree("E")
tree.right_child.left_child = Tree("F")
tree.right_child.right_child = Tree("G")
Its Newick format should be ((G,F)C,(E,D)B)A;
How can I convert any instance of Tree object to its Newick format?
Thanks to Blckknght for his hint.
def to_newick(tree):
newick = ""
newick = traverse(tree, newick)
newick = f"{newick};"
return newick
def traverse(tree, newick):
if tree.left_child and not tree.right_child:
newick = f"(,{traverse(tree.left_child, newick)}){tree.data}"
elif not tree.left_child and tree.right_child:
newick = f"({traverse(tree.right_child, newick)},){tree.data}"
elif tree.left_child and tree.right_child:
newick = f"({traverse(tree.right_child, newick)},{traverse(tree.left_child, newick)}){tree.data}"
elif not tree.left_child and not tree.right_child:
newick = f"{tree.data}"
else:
pass
return newick
I just thought you might want something not recursive, iterative implementations usually run faster.
from typing import List
class Tree:
def __init__(self, data=None):
self.data: str = data
self.left_child: Tree = None
self.right_child: Tree = None
def newick(self) -> str:
# Recursive version
# Practically a postorder tree traversal
if not self.left_child and not self.right_child:
return self.data
left_child = self.left_child.newick() if self.left_child else ""
right_child = self.right_child.newick() if self.right_child else ""
return f"({right_child},{left_child}){self.data}"
def newick_iter(self) -> str:
# Iterative version
# https://www.geeksforgeeks.org/iterative-postorder-traversal-using-stack/
res: str = ""
traverse_stack: List[Tree] = []
curr: Tree = self
while True:
while curr:
if curr.left_child:
traverse_stack.append(curr.left_child)
res += '('
traverse_stack.append(curr)
curr = curr.right_child
curr = traverse_stack.pop()
if curr.left_child and (traverse_stack and curr.left_child == traverse_stack[-1]):
tmp = traverse_stack.pop()
traverse_stack.append(curr)
curr = tmp
if res[-1] == ')':
res = res[:-1]
res += ','
else:
res += curr.data + ')'
curr = None
if not traverse_stack:
break
res = res[:-1]
return res
def main():
tree = Tree("A")
tree.left_child = Tree("B")
tree.right_child = Tree("C")
tree.left_child.left_child = Tree("D")
tree.left_child.right_child = Tree("E")
tree.right_child.left_child = Tree("F")
tree.right_child.right_child = Tree("G")
print(tree.newick_iter())
print(tree.newick())
if __name__ == '__main__':
main()
For my homework, I need to return a list containing the nodes with correct orders in binary tree according to the string(in, pre and post) that was given. But it return 'None' instead and I don't know what's wrong. Thanks for any kind of help.
class BinarySearchTree:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def create_new_bst(nums):
root = None
for num in nums:
root = insert(root, num)
return root
def insert (t, data):
if not t:
return BinarySearchTree(data)
elif t.data == data:
t.count += 1
elif data < t.data:
t.left = insert(t.left, data)
else:
t.right = insert(t.right, data)
return t
def traverse(t, order):
if order == 'in':
return inorder(t)
elif order == 'pre':
return preorder(t)
elif order == 'post':
return postorder(t)
def inorder(root):
lst = []
if root:
inorder(root.left)
lst.append(root.data)
inorder(root.right)
return lst
def postorder(root):
lst = []
if root:
postorder(root.left)
postorder(root.right)
lst.append(root.data)
return lst
def preorder(root):
lst = []
if root:
lst.append(root.data)
preorder(root.left)
preorder(root.right)
return lst
t = create_new_bst([55, 24, 8, 51, 25, 72, 78])
result = traverse(t, 'post')
print('Result =', result)
So apart from your initial problems with constructing the BST, the traversals were not updating the lst variable with the value returned from the left and right subtrees. The following code should work:
def inorder(root):
lst = []
if root:
lst = inorder(root.left)
lst.append(root.data)
lst.extend(inorder(root.right))
return lst
def postorder(root):
lst = []
if root:
lst = postorder(root.left)
lst.extend(postorder(root.right))
lst.append(root.data)
return lst
def preorder(root):
lst = []
if root:
lst.append(root.data)
lst.extend(preorder(root.left))
lst.extend(preorder(root.right))
return lst
extend is a list method that will add each item from the argument list to the end of the caller list.
I was trying to run this code and encountered a run time error. I am not able to debug the code. I do believe that the error lies in functions huffman_encode and huffman_decode. The error showing is the resource warning error. Here is the code:
from linked_list import *
from huffman_bits_io import HuffmanBitsWriter as writer, HuffmanBitsReader as reader
import unittest
class Leaf:
'''class that implements Leaf'''
def __init__(self, parent, value, code, frequency):
self.parent = parent
self.frequency = frequency
self.value = value
self.code = code
def __eq__(self, other):
return type(other) == Leaf and self.parent == other.parent and self.frequency ==other.frequency and self.value==other.value and self.code==other.code
def __repr__(self):
return "[ {}, frequency = {} ]".format(self.code, self.frequency)
class Node:
'''class that implements Node'''
def __init__(self, parent, code, lchild, rchild, frequency):
self.parent = parent
self.code = code
self.frequency = frequency
self.lchild = lchild
self.rchild = rchild
def __eq__(self, other):
return type(other) == Node and self.parent==other.parent and self.code == other.code and self.frequency == other.frequency and self.lchild == other.lchild and self.rchild == other.rchild
def __repr__(self):
return "{}, freq = {}\n\left = {}\n\right = {}".format(self.code, self.frequency, self.lchild.___repr__(), self.rchild.__repr__())
def strip(string, seq):
'''this function cuts sequence from beginning of string if possible and returns result '''
if len(seq) > len(string):
return string
for i in range(len(seq)):
if seq[i] != string[i]:
return string
else:
return string[len(seq):]
def find(lst, item):
'''this function finds index of first occurrence of given element in the list and returns it or raise error if there is no such element'''
for i in range(lst.length):
if get(lst, i).value[0] == item:
return i
else:
raise ValueError
def string_traverse(node):
'''this function returns string representation of tree in pre-order traversal'''
lst = empty_list()
traverse(node, lst) #calls traverse
result_string = ''
for i in range(lst.length): #accumulate string from lst list
result_string += chr(get(lst, i).value)
return result_string
def traverse(node, code):
'''this function traverse the try and return list of leaf's value(helper for string_traverse)'''
if type(node) == Leaf:
code = add(code, node.value, code.length) #if node is Leaf than terminate recursion and return character
else:
traverse(node.lchild, code) #recursive call
traverse(node.rchild, code) #recursive call
def count_occurrences(file_name):
'''this function returns list that represent occurrence of every character of given string'''
with open(file_name) as file: #reads file
data = file.read()
lst = list()
for i in range(len(data)): #creates list of integer representation of string
lst.append(ord(data[i]))
data = lst
lst = empty_list()
for char in data: #this loop calculates occurrences of characters in the string
try:
index = find(lst, char)
lst = set(lst, index, (char, get(lst, index).value[1] + 1))
except ValueError:
lst = add(lst, (char, 1), 0)
lst = sort(lst, lambda x: x.value[1], False) #sorts occurrences
return lst
def comes_before(el1, el2):
'''this function returns True if el1 leaf should come before el2 leaf in Huffman tree meaning'''
if el1[1] < el2[1] or (el1[1] == el2[1] and type(el1[0]) is int and type(el2[0]) is int and el1[0] < el2[0]):
return True
else:
return False
def build_tree(occurrences):
'''this function returns Huffman tree based on given list of occurrences'''
if occurrences.length == 1: #if we have only one character returns Leaf with this character and code '0'
return Leaf(None, get(occurrences, 0).value[0], '0', get(occurrences, 0).value[1])
while occurrences.length != 1: #algorith described in the task
el1, occurrences = remove(occurrences, 0)
el2, occurrences = remove(occurrences, 0)
el1, el2 = el1.value, el2.value
if not comes_before(el1, el2): #finds order of elements in the tree
el1, el2 = el2, el1
new = Node(None, '', None, None, el1[1] + el2[1]) #creates new node
if type(el1[0]) is Node:
el1[0].code = '0' #sets up code for node
el1[0].parent = new
new.lchild = el1[0]
else:
new.lchild = Leaf(new, el1[0], '0', el1[1]) #if el1 is character not Node we will create leaf for that character
if type(el2[0]) is Node:
el2[0].code = '1' #sets up code for node
el2[0].parent = new
new.rchild = el2[0]
else:
new.rchild = Leaf(new, el2[0], '1', el2[1]) #if el2 is character not Node we will create leaf for that character
occurrences = insert_sorted(occurrences, (new, new.frequency), comes_before) #inserts new node
return get(occurrences, 0).value[0]
def collect_code(node, code = ''):
'''this function traverse Huffman tree and collect code for each leaf and returns them as nested list(helper for create_code)'''
if type(node) == Leaf:
lst = empty_list()
return add(lst, (node.value, code + node.code), 0) #if node is Leaf terminates recursion and returns code for the leaf
else:
lst = empty_list()
lst = add(lst, collect_code(node.lchild, code + node.code), 0) #recursive call
lst = add(lst, collect_code(node.rchild, code + node.code), 0) #recursive call
return lst
def create_code(tree):
'''this function unpack result of calling collect_code and return Huffman code as a list of tuples'''
code = collect_code(tree) #calls collect code
i = 0
while i < code.length: #this loop unpacks list
if type(get(code, i).value) is not tuple:
item, code = remove(code, i)
for j in range(item.value.length):
code = add(code, get(item.value, j).value, i)
continue
i += 1
return code
def huffman_encode(input_file, output_file):
'''task describe this function'''
occurrences = count_occurrences(input_file)
tree = build_tree(occurrences)
string = empty_list()
t = traverse(tree, string)
code = create_code(tree)
with open(input_file) as file:
string = file.read()
result_string = ''
for i in range(len(string)): #this loop encodes string using code produced by create_code function
for j in range(code.length):
temp = get(code, j).value
if string[i] == chr(temp[0]):
result_string += temp[1]
break
for i in range(occurrences.length):
temp = get(occurrences, i).value
occurrences = set(occurrences, i, (chr(temp[0]), temp[1]))
occurrences = sort(occurrences, lambda x: x.value[0], False)
file = writer(output_file)
file.write_int(code.length)
for i in range(occurrences.length):
temp = get(occurrences, i).value
file.write_byte(ord(temp[0]))
file.write_int(temp[1])
file.write_code(result_string)
file.close()
return string_traverse(tree)
def huffman_decode(input_file, output_file):
'''task describe this function'''
file = reader(input_file)
number_of_codes = file.read_int()
occurrences = empty_list()
for i in range(number_of_codes):
char = file.read_byte()
number = file.read_int()
occurrences = add(occurrences, (char, number), 0)
occurrences = sort(occurrences, lambda x: x.value[1], False)
tree = build_tree(occurrences)
code = sort(create_code(tree), lambda x: x.value[0], False)
occurrences = sort(occurrences, lambda x: x.value[0], False)
quantity_of_bits = 0
for i in range(code.length):
quantity_of_bits += get(occurrences, i).value[1]*len(get(code, i).value[1])
occurrences = sort(occurrences, lambda x: x.value[1], False)
bit_string = ''
for i in range(quantity_of_bits):
bit_string = bit_string + ('1' if file.read_bit() else '0')
result_string = ''
while bit_string: #this loop decodes string using code produced by create_code function
for j in range(code.length):
temp = get(code, j).value
stripped = strip(bit_string, temp[1])
if len(stripped) < len(bit_string):
result_string += chr(temp[0])
bit_string = stripped
break
with open(output_file, 'w') as file:
file.write(result_string)
file.close()
class Test(unittest.TestCase):
def test_strip1(self):
self.assertEqual(strip('123456', '123'), '456')
def test_strip2(self):
self.assertEqual(strip('123', '4567'), '123')
def test_strip3(self):
self.assertEqual(strip('123', '456'), '123')
def test_find(self):
lst = empty_list()
lst = add(lst, (1, 'b'), 0)
lst = add(lst, (2, 'a'), 1)
self.assertEqual(find(lst, 2), 1)
def test_find_raise(self):
lst = empty_list()
lst = add(lst, (1, 'b'), 0)
lst = add(lst, (2, 'a'), 1)
self.assertRaises(ValueError, find, lst, 5)
def test_occurrences(self):
lst = empty_list()
lst = add(lst, (97, 5), 0)
lst = add(lst, (98, 3), 0)
lst = add(lst , (99, 7), 2)
self.assertEqual(str(count_occurrences(r'test2.txt')), str(lst))
def test_create_code_and_tree_build(self):
occurrences = count_occurrences(r'test2.txt')
tree = build_tree(occurrences)
code = create_code(tree)
code = sort(code, lambda x: x.value[0], False)
self.assertEqual(str(code), "[(97, '11'), (98, '10'), (99, '0')]")
def test_huffman_encode_decode(self):
string = huffman_encode(r'test1.txt', r'test_out.txt')
huffman_decode(r'test_out.txt', r'test_decode.txt')
self.assertEqual(string, 'a')
with open(r'test1.txt') as file1:
with open(r'test_decode.txt') as file2:
self.assertEqual(file1.read(), file2.read())
file2.close()
file1.close()
def test_huffman_encode_decode3(self):
string = huffman_encode(r'test2.txt', r'test2_out.txt')
huffman_decode(r'test2_out.txt', r'test2_decode.txt')
self.assertEqual(string, 'cba')
with open(r'test2.txt') as file1:
with open(r'test2_decode.txt') as file2:
self.assertEqual(file1.read(), file2.read())
file2.close()
file1.close()
def test_huffman_encode_decode2(self):
string = huffman_encode(r'test3.txt', r'test3_out.txt')
huffman_decode(r'test3_out.txt', r'test3_decode.txt')
self.assertEqual(string, 'edcba')
with open(r'test3.txt') as file1:
with open(r'test3_decode.txt') as file2:
self.assertEqual(file1.read(), file2.read())
file2.close()
file1.close()
if __name__ == '__main__':
unittest.main()
And following is the error:
...
Warning (from warnings module):
File "C:\Users\Vikas\Documents\fwdregardingprojectdevelopment\huffman.py", line 212
with open(output_file, 'w') as file:
ResourceWarning: unclosed file <_io.BufferedReader name='test_out.txt'>
.
Warning (from warnings module):
File "C:\Users\Vikas\Documents\fwdregardingprojectdevelopment\huffman.py", line 212
with open(output_file, 'w') as file:
ResourceWarning: unclosed file <_io.BufferedReader name='test3_out.txt'>
.
Warning (from warnings module):
File "C:\Users\Vikas\Documents\fwdregardingprojectdevelopment\huffman.py", line 212
with open(output_file, 'w') as file:
ResourceWarning: unclosed file <_io.BufferedReader name='test2_out.txt'>
.....
----------------------------------------------------------------------
Ran 10 tests in 0.272s
OK
it seems somewhere in your code file 'out_file' is opened and not closed
find where it is opened and close it :
out_file.close()
class block(object):
def __init__(self, N):
self.N = N; self.l, self.r, self.u, self.d = [None]*4
def move_lower(self):
res = []
for x in (self.u, self.d, self.l, self.r):
if x != None and x.N < self.N:
res.append(x)
return res
def move_lower_chain(self, res = [], history = []):
temp = self.move_lower()
if len(temp) == 0:
res.append(history + [self.N])
else:
for x in temp:
x.move_lower_chain(res, history + [x.N])
return res
I tried to change the 'move_lower_chain' function to Non-recursive function, but i couldn't and even didn't know how to solve. most difficult part was below:
for x in temp:
x.move_lower_chain(res, history + [x.N])
Is there anyone who can help me?