Coding test review 2
•
0 likes•59 views
This document contains summaries of two LeetCode problems - Single Number and Product of Array Except Self. For Single Number, it provides two O(n) solutions, one using a dictionary to track duplicate numbers and another using math by summing all elements and multiplying by 2, then subtracting the original sum. For Product of Array Except Self, it again provides two O(n) solutions. The first uses a variable to track the running product and another to count zeros, updating the output array accordingly. The second avoids division by calculating left and right running products in two arrays and multiplying the values together for each output element.
Report
Share
Report
Share
Download to read offline
Recommended
Coding Test Review1
This document discusses two algorithms for solving the Two Sum problem from LeetCode: an O(n^2) nested loop solution and an O(n) hash table solution. It also presents a coding interview question to find the maximum prime factor of a given number N and provides a solution using a while loop to iteratively check for divisibility.
Dev Concepts: Data Structures and Algorithms
Brief overview of the "data structures" and "algorithms" concepts.
Watch the video lesson from Svetlin Nakov and learn more at: https://softuni.org/dev-concepts/what-are-data-structures-and-algorithms
11 1. multi-dimensional array eng
The document discusses multidimensional arrays in C, including two-dimensional and three-dimensional arrays. It explains the syntax for declaring multidimensional arrays and how they are logically and physically stored in memory as one-dimensional arrays. The document also covers passing multidimensional arrays to functions, including type conversions, and initializing multidimensional arrays.
Coding test review
The document contains summaries of two coding interview questions:
1) Given a sorted array of integers, write a function to return a sorted array containing the squares of the original integers. Two solutions are provided - one in O(nlogn) time and one in O(n) time.
2) Given two integer arrays a and b and a target value v, determine if there is a pair where one number is from a and one is from b that sum to v. Return True if such a pair exists, otherwise False. Two solutions are provided - one in O(n^2) time and one in O(n) time.
Introduction to python
This document provides an introduction to Python programming. It discusses various Python data types like integers, floats and strings. It demonstrates how to perform basic operations like addition on numbers and strings. It also introduces Python lists and shows how to append elements, access elements using indexes, and print lists. The document further explains various Python operators like conditional, boolean, membership, identity operators and use of loops, functions and numpy library.
Arrays and library functions
This document discusses arrays and library functions in C++. It defines arrays as collections of variables of the same type that are referenced by a common name. Arrays are useful for organizing related data and performing operations on multiple elements. The document describes one-dimensional and two-dimensional arrays. One-dimensional arrays contain elements accessed by a single index, while two-dimensional arrays are arrays of arrays that use two indices to access elements. Memory allocation and initialization techniques for both array types are also covered.
Lecture 6 python oop (ewurc)
The document discusses object-oriented programming in Python using a Point class as an example. It covers defining a Point class with x and y attributes, initializing points, overloading operators like addition and print, adding methods like calculating distance and slope between points, handling errors, and inheriting from the Point class to create a Point3d class. The goal is to demonstrate key OOP concepts in Python including classes, objects, methods, operator overloading, inheritance and exceptions.
Multi dimensional arrays
The document discusses multidimensional arrays and provides examples of declaring and using two-dimensional arrays in Java. It describes how to represent tables of data using two-dimensional arrays, initialize arrays, access elements, and perform common operations like summing elements. The document also introduces the concept of ragged arrays and declares a three-dimensional array could be used to store student exam scores with multiple parts.
Recommended
Coding Test Review1
This document discusses two algorithms for solving the Two Sum problem from LeetCode: an O(n^2) nested loop solution and an O(n) hash table solution. It also presents a coding interview question to find the maximum prime factor of a given number N and provides a solution using a while loop to iteratively check for divisibility.
Dev Concepts: Data Structures and Algorithms
Brief overview of the "data structures" and "algorithms" concepts.
Watch the video lesson from Svetlin Nakov and learn more at: https://softuni.org/dev-concepts/what-are-data-structures-and-algorithms
11 1. multi-dimensional array eng
The document discusses multidimensional arrays in C, including two-dimensional and three-dimensional arrays. It explains the syntax for declaring multidimensional arrays and how they are logically and physically stored in memory as one-dimensional arrays. The document also covers passing multidimensional arrays to functions, including type conversions, and initializing multidimensional arrays.
Coding test review
The document contains summaries of two coding interview questions:
1) Given a sorted array of integers, write a function to return a sorted array containing the squares of the original integers. Two solutions are provided - one in O(nlogn) time and one in O(n) time.
2) Given two integer arrays a and b and a target value v, determine if there is a pair where one number is from a and one is from b that sum to v. Return True if such a pair exists, otherwise False. Two solutions are provided - one in O(n^2) time and one in O(n) time.
Introduction to python
This document provides an introduction to Python programming. It discusses various Python data types like integers, floats and strings. It demonstrates how to perform basic operations like addition on numbers and strings. It also introduces Python lists and shows how to append elements, access elements using indexes, and print lists. The document further explains various Python operators like conditional, boolean, membership, identity operators and use of loops, functions and numpy library.
Arrays and library functions
This document discusses arrays and library functions in C++. It defines arrays as collections of variables of the same type that are referenced by a common name. Arrays are useful for organizing related data and performing operations on multiple elements. The document describes one-dimensional and two-dimensional arrays. One-dimensional arrays contain elements accessed by a single index, while two-dimensional arrays are arrays of arrays that use two indices to access elements. Memory allocation and initialization techniques for both array types are also covered.
Lecture 6 python oop (ewurc)
The document discusses object-oriented programming in Python using a Point class as an example. It covers defining a Point class with x and y attributes, initializing points, overloading operators like addition and print, adding methods like calculating distance and slope between points, handling errors, and inheriting from the Point class to create a Point3d class. The goal is to demonstrate key OOP concepts in Python including classes, objects, methods, operator overloading, inheritance and exceptions.
Multi dimensional arrays
The document discusses multidimensional arrays and provides examples of declaring and using two-dimensional arrays in Java. It describes how to represent tables of data using two-dimensional arrays, initialize arrays, access elements, and perform common operations like summing elements. The document also introduces the concept of ragged arrays and declares a three-dimensional array could be used to store student exam scores with multiple parts.
Simple Neural Network Python Code
Here, we have a simple neural network described in my slides about neural networks... It is using simple concepts from linear algebra to encapsulate the complexities (This makes possible to even use parallel matrix multiplication and some other algorithms to make everything faster) and making everything more modular and compact.
The data sets are coming from http://yann.lecun.com/exdb/mnist/.
Print input-presentation
This document discusses input and print functions in Python. It explains that the print function displays information to the user and includes examples of printing different data types. It also explains that the input function accepts information from the user, stores it in a variable, and can include a prompt. Examples are provided of getting both string and numeric input and converting the input to other data types like integers. The document also covers simple formatting options for print like printing on new lines, adding separators, or printing on the same line.
Oh, All the things you'll traverse
This document summarizes a presentation about type classes in Scala. It introduces type classes like Monoid and Functor. It provides examples of Monoid instances for types like Int and Option. It explains how to define type classes for new types. It shows how to generalize functions like sequence and traverse to work for any Applicative functor using type classes. Finally, it discusses related concepts like Semigroup, Semigroupal functors, and NonEmptyList.
Pandas pythonfordatascience
The document provides an overview of the Pandas library in Python for working with data structures like Series and DataFrames. It covers common operations for selecting, filtering, sorting, applying functions, handling missing data, and reading/writing data to files and databases. These operations allow for easy manipulation and analysis of data in Pandas.
Polynomials
The document discusses representing polynomials using linked lists. Polynomials can be represented as singly linked lists by storing the coefficient and exponent of each term in a node. Adding polynomials involves traversing the lists and combining terms with matching exponents. Polynomials can also be represented using circular linked lists. This allows nodes to be reused by maintaining a list of available nodes, and getting nodes from this list or returning nodes to it.
Introduction to haskell
A simple introduction to Haskell during the 17/10/2015 Haskell ITA meetup in Bologna.
It shows basic Haskell concepts, currying and functors.
Python matplotlib cheat_sheet
Matplotlib is a Python library used for 2D plotting. It can create publication-quality figures in both hardcopy and interactive formats across platforms. The basic steps for creating plots with Matplotlib are: 1) prepare data, 2) create a plot, 3) add elements to the plot, 4) customize the plot, 5) save the plot, and 6) show the plot. Matplotlib provides various functions for plotting different types of data, customizing figures, axes, and layouts.
02 arrays
This document discusses arrays in C programming. It defines an array as a collection of variables of the same type that are referenced by a common name. It describes single-dimensional and multi-dimensional arrays. Single-dimensional arrays are comprised of finite, homogeneous elements while multi-dimensional arrays have elements that are themselves arrays. The document provides examples of declaring, initializing, accessing, and implementing arrays in memory for both single and double-dimensional arrays. It includes sample programs demonstrating various array operations.
Monoids, Monoids, Monoids - ScalaLove 2020
This document provides an overview of algebraic structures like monoids, lattices, groups, and rings. It discusses how these structures appear at both the value level and type level in Scala. At the value level, concepts like monoids, semigroups, and groups are demonstrated with examples. At the type level, product and sum types are shown to form monoids, and union/intersection types form lattices. Higher kinded type classes are used to abstract over these structures. Applications to data processing and error handling are also covered. In conclusion, algebraic structures provide useful abstractions both mathematically and in Scala's type system.
Scope
This document discusses variable scope in Swift, including:
1. Global scope variables are defined outside functions while local scope variables are defined within curly braces.
2. Variables defined within a function are not accessible outside that function.
3. Variable shadowing occurs when a variable with the same name is declared within the scope of another variable, hiding the outer variable.
Testing in the World of Functional Programming
This document summarizes a presentation about testing in functional programming. It discusses:
1. Property-based testing and how it can find bugs early by generating many test cases, including edge cases. However, it can be painful to write tests for complex functions interacting with external systems.
2. Mocking external dependencies to test internal logic, made possible through techniques like tagless final which separate interfaces from implementations. Complex interactions can be modeled with state machines.
3. Other FP testing techniques like newtypes, refined types, and libraries that make testing easier by restricting valid inputs. The presentation provides examples of testing parsing, network calls and database access in isolation.
Principled Error Handling with FP
This document discusses principled error handling in Scala programs. It introduces the MonadError type class for representing programs that can fail with errors. While useful, MonadError has limitations in representing error handling in the type system. The document proposes an ErrorControl type class that uses two type constructors to represent fallible and non-fallible program types. ErrorControl allows error handling to be represented more precisely in types. Several instances of ErrorControl are discussed, including for IO, StateT, and EitherT. In conclusion, error handling is challenging and the document explores some alternatives to representing it in programs.
C Programming : Arrays
This document provides information about arrays in C programming. It defines an array as a linear list of homogeneous elements stored in consecutive memory locations. It notes that arrays always start at index 0 and end at size-1. It describes one-dimensional and multi-dimensional arrays. For one-dimensional arrays, it provides examples of declaration, definition, accessing elements, and several programs for operations like input, output, finding the largest element, and linear search. For multi-dimensional arrays, it describes how they are represented and defined with multiple subscript variables. It also includes a program to add two matrices as an example of a two-dimensional array.
Monoids, monoids, monoids
This document provides an overview of algebraic structures like monoids, lattices, groups, and rings. It discusses how these concepts can be generalized to higher-kinded type classes in Scala. It also explores how Scala's type system relates to these structures, with sum and product types forming commutative rigs. Finally, it discusses how these structures can be useful for modeling parallelism, error handling, and other programming patterns in Scala.
Array notes
1) The document discusses arrays in C programming, including what arrays are, how to declare and initialize one-dimensional arrays, and how to perform common operations like reading, writing, summing, and finding largest elements in arrays.
2) Examples are provided to demonstrate how to write programs to read and display arrays, calculate sums of array elements, and determine other properties of arrays.
3) Key concepts covered include declaring arrays, initializing arrays, accessing array elements, looping through arrays, and performing calculations using the elements of arrays.
Pandas,scipy,numpy cheatsheet
ref: https://s3.amazonaws.com/quandl-static-content/Documents/Quandl+-+Pandas,+SciPy,+NumPy+Cheat+Sheet.pdf
2_Set_Builder_Notation_and_Sets_of_Real_Numbers
Students will learn about sets of real numbers using different notations. Roster notation lists all elements of a set, while set builder notation describes the properties elements must satisfy using symbols like ∈ and ∉. Examples show using set builder notation to define the set of real numbers greater than -4 and integers between -2 and 14. A graphic organizer is provided to classify types of real numbers into sets defined with standard notations like R, N, Z, Q, and I.
Coding test review2
The document contains summaries of two coding interview questions:
1) Given a sorted array of integers, write a function to return a sorted array containing the squares of the original integers. Two solutions are provided - one in O(nlogn) time and one in O(n) time.
2) Given two integer arrays a and b and a target value v, determine if there is a pair where one number is from a and one is from b that sum to v. Return True if such a pair exists, otherwise False. Two solutions are provided - one in O(n^2) time and one in O(n) time.
Fix this code so that it will run with proper answers, please dont u.pdf
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[.
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.
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.
Python programming workshop session 3
The document provides information about error handling in Python programming. It discusses different types of exceptions that may occur during program execution and how to handle them using try, except, else and finally blocks. It gives examples of programs that handle errors from inputting non-integer values or dividing by zero. The document also covers other Python programming concepts like lists, random numbers, and comparing Python to C/C++.
More Related Content
What's hot
Simple Neural Network Python Code
Here, we have a simple neural network described in my slides about neural networks... It is using simple concepts from linear algebra to encapsulate the complexities (This makes possible to even use parallel matrix multiplication and some other algorithms to make everything faster) and making everything more modular and compact.
The data sets are coming from http://yann.lecun.com/exdb/mnist/.
Print input-presentation
This document discusses input and print functions in Python. It explains that the print function displays information to the user and includes examples of printing different data types. It also explains that the input function accepts information from the user, stores it in a variable, and can include a prompt. Examples are provided of getting both string and numeric input and converting the input to other data types like integers. The document also covers simple formatting options for print like printing on new lines, adding separators, or printing on the same line.
Oh, All the things you'll traverse
This document summarizes a presentation about type classes in Scala. It introduces type classes like Monoid and Functor. It provides examples of Monoid instances for types like Int and Option. It explains how to define type classes for new types. It shows how to generalize functions like sequence and traverse to work for any Applicative functor using type classes. Finally, it discusses related concepts like Semigroup, Semigroupal functors, and NonEmptyList.
Pandas pythonfordatascience
The document provides an overview of the Pandas library in Python for working with data structures like Series and DataFrames. It covers common operations for selecting, filtering, sorting, applying functions, handling missing data, and reading/writing data to files and databases. These operations allow for easy manipulation and analysis of data in Pandas.
Polynomials
The document discusses representing polynomials using linked lists. Polynomials can be represented as singly linked lists by storing the coefficient and exponent of each term in a node. Adding polynomials involves traversing the lists and combining terms with matching exponents. Polynomials can also be represented using circular linked lists. This allows nodes to be reused by maintaining a list of available nodes, and getting nodes from this list or returning nodes to it.
Introduction to haskell
A simple introduction to Haskell during the 17/10/2015 Haskell ITA meetup in Bologna.
It shows basic Haskell concepts, currying and functors.
Python matplotlib cheat_sheet
Matplotlib is a Python library used for 2D plotting. It can create publication-quality figures in both hardcopy and interactive formats across platforms. The basic steps for creating plots with Matplotlib are: 1) prepare data, 2) create a plot, 3) add elements to the plot, 4) customize the plot, 5) save the plot, and 6) show the plot. Matplotlib provides various functions for plotting different types of data, customizing figures, axes, and layouts.
02 arrays
This document discusses arrays in C programming. It defines an array as a collection of variables of the same type that are referenced by a common name. It describes single-dimensional and multi-dimensional arrays. Single-dimensional arrays are comprised of finite, homogeneous elements while multi-dimensional arrays have elements that are themselves arrays. The document provides examples of declaring, initializing, accessing, and implementing arrays in memory for both single and double-dimensional arrays. It includes sample programs demonstrating various array operations.
Monoids, Monoids, Monoids - ScalaLove 2020
This document provides an overview of algebraic structures like monoids, lattices, groups, and rings. It discusses how these structures appear at both the value level and type level in Scala. At the value level, concepts like monoids, semigroups, and groups are demonstrated with examples. At the type level, product and sum types are shown to form monoids, and union/intersection types form lattices. Higher kinded type classes are used to abstract over these structures. Applications to data processing and error handling are also covered. In conclusion, algebraic structures provide useful abstractions both mathematically and in Scala's type system.
Scope
This document discusses variable scope in Swift, including:
1. Global scope variables are defined outside functions while local scope variables are defined within curly braces.
2. Variables defined within a function are not accessible outside that function.
3. Variable shadowing occurs when a variable with the same name is declared within the scope of another variable, hiding the outer variable.
Testing in the World of Functional Programming
This document summarizes a presentation about testing in functional programming. It discusses:
1. Property-based testing and how it can find bugs early by generating many test cases, including edge cases. However, it can be painful to write tests for complex functions interacting with external systems.
2. Mocking external dependencies to test internal logic, made possible through techniques like tagless final which separate interfaces from implementations. Complex interactions can be modeled with state machines.
3. Other FP testing techniques like newtypes, refined types, and libraries that make testing easier by restricting valid inputs. The presentation provides examples of testing parsing, network calls and database access in isolation.
Principled Error Handling with FP
This document discusses principled error handling in Scala programs. It introduces the MonadError type class for representing programs that can fail with errors. While useful, MonadError has limitations in representing error handling in the type system. The document proposes an ErrorControl type class that uses two type constructors to represent fallible and non-fallible program types. ErrorControl allows error handling to be represented more precisely in types. Several instances of ErrorControl are discussed, including for IO, StateT, and EitherT. In conclusion, error handling is challenging and the document explores some alternatives to representing it in programs.
C Programming : Arrays
This document provides information about arrays in C programming. It defines an array as a linear list of homogeneous elements stored in consecutive memory locations. It notes that arrays always start at index 0 and end at size-1. It describes one-dimensional and multi-dimensional arrays. For one-dimensional arrays, it provides examples of declaration, definition, accessing elements, and several programs for operations like input, output, finding the largest element, and linear search. For multi-dimensional arrays, it describes how they are represented and defined with multiple subscript variables. It also includes a program to add two matrices as an example of a two-dimensional array.
Monoids, monoids, monoids
This document provides an overview of algebraic structures like monoids, lattices, groups, and rings. It discusses how these concepts can be generalized to higher-kinded type classes in Scala. It also explores how Scala's type system relates to these structures, with sum and product types forming commutative rigs. Finally, it discusses how these structures can be useful for modeling parallelism, error handling, and other programming patterns in Scala.
Array notes
1) The document discusses arrays in C programming, including what arrays are, how to declare and initialize one-dimensional arrays, and how to perform common operations like reading, writing, summing, and finding largest elements in arrays.
2) Examples are provided to demonstrate how to write programs to read and display arrays, calculate sums of array elements, and determine other properties of arrays.
3) Key concepts covered include declaring arrays, initializing arrays, accessing array elements, looping through arrays, and performing calculations using the elements of arrays.
Pandas,scipy,numpy cheatsheet
ref: https://s3.amazonaws.com/quandl-static-content/Documents/Quandl+-+Pandas,+SciPy,+NumPy+Cheat+Sheet.pdf
2_Set_Builder_Notation_and_Sets_of_Real_Numbers
Students will learn about sets of real numbers using different notations. Roster notation lists all elements of a set, while set builder notation describes the properties elements must satisfy using symbols like ∈ and ∉. Examples show using set builder notation to define the set of real numbers greater than -4 and integers between -2 and 14. A graphic organizer is provided to classify types of real numbers into sets defined with standard notations like R, N, Z, Q, and I.
What's hot (17)
Similar to Coding test review 2
Coding test review2
The document contains summaries of two coding interview questions:
1) Given a sorted array of integers, write a function to return a sorted array containing the squares of the original integers. Two solutions are provided - one in O(nlogn) time and one in O(n) time.
2) Given two integer arrays a and b and a target value v, determine if there is a pair where one number is from a and one is from b that sum to v. Return True if such a pair exists, otherwise False. Two solutions are provided - one in O(n^2) time and one in O(n) time.
Fix this code so that it will run with proper answers, please dont u.pdf
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[.
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.
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.
Python programming workshop session 3
The document provides information about error handling in Python programming. It discusses different types of exceptions that may occur during program execution and how to handle them using try, except, else and finally blocks. It gives examples of programs that handle errors from inputting non-integer values or dividing by zero. The document also covers other Python programming concepts like lists, random numbers, and comparing Python to C/C++.
chapter1.ppt
This document discusses key concepts in algorithm analysis and design including algorithms, data types, specifications vs implementations, time and space complexity analysis, asymptotic notation, and examples. It defines an algorithm as a set of instructions to accomplish a task, and a data type as a collection of objects and operations on those objects. The document covers analyzing time complexity using counting steps and asymptotic notation such as Big O, Omega, and Theta. Examples of matrix and list functions and their analyses are provided.
Arrow 101 - Kotlin funcional com Arrow
Apresentação de introdução a uso do framework Arrow em Kotlin. Alguns conceitos sobre teoria da categoria e programação
Functional aspects of java 8
Slides of an old talk I given on Java8, at JUGBD. This is an introductory talk on the new functional aspects of Java 8.
Scala by Luc Duponcheel
Scala is a multi-paradigm programming language that supports functional, object-oriented and imperative programming paradigms. The document discusses Scala's support for types, expressions, objects, functions, and provides examples of using Scala for expressions, functions, control structures, patterns, spaces and actors.
Each team works on assigned sorting algorithms and will give demonstr.pdf
Each team works on assigned sorting algorithms and will give demonstration and PowerPoint
presentation on Nov. 16^th during lab class. Search internet for tutorials and source code in
python on sorting algorithms assigned to your team. Modify the python code to count the number
of comparisons and the number of swaps when sorting a random list of size n, n>=100, for
example, n = 100, 1000, 10000. To test your program use a small size of n for example, n = 10,
and print the list before and after sorting. Once confirmed the your program sorts correctly, try
larger size of n without print the list. In your presentation, explain how do the sorting algorithms
work and given their worst case and average case complexity, and include following table:
Submit the source code and presentation to D2L Assignment for Team Project 1 before
11:00PM. 11/16/2016 Sorting Algorithms: Selection sort, quick sort Insertion sort, shell sort
Bubble sort, merge sort Heap sort Radix sort
Solution
Selection Sort:
def selectionSort(list1):
for x in range(len(list1)-1,0,-1):
max_pos=0
for location in range(1,x+1):
if list1[location]>list1[max_pos]:
max_pos = location
temp = list1[x]
list1[x] = list1[max_pos]
list1[max_pos] = temp
list1 = [100,550,12,10,9]
selectionSort(list1)
print \"Sorted List\"
print(list1)
================================================
Output:
Sorted List
[9, 10, 12, 100, 550]
==================================================
Quck sort
def quickSort(list1):
quickSortHelper(list1,0,len(list1)-1)
def quickSortHelper(list1,left,right):
if left= pivot and r >= l:
r = r -1
if r < l:
done = True
else:
temp = list1[l]
list1[l] = list1[r]
list1[r] = temp
temp = list1[left]
list1[left] = list1[r]
list1[r] = temp
return r
list1 = [100,550,12,10,9]
quickSort(list1)
print(list1)
=============================================
Output:
[9, 10, 12, 100, 550]
=================================================
insertion sort:
def insertionSort(list1):
for i in range(1,len(list1)):
currentvalue = list1[i]
position = i
while position>0 and list1[position-1]>currentvalue:
list1[position]=list1[position-1]
position = position-1
list1[position]=currentvalue
list1 = [100,550,12,10,9]
insertionSort(list1)
print(list1)
===================================================
Output:
[9, 10, 12, 100, 550]
=================================================
Bubble sort:
def bubbleSort(list1):
for x in range(len(list1)-1,0,-1):
for i in range(x):
if list1[i]>list1[i+1]:
temp = list1[i]
list1[i] = list1[i+1]
list1[i+1] = temp
list1 = [100,550,12,10,9]
bubbleSort(list1)
print(list1)
======================================
Output:
[9, 10, 12, 100, 550]
====================================
def mergeSort(list1):
print(\"Splitting list \",list1)
if len(list1)>1:
mid = len(list1)//2
lefthalf = list1[:mid]
righthalf = list1[mid:]
mergeSort(lefthalf)
mergeSort(righthalf)
i=0
j=0
k=0
while i < len(lefthalf) and j < len(righthalf):
if lefthalf[i] < righthalf[j]:
list1[k]=lefthalf[i]
i=i+1
else:
lis.
The Ring programming language version 1.7 book - Part 37 of 196
The document provides examples of using various functions in Ring to add, get, and modify methods and attributes of objects. It demonstrates how to add methods to classes using addmethod(), get attribute values using getattribute(), set attribute values using setattribute(), share methods between classes using mergemethods(), and get the package name of the latest import using packagename(). Examples are given for each function to illustrate their usage.
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.
07012023.pptx
The document discusses various operations that can be performed on sets in Python like adding, removing, and checking for elements. It provides examples of using common set methods such as add(), remove(), pop(), clear(), len(), in, issubset(), issuperset(), copy(), isdisjoint(), all(), any(), enumerate(), max(), min(), sum(), sorted() and comparing sets using == and != operators. It emphasizes that sets are unordered and do not allow indexing or slicing as they are immutable.
Basic_analysis.ppt
This document discusses algorithms and data structures. It begins by defining an algorithm as a set of instructions to accomplish a task and lists criteria such as being unambiguous and terminating. Data types and abstract data types are introduced. Methods for analyzing programs are covered, including time and space complexity using asymptotic notation. Examples are provided to illustrate iterative and recursive algorithms for summing lists as well as matrix operations.
chapter1.ppt
This document discusses fundamental concepts in data structures and algorithms including:
1) How to design algorithms by analyzing requirements, designing data objects and operations, and refining and coding programs.
2) Key criteria for algorithms including being unambiguous, terminating in a finite number of steps, and having basic instructions.
3) Abstract data types which separate the specification of objects and operations from their implementation.
4) Asymptotic analysis which classifies algorithms according to how their running time grows relative to the input size.
chapter1.ppt
This document discusses fundamental concepts in data structures and algorithms including:
1) How to design algorithms by analyzing requirements, designing data objects and operations, and refining and coding programs.
2) Key criteria for algorithms including being input/output defined, unambiguous, and able to terminate in a finite number of steps.
3) How abstract data types specify objects and operations separately from implementation.
4) Examples of analyzing time and space complexity for different algorithms including iterative and recursive solutions.
5) Common asymptotic notations like O(1), O(n), O(n^2), and O(nlogn) and how they describe an algorithm's growth rate.
Functional programming with haskell
This document provides an overview of functional programming with Haskell. It discusses key concepts of functional programming like immutable data structures and pure functions. It introduces Haskell types including basic types, tuples, lists, data types, and type classes. It covers Haskell functions like pattern matching, guards, and higher order functions. It also discusses Haskell concepts like laziness, currying, and polymorphism. Finally, it provides an introduction to monads in Haskell and discusses Haskell tools, frameworks, and performance.
Similar to Coding test review 2 (17)
Fix this code so that it will run with proper answers, please dont u.pdf
Fix this code so that it will run with proper answers, please dont u.pdf
Will upvote asapPlease help my code gives me incorrect val.pdf
Will upvote asapPlease help my code gives me incorrect val.pdf
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 o.pdf
Each team works on assigned sorting algorithms and will give demonstr.pdf
Each team works on assigned sorting algorithms and will give demonstr.pdf
The Ring programming language version 1.7 book - Part 37 of 196
The Ring programming language version 1.7 book - Part 37 of 196
python3 HashTableSolutionmain.pyfrom ChainingHashTable impor.pdf
python3 HashTableSolutionmain.pyfrom ChainingHashTable impor.pdf
More from SEMINARGROOT
Metric based meta_learning
The document discusses metric-based few-shot learning approaches. It introduces Matching Networks, which use an attention mechanism to calculate similarity between support and query embeddings. Prototypical Networks determine class membership for a query based on distance to prototype representations of each class. Relation Networks concatenate support and query embeddings and pass them through a relation module to predict relations as classification scores. The approaches aim to learn from few examples by leveraging metric learning in an embedding space.
Sampling method : MCMC
Main obstacles of Bayesian statistics or Bayesian machine learning is computing posterior distribution. In many contexts, computing posterior distribution is intractable. Today, there are two main stream to detour directly computing posterior distribution. One is using sampling method(ex. MCMC) and another is Variational inference. Compared to Variational inference, MCMC takes more time and vulnerable to high-dimensional parameters. However, MCMC has strength in simplicity and guarantees of convergence. I'll briefly introduce several methods people using in application.
Demystifying Neural Style Transfer
Texture synthesis aims to produce new texture samples from an example that are similar but not repetitive. It analyzes the example using a CNN to compute gram matrices representing the texture at different layers, then synthesizes new textures by passing noise through the CNN and minimizing differences from the example's gram matrices. Style transfer extends this to merge the texture of one image onto the content of another by matching gram matrices between layers to transfer style while preserving content. It has been shown that style and content are separable in CNN representations. Style transfer can be viewed as a type of domain adaptation between content and style domains.
Towards Deep Learning Models Resistant to Adversarial Attacks.
This document discusses approaches to training deep neural networks to be robust against adversarial examples. It frames adversarial robustness as a minimax game between the network and an attacker. It presents projected gradient descent (PGD) and the Fast Gradient Sign Method (FGSM) as ways to solve the inner maximization problem during training. Experiments show that adversarially trained models can achieve increased robustness compared to standard networks.
The ways of node embedding
Node embedding techniques learn vector representations of nodes in a graph that can be used for downstream machine learning tasks like classification, clustering, and link prediction. DeepWalk uses random walks to generate sequences of nodes that are treated similarly to sentences, and learns embeddings by predicting nodes using their neighbors, like word2vec. It does not incorporate node features or labels. Node2vec extends DeepWalk by introducing a biased random walk to learn embeddings, addressing some limitations of DeepWalk while maintaining scalability.
Graph Convolutional Network
This document discusses graph convolutional networks (GCNs), which are neural network models for graph-structured data. GCNs aim to learn functions on graphs by preserving the graph's spatial structure and enabling weight sharing. The document outlines the basic components of a GCN, including the adjacency matrix, node features, and application of deep neural network layers. It also notes some challenges with applying convolutions to graphs and discusses approaches like using the graph Fourier transform based on the Laplacian matrix.
Denoising With Frequency Domain
The document discusses different methods for denoising images in the spatial and frequency domains. It introduces spatial domain denoising techniques like mean filtering, median filtering, and adaptive filtering. It then explains how spatial domain images can be transformed into the frequency domain using Fourier and wavelet transforms. This allows denoising based on frequency content, where high frequencies associated with noise can be removed. It concludes by mentioning the CVPR Denoising Workshop as a resource.
Coding Test Review 3
The document contains code snippets and explanations for solving three LeetCode problems: Power of Two, Valid Parentheses, and Find Minimum in Rotated Sorted Array. For Power of Two, it provides an O(log n) solution that uses modulo and division to check if a number is a power of two. For Valid Parentheses, it provides an O(n) solution that uses a string to track opening and closing parentheses. For Find Minimum, it provides both an O(n) solution that finds the minimum by checking if each number is less than the previous, and an O(log n) solution that recursively searches halves of the array to find the minimum.
Time Series Analysis - ARMA
This document provides an overview of time series models and concepts. It discusses stochastic processes, stationarity, the Wold decomposition, impulse response analysis, and ARMA processes. The key points are:
1) Time series models are used to identify shocks and responses over time from stochastic processes.
2) Stationarity assumptions are needed to estimate expectations and variances from time series data using the concept that these values are time-invariant.
3) The Wold decomposition represents a stationary process as the sum of a deterministic component and stochastic prediction errors/shocks.
4) Impulse response analysis examines how past shocks continue to impact the present and future through their effect over time which decays as time
Differential Geometry for Machine Learning
References:
Differential Geometry of Curves and Surfaces, Manfredo P. Do Carmo (2016)
Differential Geometry by Claudio Arezzo
Youtube: https://youtu.be/tKnBj7B2PSg
What is a Manifold?
Youtube: https://youtu.be/CEXSSz0gZI4
Shape analysis (MIT spring 2019) by Justin Solomon
Youtube: https://youtu.be/GEljqHZb30c
Tensor Calculus
Youtube: https://youtu.be/kGXr1SF3WmA
Manifolds: A Gentle Introduction,
Hyperbolic Geometry and Poincaré Embeddings by Brian Keng
Link: http://bjlkeng.github.io/posts/manifolds/,
http://bjlkeng.github.io/posts/hyperbolic-geometry-and-poincare-embeddings/
Statistical Learning models for Manifold-Valued measurements with application to computer vision and neuroimaging by Hyunwoo J.Kim
Generative models : VAE and GAN
This document summarizes generative models like VAEs and GANs. It begins with an introduction to information theory, defining key concepts like entropy and maximum likelihood estimation. It then explains generative models as estimating the joint distribution P(X,Y) compared to discriminative models estimating P(Y|X). VAEs are discussed as maximizing the evidence lower bound (ELBO) to estimate the latent variable distribution P(Z|X), allowing generation of new X values. GANs are also covered, defining their minimax game between a generator G and discriminator D, with G learning to generate samples resembling the real data distribution Pemp.
Understanding Blackbox Prediction via Influence Functions
Pang Wei Koh and Percy Liang
"Understanding Black-Box prediction via influence functions" ICML 2017 Best paper
References:
https://youtu.be/0w9fLX_T6tY
https://arxiv.org/abs/1703.04730
Attention Is All You Need
Attention Is All You Need (NIPS 2017)
(Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, Illia Polosukhin)
paper link: https://arxiv.org/pdf/1706.03762.pdf
Reference:
https://youtu.be/mxGCEWOxfe8 (by Minsuk Heo)
https://youtu.be/5vcj8kSwBCY (Stanford CS224N: NLP with Deep Learning | Winter 2019 | Lecture 14 – Transformers and Self-Attention)
Attention
The document discusses different types of attention mechanisms used in neural machine translation and image captioning models. It describes global attention which considers all encoder hidden states when deriving context vectors, and local attention which selectively focuses on a small window of context. Hard attention selects a single location to focus on, while soft attention takes a weighted average over locations. The document also discusses input feeding which makes the model aware of previous alignment choices.
WWW 2020 XAI Tutorial Review
This document is a tutorial on explainable AI from the WWW 2020 conference. It introduces explainable AI and discusses explanations from both a model and regulatory perspective. It then explores different methods for explaining individual predictions, global models, and building interpretable models. The remainder of the tutorial provides case studies on explaining diabetic retinopathy predictions, building an explainable AI engine for talent search, and using model interpretations for sales predictions. References are also included.
Locality sensitive hashing
This document summarizes the key steps in the locality sensitive hashing (LSH) algorithm for finding similar documents:
1. Documents are converted to sets of shingles (sequences of tokens) to represent them as high-dimensional data points.
2. MinHashing is applied to generate signatures (hashes) for each document such that similar documents are likely to have the same signatures. This compresses the data into a signature matrix.
3. LSH uses the signature matrix to hash similar documents into the same buckets with high probability, finding candidate pairs for further similarity evaluation and filtering out dissimilar pairs from consideration. This improves the computation efficiency over directly comparing all pairs.
Strong convexity on gradient descent and newton's method
Gradient descent is an optimization algorithm used to find local minima of differentiable functions. It works by taking steps in the negative direction of the gradient of the function at the current point. Newton's method approximates the function using a second-order Taylor expansion and finds the minimum of the quadratic approximation to determine the next step. The gradient descent step size can be shown to decrease the function value when the function is strongly convex or satisfies the Lipschitz condition.
SVM (Support Vector Machine & Kernel)
Based on MIT 6.034 Artificial Intelligence, Fall 2010
Instructor: Patrick Winston
video link: https://youtu.be/_PwhiWxHK8o
More from SEMINARGROOT (20)
Towards Deep Learning Models Resistant to Adversarial Attacks.
Towards Deep Learning Models Resistant to Adversarial Attacks.
Understanding Blackbox Prediction via Influence Functions
Understanding Blackbox Prediction via Influence Functions
Strong convexity on gradient descent and newton's method
Strong convexity on gradient descent and newton's method
Recently uploaded
South Mumbai @Call @Girls Whatsapp 9930687706 With High Profile Service
South Mumbai @Call @Girls Whatsapp 9930687706 With High Profile Service
PMSM-Motor-Control : A research about FOC
This is research about a process called field-oriented control (FOC) that is used to control the pmsm motor.
Coroutines Flow & Channels Workshop Slides
Coroutines Flow & Channels Workshop Slides at Tapsell
YouTube:
https://www.youtube.com/watch?v=SAVRGpgIgXE
Source Code:
https://github.com/MortezaNedaei/Kotlin-Coroutines-Workshop
Unblocking The Main Thread - Solving ANRs and Frozen Frames
In the realm of Android development, the main thread is our stage, but too often, it becomes a battleground where performance issues arise, leading to ANRS, frozen frames, and sluggish Uls. As we strive for excellence in user experience, understanding and optimizing the main thread becomes essential to prevent these common perforrmance bottlenecks. We have strategies and best practices for keeping the main thread uncluttered. We'll examine the root causes of performance issues and techniques for monitoring and improving main thread health as wel as app performance. In this talk, participants will walk away with practical knowledge on enhancing app performance by mastering the main thread. We'll share proven approaches to eliminate real-life ANRS and frozen frames to build apps that deliver butter smooth experience.
Response & Safe AI at Summer School of AI at IIITH
Talk covering Guardrails , Jailbreak, What is an alignment problem? RLHF, EU AI Act, Machine & Graph unlearning, Bias, Inconsistency, Probing, Interpretability, Bias
( Call ) Girls Vasant Kunj Just 9873940964 High Class Model Shneha Patil
( Call ) Girls Vasant Kunj Just 9873940964 High Class Model Shneha Patil
一比一原版(UQ毕业证书)昆士兰大学毕业证如何办理
原件一模一样【微信：WP101A】【(UQ毕业证书)昆士兰大学毕业证书学位证成绩单】【微信：WP101A】（留信学历认证永久存档查询）采用学校原版纸张、特殊工艺完全按照原版一比一制作（包括：隐形水印，阴影底纹，钢印LOGO烫金烫银，LOGO烫金烫银复合重叠，文字图案浮雕，激光镭射，紫外荧光，温感，复印防伪）行业标杆！精益求精，诚心合作，真诚制作！多年品质 ,按需精细制作，24小时接单,全套进口原装设备，十五年致力于帮助留学生解决难题，业务范围有加拿大、英国、澳洲、韩国、美国、新加坡，新西兰等学历材料，包您满意。
【业务选择办理准则】
一、工作未确定，回国需先给父母、亲戚朋友看下文凭的情况，办理一份就读学校的毕业证【微信：WP101A】文凭即可
二、回国进私企、外企、自己做生意的情况，这些单位是不查询毕业证真伪的，而且国内没有渠道去查询国外文凭的真假，也不需要提供真实教育部认证。鉴于此，办理一份毕业证【微信：WP101A】即可
三、进国企，银行，事业单位，考公务员等等，这些单位是必需要提供真实教育部认证的，办理教育部认证所需资料众多且烦琐，所有材料您都必须提供原件，我们凭借丰富的经验，快捷的绿色通道帮您快速整合材料，让您少走弯路。
留信网认证的作用:
1:该专业认证可证明留学生真实身份【微信：WP101A】
2:同时对留学生所学专业登记给予评定
3:国家专业人才认证中心颁发入库证书
4:这个认证书并且可以归档倒地方
5:凡事获得留信网入网的信息将会逐步更新到个人身份内，将在公安局网内查询个人身份证信息后，同步读取人才网入库信息
6:个人职称评审加20分
7:个人信誉贷款加10分
8:在国家人才网主办的国家网络招聘大会中纳入资料，供国家高端企业选择人才
→ 【关于价格问题（保证一手价格）
我们所定的价格是非常合理的，而且我们现在做得单子大多数都是代理和回头客户介绍的所以一般现在有新的单子 我给客户的都是第一手的代理价格，因为我想坦诚对待大家 不想跟大家在价格方面浪费时间
对于老客户或者被老客户介绍过来的朋友，我们都会适当给一些优惠。
选择实体注册公司办理，更放心，更安全！我们的承诺：可来公司面谈，可签订合同，会陪同客户一起到教育部认证窗口递交认证材料，客户在教育部官方认证查询网站查询到认证通过结果后付款，不成功不收费！
办理(UQ毕业证书)昆士兰大学毕业证学位证）学位证【微信：WP101A 】外观非常精致，由特殊纸质材料制成，上面印有校徽、校名、毕业生姓名、专业等信息。
办理(UQ毕业证书)昆士兰大学毕业证学位证）学位证【微信：WP101A 】格式相对统一，各专业都有相应的模板。通常包括以下部分：
校徽：象征着学校的荣誉和传承。
校名:学校英文全称
授予学位：本部分将注明获得的具体学位名称。
毕业生姓名：这是最重要的信息之一，标志着该证书是由特定人员获得的。
颁发日期：这是毕业正式生效的时间，也代表着毕业生学业的结束。
其他信息：根据不同的专业和学位，可能会有一些特定的信息或章节。
办理(UQ毕业证书)昆士兰大学毕业证学位证）学位证【微信：WP101A 】价值很高，需要妥善保管。一般来说，应放置在安全、干燥、防潮的地方，避免长时间暴露在阳光下。如需使用，最好使用复印件而不是原件，以免丢失。
综上所述，办理(UQ毕业证书)昆士兰大学毕业证学位证）学位证【微信：WP101A 】是证明身份和学历的高价值文件。外观简单庄重，格式统一，包括重要的个人信息和发布日期。对持有人来说，妥善保管是非常重要的。
@Call @Girls Rajkot 0000000000 Priya Sharma Beautiful And Cute Girl any Time
@Call @Girls Rajkot 0000000000 Priya Sharma Beautiful And Cute Girl any Time
For Ad Post Contact :- adityaroy0215@gmail.com
Social media management system project report.pdf
The project "Social Media Platform in Object-Oriented Modeling" aims to design
and model a robust and scalable social media platform using object-oriented
modeling principles. In the age of digital communication, social media platforms
have become indispensable for connecting people, sharing content, and fostering
online communities. However, their complex nature requires meticulous planning
and organization.This project addresses the challenge of creating a feature-rich and
user-friendly social media platform by applying key object-oriented modeling
concepts. It entails the identification and definition of essential objects such as
"User," "Post," "Comment," and "Notification," each encapsulating specific
attributes and behaviors. Relationships between these objects, such as friendships,
content interactions, and notifications, are meticulously established.The project
emphasizes encapsulation to maintain data integrity, inheritance for shared behaviors
among objects, and polymorphism for flexible content handling. Use case diagrams
depict user interactions, while sequence diagrams showcase the flow of interactions
during critical scenarios. Class diagrams provide an overarching view of the system's
architecture, including classes, attributes, and methods .By undertaking this project,
we aim to create a modular, maintainable, and user-centric social media platform that
adheres to best practices in object-oriented modeling. Such a platform will offer users
a seamless and secure online social experience while facilitating future enhancements
and adaptability to changing user needs.
FD FAN.pdf forced draft fan for boiler operation and run its very important f...
FD fan or forced draft fan, draws air from the atmosphere and forces it into the furnace through a preheater. These fans are located at the inlet of the boiler to push high pressure fresh air into combustion chamber, where it mixes with the fuel to produce positive pressure. and A forced draft fan (FD fan) is a fan that is used to push air into a boiler or other combustion chamber. It is located at the inlet of the boiler and creates a positive pressure in the combustion chamber, which helps to ensure that the fuel burns properly.
The working principle of a forced draft fan is based on the Bernoulli principle, which states that the pressure of a fluid decreases as its velocity increases. The fan blades rotate and impart momentum to the air, which causes the air to accelerate. This acceleration of the air creates a lower pressure at the outlet of the fan, which draws air in from the inlet.
The amount of air that is pushed into the boiler by the FD fan is determined by the fan’s capacity and the pressure differential between the inlet and outlet of the fan. The fan’s capacity is the amount of air that it can move per unit of time, and the pressure differential is the difference in pressure between the inlet and outlet of the fan.
The FD fan is an essential component of any boiler system. It helps to ensure that the fuel burns properly and that the boiler operates efficiently.
Here are some of the benefits of using a forced draft fan:Improved combustion efficiency: The FD fan helps to ensure that the fuel burns completely, which results in improved combustion efficiency.
Reduced emissions: The FD fan helps to reduce emissions by ensuring that the fuel burns completely.
Increased boiler capacity: The FD fan can increase the capacity of the boiler by providing more air for combustion.
Improved safety: The FD fan helps to improve safety by preventing the buildup of flammable gases in the boiler.
Forced Draft Fan ( Full form of FD Fan) is a type of fan supplying pressurized air to a system. In the case of a Steam Boiler Assembly, this FD fan is of great importance. The Forced Draft Fan (FD Fan) plays a crucial role in supplying the necessary combustion air to the steam boiler assembly, ensuring efficient and optimal combustion processes. Its pressurized airflow promotes the complete and controlled burning of fuel, enhancing the overall performance of the system.What is the FD fan in a boiler?
In a boiler system, the FD fan, or Forced Draft Fan, plays a crucial role in ensuring efficient combustion and proper air circulation within the boiler. Its primary function is to supply the combustion air needed for the combustion process.
The FD fan works by drawing in ambient air and then forcing it into the combustion chamber, creating the necessary air-fuel mixture for the combustion process. This controlled air supply ensures that the fuel burns efficiently, leading to optimal heat transfer and energy production.
In summary, the FD fan i
DESIGN OF BEARINGS ANJANEYULU bridge bearing
Precast bridge construction method. ...
Cast in-situ bridge construction method. ...
Balanced cantilever bridge construction method. ...
Incremental Launching bridge construction method. ...
Cable-stayed bridge construction method. ...
Bearing
Net Zero Case Study: SRK House and SRK Empire
In May 2024, globally renowned natural diamond crafting company Shree Ramkrishna Exports Pvt. Ltd. (SRK) became the first company in the world to achieve GNFZ’s final net zero certification for existing buildings, for its two two flagship crafting facilities SRK House and SRK Empire. Initially targeting 2030 to reach net zero, SRK joined forces with the Global Network for Zero (GNFZ) to accelerate its target to 2024 — a trailblazing achievement toward emissions elimination.
Application Infrastructure and cloud computing.pdf
Basic Application Infrastructure and cloud computing.pdf
Analysis and Design of Algorithm Lab Manual (BCSL404)
Analysis and Design of Algorithm Lab Manual (BCSL404)
Recently uploaded (20)
South Mumbai @Call @Girls Whatsapp 9930687706 With High Profile Service
South Mumbai @Call @Girls Whatsapp 9930687706 With High Profile Service
Unblocking The Main Thread - Solving ANRs and Frozen Frames
Unblocking The Main Thread - Solving ANRs and Frozen Frames
Response & Safe AI at Summer School of AI at IIITH
Response & Safe AI at Summer School of AI at IIITH
( Call ) Girls Vasant Kunj Just 9873940964 High Class Model Shneha Patil
( Call ) Girls Vasant Kunj Just 9873940964 High Class Model Shneha Patil
@Call @Girls Rajkot 0000000000 Priya Sharma Beautiful And Cute Girl any Time
@Call @Girls Rajkot 0000000000 Priya Sharma Beautiful And Cute Girl any Time
FD FAN.pdf forced draft fan for boiler operation and run its very important f...
FD FAN.pdf forced draft fan for boiler operation and run its very important f...
Application Infrastructure and cloud computing.pdf
Application Infrastructure and cloud computing.pdf
Analysis and Design of Algorithm Lab Manual (BCSL404)
Analysis and Design of Algorithm Lab Manual (BCSL404)
Coding test review 2
- 2. LeetCode – Single Number (Easy)
- 3. 𝑂(𝑛) 𝑠𝑜𝑙𝑢𝑡𝑖𝑜𝑛 class Solution: def singleNumber(self, nums: List[int]) -> int: dup_check = {} for _ in range(len(nums)): num = nums.pop(0) if num in dup_check: dup_check.pop(num, None) else: dup_check[num] = num return list(dup_check.keys())[0]
- 4. 𝑂 𝑛 𝑠𝑜𝑙𝑢𝑡𝑖𝑜𝑛 − 𝑚𝑎𝑡ℎ class Solution(object): def singleNumber(self, nums): return 2 * sum(set(nums)) - sum(nums)
- 5. Apple – Product of Array Except Self (Medium)
- 6. 𝑂 𝑛 𝑠𝑜𝑙𝑢𝑡𝑖𝑜𝑛 class Solution: def productExceptSelf(self, nums: List[int]) -> List[int]: product_arr = 1 count_zero = 0 for num in nums: if num != 0: product_arr = product_arr * num else: count_zero += 1 if count_zero == 0: for idx, num in enumerate(nums): nums[idx] = int(product_arr/num) elif count_zero == 1: for idx, num in enumerate(nums): if num != 0: nums[idx] = 0 else: nums[idx] = product_arr else: for idx, num in enumerate(nums): nums[idx] = 0 return nums
- 7. 𝑂 𝑛 𝑠𝑜𝑙𝑢𝑡𝑖𝑜𝑛 − 𝑤/𝑜 𝑑𝑖𝑣𝑖𝑠𝑖𝑜𝑛 class Solution: def productExceptSelf(self, nums: List[int]) -> List[int]: n = len(nums) left = [1] * n right = [1] * n for idx in range(n): if idx == 0: left[idx] = 1 right[-(idx + 1)] = 1 else: left[idx] = left[idx - 1] * nums[idx - 1] right[-(idx + 1)] = right[-(idx)] * nums[-(idx)] for idx in range(n): nums[idx] = left[idx] * right[idx] return nums
- 8. Thank You