DEV Community: JaeHonity

Prime number determination (aka Sieve of Eratosthenes)

JaeHonity — Thu, 03 Jul 2025 06:52:40 +0000

Prime number determination can be approached in several ways.

Basic Double For-Loop

bool[] era = new bool[1000001]; // 1,000,000

// 0 & 1 are not prime numbers
era[0] = true;
era[1] = true;

for(int i = 2; i <= era.Length; i++)
{
    for(int j = 2; j <= i; j++)
    {
        if(i % j == 0)
        {
            era[i] = true;
            break;
        }
    }
}

In this way, it is fundamentally possible to determine primes using a double for-loop.

However, this method has a time complexity of up to

O(n^2)

, making it highly inefficient.

In practice, with 1,000,000 data points, it takes more than 10 seconds to execute.

For-Loop Using Square Root

Let's think simply about what makes a number prime.

Take the number 10.
The square root of 10 is about 3.xxxxx.
If there is any number between 2 and 3 that divides 10 evenly, then 10 is not a prime.

For example, for 121:
If any number between 2 and 11 divides 121 evenly, then 121 is not a prime.
Since 121 % 11 == 0, it is not a prime.

The code looks like this:

bool[] era = new bool[1000001]; // 1,000,000

// 0 & 1 are not prime numbers
era[0] = true;
era[1] = true;

for(int i = 2; i <= era.Length; i++)
{
    int sqrt = (int)Math.Sqrt(i);
    for(int j = 2; j <= sqrt; j++)
    {
        if(i % j == 0)
        {
            era[i] = true;
            break;
        }
    }
}

This method is sufficiently fast, but there is an even faster approach.

The time complexity is

\sqrt{n})

Sieve of Eratosthenes

This method starts from 2 and eliminates all multiples of each number except itself, leaving only prime numbers.

For example, starting from 2, you eliminate 4, 6, 8, etc. (all multiples of 2 except 2 itself).
Then, for 3, you eliminate 6, 9, 12, etc., and so on.

bool[] era = new bool[1000000]; // 1,000,000

// 0 & 1 are not prime numbers
era[0] = true;
era[1] = true;

int sqrt = (int)Math.Sqrt(era.Length);  

// 1
for (int i = 2; i <= sqrt; i++)  
{  
    // 2
    if (era[i] == false) {  
        // 2-1
        for (int j = i * i; j < era.Length; j += i)  
        {  
            era[j] = true;  
        }  
    }  
}

The process is as follows:

Since the maximum number is one million, iterate only up to the square root of one million, which is 1,000.

Even with this, all numbers up to one million are checked.

If a number has not been filtered out,

Eliminate all multiples of that number, starting from its square.

In this way, initially, 4, 6, 8, 10... are filtered, then 3, 9, 15..., and so on.
If a number has already been filtered, it is skipped, and the process continues with the next.

The time complexity is

O (n * (l o g * (l o g * n)))

, making it extremely efficient for large ranges.

Also Extremly fast.

Coding Test - Snail wants to climb

JaeHonity — Wed, 02 Jul 2025 05:44:22 +0000

https://www.acmicpc.net/problem/2869

In the beginning, I thought it's so simple test because one while loop can solve it.

But after I failure the test cases, I check one more time and they want "0.25" second of optimization.

Spoiler

I found the math logic.

each day, Snail climbs up and fell down, but other way, Snail is fell down and climb up.

So there's this logic is available.

n = days

-fall * (n - 1) + climb  * n >= max
-fall * n + fall + climb * n >= max
-fall * n + climb * n >= max - fall
(climb-fall) * n >= max - fall
n = (max - fall) / (climb - fall)

and without loop, just one time of calculation is solving the problem!

Quaternion in Unity

JaeHonity — Thu, 05 Jun 2025 11:57:22 +0000

Quaternion

A Quaternion consists of a 3D vector (x, y, z) along with an additional scalar value, w.

Vector3 from unity

Just like a Vector3, it's a struct-based data type.

In other words, it has x, y, z as the axis of rotation, and w as a scalar value representing the amount of rotation.

Scalar: A value with magnitude but no direction

Vector: A value with both magnitude and direction

So why does it need these four components?

Gimbal Lock / Euler Angles

In 3D space, the axes look like this:

Visualized differently:

When rotating around these axes...

...axes can lock together, causing what's known as gimbal lock.

In this situation, the purple and green axes rotate together, causing one or more axis's rotation to be indistinguishable from another's.

Even though a rotation is occurring, it might appear stationary. This type of rotation is called Euler angle rotation.

To solve this problem, Quaternions were introduced with the help of that extra w component.

Rotate and Direction In Unity

How to Rotate?

According to the Unity documentation:

In general, it’s better to use Euler angles in scripts.

In this case, store the angle as a variable and only use the Euler angles to apply rotation.

Ultimately, it should still be stored as a Quaternion.

You can read Euler angles from a Quaternion, but modifying them and converting back can cause issues.

Unity Quaternion

So while using Euler angles in code can be convenient, modifying values extracted from a Quaternion and then converting them back to a Quaternion can lead to unexpected rotation results.

Here are some code examples:

1. Modifying the `x` component of a Quaternion directly

[SerializeField] private float rotSpeed;  

private void Update()  
{  
    Quaternion rot = transform.rotation;  
    rot.x += Time.deltaTime * rotSpeed;  
    transform.rotation = rot;  
}

This leads to an incorrect rotation.

The problem arises because the modified value does not represent an actual angle.

2. Reading Euler angles from a Quaternion, modifying, and applying back

[SerializeField] private float rotSpeed = 170;  

private void Update()  
{  
    Vector3 angles = transform.rotation.eulerAngles;  
    angles.x += Time.deltaTime * rotSpeed;  
    transform.rotation = Quaternion.Euler(angles);  
}

This results in gimbal lock.

Euler angles extracted from a Quaternion can be inconsistent due to internal Quaternion calculations.

3. The correct way

As suggested by the official documentation, keep the angle as a class-level variable and apply it directly using Quaternion.Euler.

[SerializeField] private float rotSpeed;  

private float x;  
void Update ()   
{  
    x += Time.deltaTime * rotSpeed;  
    transform.rotation = Quaternion.Euler(x, 0, 0);  
}

Store the Euler angles in a class-level variable
Don’t rely on reading and modifying them every frame!

summary

Incorrect Approach	Recommended Approach
Read `eulerAngles` every frame and modify	Store Euler angles in a variable and update it
Re-create a Quaternion every frame	Convert to Quaternion only once per update

Usage

For example, if you're implementing user movement:

void OnKeyboard()  
{  
    if (Input.GetKey(KeyCode.W))  
    {  
        transform.rotation = 
            Quaternion.Slerp(transform.rotation, 
                             Quaternion.LookRotation(Vector3.forward), 
                             _rotationSpeed);  

        transform.position += Vector3.forward * (Time.deltaTime * _speed);  
    }  
    //...
}

Here, we use Quaternion.Slerp to interpolate between the current rotation and the target rotation (Quaternion.LookRotation) based on _rotationSpeed.

Interpolation :
Filling in the values between A and B at a given ratio.

So, from the current rotation to the new target (Quaternion.LookRotation(Vector3.forward)), the code fills in the rotation by a proportion of _rotationSpeed.

The start and end values are considered to be 1 unit apart, and the third parameter determines the fraction to interpolate between them.

Lerp vs Slerp

Abbreviation

Lerp: Linear interpolation
Slerp: Spherical (as in "sphere-shaped") linear interpolation

Difference:

Lerp: Straight-line interpolation
Slerp: Curve-based interpolation over a sphere

If _rotationSpeed is 1/3,

Lerp will evenly divide the straight line between A and B into thirds.
But when projected onto a spherical surface, it will no longer represent exactly 1/3 of the rotation arc.

Thus:

Lerp: Linearly fills in based on a straight path
Slerp: Fills in proportionally along a curve, maintaining constant rotation speed

Vector3 from Unity

JaeHonity — Wed, 04 Jun 2025 11:22:28 +0000

What is Vector3?

When a GameObject moves due to physics calculations or simple position changes, its position value changes.
This position is represented by a structure called Vector3.

As shown in the images above, the Transform's position is a Vector3, and you can see that Vector3 is a struct.

So, what is Vector3 used for?

Position

As the name suggests, it is used to determine an object's position.

Vector3 operates based on three axes:

x-axis: horizontal
y-axis: vertical
z-axis: vertical in the 2D space relative to the x-axis

This is how it works.

In 2D space, the z-axis is typically interpreted as the depth (front-back positioning) of an object.

Direction

In 2D vectors, direction can be easily calculated using the Pythagorean theorem.

Let’s say User A is at position (1, 2), and User B is at position (4, 8).

Using the equation $f^2 + g^2 = h^2$ , you can find the direction from A to B.

However, determining direction becomes more complex in 3D vectors.

So, it’s helpful to know that direction can be derived using vectors

Vector Magnitude

The segment h that connects the positions and direction represents the vector’s magnitude.
$A,B→=<4,8>\overrightarrow{A,B} = <4,8>$

While it's simple to calculate in 2D,
in 3D space, calculating the magnitude is more challenging due to the additional axis.

This is where magnitude comes in handy.
By computing the difference between two points in 3D space and using the magnitude,
you can find the length of the vector between them.

Vector3 A = new Vector3(4, 8, 7)
Vector3 B = new Vector3(3, 10, 5)
float magnitude = (A - B).magnitude

It can also be used to calculate speed:

Vector3 velo = new Vectore(1, 2, 3);
float magVelo = velo.magnitude;

Vector3.magnitude

The magnitude of a vector is used to measure distance, calculate speed, and determine direction.

The magnitude is calculated as $x2+y2+z2\sqrt{x^2 + y^2 + z^2}$ .
sqrMagnitude gives the value before the square root, i.e., $x^2 + y^2 + z^2$ .
When you only need to compare distances, you can use sqrMagnitude to avoid the computational cost of a square root operation.

Vector3.magnitude

normalized

normalized is used when the magnitude (distance or speed) varies and you want to normalize the vector’s size.
Vector3.noramlized

Its implementation looks like this:

A normalized vector has a magnitude of 1 but retains its original direction.
It’s the result of dividing each component of the Vector3 by its magnitude.

For example, if Vector3 = (2, 2, 1), the magnitude is 3, so
it becomes (2/3, 2/3, 1/3).
Then, calculating the magnitude:
$(23)2+(23)2+(13)2=1\sqrt{(\frac{2}{3})^2 + (\frac{2}{3})^2 + (\frac{1}{3})^2} = 1$ — it has a length of 1.

using UnityEngine;  

public class Test : MonoBehaviour  
{  
    private Vector3 point = new Vector3(1, 0, 0);  
    private Vector3 diagonalPoint = new Vector3(2, 2, 1);  

    void Start()  
    {  
        Debug.Log($"point: {point.magnitude}");  
        Debug.Log($"diagonalPoint: {diagonalPoint.magnitude}");  
        Debug.Log($"normalized Point: {point.normalized.magnitude}");  
        Debug.Log($"normalized DiagonalPoint: {diagonalPoint.normalized.magnitude}");  
    }  
}

If you run the above code to test normalized,
you’ll get the following result:

Let’s assume a user jumps in a 2D space.
If they jump from coordinate (0, 0) to (1, 1),
the horizontal movement is 1 unit on the x-axis,
but the jump’s force, using the Pythagorean theorem, is $12+12\sqrt{1^2 + 1^2}$ = 1.414213...
Therefore, because each axis’s velocity differs, using normalized adjusts the direction vector to a magnitude of 1,
allowing consistent force or speed calculations.

Singleton for Unity

JaeHonity — Tue, 03 Jun 2025 15:45:41 +0000

A basic singleton in Unity can be implemented like this:

using UnityEngine;

public class Managers : MonoBehaviour
{
    private static Managers Instance;

    public static Managers GetInstance() { return Instance; }

    void Start()
    {
        GameObject go = GameObject.Find("@Managers");
        Instance = go.GetComponent<Managers>();
    }

    void Update() { }
}

This works, but there's a problem:

If another object tries to access the singleton before the manager object exists, it will be null.

So we need to make sure that:

If the manager GameObject exists:

Just find it and assign it as the singleton.

If it doesn't exist:

Create the manager GameObject and assign it as the singleton.

using UnityEngine;

public class Managers : MonoBehaviour
{
    private static Managers s_Instance;

    // 1.
    // Use the Instance property to access s_Instance
    public static Managers Instance
    {
        get
        {
            Init();
            return s_Instance;
        }
    }

    static void Init()
    {
        // 2.
        // Called through the Instance property

        if (s_Instance == null)
        {
            // 2-1.
            // If s_Instance is null (which it will be the first time),
            // try to find a GameObject named "@Managers"
            GameObject go = GameObject.Find("@Managers");

            // 3.
            // If no such GameObject exists (i.e., not found in the Hierarchy)
            if (go == null)
            {
                // 4.
                // Create a new GameObject named "@Managers"
                // and add the Managers component to it
                go = new GameObject() { name = "@Managers" };
                go.AddComponent<Managers>();
            }

            // 3-1.
            // If the GameObject "@Managers" already exists,
            // make sure it is not destroyed on scene changes
            // and assign the Managers component to s_Instance
            DontDestroyOnLoad(go);
            s_Instance = go.GetComponent<Managers>();
        }
    }
}

This way, s_Instance will always refer to the correct Managers instance.