Talhaa Hussain talhaahussain

## the-dangers-of-generative-AI.md

      
              1 file
            
          
              0 forks
            
          
              0 comments
            
          
              0 stars
            
          
                talhaahussain
                / the-dangers-of-generative-AI.md
            
            
              Last active
              May 9, 2024 13:52
            
              
                the-dangers-of-generative.AI.md -- Continuous Assessment for ECM2427 - Outside the Box: Computer Science Research and Applications (Year 2, Semester 2). A short report on the dangers of generative artificial intelligence. This work received a final mark of 72/100.
              
          
## stack.py
class Stack:
    def __init__(self):
        self.stack = []
        self.stacklen = int(input(print("How long should the stack be?")))

    def push(self):
        if len(self.stack) == self.stacklen:
            self.full()
        else:
            self.stack.append(int(input("Enter a value to append.\n")))

## maze-algorithm.py
import random # Since the generation of this maze is random, I need the random module.

def generate_maze(x_cells, y_cells):
#x_cells = 20 # This defines the number of cells in the x-direction.
#y_cells = 20 # This defines the number of cells in the y-direction.
    grid = [] # This allows me to build the grid from which the maze is generated.

    for y in range(y_cells):
        row = [] # Creates a 'row' list for all y locations (10 rows)
        for x in range(x_cells):

## collatz.py
import math

x = 99 # Select a starting point here
i = 0
running = True

while running:
    i += 1
    if x % 2 == 0:
        x = x / 2

## find_neighbours.py
def moore(x, y, lower_x, lower_y, upper_x, upper_y):
  neighbours = [(i, j) for i, j in ((x-1, y-1), (x, y-1), (x+1, y-1), (x-1, y), (x+1, y), (x-1, y+1), (x, y+1), (x+1, y+1)) if lower_x<=i<upper_x and lower_y<=j<upper_y]
  return neighbours

def von_Neumann(x, y,  lower_x, lower_y, upper_x, upper_y):
  neighbours = [(i, j) for i, j in ((x, y-1), (x-1, y), (x+1, y), (x, y+1)) if lower_x<=i<upper_x and lower_y<=j<upper_y]
  return neighbours

## contiguous_subarrays.py
def generate_subarrays(a: list[any]) -> list[any]:
  return [a[i:j] for i in range(len(a)) for j in range(i + 1, len(a) + 1)]

## euclidean_distance.py
import math

def distance(a: list[int], b: list[int]) -> list[int]:
  assert len(a) == len(b), "Coordinates must be in same dimension."
  return math.sqrt(sum([(a[i] - b[i])**2 for i in range(len(a))]))

## manhattan_distance.py
def distance(a: list[int], b: list[int]) -> list[int]:
  assert len(a) == len(b), "Coordinates must be in same dimension."
  return [abs((a[i] - b[i])) for i in range(len(a))]

## video_to_image_seq.py
import cv2

def split_video_into_frames(filename):
  frames = []
  cap = cv2.VideoCapture(filename)
  fps = cap.get(cv2.CAP_PROP_FPS)

  success = 1
  while success:
    success, frame = cap.read()

## image_seq_to_video.py
import cv2

def concat_frames_into_video(filename, frames, fps):
  height, width, channels = frames[0].shape

  fourcc = cv2.VideoWriter_fourcc(*'mp4v')
  out = cv2.VideoWriter(filename, fourcc, fps, (width, height))

  for frame in frames:
    out.write(frame)
	class Stack:
	def __init__(self):
	self.stack = []
	self.stacklen = int(input(print("How long should the stack be?")))

	def push(self):
	if len(self.stack) == self.stacklen:
	self.full()
	else:
	self.stack.append(int(input("Enter a value to append.\n")))
	import random # Since the generation of this maze is random, I need the random module.

	def generate_maze(x_cells, y_cells):
	#x_cells = 20 # This defines the number of cells in the x-direction.
	#y_cells = 20 # This defines the number of cells in the y-direction.
	grid = [] # This allows me to build the grid from which the maze is generated.

	for y in range(y_cells):
	row = [] # Creates a 'row' list for all y locations (10 rows)
	for x in range(x_cells):
	import math

	x = 99 # Select a starting point here
	i = 0
	running = True

	while running:
	i += 1
	if x % 2 == 0:
	x = x / 2
	def moore(x, y, lower_x, lower_y, upper_x, upper_y):
	neighbours = [(i, j) for i, j in ((x-1, y-1), (x, y-1), (x+1, y-1), (x-1, y), (x+1, y), (x-1, y+1), (x, y+1), (x+1, y+1)) if lower_x<=i<upper_x and lower_y<=j<upper_y]
	return neighbours

	def von_Neumann(x, y, lower_x, lower_y, upper_x, upper_y):
	neighbours = [(i, j) for i, j in ((x, y-1), (x-1, y), (x+1, y), (x, y+1)) if lower_x<=i<upper_x and lower_y<=j<upper_y]
	return neighbours
	def generate_subarrays(a: list[any]) -> list[any]:
	return [a[i:j] for i in range(len(a)) for j in range(i + 1, len(a) + 1)]
	import math

	def distance(a: list[int], b: list[int]) -> list[int]:
	assert len(a) == len(b), "Coordinates must be in same dimension."
	return math.sqrt(sum([(a[i] - b[i])**2 for i in range(len(a))]))
	def distance(a: list[int], b: list[int]) -> list[int]:
	assert len(a) == len(b), "Coordinates must be in same dimension."
	return [abs((a[i] - b[i])) for i in range(len(a))]
	import cv2

	def split_video_into_frames(filename):
	frames = []
	cap = cv2.VideoCapture(filename)
	fps = cap.get(cv2.CAP_PROP_FPS)

	success = 1
	while success:
	success, frame = cap.read()
	import cv2

	def concat_frames_into_video(filename, frames, fps):
	height, width, channels = frames[0].shape

	fourcc = cv2.VideoWriter_fourcc(*'mp4v')
	out = cv2.VideoWriter(filename, fourcc, fps, (width, height))

	for frame in frames:
	out.write(frame)