focustime: Add focustime CLI workflows and repository structure updates (#11)

Author: Unique-Divine

README.md

@@ -11,8 +11,8 @@
 | <span style="white-space: nowrap;">📂 [gocovmerge](./gocovmerge/README.md)</span> | Go coverage profile merger with modern CLI features |
 | <span style="white-space: nowrap;">📂 [mdtoc](./mdtoc/README.md)</span> | Markdown table of contents (TOC) generator |
 | <span style="white-space: nowrap;">📂 [winfixtext](./winfixtext/README.md)</span> | Fixes Windows encoding issues and corrupted LLM text outputs |
-| <span style="white-space: nowrap;">📂 [bash-ts](./bash-ts/README.md)</span> | Production TypeScript scripting library (bun install `@uniquedivine/bash`) for robust scripts with Bun runtime |
-| <span style="white-space: nowrap;">📂 [ud-jiyuu](./ud-jiyuu/README.md)</span> | TypeScript package mimicking Rust/Go functionality |
+| <span style="white-space: nowrap;">📂 [ts-pkg/bash](./ts-pkg/bash/README.md)</span> | Production TypeScript scripting library (bun install `@uniquedivine/bash`) for robust scripts with Bun runtime |
+| <span style="white-space: nowrap;">📂 [ts-pkg/jiyuu](./ts-pkg/jiyuu/README.md)</span> | TypeScript package mimicking Rust/Go functionality |
 | <span style="white-space: nowrap;">📂 [discord-nibiru](./discord-nibiru/README.md)</span> | Discord moderation bot for Nibiru community |
 | <span style="white-space: nowrap;">📦 scripts</span> | Scripts crate in Rust |
 | <span style="white-space: nowrap;">├── justfile</span> | Runs project-specific commands |

algos/000_dfs_test.go algos/000_dfs/000_dfs_test.goalgos/000_dfs_test.go renamed to algos/000_dfs/000_dfs_test.go

@@ -0,0 +1,3 @@
+# 000
+
+TODO

algos/000_dfs/log.md

@@ -1,5 +1,10 @@
 package algos
 
+import (
+	"github.com/stretchr/testify/suite"
+	"testing"
+)
+
 // Given an array of integers `nums` and an integer `target`, return indices of
 // the two numbers such that they add up to `target`.
 //
@@ -43,6 +48,12 @@ func Sol1(nums []int, target int) [2]int {
 	return [2]int{-1, -1}
 }
 
+type S struct{ suite.Suite }
+
+func Test(t *testing.T) {
+	suite.Run(t, new(S))
+}
+
 func (s *S) Test1_TwoSum() {
 	type testCase struct {
 		nums   []int

algos/001_two_sum_test.go algos/001_two_sum/001_two_sum_test.goalgos/001_two_sum_test.go renamed to algos/001_two_sum/001_two_sum_test.go

@@ -0,0 +1,38 @@
+# Ex 001: Two Sum
+
+Practice Problem:
+
+Given an array of integers `nums` and an integer `target`, return indices of
+the two numbers such that they add up to `target`.
+
+You may assume that each input would have exactly one solution, and you may
+not use the same element twice.
+
+```
+Example 1:
+Input: nums = [2,7,11,15], target = 9
+Output: [0,1]
+Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+
+Example 2:
+Input: nums = [3,2,4], target = 6
+Output: [1,2]
+
+Example 3:
+Input: nums = [3,3], target = 6
+Output: [0,1]
+```
+
+Source Info:
+- This is [Leetcode 1: Two Sum](https://leetcode.com/problems/two-sum/)
+
+Q: Describe the solution in words.
+
+- Inputs have exactly one solution -> there's guaranteed to be a correct answer.
+- Cannot use same element twice -> [0, 0] is not a valid answer, even if it
+evaluates to the target.
+
+- .x
+- .x
+- .x
+

algos/001_two_sum/log.md

@@ -1,5 +1,11 @@
 package algos
 
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
 // Given an integer array `nums` and an integer `val`, remove all occurrences of
 // `val` in `nums` in-place. The order of the elements may be changed. Then return
 // the number of elements in nums which are not equal to `val`.
@@ -29,6 +35,12 @@ package algos
 // ```
 // If all assertions pass, then your solution will be accepted.
 
+type S struct{ suite.Suite }
+
+func Test(t *testing.T) {
+	suite.Run(t, new(S))
+}
+
 // Sol2: Pushes all "val" elements to the back of "nums".
 //
 // Args:

algos/002_remove_element_test.go …emove_element/002_remove_element_test.goalgos/002_remove_element_test.go renamed to algos/002_remove_element/002_remove_element_test.go algos/002_remove_element_test.go renamed to algos/002_remove_element/002_remove_element_test.go

@@ -0,0 +1,40 @@
+# Ex 002: Remove Element
+
+Practice Problem:
+
+Given an integer array `nums` and an integer `val`, remove all occurrences of
+`val` in `nums` in-place. The order of the elements may be changed. Then return
+the number of elements in nums which are not equal to `val`.
+
+Consider the number of elements in nums which are not equal to `val` be `k`, to
+get accepted, you need to do the following things:
+- Change the array `nums` such that the first `k` elements of `nums` contain the
+  elements which are not equal to `val`. The remaining elements of `nums` are not
+  important as well as the size of `nums`.
+- Return k.
+
+Custom Judge:
+The judge will test your solution with the following code:
+```
+int[] nums = [...]; // Input array
+int val = ...; // Value to remove
+int[] expectedNums = [...]; // The expected answer with correct length.
+                            // It is sorted with no values equaling val.
+
+int k = removeElement(nums, val); // Calls your implementation
+
+assert k == expectedNums.length;
+sort(nums, 0, k); // Sort the first k elements of nums
+for (int i = 0; i < actualLength; i++) {
+    assert nums[i] == expectedNums[i];
+}
+```
+If all assertions pass, then your solution will be accepted.
+
+Source Info:
+- [Leetcode 27: Remove Element](https://leetcode.com/problems/remove-element/description/)
+- Topics: \[Array, Two Pointers\]
+
+A: 
+Impl in 002_remove_element_test.go
+

algos/002_remove_element/log.md

@@ -1,5 +1,11 @@
 package algos
 
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
 // Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements.
 //
 // Note that you must do this in-place without making a copy of the array.
@@ -26,3 +32,9 @@ func Sol3(nums []int) {
 		writeIdx++
 	}
 }
+
+type S struct{ suite.Suite }
+
+func Test(t *testing.T) {
+	suite.Run(t, new(S))
+}

algos/003_move_zeros_test.go …os/003_move_zeros/003_move_zeros_test.goalgos/003_move_zeros_test.go renamed to algos/003_move_zeros/003_move_zeros_test.go algos/003_move_zeros_test.go renamed to algos/003_move_zeros/003_move_zeros_test.go

@@ -0,0 +1,24 @@
+### Ex 003: Move Zeros
+
+Practice Problem:
+
+Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements.
+
+Note that you must do this in-place without making a copy of the array.
+
+```
+Example 1:
+Input: nums = [0,1,0,3,12]
+Output: [1,3,12,0,0]
+
+Example 2:
+Input: nums = [0]
+Output: [0]
+```
+
+Source Info:
+- [Leetcode 283: Move Zeros](https://leetcode.com/problems/move-zeroes/)
+- Topics: \[Array, Two Pointers\]
+
+A: 
+Impl in 003_move_zeros_test.go