DEV Community: Arthur

Simplify Greatest Common Divisor with Euclidean Algorithm

Arthur — Wed, 13 Sep 2023 15:18:57 +0000

Introduction

Today I was looking to get the Greatest Common Divisor during a daily LeetCode grind.

While I used to work with algorithm at work I got rusty and got stuck on a Medium problem where in some step I needed to find the GCD(Greatest Common Divisor).

So at first let's understand what is a Greatest Common Divisor.

GCD

Let's make it very simple, the GCD is the largest number that can evenly divide two or more numbers.

It's like finding the biggest number that can go into both numbers without leaving any leftovers.

Example:

For 12 and 18, the GCD is 6 because 6 is the largest number that divides both 12 and 18 evenly. Easy right ?

So the GCD helps us to find a common factor.

It can also work for strings !

GCG step by step example

Step 1:
a = 12
b = 8
a % b = 4
(a, b) -> (b, a % b)

Step 2:
a = 8
b = 4
a % b = 0
(a, b) -> (b, a % b)

Step 3:
a = 4
b = 0 (termination condition)

GCD = 4 (the last non-zero remainder)

GCD of 2 numbers (TypeScript)

function findGCD(a: number, b: number): number {
    // Check conidtion that both numbers are positive
    a = Math.abs(a);
    b = Math.abs(b);

     // This part is the algorthim
    // Use the Euclidean algorithm to find the GCD
    while (b !== 0) {
        const temp = b;
        b = a % b;
        a = temp;
    }

    return a;
}

const num1 = 24;
const num2 = 36;

const gcd = findGCD(num1, num2);
console.log(`The GCD of ${num1} and ${num2} is ${gcd}`);

GCD for 2 strings (TypeScript)

function gcdOfStrings(str1, str2) {
    // Find the lengths of both strings
    const len1 = str1.length;
    const len2 = str2.length;

    // Calculate the GCD of the lengths using the Euclidean algorithm
    const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));
    const lengthGCD = gcd(len1, len2);

    // Extract a substring of lengthGCD from str1
    const x = str1.slice(0, lengthGCD);

    // Check if x divides both str1 and str2
    if (x.repeat(len1 / lengthGCD) === str1 && x.repeat(len2 / lengthGCD) === str2) {
        return x;
    } else {
        return "";
    }
}

(Also possible to re-use findGCD() example from above)

Explanation

The Goal

The code's aim is to find the greatest common divisor (GCD) of two strings. In this case, it's not the numerical GCD but rather a string that can be used to construct both str1 and str2 by repeating it.

Variables and Functions

num1 and num2: Store the lengths of str1 and str2.
gdc(a, b): A function to find the GCD of two numbers. This uses the Euclidean algorithm.
lenGDC: Stores the GCD of the lengths of the two strings.
x: The potential GCD string. It slices str1 up to lenGDC characters.

Core Logic

Find the GCD of the lengths of the two strings using gdc(num1, num2).
Take the first lenGDC characters from str1. Let's call this string x.
Check if x can recreate str1 and str2 when repeated certain times (num1 / lenGDC and num2 / lenGDC times).
If yes, return x. Otherwise, return an empty string.

Git Subtree in 1 minute

Arthur — Wed, 16 Feb 2022 12:44:30 +0000

"Git subtree" are often described like a better Git Sub-module.

Git subtree gives the possibility to nest one repository into another repository. It's very useful to manage dependencies in your project.

Pro:

Modifying content of the module without having another repository.
Keep your metadata files clean.
Users don't need to learn specific command to modify modules and files.
After initializing the subtree, all the code is available in the main tree and subtree.
Can create easier workflow.

Cons:

Upstream flow is more difficult to modify.
Need to use git subtree instead of git merge.
Potential mistakes while committing and mixing super and sub into commit.
listing multiples subtree is complicated

Creating a subtree

To add a subtree you need a repository with at least 1 commit(initial commit).

Then you can add your subtree like this.

git subtree add --prefix subtreeDirectory https://github.com/arthurlch/mytree.git master --squash

Here we clone this repo --> https://github.com/arthurlch/mytree.git master branch in subtreeDirectory.

Pull new commits to the subtree repository

Use pull instead of add.

Example:

git subtree pull --prefix subtreeDirectory https://github.com/arthurlch/mytree.git master

UPDATE

You can update the subtree remote repo.

git subtree push --prefix subtreeDirectory https://github.com/arthurlch/mytree.git master

Note: The commit will be stored in the host repository and with it logs.

Conclusion

Subtree > Submodule

Feel free to @ me on Twitter with your opinion & feedback about my article; Constructive feedback is always welcome.

Knuth Morris Pratt Algorithm

Arthur — Mon, 29 Nov 2021 02:56:43 +0000

What is the KMP algorithm

The KMP algorithm is used has a string-matching algorithm, if you want to find the starting index m in string S[] that matches the search word W[]. It is very effective to match string pattern and has an O(n) time complexity and worst case scenario O(m) time complexity.
Brute force solutions would be O(n*m) complexity, KMP O(n+m)

The space complexity is O(m) due to a pre-processing of a function that sets a table.

Example

The first step is to create a table. However before coding the table.

Explanations:

Here a table:
i
+---+---+---+---+---+---+---+---+
| a | b | c | a | b | a | b | c |
+---+---+---+---+---+---+---+---+
| | | | | | | | |
+---+---+---+---+---+---+---+---+
k

The first line represents a string and the second line a sub-string(pattern).

The first line is called i.
The second line is called k.

The line i has a recurrent pattern which is abc.

We can define a pattern as prefix and suffix.

Prefix : a,ab,abc.
Suffix: c, bc, abc.

One prefix is matching a suffix: 'abc'.

If encountering 'abc' twice in a table then:
a: 1, b:2, c:3

Simple Table:
Pattern: 'aab'
+---+---+---+---+---+---+---+---+
| a | a | b | a | b | a | a | b |
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 | 0 | 1 | 2 | 3 |
+---+---+---+---+---+---+---+---+

Complex table

+---+---+---+---+---+---+---+---+---+---+
| a | b | c | a | b | a | x | a | b | c |
+---+---+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 | 2 | 0 | 0 | 1 | 2 | 3 |
+---+---+---+---+---+---+---+---+---+---+

We have a pattern 'abc'.
Any character that is not included in our pattern will be 0.
Characters included in the pattern('abc') are respectively are index
Index 3,4 'ab' a:1,b:2.
Second match at index 8,9,10 'abc'. a:1,b:2,c:3.

That's how we define a table to set up the algorithm. We simply match the prefix and suffix from a table and set a value according to the pattern.

Coding the table

function Table(a) {
  // create an array from index 0
  const table = [0];
  // define i for looping trough table
  // define j = length prefix and suffix
  let i = 1;
  let k = 0;
  while (i < a.length) {
    // if character match them increase i and set k equal to i;
    if (a[i] === a[k]) {
      k += 1;
      table[i] = k;
      i += 1;
    // if k is greater than 0 and  
     characters don't match 
    // will reset k to previous index table -1 then while loop again to compare next i from k 
    } else if (k > 0) {
      k = table[k - 1];
    // no character match and k is equal to 0 then increment i to check the next character
    } else {
      table[i] = 0;
      i += 1;
    }
  }
  return table;
}

The easiest way to understand how to table is working is to watch the tables above and reading the code at the same time.

Finishing the Algorithm

const strStr = (string, subString) => {
  // filter out if string is empty = ''
  if (subString === "") return 0;
  // build table from Table function
  const Table = buildTable(subString);
  // create our variable k & i
  i = 0;
  k = 0;
  // we loop trough both string and substring
  while (i < string.length && j < subString.length) {
    // if characters match, increse index by one for both string and continue looping
    if (string[i] === subString[k]) {
      i += 1;
      k += 1;
      // if no match return k to previous index k -1
    } else if (j > 0) {
      k = buildTable[k - 1];
      // if no match and k = 0, increment
    } else {
      i += 1;
    }
    // when we got sutsring into string return -1
    if (k === subString.length) return i - k;
  }
  return -1;
};

Bonus naive solution


function stringSearch(string, pattern) {
  let count = 0;
  for (let i = 0; i < string.length; i++) {
    for (let j = 0; j < pattern.length; j++) {
      if (pattern[j] !== string[i + j]) break;
      if (j === pattern.length - 1) {
        console.log(i)
        count++;  
      } 
    }
  }
  return count;
}

console.log(stringSearch("akgjfjhuyutomatokajkhgsvkjrtomato", "tomato"));

Conclusion

You can test your skills for the KMP algorithm with leetcode question n'28.
shorturl.at/bdD35

Feel free to @ me on Twitter with your opinion & feedback about my article; Constructive feedback is always welcome.

Frequency Counter Pattern

Arthur — Fri, 19 Nov 2021 06:52:22 +0000

What is the Frequency Counter Pattern?

It's a pattern that uses Objects, sets to inspect the frequencies of values.

You want to use this pattern when comparing inputs to multiple data, like [anagrams](https://en.wikipedia.org/wiki/Anagram.

It's also useful to avoid quadratic time complexity O(n²) since the Frequency Counter Pattern has a complexity of O(n).

Example with squared numbers

One of the easiest examples used to explain the Frequency Counter pattern is creating a function that takes 2 array and compare the values of the arrays. It should return true if the corresponding value squared in the other array. It will return false if the frequency of the values is not the same.

isSquaredFrequency([1,2,3], [9,1,4]) // True

Even not in the order each value has its corresponding squared value in the second array.

isSquaredFrequency([1,3,4], [1,16]) // False

The value of 3 squared is not in the second array.

isSquaredFrequency([3,3,2,1], [9,4,4,1]) // False

The frequency doesn't match since the number 2 is included in the first array, but 2 squared (4) is present twice in the second array. It doesn't match the frequency.

Making the isSquaredFrequency Function

isSquaredFrequency() should compare both array length and compare each index.

To do that we could use a solution with nested loops.

Therefore nested loop has a quadratic time complexity, so let's use the frequency counter pattern to create our function.

It's often better to have multiple for loop instead of nested loops.

If n is equal to 100 then you loop through n 100 times for each (for loop).

If n is equal to 100 then you loop through with a nested loop. You will loop n * n times so 100 * 100 = 10,000.

function  isSquareFrequency(arr1,arr2) {
    // compare arrays length
    if(arr1.length !== arr2.length) return false;
    // create 2 counter
    let counter1 = {}
    let counter2 = {}

    // looping through each array x on x times
    // and store the number of time each value appears in the 
    // array
    for (let val of arr1) {
      counter1[val] = (counter1[val] || 0) + 1
    }
    for (let val of arr2) {
      counter2[val] = (counter2[val] || 0) + 1
    }


    // check is there is the value counter1 key squared in the 
    // counter 2, then check if the number of values correspond
    // in the counter1

    for (let key in counter1) {
      if(!(key ** 2 in counter2)) return false;
      if (counter2[key ** 2] !== counter1[key]) return false;
    }
    return true;
  }

let array1 = [1,1,3,3,3] 
let array2 = [1,2,9,9,9]
let array3 = [1,1,9,9,9]

console.log(isSquareFrequency(array1,array2)) // return false
console.log(isSquareFrequency(array1,array3)) // return true

Using an object instead of an array we can deconstruct an array, so we can compare other values more easily.

Anagram

Anagrams are one of the most asked questions during interviews, as you can see here: https://stackoverflow.com/questions/909449/anagrams-finder-in-javascript

The frequency counter pattern can help us to solve this problem in a very elegant way and with O(n) time complexity.

Example.

function isAnagram(firstString,secondString) {
 // check if both strongs have same length 
  if (firstString.length !== secondString.length) return false; 

  // create object to store the key value of each letter to 
     decompose the string
  let anagram = {}; 

  // loop through the first string and decompose the string into an object
  for (let i = 0; i < firstString.length; i++ ) {
    let char = firstString[i];
    // check if the letter exist and if more than 1 increment the 
    // key/value, if character in anagram is true, add 1, if false 
    // then only 1 character so char = 1 
    anagram[char] ? anagram[char] +1 : anagram[char] = 1; 
  }

  // second loop to go through the second string 
  for (let i = 0; i < secondString.length; i++) {
    let char = secondString[i];
    // check for the letter. if none then false, otherwise 
   // continue looping, 
    if (!anagram[char]) {
      return false;
    } else {
      anagram[char] -= 1;
    }
  }
  return true;
}

console.log(isAnagram('dog','gd')); // false
console.log(isAnagram('cat','tac')); // true

We can decompose the object anagram to see how it looks like.
{d: 1, o: 1, g: 1}
Each time we loop if the character is present, then we subtract the char that match.

First loop: {d: 0, o: 1, g: 1}
Second loop: {d: 0, o: 0, g: 1}
Third loop: {d: 0, o: 0, g: 0}

Then will return true.

Conclusion

There are not many resources available about the Frequency Counter Pattern. I invite you to check more about!

Feel free to @ me on Twitter with your opinion & feedback about my article; Constructive feedback is always welcome.

Polya’s Problem Solving Techniques

Arthur — Wed, 03 Nov 2021 14:23:04 +0000

I want to talk about a book that I read long ago about problem solving, problem solving is an important skill for anyone but especially important for developers and engineers!

In 1945 George Polya published a book How To Solve It and sold over one million copies. I'm gonna make a resume and reuse some content from his book, therefore I'll try to summarize everything here!

Polya identified 4 basic principles of problem solving.

First Principle: Understand the Problem

First of all a very easy thing to ask yourself is, Do I understand the meaning of the questions/problem.

• Do you understand all the words used in stating the problem?
• What are you asked to find or show?
• Can you restate the problem in your own words?
• Can you think of a picture or diagram that might help you understand the
problem?
• Is there enough information to enable you to find a solution?

Polya’s Second Principle: Devise a Plan

Sun-Tzu said: Plan for what is difficult while it is easy, do what is great while it is small.

Making a plan is one of the first steps to solve any problems. There is many approach to conceive a successful plan.

*Guess and check
*Look for a pattern
*Make an orderly list
*Draw a picture
*Eliminate the possibilities
*Solve a simpler problem
*Use symmetry
*Use a model
*Consider special cases
*Work backwards
*Use direct reasoning
*Use a formula
*Solve an equation
*Be ingenious

My favorites are: Trying to find pattern, going backward, Solve a simpler problem, which means simply dividing a big problem into smaller problems.

Polya’s Third Principle: Carry Out the Plan

Follow what you planned step by step. During the process patience is important but don't waste time on things that don't work or disturb other parts of your plan.

Polya’s Fourth Principle: Look Back

Coming back to our previous steps is the last step.
Taking time to redo, is a simple way to get a better understanding. It's great to summarize what worked and what didn't.

1. Understand the Problem

• First. You have to understand the problem.
• What is the unknown? What are the data? What is the condition?
• Is it possible to satisfy the condition? Is the condition sufficient to determine
the unknown? Or is it insufficient? Or redundant? Or contradictory?
• Draw a figure. Introduce suitable notation.
• Separate the various parts of the condition. Can you write them down?

2. Devising a Plan

• Find the connection between the data and the unknown.
Auxiliary problems needs to be considered.
• Have you seen it before? Or have you seen the same problem
in a slightly different form?

• Look at the unknown! Try to think of a familiar problem
having the same or a similar unknown.
• Here is a problem related to yours and solved before. Could
you use it(StackOverflow, Github)?

• Could you restate the problem?
• If you cannot solve the proposed problem, try to solve
first some related problem.

• Could you imagine a more accessible related problem?
• Could you change the unknown or data, or both if necessary,
so that the new unknown and the new data are nearer to each
other?

• Did you use all the data? Did you use the whole condition?
Have you taken into account all essential notions involved
in the problem?

3. Carrying Out The Plan

• Third. Carry out your plan.
• Carry out your plan of the solution, check each step. Can you see clearly that the step is correct? Can you prove that it is correct?

4. Looking Back

• Examine the solution obtained.
• Can you check the result? Can you check the argument?
• Can you derive the solution differently? Can you see it at a glance?
• Can you use the result, or the method, for some other problem?

I really recommend you to read How to Solve It: A New Aspect of Mathematical Method.

Credits to berkeley who published for free another resume of Polya works, which inspired me to do this one.
https://math.berkeley.edu/~gmelvin/polya.pdf

Conclusion:

Time to solve your fizzbuzz issue with Polya's help

Feel free to @ me on Twitter with your opinion & feedback about my article; Constructive feedback is welcome.

Building my own bug-tracker

Arthur — Tue, 19 Oct 2021 13:38:23 +0000

The idea.

EDIT: Before you start reading, I'm taking an undefined break with this project but will return to it.

As a developer I always wanted to build my own tools, for the principle to understand how these tools works.

After a 5 minute brainstorming I decided to make my own BugTracker.

There is diverse solutions for bug tracking: GitHub issues, Bug Tracker.
I don't like GitHub issues much, it's too simple and there is no predefined template, it's hard at the first glance to understand the importance of the issue without a proper template or system.

Bug Tracker software are great but I couldn't find a simple one with a modern design except the one from Zoho. They are more enterprise focused software and also most of them are not open source.

Here 2 list of most known bug tracker
https://medevel.com/19-os-bug-and-issues-tracking-and-management-solutions
https://www.guru99.com/top-20-bug-tracking-tools.html

None of them we're what I wanted so I simply decided to make mine!

Stack brainstorming

Architecture.

Rails monolith.

Client side.

I'm used to React but recently tried Vue and felt in love with.
I'm not familiar with Vue that much also I don't know Composition API yet nor VueX. Since I'm not familiar with Vue I decided to go for classic react with Webpack. I also decided to go with simple JS not TS. (Loving TS tho)

For styling I really like Tailwind but since I'm used to Bootstrap and MaterialUI I decided to stick with Material UI. MUI will be my pick.

I decided to not use Jest or any TDD tools for the client since I wanna ship it as soon as possible.

For front-end tooling webpack is by default with Rails which I'm not a huge fan especially since I discovered Vite which I'm in love with.

Backend :

'credit to @CodeDoesMeme on Twitter'

Well here things get complicated...

I'd like to ship my backend asap and not adding to much complexity with DB request, long configuration setup, multiple stack, non native ORM etc
I like JAMStack but it seems to add some complexity and to be useful when you need to scale or are very comfortable with a stack.
Adonis could do the job and seems to be very interesting but I never tried it, so I'm not gonna use any NodeJS framework.

Other than JAMStack I like Flask and Ruby On Rails, both do a different job and are well known and solid techs.

Both of them have a huge ecosystem but in my case it seems that Ruby On Rails will be the best choice.

It's well documented, Ruby's syntax is an eyes treat, MVC pattern which i'm used too, Active Records, Native ORM, Postgre which is to me one the best relational DB and fits my need for this project, gem ecosystem(package sys) is rock solid.

Deployment:

Client side:

Is a no brainer choice, Netlify <3.

'credit to u/donjuan26 from reddit'

Backend:

**Heroku: **Pricey but very straightforward. Maybe

VPS + Capistrano: Great but require set up & administration of the server. No

**Single Server: **DigitalOcean/Linode 5$ droplet + Dokku is very easy to deploy and cheap. Scaling is a big ? tho. Maybe

Kuberneters: Great tool but overpowered for this project. No

AWS Elastic Bean: Cheap, very Good support & service but AWS pricing system is an unsolved mystery and will probably remain unsolved till human reach a 400 IQ. Good when you need to scale mostly.

I'm still divided between Heroku and DigitalOcean droplet + Dokku. I might push to prod with Heroku at first with the free tier then go for the Droplet.

Conclusion:

Time to code, I will regularly post the process.

Feel free to @ me on Twitter with your opinion & feedback about my article; It's the first Constructive feedback is welcome.

Get started with MySQL | Mini-Guide

Arthur — Mon, 14 Sep 2020 07:16:10 +0000

A QUICK REMINDER

What's a database ?

A database is an organized collection of data, usually stored and accessed electronically from a computer system. When databases are more complex, they are often developed using formal design and modeling techniques.

A database will simply record data for us. With a database, you can create data, read data, update data and delete data, etc.
For example, when you are shopping on Amazon, all the items you have seen are saved in a database referencing Amazon items and it is a huge database. A database is a container of data.

There is basically 2 types of database where you will see the word SQL : SQL, NoSQL

SQL databases are relational database.

SQL database will scale vertically.
They use structured query language. A Structured Query Language is a language created to manage data inside a Database Management System, like MySQL for example.
SQL database use tables with rows and columns.

NoSQL databases are non-relational.

NoSQL scale horizontally.
They have a dynamic schema for unstructured data.
NoSQL databases are document, key-value, graph etc..

What is MySQL

MySQL is a fully managed database service using the query language known as ** SQL **. If you've never heard of MySQL, I recommend you take a look at their homepage.

Database management systems are very important, they will help us to: manage security, import and export data, manage a larger set of data and allow us to interact with other software applications such as a language of programming. MySQL is probably the most well-known database management system.

Using SQL / MySQL, we will be able to perform different types of actions and queries in the database.
The different types of actions are sometimes called ** CRUD **.

WHAT IS CRUD

CRUD means:

Create Read Update Delete

These are the four most basic functions that you will perform in a database system.

*For example:
*

Creating a user account.

Accessing an user account.

Updating a user profile picture.

Deleting a old profile picture.

MySQL Download and installation

Let's download and install MySQL, since the MySQL documentation is very good, we will use it.

Let's connect to MySQL & creating a database

You just installed MySQL and ready to dive into SQL.

On linux you might need to start SQLService

sudo service mysql start

Let's create a simple MySQL database, we will need to connect to the MySQL server from our command prompt/terminal.

*Let's connect as root with the command:
*

mysql -u root -p

** Note: A password will be required to connect to the MySQL server**, you had to set-up a password during the installation, if you forgot your password go check the documentation here .

We will create a new user:

mysql> create user 'testuser' identified by 'testuser';

Note: Instead of testuser, you are free to choose any username you want.

*Now we can create a new database
*

mysql> create database testdatabase;

mysql> grant all on testdatabase.* to 'testdatabase';

Note: Instead of testdatabase, you are free to choose any database name you want.

To be sure that we created a database we can type:

mysql> show databases;

You should be able to see your database

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
| testdatabase       |
+--------------------+

First table & queries

A query is a set of statements using SQL, which will search the database management system for the information you are looking for.

When Googling something you simply perform queries. If you Google space cat, you will get a space cat, it's a search query.

With SQL we will be able to make queries to find data in a large sets of data. With MySQL data are stored inside tables.

Tables

As mentioned above with MySQL our data are store inside tables, tables contains rows and columns.
Below you can a table that contain 3 columns and 3 rows.
Columns are read vertically.
Rows are read horizontally and contains all the information about an individual or a case.
The row for John would contain: John, 24, 67

In our table we defined a primary key(colored in pink) which is NAME. A primary key is an attribute which uniquely define a row.
So we can identify more easily each row.
We couldn't have 2 Johns or 2 Katie's but we could have Katie's height equal to John's height since the HEIGHT column is not a primary key and does not need to be unique; In the name, we could only have a single entry.

Datatype

Inside our tables we can stock different kind of data, in our example below you can see different data types: strings and integers but table can contain:

Note: param = parameter

*String data types:
*

CHAR(param) : String with a fixed length that can contain (letters,numbers, special characters) EX: if CHAR(10), CHAR will contain 10 characters and if left empty CHAR will be filled with 10 blank character.
VARCHAR(param) : String with a variable length that can contain (letters,numbers, special characters) EX: if VARCHAR(10), VARCHAR can contain between 1 and 10 characters. Ex: VARCHAR(40) max number of characters is equal to 40 it's convenient to save space inside your database to limit the number of characters of a string.
BINARY(param) Store binary bytes type, the parameter specifies the column length in bytes.
TEXT(param) Store a long string that can hold 21,844 characters.

*Numeric data types:
*

INT(param) : Integer with a range from -9223372036854775808 to 9223372036854775807. Ex: INT(345)
BIT(param) : Hold a bit value type with a range from 1 to 64. Ex: BIT(32)
BIGINT(param) : Big integer with a range from -9223372036854775808 to 9223372036854775807, Ex: BIGINT(3465242552342453)

*Date and Time data types:
*

DATE(param) : Store a date with the format YYYY-MM-DD, EX: DATE("2017-06-15");
DATETIME(param): Store a date with the time, format YYYY-MM-DD hh:mm:ss. EX: DATETIME("2017-06-15 10:20:45")
TIME(param): Store the time, format hh:mm:ss. Ex: TIME("10:20:45")

Creating a table

It's time to create a table using SQL for that we will need an SQL editor.

Let's download an SQL editor and database manager software called Beekper Studio. Site
It's free and open-source <3

Launch the software and click on quick connect, then you'll end up with this window.

Connection type: MySQL
Host: localhost
Port: 3306
User: the username you created.
Password: the password you created before
Default Database: The name of your database, i used testdatabase.

Before to connect click on Test to see if your credentials are the good one, then let's connect.

You'll end up on an empty window with a tab query#1, the magic will happens here.

Before to start check quickly the documentation of Beekeeper Studio.

Let's create a new table that describe products from an e-commerce.

CREATE TABLE Product (
    product_id INT PRIMARY KEY,
    product_name VARCHAR(40),
    price INT,
    bar_code INT,
    creation_date DATETIME,
    type VARCHAR(40)
);

DESCRIBE product;

Let's go step-by-step:

CREATE TABLE my_table_name(); will create a table, pretty explicit right?
Note: At the end of each query you should use a ";" semicolon. 1 semicolon = 1 query
Inside the bracket () we will define each columns.

product_id is the name, INT(integers) is the type of data, PRIMARY KEY define product_id as the primary key of the table. Primary key are unique and very important, choosing an adequate name for the PRIMARY key is important.

product_name, VARCHAR which is a string and inside the bracket you can specify the number maximum of characters to save space inside the database.

We repeat the operation every time for each columns; DATETIME(YYYY-MM-DD HH:MM:SS.SSSSS) correspond to a type of data that take the date and time.

Click on your query and then click on the yellow button Run Selection at the bottom right of your editor.
You now created your first table but yet we can't see anything.

let's run DESCRIBE product to show the table, click on the query and click on Run Selection.

DESCRIBE product;

Here you are, we should be able to see our table.

We can see each columns field; Type,(Null: Null mean that the column is not defined, the primary key need to be defined so Null = NO); Default(value), Extra(comments for example)

Note: SQL Convention

For now we will keep it simple. See CREATE, TABLE, INT,VARCHAR, DATETIME, DESCRIBE. It's the SQL reserved syntax and need to be in CAPITAL letter, it's not necessary and even non-capitalized it will works, it's simply a convention.

There is a tons of convention for SQL and actually the convention might differ depending of the company/project, the best resource that I found about SQL convention is here.

Delete a table

Let's delete our table with:

DROP TABLE product;

Now our table is deleted. Don't delete the previous queries that we wrote. You can 1 query each time, so feel free to delete and re-creating the table.

Altering a table

We will use the 'ALTER' statement which is used to delete,add, modify columns in a table. 'ALTER' can also be used to ADD and DROP.

Let's add a column in our table.

ALTER TABLE table_name
ADD column_name datatype;

ALTER TABLE product
ADD weight INT;

then

DESCRIBE product;

You should see the new column in the table located at the last position.

Now let's delete the column weight.

ALTER TABLE product
DROP COLUMN weight;

Let's check it:

DESCRIBE product;

The column has been deleted.

The 'ALTER' statement is very useful, we also could change the data type of a column like this:

ALTER TABLE product
MODIFY COLUMN bar_code VARCHAR(60);

Now if you run DESCRIBE table_name you should see that bar_code is now a VARCHAR limited to 60 characters.

DESCRIBE product;

Constraints

A SQL constraint is a rule that is specified inside a column.

PRIMARY KEY is a constraint it specify that the column will be a PRIMARY KEY.
UNIQUE It make sure that all values in a column are different. A PRIMARY KEY is also a unique value by default. If you want your value to be UNIQUE in a column, you'll use the constraint UNIQUE.
FOREIGN KEY is a constraint that link a column or a group of columns to another table. It will basically link multiple tables from the specified column with the constraint FOREIGN KEY. The table that contain the FOREIGN KEY is called the child table. The FOREIGN key is a way to link a parent table to a child table.
*With foreign keys, databases can become relational databases.
*

We will link the column product_name to a child table that we will create but before we need to do something.
When you link two tables with a FOREIGN KEY make sure that the column that will have the FOREIGN KEY constraint is either a PRIMARY KEY or has the constraint UNIQUE. In our case we need to choose a column that will link our 2 tables and modify the column.

Let's choose the column: product_name VARCHAR(40)
We need to make this column UNIQUE:

ALTER TABLE product
MODIFY COLUMN product_name VARCHAR(40) UNIQUE;

Let's see if your column took the constraint UNIQUE with.

DESCRIBE product;

in the column key we can see now that the column is having the constraint UNIQUE.
*Note: In my screenshot the VARCHAR is (60) due to a typo, keep (40) like in the code sample above.

Let's make a child table called product_type and define a FOREIGN KEY.

CREATE TABLE product_type (
    category_id INT AUTO_INCREMENT PRIMARY KEY,
    product_name VARCHAR(40),
    sub_category VARCHAR(20),
    FOREIGN KEY (product_name) REFERENCES product(product_name) ON DELETE CASCADE
);

We define:

A primary key called category_id ( Don't mind the AUTO_INCREMENT)
A product_name column that will be our foreign key.
A sub_category column

Then we define the foreign key with this query :

FOREIGN KEY (product_name) REFERENCES product(product_name) 
ON DELETE CASCADE;

FOREIGN KEY (my_column) REFERENCES parent_table(parent_table_column);

First you specify FOREIGN KEY in the column that will be the FOREIGN KEY inside the child table (product_type),
REFERENCES the parent table and inside the bracket the (column) you want to link from the parent table.

The column name in the parent table and in the child table don't need to have the same name but need to be the same data type. You can't link 2 tables with a different type of data, it doesn't make sense and wouldn't work.

ON DELETE CASCADE delete means that if a record in the parent table is deleted the linked records in the child table will be deleted.

ALTER TABLE product
ADD FOREIGN KEY (product_name) REFERENCES product(product_name);

NOT NULL The column cannot have a null value. When you'll fill the row with data you will need to fill the column with some data, if you tried to let the column without data(null), you won't be able to fill the row with data.

In the child table product_type I'd like to make the column sub_category always filled with a value, for this I will need to use the constraint NULL.

Note: PRIMARY KEY are NOT NULL by default.

ALTER TABLE product_type
MODIFY sub_category VARCHAR(20) NOT NULL;

DESCRIBE product_type;

In the column sub_category, NULL became 'NO' instead of 'YES'.
It means that this column will need to be fill with data when we will fill the table.

You can also specify a column with the constraint NOT NULL while creating the table. In fact you can specify in kind of constraint when creating a table.

CREATE TABLE example_table (
    id INT  PRIMARY KEY,
    name VARCHAR(40) DEFAULT 'User',
    age INT NOT NULL,
        account_creation DATE
);

DEFAULT gives a default value to the column, above you can see that name VARCHAR(40) DEFAULT 'User', has the DEFAULT constraint and give to the name column a default value of 'User'.

Example:

ALTER TABLE example_table
ALTER account_creation SET DEFAULT (2000-01-01);

AUTO_INCREMENT

Previously you saw AUTO_INCREMENT. It's very a very useful tool, it increment by 1 automatically when a new record is inserted into a table.

Example:

CREATE TABLE animals (
     id MEDIUMINT NOT NULL AUTO_INCREMENT,
     name CHAR(30) NOT NULL,
     PRIMARY KEY (id)
);

INSERT INTO animals (name) VALUES
    ('dog'),('cat'),('penguin'),
    ('lax'),('whale'),('ostrich');

SELECT * FROM animals;

The result will be :

+----+---------+
| id | name    |
+----+---------+
|  1 | dog     |
|  2 | cat     |
|  3 | penguin |
|  4 | lax     |
|  5 | whale   |
|  6 | ostrich |
+----+---------+

Each time we inserted a value inside the column name the id incremented automatically by 1.

SQL Syntax and QUERIES

Now you should be able to create and modify tables and specify constraints but yet we didn't inserted data inside our table.

Let's insert values inside the product table.

INSERT INTO

INSERT INTO product VALUES(1,'TV', 35, 11109474, '2020-01-01 10:10:10');

INSERT INTO my_table VALUES(id, product_name, price, bar_code, creation_date)

The INSERT INTO statement is used to insert new data into a database.

VALUES() is the place where you will fill the values that you want to put inside your database, they should correspond to the columns you made and to the constraint of the column.

If i try to insert a product with the same product_name it won't work because the column product_name as a constraint of UNIQUE.
Try it.

INSERT INTO product VALUES(2,'TV', 23, 863544, '2020-01-01 10:10:10');

Inserting values only in certain columns is also possible.

INSERT INTO product (product_id, product_name)
VALUES (7, 'Microwave')

SELECT

We will need to select values from our database for that we will use the SELECT statement.

SELECT * FROM product;

SELECT * (all) FROM my_table.

We can also select certain columns from the table.

SELECT product_id, price FROM product;

Here some data for your table product.

INSERT INTO product VALUES(2,'Video-Games', 135, 11103474, '2020-01-01 10:10:10');
INSERT INTO product VALUES(3,'Blue T-Shirt', 14, 11209474, '2020-01-01 10:10:10');
INSERT INTO product VALUES(4,'Asus Computer', 700, 21105474, '2020-01-01 10:10:10');
INSERT INTO product VALUES(5,'Desktop Monitor', 210, 11409474, '2020-01-01 10:10:10');
INSERT INTO product VALUES(6,' Apple Keyboard', 63, 11789474, '2020-01-01 10:10:10');

We can be more specific using the WHERE statement. I'd like to select a product where the column is equal to 'video-games'.

SELECT * FROM product
WHERE product_name='Video-Games';

The query can be even more precise with the AND, OR, NOT statement.

SELECT * FROM product
WHERE NOT product_name='Video-Games' AND NOT product_name ='TV';

We will select all the row except the ones where the column product_name contain 'Video-Games' OR product_name ='TV'

Here what result you should have.

ORDER BY

We can get the result of a query ordered in a an alphabetic way or numeric with ORDER BY.

Example.

SELECT * FROM product
ORDER BY product_name;

The table is know ordered alphabetically from product_name

We can also reverse the order with DESC.

SELECT * FROM product
ORDER BY product_name DESC;

We can specify 2 columns with an ascendant and a descent order.

SELECT * FROM product
ORDER BY product_name ASC,  product_id DESC;

MIN() and MAX() with GROUP BY

MIN will return the smallest value in the selected column and MAX will return the largest value.

If we want to know the most expensive product in the table we could do.

SELECT MAX(price)
FROM product;

Return the largest value in price.

We can return a GROUP, where we find the max value for every group. It's a little confusing so let's try.

SELECT product_id, MAX(price)
FROM product
GROUP BY product_id 
ORDER BY MAX(price);

Let's decompose the QUERY SELECT column, MAX(column)
from table
GROUP BY (first_column shown in the result)
ORDER BY (second_column that you want to be ordered by value)

It will works the same way with MIN().

IN OPERATOR

IN is an operator useful to specify multiple values with WHERE.

SELECT * FROM product
WHERE product_name IN ('TV', 'Video-Games', 'Desktop Monitor');

AVG(), SUM(), COUNT()

*COUNT()
*
Count will return the number of column that match a condition.

SELECT COUNT(price)
FROM product
WHERE price < 500 ;

Will return the count of all columns that have a price less than 500.

We used < as an operator but you can also use <, >, <=, >= ,<>(Not equal to).

SUM

We could make the sum of the price column.

SELECT SUM(price)
FROM product;

You can also specify a condition.

SELECT SUM(column)
FROM table
WHERE condition;

AVG

AVG stand for average, let's make the average of the price in the column product.

SELECT AVG(price)
FROM product;

You can also put a condition in your QUERY with WHERE.

SELECT AVG(column)
FROM table
WHERE Condition;

LIKE

LIKE is very useful it helps use to find a specified pattern in a column.

For example you want to find a certain brand in the product table like an Apple keyboard then we can use LIKE.

SELECT * FROM product
WHERE product_name LIKE '%Apple%';

Underscore _ is be used for 1 single character, % sign is used for 0, 1 and multiple characters.

UNION

UNION can link 2 results from 2 tables.

First insert data your child tables with data.

INSERT INTO product_type VALUES(2,'Video-Games', 'games');
INSERT INTO product_type VALUES(3,'Blue T-Shirt', 'clothing');
INSERT INTO product_type VALUES(4,'Asus Computer', 'computer');
INSERT INTO product_type VALUES(5,'Desktop Monitor', 'pc monitor');
INSERT INTO product_type VALUES(6,' Apple Keyboard', 'Apple accessories');

SELECT product_name FROM product
UNION
SELECT sub_category FROM product_type
ORDER BY product_name;

We linked the column product_name from the parent table to the column sub_category from the child table.

UPDATE

Sometimes you will need to update some data or columns

You need to use WHERE to specify which row otherwise all the records will be updated.

UPDATE product
SET product_name = 'Green-shirt', price = 16
WHERE product_id = 3;

DELETE

We can delete one value at a time.

DELETE FROM product WHERE product_name=''Microwave

It's also possible to DELETE all the records and row without deleting the table itself .

DELETE FROM product;

Conclusion

With all of this you should be able to do some queries, making tables . MySQL is very popular and i encourage to go deeper than this article and to check more about, in the official documentation. I didn't followed the standard convention but you can find more about SQL convention here.
This article cover a very limited part of MySQL but will give you the very basic. It's just the beginning of the journey into DMBS.

Feel free to @ me on Twitter with your opinion & feedback about my article;
It's the first time that I'm publishing an article be indulgent with your feedback.

DEV Community: Arthur

Simplify Greatest Common Divisor with Euclidean Algorithm

Introduction

GCD

GCG step by step example

GCD of 2 numbers (TypeScript)

GCD for 2 strings (TypeScript)

Explanation

The Goal

Variables and Functions

Core Logic

Git Subtree in 1 minute

"Git subtree" are often described like a better Git Sub-module.

Creating a subtree

Pull new commits to the subtree repository

UPDATE

Conclusion

Knuth Morris Pratt Algorithm

What is the KMP algorithm

Example

Coding the table

Finishing the Algorithm

Bonus naive solution

Conclusion

Frequency Counter Pattern

What is the Frequency Counter Pattern?

Example with squared numbers

Making the isSquaredFrequency Function

Anagram

Example.

Conclusion

Polya’s Problem Solving Techniques

First Principle: Understand the Problem

Polya’s Second Principle: Devise a Plan

Polya’s Third Principle: Carry Out the Plan

Polya’s Fourth Principle: Look Back

1. Understand the Problem

2. Devising a Plan

3. Carrying Out The Plan

4. Looking Back

Conclusion:

Building my own bug-tracker

The idea.

Stack brainstorming

Architecture.

Client side.

Backend :

Deployment:

Client side:

Backend:

Conclusion:

Get started with MySQL | Mini-Guide

A QUICK REMINDER

What's a database ?

What is MySQL

WHAT IS CRUD

MySQL Download and installation

Windows

MacOS

Linux(Ubuntu & Ubuntu based distro)

Let's connect to MySQL & creating a database

First table & queries

Tables

Datatype

Creating a table

Note: SQL Convention

Delete a table

Altering a table

Constraints

AUTO_INCREMENT

SQL Syntax and QUERIES

INSERT INTO

SELECT

ORDER BY

MIN() and MAX() with GROUP BY

IN OPERATOR

AVG(), SUM(), COUNT()

LIKE

UNION

UPDATE