Cleanup

nityansuman · nityansuman · commit 621931f79ab9 · 2022-11-27T19:32:54.000Z
diff --git a/hackerrank/acm_icpc_team.py b/hackerrank/acm_icpc_team.py
@@ -1,11 +1,8 @@
 # Import packages
 from typing import List
 
-
 def acm_team(topic: List[str]) -> List[int]:
-	# Convert string to binary
 	topic = [int(t, 2) for t in topic]
-
 	max_topics, num_teams = 0, 0
 
 	for i in range(len(topic) - 1):
@@ -23,10 +20,8 @@ def acm_team(topic: List[str]) -> List[int]:
 
 
 if __name__ == "__main__":
-	# Read input from stdin
 	n, m = list(map(int, input().strip().split()))
 
-	# Read topic input from stdin
 	topic = list()
 	for _ in range(n):
 		topic_item = input()
diff --git a/hackerrank/angry_professor.py b/hackerrank/angry_professor.py
@@ -3,16 +3,12 @@ def angry_professor(k: int, arr: list) -> str:
 
 
 if __name__ == "__main__":
-	# Read number test cases
 	num_test = int(input().strip())
 
 	for t in range(num_test):
-		# Read students in class (n) and cancelation threshold (k)
 		n, k = map(int, input().strip().split())
 
-		# Read n-separated integers describing student arrival times
 		arr = list(map(int, input().rstrip().split()))
 		arr = sorted(arr, key=int)
 
-		# Determine if class is canceled
 		print("Is class canceled:", angry_professor(k, arr))
diff --git a/hackerrank/athlete_sort.py b/hackerrank/athlete_sort.py
@@ -1,15 +1,11 @@
 if __name__ == "__main__":
-	# Read number of rows and columns from stdin
 	rows, columns = list(map(int, input().strip().split()))
 
-	# Read data points from stdin
 	data = list()
 	for i in range(rows):
 		data.append(list(map(int, input().strip().split())))
 
-	# Read sprting index from stdin
 	sort_col_index = int(input().strip())
 
-	# Sort data using a particular column index
 	for row in sorted(data, key=lambda t: t[sort_col_index]):
 		print(" ".join([str(x) for x in row]).strip())
diff --git a/hackerrank/beautiful_days.py b/hackerrank/beautiful_days.py
@@ -1,8 +1,6 @@
 if __name__ == "__main__":
-	# Read input from stdin
 	n, m, k = list(map(int, input().strip().split()))
 
-	# Count beautiful days
 	count = 0
 	for x in range(n, m+1):
 		y = int(str(x)[::-1])
diff --git a/hackerrank/captains_room.py b/hackerrank/captains_room.py
@@ -1,26 +1,18 @@
 def find_captains_room(rooms, size):
 	all_guests = list(map(int, rooms))
+
 	unique_guests = set(all_guests)
 	sum_all_guests = sum(all_guests)
 
-	# Get the sum of all the unique room numbers
 	sum_unique_guests = sum(unique_guests)
-
-	# Get the difference, in the sum: the captains room will cause this difference
 	temp = (sum_unique_guests * size) - sum_all_guests
 
-	# Compute the captain's room number
 	return temp // (size - 1)
 
 
 if __name__ == "__main__":
-	# Read input size from stdin
 	size = int(input().strip())
-
-	# Read room number list from stdin
 	rooms = input().strip().split(" ")
 
-	# Find captain's room
 	captains_room_number = find_captains_room(rooms, size)
-
 	print(captains_room_number)
diff --git a/hackerrank/designer_door_mat.py b/hackerrank/designer_door_mat.py
@@ -1,17 +1,13 @@
 if __name__ == "__main__":
-	# Read input from stdin
 	n, m = input().strip().split(" ")
 	n, m = [int(n), int(m)]
 
-	# Draw top half
 	for i in range(1, n, 2):
 		print("-" * ((m - i * 3) // 2) + ("|".center(3, "."))
 				  * i + "-" * ((m - i * 3) // 2))
 
-	# Print message
-	print("WELCOmE".center(m, "-"))
+	print("WELCOME".center(m, "-"))
 
-	# Draw bottom half
 	for i in range(n - 2, -1, -2):
 		print("-" * ((m - i * 3) // 2) + ("|".center(3, "."))
 				  * i + "-" * ((m - i * 3) // 2))
diff --git a/hackerrank/find_angle.py b/hackerrank/find_angle.py
@@ -1,22 +1,13 @@
 # Import packages
 from math import degrees, hypot, acos
 
-
 def compute_angle(ab, bc):
-	# Compute larger triangle hypotenuse
-	hypotenuse = hypot(ab, bc)
-
-	# Compute angle using arc cosine (base / hypotenuse)
-	return int(round(degrees(acos(bc/hypotenuse))))
+	return int(round(degrees(acos(bc/hypot(ab, bc)))))
 
 
 if __name__ == "__main__":
-	# Read triangle side input from stdin
 	ab = int(input().strip())
 	bc = int(input().strip())
 
-	# Compute angle at mbc
 	angle = compute_angle(ab, bc)
-
-	# Print angle with degree symbol
 	print(f"Computed Angle: {angle}{chr(176)}")
diff --git a/hackerrank/get_node_value.py b/hackerrank/get_node_value.py
@@ -1,45 +1,31 @@
-class SinglyLinkedListNode:
-	"""Node class implementation.
-	"""
-
-	def __init__(self, node_data):
+class Node:
+	def __init__(self, node_data: int) -> None:
 		self.data = node_data
 		self.next = None
 
-
 class SinglyLinkedList:
-	"""Singly linked list class implementation.
-	"""
-
-	def __init__(self):
+	def __init__(self) -> None:
 		self.head = None
 		self.tail = None
 
-	def insert_node(self, node_data):
-		# Create a new node
-		node = SinglyLinkedListNode(node_data)
+	def insert_node(self, node_data) -> None:
+		node = Node(node_data)
 
 		if not self.head:
-			# Add ndoe to head when list is empty
 			self.head = node
 		else:
-			# Add node to tail when list is not empty
 			self.tail.next = node
 
-		# Set new node as tail
 		self.tail = node
 
-
-def get_node(head, pos_from_tail):
-	# Count number of nodes in the list
+def get_node(head, pos_from_tail) -> int:
 	num_nodes = 0
 
 	curr = head
 	while curr:
 		num_nodes += 1
 		curr  = curr.next
 
-	# Now identify the node relative to tail
 	pos_from_head = 0
 
 	curr = head
@@ -51,28 +37,18 @@ def get_node(head, pos_from_tail):
 
 
 if __name__ == "__main__":
-	# Read numer of test cases from stdin
 	tests = int(input().strip())
 
-	# For each test case
 	for t in range(tests):
-		# Read number of elements from stdin
 		num_elements = int(input().strip())
 
-		# Initiate singly linked list class
 		llist = SinglyLinkedList()
 
-		# For each element
 		for _ in range(num_elements):
-			# Read list input from stdin
 			item = int(input().strip())
-
-			# Insert input into list
 			llist.insert_node(item)
 
-		# Read position relative to tail from stdin
 		position = int(input().strip())
 
-		# Get data stored at node for the given position
 		node_value = get_node(llist.head, position)
 		print("Node Value:", node_value)
diff --git a/hackerrank/merge_the_tools.py b/hackerrank/merge_the_tools.py
@@ -1,29 +1,19 @@
 def create_sequences(sequence, factor):
-	# Compute sequence and new sequence length
 	seq_len = len(sequence)
 
-	# Iteratively create new sequences
 	for i in range(0, seq_len, factor):
-		# Unique character set placeholder
 		seen = set()
 		for char in sequence[i:i+factor]:
 			if char not in seen:
-				# If not seen, print
 				seen.add(char)
 				print(char, end="")
 			else:
-				# If seen, ignore
 				continue
-		# Add newline for next sequence
 		print()
 
 
 if __name__ == "__main__":
-	# Read sequenc string from stdin
 	sequence = input().strip()
-
-	# Read factor integer from stdin
 	factor = int(input().strip())
 
-	# Print new sequences on newlines
 	create_sequences(sequence, factor)
diff --git a/hackerrank/piling_up.py b/hackerrank/piling_up.py
@@ -1,88 +1,64 @@
-def piling_up(num_blocks, block_lengths):
-	# Set dummy top value
+def piling_up(num_blocks: int, block_lengths: int) -> bool:
 	top = -1
+	left, right = 0,
+	num_blocks - 1
 
-	# Set left and right pointers
-	left, right = 0, num_blocks - 1
+	if_first, flag = True, True
 
-	# Set flag to denote first iteration
-	if_first = True
-
-	# Set flag to indicate if piling is possible
-	flag  = True
-
-	# Iterate over the block lengths using two pointers
 	while left < right:
-		# Find the largest block length
 		if block_lengths[left] > block_lengths[right]:
 			if if_first:
-				# First iteration
 				top = block_lengths[left]
 				left += 1
 
-				# Reset flag to avoid running this block for other iterations
 				if_first = False
 			else:
 				if block_lengths[left] <= top:
 					top = block_lengths[left]
 					left += 1
 				else:
-					# Reset piling up flag when rule failes and break
 					flag = False
 					break
 		elif block_lengths[left] < block_lengths[right]:
 			if if_first:
-				# First iteration
 				top = block_lengths[right]
 				right -= 1
 
-				# Reset flag to avoid running this block for other iterations
 				if_first = False
 			else:
 				if block_lengths[right] <= top:
 					top = block_lengths[right]
 					left += 1
 				else:
-					# Reset piling up flag when rule failes and break
 					flag = False
 					break
 		else:
 			if if_first:
-				# First iteration
 				top = block_lengths[left]
 				left += 1
 				right -= 1
 
-				# Reset flag to avoid running this block for other iterations
 				if_first = False
 			else:
 				if block_lengths[left] <= top:
 					top = block_lengths[left]
 					left += 1
 					right -= 1
 				else:
-					# Reset piling up flag when rule failes and break
 					flag = False
 					break
 	return flag
 
 
 if __name__ == "__main__":
-	# Read number test cases from stdin
 	test_cases = int(input().strip())
 
-	# For each test case
 	for t in range(test_cases):
-		# Read number of blocks from stdin
 		num_blocks = int(input().strip())
 
-		# Read block side lengths from stdin
 		block_lengths = list(map(int, input().strip().split()))
-
-		# Check for piling
 		flag = piling_up(num_blocks, block_lengths)
 
-		# Print appropriate message
 		if flag:
 			print("Yes")
 		else:
diff --git a/hackerrank/strange_counter.py b/hackerrank/strange_counter.py
@@ -1,13 +1,9 @@
 if __name__ == "__main__":
-	# Read number of test cases input from stdin
 	t = int(input().strip())
 
-	x = 3 # Counter start
-
-	# Placeholder variables
+	x = 3
 	total, diff, n = 0, 0, 0
 
-	# Compute counter
 	while t > total:
 		diff = (x * 2**(n+1)) - (x * 2**n)
 		total += diff
diff --git a/hackerrank/text_wrap.py b/hackerrank/text_wrap.py
@@ -10,4 +10,7 @@ def wrap(string: str, max_width: int) -> str:
 
 
 if __name__ == "__main__":
-	print(wrap("ABCDEFGHIJKLIMNOQRSTUVWXYZ", 4))
+	input_string = input().strip()
+	width = int(input().strip())
+
+	print(wrap(input_string, width))
diff --git a/hackerrank/time_delta.py b/hackerrank/time_delta.py
@@ -1,21 +1,15 @@
 # Import packages
 from datetime import datetime
 
-
 def time_delta(t1, t2):
-	# Compute absolute difference in seconds
 	return int(abs((t1 - t2).total_seconds()))
 
 
 if __name__ == "__main__":
-	# Read test cases from stdin
 	t = int(input().strip())
 
 	for i in range(t):
-		# Read two timestamps with time zone from stdin
 		t1 = datetime.strptime(input().strip(), "%a %d %b %Y %H:%M:%S %z")
 		t2 = datetime.strptime(input().strip(), "%a %d %b %Y %H:%M:%S %z")
-
-		# Compute delta in seconds
 		delta = time_delta(t1, t2)
 		print("Time Delta (seconds):", delta)
diff --git a/hackerrank/utopian_tree.py b/hackerrank/utopian_tree.py
diff --git a/hackerrank/word_order.py b/hackerrank/word_order.py
