DEV Community: Trinity

ARM BASICS

Trinity — Mon, 18 May 2026 19:50:30 +0000

STR Rx, [Ry]

STORE the value of Rx into the memory with address saved in Ry. So, it's not 'Save value of R3 into R1.' More precisely, suppose R1 has memory address 0x1234, then program will look up memory 0x1234 and save the value there, not directly into R1.

LDR Rx, [Ry]

Program: I will look up the value of Ry, that will be your memory address I will look up, then I will load the value in that memory into Rx.

To wake up cores, you need to

Save the program counter somewhere
Save the #0xe0 or #0xe8 or #0xf0 for core 1, 2, and 3 respectively
Move the PC address into the memory address above.

Hot take - you don't need react

Trinity — Fri, 21 Feb 2025 03:30:20 +0000

don't learn react
just learn javascript and typescript and build one without using react because react is just javascript and typescript.
if anyone tells you react is to ease your life in building software, know it is not, you can do it with just javascript and typescript, react is just a bloat, trying to obscure your understanding of the subject.

Core C++ OOP Concepts

Trinity — Thu, 08 Sep 2022 02:37:15 +0000

Four concepts:

Encapsulation - setting access level for whatever is inside a class
Abstraction - creating a design of things you like

Things learned today

When you write static array and assign to a variable with less than x in array[x] then the rest of the space is by default filled in as 0 (in c++ 14)
If you do not specify the length of the array, then the size is size of element multiplied by how many you put in when you initialize
array as argument in a function parameter will 'read' only one element (int* aka pointer to int)

Pointer & Reference & Deference in C++

Trinity — Sat, 16 Jul 2022 08:26:16 +0000

Say you have a variable 'a' of type integer.
int a = 4;

Then, you can find the address of 'a' using pointer.
int *b = &a;

Well, not exactly because '&a' will give you the address as well. Try,
cout << &a; // will output address of the variable a

But, back to the pointer, it gives you the ability to 'save' the address of memory. Hence, it will show memory address of 'a' as well. Try,
cout << b

What would happen if I try printing out *b? It will give you the value of 'a'. Weird, isn't it? This behavior is called dereferencing, meaning you get the actual value of whatever is saved in that memory.

Does b have memory address as well? Yes, you can access it with '&b'

So, in summary

int a = 4; // note it has memory allocated to this integer
int *b = &a; // you can save the memory address to a variable 'a'
cout << b; // it will give you memory address of 'a'. Notice how it is not saved in '*b' but 'b' itself. 
cout << &a; // this will give you memory address of 'a'
cout << *b; // this will give you the value of 'a'. Dereferenced!

Question remains: what would &*b produce? what will *&a produce?

Answer:
&*b -> it is address of pointer to 'a', hence same as &a, memory address where 'a' is saved.
*&a -> * dereferences memory address aka finds out the value in the address hence value of 'a'

Blindly Following Other People's Solution

Trinity — Fri, 17 Jun 2022 21:36:02 +0000

There are some things I do not understand in the coding world: Making assumptions like it's true. Let's see this solution to binary search.

The question is to find a target number in an array of numbers. If the target is not in the array, return -1. If it is, return the index of the target in the array.

This user's coding solution is brilliant

var search = function(nums, target) {
    let lo = 0, hi = nums.length-1;
    while (lo < hi) {
        let mid = lo + Math.floor((hi-lo+1)/2);
        if (target < nums[mid]) {
            hi = mid - 1
        } else {
            lo = mid; 
        }
    }
    return nums[lo]==target?lo:-1;
};

The solver goes on further to explain (which I really appreciate by the way rather than simply writing down solution) the logic behind his choice of indexes of midpoint, low, and high.

Quote

But! That seemingly sound very mathematical or programmatic is actually not that rigorous because if you change lo+hi/2 to lo+hi+1/2 there won't be an overflow. So, there is nothing wrong with that certain operations.

This, I think is the problem in trying to understand every leetcode problem on the high level. You will not get things correct.

Beware folks! You never know what's true until you see and understand how it works.

Invert Binary Tree - JS

Trinity — Thu, 16 Jun 2022 12:49:54 +0000

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
// DFS
function invertTree(root) {
    if (root === null) return root
  var temp = root.left;
  root.left = root.right;
  root.right = temp;
  invertTree(root.left);
  invertTree(root.right);
  return root;
}

Binary tree - js

Trinity — Thu, 16 Jun 2022 12:06:27 +0000

Depth First Values


const depthFirstValues = (root) => {

    if (root === null) return [];

    const stack = [root];

    const result = [];

    while (stack.length > 0) {
        const current = stack.pop();

        result.push(current.val);

        if (current.right) stack.push(current.right);
        if (current.left) stack.push(current.left);

    }

    return result;

}

c++ - valid parenthesis

Trinity — Wed, 15 Jun 2022 01:28:27 +0000

Still not fully understood but here's the solution

class Solution {
public:
    bool isValid(string s) {
        unordered_map<char, char> bracketHash;

        bracketHash['{'] = '}';
        bracketHash['['] = ']';
        bracketHash['('] = ')';

        stack<char> st;

        char last;

        int checkVal;

        if (s.length() == 0)
        {
            return true;
        }

        if (s[0] == '}' || s[0] == ']' || s[0] == ')')
        {
            return false;
        }

        for (int i = 0; i < s.size(); ++i)    
        {
            if (s[i] == '{' || s[i] == '(' || s[i] == '[')
            {
                st.push(s[i]);
            }

            else
            {

                if (st.empty())
                {
                    return false;
                }
                else if (s[i] != bracketHash[st.top()])
                {
                    return false;
                }
                st.pop();
            }
        }


        return st.empty();
    }
};

You might wonder why I post then. I know I solved this in Python. Just adopted the same logic. Still long way to go to think like a computer. I need time to understand. I mean I understand all the methods and why it works but did not run loop myself to simulate long bracket in my head.

String size vs string length

Trinity — Tue, 14 Jun 2022 23:53:08 +0000

I don't know what the difference is so I searched what the difference is...

They are the same! It is for semantic purpose that both methods exist in different names but the function is exactly the name - which returns a number of characters.

So, mystery solved!

Learning new things.

Trinity — Tue, 14 Jun 2022 23:48:16 +0000

You need patience. Especially learning hard ones, note it takes time and patience and you need to take step by step. This is a note to self.

c++ note - unordered_map

Trinity — Tue, 14 Jun 2022 23:45:35 +0000

Unordered_map has method find not has
If property (or key? not sure what the right term is) exists, then the unordered map's end value will be not equal. If doesn't, it will equal it's end value. I don't know why.

Two Sum - O(n) Solution

Trinity — Tue, 14 Jun 2022 02:07:12 +0000


class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {



        unordered_map<int, int> hash;
        vector<int> result;

        for (int i = 0; i < nums.size(); ++i)
        {
            int numToFind = target - nums[i];

            if (hash.find(numToFind) != hash.end())
            {
                result.push_back(hash[numToFind]);
                result.push_back(i);
                return result;
            }
            else
            {
                hash[nums[i]] = i;
            }
        }



        return result;

    }
};