update changes

Author: prateekiiest

.gitignore

@@ -0,0 +1,3 @@
+.sass-cache/
+_site/
+

CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at codeiiest@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

CONTRIBUTING.md

@@ -0,0 +1,22 @@
+# Contribution guidelines
+
+First of all, thanks for thinking of contributing to this project. :smile:
+
+Before sending a Pull Request, please make sure that you're assigned the task on a GitHub issue.
+
+- If a relevant issue already exists, discuss on the issue and get it assigned to yourself on GitHub.
+- If no relevant issue exists, open a new issue and get it assigned to yourself on GitHub.
+
+Please proceed with a Pull Request only after you're assigned. It'd be sad if your Pull Request (and your hardwork) isn't accepted just because it isn't ideologically compatible.
+
+While making a Pull Request, please take care of the following rules: 
+
+- Make sure the master branch of your forked repo is not any commits ahead than the original master repository.
+- Create a new branch from master in the forked repository. Updated your changes in that branch and not in master.
+- Include only one algorithm in each pull request. A PR containing more than one algorithm *will not be merged*.
+- Write your algorithm in a language other coders are mostly acquainted with i.e. `C`/`C++`/`Python`/`Java`. Any 
+other language will be accepted only after discussion with the maintainers.
+- When writing the algorithm's code, please include a small `readme.md` file in the folder briefly explaining the 
+algorithm. Make sure your `readme.md` provides a clear understanding of the algorithm to a new-comer. Explanation 
+should be given in not more than 300 characters
+- Write the name of the algorithm you added and the language you used in the title while making the PR.

Competitive Coding/Backtrack/Sudoku.cpp

@@ -0,0 +1,132 @@
+// A Backtracking program in C++ to solve Sudoku problem
+#include <stdio.h>
+
+// UNASSIGNED is used for empty cells in sudoku grid
+#define UNASSIGNED 0
+
+// N is used for size of Sudoku grid. Size will be NxN
+#define N 9
+
+// This function finds an entry in grid that is still unassigned
+bool FindUnassignedLocation(int grid[N][N], int &row, int &col);
+
+// Checks whether it will be legal to assign num to the given row,col
+bool isSafe(int grid[N][N], int row, int col, int num);
+
+/* Takes a partially filled-in grid and attempts to assign values to
+ all unassigned locations in such a way to meet the requirements
+ for Sudoku solution (non-duplication across rows, columns, and boxes) */
+bool SolveSudoku(int grid[N][N])
+{
+ int row, col;
+
+ // If there is no unassigned location, we are done
+ if (!FindUnassignedLocation(grid, row, col))
+ return true; // success!
+
+ // consider digits 1 to 9
+ for (int num = 1; num <= 9; num++)
+ {
+ // if looks promising
+ if (isSafe(grid, row, col, num))
+ {
+ // make tentative assignment
+ grid[row][col] = num;
+
+ // return, if success, yay!
+ if (SolveSudoku(grid))
+ return true;
+
+ // failure, unmake & try again
+ grid[row][col] = UNASSIGNED;
+ }
+ }
+ return false; // this triggers backtracking
+}
+
+/* Searches the grid to find an entry that is still unassigned. If
+ found, the reference parameters row, col will be set the location
+ that is unassigned, and true is returned. If no unassigned entries
+ remain, false is returned. */
+bool FindUnassignedLocation(int grid[N][N], int &row, int &col)
+{
+ for (row = 0; row < N; row++)
+ for (col = 0; col < N; col++)
+ if (grid[row][col] == UNASSIGNED)
+ return true;
+ return false;
+}
+
+/* Returns a boolean which indicates whether any assigned entry
+ in the specified row matches the given number. */
+bool UsedInRow(int grid[N][N], int row, int num)
+{
+ for (int col = 0; col < N; col++)
+ if (grid[row][col] == num)
+ return true;
+ return false;
+}
+
+/* Returns a boolean which indicates whether any assigned entry
+ in the specified column matches the given number. */
+bool UsedInCol(int grid[N][N], int col, int num)
+{
+ for (int row = 0; row < N; row++)
+ if (grid[row][col] == num)
+ return true;
+ return false;
+}
+
+/* Returns a boolean which indicates whether any assigned entry
+ within the specified 3x3 box matches the given number. */
+bool UsedInBox(int grid[N][N], int boxStartRow, int boxStartCol, int num)
+{
+ for (int row = 0; row < 3; row++)
+ for (int col = 0; col < 3; col++)
+ if (grid[row+boxStartRow][col+boxStartCol] == num)
+ return true;
+ return false;
+}
+
+/* Returns a boolean which indicates whether it will be legal to assign
+ num to the given row,col location. */
+bool isSafe(int grid[N][N], int row, int col, int num)
+{
+ /* Check if 'num' is not already placed in current row,
+ current column and current 3x3 box */
+ return !UsedInRow(grid, row, num) &&
+ !UsedInCol(grid, col, num) &&
+ !UsedInBox(grid, row - row%3 , col - col%3, num);
+}
+
+/* A utility function to print grid */
+void printGrid(int grid[N][N])
+{
+ for (int row = 0; row < N; row++)
+ {
+ for (int col = 0; col < N; col++)
+ printf("%2d", grid[row][col]);
+ printf("\n");
+ }
+}
+
+/* Driver Program to test above functions */
+int main()
+{
+ // 0 means unassigned cells
+ int grid[N][N] = {{3, 0, 6, 5, 0, 8, 4, 0, 0},
+ {5, 2, 0, 0, 0, 0, 0, 0, 0},
+ {0, 8, 7, 0, 0, 0, 0, 3, 1},
+ {0, 0, 3, 0, 1, 0, 0, 8, 0},
+ {9, 0, 0, 8, 6, 3, 0, 0, 5},
+ {0, 5, 0, 0, 9, 0, 6, 0, 0},
+ {1, 3, 0, 0, 0, 0, 2, 5, 0},
+ {0, 0, 0, 0, 0, 0, 0, 7, 4},
+ {0, 0, 5, 2, 0, 6, 3, 0, 0}};
+ if (SolveSudoku(grid) == true)
+ printGrid(grid);
+ else
+ printf("No solution exists");
+
+ return 0;
+}

Competitive Coding/Backtrack/nQueen.cpp

@@ -0,0 +1,104 @@
+/* C/C++ program to solve N Queen Problem using backtracking */
+#define N 4
+#include<stdio.h>
+
+/* A utility function to print solution */
+void printSolution(int board[N][N])
+{
+ for (int i = 0; i < N; i++)
+ {
+ for (int j = 0; j < N; j++)
+ printf(" %d ", board[i][j]);
+ printf("\n");
+ }
+}
+
+/* A utility function to check if a queen can
+ be placed on board[row][col]. Note that this
+ function is called when "col" queens are
+ already placed in columns from 0 to col -1.
+ So we need to check only left side for
+ attacking queens */
+bool isSafe(int board[N][N], int row, int col)
+{
+ int i, j;
+
+ /* Check this row on left side */
+ for (i = 0; i < col; i++)
+ if (board[row][i])
+ return false;
+
+ /* Check upper diagonal on left side */
+ for (i=row, j=col; i>=0 && j>=0; i--, j--)
+ if (board[i][j])
+ return false;
+
+ /* Check lower diagonal on left side */
+ for (i=row, j=col; j>=0 && i<N; i++, j--)
+ if (board[i][j])
+ return false;
+
+ return true;
+}
+
+/* A recursive utility function to solve N Queen problem */
+bool solveNQUtil(int board[N][N], int col)
+{
+ /* base case: If all queens are placed then return true */
+ if (col >= N)
+ return true;
+
+ /* Consider this column and try placing this queen in all rows one by one */
+ for (int i = 0; i < N; i++)
+ {
+ /* Check if queen can be placed on board[i][col] */
+ if ( isSafe(board, i, col) )
+ {
+ /* Place this queen in board[i][col] */
+ board[i][col] = 1;
+
+ /* recur to place rest of the queens */
+ if ( solveNQUtil(board, col + 1) )
+ return true;
+
+ /* If placing queen in board[i][col] doesn't lead to a solution, then remove queen from board[i][col] */
+ board[i][col] = 0; // BACKTRACK
+ }
+ }
+
+ /* If queen can not be place in any row in this colum col then return false */
+ return false;
+}
+
+/* This function solves the N Queen problem using
+ Backtracking. It mainly uses solveNQUtil() to
+ solve the problem. It returns false if queens
+ cannot be placed, otherwise return true and
+ prints placement of queens in the form of 1s.
+ Please note that there may be more than one
+ solutions, this function prints one of the
+ feasible solutions.*/
+bool solveNQ()
+{
+ int board[N][N] = { {0, 0, 0, 0},
+ {0, 0, 0, 0},
+ {0, 0, 0, 0},
+ {0, 0, 0, 0}
+ };
+
+ if ( solveNQUtil(board, 0) == false )
+ {
+ printf("Solution does not exist");
+ return false;
+ }
+
+ printSolution(board);
+ return true;
+}
+
+// driver program to test above function
+int main()
+{
+ solveNQ();
+ return 0;
+}

Competitive Coding/Dynamic Programming/Edit Distance/CODECHEF_seatsr.cpp

@@ -0,0 +1,78 @@
+// Two 1-d array implementation
+#include <bits/stdc++.h>
+using namespace std;
+const int inf=0x3fffffff;
+#define Min(a,b) (a<b?a:b)
+#define Max(a,b) (a<b?b:a)
+#define fr(i,j,s) for(i = j ; i < s ; i++)
+long long int current_dp[100002]={0};
+long long int previous_dp[100002]={0};
+int main(void)
+{
+long long int test ,alpha , temp , lena , lenb , i, j,z,x,c ;
+char a[100001];
+char b[100001];
+cin>>test ;
+while(test--)
+{
+cin>>a;
+cin>>b;
+cin>>z;
+cin>>x;
+cin>>c;
+lena = strlen(a) ;
+lenb = strlen(b) ;
+if((lena-lenb)*z > c || (lenb-lena)*z > c )
+{
+cout<<"-1\n";
+continue ;
+}
+if( (z == 0) )
+{
+cout<<"0\n" ;
+continue ;
+}
+if( (x == 0) )
+{
+cout<<z*((lena-lenb) < 0 ? -1*(lena-lenb):(lena-lenb))<<"\n" ;
+continue ;
+}
+fr(i,0,lenb+1)
+{
+if(i > c)
+previous_dp[i] = inf ;
+else
+previous_dp[i] = i*z ;
+}
+fr(i,1,lena+1)
+{
+alpha = Max((i-c),0) ;
+if( alpha > 0)
+{
+current_dp[alpha-1] = inf ;
+}
+alpha -= 1 ;
+temp = Min((i+c+1),(lenb+1)); 
+fr(j,alpha+1,temp)
+{
+if(j == 0)
+{
+current_dp[j] = i*z ;
+}
+else
+{
+current_dp[j] = Min(Min(previous_dp[j] + z , current_dp[j-1] + z ) , previous_dp[j-1]+(a[i-1] == b[j-1] ? 0 : x));
+}
+}
+fr(j,alpha,temp)
+{
+previous_dp[j] = current_dp[j] ; 
+}
+}
+if(current_dp[lenb] > c)
+cout<<"-1\n";
+else
+cout<<current_dp[lenb]<<"\n";
+}
+return 0 ;
+}