Skip to main content

Differentiate Between del, remove, and pop on a List

May 31, 2023CodeCatch
Loading...

More Python Posts

Bogo Sort

Nov 19, 2022CodeCatch

0 likes • 0 views

# Python program for implementation of Bogo Sort
import random
# Sorts array a[0..n-1] using Bogo sort
def bogoSort(a):
n = len(a)
while (is_sorted(a)== False):
shuffle(a)
# To check if array is sorted or not
def is_sorted(a):
n = len(a)
for i in range(0, n-1):
if (a[i] > a[i+1] ):
return False
return True
# To generate permuatation of the array
def shuffle(a):
n = len(a)
for i in range (0,n):
r = random.randint(0,n-1)
a[i], a[r] = a[r], a[i]
# Driver code to test above
a = [3, 2, 4, 1, 0, 5]
bogoSort(a)
print("Sorted array :")
for i in range(len(a)):
print ("%d" %a[i]),

Radix sort

Nov 19, 2022CodeCatch

0 likes • 1 view

# Python program for implementation of Radix Sort
# A function to do counting sort of arr[] according to
# the digit represented by exp.
def countingSort(arr, exp1):
n = len(arr)
# The output array elements that will have sorted arr
output = [0] * (n)
# initialize count array as 0
count = [0] * (10)
# Store count of occurrences in count[]
for i in range(0, n):
index = (arr[i]/exp1)
count[int((index)%10)] += 1
# Change count[i] so that count[i] now contains actual
# position of this digit in output array
for i in range(1,10):
count[i] += count[i-1]
# Build the output array
i = n-1
while i>=0:
index = (arr[i]/exp1)
output[ count[ int((index)%10) ] - 1] = arr[i]
count[int((index)%10)] -= 1
i -= 1
# Copying the output array to arr[],
# so that arr now contains sorted numbers
i = 0
for i in range(0,len(arr)):
arr[i] = output[i]
# Method to do Radix Sort
def radixSort(arr):
# Find the maximum number to know number of digits
max1 = max(arr)
# Do counting sort for every digit. Note that instead
# of passing digit number, exp is passed. exp is 10^i
# where i is current digit number
exp = 1
while max1/exp > 0:
countingSort(arr,exp)
exp *= 10
# Driver code to test above
arr = [ 170, 45, 75, 90, 802, 24, 2, 66]
radixSort(arr)
for i in range(len(arr)):
print(arr[i]),

Topological sort

Nov 19, 2022CodeCatch

0 likes • 3 views

#Python program to print topological sorting of a DAG
from collections import defaultdict
#Class to represent a graph
class Graph:
def __init__(self,vertices):
self.graph = defaultdict(list) #dictionary containing adjacency List
self.V = vertices #No. of vertices
# function to add an edge to graph
def addEdge(self,u,v):
self.graph[u].append(v)
# A recursive function used by topologicalSort
def topologicalSortUtil(self,v,visited,stack):
# Mark the current node as visited.
visited[v] = True
# Recur for all the vertices adjacent to this vertex
for i in self.graph[v]:
if visited[i] == False:
self.topologicalSortUtil(i,visited,stack)
# Push current vertex to stack which stores result
stack.insert(0,v)
# The function to do Topological Sort. It uses recursive
# topologicalSortUtil()
def topologicalSort(self):
# Mark all the vertices as not visited
visited = [False]*self.V
stack =[]
# Call the recursive helper function to store Topological
# Sort starting from all vertices one by one
for i in range(self.V):
if visited[i] == False:
self.topologicalSortUtil(i,visited,stack)
# Print contents of stack
print(stack)
g= Graph(6)
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);
print("Following is a Topological Sort of the given graph")
g.topologicalSort()

bruteforce password cracker

Nov 18, 2022AustinLeath

0 likes • 4 views

import itertools
import string
import time
def guess_password(real):
chars = string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation
attempts = 0
for password_length in range(1, 9):
for guess in itertools.product(chars, repeat=password_length):
startTime = time.time()
attempts += 1
guess = ''.join(guess)
if guess == real:
return 'password is {}. found in {} guesses.'.format(guess, attempts)
loopTime = (time.time() - startTime);
print(guess, attempts, loopTime)
print("\nIt will take A REALLY LONG TIME to crack a long password. Try this out with a 3 or 4 letter password and see how this program works.\n")
val = input("Enter a password you want to crack that is 9 characters or below: ")
print(guess_password(val.lower()))

Check Armstrong Number

May 31, 2023CodeCatch

0 likes • 0 views

# Function to check Armstrong number
def is_armstrong_number(number):
# Convert number to string to iterate over its digits
num_str = str(number)
# Calculate the sum of the cubes of each digit
digit_sum = sum(int(digit) ** len(num_str) for digit in num_str)
# Compare the sum with the original number
if digit_sum == number:
return True
else:
return False
# Prompt user for a number
number = int(input("Enter a number: "))
# Check if the number is an Armstrong number
if is_armstrong_number(number):
print(number, "is an Armstrong number.")
else:
print(number, "is not an Armstrong number.")

UNT CSCE 2100 Assignment 6

Nov 18, 2022AustinLeath

0 likes • 0 views

"""
Assignment 6
The goal is to make a graph of
who bit who and who was bitten.
There should be 10 nodes and 15 edges.
3 arrows of biting each other and
3 arrows of someone biting themselves.
Networkx can not do self biting
arrows, but it is in the code.
"""
from graphviz import Digraph as DDotGraph
from graphviz import Graph as UDotGraph
import networkx as nx
from networkx.algorithms.dag import transitive_closure
import graphviz as gv
import matplotlib.pyplot as plt
import numpy as np
from numpy.linalg import matrix_power
"""
class DGraph:
def __init__(self):
self.d = dict()
def clear(self):
self.d = dict()
def add_node(self,n):
if not self.d.get(n):
self.d[n] = set()
def add_edge(self,e):
f,t=e
self.add_node(f)
self.add_node(t)
vs=self.d.get(f)
if not vs:
self.d[f] = {t}
else:
vs.add(t)
def add_edges_from(self,es):
for e in es:
self.add_edge(e)
def edges(self):
for f in self.d:
for t in self.d[f]:
yield (f,t)
def number_of_nodes(self):
return len(self.d)
def __repr__(self):
return self.d.__repr__()
def show(self):
dot = gv.Digraph()
for e in self.edges():
#print(e)
f, t = e
dot.edge(str(f), str(t), label='')
#print(dot.source)
show(dot)
# displays graph with graphviz
def show(dot, show=True, file_name='graph.gv'):
dot.render(file_name, view=show)
def showGraph(g,label="",directed=True):
if directed:
dot = gv.Digraph()
else:
dot = gv.Graph()
for e in g.edges():
print(e)
f, t = e
dot.edge(str(f), str(t), label=label)
print(dot.source)
show(dot)
def bit():
G = DGraph()
G.add_edge(("Blade","Samara"))
G.add_edge(("Shadow","Wolfe"))
G.add_edge(("Raven", "Austin"))
G.add_edge(("Blade", "Alice"))
G.add_edge(("Alice","Brandon"))
G.add_edge(("Blade", "Wolfe"))
G.add_edge(("Samara", "Robin"))
G.add_edge(("Samara", "Raven"))
G.add_edge(("Samara", "Hamed"))
G.add_edge(("Wolfe", "Blade"))
G.add_edge(("Hamed", "Samara"))
G.add_edge(("Wolfe", "Shadow"))
G.add_edge(("Brandon", "Brandon"))
G.add_edge(("Hamed", "Hamed"))
G.add_edge(("Austin", "Austin"))
showGraph(G, label="bit")
bit()
def bitten():
G=DGraph()
G.add_edge(("Samara","Blade"))
G.add_edge(("Wolfe","Shadow"))
G.add_edge(("Austin", "Raven"))
G.add_edge(("Alice","Blade"))
G.add_edge(("Brandon", "Alice"))
G.add_edge(("Wolfe", "Blade" ))
G.add_edge(("Robin", "Samara"))
G.add_edge(("Raven", "Samara"))
G.add_edge(("Hamed", "Samara"))
G.add_edge(("Blade", "Wolfe"))
G.add_edge(("Samara", "Hamed"))
G.add_edge(("Shadow", "Wolfe"))
G.add_edge(("Brandon", "Brandon"))
G.add_edge(("Hamed", "Hamed"))
G.add_edge(("Austin", "Austin"))
showGraph(G, label="bitten by")
#bitten()
family = ["Blade", "Samara", "Shadow", "Wolfe", "Raven", "Alice"]
"""
#Do transitive closure call out and the
#matrix power operation should be the same
D = nx.DiGraph()
#D.add_nodes_from("SamaraBladeWolfeShadowAliceRavenBrandonRobinHamedAustin")
D.add_edge("Blade","Samara")
D.add_edge("Shadow","Wolfe")
D.add_edge("Raven", "Austin")
D.add_edge("Blade", "Alice")
D.add_edge("Alice","Brandon")
D.add_edge("Blade", "Wolfe")
D.add_edge("Samara", "Robin")
D.add_edge("Samara", "Raven")
D.add_edge("Samara", "Hamed")
D.add_edge("Wolfe", "Blade")
D.add_edge("Hamed", "Samara")
D.add_edge("Wolfe", "Shadow")
D.add_edge("Brandon", "Brandon")
D.add_edge("Hamed", "Hamed")
D.add_edge("Austin", "Austin")
T = transitive_closure(D)
for e in D.edges(): print(e)
for n in D.nodes(): print(n)
def show(H):
nx.draw(H, with_labels=True, font_weight='bold')
plt.show()
#Use nx.to_numpy_matrix instead of nx.adjacency_matrix
# M = nx.adjacency_matrix(D)
# MT = nx.adjacency_matrix(T)
M = nx.to_numpy_matrix(D)
MT = nx.to_numpy_matrix(T)
M2 = M@M
def mPower(M, k): #M is numpy matrix
assert k >= 1
P = M
for _ in range(k):
P = P @ M
return P
def tc(M):
#compute transitive closure
pass
D1 = nx.DiGraph(M)
D2 = nx.DiGraph(M2)
print('Matrix for Original\n', M)
N = nx.to_numpy_array(D,dtype=int)
print('np_array for Original\n', N)
print('\nMatrix for Transitive Closure\n', MT)
N2 = nx.to_numpy_array(T,dtype=int)
print('np_array for Transitive Closure\n', N2)
show(D) #can use D, T, and numpy matrix power operation
show(T)
show(T)