Loading...
More TypeScript Posts
// This function takes a matrix and outputs 4 equal size submatrices, starting from top left going to bottom right.const split = (matrix: number[][]): number[][][] => {const n: number = matrix.lengthconst mid: number = n/2const C11: number[][] = new Array<Array<number>> // first n/2 rows intersection first n/2 colummsconst C12: number[][] = new Array<Array<number>> // first n/2 rows intersection last n/2 columnsconst C21: number[][] = new Array<Array<number>> // last n/2 rows intersection first n/2 columnsconst C22: number[][] = new Array<Array<number>> // last n/2 rows intersection last n/2 columnsfor(let i: number = 0; i < mid; i++) {C11.push([])C12.push([])for (let j: number = 0; j < mid; j++) {C11[i].push(matrix[i][j])}for (let j: number = mid; j < n; j++) {C12[i].push(matrix[i][j])}}for(let i: number = 0; i < mid; i++) {C21.push([])C22.push([])for (let j: number = 0; j < mid; j++) {C21[i].push(matrix[i+mid][j])}for (let j: number = mid; j < n; j++) {C22[i].push(matrix[i+mid][j])}}return [C11, C12, C21, C22]}// This function takes 4 matrices, in order from top left to bottom right, and combines them into one matrixconst combine = (A: number[][], B: number[][], C: number[][], D: number[][]): number[][] => {const n: number = A.length*2const combo: number[][] = new Array<Array<number>>// Populate combo with temporary 0sfor(let i: number = 0; i < A.length; i++) {combo.push([])for (let j: number = 0; j < A.length; j++) {combo[i].push(A[i][j])}for (let j: number = A.length; j < n; j++) {combo[i].push(B[i][j-A.length])}}for(let i: number = A.length; i < n; i++) {combo.push([])for (let j: number = 0; j < A.length; j++) {combo[i].push(C[i-A.length][j])}for (let j: number = A.length; j < n; j++) {combo[i].push(D[i-A.length][j-A.length])}}return combo}// Basic matrix addition functionconst matrix_add = (A: number[][], B: number[][]): number[][] => {const matrix_sum: number[][] = [[]]const n: number = A.lengthfor(let i: number = 0; i < n; i++) {matrix_sum[i] = []for (let j: number = 0; j < n; j++) {matrix_sum[i][j] = A[i][j] + B[i][j]}}return matrix_sum}// Basic matrix subtraction functionconst matrix_subtract = (A: number[][], B: number[][]): number[][] => {const matrix_diff: number[][] = [[]]const n: number = A.lengthfor(let i: number = 0; i < n; i++) {matrix_diff[i] = []for (let j: number = 0; j < n; j++) {matrix_diff[i][j] = A[i][j] - B[i][j]}}return matrix_diff}const strassen = (A: number[][], B: number[][]): number[][] => {const n: number = A.lengthvar C: number[][] = [[]]// Populate C with temporary 0sfor(let i: number = 0; i < n; i++) {C[i] = []for (let j: number = 0; j < n; j++) {C[i][j] = 0}}// Once the matrices reach a small enough size, compute using the brute force methodif (n <= 2) {for (let i: number = 0; i < n; i++) {for (let j: number = 0; j < n; j++) {for (let z: number = 0; z < n; z++) {C[i][j] = C[i][j] + (A[i][z]*B[z][j])}}}return C}// Create independent variables from function that returns an array with array destructuring.const [a, b, c, d] = split(A)const [e, f, g, h] = split(B)// Using Strassen's method to calculate 1 less productconst p1: number[][] = strassen(matrix_add(a, d), matrix_add(e,h))const p2: number[][] = strassen(d, matrix_subtract(g, e))const p3: number[][] = strassen(matrix_add(a, b), h)const p4: number[][] = strassen(matrix_subtract(b, d), matrix_add(g, h))const p5: number[][] = strassen(a, matrix_subtract(f, h))const p6: number[][] = strassen(matrix_add(c, d), e)const p7: number[][] = strassen(matrix_subtract(a, c), matrix_add(e, f))const C11: number[][] = matrix_add(matrix_subtract(matrix_add(p1, p2), p3), p4)const C12: number[][] = matrix_add(p5, p3)const C21: number[][] = matrix_add(p6, p2)const C22: number[][] = matrix_subtract(matrix_subtract(matrix_add(p5, p1), p6), p7)C = combine(C11, C12, C21, C22)return C}const M1: number[][] = [[1,3],[7,5]]const M2: number[][] = [[6,8],[4,2]]const M_Product: number[][] = strassen(M1, M2)console.log("Matrix 1:")console.log(M1)console.log("Matrix 2:")console.log(M2)console.log("Product: ")console.log(M_Product)
class DFS{public dfs(G: DFSGraph, startVert: number){let visited: boolean[] = Array<boolean>();// Pre-populate array:for(let i = 0; i < G.size; i++){visited.push(false);}let s: number[] = new Array();visited[startVert] = true;s.push(startVert);while(s.length > 0){const v = s.pop();for(let adjV of G.adj[v]){if(!visited[adjV]){visited[adjV] = true;s.push(adjV);}}}}public dfsRecursive(G: DFSGraph, startVert: number){let visited: boolean[] = Array<boolean>();// Pre-populate array:for(let i = 0; i < G.size; i++){visited.push(false);}this.dfsAux(G, startVert, visited);}private dfsAux(G: DFSGraph, v: number, visited: boolean[]){visited[v] = true;for(let adjV of G.adj[v]){if(!visited[adjV]){// this.foo(); // Something can happen before the visit.this.dfsAux(G, adjV, visited);// this.bar(); // Something can happen after the visit.}}}}
//Retries maxRetries number of times, meaning that if you have 0, then it'll run the function once.async function retryPromise<T>(promiseFn: () => Promise<T>,maxRetries = 3,delayOffset = 0,delayRandomRange = 0): Promise<T> {return new Promise<T>((resolve, reject) => {promiseFn().then(resolve, (error: any) => { //On errorif (maxRetries <= 0) {return reject(error);} else {if(delayRandomRange * Math.random() + delayOffset < 1.0){return retryPromise(promiseFn, maxRetries - 1, delayOffset, delayRandomRange).then(resolve, reject);}else{return new Promise<T>((resolveTwo, rejectTwo) => {setTimeout(() => {return retryPromise(promiseFn, maxRetries - 1, delayOffset, delayRandomRange).then(resolveTwo, rejectTwo);}, delayRandomRange * Math.random() + delayOffset);}).then(resolve, reject);}}});});}//Returns a function that will fail numTimes times, then will return aValuefunction functionThatReturnsAFunctionThatFailsACoupleTimes(numTimes: number, aValue: any): () => Promise<any> {return async function(){if(numTimes == 0){return aValue;}numTimes--;throw false;};}const SMALL_NUMBER = 10;function testTest(failNumberOfTimes: number){let functionThatFailsACoupleTimes = functionThatReturnsAFunctionThatFailsACoupleTimes(failNumberOfTimes, true);//Test my testfor(let i = 0; i < (failNumberOfTimes * 2); ++i){function evalTest(val: any){let testTestFailedReason = "";if(val === undefined){testTestFailedReason = "Test test returned undefined for some reason.";}if((i + 1) > failNumberOfTimes){if(val === true){//We're good}else{testTestFailedReason = "Test test didn't return true when it should have.";}}else{if(val === false){//We're good}else{testTestFailedReason = "Test test didn't return false when it should have.";}}testTestFailedReason = testTestFailedReason || "Test test passed test case";console.log(testTestFailedReason, "at index", i, "where the function returned", val);}functionThatFailsACoupleTimes().then(evalTest, evalTest)};}testTest(SMALL_NUMBER);let testCaseCounter = 1;const throwsNoError = [(val: any) => {if(val == true){console.log("Passed test case " + testCaseCounter++);}else{console.error("Unexpected return value", val);}},() => {console.error("It wasn't supposed to fail!")}]const throwsError = [(val: any) => {console.error("It wasn't supposed to succeed!", val);},(val: any) => {if(val == false){console.log("Passed test case " + testCaseCounter++);}else{console.error("Unexpected return value", val);}}];//Runs SMALL_NUMBER times, because SMALL_NUMBER - 1 is the number of retries after the first onelet functionThatFailsACoupleTimes = functionThatReturnsAFunctionThatFailsACoupleTimes(SMALL_NUMBER - 1, true);retryPromise(functionThatFailsACoupleTimes, SMALL_NUMBER - 1).then(...throwsNoError)functionThatFailsACoupleTimes = functionThatReturnsAFunctionThatFailsACoupleTimes(SMALL_NUMBER - 1, true);//Runs SMALL_NUMBER - 1 times, because SMALL_NUMBER - 2 is the number of retries after the first oneretryPromise(functionThatFailsACoupleTimes, SMALL_NUMBER - 2).then(...throwsError)//Testing the delay. You'll have to wait a bit too.functionThatFailsACoupleTimes = functionThatReturnsAFunctionThatFailsACoupleTimes(SMALL_NUMBER - 1, true);//Runs SMALL_NUMBER times, because SMALL_NUMBER - 1 is the number of retries after the first oneretryPromise(functionThatFailsACoupleTimes, SMALL_NUMBER - 1, 500, 500).then(...throwsNoError)functionThatFailsACoupleTimes = functionThatReturnsAFunctionThatFailsACoupleTimes(SMALL_NUMBER - 1, true);//Runs SMALL_NUMBER - 1 times, because SMALL_NUMBER - 2 is the number of retries after the first oneretryPromise(functionThatFailsACoupleTimes, SMALL_NUMBER - 2, 500, 500).then(...throwsError)
const getFollowers = async (req: Request, res: Response) => {try {const username = req.params.username || '';const user = await User.findUnique({where: { username },include: { followedBy: true },});if (!user) {res.status(404).json({error: 'User could not be found',});return;}const followers = user.followedBy.map(followedBy => {return {followerId: followedBy.followerId,};});const followersCount = followers.length;res.json({ followersCount: followersCount, followers });} catch (error) {console.error('getFollowers() error: ', error);res.status(500).json({error: `There was an error fetching followers for user with username "${req.params.username}", please try again later`,});}};const getFollowing = async (req: Request, res: Response) => {try {const username = req.params.username || '';const user = await User.findUnique({where: { username },include: { following: true },});if (!user) {res.status(404).json({error: 'User could not be found',});return;}const following = user.following.map(following => {return {followingId: following.followingId,};});const followingCount = following.length;res.json({ followingCount: followingCount, following });} catch (error) {console.error('getFollowing() error: ', error);res.status(500).json({error: `There was an error fetching who is following "${req.params.username}", please try again later`,});}};const followUser = async (req: Request, res: Response) => {try {const username = req.params.username || '';const user = await User.findUnique({where: { username },});if (!user) {res.status(404).json({error: 'User could not be found',});return;}// dont allow a user to follow themselvesif (req.user.id === user.id) {res.status(400).json({ error: 'You cannot follow yourself' });return;}//check if a follow relationship already existsconst followrelationship = await prisma.follows.findUnique({where: {followerId_followingId: {followerId: req.user.id,followingId: user.id,},},});// check if the follow relationship already existsif (followrelationship) {res.status(400).json({ error: 'You are already following this user' });return;}// create the follow relationshipconst follow = await prisma.follows.create({data: {followerId: req.user.id,followingId: user.id,},});res.json({ follow });} catch (error) {console.error('followUser() error: ', error);res.status(500).json({error: `There was an error following "${req.params.username}", please try again later`,});}};const unfollowUser = async (req: Request, res: Response) => {try {const username = req.params.username || '';const user = await User.findUnique({where: { username },});if (!user) {res.status(404).json({error: 'User could not be found',});return;}// dont allow a user to unfollow themselvesif (req.user.id === user.id) {res.status(400).json({ error: 'You cannot unfollow yourself' });return;}//check if a follow relationship already existsconst followrelationship = await prisma.follows.findUnique({where: {followerId_followingId: {followerId: req.user.id,followingId: user.id,},},});// check if the follow relationship already existsif (!followrelationship) {res.status(400).json({ error: 'You are not following this user' });return;}// delete the follow relationshipconst follow = await prisma.follows.delete({where: {followerId_followingId: {followerId: req.user.id,followingId: user.id,},},});res.json({ follow });} catch (error) {console.error('unfollowUser() error: ', error);res.status(500).json({error: `There was an error unfollowing "${req.params.username}", please try again later`,});}};
interface Task {id: number;title: string;completed: boolean;}class TaskManager {private tasks: Task[] = [];constructor() {}addTask(title: string) {const taskId = this.tasks.length + 1;const task: Task = {id: taskId,title,completed: false,};this.tasks.push(task);}markTaskAsComplete(taskId: number) {const task = this.tasks.find((task) => task.id === taskId);if (task) {task.completed = true;}}markTaskAsIncomplete(taskId: number) {const task = this.tasks.find((task) => task.id === taskId);if (task) {task.completed = false;}}listTasks() {console.log('Tasks:');this.tasks.forEach((task) => {console.log(`${task.id}. [${task.completed ? 'X' : ' '}] ${task.title}`);});}}// Example usage:const taskManager = new TaskManager();taskManager.addTask('Buy groceries');taskManager.addTask('Pay bills');taskManager.addTask('Clean the house');taskManager.listTasks();// Output:// Tasks:// 1. [ ] Buy groceries// 2. [ ] Pay bills// 3. [ ] Clean the house
class DFS{public dfs(G: DFSGraph, startVert: number){let visited: boolean[] = Array<boolean>();// Pre-populate array:for(let i = 0; i < G.size; i++){visited.push(false);}let s: number[] = new Array();visited[startVert] = true;s.push(startVert);while(s.length > 0){const v = s.pop();for(let adjV of G.adj[v]){if(!visited[adjV]){visited[adjV] = true;s.push(adjV);}}}}public dfsRecursive(G: DFSGraph, startVert: number){let visited: boolean[] = Array<boolean>();// Pre-populate array:for(let i = 0; i < G.size; i++){visited.push(false);}this.dfsAux(G, startVert, visited);}private dfsAux(G: DFSGraph, v: number, visited: boolean[]){visited[v] = true;for(let adjV of G.adj[v]){if(!visited[adjV]){// this.foo(); // Something can happen before the visit.this.dfsAux(G, adjV, visited);// this.bar(); // Something can happen after the visit.}}}}