Muhammad Khan

@muhammadkhan.dev

75 Followers 109 Following

Despite being terribly unreasonable, I like to think of myself as rational & practical. He/Him 📍 Lahore, Pakistan

export const nearestPerfectMonths = (year: number) => {
const result = { prev: new Date(year, 0, 1), next: new Date(year + 1, 0, 1) };

while (![4, 5].includes(result.prev.getDay())) {
result.prev = new Date(result.prev.getFullYear() - 1, 0, 1);
}
while (![4, 5].includes(result.next.getDay())) {
result.next = new Date(result.next.getFullYear() + 1, 0, 1);
}

return {
prev: `${result.prev.getFullYear()}-02`,
next: `${result.next.getFullYear()}-02`,
};
};

const countVowels = (word: string) => word.match(/[aeiou]/gi)?.length || 0;

export const flippedy = (str: string) => {
const words = str.split(" ");

const firstWord = words[0];

if (!firstWord) return str;

const vowelCount = countVowels(firstWord);

return words.reduce((acc, word) => {
if (countVowels(word) === vowelCount) {
return acc + " " + word.split("").reverse().join("");
}

return acc + " " + word;
});
};

export const hungryBears = (bears: { name: string; hunger: number }[]) =>
bears
.filter(bear => bear.hunger > bears.reduce((sum, bear) => sum + bear.hunger, 0) / bears.length)
.sort((a, b) => a.name.localeCompare(b.name))
.map(bear => bear.name);

export const sumOfNeighbors = (arr: number[]): number => {
let sum = 0;

for (let i = 0; i < arr.length; i++) {
sum += (arr[i - 1] || 0) + (arr[i] || 0) + (arr[i + 1] || 0);
}

return sum;
};

export const canFormHexagon = (sides: number[]): boolean => {
if (sides.length !== 6) return false;

const sideCount: Record<number, number> = {};
for (const side of sides) {
sideCount[side] = (sideCount[side] || 0) + 1;
}

return Object.values(sideCount).filter(count => count >= 2).length === 3;
};

export const nonRepeat = (str: string): string => {
const charCount: Record<string, number> = {};

for (const char of str) {
charCount[char] = (charCount[char] || 0) + 1;
}

for (let i = str.length - 1; i >= 0; i--) {
const char = str[i] || "";
if (charCount[char] === 1) return char;
}

return "";
};

$const ROMAN_MAP = { I: 1, V: 5, X: 10, L: 50, C: 100, D: 500, M: 1000, } as const; const romanToInt = (roman: string): number => { let total = 0; let prevValue = 0; for (let i = roman.length - 1; i >= 0; i--) { const currentValue = ROMAN_MAP[roman[i] as keyof typeof ROMAN_MAP]; if (currentValue < prevValue) total -= currentValue; else total += currentValue; prevValue = currentValue; } return total; }; export const sortMonarchs = (monarchs: string[]): string[] => { return monarchs.sort((a, b) => { const [nameA, ordinalA] = a.split(" ") as [string, string]; const [nameB, ordinalB] = b.split(" ") as [string, string]; const numberA = romanToInt(ordinalA); const numberB = romanToInt(ordinalB); // If years are the same, compare by name return nameA.localeCompare(nameB) || numberA - numberB; }); };$

export type TrafficLight = "red" | "green" | "yellow";
export const isValidTrafficSequence = (sequence: TrafficLight[]): boolean => {
let prevLight: TrafficLight | null = null;

for (let i = 0; i < sequence.length; i++) {
const light = sequence[i] as TrafficLight;

if (prevLight === "red" && light !== "green") return false;
if (prevLight === "green" && light !== "yellow") return false;
if (prevLight === "yellow" && light !== "red") return false;

prevLight = light;
}

return true;
};

export const nestArray = (array: any[]): any[] => {
const result: any[] = [];
let current = result;

for (let i = 0; i < array.length; i++) {
current.push(array[i]);

if (i === array.length - 1) break;

const nextLevel: any[] = [];
current.push(nextLevel);
current = nextLevel;
}

return result;
};

export const oddSum = (first: number[], second: number[]): number[][] => {
const result: number[][] = [];

first.forEach(x => {
second.forEach(y => {
if ((x + y) % 2 !== 0) {
result.push([x, y]);
}
});
});

return result;
};

$const CORNER = "+"; const VERTICAL = "|"; const HORIZONTAL = "-"; const DIAGONAL = "/"; const SPACE = " "; const NUMBER_OF_HORIZONTAL_LINES = 3; export const drawCube = (size: number) => { const horizontalLine = Array.from({ length: size * 2 + 2 }) .map((_, i, { length }) => (i === 0 || i === length - 1 ? CORNER : HORIZONTAL)) .join(""); const padding = Math.floor(size / 2); const rows = Array.from({ length: size + NUMBER_OF_HORIZONTAL_LINES + padding }); return ( "\n" + rows .map((_, i, { length }) => { if (i === 0) { return SPACE.repeat(padding + 1) + horizontalLine; } else if (i > 0 && i < padding + 1) { return ( SPACE.repeat(padding + 1 - i) + DIAGONAL + SPACE.repeat(size * 2) + DIAGONAL + SPACE.repeat(Math.max(i - 1, 0)) + VERTICAL ); } else if (i === padding + 1) { return horizontalLine + SPACE.repeat(padding) + VERTICAL; } else if (i > padding + 1 && i < length - 1) { let endItem = VERTICAL; let paddingEnd = padding; if (i === size + 1) { endItem = CORNER; } if (i > size + 1) { endItem = DIAGONAL; paddingEnd = length - i - 2; } return VERTICAL + SPACE.repeat(size * 2) + VERTICAL + SPACE.repeat(paddingEnd) + endItem; } else if (i === length - 1) { return horizontalLine; } else { return SPACE; } }) .join("\n") + "\n" ); };$

export const addOperators = (origin: number, target: number): string[] => {
const digits = origin.toString().split("");
const result: string[] = [];

const dfs = (index: number, path: string, currentNumber: number) => {
if (index === digits.length) {
if (currentNumber === target) result.push(path);
return;
}

for (let i = index; i < digits.length; i++) {
const digit = digits[i];
const newNumber = Number(digit);

dfs(i + 1, `${path}+${digit}`, currentNumber + newNumber);
dfs(i + 1, `${path}-${digit}`, currentNumber - newNumber);

// Multiply but only if BODMAS is not violated
if (!(path.includes("+") || path.includes("-")))
dfs(i + 1, `${path}*${digit}`, currentNumber * newNumber);
}
};

// Start DFS from the first digit
const firstDigit = digits[0] as string;
const firstNumber = Number(firstDigit);
dfs(1, firstDigit, firstNumber);

return result;
};

"Never think that war, no matter how necessary, nor how justified, is not a crime." ~ Ernest Hemingway

I wish for calmer heads to prevail.

export const longestCommonPrefix = (strings: string[]): string => {
let prefix = strings[0] || "";

for (let i = 1; i < strings.length; i++) {
while (strings[i]?.indexOf(prefix) !== 0) {
prefix = prefix.slice(0, -1);
if (prefix === "") return "";
}
}

return prefix;
};

export const compress = (characters: string[]): string[] => {
const compressed: string[] = [];

let currentChar = characters[0] as string;
let count = 1;

for (let i = 1; i <= characters.length; i++) {
if (characters[i] === currentChar) {
count++;
} else {
compressed.push(currentChar);
if (count > 1) {
compressed.push(count.toString());
}
currentChar = characters[i] as string;
count = 1;
}
}

return compressed;
};

export type TIngredient = {
name: string;
amount: number;
};

export const calculateIngredients = (
ingredients: TIngredient[],
targetServings: number,
): TIngredient[] =>
ingredients.map(ingredient => ({
...ingredient,
amount: ingredient.amount * targetServings,
}));

const DIRECTIONS = [
[0, 1],
[1, 0],
[0, -1],
[-1, 0],
] as const;

export const largestPathSum = (grid: number[][]): number => {
const rows = grid.length;

if (!grid[0]) return 0;

const cols = grid[0].length;

let maxSum = 0;

function dfs(x: number, y: number, visited: boolean[][], currentSum: number) {
maxSum = Math.max(maxSum, currentSum);

for (const [dx, dy] of DIRECTIONS) {
const nx = x + dx;
const ny = y + dy;

if (!visited[nx] || !grid[nx]) continue;

if (nx >= 0 && ny >= 0 && nx < rows && ny < cols && !visited[nx][ny]) {
visited[nx][ny] = true;
dfs(nx, ny, visited, currentSum + (grid[nx][ny] || 0));
visited[nx][ny] = false;
}
}
}

for (let i = 0; i < rows; i++) {
for (let j = 0; j < cols; j++) {
const visited = Array.from({ length: rows }, () => Array(cols).fill(false));

// @ts-ignore
visited[i][j] = true;
// @ts-ignore
dfs(i, j, visited, grid[i][j]);
}
}

return maxSum;
};

const getLeylandNumbers = (n: number): number[] => {
let count = n;
let leylandNumbers: number[] = [];

let x = 2;

while (count > 0) {
for (let i = 2; i <= x; i++) {
leylandNumbers.push(Math.pow(i, x) + Math.pow(x, i));
}
x++;
count--;
}

return leylandNumbers.toSorted((a, b) => a - b).slice(0, n);
};

const getMinutes = (time: string): number => {
const [hours, minutes] = time.split(":").map(Number);

if (hours === undefined || minutes === undefined)
throw new Error(`Invalid time format: ${time}`);

return hours * 60 + minutes;
};

export const findLongestTimeGap = (times: string[]): number => {
let longestGap = 0;

for (let i = 0; i < times.length - 1; i++) {
const current = times[i] as string;
const next = times[i + 1] as string;

longestGap = Math.max(longestGap, getMinutes(next) - getMinutes(current));
}

return longestGap;
};

export const findLongestStreak = (values: boolean[]) => {
let max = 0;

for (let i = 0; i < values.length; i++) {
let current = 0;
while (values[i]) {
current++;
i++;
}

if (current > max) {
max = current;
}
}

return max;
}

const SEMITONES = {
C: 0,
D: 2,
E: 4,
F: 5,
G: 7,
A: 9,
B: 11,
};

export const findLargestInterval = (keys: string[]): number => {
const intervals = keys.map(key => {
const note = key[0] as keyof typeof SEMITONES;
const octave = Number(key[1]);
return SEMITONES[note] + octave * 12;
});

let largestInterval = 0;

for (let i = 0; i < intervals.length - 1; i++) {
const current = intervals[i] as number;
const next = intervals[i + 1] as number;

largestInterval = Math.max(largestInterval, Math.abs(current - next));
}

return largestInterval;
};

export const calculatePrice = (closingDate: string, visitDate: string, price: number): number => {
const closingDateTimestamp = new Date(closingDate).getTime();
const visitDateTimestamp = new Date(visitDate).getTime();

if (visitDateTimestamp > closingDateTimestamp) return price;

const weeks = Math.floor(
(closingDateTimestamp - visitDateTimestamp) / (1000 * 60 * 60 * 24 * 7),
);

for (let i = 0; i < weeks; i++) {
price -= price * 0.1;
}

return price;
};

export const findShieldBreak = (attacks: number[], shield: number): number => {
for (let i = 0; i < attacks.length; i++) {
shield -= attacks[i] as number;
if (shield < 0) return i;
}

return -1;
};

Me holding a medal for finishing a 5K run, in front of a banner saying "I am a finisher"

My sister and I holding placards during Aurat March in Lahore.

The signs are written in Urdu. My sister is holding a sign that says: "Izzat nahi, jaan bachao", which means "Save lives not honour" I am holding a sign that says: "Ziyada soch mat bas barabar samajh", which means "Don't think too much, just think of all as equals".

export type TPosition = "QB" | "RB" | "WR" | "TE" | "OL" | "DL" | "LB" | "DB" | "K" | "LS";
type TRange = {
min: number;
max: number;
};

const ranges: Record<TPosition, TRange[]> = {
QB: [{ min: 1, max: 19 }],
RB: [
{ min: 1, max: 49 },
{ min: 80, max: 89 },
],
WR: [
{ min: 1, max: 49 },
{ min: 80, max: 89 },
],
TE: [
{ min: 1, max: 49 },
{ min: 80, max: 89 },
],
OL: [{ min: 50, max: 79 }],
DL: [
{ min: 50, max: 79 },
{ min: 90, max: 99 },
],
LB: [
{ min: 1, max: 59 },
{ min: 90, max: 99 },
],
DB: [{ min: 1, max: 49 }],
K: [
{ min: 1, max: 49 },
{ min: 90, max: 99 },
],
LS: [{ min: 1, max: 99 }],
};

export const availableNumbers = (position: TPosition, numbers: number[]): number[] => {
const validRanges = ranges[position];
let availableNumbers: number[] = [];

for (const range of validRanges) {
for (let i = range.min; i <= range.max; i++) {
if (!numbers.includes(i)) {
availableNumbers.push(i);
}
}
}

return availableNumbers;
};

type Operator = "+" | "-" | "*" | "/";

const isOperator = (char: string): char is Operator => {
return char === "+" || char === "-" || char === "*" || char === "/";
};

const operate = (operand1: number, operand2: number, operator: Operator): number => {
if (operator === "/") {
return Math.floor(operand1 / operand2);
} else if (operator === "*") {
return operand1 * operand2;
} else if (operator === "+") {
return operand1 + operand2;
} else {
return operand1 - operand2;
}
};

export const evaluatePostfix = (expression: string): number => {
const stack: number[] = [];

for (let i = 0; i < expression.length; i++) {
const char = expression[i] as string;

if (isOperator(char)) {
const operand2 = stack.pop();
const operand1 = stack.pop();

if (operand1 === undefined || operand2 === undefined) {
throw new Error("Invalid expression");
}

const result = operate(operand1, operand2, char);
stack.push(result);
} else {
stack.push(Number(char));
}
}

return stack.pop() || 0;
};

const getAnagrams = (s: string): string[] => {
const anagrams: string[] = [];

const generateAnagrams = (str: string, anagram: string) => {
if (str.length === 0) {
anagrams.push(anagram);
return;
}

for (let i = 0; i < str.length; i++) {
generateAnagrams(str.slice(0, i) + str.slice(i + 1), anagram + str[i]);
}
};

generateAnagrams(s, "");

return anagrams;
};

export const findAnagrams = (s: string, p: string): number[] => {
const result: number[] = [];

if (s.length < p.length) return result;

const pAnagrams = getAnagrams(p);

for (let i = 0; i < s.length - p.length + 1; i++) {
const subStr = s.slice(i, i + p.length);
if (pAnagrams.includes(subStr)) {
result.push(i);
}
}

return result;
};

A screenshot of the login page from the web portal of Askari Bank Pakistan is attached.

The text reads: "Please enter 1st, 3rd, 7th and 8th characters of your password."

export const longestSubsequence = (sequence: number[]): number => {
let longest = -Infinity;
let current = 1;
let prev = sequence[0];

if (prev === undefined) return 0;

for (const num of sequence.slice(1)) {
if (Math.abs(num - prev) === 1) current++;
else {
longest = Math.max(longest, current);
current = 1;
}
prev = num;
}

return Math.max(longest, current);
};

$const NATO_ALPHABET_MAP = { a: "Alpha", b: "Bravo", c: "Charlie", d: "Delta", e: "Echo", f: "Foxtrot", g: "Golf", h: "Hotel", i: "India", j: "Juliett", k: "Kilo", l: "Lima", m: "Mike", n: "November", o: "Oscar", p: "Papa", q: "Quebec", r: "Romeo", s: "Sierra", t: "Tango", u: "Uniform", v: "Victor", w: "Whiskey", x: "X-ray", y: "Yankee", z: "Zulu", " ": "(space)", 1: "One", 2: "Two", 3: "Three", 4: "Four", 5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine", 0: "Zero", ".": "Stop", ",": "Comma", "!": "Exclamation mark", "?": "Question mark", "'": "Apostrophe", "“": "Quote", "”": "Unquote", "-": "Hyphen", _: "Underscore", ":": "Colon", ";": "Semicolon", "(": "Bracket on", ")": "Bracket off", "/": "Slant", "\\": "Backslant", } as const; type NATO_KEY = keyof typeof NATO_ALPHABET_MAP; export const natoify = (s: string) => { let result = ""; for (const char of s) { const lowerChar = char.toLowerCase(); if (lowerChar in NATO_ALPHABET_MAP) { result += NATO_ALPHABET_MAP[lowerChar as NATO_KEY] + " "; } else { result += char; } } return result.trim(); };$

Stat card showing 1203 Rapid Rating on Chess.com.

export const permute = (s: string) => {
if (s.length === 0) return [""];

const result: string[] = [];

for (let i = 0; i < s.length; i++) {
const rest = s.slice(0, i).concat(s.slice(i + 1));
permute(rest).forEach(restPermutation => {
result.push(s[i] + restPermutation);
});
}

return result;
};

Screenshot of Unlocked Achievement on Chess.com for reaching a rating of 1100 in Rapid Chess

export const DAYS = [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
] as const;
export type Day = (typeof DAYS)[number];

export const newYearsDay = (year: number) => DAYS[new Date(year, 0).getDay()] as Day;

export const countPerfectlyRoundCookies = (input: number): number => {
let result = 0;
let power = 1;

while (5 ** power <= input) {
result += Math.floor(input / 5 ** power);
power++;
}
return result;
};

type TRes = {
declared: string[];
used: string[];
};

type ParseStatement<T extends string, TResult extends TRes> = T extends `${string}${
| "let"
| "const"
| "var"} ${infer TId extends string} =${string}`
? {
declared: [...TResult["declared"], TId];
used: TResult["used"];
}
: T extends `${string}(${infer TId extends string})${string}`
? {
used: [...TResult["used"], TId];
declared: TResult["declared"];
}
: TResult;

type AnalyzeScope<
T extends string,
TResult extends TRes = {
declared: [];
used: [];
},
> = T extends `${infer TFirst};${infer TSecond}`
? AnalyzeScope<TSecond, ParseStatement<TFirst, TResult>>
: ParseStatement<T, TResult>;

const createStreetLight = <TColors extends string[], TColor extends TColors[number]>(colors: TColors, defaultColor: TColor) => {
console.log(colors);
return defaultColor;
}

$export const upperCase = <T extends string>(x: T) => x.toUpperCase() as Uppercase<T>; export const lowerCase = <T extends string>(x: T) => x.toLowerCase() as Lowercase<T>; export const firstChar = <T extends string>(x: T) => x[0] as T extends `${infer TFirst}${infer _}` ? TFirst : never; export const firstItem = <T extends string[]>(x: T) => x[0] as T[0]; export const makeTuple = <T extends string>(x: T) => [x] as [T]; export const makeBox = <T>(value: T) => ({ value }); type TFunc<T1, T2> = (x: T1) => T2; export const compose = <T1, T2, T3, T4>(f: TFunc<T1, T2>, g: TFunc<T2, T3>, h: TFunc<T3, T4>) => { return (x: T1) => { return h(g(f(x))) as T4; }; };$