This is the Full list of the sources for Ubuntu 20.04

만약 리스트/배열의 길이가 0이나 1이라면 이미 정렬된 것으로 치부한다.
그렇지 않은 경우에는 리스트/배열을 절반으로 잘라 비슷한 크기를 가진 부분 리스트/배열로 나누고 합병 정렬을 한다.
마지막에는 이 두개의 부분 리스트/배열을 하나의 정렬되었는 리스트/배열로써 합병한다.

이 그려진 도표를 보게 되면

위의 도표는 이미 분할이 되었는 상태에서 다시 병합하는 과정을 역순으로 그린 도표인데 실제로 Merge Sort가 진행되는 과정을 나타내자면

이런과정으로 진행된다.
이제 이를 일반적인 방법으로 구현을 하게 된다면 리스트의 시작과 끝을 기준으로 mid 값을 찾고 그 값을 기준으로 리스트/배열을 분할하게 될 것이다.

그리고 정렬되었는 리스트/배열만이 남게된다면 두개의 부분 리스트/배열을 합병하게 되는데 합병을 할때에는 두개의 리스트/배열에서 첫번째 값을 서로 비교하고 더 작은 값을 새로운 리스트/배열에 넣는 과정을 수행할 수 있을것이다.

이러한 과정을 되풀이하며 두 리스트/배열 중 하나가 먼저 끝나게 되면 나머지 리스트/배열의 값을 새로운 리스트/배열로 옮기면 합병과정을 수행한 것이 되는 것이다.

PyTorch

An open source machine learning framework that accelerates the path from research prototyping to production deployment.

우선 파이토치 홈페이지에 접속을 하도록 하자( 위의 링크를 눌러서 접속)

우리는 파이토치를 아나콘다를 활용해서 사용할 예정이기에 만약 아나콘다를 설치하지 않았다면 밑의 링크에서 아나콘다를 먼져 설치하고 오도록 권장한다.

아나콘다 설치하기

Anaconda | Individual EditionAnaconda’s open-source Individual Edition is theeasiest way to perform Python/R data science and machine learning on a singlemachine.Anaconda [https://www.anaconda.com/products/individual#download-section]먼저 아나콘다 홈페이지에서 다운로드 목록이 있는 페이지를 들어가야 한다. 들어가게 되면 현제 접속한 기기의 운영…

Skuld's CouncilSkuld Norniern

설치 하기 버튼을 누르게 되면 밑의 사진이 나오게 된다 ( 보통은 자신의 운영체제에 맞추어서 선택이 된 화면을 보여준다)

• 윈도우

만약 CUDA (Nvidia 그래픽카드의 프로세싱 유닛 명칭) 을 지원하는 그래픽카드를 가지고 있다면 자신의 카드가 지원하는 쿠다 버전에 맞추어 쿠다 버전을 Compute Platform을 눌러서 해당 커맨드를 아나콘다의 terminal에서 실행하도록 한다.
(보통 3GB 이상의 VRAM을 가진 그래픽 카드를 권장한다.)

만약 CUDA를 지원하는 그래픽 카드가 없다면 CPU를 눌러서 설치하도록 하자

만약 자신이 AMD 그래픽 카드를 가지고 있다면 윈도우에서는 ROCm을 사용할 수 없기에 리눅스로 넘어가는 것을 권장한다.

• 리눅스

자신이 가지고 있는 하드웨어에 맞추어 Compute Platform을 선택하고 terminal 에서 해당 커맨드를 실행하도록 하자

• 맥

맥에서는 CPU 외에는 공식적으로 지원을 하지 않는다. (아직 필자는 시험해보지 못했지만 ARM 계열의 CPU가 만약 지원이 된다면 속도가 어지간한 GPU와 비슷하거나 더 빠를 수도 있으리라 판단된다)

만약 아직 맥에서 지원하는 Nvidia 그래픽 카드가 있다면 맥 10.10 요시미츠 이상에서 직접 PyTorch를 빌드해서 사용한다면 CUDA를 사용할 수 있다고 한다. 물론 맥에 대부분은 AMD 라데온 그래픽 카드가 있긴하지만 ROCm 에 대해서는 공식 언급이 없는 것으로 보아 직접 빌드해도 지원을 하지 않거나 OpenCL로 작동이 되리라 생각한다.

• 설치 후

주피터 노트북에 들어가서 import torch를 치고 실행을 했을 때 오류가 없다면 파이토치를 정상적으로 설치했다고 생각을 하면 되겠다.

Anaconda | Individual Edition

Anaconda’s open-source Individual Edition is the easiest way to perform Python/R data science and machine learning on a single machine.

Anaconda

먼저 아나콘다 홈페이지에서 다운로드 목록이 있는 페이지를 들어가야 한다.

들어가게 되면 현제 접속한 기기의 운영체제에 맞추어 설치기를 다운할 수 있는 페이지가 뜨게 될 것이다. (필자는 현재 윈도우에서 이 글을 적고 있기에 윈도우용 다운로드 창이 뜬다)

만약 자신이사용중인 운영체제에 맞지 않은 다운로드버튼이 나온다면 Get Additional Installers 를 누르면 밑의 창이 뜨게될 것이다.

여기서 다운로드를 받은 뒤 설치를 하면 아나콘다를 설치할 수 있다.

• 윈도우

대부분은 Just Me를 그대로 두어도 괜찮다고 필자는 생각한다. 또한 모든 유저로 실행가능하게 하는 기능이 필요한 사람들은 아마 자신이 그게 필요한 이유, 그리고 본인이 무었을 하고 있는지 알고 있다고 필자는 믿도록 하겠다.

필자는 보통 Advanced Options를 기본 그대로 두어서 Anaconda prompt 를 직접 키는 편이긴 하지만 밑의 것은 만약 아나콘다에서 거의 모든 작업을 할 사람이라면 밑의 것은 체크를 하는걸 권한다.

설치가 끝난다면 Anaconda Navigator를 켜서 주피터 노트북을 실행할 수 있게 된다.

PyTorch

An open source machine learning framework that accelerates the path from research prototyping to production deployment.

First go to the PyTorch site and you will be greeted with

We will use Anaconda so if you don't have Anaconda on your computer
read the article below first

Installing Anaconda

Anaconda | Individual EditionAnaconda’s open-source Individual Edition is theeasiest way to perform Python/R data science and machine learning on a singlemachine.Anaconda [https://www.anaconda.com/products/individual#download-section]You will need to go to this webpage first you will be able to …

Skuld's CouncilSkuld Norniern

this page
than you will need to press the install button

than you will be able to found this page

• Windows

if you have CUDA compatible GPU that have a VRAM more than 3GB (it is possable with 1 or 2 GB of VRAM but on my experience at least 3GB is needed)

and if you don't have a CUDA compatible GPU

Doing this is recommended ( and if you have a AMD GPU sorry but you have no luck on windows )

• Linux

You will need to know the hardware that you are running  and select the Compute Platform that you needed and run it on the terminal

• Mac

On the mac you have no other option than using the CPU (I haven't tried the new ARM chip, but if is supported it will be very fast )

and also if you have the MacOS compatible Nvidia GPU, You can still build PyTorch from Source (but only on MacOS  10.10 Yosemie or above)

• After Installing

from the jupyter Notebook, on a new note
when you type the import torch, if you have installed PyTorch correctly it will have no error

Anaconda | Individual Edition

Anaconda’s open-source Individual Edition is the easiest way to perform Python/R data science and machine learning on a single machine.

Anaconda

You will need to go to this webpage first

you will be able to see this on the first glance (I'm writing this on windows so the download for windows is showing up on this photo)

if this page dosen't show the right download for your OS, than press the Get Additional Installers

after downloading this you will only need to do is run the installer

• Windows

almost of you will be fine with the Just Me setting (if you are the one that needs the all users settings, I bet you know what you are doing)

I usually leave this Advanced Options as it is

after the installation, You can Launch the Jupyter Notebook from the anaconda navigator

In a n length of element of an array is present, while making an subsequence each element satisficed the condition of each element is bigger than the element before it

As an example

[6, 1, 3, 2, 8, 5, 9, 4]

from an array like this the longest increasing subsequence is

[1, 2, 8, 9], [1, 3, 8, 9] …

there is more increasing subsequence like [2, 5], [1, 9] but the longest ones are
[1, 2, 8, 9], [1, 3, 8, 9]

and the simplest way of making this algorithm is to using Dynamic Programming

Simple Example code

#include<stdio.h>
#include<algorithm>
using namespace std;
int len[1003],arr[1003];
int main()
{
    int i,j,n;
    scanf("%d",&n);
    for(i=0;i<n;i++)
        scanf("%d",&arr[i]);
    for(i=0;i<n;i++){
        len[i]=1;
        for (j=0;j<i;j++){
            if(arr[j]<arr[i]){
                len[i]=max(len[i],len[j]+1);
            }        
        }
    }
    return 0;
}

This is a simple way of doing the LIS algorithm, but this way is simply just sweeping all of the array and updating the len array

and the condition for updating the len array is

Comparing of adding arr[i] on the end of len's i'th index and measure the length of the LIS and  len[i]'s value
The bigger value is the new len[i]'s value

But the Time Complexity of this algorithm is O(n^2) so we need a more optimized method of coding this algorithm

for reduce the Time complexity here comes the Binary Search Algorithm

If you don't know the Binary Search Algorithm read this article first and comeback

Binary Search Algorithm

Binary Search Algorithm is a one of a Search Algorithm, and the main point ofthis algorithm is that dividing the search radius to two part.and that’s why binary search is faster than normal search algorithm that searchthe whole search radius. The way you do the Binary Search is to use the left, …

Skuld's CouncilSkuld Norniern

If we use the Binary Search Algorithm as our advantage we can find the place for the numbers using the Binary Search Algorithm
Binary Search Algorithm have a Time Complexity of O(log n) so if we use this than we can reduce the Time Complexity to O(nlog n)

arr [4, 3, 9, 11. 10]
g    [4]
put the arr[0]'s value for the start
g    [3]
we can find the place for the arr[1]'s value after doing the Binary Search Algorithm and that value is going to be the index for arr[1]
g    [1, 3]
after that find the place for the arr[2]'s value, the g's last value is smaller than the arr[2] put the value to the back of that
g    [1, 3, 11]
after that find the place for the arr[3]'s value, the g's last value is smaller than the arr[3] put the value to the back of that
g    [1, 3, 9]
arr[4] is smaller than the last value of the g so find the place using the Binary Search  we can find the index 2 and we can put the arr[4] in to that

#include<stdio.h>
#include<algorithm>
using namespace std;
int n, arr[40001], g[40001];
int bs(int l, int r, int t) {
	int mid;
	while(l<) {
		mid=(l+r)/2;
		if(g[mid]<t)l=mid+1;
		else r=mid;
	}
	return r;
}

int main() {
	int n,i,j=0,idx;
	scanf("%d",&n);
	for(i=0;i<n;i++)
		scanf("%d",&arr[i]);
	g[0]=arr[0],i=1;
	while(i<n) {
		if(g[j]<arr[i]) g[j+1]=arr[i],j+=1;
		else idx=bs(0,j,arr[i]),g[idx]=arr[i];
		i += 1;
	}
	printf("%d",j+1);
	return 0;
}

The way you do the Binary Search is to use the left, right, mid. First of all the mid value will be (left + right)/2 and we will compare that value with the value that we are trying to find.

• when you are doing the Binary Search Algorithm the array should be sorted
• set the mid value using the left, right value
• compare the mid value with the value that we are trying to find
• after comparing if the mid value is bigger than the value that we are trying to found, then the left value should be mid+1 and if the mid value is smaller, the right value should be mid-1
• continue this method while left <= right to get the answer we are looking for

Normal search method's Time Complexity should be O(n) but when we use this method the Time Complexity should be O(log(n)), So should be very fast

[I will insert the image for  easy understanding]

#include<stdio.h>
int arr[10]={1, 2, 5, 6, 8, 9, 10, 16, 19, 24};
int main(){
 
    int n, res=0, left=0, right=9, mid;
    scanf("%d",&n); 
    while(left<=right)
    {
        mid=(left+right)/2;
        if(arr[mid]>n) right=mid-1;
        else if(arr[mid]<n)left=mid+1;
        else {res=mid;break;}
    }
    printf("%d ",res);
    return 0;
}

You can also use the lower_bound, upper_bound from the STL library
you can use it as lower/upper_bound(arr, arr+n, key);
The only downside is that the return type is a form of a Iterator so if you want the value of the key placement, you can - v.begin() or use the array's name

What you have to know is that the lower_bound is a function that find's the number's placement value of that is bigger or the same
and the upper_bound is a function that find's the number's placement value of that is bigger

16456번: 하와와 대학생쨩 하와이로 가는 거시와요~

Baekjoon Online Judge스타트링크 (Startlink)

해당 문제는 간단한 다이나믹 문제입니다.

우선 이 문제는 문제에서 제시한 조건을 잘 분석해야 합니다.

문제의 조건을 보면

1.어떤 섬을 보고 바로 그 다음 섬으로 갈 수 있사와요...
2. 어떤 섬을 보고 한 섬을 건너뛰고 그 다음 섬으로 갈 수도 있사와요...
3. 어떤 섬을 보고 그 이전 섬으로 갈 수 있사와요...

이렇게 세가지가 있는데

조건을 보게되면 우리가 n번째 섬을 가기위해서는 n-1번째 섬에서와 n-3번째 섬에서 올수가 있다.

그러면 조건은 g[i-1]+g[i-3]의 형태를 가지게 되는데 숫자가 커질 수 있으니 1000000009으로 나누어달라고 문제에서 말을 한 바가 있기에  
g[i]=(g[i-1]+g[i-3])%1000000009 를 하면 조건이 완성되는 것이다.

#include <stdio.h>
const int div=1000000009;
long long g[50000];
int main()
{
    int n,i;
    scanf("%d",&n);
    g[0]=1,g[1]=1;
    g[2]=2;
    for (i=3;i<n;i++)
        g[i]=(g[i-1]+g[i-3])%div;
    printf("%d",g[n-1]);
}

11054번: 가장 긴 바이토닉 부분 수열

Baekjoon Online Judge스타트링크 (Startlink)

이 문제는 알고보면 상당히 간단한 문제이다.

해당 문제에서 처음에 주어진 설명을 보면

예를 들어, {10, 20, 30, 25, 20}과 {10, 20, 30, 40}, {50, 40, 25, 10} 은 바이토닉 수열이지만,  {1, 2, 3, 2, 1, 2, 3, 2, 1}과 {10, 20, 30, 40, 20, 30} 은 바이토닉 수열이 아니다.

이렇게 설명이 되어있는데  여기서 바이토닉 수열인 부분을 살펴보게 되면
10, 20, 30, 25, 20 에서 10, 20, 30 까지는 증가를 하고 30, 25, 20 부분은 감소를 한다는 것을 알 수 있다.  

LIS 알고리즘을 다뤄보았는 사람이라면 알겠지만 하나의 바이토닉 수열은 증가하는 부분수열과 감소하는 부분수열으로 이루어져있다는 것을 알 수 있고
LIS 알고리즘을 정방향으로 저장하며 진행을 하고 한번은 역방향으로 다른 배열에 저장하며 진행을 한다면

[1, 2, 3, 1 ,1]-정방향
[1, 1, 3, 2, 1]-역방향

이런식으로 양측에서 가장 긴 증가/감소하는 수열을 찾을 수 있게 된다.

이제 이 문제를 보면 수열 전체에서 바이토닉 수열인 부분을 구하기 위해 LIS 알고리즘을 정방향/역방향으로 진행시키고 같은 위치의 LIS 값을 더한 최대값을 구하도록 하면 같은 위치이기에 생기는 중복된 하나의 숫자를 지우기 위해 -1을 한 값이 가장 긴 바이토닉 부분 수열이 되는 것이다.

#include<stdio.h>
#include<algorithm>
using namespace std;
int arr[1003],g[1003]={0,},f[1003]={0,};
int main()
{
    int n,i,j,mx=-999;
    scanf("%d",&n);
    for(i=0;i<n;i++)
        scanf("%d",&arr[i]);
    for(i=0;i<n;i++)
    {
        if(!g[i])g[i]=1;
        for(j=0;j<i;j++)
            if(arr[i]>arr[j]&&g[i]<g[j]+1)g[i]++;

    }
    for(i=n-1;i>=0;i--)
    {
        if(!f[i])f[i]=1;
        for(j=n-1;j>=i;j--)
             if(arr[j]<arr[i]&&f[i]<f[j]+1)f[i]++;
    }
    for(i=0;i<n;i++)
        mx=max(mx,g[i]+f[i]-1);
    printf("%d",mx);
    return 0;
}

most of developers that using Nodejs on Linux will know how to fix this, but some new comers would have a trouble so I will post a way to install NVM(Node Version Manager)

Installing

first if you installed Linux( I will explain based on Ubuntu) recently and never used the command curl
than you will need to

sudo apt install curl

after that we need to run the NVM installer

curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash 

after that you will need to logout and login to load the environment

now we will install node using NVM

nvm install node

this is the command that install the latest version of node, and if you want you can specific version of node using

nvm install 12.19.0

Using

nvm ls

this is the command that can find the installed versions of node

nvm ls-remote

this is the command that can find to available nodejs versions

nvm use xx.xx.x

this is the command that can select a different version of node

nvm run default --version 

you can also run this to find the default version of node of your system

nvm exec xx.xx.x server.js 

you can also use this to run a node script with a specific version of node

And Big Thanks to Youtuber Toby Ho

Voordat je verdergaat naar YouTube

• What is LLVM?

First of all the picture above is the way that normal programming language works
and today I'll try to follow the tutorial of the LLVM website
you can see the tutorials from

My First Language Frontend with LLVM Tutorial — LLVM 12 documentation

LLVM Logo

Now, How LLVM does work?

This is the simple ( I think so?) diagram that explaining the way how LLVM Works
and the fronted part is the area that the tutorial from the LLVM web (as I know you don't need to do the backend works)

• The Lexer

First, What is a Lexer?
Lexer is a kind of a function that is a parser that separate string of inputs into chunks

We will create the lexer first so, make a directory for the project

I'll call my Language as Nukleus-lang

mkdir Nukleus-lang
cat > nukleus.cpp

I have called my main lexer file as nukleus, just call it as you wish and press ctrl + d (Linux)
on mac or windows you can just do normal way of creating files like echo or just using the IDE that you using

After that open your IDE or editor (like VS code, Atom)
and follow the tutorial

#include <string>
 
enum Token{
  tok_eof = -1,
  tok_def = -2,
  tok_extern = -3,
  tok_identifier = -4,
  tok_number = -5,
};
 
static std::string IdentifierStr;
static double NumVal;
 
static int gettok(){
  static int LastChar = ' ';
 
  //skip spaces
  while(isspace(LastChar)){
    LastChar = getchar();
  }
 
  //get identifier
  if(isalpha(LastChar)){
    IdentifierStr = LastChar;
    while(isalnum((LastChar = getchar()))){
      IdentifierStr += LastChar;
    }
 
    if(IdentifierStr == "def"){
      return tok_def;
    }
    if(IdentifierStr == "extern"){
      return tok_extern;
    }
 
    return tok_identifier;
  }
 
  if(isdigit(LastChar) || LastChar == '.'){
    std::string NumStr;
    do{
      NumStr += LastChar;
      LastChar = getchar();
    }while(isdigit(LastChar) || LastChar == '.');
    NumVal = strtod(NumStr.c_str(), 0);
    return tok_number;
  }
 
  if(LastChar =='#'){
    do{
      LastChar = getchar();
    }while(LastChar != EOF && LastChar !='\n' && LastChar != '\r');
    if(LastChar != EOF){
      return gettok();
    }
  }
  if(LastChar == EOF){
    return tok_eof;
  }
 
  int ThisChar = LastChar;
  LastChar = getchar();
  return ThisChar;
}

This is the thing that i typed
and for review that have I typed right?

for confirming process

int main(){
  while(1){
    int tok = gettok();
    std::cout <<"got token: "<< tok << std::endl;
  }
}

I have added these line to the bottom of the code and I have used g++ from my Ubuntu computer

 g++ nukleus.cpp -o nukleus.bin

after that type

ls

Than you will see the two files, your-project-name.cpp,  your-project-name.bin

Now let's test the lexer

 ./your-project-name.bin

Euclidean Algorithm is a algorithm that gets the greatest common divisor

This algorithm usually made with a simple praise x % y=r and y % r 's greatest common divisor is same with x % y

This is the core mechanism of the Euclidean Algorithm

I'll show you guys the simplest way of coding the Euclidean Algorithm

C/C++

#include<stdio.h>
int main()
{
    int i,x,y,r,temp;
    scanf("%d %d",&x,&y);
    while(1)
    {
        r=x%y;
        if(!r)break;
        else x=y,y=r;
    }
    printf("%d",y);
    return 0;
}

Python

x=int(input())
y=int(input())
while 1:
    r=x%y
    if r==0:break
    else :
        x=y
        y=r
print(y)
 

Problem - A - Codeforces

Codeforces. Programming competitions and contests, programming community

Codeforces

Three Swimmers is a Very Simple Problem.
First of all the main subject of this problem is that we need to find the require timing for the first person to wait until any other swimmers to arrives to the left side of the pool.

and as we all know every swimmers have a sequence of

0 p 2p 3p …
0 a 2a 3a …
0 b 2b 3b …
0 c 2c 3c …

from the example case of

4
9 5 4 8
2 6 10 9
10 2 5 10
10 9 9 9

from the first case 9 5 4 8
we can fine the answer like

0 9
0 5 10
0 4 8 12
0 8 16

which makes the minimum waiting time to 1

so if we made this rule to an equation

min(a-p%a, b-p%b, c-p%c)

this equation would be a possible outcome, but in this case I don’t know why but when a-p==0
the % calculation get screwed up and throw some weird value

so to avoid that

min(a-1-(p-1)%a, (b-1-(p-1)%b, c-1-(p-1)%c)

I have done that to the equation

Index of /~kernel-ppa/mainline

What you can see is the list of available Linux Kernel Version
what you need to do is pick the kernel that you want to use (for me I used v5.12-rc6)

You can opt between low-latency and generic files.
If you want the low-latency kernel than download that, instead go only for generic files such as :

• linux-headers-x.x.x * low-latency
• linux-headers-x.x.x *_x.x.x_all.deb
• linux-image-unsigned-x.x.x * low-latency
• llinux-modules-x.x.x * low-latency

For generic download the generic Debian packages for the kernel.

• linux-headers-x.x.x * generic
• linux-headers-x.x.x *_x.x.x_all.deb
• linux-image-unsigned-x.x.x * generic
• llinux-modules-x.x.x * generic

However, one will be common in both generic and low-latency is the Linux-headers-x.x.x*_all.deb
The x.x.x in this case will be 5.12.0

Because we have downloaded from the browser

$ cd Downloads

and while avoiding to install the deb files by one by one we will use the command

$ sudo dpkg -i *.deb

after this done and your system rebooted

$ uname -sr

you will be able to see the updated kernel version