Why do we use graph neural network? In the protein interaction prediction task, the graph neural network (GNN) is often used.

The protein and its interaction are represented as a graph structure. The above is mentioned as a reason for using GNN in ordinary researches. However, we wonder why GNN works better than other machine learning (ML) or deep learning (DL) models, such as random forest or convolutional neural network (CNN).

The goal of this post is to explain why we use GNN by comparing the other model.

In this section, the background information of the receptive field is described.

This post handles extracting the slice, subset that shows a minimum average, from the numeric list.

A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P < Q < N, is called a *slice* of array A (notice that the slice contains at least two elements). The *average* of a slice (P, Q) is the sum of A[P] + A[P + 1] + … + A[Q] divided by the length of the slice. …

In this post, we will find the priority letter and coefficient of them in several DNA subsequences.

A DNA sequence can be represented as a string consisting of the letters A, C, G and T, which correspond to the types of successive nucleotides in the sequence. Each nucleotide has an *impact factor*, which is an integer. Nucleotides of types A, C, G and T have impact factors of 1, 2, 3 and 4, respectively. …

This post deals with the problem of counting the number of elements whose remainder is 0 when divided by a specific value in a given array.

Write a function:

def solution(A, B, K)

that, given three integers A, B and K, returns the number of integers within the range [A..B] that are divisible by K, i.e.:

{ i : A ≤ i ≤ B, i **mod** K = 0 }

For example, for A = 6, B = 11 and K = 2, your function should return 3, because there are three numbers divisible by 2 within the range [6..11]…

The topic of this post is checking the permutation. The problem that we want to solve follows.

A non-empty array A consisting of N integers is given.

A *permutation* is a sequence containing each element from 1 to N once, and only once.

For example, array A such that:

A[0] = 4

A[1] = 1

A[2] = 3

A[3] = 2

is a permutation, but array A such that:

A[0] = 4

A[1] = 1

A[2] = 3

is not a permutation, because value 2 is missing.

The goal is to check whether array A is a permutation.

Write a…

Sometimes, we want to compare two images, taken at two different moments. Even if those were shot at different angles or different scales.

In this post, the simple method, for matching two images to very similar conditions, will be handled. The above method called ‘Rigid Registration’.

The target image for registration is the following. The image is provided from the misc of the ‘scipy’ package.

Now, we have got one image as a target but we do not have the source image. So, we generate an arbitrary source image by transforming the target image. …

Finding the missing value in a given array is handled in this post. The problem definition can be confirmed via the following URL.

This is a demo task.

Write a function:

def solution(A)

that, given an array A of N integers, returns the smallest positive integer (greater than 0) that does not occur in A.

For example, given A = [1, 3, 6, 4, 1, 2], the function should return 5.

Given A = [1, 2, 3], the function should return 4.

Given A = [−1, −3], the function should return 1.

Write an **efficient** algorithm for the following assumptions:

- …

The problem named ‘MaxCounters’ is handled via this post. The URL for confirming the original task is the following.

You are given N counters, initially set to 0, and you have two possible operations on them:

*increase(X)*− counter X is increased by 1,*max counter*− all counters are set to the maximum value of any counter.

A non-empty array A of M integers is given. This array represents consecutive operations:

- if A[K] = X, such that 1 ≤ X ≤ N, then operation K is increase(X),
- if A[K] = N + 1 then operation K is max counter.

…

This post handles the first solution of lesson 4 using python. The topic of lesson 4 is the ‘Counting Elements’.For accessing the problem, click the following link.

A small frog wants to get to the other side of a river. The frog is initially located on one bank of the river (position 0) and wants to get to the opposite bank (position X+1). Leaves fall from a tree onto the surface of the river.

You are given an array A consisting of N integers representing the falling leaves. …

In this post, the third solution for lesson 3 with reducing time complexity is handled. For accessing the problem, click the following link.

A non-empty array A consisting of N integers is given. Array A represents numbers on a tape.

Any integer P, such that 0 < P < N, splits this tape into two non-empty parts: A[0], A[1], …, A[P − 1] and A[P], A[P + 1], …, A[N − 1].

The *difference* between the two parts is the value of: |(A[0] + A[1] + … + A[P − 1]) − (A[P] + A[P + 1] + … +…

GitHub: https://github.com/YeongHyeon