# Minimum Absolute Sum Difference

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`

# Finding the Users Active Minutes

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. …

# Truncate Sentence

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…`

# Minimum Number of Operations to Reinitialize a Permutation

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…`

# Evaluate the Bracket Pairs of a String

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…

# Approach 1:

• 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.
`@Overridevoid run(){    while(true)    {        newJob = getNewJobFromCrontabFile() // blocking call        JobThread newJobThread = new JobThread(newJob);        newJobThread.start();    }}@Overridevoid run(){    while(true)    {        Thread.sleep(job.getNextExecutionTime() - currentTime());        job.execute();        job.setNextExecutionTime(currentTime() + job.getExecutionInterval());    }}`
• This is a very simple approach.
• However, it suffers from performance issues as a machine can only contain so many threads at a time. …

# Find Center of Star Graph

There is an undirected star graph consisting of `n` nodes labeled from `1` to `n`. A star graph is a graph where there is one center node and exactly `n - 1` edges that connect the center node with every other node.

You are given a 2D integer array `edges` where each `edges[i] = [ui, vi]` indicates that there is an edge between the nodes `ui` and `vi`. Return the center of the given star graph.

Example 1:

`Input: edges = [[1,2],[2,3],[4,2]] Output: 2 Explanation: As shown in the figure above, node 2 is connected to every other node, so…`

# Check if One String Swap Can Make Strings Equal

You are given two strings `s1` and `s2` of equal length. A string swap is an operation where you choose two indices in a string (not necessarily different) and swap the characters at these indices.

Return `true` if it is possible to make both strings equal by performing at most one string swap on exactly one of the strings. Otherwise, return `false`.

Example 1:

`Input: s1 = "bank", s2 = "kanb"Output: trueExplanation: For example, swap the first character with the last character of s2 to make "bank".`

Example 2:

`Input: s1 = "attack", s2 = "defend" Output: false…`

# Building AWS step function, lambda with CDK and handling error case.

Todo: This will post will be updated. Here is just some sample code.

Problem Statement: I want to create a step function backed by lambda. For failure cases, I will retry to execute the lambda several time and if it still fail, we will execute failed task. For succeed, we will finish.

Solution:

1. Create a lambda which will execute from step function as first step,
`const workFunction = lambda.Function.fromFunctionArn(this,    'stepfunctionLambda',    'arn:aws:lambda:us-east-1:***:function:lambdaForStepFunction');`

2. Invoke the lambda as a task

`const workJob = new tasks.LambdaInvoke(this, 'Submit Job', { lambdaFunction: workFunction, // Lambda's result is in the attribute `Payload` retryOnServiceExceptions: false, outputPath: '\$.Payload'…` ## Omar Faroque

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