First thing first, lets install some tools we need.

- WebAssembly Binary Toolkit, or
*wabt*

- Go to https://github.com/WebAssembly/wabt/releases
- download based on your OS, I am MAC
- uzip the artifact, you have downloaded

To make life easier, I have updated my zshrc file, so i can run wabt commands. Like

`# WebAssembly`

alias wat2wasm="~/Downloads/wabt-1.0.23/bin/wat2wasm"

alias wasm-decompile="~/Downloads/wabt-1.0.23/bin/wasm-decompile"

alias wasm-objdump="~/Downloads/wabt-1.0.23/bin/wasm-objdump"

alias wasm-strip="~/Downloads/wabt-1.0.23/bin/wasm-strip"

alias wasm2c="~/Downloads/wabt-1.0.23/bin/wasm2c"

alias wast2json="~/Downloads/wabt-1.0.23/bin/wast2json"

alias wasm2wat="~/Downloads/wabt-1.0.23/bin/wasm2wat"

alias wasm-interp="~/Downloads/wabt-1.0.23/bin/wasm-interp"

As you can see, I have downloaded wabt in Downloads folder and I unzip there.

Now run the command from a different terminal

`wasm2wat --version`

If that works, you are ready to write your…

Given an integer `n`

(in base `10`

) and a base `k`

, return *the **sum** of the digits of *`n`

* **after** converting *`n`

* from base *`10`

* to base *`k`

.

After converting, each digit should be interpreted as a base `10`

number, and the sum should be returned in base `10`

.

**Example 1:**

**Input:** n = 34, k = 6

**Output:** 9

**Explanation: **34 (base 10) expressed in base 6 is 54. 5 + 4 = 9.

**Example 2:**

**Input:** n = 10, k = 10

**Output:** 1

**Explanation: **n is already in base 10. 1 + 0 = 1.

**Constraints:**

`1…`

The **frequency** of an element is the number of times it occurs in an array.

You are given an integer array `nums`

and an integer `k`

. In one operation, you can choose an index of `nums`

and increment the element at that index by `1`

.

Return *the **maximum possible frequency** of an element after performing **at most** *`k`

* operations*.

**Example 1:**

**Input:** nums = [1,2,4], k = 5

**Output:** 3

Explanation: Increment the first element three times and the second element two times to make nums = [4,4,4].

4 has a frequency of 3.

**Example 2:**

**Input:** nums = [1,4,8,13]…

You are given two positive integer arrays `nums1`

and `nums2`

, both of length `n`

.

The **absolute sum difference** of arrays `nums1`

and `nums2`

is defined as the **sum** of `|nums1[i] - nums2[i]|`

for each `0 <= i < n`

(**0-indexed**).

You can replace **at most one** element of `nums1`

with **any** other element in `nums1`

to **minimize** the absolute sum difference.

Return the *minimum absolute sum difference **after** replacing at most one** **element in the array **nums1**.* Since the answer may be large, return it **modulo** `109 + 7`

.

`|x|`

is defined as:

`x`

if`x >= 0`

, or`-x`

…

You are given the logs for users’ actions on LeetCode, and an integer `k`

. The logs are represented by a 2D integer array `logs`

where each `logs[i] = [IDi, timei]`

indicates that the user with `IDi`

performed an action at the minute `timei`

.

**Multiple users** can perform actions simultaneously, and a single user can perform **multiple actions** in the same minute.

The **user active minutes (UAM)** for a given user is defined as the **number of unique minutes** in which the user performed an action on LeetCode. …

A **sentence** is a list of words that are separated by a single space with no leading or trailing spaces. Each of the words consists of **only** uppercase and lowercase English letters (no punctuation).

- For example,
`"Hello World"`

,`"HELLO"`

, and`"hello world hello world"`

are all sentences.

You are given a sentence `s`

and an integer `k`

. You want to **truncate** `s`

such that it contains only the **first** `k`

words. Return `s`

* after **truncating** it.*

**Example 1:**

**Input:** s = "Hello how are you Contestant", k = 4

**Output:** "Hello how are you"

**Explanation:**

The words in s are ["Hello", "how" "are"…

You are given an **even** integer `n`

. You initially have a permutation `perm`

of size `n`

where `perm[i] == i`

**(0-indexed)**.

In one operation, you will create a new array `arr`

, and for each `i`

:

- If
`i % 2 == 0`

, then`arr[i] = perm[i / 2]`

. - If
`i % 2 == 1`

, then`arr[i] = perm[n / 2 + (i - 1) / 2]`

.

You will then assign `arr`

to `perm`

.

Return *the minimum **non-zero** number of operations you need to perform on *`perm`

* to return the permutation to its initial value.*

**Example 1:**

**Input:** n = 2

**Output:** 1

**Explanation…**

You are given a string `s`

that contains some bracket pairs, with each pair containing a **non-empty** key.

- For example, in the string
`"(name)is(age)yearsold"`

, there are**two**bracket pairs that contain the keys`"name"`

and`"age"`

.

You know the values of a wide range of keys. This is represented by a 2D string array `knowledge`

where each `knowledge[i] = [keyi, valuei]`

indicates that key `keyi`

has a value of `valuei`

.

You are tasked to evaluate **all** of the bracket pairs. When you evaluate a bracket pair that contains some key `keyi`

, you will:

- Replace
`keyi`

and the bracket pair with…

**Fast Inverse Square Root — A Quake III Algorithm**

https://www.youtube.com/watch?v=p8u_k2LIZyo

2. **Bresenham’s Circle Drawing Algorithm**

3. Aho Corasick for string pattern matching

Note: It will be synced with github…

- We can have a main thread which will monitor the crontab file for any job additions.
- As soon as there is a new job added, we can fire a new thread dedicated to that job.

@Override

void run()

{

while(true)

{

newJob = getNewJobFromCrontabFile() // blocking call

JobThread newJobThread = new JobThread(newJob);

newJobThread.start();

}

}@Override

void run()

{

while(true)

{

Thread.sleep(job.getNextExecutionTime() - currentTime());

job.execute();

job.setNextExecutionTime(currentTime() + job.getExecutionInterval());

}

}

Enterprise Applications Architectecture | JAVA | Rust |Parallel & Distributed Programing | Node.js | IoT | Golang |Starter|Microservices