Dev note 8JAN2021

Kipack Jeong — Sun, 09 Jan 2022 03:40:10 +0000

Leetcode

Palindrome Partitioning
Given a string s, partition s such that every substring of the partition is a palindrome. Return all possible palindrome partitioning of

A palindrome string is a string that reads the same backward as forward.

Example 1:

Input: s = "aab"
Output: [["a","a","b"],["aa","b"]]
Example 2:

Input: s = "a"
Output: [["a"]]

Constraints:

1 <= s.length <= 16
s contains only lowercase English letters.

Depth first search approach

dfs the possible set of letters starting from index 0. so like in s = "aaba", start from s[0] = "a", possible forms would be : a , aa , aab, aaba Among above candidates, if candidate is not a palindrome we would skip to next candidate.

function dfs(s, start, subList, result){
  for(var end = start ; end < s.length; end ++){
    if(isPalindrome(start, end)){

    }
  }
}

If candidate is palindrome, add the current candidate to subList, then dfs in after the next following letter after the candidate.

function dfs(s, start, subList, result){
  for(var end = start ; end < s.length; end ++){
    if(isPalindrome(start, end)){
      subList.push(s.slice(start, end+1)
      dfs(end+1, subList, result)
    }
  }
}

Setup the base condition of this dfs recursive call. Which would be when start >= s.length, then add subList to result then get out from single recursion. Then backtrack by popping out an element from subList.

function dfs(s, start, subList, result){
  if(start >= s.length){
    result.push([...subList])
    return
  }
  for(var end = start ; end < s.length; end ++){
    if(isPalindrome(start, end)){
      subList.push(s.slice(start, end+1)
      dfs(end+1, subList, result)
      subList.pop() // backtracking
    }
}

Now the whole setup would look like this.

var answer = function(s) {
    const result = []
    function isPalindrome(s, start, end){
        while(start < end){
            if( s[start] !== s[end]){
                return false;
            }
            start ++
            end --
        }
    return true;
}
    function dfs(s, start, subList, result){
        if(start >= s.length){
            result.push([...subList])
            return 
        }

        for(var end = start; end < s.length; end++){
            if(isPalindrome(s,start,end)){
                subList.push(s.slice(start,end+1))
                dfs(s,end+1, subList, result)
                subList.pop()    
            }
        }
    }
    dfs(s, 0, [], result)
    return result
};

Dev note 7JAN2021

Kipack Jeong — Fri, 07 Jan 2022 17:45:30 +0000

Git

git diff

git diff command is to view the changes.

git diff - list all the changes in our working directory that are not staged.
git diff HEAD - list all the changes between working directory and HEAD.
git diff branch1 branch2 - list all the changes between branch1 and branch2
git diff --staged - list all the changes between working directory and staged.

git stash

when you want to temporarily save changes without committing them before switching over to different branch.
is not mandatory command.
it just makes more convenient.

git stash: stash the current work.
git stash pop : pop recent stash.
git stash apply: User to apply whatever stashed away, without removing it from the stash. This can be useful if you want to apply stashed changes to multiple branches.
git stash list : shows all the stashes.
git stash apply : apply particular stash to current branch.
git stash drop : delete particular stash.

Nest.js

Hashing Password

Hashed password cannot be decrypted.

To secure user from rainbow table, need to use salt.

So the step to save password is.

when user inputs plain text version of password.
salt it.
then hash it.
then save it in db.

Library to encrypt password.
bcrypt

bcrypt not only hash password, but also salt it.

import * as bcrypt from 'bcrypt'

const salt = bcrypt.genSalt()
const hashedPassword = bcrypt.hash(password, salt)
const createdUser = user.create({username,password:hashedPassword})
user.save(createdUser)

Many to One and One to Many

/tasks.entity.ts

import { Exclude } from 'class-transformer';
import { User } from 'src/users/user.entity';
import { Column, Entity, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class Task {
    @PrimaryGeneratedColumn('uuid')
    id: string;

    @Column()
    title: string;

    @ManyToOne((_type) => User, (user) => user.tasks, { eager: false })
    @Exclude({ toPlainOnly: true })
    user: User;
}

/user.entity.ts

@Entity()
export class User {
    @PrimaryGeneratedColumn('uuid')
    id: string;

    @Column({ unique: true })
    username: string;

    @Column()
    password: string;

    @OneToMany((_type) => Task, (task) => task.user, { eager: true })
    tasks: Task[];
}

/transform.interceptor.ts

import {
    CallHandler,
    ExecutionContext,
    Injectable,
    NestInterceptor,
} from '@nestjs/common';
import { classToPlain, instanceToPlain } from 'class-transformer';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Injectable()
export class TransformInterceptor implements NestInterceptor {
    intercept(
        context: ExecutionContext,
        next: CallHandler<any>,
    ): Observable<any> | Promise<Observabl
e<any>> {
        return next.handle().pipe(map((data) => instanceToPlain(data)));
    }
}

/main.ts

async function bootstrap() {
    const app = await NestFactory.create(AppModule);

    app.useGlobalPipes(new ValidationPipe());
    app.useGlobalInterceptors(new TransformInterceptor());

    await app.listen(3000);
}
bootstrap();

DEV Community: Kipack Jeong