tatsuyax25’s gists

tatsuyax25 / maxStability.js

Created March 12, 2026 15:40

You are given an integer n, representing n nodes numbered from 0 to n - 1 and a list of edges, where edges[i] = [ui, vi, si, musti]: ui and vi indicates an undirected edge between nodes ui and vi. si is the strength of the edge. musti is an integer

	/**
	* @param {number} n
	* @param {number[][]} edges
	* @param {number} k
	* @return {number}
	*/
	var maxStability = function (n, edges, k) {
	// -----------------------------
	// Disjoint Set Union (Union-Find)
	// -----------------------------

tatsuyax25 / bitwiseComplement.js

Created March 11, 2026 18:56

The complement of an integer is the integer you get when you flip all the 0's to 1's and all the 1's to 0's in its binary representation. For example, The integer 5 is "101" in binary and its complement is "010" which is the integer 2. Given an inte

	/**
	* @param {number} n
	* @return {number}
	*/
	/**
	* @param {number} n
	* @return {number}
	*/
	var bitwiseComplement = function(n) {
	// Edge case:

tatsuyax25 / numberOfStableArrays.js

Created March 10, 2026 21:46

You are given 3 positive integers zero, one, and limit. A binary array arr is called stable if: The number of occurrences of 0 in arr is exactly zero. The number of occurrences of 1 in arr is exactly one. Each subarray of arr with a size greater th

	/**
	* @param {number} zero
	* @param {number} one
	* @param {number} limit
	* @return {number}
	*/
	var numberOfStableArrays = function(zero, one, limit) {
	const MOD = 1_000_000_007;

	// dp0[x][y] = ways using x zeros, y ones, ending with 0

tatsuyax25 / numberOfStableArrays.js

Created March 9, 2026 16:32

You are given 3 positive integers zero, one, and limit. A binary array arr is called stable if: The number of occurrences of 0 in arr is exactly zero. The number of occurrences of 1 in arr is exactly one. Each subarray of arr with a size greater th

	/**
	* @param {number} zero
	* @param {number} one
	* @param {number} limit
	* @return {number}
	*/
	var numberOfStableArrays = function (zero, one, limit) {
	const MOD = 1_000_000_007;

	// ------------------------------------------------------------

tatsuyax25 / minFlips.js

Created March 7, 2026 16:14

You are given a binary string s. You are allowed to perform two types of operations on the string in any sequence: Type-1: Remove the character at the start of the string s and append it to the end of the string. Type-2: Pick any character in s and

	/**
	* @param {string} s
	* @return {number}
	*/
	var minFlips = function(s) {
	const n = s.length;
	const s2 = s + s;

	// Build alternating patterns of length 2n
	let alt0 = "", alt1 = "";

tatsuyax25 / checkOnesSegment.js

Created March 6, 2026 20:51

Given a binary string s without leading zeros, return true if s contains at most one contiguous segment of ones. Otherwise, return false.

	/**
	* @param {string} s
	* @return {boolean}
	*/
	var checkOnesSegment = function(s) {
	// This flag will turn true once we hit the first '0'
	// after the initial block of ones.
	let seenZero = false;

	// Loop through each character in the string

tatsuyax25 / minOperations.js

Last active March 5, 2026 20:53

You are given a string s consisting only of the characters '0' and '1'. In one operation, you can change any '0' to '1' or vice versa. The string is called alternating if no two adjacent characters are equal. For example, the string "010" is alterna

	/**
	* @param {string} s
	* @return {number}
	*/
	var minOperations = function(s) {
	// cost0 = number of flips needed if we force pattern "010101..."
	// cost1 = number of flips needed if we force pattern "101010..."
	let cost0 = 0;
	let cost1 = 0;

tatsuyax25 / numSpecial.js

Created March 4, 2026 17:59

Given an m x n binary matrix mat, return the number of special positions in mat. A position (i, j) is called special if mat[i][j] == 1 and all other elements in row i and column j are 0 (rows and columns are 0-indexed).

	/**
	* @param {number[][]} mat
	* @return {number}
	*/
	var numSpecial = function(mat) {
	const m = mat.length;
	const n = mat[0].length;

	// Count how many 1s appear in each row
	const rowCount = new Array(m).fill(0);

tatsuyax25 / minSwaps.js

Created March 2, 2026 18:00

Given an n x n binary grid, in one step you can choose two adjacent rows of the grid and swap them. A grid is said to be valid if all the cells above the main diagonal are zeros. Return the minimum number of steps needed to make the grid valid, or

	/**
	* @param {number[][]} grid
	* @return {number}
	*/
	var minSwaps = function(grid) {
	const n = grid.length;

	// Step 1: For each row, compute the index of the rightmost 1.
	// If a row has no 1s, store -1.
	const rightmost = new Array(n).fill(0);

tatsuyax25 / minPartitions.js

Created March 1, 2026 17:27

A decimal number is called deci-binary if each of its digits is either 0 or 1 without any leading zeros. For example, 101 and 1100 are deci-binary, while 112 and 3001 are not. Given a string n that represents a positive decimal integer, return the m

	/**
	* @param {string} n
	* @return {number}
	*/
	var minPartitions = function(n) {
	// We want the minimum number of deci-binary numbers needed.
	// A deci-binary number can only contribute 0 or 1 to each digit.
	// Therefore, the number of deci-binary numbers required is equal
	// to the maximum digit in the string.

Miguel Urena tatsuyax25