Brecht Billiet’s Post

Injecting Schema Code by CHRIS PALMER SEO Injecting code into a frame for easy distribution. #Coding #Distribution #Hidden #Shorts via YouTube https://lnkd.in/eyNMQZsg

New Article About #Mapped #Types in #TypeScript We will delve into the mechanics of how mapped types work and how they can be utilized in our codebase to enhance the developer experience. In essence, mapped types are used to take one type and dynamically, programmatically transform it into another. Why? To reduce boilerplate and create handy utility types for performing type operations. Mapped types also enable the use of ternary operators to filter properties and values, or even to enforce that type parameters adhere to specific constraints through the "type constraints" mechanism. Everything is described in the new article, linked in the comments section.

#TypeScript nuggets - Reversed Mapped Types Magic Got a perfect problem today for which I had to make use of the reversed mapping magic of the types. This technique is super super elegant when such use-cases arise where we want to allow the retention of contextual type info of the input params which in other case would not be retained by the Type Inference system. Let's consider that you wanted to implement a method wherein we need to have the individual promises info from the All Settled Promise Interface. But `Promise.all([...])` doesn't work here as we can see in Ex-1 provided. It just collapses and combines result type to Promise<[...]> Solution: Here we have an equivalent of `Promise.allSettled()` using our reverse-mapping that retains this positional information for each item in the input. Basically we allowed the inference to follow backward from the computation of return and the params to be in sync and preserving the concrete resolved promise type info for each of the promise constituent of settled state. Live Code Playground - https://tsplay.dev/mxEz8W This is so powerful and yet fundamentally such a simple constraint. Super cool stuff!

Today's Leetcode/Algorithm practice. Leetcode #9 Palindrome Number: Given an integer x, return true if x is a palindrome, and false otherwise. Input: x = 121 Output: true Input: x = -121 Output: false Input: x = 10 Output: false First possible solution: const palindromeNumber = (x) => { let reversed = x.toString().split("").reverse().join(""); return x.toString() === reversed; }; This solution creates a reversed version of the input number by converting it to a string, splitting it into an array of characters, reversing the order of characters, and then joining them back into a string. The reversed string is then compared to the original number which has also been converted into a string. The time and space complexity are both O(n) or linear. Second possible solution: const palindromeNumber = (x) => { let reversedString = ""; xStr = x.toString(); for (let i of xStr) { reversedString = i + reversedString; } return reversedString === xStr; }; This solution creates an empty string which will eventually become the reversed string. The input number is converted into a string and then looped through adding each iterated character to the beginning of the reversed string and then the reversed string is compared to the original number as a string. The time and space complexity are both also O(n) or linear.

base options for all projects using type script {  "compilerOptions": {   "esModuleInterop": true,   "skipLibCheck": true,   "target": "es2022",   "allowJs": true,   "resolveJsonModule": true,   "moduleDetection": "force",   "isolatedModules": true  } }

idk why I even solved this leetcode problem but guess took me about 45:03 minutes to be precise for this (Please read below for approach and other relevant info) What does the problem says - You're given two strings, s (the input string) and p (the pattern string). The goal is to determine if the pattern p matches the entire input string s while considering two special characters: '.' and '*'. Approach - we will create a matrix name dp (as concept used is of dynamic programming) of elements dp[i][j] where i elements from 's' matches with j elements from 'p'. If dp[m][n] (where m is the length of s and n is the length of p) is true at the end, it means the entire s matches the entire p Time and space complexity of this code - Time complexity - since this uses a dp approach we'll have two elements m and n and matrix of size (m+1)*(n+1) so the time complexity is of O(m*n) Space complexity - this uses a concept of 2D Array of size (m+1)*(n+1) so the space complexity will also be O(m*n) Thanks for reading by :) Feel free to ask ques

If you use reactive forms, you must know how to enable or disable the Submit button under certain conditions. Enable the button if some specific inputs have been filled out. enabling the entire form to be valid, i.e., the required inputs are filled. disabling if the conditions do not match or the form is not valid. In some cases, users need to resubmit the data. Here, to make the form more user-interactive, we need to again enable or disable the button using conditions. Here is where the Pristine of Form Group plays a role. the pristine attribute of form control says whether the form is modified or not. #Angular #ReactiveForms #pristine #Angulardev

Hi, #connections. It's my #Day-54 of the #100daysofcodechallenge. Problem Statement - Given an array of characters chars, compress it using the following algorithm: Begin with an empty string s. For each group of consecutive repeating characters in chars: If the group's length is 1, append the character to s. Otherwise, append the character followed by the group's length. The compressed string s should not be returned separately, but instead, be stored in the input character array chars. Note that group lengths that are 10 or longer will be split into multiple characters in chars. After you are done modifying the input array, return the new length of the array. You must write an algorithm that uses only constant extra space. The difficulty of the Question is Medium. Ques -> String Compression (https://lnkd.in/g_pZuGEn) GitHub (Solution) -> https://lnkd.in/gP65qqz2 #problemsolving #DSA #codingpractices #cpp #100daysofcodechallenge #github

🌟100 Days of Code Challenge!🌟 Day 40 of #100daysofcodingchallenge Revision Day 3 🔎 Coded today: 1. Search a 2D Matrix II:https://lnkd.in/dCGzhcZ7 Solution: 1. class Solution { public: bool searchMatrix(vector<vector<int>>& matrix, int target) { int n=matrix.size(); int m=matrix[0].size(); int row=0; int col=m-1; while(row<n && col>=0){ if(matrix[row][col]==target) return 1; else if(matrix[row][col]>target) col--; else row++; } return 0; } }; Happy Coding :)

🚀 Day 9 of daily Leetcode: Problem Type: String Type: Easy Today,I solved a "VALID PARENTHESIS" problem ,I was given a string s containing just the characters '(', ')' ,'{' , '}', ']' and '['.I was supposed to determine if the input string is valid .The condition to determine whether the input string is valid or not are: >Open brackets must be closed by the same type of brackets. >Open brackets must be closed in the correct order. >Every close bracket has a corresponding open bracket of the same type. BREAKDOWN OF CODE: 1->At first a stack is initialized as an empty list. This helps us to keep track of the opening brackets encountered. 2->Now a hash map is which is created for determining the corresponding opening bracket for a given closing bracket. 3->'FOR' loop is used for iterating over each value of s 4->'IF' statement is used to check for the closed bracket in hash map 5->top_element is popped from the stack if the stack is not empty else '#' is returned as a placeholder value 6->'IF mapping[char]!=top_element' then 'False' is returned which means,it is checking if the current closing bracket(char)matches the corresponding opening bracket at the top of the stack(top_element)or not .If it doesn't match then 'False' is returned. 7->'ELSE: stack.append(char)' is used to handle open brackets which is then appended to the top of stack ,It is because all the open brackets needs to be matched with their corresponding closing bracket later in the string 8->'return not stack' returns 'True' if all brackets are matched and closed properly and 'False' otherwise. #learninginpublic #leetcode #dailychallenge