Showing preview only (477K chars total). Download the full file or copy to clipboard to get everything.
Repository: donutloop/leetcode.com
Branch: main
Commit: 7e037f5fe1e8
Files: 689
Total size: 326.5 KB
Directory structure:
gitextract_1nm0h8c7/
├── Day of the Week/
│ └── kata.py
├── Find Total Time Spent by Each Employee/
│ └── q.sql
├── Students With Invalid Departments/
│ └── q.sql
├── .gitignore
├── 3042. Count Prefix and Suffix Pairs I/
│ └── kata.py
├── 3110. Score of a String/
│ └── main.scala
├── A Number After a Double Reversal/
│ └── kata.go
├── Account Balance/
│ └── q.sql
├── Account Balance After Rounded Purchase/
│ └── kata.go
├── Accounts Merge/
│ └── kata.go
├── Active Businesses/
│ └── q.sql
├── Add Binary/
│ └── kata.go
├── Add Digits/
│ └── kata.go
├── Add One Row to Tree/
│ └── kata.go
├── Add Strings/
│ └── kata.go
├── Add Two Integers/
│ └── kata.go
├── Adding Spaces to a String/
│ └── kata.go
├── All Elements in Two Binary Search Trees/
│ └── kata.go
├── All the Matches of the League/
│ └── q.sql
├── Allow One Function Call/
│ └── kata.ts
├── Alternating Digit Sum/
│ └── kata.java
├── Ant on the Boundary/
│ └── kata.go
├── Apple Redistribution into Boxes/
│ └── kata.go
├── Apples & Oranges/
│ └── q.sql
├── Apply Discount Every n Orders/
│ └── kata.go
├── Apply Transform Over Each Element in Array/
│ └── kata.ts
├── Armstrong Number/
│ └── kata.go
├── Arranging Coins/
│ └── kata.go
├── Array Partition I/
│ └── kata.go
├── Array Reduce Transformation/
│ └── kata.ts
├── Array Wrapper/
│ └── kata.ts
├── Article Views I/
│ └── q.sql
├── Assign Cookies/
│ └── kata.go
├── Average Salary Excluding the Minimum and Maximum Salary/
│ └── kata.go
├── Average Selling Price/
│ └── q.sql
├── Average Time of Process per Machine/
│ └── q.sql
├── Average Value of Even Numbers That Are Divisible by Three/
│ └── kata.java
├── Average of Levels in Binary Tree/
│ └── kata.go
├── Backspace String Compare/
│ └── kata.go
├── Bank Account Summary/
│ └── q.sql
├── Bank Account Summary II/
│ └── q.sql
├── Base 7/
│ └── kata.go
├── Baseball Game/
│ └── kata.go
├── Basic Calculator II/
│ └── kata.go
├── Best Poker Hand/
│ └── kata.go
├── Best Time to Buy and Sell Stock/
│ └── kata.go
├── Big Countries/
│ └── kata.sql
├── Biggest Single Number/
│ └── q.sql
├── Binary Gap/
│ └── kata.go
├── Binary Number with Alternating Bits/
│ └── kata.go
├── Binary Prefix Divisible By 5/
│ └── kata.py
├── Binary Search Tree Iterator/
│ └── kata.go
├── Binary Tree Inorder Traversal/
│ └── kata.go
├── Binary Tree Paths/
│ └── kata.go
├── Binary Tree Postorder Traversal/
│ └── kata.go
├── Binary Tree Preorder Traversal/
│ └── kata.go
├── Build Array from Permutation/
│ └── kata.go
├── Buildings With an Ocean View/
│ └── kata.java
├── Bulls and Cows/
│ └── kata.go
├── Calculate Amount Paid in Taxes/
│ └── kata.go
├── Calculate Money in Leetcode Bank/
│ └── kata.go
├── Calculate Salaries/
│ └── q.sql
├── Calculate Special Bonus/
│ └── q.sql
├── Calculate the Influence of Each Salesperson/
│ └── q.sql
├── Calculator with Method Chaining/
│ └── kata.js
├── Can Make Arithmetic Progression From Sequence/
│ └── kata.go
├── Can Place Flowers/
│ └── kata.go
├── Capital Gain-loss/
│ └── q.sql
├── Capitalize the Title/
│ └── kata.go
├── Categorize Box According to Criteria/
│ └── kata.java
├── Cells with Odd Values in a Matrix/
│ └── kata.go
├── Change Data Type/
│ └── kata.py
├── Check Distances Between Same Letters/
│ └── kata.java
├── Check If All 1's Are at Least Length K Places Away/
│ └── kata.go
├── Check If N and Its Double Exist/
│ └── kata.go
├── Check If Two String Arrays are Equivalent/
│ └── kata.go
├── Check If a Number Is Majority Element in a Sorted Array/
│ └── kata.java
├── Check If a Word Occurs As a Prefix of Any Word in a Sentence/
│ └── kata.go
├── Check Whether Two Strings are Almost Equivalent/
│ └── kata.go
├── Check if All A's Appears Before All B's/
│ └── kata.go
├── Check if All Characters Have Equal Number of Occurrences/
│ └── kata.go
├── Check if Binary String Has at Most One Segment of Ones/
│ └── kata.go
├── Check if Bitwise OR Has Trailing Zeros/
│ └── kata.go
├── Check if Number Has Equal Digit Count and Digit Value/
│ └── kata.go
├── Check if Numbers Are Ascending in a Sentence/
│ └── kata.go
├── Check if One String Swap Can Make Strings Equal/
│ └── kata.go
├── Check if The Number is Fascinating/
│ └── kata.go
├── Check if Word Equals Summation of Two Words/
│ └── kata.go
├── Check if an Array Is Consecutive/
│ └── kata.go
├── Check if the Sentence Is Pangram/
│ └── kata.go
├── Classes More Than 5 Students/
│ └── kata.sql
├── Climbing Stairs/
│ └── kata.go
├── Combine Two Tables/
│ └── kata.sql
├── Compare Strings by Frequency of the Smallest Character/
│ └── kata.go
├── Complement of Base 10 Integer/
│ └── kata.go
├── Compute the Rank as a Percentage/
│ └── q.sql
├── Concatenate the Name and the Profession/
│ └── q.sql
├── Concatenation of Array/
│ └── kata.go
├── Confusing Number/
│ └── kata.java
├── Consecutive Available Seats/
│ └── q.sql
├── Consecutive Characters/
│ └── kata.go
├── Construct Binary Search Tree from Preorder Traversal/
│ └── kata.go
├── Construct String from Binary Tree/
│ └── kata.java
├── Construct the Rectangle/
│ └── kata.go
├── Contains Duplicate/
│ └── kata.go
├── Contains Duplicate II/
│ └── kata.go
├── Convert 1D Array Into 2D Array/
│ └── kata.go
├── Convert Binary Number in a Linked List to Integer/
│ └── kata.go
├── Convert Date Format/
│ └── q.sql
├── Convert Integer to the Sum of Two No-Zero Integers/
│ └── kata.go
├── Convert a Number to Hexadecimal/
│ └── kata.go
├── Convert the Temperature/
│ └── kata.java
├── Count Apples and Oranges/
│ └── q.sql
├── Count Asterisks/
│ └── kata.java
├── Count Common Words With One Occurrence/
│ └── kata.go
├── Count Complete Tree Nodes/
│ └── kata.go
├── Count Elements With Maximum Frequency/
│ └── kata.go
├── Count Elements With Strictly Smaller and Greater Elements/
│ └── kata.go
├── Count Integers With Even Digit Sum/
│ └── kata.go
├── Count Items Matching a Rule/
│ └── kata.go
├── Count Largest Group/
│ └── kata.java
├── Count Negative Numbers in a Sorted Matrix/
│ └── kata.rs
├── Count Odd Numbers in an Interval Range/
│ └── kata.go
├── Count Operations to Obtain Zero/
│ └── kata.go
├── Count Prefixes of a Given String/
│ └── kata.go
├── Count Student Number in Departments/
│ └── q.sql
├── Count Substrings Starting and Ending with Given Character/
│ └── kata.py
├── Count Tested Devices After Test Operations/
│ └── kata.go
├── Count Total Number of Colored Cells/
│ └── kata.go
├── Count of Matches in Tournament/
│ └── kata.go
├── Count the Digits That Divide a Number/
│ └── kata.java
├── Count the Number of Consistent Strings/
│ └── kata.go
├── Counter/
│ └── kata.ts
├── Counter II/
│ └── kata.ts
├── Counting Bits/
│ └── kata.go
├── Counting Elements/
│ └── kata.go
├── Counting Words With a Given Prefix/
│ └── kata.go
├── Cousins in Binary Tree/
│ └── kata.go
├── Create Hello World Function/
│ └── kata.ts
├── Create Target Array in the Given Order/
│ └── kata.go
├── Create a DataFrame from List/
│ └── kata.py
├── Create a New Column/
│ └── kata.py
├── Create a Session Bar Chart/
│ └── q.sql
├── Custom Sort String/
│ └── kata.go
├── Customer Placing the Largest Number of Orders/
│ └── q.sql
├── Customer Who Visited but Did Not Make Any Transactions/
│ └── q.sql
├── Customers Who Never Order/
│ └── kata.sql
├── DI String Match/
│ └── kata.go
├── Daily Leads and Partners/
│ └── q.sql
├── Day of the Year/
│ └── kata.go
├── Decode XORed Array/
│ └── kata.go
├── Decode the Message/
│ └── kata.go
├── Decompress Run-Length Encoded List/
│ └── kata.go
├── Decrypt String from Alphabet to Integer Mapping/
│ └── kata.go
├── Deepest Leaves Sum/
│ └── kata.go
├── Defanging an IP Address/
│ └── kata.go
├── Delete Characters to Make Fancy String/
│ └── kata.go
├── Delete Duplicate Emails/
│ └── kata.sql
├── Delete Greatest Value in Each Row/
│ └── kata.go
├── Delete Leaves With a Given Value/
│ └── kata.go
├── Delete Node in a Linked List/
│ └── kata.go
├── Delete the Middle Node of a Linked List/
│ └── kata.go
├── Design Add and Search Words Data Structure/
│ └── kata.go
├── Design HashMap/
│ └── kata.go
├── Design HashSet/
│ └── kata.go
├── Design Linked List/
│ └── kata_test.go
├── Design Parking System/
│ └── kata.go
├── Design a Stack With Increment Operation/
│ └── kata.go
├── Design an Ordered Stream/
│ └── kata.go
├── Destination City/
│ └── kata.go
├── Detect Capital/
│ └── kata.go
├── Determine Color of a Chessboard Square/
│ └── kata.go
├── Determine if String Halves Are Alike/
│ └── kata.go
├── Determine if Two Events Have Conflict/
│ └── kata.java
├── Diet Plan Performance/
│ └── kata.java
├── Difference Between Element Sum and Digit Sum of an Array/
│ └── kata.java
├── Display the First Three Rows/
│ └── kata.py
├── Distinct Numbers in Each Subarray/
│ └── kata.java
├── Distribute Candies to People/
│ └── kata.go
├── Distribute Elements Into Two Arrays I/
│ └── kata.go
├── Divide Array Into Equal Pairs/
│ └── kata.go
├── Divide a String Into Groups of Size k/
│ └── kata.go
├── Divisible and Non-divisible Sums Difference/
│ └── kata.go
├── Dot Product of Two Sparse Vectors/
│ └── kata.go
├── Drop Duplicate Rows/
│ └── kata.py
├── Drop Missing Data/
│ └── kata.py
├── Duplicate Emails/
│ └── kata.sql
├── Duplicate Zeros/
│ └── kata.go
├── Element Appearing More Than 25% In Sorted Array/
│ └── kata.go
├── Employee Bonus/
│ └── q.sql
├── Employee Importance/
│ └── kata.py
├── Employees Earning More Than Their Managers/
│ └── kata.sql
├── Employees With Missing Information/
│ └── q.sql
├── Encode and Decode TinyURL/
│ └── kata.go
├── Equal Row and Column Pairs/
│ └── kata.go
├── Evaluate Boolean Binary Tree/
│ └── kata.go
├── Evaluate Boolean Expression/
│ └── q.sql
├── Evaluate Reverse Polish Notation/
│ └── kata.go
├── Factorial Trailing Zeroes/
│ └── kata.go
├── Fibonacci Number/
│ └── kata.go
├── Fill Missing Data/
│ └── kata.py
├── Filter Elements from Array/
│ └── kata.ts
├── Filter Restaurants by Vegan-Friendly, Price and Distance/
│ └── kata.go
├── Final Prices With a Special Discount in a Shop/
│ └── kata.go
├── Final Value of Variable After Performing Operations/
│ └── kata.go
├── Find All Duplicates in an Array/
│ └── kata.go
├── Find All Lonely Numbers in the Array/
│ └── kata.go
├── Find All Numbers Disappeared in an Array/
│ └── kata.go
├── Find All The Lonely Nodes/
│ └── kata.java
├── Find Anagram Mappings/
│ └── kata.go
├── Find Bottom Left Tree Value/
│ └── kata.go
├── Find Center of Star Graph/
│ └── kata.go
├── Find Closest Number to Zero/
│ └── kata.go
├── Find Common Characters/
│ └── kata.go
├── Find Customer Referee/
│ └── q.sql
├── Find Customers With Positive Revenue this Year/
│ └── q.sql
├── Find First Palindromic String in the Array/
│ └── kata.go
├── Find First and Last Position of Element in Sorted Array/
│ └── kata.go
├── Find Followers Count/
│ └── q.sql
├── Find Greatest Common Divisor of Array/
│ └── kata.go
├── Find K Closest Elements/
│ └── kata.go
├── Find K-Length Substrings With No Repeated Characters/
│ └── kata.java
├── Find Largest Value in Each Tree Row/
│ └── kata.go
├── Find Lucky Integer in an Array/
│ └── kata.go
├── Find Maximum Number of String Pairs/
│ └── kata.go
├── Find Median from Data Stream/
│ └── kata.go
├── Find Minimum Time to Finish All Jobs II/
│ └── kata.java
├── Find Minimum in Rotated Sorted Array/
│ └── kata.go
├── Find Minimum in Rotated Sorted Array II/
│ └── kata.go
├── Find Missing and Repeated Values/
│ └── kata.go
├── Find Mode in Binary Search Tree/
│ └── kata.go
├── Find N Unique Integers Sum up to Zero/
│ └── kata.go
├── Find Nearest Point That Has the Same X or Y Coordinate/
│ └── kata.java
├── Find Numbers with Even Number of Digits/
│ └── kata.go
├── Find Peak Element/
│ └── kata.go
├── Find Pivot Index/
│ └── kata.go
├── Find Players With Zero or One Losses/
│ └── kata.go
├── Find Positive Integer Solution for a Given Equation/
│ └── kata.py
├── Find Smallest Common Element in All Rows/
│ └── kata.go
├── Find Smallest Letter Greater Than Target/
│ └── kata.go
├── Find Target Indices After Sorting Array/
│ └── kata.go
├── Find The Original Array of Prefix Xor/
│ └── kata.java
├── Find Triangular Sum of an Array/
│ └── kata.go
├── Find Users With Valid E-Mails/
│ └── q.sql
├── Find Words Containing Character/
│ └── kata.go
├── Find Words That Can Be Formed by Characters/
│ └── kata.go
├── Find and Replace Pattern/
│ └── kata.go
├── Find the Array Concatenation Value/
│ └── kata.java
├── Find the Difference/
│ └── kata.go
├── Find the Distance Value Between Two Arrays/
│ └── kata.go
├── Find the Duplicate Number/
│ └── kata.go
├── Find the Highest Altitude/
│ └── kata.go
├── Find the K-Beauty of a Number/
│ └── kata.java
├── Find the Kth Largest Integer in the Array/
│ └── kata.go
├── Find the Maximum Achievable Number/
│ └── kata.go
├── Find the Minimum and Maximum Number of Nodes Between Critical Points/
│ └── kata.go
├── Find the Missing IDs/
│ └── q.sql
├── Find the Peaks/
│ └── kata.go
├── Find the Pivot Integer/
│ └── kata.java
├── Find the Sum of Encrypted Integers/
│ └── kata.go
├── Find the Team Size/
│ └── q.sql
├── Find the Winner of the Circular Game/
│ └── kata.java
├── First Bad Version/
│ └── kata.go
├── First Letter to Appear Twice/
│ └── kata.go
├── First Missing Positive/
│ └── kata.go
├── First Unique Character in a String/
│ └── kata.go
├── Fix Names in a Table/
│ └── q.sql
├── Fix Product Name Format/
│ └── q.sql
├── Fizz Buzz/
│ └── kata.go
├── Flatten 2D Vector/
│ └── kata.go
├── Flatten Nested List Iterator/
│ └── kata.go
├── Flatten a Multilevel Doubly Linked List/
│ └── kata.go
├── Flipping an Image/
│ └── kata.go
├── Friendly Movies Streamed Last Month/
│ └── q.sql
├── Function Composition/
│ └── kata.ts
├── Game Play Analysis I/
│ └── q.sql
├── Generate a String With Characters That Have Odd Counts/
│ └── kata.go
├── Generate the Invoic/
│ └── q.sql
├── Get Maximum in Generated Array/
│ └── kata.go
├── Get the Size of a DataFrame/
│ └── kata.py
├── Goal Parser Interpretation/
│ └── kata.go
├── Goat Latin/
│ └── kata.java
├── Grand Slam Titles/
│ └── q.sql
├── Greatest English Letter in Upper and Lower Case/
│ └── kata.go
├── Group Anagrams/
│ └── kata.go
├── Group By/
│ └── kata.js
├── Group Sold Products By The Date/
│ └── q.sql
├── Group the People Given the Group Size They Belong To/
│ └── kata.go
├── H-Index/
│ └── kata.go
├── HTML Entity Parser/
│ └── kata.go
├── Hamming Distance/
│ └── kata.go
├── Happy Number/
│ └── kata.go
├── Harshad Number/
│ └── kata.go
├── Height Checker/
│ └── kata.go
├── High Five/
│ └── kata.go
├── How Many Apples Can You Put into the Basket/
│ └── kata.java
├── How Many Numbers Are Smaller Than the Current Number/
│ └── kata.go
├── Immediate Food Delivery I/
│ └── q.sql
├── Implement Magic Dictionary/
│ └── kata.go
├── Implement Queue using Stacks/
│ └── kata.go
├── Implement Stack using Queues/
│ └── kata.go
├── Implement Trie (Prefix Tree)/
│ └── kata.go
├── Implement strStr()/
│ └── kata.go
├── Increasing Order Search Tree/
│ └── kata.go
├── Index Pairs of a String/
│ └── kata.java
├── Insertion Sort List/
│ └── kata.go
├── Intersection of Multiple Arrays/
│ └── kata.go
├── Intersection of Three Sorted Arrays/
│ └── kata.go
├── Intersection of Two Arrays/
│ └── kata.go
├── Intersection of Two Arrays II/
│ └── kata.go
├── Intersection of Two Linked Lists/
│ └── kata.go
├── Invalid Tweets/
│ └── q.sql
├── Invert Binary Tree/
│ └── kata.go
├── Is Object Empty/
│ └── kata.js
├── Is Subsequence/
│ └── kata.go
├── Island Perimeter/
│ └── kata.go
├── Jewels and Stones/
│ └── kata.go
├── K Items With the Maximum Sum/
│ └── kata.go
├── K Radius Subarray Averages/
│ └── kata.go
├── Keep Multiplying Found Values by Two/
│ └── kata.go
├── Kids With the Greatest Number of Candies/
│ └── kata.go
├── Kth Distinct String in an Array/
│ └── kata.go
├── Kth Largest Element in a Stream/
│ └── kata.go
├── Kth Largest Element in an Array/
│ └── kata.go
├── Kth Missing Positive Number/
│ └── kata.go
├── Kth Smallest Element in a BST/
│ └── kata.go
├── LRU Cache/
│ └── kata.go
├── Largest 3-Same-Digit Number in String/
│ └── kata.go
├── Largest Number After Digit Swaps by Parity/
│ └── kata.go
├── Largest Number At Least Twice of Others/
│ └── kata.go
├── Largest Perimeter Triangle/
│ └── kata.go
├── Largest Positive Integer That Exists With Its Negative/
│ └── kata.java
├── Largest Subarray Length K/
│ └── kata.java
├── Largest Unique Number/
│ └── kata.go
├── Last Person to Fit in the Bus/
│ └── q.sql
├── Last Stone Weight/
│ └── kata.go
├── Latest Time by Replacing Hidden Digits/
│ └── kata.go
├── Leaf-Similar Trees/
│ └── kata.go
├── Least Number of Unique Integers after K Removals/
│ └── kata.java
├── Left and Right Sum Differences/
│ └── kata.java
├── Length of Last Word/
│ └── kata.go
├── Letter Case Permutation/
│ └── kata.go
├── Lexicographical Numbers/
│ └── kata.go
├── Linked List Cycle/
│ └── kata.go
├── List the Products Ordered in a Period/
│ └── q.sql
├── Longer Contiguous Segments of Ones than Zeros/
│ └── kata.go
├── Longest Common Prefix/
│ └── kata.go
├── Longest Consecutive Sequence/
│ └── kata.go
├── Longest Continuous Increasing Subsequence/
│ └── kata.go
├── Longest Strictly Increasing or Strictly Decreasing Subarray/
│ └── kata.go
├── Longest Subsequence With Limited Sum/
│ └── kata.java
├── Low-Quality Problems/
│ └── q.sql
├── Lucky Numbers in a Matrix/
│ └── kata.go
├── Majority Element/
│ └── kata.go
├── Majority Element II/
│ └── kata.go
├── Make Array Zero by Subtracting Equal Amounts/
│ └── kata.java
├── Make The String Great/
│ └── kata.go
├── Make Two Arrays Equal by Reversing Sub-arrays/
│ └── kata.go
├── Map Sum Pairs/
│ └── kata.go
├── Matrix Diagonal Sum/
│ └── kata.go
├── Max Consecutive Ones/
│ └── kata.go
├── Max Stack/
│ └── kata.go
├── Maximize Sum Of Array After K Negations/
│ └── kata.go
├── Maximum 69 Number/
│ └── kata.go
├── Maximum Ascending Subarray Sum/
│ └── kata.go
├── Maximum Average Subarray I /
│ └── kata.go
├── Maximum Count of Positive Integer and Negative Integer/
│ └── kata.java
├── Maximum Depth of Binary Tree/
│ └── kata.go
├── Maximum Difference Between Increasing Elements/
│ └── kata.java
├── Maximum Difference by Remapping a Digit/
│ └── kata.java
├── Maximum Frequency Stack/
│ └── kata.go
├── Maximum Nesting Depth of the Parentheses/
│ └── kata.java
├── Maximum Number of Balloons/
│ └── kata.go
├── Maximum Number of Balls in a Box/
│ └── kata.go
├── Maximum Number of Coins You Can Get/
│ └── kata.java
├── Maximum Number of Pairs in Array/
│ └── kata.go
├── Maximum Number of Words Found in Sentences/
│ └── kata.go
├── Maximum Number of Words You Can Type/
│ └── kata.go
├── Maximum Odd Binary Number/
│ └── kata.go
├── Maximum Product Difference Between Two Pairs/
│ └── kata.go
├── Maximum Product of Three Numbers/
│ └── kata.go
├── Maximum Product of Two Elements in an Array/
│ └── kata.go
├── Maximum Score After Splitting a String/
│ └── kata.go
├── Maximum Subarray/
│ └── kata.go
├── Maximum Sum Score of Array/
│ └── kata.go
├── Maximum Sum With Exactly K Elements/
│ └── kata.go
├── Maximum Twin Sum of a Linked List/
│ └── kata.go
├── Maximum Units on a Truck/
│ └── kata.java
├── Maximum Value after Insertion/
│ └── kata.go
├── Maximum Value of a String in an Array/
│ └── kata.java
├── Maximum XOR After Operations /
│ └── kata.java
├── Mean of Array After Removing Some Elements/
│ └── kata.go
├── Meeting Rooms/
│ └── kata.java
├── Merge In Between Linked Lists/
│ └── kata.go
├── Merge Nodes in Between Zeros/
│ └── kata.go
├── Merge Similar Items/
│ └── kata.java
├── Merge Strings Alternately/
│ └── kata.go
├── Merge Two 2D Arrays by Summing Values/
│ └── kata.go
├── Merge Two Sorted Lists/
│ └── kata.go
├── Merge k Sorted Lists/
│ └── kata.go
├── Method Chaining/
│ └── kata.py
├── Middle of the Linked List/
│ └── kata.go
├── Min Cost Climbing Stairs/
│ └── kata.go
├── Min Max Game/
│ └── kata.go
├── Min Stack/
│ └── kata.go
├── Minimize Maximum Pair Sum in Array/
│ └── kata.go
├── Minimize Product Sum of Two Arrays/
│ └── kata.go
├── Minimize String Length/
│ └── kata.go
├── Minimum Absolute Difference/
│ └── kata.go
├── Minimum Absolute Difference in BST/
│ └── kata.go
├── Minimum Add to Make Parentheses Valid/
│ └── kata.java
├── Minimum Average Difference/
│ └── kata.go
├── Minimum Bit Flips to Convert Number/
│ └── kata.go
├── Minimum Common Value/
│ └── kata.java
├── Minimum Cuts to Divide a Circle/
│ └── kata.java
├── Minimum Depth of Binary Tree/
│ └── kata.go
├── Minimum Distance to the Target Element/
│ └── kata.go
├── Minimum Increment to Make Array Unique/
│ └── kata.go
├── Minimum Moves to Convert String/
│ └── kata.go
├── Minimum Number Game/
│ └── kata.go
├── Minimum Number of Steps to Make Two Strings Anagram II/
│ └── kata.go
├── Minimum Operations to Collect Elements/
│ └── kata.go
├── Minimum Operations to Exceed Threshold Value I/
│ └── kata.go
├── Minimum Operations to Make the Array Increasing/
│ └── kata.go
├── Minimum Recolors to Get K Consecutive Black Blocks/
│ └── kata.java
├── Minimum String Length After Removing Substrings/
│ └── kata.go
├── Minimum Subsequence in Non-Increasing Order/
│ └── kata.java
├── Minimum Sum of Four Digit Number After Splitting Digits/
│ └── kata.go
├── Minimum Value to Get Positive Step by Step Sum/
│ └── kata.java
├── Missing Number/
│ └── kata.go
├── Missing Ranges/
│ └── kata.java
├── Modify Columns/
│ └── kata.py
├── Modify the Matrix/
│ └── kata.go
├── Monotonic Array/
│ └── kata.go
├── Monthly Transactions I/
│ └── q.sql
├── Most Common Word/
│ └── kata.go
├── Most Frequent Even Element/
│ └── kata.go
├── Most Frequent Number Following Key In an Array/
│ └── kata.go
├── Move Zeroes/
│ └── kata.go
├── Moving Average from Data Stream/
│ └── kata.go
├── Multiply Strings/
│ └── kata.go
├── My Calendar I/
│ └── kata.go
├── N-Repeated Element in Size 2N Array/
│ └── kata.go
├── N-th Tribonacci Number/
│ └── kata.go
├── NPV Queries/
│ └── q.sql
├── Neither Minimum nor Maximum/
│ └── kata.go
├── Nested List Weight Sum/
│ └── kata.go
├── New Users Daily Count/
│ └── q.sql
├── Next Greater Element I/
│ └── kata.go
├── Not Boring Movies/
│ └── kata.sql
├── Nth Highest Salary/
│ └── kata.sql
├── Number Complement/
│ └── kata.go
├── Number Of Rectangles That Can Form The Largest Square/
│ └── kata.java
├── Number of 1 Bits/
│ └── kata.go
├── Number of Arithmetic Triplets/
│ └── kata.java
├── Number of Days Between Two Dates/
│ └── kata.go
├── Number of Days in a Month/
│ └── kata.java
├── Number of Different Integers in a String/
│ └── kata.go
├── Number of Distinct Averages/
│ └── kata.java
├── Number of Employees Who Met the Target/
│ └── kata.go
├── Number of Equivalent Domino Pairs/
│ └── kata.go
├── Number of Even and Odd Bits/
│ └── kata.go
├── Number of Good Pairs/
│ └── kata.go
├── Number of Laser Beams in a Bank/
│ └── kata.go
├── Number of Lines To Write String/
│ └── kata.java
├── Number of Recent Calls/
│ └── kata.go
├── Number of Segments in a String/
│ └── kata.go
├── Number of Senior Citizens/
│ └── kata.go
├── Number of Steps to Reduce a Number to Zero/
│ └── kata.go
├── Number of Strings That Appear as Substrings in Word/
│ └── kata.java
├── Number of Students Doing Homework at a Given Time/
│ └── kata.go
├── Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold/
│ └── kata.java
├── Number of Unique Subjects Taught by Each Teacher/
│ └── k.sql
├── Number of Visible People in a Queue/
│ └── kata.go
├── Occurrences After Bigram/
│ └── kata.go
├── One Edit Distance/
│ └── kata.go
├── Online Stock Span/
│ └── kata.go
├── Orders With Maximum Quantity Above Average/
│ └── q.sql
├── Palindrome Linked List/
│ └── kata.go
├── Palindrome Number/
│ └── kata.go
├── Parsing A Boolean Expression/
│ └── kata.go
├── Partition Array According to Given Pivot/
│ └── kata.go
├── Partitioning Into Minimum Number Of Deci-Binary Numbers/
│ └── kata.java
├── Pascal's Triangle/
│ └── kata.go
├── Pascal's Triangle II/
│ └── kata.go
├── Path Sum/
│ └── kata.go
├── Patients With a Condition/
│ └── q.sql
├── Peak Index in a Mountain Array/
│ └── kata.go
├── Peeking Iterator/
│ └── kata.go
├── Percentage of Letter in String/
│ └── kata.go
├── Percentage of Users Attended a Contest/
│ └── q.sql
├── Perfect Number/
│ └── kata.go
├── Perform String Shifts/
│ └── kata.go
├── Permutations/
│ └── kata.go
├── Permutations II/
│ └── kata.go
├── Plus One/
│ └── kata.go
├── Points That Intersect With Cars/
│ └── kata.go
├── Populating Next Right Pointers in Each Node/
│ └── kata.go
├── Positions of Large Groups/
│ └── kata.go
├── Power of Four/
│ └── kata.go
├── Power of Three/
│ └── kata.go
├── Power of Two/
│ └── kata.go
├── Powerful Integers/
│ └── kata.go
├── Prefix and Suffix Search/
│ └── kata.go
├── Primary Department for Each Employee/
│ └── q.sql
├── Prime Number of Set Bits in Binary Representation/
│ └── kata.java
├── Print Immutable Linked List in Reverse/
│ └── kata.go
├── Product Sales Analysis I/
│ └── q.sql
├── Product Sales Analysis II/
│ └── q.sql
├── Product of Array Except Self/
│ └── kata.go
├── Product of the Last K Numbers/
│ └── kata.go
├── Product's Price for Each Store/
│ └── q.sql
├── Product's Worth Over Invoices/
│ └── q.sql
├── Project Employees I/
│ └── q.sql
├── Queries Quality and Percentage/
│ └── q.sql
├── Queries on Number of Points Inside a Circle/
│ └── kata.java
├── Queries on a Permutation With Key/
│ └── kata.go
├── README.md
├── Random Pick Index/
│ └── kata.go
├── Range Sum Query - Immutable/
│ └── kata.go
├── Range Sum Query - Mutable/
│ └── kata.go
├── Range Sum Query 2D - Immutable/
│ └── kata.go
├── Range Sum of BST/
│ └── kata.go
├── Rank Scores/
│ └── kata.sql
├── Rank Transform of an Array/
│ └── kata.go
├── Ransom Note/
│ └── kata.go
├── Rearrange Array Elements by Sign/
│ └── kata.go
├── Rearrange Characters to Make Target String/
│ └── kata.go
├── Rearrange Products Table/
│ └── q.sql
├── Rearrange Spaces Between Words/
│ └── kata.go
├── Rearrange Words in a Sentence/
│ └── kata.go
├── Recyclable and Low Fat Products/
│ └── q.sql
├── Redistribute Characters to Make All Strings Equal/
│ └── kata.go
├── Reduce Array Size to The Half/
│ └── kata.go
├── Reformat Department Table/
│ └── q.sql
├── Relative Ranks/
│ └── kata.go
├── Remove All Adjacent Duplicates In String/
│ └── kata.java
├── Remove Colored Pieces if Both Neighbors are the Same Color/
│ └── kata.go
├── Remove Duplicates from Sorted List/
│ └── kata.go
├── Remove Duplicates from Sorted List II/
│ └── kata.go
├── Remove Element/
│ └── kata.go
├── Remove Linked List Elements/
│ └── kata.go
├── Remove Nth Node From End of List/
│ └── kata.go
├── Remove Stones to Minimize the Total/
│ └── kata.go
├── Remove Trailing Zeros From a String/
│ └── kata.go
├── Remove Vowels from a String/
│ └── kata.go
├── Removing Minimum and Maximum From Array/
│ └── kata.java
├── Removing Stars From a String/
│ └── kata.java
├── Rename Columns/
│ └── kata.py
├── Replace All 's to Avoid Consecutive Repeating Characters/
│ └── kata.go
├── Replace All Digits with Characters/
│ └── kata.go
├── Replace Employee ID With The Unique Identifier/
│ └── query.sql
├── Reshape Data: Concatenate/
│ └── kata.py
├── Reshape Data: Melt/
│ └── kata.py
├── Reshape Data: Pivot/
│ └── kata.py
├── Reshape the Matrix/
│ └── kata.go
├── Return Length of Arguments Passed/
│ └── kata.js
├── Reverse Integer/
│ └── kata.go
├── Reverse Linked List/
│ └── kata.go
├── Reverse Prefix of Word/
│ └── kata.go
├── Reverse String/
│ └── kata.go
├── Reverse Vowels of a String/
│ └── kata.go
├── Reverse Words in a String/
│ └── kata.go
├── Reverse Words in a String III/
│ └── kata.go
├── Richest Customer Wealth/
│ └── kata.go
├── Rings and Rods/
│ └── kata.go
├── Roman to Integer/
│ └── kata.go
├── Root Equals Sum of Children/
│ └── kata.go
├── Rotate Array/
│ └── kata.go
├── Rotate String/
│ └── kata.go
├── Row With Maximum Ones/
│ └── kata.go
├── Running Sum of 1d Array/
│ └── kata.go
├── Running Total for Different Genders/
│ └── q.sql
├── Sales Analysis I/
│ └── q.sql
├── Sales Person/
│ └── q.sql
├── Sales by Day of the Week/
│ └── q.sql
├── Same Tree/
│ └── kata.go
├── Score of a String/
│ └── kata.go
├── Search Insert Position/
│ └── kata.go
├── Search a 2D Matrix/
│ └── kata.go
├── Search a 2D Matrix II/
│ └── kata.go
├── Search in Rotated Sorted Array II/
│ └── kata.go
├── Search in a Binary Search Tree/
│ └── kata.go
├── Seat Reservation Manager/
│ └── kata.go
├── Second Highest Salary/
│ └── kata.sql
├── Second Largest Digit in a String/
│ └── kata.go
├── Second Minimum Node In a Binary Tree/
│ └── kata.go
├── Select Data/
│ └── kata.py
├── Self Dividing Numbers/
│ └── kata.go
├── Sellers With No Sales/
│ └── q.sql
├── Separate the Digits in an Array/
│ └── kata.java
├── Set Mismatch/
│ └── kata.go
├── Shift 2D Grid/
│ └── kata.go
├── Shortest Distance in a Line/
│ └── q.sql
├── Shortest Distance to a Character/
│ └── kata.go
├── Shortest Word Distance/
│ └── kata.go
├── Shortest Word Distance II/
│ └── kata.go
├── Shuffle String/
│ └── kata.go
├── Shuffle the Array/
│ └── kata.go
├── Sign of the Product of an Array/
│ └── kata.go
├── Simple Bank System/
│ └── kata.go
├── Single Element in a Sorted Array/
│ └── kata.go
├── Single Number/
│ └── kata.go
├── Single-Row Keyboard/
│ └── kata.go
├── Sliding Window Maximum/
│ └── kata.go
├── Sliding Window Median/
│ └── kata.go
├── Smallest Even Multiple/
│ └── kata.go
├── Smallest Index With Equal Value/
│ └── kata.go
├── Smallest Range I/
│ └── kata.go
├── Sort Array By Parity/
│ └── kata.go
├── Sort Array by Increasing Frequency/
│ └── kata.go
├── Sort Characters By Frequency/
│ └── kata.go
├── Sort Integers by The Number of 1 Bits/
│ └── kata.go
├── Sort Integers by The Power Value/
│ └── kata.go
├── Sort the Olympic Table/
│ └── q.sql
├── Sort the People/
│ └── kata.go
├── Sorting the Sentence/
│ └── kata.go
├── Split With Minimum Sum/
│ └── kata.go
├── Split a String in Balanced Strings/
│ └── kata.go
├── Split the Array/
│ └── kata.go
├── Sqrt(x)/
│ └── kata.go
├── Squares of a Sorted Array/
│ └── kata.go
├── Strong Password Checker II/
│ └── kata.go
├── Student Attendance Record I/
│ └── kata.go
├── Subdomain Visit Count/
│ └── kata.go
├── Subrectangle Queries/
│ └── kata.go
├── Substrings of Size Three with Distinct Characters/
│ └── kata.java
├── Subtract the Product and Sum of Digits of an Integer/
│ └── kata.go
├── Subtree of Another Tree/
│ └── kata.go
├── Sum Multiples/
│ └── kata.go
├── Sum Root to Leaf Numbers/
│ └── kata.go
├── Sum in a Matrix/
│ └── kata.go
├── Sum of Digits in Base K/
│ └── kata.go
├── Sum of Digits in the Minimum Number/
│ └── kata.go
├── Sum of Digits of String After Convert/
│ └── kata.go
├── Sum of Even Numbers After Queries/
│ └── kata.java
├── Sum of Left Leaves/
│ └── kata.go
├── Sum of Squares of Special Elements/
│ └── kata.go
├── Sum of Unique Elements/
│ └── kata.go
├── Sum of Values at Indices With K Set Bits/
│ └── kata.go
├── Summary Ranges/
│ └── kata.go
├── Swap Nodes in Pairs/
│ └── kata.go
├── Swap Salary/
│ └── kata.sql
├── Symmetric Tree/
│ └── kata.java
├── Take Gifts From the Richest Pile/
│ └── kata.java
├── Tasks Count in the Weekend/
│ └── q.sql
├── The Airport With the Most Traffic/
│ └── q.sql
├── The Employee That Worked on the Longest Task/
│ └── kata.java
├── The K Weakest Rows in a Matrix/
│ └── kata.go
├── The Latest Login in 2020/
│ └── q.sql
├── The Number of Employees Which Report to Each Employee/
│ └── q.sql
├── The Number of Rich Customers/
│ └── q.sql
├── The Number of Users That Are Eligible for Discount/
│ └── q.sql
├── The Users That Are Eligible for Discount/
│ └── q.sql
├── The Winner University/
│ └── q.sql
├── Third Maximum Number/
│ └── kata.go
├── Thousand Separator/
│ └── kata.go
├── Three Consecutive Odds/
│ └── kata.go
├── Time Based Key-Value Store/
│ └── kata.go
├── To Be Or Not To Be/
│ └── kata.ts
├── To Lower Case/
│ └── kata.go
├── Toeplitz Matrix/
│ └── kata.go
├── Top K Frequent Elements/
│ └── kata.go
├── Top K Frequent Words/
│ └── kata.go
├── Top Travellers/
│ └── q.sql
├── Transpose Matrix/
│ └── kata.go
├── Triangle Judgement/
│ └── kata.sql
├── Truncate Sentence/
│ └── kata.go
├── Two Furthest Houses With Different Colors/
│ └── kata.go
├── Two Out of Three/
│ └── kata.go
├── Two Sum/
│ └── kata.py
├── Ugly Number/
│ └── kata.go
├── Uncommon Words from Two Sentences/
│ └── kata.go
├── Unique Morse Code Words/
│ └── kata.go
├── Unique Number of Occurrences/
│ └── kata.go
├── Unique Orders and Customers Per Month/
│ └── q.sql
├── Univalued Binary Tree/
│ └── kata.go
├── Valid Anagram/
│ └── kata.go
├── Valid Mountain Array/
│ └── kata.go
├── Valid Palindrome/
│ └── kata.go
├── Valid Palindrome II/
│ └── kata.go
├── Valid Parentheses/
│ └── kata.go
├── Validate Binary Search Tree/
│ └── kata.go
├── Warehouse Manager/
│ └── q.sql
├── Water Bottles/
│ └── kata.go
├── Weather Type in Each Country/
│ └── q.sql
├── Widest Vertical Area Between Two Points Containing No Points/
│ └── kata.java
├── Word Pattern/
│ └── kata.go
└── XOR Operation in an Array/
└── kata.go
================================================
FILE CONTENTS
================================================
================================================
FILE: Day of the Week/kata.py
================================================
# math equation by Tomohiko Sakamoto
class Solution:
def dayOfTheWeek(self, d: int, m: int, y: int) -> str:
t = [ 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 ]
# if month is less than 3 reduce year by 1
if (m < 3) :
y = y - 1
f = (y + y // 4 - y // 100 + y // 400 + t[m - 1] + d) % 7
weekDay = ""
if f == 6:
weekDay = "Saturday"
elif f == 0:
weekDay = "Sunday"
elif f == 1:
weekDay = "Monday"
elif f == 2:
weekDay = "Tuesday"
elif f == 3:
weekDay = "Wednesday"
elif f == 4:
weekDay = "Thursday"
elif f == 5:
weekDay = "Friday"
return weekDay
================================================
FILE: Find Total Time Spent by Each Employee/q.sql
================================================
SELECT event_day AS day, emp_id, SUM(out_time - in_time) AS total_time
FROM Employees
GROUP BY event_day, emp_id;
================================================
FILE: Students With Invalid Departments/q.sql
================================================
SELECT id, name FROM Students WHERE department_id NOT IN (SELECT id FROM Departments);
================================================
FILE: .gitignore
================================================
# Binaries for programs and plugins
*.exe
*.exe~
*.dll
*.so
*.dylib
# Test binary, built with `go test -c`
*.test
# Output of the go coverage tool, specifically when used with LiteIDE
*.out
# Dependency directories (remove the comment below to include it)
# vendor/
.idea
================================================
FILE: 3042. Count Prefix and Suffix Pairs I/kata.py
================================================
import itertools
class Solution:
def countPrefixSuffixPairs(self, words: List[str]) -> int:
matched = 0
for pair in itertools.combinations(words, 2):
if self.isPrefixAndSuffix(pair[0], pair[1]):
matched = matched + 1
return matched
def isPrefixAndSuffix(self, a: str, b :str) -> bool:
if len(a) > len(b):
return False
if a == b[:len(a)] and b[len(b)-len(a):] == a:
return True
return False
================================================
FILE: 3110. Score of a String/main.scala
================================================
object Solution {
def scoreOfString(s: String): Int = {
var sum: Int = 0
for (i <- 1 to s.length-1) {
sum += (s.charAt(i-1) - s.charAt(i)).abs
}
return sum
}
}
================================================
FILE: A Number After a Double Reversal/kata.go
================================================
package A_Number_After_a_Double_Reversal
func isSameAfterReversals(num int) bool {
if num == 0 {
return true
}
return num%10 > 0
}
================================================
FILE: Account Balance/q.sql
================================================
SELECT
account_id,
day,
SUM(IF(type = 'Deposit', amount, -amount)) OVER (
PARTITION BY account_id
ORDER BY
day
) AS balance
FROM
Transactions;
================================================
FILE: Account Balance After Rounded Purchase/kata.go
================================================
package kata
func accountBalanceAfterPurchase(purchaseAmount int) int {
initAccount := 100
point := purchaseAmount % 10
if point <= 4 {
purchaseAmount = purchaseAmount - point
} else {
purchaseAmount = purchaseAmount + (10 - point)
}
return initAccount - purchaseAmount
}
================================================
FILE: Accounts Merge/kata.go
================================================
package kata
import "sort"
func accountsMerge(accounts [][]string) [][]string {
toDelete := make(map[int]bool)
for {
ok := merge(accounts, toDelete)
if !ok {
break
}
}
previousLen := len(accounts)
for k := 0; k < previousLen; k++ {
if !toDelete[k] {
accounts[k] = emailUnion(accounts[k], 1)
sort.Slice(accounts[k], func(i, j int) bool {
return accounts[k][i] < accounts[k][j]
})
accounts = append(accounts, accounts[k])
}
}
return accounts[previousLen:]
}
func merge(accounts [][]string, toDelete map[int]bool) bool {
emails := make(map[string]int)
for i, account := range accounts {
if toDelete[i] {
continue
}
for _, email := range account[1:] {
v, ok := emails[email]
if ok && emails[email] != i {
accounts[v] = append(accounts[v], accounts[i][1:]...)
toDelete[i] = true
return true
}
emails[email] = i
}
}
return false
}
func emailUnion(a []string, startIdx int) []string {
set := make(map[string]bool, len(a)/2)
for i := startIdx; i < len(a); i++ {
set[a[i]] = true
}
a = a[:1]
for elem := range set {
a = append(a, elem)
}
return a
}
================================================
FILE: Active Businesses/q.sql
================================================
WITH EventsAVG AS (
SELECT
event_type,
AVG(occurences) AS occurences_avg
FROM
Events
GROUP BY
event_type
)
SELECT
DISTINCT business_id
FROM
EventsAVG AS ea
JOIN Events AS e ON e.event_type = ea.event_type
WHERE
occurences > ea.occurences_avg
GROUP BY
business_id
HAVING
COUNT(e.event_type) > 1;
================================================
FILE: Add Binary/kata.go
================================================
package kata
func addBinary(a string, b string) string {
if len(a) == 0 && len(b) == 0 {
return "0"
}
bb := []byte(b)
aa := []byte(a)
if len(aa) > len(bb) {
for len(bb) < len(aa) {
bb = append([]byte{'0'}, bb...)
}
} else {
for len(aa) < len(bb) {
aa = append([]byte{'0'}, aa...)
}
}
carry := byte(0)
for i := len(bb) - 1; i >= 0; i-- {
if (bb[i] == '0' && aa[i] == '0') && carry == byte(1) {
bb[i] = '1'
carry = byte(0)
} else if (bb[i] == '1' && aa[i] == '1') && carry == byte(1) {
bb[i] = '1'
} else if (bb[i] == '1' || aa[i] == '1') && carry == byte(1) {
bb[i] = '0'
} else if bb[i] == '1' && aa[i] == '1' {
bb[i] = '0'
carry = byte(1)
} else if (bb[i] == '0' && aa[i] == '1') || (bb[i] == '1' && aa[i] == '0') {
bb[i] = '1'
carry = byte(0)
} else if bb[i] == '0' && aa[i] == '0' {
bb[i] = '0'
carry = byte(0)
}
}
if carry == byte(1) {
bb = append([]byte{'1'}, bb...)
}
return string(bb)
}
================================================
FILE: Add Digits/kata.go
================================================
package kata
func addDigits(num int) int {
if num == 0 {
return 0
}
var digitCount int
for {
num, digitCount = sumFunc(num)
if digitCount == 1 {
return num
}
}
}
func sumFunc(num int) (int, int) {
var s int
var c int
for num > 0 {
n := num % 10
num = num / 10
s += n
c++
}
return s, c
}
================================================
FILE: Add One Row to Tree/kata.go
================================================
package kata
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func addOneRow(root *TreeNode, v int, d int) *TreeNode {
if d == 1 {
return &TreeNode{Val: v, Left: root}
}
add(root, 0, v, d-1)
return root
}
func add(node *TreeNode, count, v, d int) {
count = count + 1
if count == d {
tmp := node.Right
node.Right = &TreeNode{Val: v}
node.Right.Right = tmp
tmp = node.Left
node.Left = &TreeNode{Val: v}
node.Left.Left = tmp
return
}
if node.Right != nil {
add(node.Right, count, v, d)
}
if node.Left != nil {
add(node.Left, count, v, d)
}
}
================================================
FILE: Add Strings/kata.go
================================================
package kata
func addStrings(num1 string, num2 string) string {
if len(num1) < len(num2) {
num1 = padding(num2, num1)
return sumFunc(num1, num2)
} else if len(num1) > len(num2) {
num2 = padding(num1, num2)
return sumFunc(num1, num2)
}
return sumFunc(num1, num2)
}
func sumFunc(num1, num2 string) string {
num3 := []byte(num1)
var lastReminder byte
for i := len(num2) - 1; i >= 0; i-- {
sum := ((num1[i] - 48) + (num2[i] - 48)) + lastReminder
if sum > 9 {
diff := sum - byte(9)
if diff > 1 {
num3[i] = diff - 1 + 48
} else {
num3[i] = 48
}
lastReminder = byte(1)
} else {
num3[i] = sum + 48
lastReminder = byte(0)
}
}
if lastReminder > 0 {
return "1" + string(num3)
}
return string(num3)
}
func padding(num2, num1 string) string {
diff := len(num2) - len(num1)
for diff > 0 {
num1 = "0" + num1
diff--
}
return num1
}
================================================
FILE: Add Two Integers/kata.go
================================================
package Add_Two_Integers
func sum(num1 int, num2 int) int {
return num1 + num2
}
================================================
FILE: Adding Spaces to a String/kata.go
================================================
package Adding_Spaces_to_a_String
func addSpaces(s string, spaces []int) string {
b := make([]byte, len(s)+len(spaces))
var j int
var k int
for i := 0; i < len(s)+len(spaces); i++ {
if k < len(spaces) && spaces[k] == j {
b[i] = ' '
k++
} else {
b[i] = s[j]
j++
}
}
return string(b)
}
================================================
FILE: All Elements in Two Binary Search Trees/kata.go
================================================
package kata
import "sort"
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func getAllElements(root1 *TreeNode, root2 *TreeNode) []int {
list := make([]int, 0)
inorder(root1, &list)
inorder(root2, &list)
sort.Slice(list, func(i, j int) bool {
return list[i] < list[j]
})
return list
}
func inorder(node *TreeNode, list *[]int) {
if node == nil {
return
}
if node.Left != nil {
inorder(node.Left, list)
}
*list = append(*list, node.Val)
if node.Right != nil {
inorder(node.Right, list)
}
}
================================================
FILE: All the Matches of the League/q.sql
================================================
SELECT a.team_name AS home_team,
b.team_name AS away_team
FROM Teams AS a
INNER JOIN Teams AS b ON b.team_name != a.team_name;
================================================
FILE: Allow One Function Call/kata.ts
================================================
type JSONValue = null | boolean | number | string | JSONValue[] | { [key: string]: JSONValue };
type OnceFn = (...args: JSONValue[]) => JSONValue | undefined
function once(fn: Function): OnceFn {
let called: boolean = false;
return function (...args) {
if (called == true) {
return undefined;
}
called = true
return fn(...args);
};
}
/**
* let fn = (a,b,c) => (a + b + c)
* let onceFn = once(fn)
*
* onceFn(1,2,3); // 6
* onceFn(2,3,6); // returns undefined without calling fn
*/
================================================
FILE: Alternating Digit Sum/kata.java
================================================
class Solution {
public int alternateDigitSum(int n) {
var digitCount = ((int) Math.log10((double) n));
var sum = 0;
var sign = 1;
for (; digitCount >= 0; digitCount--) {
var digit = (n/(int) Math.pow(10, (double) digitCount)) % 10;
sum += sign * digit;
sign = sign * -1;
}
return sum;
}
}
================================================
FILE: Ant on the Boundary/kata.go
================================================
func returnToBoundaryCount(nums []int) int {
var prefixSum int
var count int
for _, num := range nums {
prefixSum += num
if prefixSum == 0 {
count++
}
}
return count
}
================================================
FILE: Apple Redistribution into Boxes/kata.go
================================================
package kata
import "sort"
func minimumBoxes(apple []int, capacity []int) int {
sort.Slice(capacity, func(i, j int) bool {
return capacity[i] > capacity[j]
})
var applesCount int
for i := range apple {
applesCount += apple[i]
}
var sum, count int
for i := range capacity {
sum += capacity[i]
count++
if sum >= applesCount {
break
}
}
return count
}
================================================
FILE: Apples & Oranges/q.sql
================================================
SELECT
sale_date,
SUM(
CASE WHEN fruit = 'apples' THEN sold_num END
)
- SUM(
CASE WHEN fruit = 'oranges' THEN sold_num END
) AS diff
FROM
Sales
GROUP BY
sale_date
ORDER BY
sale_date;
================================================
FILE: Apply Discount Every n Orders/kata.go
================================================
package kata
type Cashier struct {
CustomerCounter int
n int
discount float64
products map[int]float64
}
func Constructor(n int, discount int, products []int, prices []int) Cashier {
productsMap := make(map[int]float64, 0)
for i, p := range products {
productsMap[p] = float64(prices[i])
}
return Cashier{
n: n,
discount: float64(discount),
products: productsMap,
CustomerCounter: 0,
}
}
func (this *Cashier) GetBill(product []int, amount []int) float64 {
if len(product) != len(amount) {
panic("product and amount size are unequal")
}
this.CustomerCounter++
var totalPrice float64
for i, p := range product {
totalPrice += float64(this.products[p] * float64(amount[i]))
}
if this.CustomerCounter == this.n && this.discount > 0 && this.discount != 100 {
totalPrice = totalPrice - totalPrice*(this.discount/100)
this.CustomerCounter = 0
} else if this.discount == 100 {
return 0
}
return totalPrice
}
/**
* Your Cashier object will be instantiated and called as such:
* obj := Constructor(n, discount, products, prices);
* param_1 := obj.GetBill(product,amount);
*/
================================================
FILE: Apply Transform Over Each Element in Array/kata.ts
================================================
function map(arr: number[], fn: (n: number, i: number) => number): number[] {
if (arr.length == 0) {
return arr
}
let returnedArray: number[] = new Array(arr.length-1);
for(let i: number = 0; i < arr.length; i++) {
returnedArray[i] = fn(arr[i], i)
}
return returnedArray
};
================================================
FILE: Armstrong Number/kata.go
================================================
package kata
import "math"
func isArmstrong(n int) bool {
l := n
var c int
for l != 0 {
l /= 10
c++
}
var m int
k := n
for n != 0 {
r := n % 10
n /= 10
m += int(math.Pow(float64(r), float64(c)))
if m > k {
return false
}
}
return m == k
}
================================================
FILE: Arranging Coins/kata.go
================================================
package kata
func arrangeCoins(n int) int {
if n == 1 {
return 1
}
i := 1
c := 0
for n > 0 {
n = n - i
if n < 0 {
break
}
c++
i++
}
return c
}
================================================
FILE: Array Partition I/kata.go
================================================
package kata
import "sort"
func arrayPairSum(a []int) int {
sort.Slice(a, func(i, j int) bool {
return a[i] < a[j]
})
var sum int
for i := 0; i < len(a); i = i + 2 {
sum += a[i]
}
return sum
}
================================================
FILE: Array Reduce Transformation/kata.ts
================================================
type Fn = (accum: number, curr: number) => number
function reduce(nums: number[], fn: Fn, init: number): number {
for(let i: number = 0; i < nums.length; i++) {
init = fn(init, nums[i])
}
return init
};
================================================
FILE: Array Wrapper/kata.ts
================================================
class ArrayWrapper {
nums: number[];
constructor(nums: number[]) {
this.nums = nums;
}
valueOf(): number {
let num: number = 0;
this.nums.forEach( n => {
num += n;
})
return num;
}
toString(): string {
return "[" + this.nums.toString() + "]";
}
};
/**
* const obj1 = new ArrayWrapper([1,2]);
* const obj2 = new ArrayWrapper([3,4]);
* obj1 + obj2; // 10
* String(obj1); // "[1,2]"
* String(obj2); // "[3,4]"
*/
================================================
FILE: Article Views I/q.sql
================================================
SELECT DISTINCT author_id AS id FROM Views WHERE author_id = viewer_id ORDER BY author_id;
================================================
FILE: Assign Cookies/kata.go
================================================
package Assign_Cookies
import "sort"
func findContentChildren(g []int, s []int) int {
if len(s) == 0 {
return 0
}
sort.Slice(g, func(i, j int) bool {
return g[i] > g[j]
})
sort.Slice(s, func(i, j int) bool {
return s[i] > s[j]
})
var j int
var c int
for i := 0; i < len(g); {
if s[j] >= g[i] {
c++
i++
j++
if j == len(s) {
break
}
} else {
i++
}
}
return c
}
================================================
FILE: Average Salary Excluding the Minimum and Maximum Salary/kata.go
================================================
package kata
import "sort"
func average(salary []int) float64 {
sort.Ints(salary)
salary = salary[1 : len(salary)-1]
var average int
for _, n := range salary {
average = average + n
}
return float64(average) / float64(len(salary))
}
================================================
FILE: Average Selling Price/q.sql
================================================
SELECT p.product_id,
ROUND(Sum(p.price * us.units) / Sum(us.units), 2) AS average_price
FROM unitssold AS us
INNER JOIN prices AS p
ON p.product_id = us.product_id
WHERE us.purchase_date >= p.start_date
AND us.purchase_date <= p.end_date
GROUP BY us.product_id
================================================
FILE: Average Time of Process per Machine/q.sql
================================================
SELECT
machine_id,
ROUND(
(
SUM(
CASE WHEN activity_type = "end" THEN timestamp ELSE 0 END
) - SUM(
CASE WHEN activity_type = "start" THEN timestamp ELSE 0 END
)
) /(COUNT(*) / 2),
3
) as processing_time
FROM
Activity
GROUP BY
machine_id
================================================
FILE: Average Value of Even Numbers That Are Divisible by Three/kata.java
================================================
class Solution {
public int averageValue(int[] nums) {
var sum = 0;
var count = 0;
for (var i = 0; i < nums.length; i++) {
if (nums[i] % 2 == 0 && nums[i] % 3 == 0) {
sum += nums[i];
count++;
}
}
if (sum == 0) {
return 0;
}
return (int) Math.floor(sum / count);
}
}
================================================
FILE: Average of Levels in Binary Tree/kata.go
================================================
package kata
import "container/list"
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func averageOfLevels(node *TreeNode) []float64 {
if node == nil {
return nil
}
queue := list.New()
type TreeNodeWrapper struct {
n *TreeNode
l int
}
queue.PushBack(&TreeNodeWrapper{n: node, l: 1})
vals := make([]float64, 0)
var sum float64
lastLevel := 1
var count float64
for queue.Len() > 0 {
e := queue.Front()
w := e.Value.(*TreeNodeWrapper)
if w.n.Left != nil {
queue.PushBack(&TreeNodeWrapper{n: w.n.Left, l: w.l + 1})
}
if w.n.Right != nil {
queue.PushBack(&TreeNodeWrapper{n: w.n.Right, l: w.l + 1})
}
if w.l != lastLevel {
vals = append(vals, sum/count)
sum = 0
count = 0
lastLevel = w.l
}
count = count + 1
sum = sum + float64(w.n.Val)
queue.Remove(e)
if queue.Len() == 0 {
vals = append(vals, sum/count)
}
}
return vals
}
================================================
FILE: Backspace String Compare/kata.go
================================================
package kata
func backspaceCompare(S string, T string) bool {
return mod(S) == mod(T)
}
func mod(S string) string {
modifiedS := make([]byte, 0)
var j int
for i := 0; i < len(S); i++ {
if S[i] == '#' {
if j-1 >= 0 {
modifiedS = modifiedS[:j-1]
j = j - 1
}
continue
}
j++
modifiedS = append(modifiedS, S[i])
}
return string(modifiedS)
}
================================================
FILE: Bank Account Summary/q.sql
================================================
SELECT
Ux.user_id,
Ux.user_name,
(credit + SUM(COALESCE(Tx.amount, 0))) AS credit,
(
CASE WHEN (credit + SUM(COALESCE(Tx.amount, 0))) < 0 THEN 'Yes' ELSE 'No' END
) AS credit_limit_breached
FROM
Users AS Ux
INNER JOIN (
(
SELECT
user_id,
- amount AS amount
FROM
Users AS u
LEFT JOIN Transactions AS t ON u.user_id = t.paid_by
)
UNION ALL
(
SELECT
user_id,
amount AS amount
FROM
Users AS u
LEFT JOIN Transactions AS t ON u.user_id = t.paid_to
)
) AS Tx ON Tx.user_id = Ux.user_id
GROUP By
Ux.user_id;
================================================
FILE: Bank Account Summary II/q.sql
================================================
SELECT u.name, SUM(amount) AS balance FROM Users AS u INNER JOIN Transactions AS t ON t.account = u.account GROUP BY u.name HAVING balance > 10000 ;
================================================
FILE: Base 7/kata.go
================================================
package kata
func convertToBase7(num int) string {
if num == 0 {
return "0"
}
var neg bool
if num < 0 {
num = num * -1
neg = true
}
convertedNum := make([]byte, 0)
for num > 0 {
rem := num % 7
num = num / 7
rem = rem + 48
convertedNum = append(convertedNum, byte(rem))
}
for i, j := 0, len(convertedNum)-1; i < j; i, j = i+1, j-1 {
convertedNum[i], convertedNum[j] = convertedNum[j], convertedNum[i]
}
if neg {
return "-" + string(convertedNum)
}
return string(convertedNum)
}
================================================
FILE: Baseball Game/kata.go
================================================
package kata
import "strconv"
func calPoints(ops []string) int {
history := make([]int, 0)
for _, op := range ops {
if op == "C" {
history = history[:len(history)-1]
continue
} else if op == "D" {
n := history[len(history)-1] * 2
history = append(history, n)
continue
} else if op == "+" {
n := history[len(history)-1] + history[len(history)-2]
history = append(history, n)
continue
}
n, _ := strconv.Atoi(op)
history = append(history, n)
}
var sum int
for _, n := range history {
sum = sum + n
}
return sum
}
================================================
FILE: Basic Calculator II/kata.go
================================================
package kata
import (
"container/list"
)
func calculate(s string) int {
nodes := Parse([]byte(s))
return Eval(nodes)
}
const (
NumberKind = iota
PlusKind
MinusKind
MultiplyKind
DvisionKind
)
type Node struct {
Identifier byte
Kind int
Value int
Priority int
}
const (
Multiply byte = 42
Dvision byte = 47
Plus byte = 43
Minus byte = 45
)
func Parse(expression []byte) *list.List {
nodes := list.New()
for i := len(expression) - 1; i >= 0; i-- {
if expression[i] == Minus {
nodes.PushBack(Node{Kind: MinusKind})
} else if expression[i] == Multiply {
nodes.PushBack(Node{Kind: MultiplyKind, Priority: 1})
} else if expression[i] == Plus {
nodes.PushBack(Node{Kind: PlusKind})
} else if expression[i] == Dvision {
nodes.PushBack(Node{Kind: DvisionKind, Priority: 1})
} else if expression[i] >= 48 && expression[i] <= 57 {
n := Node{Kind: NumberKind}
var sum int
sum = int(expression[i]) - 48
i--
norm := 10
for i >= 0 {
if expression[i] >= 48 && expression[i] <= 57 {
sum += (int(expression[i]) - 48) * norm
i--
norm = norm * 10
} else {
i++
break
}
}
n.Value = sum
nodes.PushBack(n)
}
}
return nodes
}
func Eval(nodes *list.List) int {
if nodes.Len() == 0 {
return 0
}
for e := nodes.Back(); e != nil; e = e.Prev() {
node := e.Value.(Node)
if node.Priority == 1 {
if node.Kind == MultiplyKind {
eA := e.Prev()
nodeA := eA.Value.(Node)
eb := e.Next()
nodeB := eb.Value.(Node)
sum := nodeA.Value * nodeB.Value
nodes.Remove(eb)
nodes.Remove(eA)
newNode := nodes.InsertBefore(Node{Kind: NumberKind, Value: sum}, e)
nodes.Remove(e)
e = newNode
}
if node.Kind == DvisionKind {
eA := e.Prev()
nodeA := eA.Value.(Node)
eb := e.Next()
nodeB := eb.Value.(Node)
sum := nodeB.Value / nodeA.Value
nodes.Remove(eb)
nodes.Remove(eA)
newNode := nodes.InsertBefore(Node{Kind: NumberKind, Value: sum}, e)
nodes.Remove(e)
e = newNode
}
}
}
value := nodes.Back()
sum := value.Value.(Node).Value
value = value.Prev()
for e := value; e != nil; e = e.Prev() {
node := e.Value.(Node)
if node.Kind == PlusKind {
e = e.Prev()
node = e.Value.(Node)
sum += node.Value
} else if node.Kind == MinusKind {
e = e.Prev()
node = e.Value.(Node)
sum -= node.Value
}
}
return sum
}
================================================
FILE: Best Poker Hand/kata.go
================================================
package kata
func bestHand(ranks []int, suits []byte) string {
c := make([]int, 13+4)
for i, suit := range suits {
c[ranks[i]-1]++
c[suit-97+13]++
}
i := len(c) - 1
for ; i >= 13; i-- {
if c[i] == 5 {
return "Flush"
}
}
var max int
for ; i >= 0; i-- {
if c[i] > max {
max = c[i]
}
}
if max >= 3 {
return "Three of a Kind"
} else if max == 2 {
return "Pair"
}
return "High Card"
}
================================================
FILE: Best Time to Buy and Sell Stock/kata.go
================================================
package kata
func maxProfit(prices []int) int {
min := -1
var maxProfit int
for i := 0; i < len(prices); i++ {
if min == -1 || min > prices[i] {
min = prices[i]
} else if prices[i]-min > maxProfit {
maxProfit = prices[i] - min
}
}
return maxProfit
}
================================================
FILE: Big Countries/kata.sql
================================================
package kata
SELECT name,population,area FROM World WHERE area > 3000000 OR population > 25000000;
================================================
FILE: Biggest Single Number/q.sql
================================================
(SELECT num
FROM mynumbers GROUP BY num
HAVING Count(num) = 1
ORDER BY num DESC
LIMIT 1)
UNION
(SELECT NULL)
LIMIT 1
================================================
FILE: Binary Gap/kata.go
================================================
package kata
func binaryGap(n int) int {
var globalMax int
var max int
for n != 0 {
r := n % 2
n = n / 2
if r == 0 && max == 0 {
continue
} else if r == 1 && max == 0 {
max++
} else if r == 1 && max != 0 {
if max > globalMax {
globalMax = max
}
max = 1
} else {
max++
}
}
return globalMax
}
================================================
FILE: Binary Number with Alternating Bits/kata.go
================================================
package kata
func hasAlternatingBits(n int) bool {
lastBit := n % 2
n = n >> 1
for n > 0 {
b := n % 2
n = n >> 1
if lastBit == b {
return false
}
lastBit = b
}
return true
}
================================================
FILE: Binary Prefix Divisible By 5/kata.py
================================================
class Solution(object):
def prefixesDivBy5(self, nums):
"""
:type nums: List[int]
:rtype: List[bool]
"""
result = [False] * len(nums)
tracker = 1
i = 0
for i, num in enumerate(nums):
if num != 0:
break
else:
result[i] = True
i += 1
for num in nums[i:]:
if num == 0:
tracker = tracker << 1
if tracker % 5 == 0:
result[i] = True
else:
tracker = tracker << 1
tracker = tracker | 1
if tracker % 5 == 0:
result[i] = True
i += 1
return result
================================================
FILE: Binary Search Tree Iterator/kata.go
================================================
package kata
import "sort"
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
type BSTIterator struct {
stack []int
}
func Constructor(root *TreeNode) BSTIterator {
stack := make([]int, 0)
populateStack(root, &stack)
sort.Slice(stack, func(i, j int) bool {
return stack[i] < stack[j]
})
return BSTIterator{
stack: stack,
}
}
func populateStack(node *TreeNode, stack *[]int) {
if node == nil {
return
}
*stack = append(*stack, node.Val)
if node.Left != nil {
populateStack(node.Left, stack)
}
if node.Right != nil {
populateStack(node.Right, stack)
}
}
/** @return the next smallest number */
func (this *BSTIterator) Next() int {
v := this.stack[0]
this.stack = this.stack[1:]
return v
}
/** @return whether we have a next smallest number */
func (this *BSTIterator) HasNext() bool {
if len(this.stack) == 0 {
return false
}
return true
}
/**
* Your BSTIterator object will be instantiated and called as such:
* obj := Constructor(root);
* param_1 := obj.Next();
* param_2 := obj.HasNext();
*/
================================================
FILE: Binary Tree Inorder Traversal/kata.go
================================================
package kata
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func inorderTraversal(root *TreeNode) []int {
list := make([]int, 0)
traversal(root, &list)
return list
}
func traversal(node *TreeNode, list *[]int) {
if node == nil {
return
}
if node.Left != nil {
traversal(node.Left, list)
}
*list = append(*list, node.Val)
if node.Right != nil {
traversal(node.Right, list)
}
}
================================================
FILE: Binary Tree Paths/kata.go
================================================
package kata
import "strconv"
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func binaryTreePaths(root *TreeNode) []string {
if root == nil {
return []string{}
}
paths := make([]string, 0)
allPaths(root, strconv.Itoa(root.Val)+"->", &paths)
return paths
}
func allPaths(node *TreeNode, s string, all *[]string) {
if node.Left == nil && node.Right == nil {
*all = append(*all, s[:len(s)-2])
return
}
if node.Left != nil {
allPaths(node.Left, s+strconv.Itoa(node.Left.Val)+"->", all)
}
if node.Right != nil {
allPaths(node.Right, s+strconv.Itoa(node.Right.Val)+"->", all)
}
}
================================================
FILE: Binary Tree Postorder Traversal/kata.go
================================================
package kata
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func postorderTraversal(root *TreeNode) []int {
list := make([]int, 0)
traversal(root, &list)
return list
}
func traversal(node *TreeNode, list *[]int) {
if node == nil {
return
}
if node.Left != nil {
traversal(node.Left, list)
}
if node.Right != nil {
traversal(node.Right, list)
}
*list = append(*list, node.Val)
}
================================================
FILE: Binary Tree Preorder Traversal/kata.go
================================================
package kata
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func preorderTraversal(root *TreeNode) []int {
list := make([]int, 0)
traversal(root, &list)
return list
}
func traversal(node *TreeNode, list *[]int) {
if node == nil {
return
}
*list = append(*list, node.Val)
if node.Left != nil {
traversal(node.Left, list)
}
if node.Right != nil {
traversal(node.Right, list)
}
}
================================================
FILE: Build Array from Permutation/kata.go
================================================
package kata
func buildArray(nums []int) []int {
permNums := make([]int, len(nums))
for i := 0; i < len(nums); i++ {
permNums[i] = nums[nums[i]]
}
return permNums
}
================================================
FILE: Buildings With an Ocean View/kata.java
================================================
class Solution {
public int[] findBuildings(int[] heights) {
var n = heights.length;
Stack<Integer> buildings = new Stack<>();
for (int i = 0; i < n; i++) {
while (!buildings.empty() && heights[buildings.peek()] <= heights[i]) {
buildings.pop();
}
buildings.push(i);
}
var result = new int[buildings.size()];
var i = buildings.size()-1;
while (!buildings.isEmpty()) {
result[i] = buildings.pop();
i--;
}
return result;
}
}
================================================
FILE: Bulls and Cows/kata.go
================================================
package kata
import "strconv"
func getHint(secret string, guess string) string {
var bulls int
var cows int
chars := make(map[int]int)
idxs := make(map[int]bool)
for i, char := range secret {
chars[i] = int(char)
charNorm := int(char) * -1
chars[charNorm] = chars[charNorm] + 1
}
for i, char := range guess {
v, ok := chars[i]
if ok && v == int(char) {
charNorm := int(char) * -1
chars[charNorm] = chars[charNorm] - 1
if chars[charNorm] == 0 {
delete(chars, charNorm)
}
idxs[i] = true
bulls++
continue
}
}
for i, char := range guess {
if idxs[i] {
continue
}
charNorm := int(char) * -1
v := chars[charNorm]
if v > 0 {
chars[charNorm] = chars[charNorm] - 1
cows++
}
}
return strconv.Itoa(bulls) + "A" + strconv.Itoa(cows) + "B"
}
================================================
FILE: Calculate Amount Paid in Taxes/kata.go
================================================
package Calculate_Amount_Paid_in_Taxes
func calculateTax(brackets [][]int, income int) float64 {
if income == 0 {
return 0
}
k := 0
amount := 0.0
for _, bracket := range brackets {
if income >= bracket[0] {
if k == 0 {
k += bracket[0]
amount += float64(bracket[0]) * float64(bracket[1]) / 100
} else {
amount += (float64(bracket[0]) - float64(k)) * float64(bracket[1]) / 100
k += bracket[0] - k
}
} else if income < bracket[0] {
amount += float64(income-k) * float64(bracket[1]) / 100
break
}
}
return amount
}
================================================
FILE: Calculate Money in Leetcode Bank/kata.go
================================================
package kata
func totalMoney(n int) int {
count := 0
days := 0
bouns := 0
money := 1
for i := 0; i < n; i++ {
count += (money + bouns)
days++
money++
if days == 7 {
bouns++
days = 0
money = 1
}
}
return count
}
================================================
FILE: Calculate Salaries/q.sql
================================================
select
company_id,
employee_id,
employee_name,
(CASE
WHEN (MAX(salary) OVER(PARTITION BY company_id) >= 1000 AND MAX(salary) OVER(PARTITION BY company_id) <= 10000) THEN ROUND((salary-(salary*0.24)), 0)
WHEN (MAX(salary) OVER(PARTITION BY company_id) < 1000) THEN ROUND(salary,0)
WHEN (MAX(salary) OVER(PARTITION BY company_id) > 10000) THEN ROUND((salary-(salary*0.49)),0)
END) AS salary
from Salaries;
================================================
FILE: Calculate Special Bonus/q.sql
================================================
SELECT employee_id,
CASE
WHEN employee_id % 2 = 1 AND LEFT(name, 1) != 'M' THEN salary
ELSE 0
END AS bonus
FROM Employees;
================================================
FILE: Calculate the Influence of Each Salesperson/q.sql
================================================
SELECT salesperson_id,
name,
IFNULL(SUM(price), 0) AS total
FROM Salesperson AS s
LEFT JOIN Customer USING(salesperson_id)
LEFT JOIN Sales USING(customer_id)
GROUP BY s.salesperson_id;
================================================
FILE: Calculator with Method Chaining/kata.js
================================================
class Calculator {
/**
* @param {number} value
*/
constructor(value) {
this.currentValue = value
this.error = null
}
/**
* @param {number} value
* @return {Calculator}
*/
add(value){
this.currentValue += value
return this
}
/**
* @param {number} value
* @return {Calculator}
*/
subtract(value){
this.currentValue -= value
return this
}
/**
* @param {number} value
* @return {Calculator}
*/
multiply(value) {
this.currentValue *= value
return this
}
/**
* @param {number} value
* @return {Calculator}
*/
divide(value) {
if (value == 0) {
this.error = "Division by zero is not allowed"
return this
}
this.currentValue /= value
return this
}
/**
* @param {number} value
* @return {Calculator}
*/
power(value) {
this.currentValue = Math.pow(this.currentValue, value);
return this
}
/**
* @return {number}
*/
getResult() {
if (this.error != null) {
return this.error
}
return this.currentValue
}
}
================================================
FILE: Can Make Arithmetic Progression From Sequence/kata.go
================================================
package kata
import "sort"
func canMakeArithmeticProgression(arr []int) bool {
if len(arr) == 2 {
return true
}
sort.Ints(arr)
globalDiff := arr[1] - arr[0]
for i := 2; i < len(arr); i++ {
diff := arr[i] - arr[i-1]
if globalDiff != diff {
return false
}
}
return true
}
================================================
FILE: Can Place Flowers/kata.go
================================================
package kata
func canPlaceFlowers(flowerbed []int, n int) bool {
for i := 0; i < len(flowerbed); i++ {
if flowerbed[i] == 0 {
if i-1 >= 0 && flowerbed[i-1] != 0 {
continue
}
if i+1 < len(flowerbed) && flowerbed[i+1] != 0 {
continue
}
flowerbed[i] = 1
n = n - 1
}
}
return n <= 0
}
================================================
FILE: Capital Gain-loss/q.sql
================================================
SELECT
s.stock_name,
SUM(CASE WHEN s.operation="Buy" THEN -s.price ELSE s.price END) AS capital_gain_loss
FROM Stocks AS s
GROUP BY s.stock_name;
================================================
FILE: Capitalize the Title/kata.go
================================================
package Capitalize_the_Title
func capitalizeTitle(title string) string {
b := make([]byte, len(title))
var c int
var j int
for i := 0; i < len(title); i++ {
if 'A' <= title[i] && title[i] <= 'Z' {
b[i] = title[i] + 32
} else {
b[i] = title[i]
}
if title[i] == ' ' || len(title)-1 == i {
if len(title)-1 == i {
c++
}
if c > 2 && 'a' <= title[j] && title[j] <= 'z' {
b[j] = title[j] - 32
} else if c > 2 {
b[j] = title[j]
}
c = 0
j = i + 1
} else {
c++
}
}
return string(b)
}
================================================
FILE: Categorize Box According to Criteria/kata.java
================================================
class Solution {
public String categorizeBox(int length, int width, int height, int mass) {
var bulky = false;
var heavy = false;
// If the mass of the box is greater or equal to 100, it is "Heavy".
if (mass >= 100) {
heavy = true;
}
// The box is "Bulky" if any of the dimensions of the box is greater or equal to.
var dimensionThreshold = (long) Math.pow(10.0, 4.0);
if (length >= dimensionThreshold || width >= dimensionThreshold || height >= dimensionThreshold) {
bulky = true;
}
// The box is "Bulky" if the volume of the box is greater or equal to
if (((long)length * (long) width * (long) height) >= (long) Math.pow(10.0, 9)) {
bulky = true;
}
// If the box is both "Bulky" and "Heavy", then its category is "Both"
if (bulky && heavy) {
return "Both";
// If the box is neither "Bulky" nor "Heavy", then its category is "Neither"
}else if (!bulky && !heavy) {
return "Neither";
// If the box is "Bulky" but not "Heavy", then its category is "Bulky
} else if (bulky && !heavy) {
return "Bulky";
}
// If the box is "Heavy" but not "Bulky", then its category is "Heavy".
return "Heavy";
}
}
================================================
FILE: Cells with Odd Values in a Matrix/kata.go
================================================
package kata
func oddCells(n int, m int, indices [][]int) int {
if n == 0 {
return 0
}
matrix := make([][]int, n)
for i := 0; i < n; i++ {
matrix[i] = make([]int, m)
}
for _, idx := range indices {
n := idx[0]
m := idx[1]
for j := 0; j < len(matrix[n]); j++ {
matrix[n][j]++
}
for i := 0; i < len(matrix); i++ {
matrix[i][m]++
}
}
var c int
for i := 0; i < n; i++ {
for j := 0; j < len(matrix[i]); j++ {
if matrix[i][j]%2 == 1 {
c++
}
}
}
return c
}
================================================
FILE: Change Data Type/kata.py
================================================
import pandas as pd
def changeDatatype(students: pd.DataFrame) -> pd.DataFrame:
students['grade'] = students['grade'].astype(int)
return students
================================================
FILE: Check Distances Between Same Letters/kata.java
================================================
class Solution {
public boolean checkDistances(String s, int[] distance) {
for (var i = 0; i < s.length(); i++) {
var distanceOfChar = distance[s.charAt(i)- 97];
var rightPosNewChar = distanceOfChar + i + 1;
var leftPosNewChar = i - distanceOfChar - 1;
var left = true;
var right = true;
if (rightPosNewChar < s.length()) {
if (s.charAt(i) == s.charAt(rightPosNewChar)) {
right = false;
}
}
if (leftPosNewChar >= 0) {
if (s.charAt(i) == s.charAt(leftPosNewChar)) {
left = false;
}
}
if (left && right) {
return false;
}
}
return true;
}
}
================================================
FILE: Check If All 1's Are at Least Length K Places Away/kata.go
================================================
package kata
func kLengthApart(nums []int, k int) bool {
var currentK *int
for i := 0; i < len(nums); i++ {
if nums[i] == 1 {
if currentK == nil {
currentK = new(int)
} else {
if *currentK < k {
return false
}
*currentK = 0
}
continue
}
if currentK != nil {
*currentK++
}
}
return true
}
================================================
FILE: Check If N and Its Double Exist/kata.go
================================================
package kata
func checkIfExist(arr []int) bool {
doubles := make(map[int]int)
for i := 0; i < len(arr); i++ {
doubles[arr[i]*2] = i
}
for i, n := range arr {
if doubles[n] == i {
continue
}
if _, ok := doubles[n]; ok {
return true
}
}
return false
}
================================================
FILE: Check If Two String Arrays are Equivalent/kata.go
================================================
package kata
func arrayStringsAreEqual(word1 []string, word2 []string) bool {
var i int
var j int
var a int
var b int
for a < len(word1) && b < len(word2) {
if word1[a][i] != word2[b][j] {
return false
}
if a < len(word1) && len(word1[a])-1 == i {
i = 0
a++
if b < len(word2) && len(word2[b])-1 == j {
j = 0
b++
continue
}
j++
continue
}
if b < len(word2) && len(word2[b])-1 == j {
j = 0
b++
if a < len(word1) && len(word1[a])-1 == i {
i = 0
a++
continue
}
i++
continue
}
i++
j++
}
if i != 0 || j != 0 {
return false
}
return true
}
================================================
FILE: Check If a Number Is Majority Element in a Sorted Array/kata.java
================================================
class Solution {
public boolean isMajorityElement(int[] nums, int target) {
var count = 0;
for (var num: nums) {
if (num == target) {
count++;
}
}
return count > nums.length/2;
}
}
================================================
FILE: Check If a Word Occurs As a Prefix of Any Word in a Sentence/kata.go
================================================
package kata
func isPrefixOfWord(sentence string, searchWord string) int {
var wordCounter int
var matched bool
var j int
for i := 0; i < len(sentence); i++ {
if sentence[i] == ' ' || i == len(sentence)-1 {
if i == len(sentence)-1 {
i = i + 1
}
wordCounter++
if len(sentence[j:i]) >= len(searchWord) {
if sentence[j:j+len(searchWord)] == searchWord {
matched = true
break
}
}
j = i + 1
}
}
if !matched {
return -1
}
return wordCounter
}
================================================
FILE: Check Whether Two Strings are Almost Equivalent/kata.go
================================================
package Check_Whether_Two_Strings_are_Almost_Equivalent
import "math"
func checkAlmostEquivalent(word1 string, word2 string) bool {
if len(word1) != len(word2) {
return false
}
wordCounter1 := [26]int{}
wordCounter2 := [26]int{}
for i := 0; i < len(word1); i++ {
wordCounter1[int(word1[i])-97]++
wordCounter2[int(word2[i])-97]++
}
for i := 0; i < len(wordCounter1); i++ {
diff := math.Abs(float64(wordCounter1[i] - wordCounter2[i]))
if diff > 3.0 {
return false
}
}
return true
}
================================================
FILE: Check if All A's Appears Before All B's/kata.go
================================================
package Check_if_All_A_s_Appears_Before_All_B_s
func checkString(s string) bool {
for i := 1; i < len(s); i++ {
if s[i-1] == 'b' && s[i] == 'a' {
return false
}
}
return true
}
================================================
FILE: Check if All Characters Have Equal Number of Occurrences/kata.go
================================================
package kata
import "math"
func areOccurrencesEqual(s string) bool {
chars := make(map[byte]int)
for i := 0; i < len(s); i++ {
chars[s[i]]++
}
inf := int(math.Inf(1))
min := inf
max := inf
for _, count := range chars {
if max == inf || count > max {
max = count
}
if min == inf || count < min {
min = count
}
}
return max == min
}
================================================
FILE: Check if Binary String Has at Most One Segment of Ones/kata.go
================================================
package Check_if_Binary_String_Has_at_Most_One_Segment_of_Ones
func checkOnesSegment(s string) bool {
if len(s) == 1 && s[0] == '1' {
return true
}
c := 0
oneContiguousSegment := false
for i := 0; i < len(s); i++ {
if s[i] == '1' {
if oneContiguousSegment {
return false
}
c++
} else {
if c >= 1 {
oneContiguousSegment = true
}
c = 0
}
}
if c > 0 {
return true
}
return oneContiguousSegment
}
================================================
FILE: Check if Bitwise OR Has Trailing Zeros/kata.go
================================================
package kata
func hasTrailingZeros(nums []int) bool {
var count int
for _, num := range nums {
if num%2 == 0 {
count++
if count == 2 {
break
}
}
}
return count == 2
}
================================================
FILE: Check if Number Has Equal Digit Count and Digit Value/kata.go
================================================
package Check_if_Number_Has_Equal_Digit_Count_and_Digit_Value
func digitCount(num string) bool {
c := map[rune]int{}
for _, digit := range num {
c[digit]++
}
for i, digit := range num {
if c[rune(i+48)] != int(digit-48) {
return false
}
}
return true
}
================================================
FILE: Check if Numbers Are Ascending in a Sentence/kata.go
================================================
package kata
import "math"
func areNumbersAscending(s string) bool {
currentNumber := int(math.Inf(-1))
for i := len(s) - 1; i >= 0; i-- {
if s[i] >= 48 && s[i] <= 57 {
n := 1
newNumber := (int(s[i]) - 48) * n
i = i - 1
for ; i >= 0; i-- {
if s[i] >= 48 && s[i] <= 57 {
n = n * 10
newNumber += (int(s[i]) - 48) * n
} else {
break
}
}
if currentNumber == int(math.Inf(-1)) {
currentNumber = newNumber
} else {
if currentNumber <= newNumber {
return false
}
currentNumber = newNumber
}
}
}
return true
}
================================================
FILE: Check if One String Swap Can Make Strings Equal/kata.go
================================================
package kata
func areAlmostEqual(s1 string, s2 string) bool {
if len(s1) != len(s1) {
return false
}
if s1 == s2 {
return true
}
var distance int
var pairs [][]int
for i, codepoint := range s1 {
if codepoint != rune(s2[i]) {
distance++
if distance > 2 {
return false
}
pair := []int{int(codepoint), int(s2[i])}
pairs = append(pairs, pair)
}
}
if len(pairs) == 2 && pairs[0][0] == pairs[1][1] && pairs[0][1] == pairs[1][0] {
return true
}
return false
}
================================================
FILE: Check if The Number is Fascinating/kata.go
================================================
package kata
func isFascinating(n int) bool {
var stats = [9]int{}
var tracker int = 0
for i := 1; i <= 3; i++ {
ok := countDigits(n*i, &stats, &tracker)
if !ok {
return false
}
}
return true
}
func countDigits(n int, stats *[9]int, tracker *int) bool {
for n > 0 {
var digit = n % 10
n = n / 10
digit = digit - 1
if digit == -1 || stats[digit] > 0 {
return false
}
stats[digit]++
*tracker++
}
return *tracker%3 == 0
}
================================================
FILE: Check if Word Equals Summation of Two Words/kata.go
================================================
package kata
func isSumEqual(firstWord string, secondWord string, targetWord string) bool {
return sum(firstWord)+sum(secondWord) == sum(targetWord)
}
func sum(s string) int {
var n int
m := 1
for i := len(s) - 1; i >= 0; i-- {
if s[i] != 'a' {
n += (int(s[i]) - 97) * m
}
m = m * 10
}
return n
}
================================================
FILE: Check if an Array Is Consecutive/kata.go
================================================
package Check_if_an_Array_Is_Consecutive
import "sort"
func isConsecutive(nums []int) bool {
sort.Ints(nums)
min, max := nums[0], nums[0]+len(nums)-1
for i := 1; i < len(nums); i++ {
if (nums[i] >= min && nums[i] <= max) && (nums[i-1] >= min && nums[i-1] <= max) {
if nums[i]-nums[i-1] != 1 {
return false
}
} else {
return false
}
}
return true
}
================================================
FILE: Check if the Sentence Is Pangram/kata.go
================================================
package kata
func checkIfPangram(sentence string) bool {
var abc [26]int
var count int
for _, char := range sentence {
abc[char-97] += 1
if abc[char-97] == 1 {
count++
}
}
if count != 26 {
return false
}
return true
}
================================================
FILE: Classes More Than 5 Students/kata.sql
================================================
package kata
SELECT class FROM courses GROUP BY class HAVING COUNT(DISTINCT(student)) >= 5;
================================================
FILE: Climbing Stairs/kata.go
================================================
package kata
func climbStairs(n int) int {
if n == 1 {
return 1
}
dp := make([]int, n+1)
dp[1] = 1
dp[2] = 2
for i := 3; i <= n; i++ {
dp[i] = dp[i-1] + dp[i-2]
}
return dp[n]
}
================================================
FILE: Combine Two Tables/kata.sql
================================================
package kata
# Write your MySQL query statement below
SELECT p.FirstName, p.LastName, City, State FROM Person p LEFT JOIN Address a ON a.PersonId = p.PersonId;
================================================
FILE: Compare Strings by Frequency of the Smallest Character/kata.go
================================================
package kata
import "sort"
func numSmallerByFrequency(queries []string, words []string) []int {
nums := make([]int, len(queries))
memory := make(map[string]int)
for i, query := range queries {
var count int
queryFrequency := f([]byte(query))
for _, word := range words {
wordFrequency, ok := memory[word]
if !ok {
wordFrequency = f([]byte(word))
memory[word] = wordFrequency
}
if wordFrequency > queryFrequency {
count++
}
}
nums[i] = count
}
return nums
}
func f(s []byte) int {
sort.Slice(s, func(i, j int) bool {
return s[i] < s[j]
})
lastChar := s[0]
c := 1
for i := 1; i < len(s); i++ {
if lastChar != s[i] {
return c
}
c++
lastChar = s[i]
}
return c
}
================================================
FILE: Complement of Base 10 Integer/kata.go
================================================
package kata
import "math"
func bitwiseComplement(N int) int {
if N == 0 {
return 1
} else if N == 1 {
return 0
}
var sum int
var k int
for N > 0 {
b := N % 2
N = N / 2
if b == 0 {
b = 1
} else {
b = 0
}
sum += b * int(math.Pow(2, float64(k)))
k++
}
return sum
}
================================================
FILE: Compute the Rank as a Percentage/q.sql
================================================
WITH cte
AS (SELECT student_id,
department_id,
RANK() OVER (PARTITION BY department_id ORDER BY mark DESC) student_rank_in_the_department,
COUNT(*) OVER (PARTITION BY department_id) AS the_number_of_students_in_the_department
FROM Students)
SELECT student_id,
department_id,
COALESCE(ROUND((student_rank_in_the_department - 1) * 100 / (the_number_of_students_in_the_department - 1), 2), 0) AS percentage
FROM cte
GROUP BY student_id;
================================================
FILE: Concatenate the Name and the Profession/q.sql
================================================
SELECT person_id, CONCAT(name, '(', LEFT(profession, 1) ,')') as name FROM Person ORDER BY person_id DESC;
================================================
FILE: Concatenation of Array/kata.go
================================================
package kata
func getConcatenation(nums []int) []int {
numsDouble := make([]int, len(nums)*2)
for i := 0; i < len(nums); i++ {
numsDouble[i] = nums[i]
numsDouble[i+len(nums)] = nums[i]
}
return numsDouble
}
================================================
FILE: Confusing Number/kata.java
================================================
class Solution {
public boolean confusingNumber(int num) {
var digitCount = ((int) Math.log10((double) num));
var reversedCount = 0;
var oldNum = num;
var newNum = 0;
for (; digitCount >= 0; digitCount--) {
var digit = (num/(int) Math.pow(10, (double) digitCount)) % 10;
if (digit == 2 || digit == 3 || digit == 4 || digit == 5 || digit == 7) {
return false;
}
if (digit == 6) {
digit = 9;
} else if (digit == 9) {
digit = 6;
}
newNum += digit * Math.pow(10, (double) reversedCount);
reversedCount++;
}
return oldNum != newNum;
}
}
================================================
FILE: Consecutive Available Seats/q.sql
================================================
((
SELECT
b.seat_id
FROM
Cinema AS a
INNER JOIN
Cinema AS b
ON b.seat_id + 1 = a.seat_id
WHERE
a.free = 1
AND b.free = 1)
UNION
(
SELECT
b.seat_id
FROM
Cinema AS a
INNER JOIN
Cinema AS b
ON b.seat_id - 1 = a.seat_id
WHERE
a.free = 1
AND b.free = 1))
ORDER BY
seat_id
================================================
FILE: Consecutive Characters/kata.go
================================================
package kata
import "math"
func maxPower(s string) int {
if len(s) == 0 {
return 0
}
if len(s) == 1 {
return 1
}
count := 1
maxCount := int(math.Inf(-1))
lastChar := s[0]
for i := 1; i < len(s); i++ {
if s[i] == lastChar {
count++
} else {
lastChar = s[i]
count = 1
}
if maxCount == int(math.Inf(-1)) || count > maxCount {
maxCount = count
}
}
return maxCount
}
================================================
FILE: Construct Binary Search Tree from Preorder Traversal/kata.go
================================================
package kata
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func bstFromPreorder(preorder []int) *TreeNode {
if len(preorder) == 0 {
return nil
}
root := &TreeNode{
Val: preorder[0],
}
for _, v := range preorder[1:] {
build(root, v)
}
return root
}
func build(node *TreeNode, v int) {
if node.Val > v {
if node.Left == nil {
node.Left = &TreeNode{Val: v}
} else {
build(node.Left, v)
}
} else if node.Val < v {
if node.Right == nil {
node.Right = &TreeNode{Val: v}
} else {
build(node.Right, v)
}
}
}
================================================
FILE: Construct String from Binary Tree/kata.java
================================================
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public String tree2str(TreeNode root) {
var pattern = new StringBuilder("");
generatePattern(root, pattern);
return pattern.toString();
}
private void generatePattern(TreeNode node, StringBuilder pattern) {
pattern.append(Integer.valueOf(node.val));
if (node.left == null && node.right != null) {
pattern.append('(');
pattern.append(')');
}else if (node.left != null) {
pattern.append('(');
generatePattern(node.left, pattern);
pattern.append(')');
}
if (node.right != null) {
pattern.append('(');
generatePattern(node.right, pattern);
pattern.append(')');
}
return;
}
}
================================================
FILE: Construct the Rectangle/kata.go
================================================
package Construct_the_Rectangle
import "math"
func constructRectangle(area int) []int {
if area == 1 {
return []int{1, 1}
}
nl, w, l := area, 0, 0
diff := math.Inf(1)
for {
if area%nl == 0 {
nw := area / nl
if nw > nl {
break
}
if diff > float64(nl-nw) {
w = nw
l = nl
diff = float64(nl - nw)
}
}
nl--
}
return []int{l, w}
}
================================================
FILE: Contains Duplicate/kata.go
================================================
package kata
func containsDuplicate(nums []int) bool {
counter := make(map[int]int)
for i := 0; i < len(nums); i++ {
counter[nums[i]] = counter[nums[i]] + 1
if counter[nums[i]] > 1 {
return true
}
}
return false
}
================================================
FILE: Contains Duplicate II/kata.go
================================================
package kata
func containsNearbyDuplicate(nums []int, k int) bool {
i := 0
j := i + 1
for i < len(nums) {
if j == len(nums) {
i++
j = i + 1
continue
}
if nums[i] != nums[j] {
j++
continue
}
if (j - i) <= k {
return true
}
i++
j = i + 1
}
return false
}
================================================
FILE: Convert 1D Array Into 2D Array/kata.go
================================================
package kata
func construct2DArray(original []int, m int, n int) [][]int {
if m*n != len(original) {
return [][]int{}
}
matrix := make([][]int, m)
for i := range matrix {
matrix[i] = make([]int, n)
}
k := n
i := 0
j := 0
for _, b := range original {
matrix[j][i] = b
k--
if k == 0 {
j++
k = n
i = 0
} else {
i++
}
}
return matrix
}
================================================
FILE: Convert Binary Number in a Linked List to Integer/kata.go
================================================
package kata
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
type NodeBacklink struct {
*ListNode
Prev *NodeBacklink
}
func getDecimalValue(head *ListNode) int {
current := &NodeBacklink{ListNode: head}
for current.Next != nil {
current = &NodeBacklink{ListNode: current.Next, Prev: current}
}
var sum int
if current != nil {
if current.Val == 1 {
sum += 1
}
current = current.Prev
} else {
return sum
}
step := 1
for current != nil {
step = step * 2
if current.Val == 1 {
sum += step
}
current = current.Prev
}
return sum
}
================================================
FILE: Convert Date Format/q.sql
================================================
SELECT DATE_FORMAT(day, "%W, %M %e, %Y") AS day FROM Days;
================================================
FILE: Convert Integer to the Sum of Two No-Zero Integers/kata.go
================================================
package Convert_Integer_to_the_Sum_of_Two_No_Zero_Integers
func getNoZeroIntegers(n int) []int {
i := 1
var k int
for {
k = n - i
if !hasZeros(k) && !hasZeros(i) {
return []int{i, k}
}
i++
}
}
func hasZeros(num int) bool {
for num > 0 {
if num%10 == 0 {
return true
}
num /= 10
}
return false
}
================================================
FILE: Convert a Number to Hexadecimal/kata.go
================================================
package kata
import "math/bits"
func toHex(num int) string {
if num == 0 {
return "0"
}
n := uint(num)
hex := make([]byte, 0)
for {
var r uint
n, r = bits.Div(0, n, 16)
if r >= 0 && r <= 9 {
hex = append(hex, 48+byte(r))
} else if r >= 10 && r <= 15 {
hex = append(hex, 97+byte(r)-10)
}
if len(hex) == 8 {
break
}
if n == 0 {
break
}
}
j := len(hex) - 1
for i := 0; i < len(hex)/2; i++ {
hex[i], hex[j] = hex[j], hex[i]
j--
}
return string(hex)
}
================================================
FILE: Convert the Temperature/kata.java
================================================
class Solution {
public double[] convertTemperature(double celsius) {
double fahrenheit = (celsius * 9/5) + 32;
double kelvin = celsius + 273.15;
return DoubleStream.of(kelvin, fahrenheit).toArray();
}
}
================================================
FILE: Count Apples and Oranges/q.sql
================================================
SELECT (SUM(b.apple_count)+COALESCE(SUM(c.apple_count), 0)) AS apple_count,
(SUM(b.orange_count)+COALESCE(SUM(c.orange_count), 0)) AS orange_count
FROM Boxes AS b
LEFT JOIN Chests AS c ON b.chest_id = c.chest_id;
================================================
FILE: Count Asterisks/kata.java
================================================
class Solution {
public int countAsterisks(String s) {
var skip = false;
var count = 0;
for (var i = 0; i < s.length(); i++) {
if (s.charAt(i) == '|' && !skip) {
skip = true;
continue;
} else if (s.charAt(i) == '|' && skip) {
skip = false;
continue;
}
if (skip) {
continue;
}
if (s.charAt(i) == '*') {
count++;
}
}
return count;
}
}
================================================
FILE: Count Common Words With One Occurrence/kata.go
================================================
package kata
func countWords(words1 []string, words2 []string) int {
type wordCounter struct {
A, B int
}
counter := make(map[string]wordCounter)
for _, word := range words1 {
wordCounter := counter[word]
wordCounter.A++
counter[word] = wordCounter
}
for _, word := range words2 {
wordCounter := counter[word]
wordCounter.B++
counter[word] = wordCounter
}
var total int
for _, wordCounter := range counter {
if wordCounter.A == 1 && wordCounter.B == 1 {
total++
}
}
return total
}
================================================
FILE: Count Complete Tree Nodes/kata.go
================================================
package kata
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func countNodes(root *TreeNode) int {
if root == nil {
return 0
}
c := new(int)
*c++
count(root, c)
return *c
}
func count(node *TreeNode, c *int) {
if node == nil {
return
}
if node.Left != nil {
*c++
count(node.Left, c)
}
if node.Right != nil {
*c++
count(node.Right, c)
}
}
================================================
FILE: Count Elements With Maximum Frequency/kata.go
================================================
package kata
func maxFrequencyElements(nums []int) int {
var max = 0
var total = 0
frequencies := make(map[int]int, 0)
for _, num := range nums {
frequency := frequencies[num]
frequency++
if frequency > max {
max = frequency
total = 0
}
if frequency == max {
total += max
}
frequencies[num] = frequency
}
return total
}
================================================
FILE: Count Elements With Strictly Smaller and Greater Elements/kata.go
================================================
package Count_Elements_With_Strictly_Smaller_and_Greater_Elements
import "sort"
func countElements(nums []int) int {
if len(nums) < 3 {
return 0
}
sort.Ints(nums)
var k int
var t int
for i := 2; i < len(nums); i++ {
if nums[i-2] < nums[i-1] && nums[i-1] < nums[i] {
k++
} else if nums[i-2] < nums[i-1] && nums[i-1] == nums[i] {
t = 2
} else if nums[i-2] == nums[i-1] && nums[i-1] < nums[i] {
k += t
t = 0
} else if nums[i-2] == nums[i-1] && nums[i-1] == nums[i] {
if t > 0 {
t++
}
}
}
return k
}
================================================
FILE: Count Integers With Even Digit Sum/kata.go
================================================
package Count_Integers_With_Even_Digit_Sum
var mem = map[int]int{}
func countEven(num int) int {
c := 0
i := 1
for i <= num {
e, ok := mem[i]
if !ok {
n := i
var sum int
for {
k := n % 10
sum += k
n = n / 10
if n == 0 {
break
}
}
mem[i] = sum
if sum%2 == 0 {
c++
}
} else {
if e%2 == 0 {
c++
}
}
i++
}
return c
}
================================================
FILE: Count Items Matching a Rule/kata.go
================================================
package kata
func countMatches(items [][]string, ruleKey string, ruleValue string) int {
idx := 0
if ruleKey == "type" {
idx = 0
} else if ruleKey == "color" {
idx = 1
} else if ruleKey == "name" {
idx = 2
}
var count int
for _, item := range items {
if item[idx] == ruleValue {
count++
}
}
return count
}
================================================
FILE: Count Largest Group/kata.java
================================================
class Solution {
public int countLargestGroup(int n) {
HashMap<Integer, Integer> bucket = new HashMap<>();
HashMap<Integer, Integer> count = new HashMap<>();
for (var unmodifiedNum = 1; unmodifiedNum < n+1; unmodifiedNum++) {
var sum = 0;
var num = unmodifiedNum;
if (num <= 9) {
bucket.put(num, num);
count.put(num, 1);
continue;
}
do {
var r = num % 10;
sum =+ r;
num = num / 10;
if (bucket.containsKey(num)) {
count.put(bucket.get(num)+sum, count.getOrDefault(bucket.get(num)+sum, 0) + 1);
break;
}
} while(num != 0);
bucket.put(unmodifiedNum, bucket.get(num)+sum);
}
var max = -1;
var countMax = 0;
for (Map.Entry<Integer, Integer> entry : count.entrySet()) {
if (max == -1 || max < entry.getValue()) {
max = entry.getValue();
}
}
for (Map.Entry<Integer, Integer> entry : count.entrySet()) {
if (max == entry.getValue()) {
countMax++;
}
}
return countMax;
}
}
================================================
FILE: Count Negative Numbers in a Sorted Matrix/kata.rs
================================================
package kata
impl Solution {
pub fn count_negatives(grid: Vec<Vec<i32>>) -> i32 {
let mut counter: i32 = 0;
let bound: i32 = 0;
for vector in grid.iter() {
for num in vector.iter() {
if num < &bound {
counter += 1
}
}
}
return counter
}
}
================================================
FILE: Count Odd Numbers in an Interval Range/kata.go
================================================
package kata
func countOdds(low int, high int) int {
var count int
for ; low < high+1; low++ {
if low%2 == 1 {
count++
}
}
return count
}
================================================
FILE: Count Operations to Obtain Zero/kata.go
================================================
package Count_Operations_to_Obtain_Zero
func countOperations(num1 int, num2 int) int {
if num1 == 0 || num2 == 0 {
return 0
}
var c int
for {
a := num1
num1 = max(num1, num2)
num2 = min(a, num2)
num1 = num1 - num2
c++
if num1 == 0 {
break
}
}
return c
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
func min(a, b int) int {
if a < b {
return a
}
return b
}
================================================
FILE: Count Prefixes of a Given String/kata.go
================================================
package Count_Prefixes_of_a_Given_String
func countPrefixes(words []string, s string) int {
var count int
for _, w := range words {
if len(w) > len(s) {
continue
}
if w == s[:len(w)] {
count++
}
}
return count
}
================================================
FILE: Count Student Number in Departments/q.sql
================================================
SELECT dept_name,
COUNT(s.dept_id) AS student_number
FROM Department AS d
LEFT JOIN Student AS s
ON s.dept_id = d.dept_id
GROUP BY dept_name
ORDER BY student_number DESC,
dept_name ASC;
================================================
FILE: Count Substrings Starting and Ending with Given Character/kata.py
================================================
import math
class Solution(object):
def countSubstrings(self, s, c):
"""
:type s: str
:type c: str
:rtype: int
"""
count = 0
for char in s:
if char == c:
count = count + 1
return count + math.comb(count,2)
================================================
FILE: Count Tested Devices After Test Operations/kata.go
================================================
package kata
func countTestedDevices(batteryPercentages []int) int {
var counter int
for i := 0; i < len(batteryPercentages); i++ {
if (batteryPercentages[i] - counter) == 0 {
continue
} else if (batteryPercentages[i] - counter) > 0 {
counter++
}
}
return counter
}
================================================
FILE: Count Total Number of Colored Cells/kata.go
================================================
package kata
func coloredCells(n int) int64 {
k := int64(n)
return k*k + (k-1)*(k-1)
}
================================================
FILE: Count of Matches in Tournament/kata.go
================================================
package kata
func numberOfMatches(n int) int {
var totalMatches int
for n > 1 {
if n%2 == 0 {
n = n / 2
totalMatches += n
} else {
n = (n - 1) / 2
totalMatches += n
n = n + 1
}
}
return totalMatches
}
================================================
FILE: Count the Digits That Divide a Number/kata.java
================================================
class Solution {
public int countDigits(int num) {
var c = 0;
var oldNum = num;
do {
var r = num % 10;
num = num / 10;
if (oldNum % r == 0) {
c++;
}
} while (num != 0);
return c;
}
}
================================================
FILE: Count the Number of Consistent Strings/kata.go
================================================
package kata
func countConsistentStrings(allowed string, words []string) int {
set := make(map[rune]bool)
for _, char := range allowed {
set[char] = true
}
var count int
for _, word := range words {
ok := true
for _, char := range word {
if !set[char] {
ok = false
break
}
}
if ok {
count++
}
}
return count
}
================================================
FILE: Counter/kata.ts
================================================
function createCounter(n: number): () => number {
return function() {
return n++
}
}
/**
* const counter = createCounter(10)
* counter() // 10
* counter() // 11
* counter() // 12
*/
================================================
FILE: Counter II/kata.ts
================================================
type Counter = {
increment: () => number,
decrement: () => number,
reset: () => number,
}
function createCounter(init: number): Counter {
return new counter(init)
};
class counter implements Counter {
private value: number;
private init: number;
public constructor(init: number) {
this.value = init;
this.init = init;
}
public increment() :number {
this.value++
return this.value
}
public decrement() :number {
this.value--
return this.value
}
public reset() :number {
this.value = this.init
return this.value
}
}
/**
* const counter = createCounter(5)
* counter.increment(); // 6
* counter.reset(); // 5
* counter.decrement(); // 4
*/
================================================
FILE: Counting Bits/kata.go
================================================
package kata
func countBits(n int) []int {
o := make([]int, n+1)
for k := 0; k <= n; k++ {
var num = k
var count int
for num > 0 {
count += num & 1
num >>= 1
}
o[k] = count
}
return o
}
================================================
FILE: Counting Elements/kata.go
================================================
package kata
import "math"
func countElements(arr []int) int {
init := int(math.Inf(-1))
max := init
min := init
set := make(map[int]int)
for i := 0; i < len(arr); i++ {
set[arr[i]] += 1
if max == init || arr[i] > max {
max = arr[i]
}
if min == init || arr[i] < min {
min = arr[i]
}
}
lastElement := min
globalMax := 0
first := true
for i := min + 1; i < max+1; i++ {
c, ok := set[i]
if !ok {
lastElement = lastElement + 1
first = false
continue
}
if lastElement+1 == i {
nextCounter := set[i+1]
if nextCounter > 0 {
globalMax += c
}
if first {
globalMax += set[min]
}
}
first = false
lastElement = lastElement + 1
}
return globalMax
}
================================================
FILE: Counting Words With a Given Prefix/kata.go
================================================
package Counting_Words_With_a_Given_Prefix
func prefixCount(words []string, pref string) int {
var c int
for _, w := range words {
if len(w) >= len(pref) && w[:len(pref)] == pref {
c++
}
}
return c
}
================================================
FILE: Cousins in Binary Tree/kata.go
================================================
package kata
import "container/list"
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
type TreeNodeWrapper struct {
p *TreeNode
n *TreeNode
l int
}
type check struct {
p int
l int
}
func isCousins(node *TreeNode, x int, y int) bool {
if node == nil {
return false
}
queue := list.New()
queue.PushBack(&TreeNodeWrapper{n: node, l: 1})
var xLevel *check
var yLevel *check
nodeWrapper := TreeNodeWrapper{}
for queue.Len() > 0 {
e := queue.Front()
w := e.Value.(*TreeNodeWrapper)
if yLevel != nil && xLevel != nil {
break
}
if w.p != nil && w.n.Val == x {
xLevel = &check{
p: w.p.Val,
l: w.l,
}
}
if w.p != nil && w.n.Val == y {
yLevel = &check{
p: w.p.Val,
l: w.l,
}
}
if w.n.Left != nil {
leftNode := nodeWrapper
leftNode.p = w.n
leftNode.n = w.n.Left
leftNode.l = w.l + 1
queue.PushBack(&leftNode)
}
if w.n.Right != nil {
rightNode := nodeWrapper
rightNode.p = w.n
rightNode.n = w.n.Right
rightNode.l = w.l + 1
queue.PushBack(&rightNode)
}
queue.Remove(e)
}
return yLevel != nil && xLevel != nil && yLevel.l == xLevel.l && yLevel.p != xLevel.p
}
================================================
FILE: Create Hello World Function/kata.ts
================================================
function createHelloWorld() {
return function(...args): string {
return "Hello World"
};
};
/**
* const f = createHelloWorld();
* f(); // "Hello World"
*/
================================================
FILE: Create Target Array in the Given Order/kata.go
================================================
package kata
func createTargetArray(nums []int, index []int) []int {
if len(nums) != len(index) {
panic("index and nums len is unequal")
}
target := make([]int, len(nums))
for i := range target {
target[i] = -1
}
for i := range nums {
if target[index[i]] > -1 {
val := target[index[i]]
target[index[i]] = nums[i]
j := index[i] + 1
for j < len(target) {
jVal := target[j]
target[j] = val
val = jVal
j++
}
continue
} else {
target[index[i]] = nums[i]
}
}
return target
}
================================================
FILE: Create a DataFrame from List/kata.py
================================================
import pandas as pd
def createDataframe(student_data: List[List[int]]) -> pd.DataFrame:
return pd.DataFrame(student_data, columns=['student_id', 'age'])
================================================
FILE: Create a New Column/kata.py
================================================
import pandas as pd
def createBonusColumn(employees: pd.DataFrame) -> pd.DataFrame:
employees["bonus"] = employees["salary"] * 2
return employees
================================================
FILE: Create a Session Bar Chart/q.sql
================================================
WITH cte AS (SELECT
COUNT(CASE WHEN (duration/60) <= 5 THEN session_id END) AS total_1,
COUNT(CASE WHEN (duration/60) <= 10 AND (duration/60) > 5 THEN session_id END) AS total_2,
COUNT(CASE WHEN (duration/60) <= 15 AND (duration/60) > 10 THEN session_id END) AS total_3,
COUNT(CASE WHEN (duration/60) >= 15 THEN session_id END) AS total_4,
"[0-5>" AS bin_1,
"[5-10>" AS bin_2,
"[10-15>"AS bin_3,
"15 or more"AS bin_4
FROM Sessions)
SELECT bin_1 AS bin, total_1 AS total FROM cte
UNION ALL
SELECT bin_2 AS bin, total_2 AS total FROM cte
UNION ALL
SELECT bin_3 AS bin, total_3 AS total FROM cte
UNION ALL
SELECT bin_4 AS bin, total_4 AS total FROM cte
================================================
FILE: Custom Sort String/kata.go
================================================
package kata
import "sort"
func customSortString(S string, T string) string {
order := 1
orders := make(map[rune]int)
for _, char := range S {
orders[char] = order
order++
}
K := []rune(T)
sort.Slice(K, func(i, j int) bool {
return orders[K[i]] < orders[K[j]]
})
return string(K)
}
================================================
FILE: Customer Placing the Largest Number of Orders/q.sql
================================================
SELECT customer_number FROM Orders AS o GROUP BY customer_number ORDER BY COUNT(order_number) DESC LIMIT 1;
================================================
FILE: Customer Who Visited but Did Not Make Any Transactions/q.sql
================================================
SELECT customer_id, COUNT(*) AS count_no_trans FROM Visits WHERE visit_id NOT IN (SELECT visit_id FROM Transactions) GROUP BY customer_id;
================================================
FILE: Customers Who Never Order/kata.sql
================================================
package kata
SELECT c.name as Customers FROM Customers c left join Orders o on o.CustomerId = c.Id WHERE o.Id IS NULL;
================================================
FILE: DI String Match/kata.go
================================================
package kata
func diStringMatch(S string) []int {
n := make([]int, len(S)+1)
j := len(S)
k := 0
for i := 0; i < len(S); i++ {
if S[i] == 'I' {
n[i] = k
k++
} else {
n[i] = j
j--
}
}
if S[len(S)-1] == 'I' {
n[len(n)-1] = j
} else {
n[len(n)-1] = k
}
return n
}
================================================
FILE: Daily Leads and Partners/q.sql
================================================
SELECT date_id, make_name, COUNT(DISTINCT lead_id) AS unique_leads, COUNT(DISTINCT partner_id) AS unique_partners
FROM DailySales
GROUP BY date_id, make_name;
================================================
FILE: Day of the Year/kata.go
================================================
package Day_of_the_Year
import (
"time"
)
func dayOfYear(date string) int {
d, err := time.Parse("2006-01-02", date)
if err != nil {
panic(err)
}
currentYear := d.Year()
sum := d.Day()
for {
d = d.Add(-24 * time.Hour * time.Duration(d.Day()))
if d.Year() != currentYear {
break
}
sum += d.Day()
}
return sum
}
================================================
FILE: Decode XORed Array/kata.go
================================================
package Decode_XORed_Array]
func decode(encoded []int, first int) []int {
decoded := make([]int, len(encoded)+1)
decoded[0] = first
for i, n := range encoded {
i = i+1
inverse := first ^ n
decoded[i] = inverse
first = inverse
}
return decoded
}
================================================
FILE: Decode the Message/kata.go
================================================
package Decode_the_Message
func decodeMessage(key string, message string) string {
decoderTable := map[rune]rune{}
j := rune(97)
for _, char := range key {
if char == 32 {
continue
}
_, ok := decoderTable[char]
if !ok {
decoderTable[char] = j
j++
}
}
decodedMessage := make([]rune, len(message))
for i, char := range message {
if char == 32 {
decodedMessage[i] = char
} else {
decodedMessage[i] = decoderTable[char]
}
}
return string(decodedMessage)
}
================================================
FILE: Decompress Run-Length Encoded List/kata.go
================================================
package kata
func decompressRLElist(nums []int) []int {
values := make([]int, 0, len(nums)/2)
for i := 0; i < len(nums); i = i + 2 {
for j := 0; j < nums[i]; j++ {
values = append(values, nums[i+1])
}
}
return values
}
================================================
FILE: Decrypt String from Alphabet to Integer Mapping/kata.go
================================================
package kata
func freqAlphabets(s string) string {
ts := make([]byte, 0, len(s)/3*2)
for i := len(s) - 1; i >= 0; i-- {
if s[i] == '#' {
i--
k := i
i--
j := i
ts = append(ts, hashDecoder[s[j]][s[k]])
} else {
ts = append(ts, numberDecoder[s[i]])
}
}
k := 0
for i := len(ts) - 1; i >= (len(ts) / 2); i-- {
ts[i], ts[k] = ts[k], ts[i]
k++
}
return string(ts)
}
var numberDecoder map[byte]byte = map[byte]byte{'1': 'a', '2': 'b', '3': 'c', '4': 'd', '5': 'e', '6': 'f', '7': 'g', '8': 'h', '9': 'i'}
var hashDecoder map[byte]map[byte]byte = map[byte]map[byte]byte{
'1': {'0': 'j', '1': 'k', '2': 'l', '3': 'm', '4': 'n', '5': 'o', '6': 'p', '7': 'q', '8': 'r', '9': 's'},
'2': {'0': 't', '1': 'u', '2': 'v', '3': 'w', '4': 'x', '5': 'y', '6': 'z'},
}
================================================
FILE: Deepest Leaves Sum/kata.go
================================================
package kata
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func deepestLeavesSum(root *TreeNode) int {
maxHeight := 0
currentHeight := 0
maxHeight = getHeight(root, maxHeight)
return sum(root, maxHeight, currentHeight)
}
func sum(node *TreeNode, maxHeight int, currentHeight int) int {
currentHeight++
if currentHeight == maxHeight {
return node.Val
}
var s int
if node.Left != nil {
s += sum(node.Left, maxHeight, currentHeight)
}
if node.Right != nil {
s += sum(node.Right, maxHeight, currentHeight)
}
return s
}
func getHeight(node *TreeNode, h int) int {
h++
if node.Left == nil && node.Right == nil {
return h
}
var leftHeight int
if node.Left != nil {
leftHeight = getHeight(node.Left, h)
}
var rightHeight int
if node.Right != nil {
rightHeight = getHeight(node.Right, h)
}
if leftHeight > rightHeight {
return leftHeight
}
return rightHeight
}
================================================
FILE: Defanging an IP Address/kata.go
================================================
package kata
func defangIPaddr(address string) string {
defangAddress := make([]rune, 0, len(address)+6)
for _, char := range address {
if char == '.' {
defangAddress = append(defangAddress, '[', '.', ']')
continue
}
defangAddress = append(defangAddress, char)
}
return string(defangAddress)
}
================================================
FILE: Delete Characters to Make Fancy String/kata.go
================================================
package Delete_Characters_to_Make_Fancy_String
func makeFancyString(s string) string {
c := 1
char := s[0]
b := make([]byte, 0)
b = append(b, s[0])
for i := 1; i < len(s); i++ {
if s[i] == char {
c++
if c > 2 {
continue
}
} else {
c = 1
char = s[i]
}
b = append(b, s[i])
}
return string(b)
}
================================================
FILE: Delete Duplicate Emails/kata.sql
================================================
package kata
DELETE p1 FROM Person p1
INNER JOIN Person p2
WHERE
p1.id > p2.id AND
p1.email = p2.email;
================================================
FILE: Delete Greatest Value in Each Row/kata.go
================================================
package kata
import "sort"
func deleteGreatestValue(grid [][]int) int {
for i := 0; i < len(grid); i++ {
sort.Ints(grid[i])
}
var sum int
for i := 0; i < len(grid[0]); i++ {
var max int
for j := len(grid) - 1; j >= 0; j-- {
if max < grid[j][i] {
max = grid[j][i]
}
}
sum += max
}
return sum
}
================================================
FILE: Delete Leaves With a Given Value/kata.go
================================================
package kata
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func removeLeafNodes(root *TreeNode, target int) *TreeNode {
for {
ok := removeLeafNode(nil, root, target, RootNodeType)
if !ok {
if root.Right == nil && root.Left == nil && root.Val == target {
return nil
}
return root
}
}
}
type NodeType int
const (
RootNodeType NodeType = 0
LeftNodeType NodeType = 1
RightNodeType NodeType = 2
)
func removeLeafNode(parentNode *TreeNode, node *TreeNode, target int, nodeType NodeType) bool {
if node.Right == nil && node.Left == nil && node.Val == target && parentNode != nil {
if nodeType == LeftNodeType {
parentNode.Left = nil
} else {
parentNode.Right = nil
}
return true
}
var left bool
if node.Left != nil {
left = removeLeafNode(node, node.Left, target, LeftNodeType)
}
var right bool
if node.Right != nil {
right = removeLeafNode(node, node.Right, target, RightNodeType)
}
return right == true || left == true
}
================================================
FILE: Delete Node in a Linked List/kata.go
================================================
package Delete_Node_in_a_Linked_List
type ListNode struct {
Val int
Next *ListNode
}
func deleteNode(node *ListNode) {
*node = *node.Next
}
================================================
FILE: Delete the Middle Node of a Linked List/kata.go
================================================
package Delete_the_Middle_Node_of_a_Linked_List
type ListNode struct {
Val int
Next *ListNode
}
func deleteMiddle(head *ListNode) *ListNode {
if head.Next == nil {
return nil
}
c := 0
currentNode := head
for currentNode != nil {
c++
currentNode = currentNode.Next
}
var previousNode *ListNode
currentNode = head
for i := 0; i < c/2; i++ {
previousNode = currentNode
currentNode = currentNode.Next
}
if currentNode.Next == nil {
previousNode.Next = nil
} else {
*currentNode = *currentNode.Next
}
return head
}
================================================
FILE: Design Add and Search Words Data Structure/kata.go
================================================
package Design_Add_and_Search_Words_Data_Structure
type node struct {
word bool
nodes [26]*node
}
type WordDictionary struct {
rootNode *node
}
func Constructor() WordDictionary {
return WordDictionary{
rootNode: &node{nodes: [26]*node{}},
}
}
func (this *WordDictionary) AddWord(word string) {
currentNode := this.rootNode
for i, char := range word {
n := currentNode.nodes[int(char)-97]
if n == nil {
currentNode.nodes[int(char)-97] = &node{nodes: [26]*node{}, word: (len(word) - 1) == i}
n = currentNode.nodes[int(char)-97]
}
currentNode = n
}
}
func (this *WordDictionary) Search(word string) bool {
return searchInNode(this.rootNode, word)
}
func searchInNode(rootNode *node, word string) bool {
currentNode := rootNode
for i, char := range word {
if char == '.' {
for _, n := range currentNode.nodes {
if n == nil {
continue
}
if (len(word)-1) == i && n.word {
return true
}
ok := searchInNode(n, word[i+1:])
if ok {
return true
}
}
return false
} else {
n := currentNode.nodes[int(char)-97]
if n == nil {
break
}
if (len(word)-1) == i && n.word {
return true
}
currentNode = n
}
}
return false
}
================================================
FILE: Design HashMap/kata.go
================================================
package kata
import "container/list"
type HashMapValue struct {
key int
value int
}
type MyHashMap struct {
buckets []*list.List
}
/** Initialize your data structure here. */
func Constructor() MyHashMap {
buckets := make([]*list.List, 500)
for i := range buckets {
buckets[i] = list.New()
}
return MyHashMap{
buckets: buckets,
}
}
func (this *MyHashMap) Put(key int, value int) {
idx := key % 500
for e := this.buckets[idx].Front(); e != nil; e = e.Next() {
if e.Value.(*HashMapValue).key == key {
e.Value.(*HashMapValue).value = value
return
}
}
this.buckets[idx].PushFront(&HashMapValue{key: key, value: value})
}
/** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
func (this *MyHashMap) Get(key int) int {
idx := key % 500
for e := this.buckets[idx].Front(); e != nil; e = e.Next() {
if e.Value.(*HashMapValue).key == key {
return e.Value.(*HashMapValue).value
}
}
return -1
}
/** Removes the mapping of the specified value key if this map contains a mapping for the key */
func (this *MyHashMap) Remove(key int) {
idx := key % 500
for e := this.buckets[idx].Front(); e != nil; e = e.Next() {
if e.Value.(*HashMapValue).key == key {
this.buckets[idx].Remove(e)
}
}
}
/**
* Your MyHashMap object will be instantiated and called as such:
* obj := Constructor();
* obj.Put(key,value);
* param_2 := obj.Get(key);
* obj.Remove(key);
*/
================================================
FILE: Design HashSet/kata.go
================================================
package kata
import (
"container/list"
)
type MyHashSet struct {
buckets []*list.List
}
/** Initialize your data structure here. */
func Constructor() MyHashSet {
buckets := make([]*list.List, 500)
for i := range buckets {
buckets[i] = list.New()
}
return MyHashSet{
buckets: buckets,
}
}
func (this *MyHashSet) Add(key int) {
idx := key % 500
for e := this.buckets[idx].Front(); e != nil; e = e.Next() {
if e.Value.(int) == key {
return
}
}
this.buckets[idx].PushFront(key)
}
func (this *MyHashSet) Remove(key int) {
idx := key % 500
for e := this.buckets[idx].Front(); e != nil; e = e.Next() {
if e.Value.(int) == key {
this.buckets[idx].Remove(e)
}
}
}
/** Returns true if this set contains the specified element */
func (this *MyHashSet) Contains(key int) bool {
idx := key % 500
for e := this.buckets[idx].Front(); e != nil; e = e.Next() {
if e.Value.(int) == key {
return true
}
}
return false
}
/**
* Your MyHashSet object will be instantiated and called as such:
* obj := Constructor();
* obj.Add(key);
* obj.Remove(key);
* param_3 := obj.Contains(key);
*/
================================================
FILE: Design Linked List/kata_test.go
================================================
package Design_Linked_List
type Node struct {
val int
next *Node
}
type MyLinkedList struct {
rootNode *Node
lenght int
}
func Constructor() MyLinkedList {
return MyLinkedList{}
}
func (this *MyLinkedList) Get(index int) int {
if index < 0 || index > this.lenght {
return -1
}
var i int
currentNode := this.rootNode
for currentNode != nil {
if index == i {
return currentNode.val
}
currentNode = currentNode.next
i++
}
return -1
}
func (this *MyLinkedList) AddAtHead(val int) {
this.lenght++
nextNode := this.rootNode
this.rootNode = &Node{
val: val,
next: nextNode,
}
}
func (this *MyLinkedList) AddAtTail(val int) {
if this.rootNode == nil {
this.AddAtHead(val)
return
}
currentNode := this.rootNode
for currentNode != nil {
if currentNode.next != nil {
currentNode = currentNode.next
continue
} else {
break
}
}
currentNode.next = &Node{val: val}
this.lenght++
}
func (this *MyLinkedList) AddAtIndex(index int, val int) {
if index == 0 {
this.AddAtHead(val)
return
}
if this.rootNode == nil {
return
}
currentNode := this.rootNode
var i int
for currentNode != nil {
if index-1 == i {
break
} else if currentNode.next != nil {
currentNode = currentNode.next
i++
continue
} else {
break
}
}
nextNode := currentNode.next
currentNode.next = &Node{
val: val,
next: nextNode,
}
this.lenght++
}
func (this *MyLinkedList) DeleteAtIndex(index int) {
if index < 0 || index > this.lenght {
return
}
if this.lenght == 0 {
return
}
if index == 0 {
this.rootNode = this.rootNode.next
this.lenght--
return
}
currentNode := this.rootNode
var i int
for currentNode != nil {
if currentNode.next != nil {
previousNode := currentNode
i++
if i == index {
previousNode.next = currentNode.next.next
break
}
currentNode = currentNode.next
continue
} else {
break
}
}
this.lenght--
return
}
/**
* Your MyLinkedList object will be instantiated and called as such:
* obj := Constructor();
* param_1 := obj.Get(index);
* obj.AddAtHead(val);
* obj.AddAtTail(val);
* obj.AddAtIndex(index,val);
* obj.DeleteAtIndex(index);
*/
================================================
FILE: Design Parking System/kata.go
================================================
package kata
type ParkingSystem struct {
big, medium, small int
}
func Constructor(big int, medium int, small int) ParkingSystem {
return ParkingSystem{
big: big,
medium: medium,
small: small,
}
}
const (
_ = iota
CarTypeBig
CarTypeMedium
CarTypeSmall
)
func (ps *ParkingSystem) AddCar(carType int) bool {
var found bool
if carType == CarTypeSmall {
if ps.small > 0 {
found = true
ps.small--
}
} else if carType == CarTypeMedium {
if ps.medium > 0 {
found = true
ps.medium--
}
} else if carType == CarTypeBig {
if ps.big > 0 {
found = true
ps.big--
}
}
return found
}
/**
* Your ParkingSystem object will be instantiated and called as such:
* obj := Constructor(big, medium, small);
* param_1 := obj.AddCar(carType);
*/
================================================
FILE: Design a Stack With Increment Operation/kata.go
================================================
package kata
type CustomStack struct {
elements []int
maxSize int
}
func Constructor(maxSize int) CustomStack {
return CustomStack{
elements: make([]int, 0),
maxSize: maxSize,
}
}
func (this *CustomStack) Push(x int) {
if len(this.elements) >= this.maxSize {
return
}
this.elements = append(this.elements, x)
}
func (this *CustomStack) Pop() int {
if len(this.elements) == 0 {
return -1
}
x := this.elements[len(this.elements)-1]
this.elements = this.elements[:len(this.elements)-1]
return x
}
func (this *CustomStack) Increment(k int, val int) {
if k >= len(this.elements) {
k = len(this.elements)
}
for i := 0; i < k; i++ {
this.elements[i] += val
}
}
/**
* Your CustomStack object will be instantiated and called as such:
* obj := Constructor(maxSize);
* obj.Push(x);
* param_2 := obj.Pop();
* obj.Increment(k,val);
*/
================================================
FILE: Design an Ordered Stream/kata.go
================================================
package Design_an_Ordered_Stream
type OrderedStream struct {
values []*string
currentIndex int
}
func Constructor(n int) OrderedStream {
return OrderedStream{values: make([]*string, n)}
}
func (this *OrderedStream) Insert(idKey int, value string) []string {
if this.values[idKey-1] == nil {
this.values[idKey-1] = new(string)
*this.values[idKey-1] = value
} else {
*this.values[idKey-1] = value
}
rightValues := make([]string, 0)
for this.currentIndex < len(this.values) {
if this.values[this.currentIndex] == nil {
break
}
rightValues = append(rightValues, *this.values[this.currentIndex])
this.currentIndex++
}
return rightValues
}
================================================
FILE: Destination City/kata.go
================================================
package kata
func destCity(paths [][]string) string {
start := make(map[string]bool)
for _, v := range paths {
start[v[0]] = true
}
var lastV string
for _, v := range paths {
if !start[v[1]] {
lastV = v[1]
break
}
}
return lastV
}
================================================
FILE: Detect Capital/kata.go
================================================
package kata
func detectCapitalUse(word string) bool {
var capitals int
var lowers int
for i := 0; i < len(word); i++ {
if word[i] >= 65 && word[i] <= 90 {
capitals++
if capitals == 2 && lowers >= 1 {
break
}
} else {
lowers++
}
}
if capitals == 0 || capitals == len(word) || (capitals == 1 && (word[0] >= 65 && word[0] <= 90)) {
return true
}
return false
}
================================================
FILE: Determine Color of a Chessboard Square/kata.go
================================================
package kata
func squareIsWhite(coordinates string) bool {
a := int(coordinates[0]) - 96
b := int(coordinates[1]) - 48
if a%2 == 1 {
if b%2 == 0 {
return true
} else {
return false
}
} else {
if b%2 == 0 {
return false
} else {
return true
}
}
}
================================================
FILE: Determine if String Halves Are Alike/kata.go
================================================
package kata
func halvesAreAlike(s string) bool {
aCount := count(s[len(s)/2:])
bCount := count(s[:len(s)/2])
if aCount != bCount {
return false
}
return true
}
func count(a string) int {
aCount := 0
for i := 0; i < len(a); i++ {
switch a[i] {
case 'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u':
aCount += 1
}
}
return aCount
}
================================================
FILE: Determine if Two Events Have Conflict/kata.java
================================================
import java.time.LocalTime;
class Solution {
public boolean haveConflict(String[] event1, String[] event2) {
var eventAStart = LocalTime.parse(event1[0]);
var eventAEnd = LocalTime.parse(event1[1]);
var eventBStart = LocalTime.parse(event2[0]);
var eventBEnd = LocalTime.parse(event2[1]);
return eventAEnd.equals(eventBStart)
|| (eventAStart.equals(eventBEnd))
|| (eventBStart.isAfter(eventAStart) && eventBStart.isBefore(eventAEnd))
|| (eventBEnd.isAfter(eventAStart) && eventBEnd.isBefore(eventAEnd))
|| (eventAStart.isAfter(eventBStart) && eventAStart.isBefore(eventBEnd))
|| (eventAEnd.isAfter(eventBStart) && eventAEnd.isBefore(eventBEnd));
}
}
================================================
FILE: Diet Plan Performance/kata.java
================================================
class Solution {
public int dietPlanPerformance(int[] calories, int k, int lower, int upper) {
var gained = 0;
var lost = 0;
var partialSum = 0;
var count = 0;
for (var i = 0; i < calories.length; i++) {
partialSum += calories[i];
count++;
if (count == k) {
if (partialSum < lower) {
lost++;
} else if (partialSum > upper) {
gained++;
}
partialSum = partialSum - calories[i-k+1];
count--;
}
}
return gained-lost;
}
}
================================================
FILE: Difference Between Element Sum and Digit Sum of an Array/kata.java
================================================
class Solution {
public int differenceOfSum(int[] nums) {
var elementSum = 0;
var digitSum = 0;
for (var num : nums) {
elementSum += num;
while (num != 0) {
var digit = num % 10;
num = num / 10;
digitSum += digit;
}
}
return (int) Math.abs((double) elementSum-digitSum);
}
}
================================================
FILE: Display the First Three Rows/kata.py
================================================
import pandas as pd
def selectFirstRows(employees: pd.DataFrame) -> pd.DataFrame:
return employees.iloc[:3]
================================================
FILE: Distinct Numbers in Each Subarray/kata.java
================================================
class Solution {
public int[] distinctNumbers(int[] nums, int k) {
var ans = new int[nums.length-k+1];
var count = 0;
var j = 0;
Map<Integer, Integer> unique = new HashMap<>();
for (var i = 0; i < nums.length; i++) {
unique.put(nums[i], unique.getOrDefault(nums[i], 0)+1);
count++;
if (count == k) {
ans[j] = unique.size();
var n = nums[i-(k-1)];
var c = unique.get(n);
if (c > 1) {
c--;
unique.put(n, c);
} else if (c == 1) {
unique.remove(n);
}
count--;
j++;
}
}
return ans;
}
}
================================================
FILE: Distribute Candies to People/kata.go
================================================
package kata
func distributeCandies(candies int, num_people int) []int {
people := make([]int, num_people)
cd := 1
var i int
for candies > 0 {
if i == len(people) {
i = 0
}
if candies <= cd {
cd = candies
}
people[i] += cd
candies = candies - cd
cd++
i++
}
return people
}
================================================
FILE: Distribute Elements Into Two Arrays I/kata.go
================================================
package kata
func resultArray(nums []int) []int {
var a, b = make([]int, 0), make([]int, 0)
a = append(a, nums[0])
b = append(b, nums[1])
for i := 2; i < len(nums); i++ {
if a[len(a)-1] > b[len(b)-1] {
a = append(a, nums[i])
} else {
b = append(b, nums[i])
}
}
for _, ib := range b {
a = append(a, ib)
}
return a
}
================================================
FILE: Divide Array Into Equal Pairs/kata.go
================================================
package Divide_Array_Into_Equal_Pairs
import "sort"
func divideArray(nums []int) bool {
sort.Ints(nums)
for i := 1; i < len(nums); i = i + 2 {
if nums[i] != nums[i-1] {
return false
}
}
return true
}
================================================
FILE: Divide a String Into Groups of Size k/kata.go
================================================
package Divide_a_String_Into_Groups_of_Size_k
func divideString(s string, k int, fill byte) []string {
res := make([]string, 0)
if k > len(s) {
m := len(s)
for l := 0; l < k-m; l++ {
s += string(fill)
}
res = append(res, s)
return res
}
j := 0
i := k
for i <= len(s) {
res = append(res, s[j:i])
j = i
i = i + k
if i > len(s) && len(s[j:]) > 0 {
b := make([]byte, 0)
b = append(b, s[j:]...)
m := len(b)
for l := 0; l < k-m; l++ {
b = append(b, fill)
}
res = append(res, string(b))
break
}
}
return res
}
================================================
FILE: Divisible and Non-divisible Sums Difference/kata.go
================================================
package main
func differenceOfSums(n int, m int) int {
var sumDivisible, sumNotDivisible = 0, 0
for num := 1; num <= n; num++ {
if num%m == 0 {
sumDivisible += num
}
if num%m != 0 {
sumNotDivisible += num
}
}
return sumNotDivisible - sumDivisible
}
================================================
FILE: Dot Product of Two Sparse Vectors/kata.go
================================================
package Dot_Product_of_Two_Sparse_Vectors
type SparseVector struct {
Values map[int]int
}
func Constructor(nums []int) SparseVector {
v := make(map[int]int)
for i, n := range nums {
v[i] = n
}
return SparseVector{
Values: v,
}
}
// Return the dotProduct of two sparse vectors
func (this *SparseVector) dotProduct(vec SparseVector) int {
var sum int
for i, num := range vec.Values {
sum += this.Values[i] * num
}
return sum
}
/**
* Your SparseVector object will be instantiated and called as such:
* v1 := Constructor(nums1);
* v2 := Constructor(nums2);
* ans := v1.dotProduct(v2);
*/
================================================
FILE: Drop Duplicate Rows/kata.py
================================================
import pandas as pd
def dropDuplicateEmails(customers: pd.DataFrame) -> pd.DataFrame:
customers = customers.drop_duplicates(subset=['email'])
return customers
================================================
FILE: Drop Missing Data/kata.py
================================================
import pandas as pd
def dropMissingData(students: pd.DataFrame) -> pd.DataFrame:
students = students.dropna(subset=['name'])
return students
================================================
FILE: Duplicate Emails/kata.sql
================================================
package kata
SELECT DISTINCT(email) FROM Person GROUP BY email HAVING count(email) > 1
================================================
FILE: Duplicate Zeros/kata.go
================================================
package kata
func duplicateZeros(arr []int) {
for i := 0; i < len(arr); i++ {
if arr[i] == 0 {
k := 0
for j := i + 1; j < len(arr); j++ {
l := arr[j]
arr[j] = k
k = l
}
i++
}
}
}
================================================
FILE: Element Appearing More Than 25% In Sorted Array/kata.go
================================================
package kata
func findSpecialInteger(arr []int) int {
counter := make(map[int]int)
fragment := float64(len(arr)) / 100 * 25
for _, n := range arr {
counter[n]++
}
var match int
max := -1
for number, count := range counter {
if float64(count) >= fragment && (max == -1 || max < count) {
match = number
max = count
}
}
return match
}
================================================
FILE: Employee Bonus/q.sql
================================================
SELECT e.name, b.bonus
FROM Employee AS e LEFT JOIN Bonus AS b ON e.empId = b.empId WHERE b.bonus < 1000 OR b.bonus IS NULL;
================================================
FILE: Employee Importance/kata.py
================================================
package kata
"""
# Employee info
class Employee:
def __init__(self, id: int, importance: int, subordinates: List[int]):
# It's the unique id of each node.
# unique id of this employee
self.id = id
# the importance value of this employee
self.importance = importance
# the id of direct subordinates
self.subordinates = subordinates
"""
class Solution:
def getImportance(self, employees: List['Employee'], id: int) -> int:
employeesResolver = {}
for employee in employees:
employeesResolver[employee.id] = employee
employee = employeesResolver[id]
return self.getSubImportance(employeesResolver, employee)
def getSubImportance(self, employees, employee) -> int:
sum = employee.importance
for subEmployeeID in employee.subordinates:
sum = sum + employees[subEmployeeID].importance
if employees[subEmployeeID].subordinates:
for subSubEmployeeID in employees[subEmployeeID].subordinates:
sum = sum + self.getSubImportance(employees, employees[subSubEmployeeID])
return sum
================================================
FILE: Employees Earning More Than Their Managers/kata.sql
================================================
package kata
select Name as Employee from Employee as e where Salary > (select Salary from Employee as ie where ie.Id = e.ManagerId)
================================================
FILE: Employees With Missing Information/q.sql
================================================
(SELECT e.employee_id
FROM Employees AS e
LEFT JOIN Salaries AS s ON s.employee_id=e.employee_id
WHERE salary IS NULL)
UNION
(SELECT s.employee_id
FROM Salaries AS s
LEFT JOIN Employees AS e ON s.employee_id=e.employee_id
WHERE name IS NULL)
ORDER BY employee_id
================================================
FILE: Encode and Decode TinyURL/kata.go
================================================
package kata
import (
"math/rand"
"time"
)
type Codec struct {
urlContainer map[string]string
}
func Constructor() Codec {
return Codec{
urlContainer: make(map[string]string),
}
}
// Encodes a URL to a shortened URL.
func (c *Codec) encode(longURL string) string {
v := genID(5)
url := "http://tinyurl.com/" + v
c.urlContainer[url] = longURL
return url
}
// Decodes a shortened URL to its original URL.
func (c *Codec) decode(shortUrl string) string {
return c.urlContainer[shortUrl]
}
const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
var seededRand *rand.Rand = rand.New(
rand.NewSource(time.Now().UnixNano()))
func genID(length int) string {
b := make([]byte, length)
for i := range b {
b[i] = charset[seededRand.Intn(len(charset))]
}
return string(b)
}
================================================
FILE: Equal Row and Column Pairs/kata.go
================================================
package kata
import (
"crypto/md5"
"encoding/hex"
"strconv"
)
func equalPairs(grid [][]int) int {
type pair struct {
A, B int
}
matcher := make(map[string]pair)
for i := 0; i < len(grid); i++ {
k := make([]byte, 0)
for j := 0; j < len(grid[i]); j++ {
k = append(k, []byte(strconv.Itoa(grid[i][j]))...)
k = append(k, byte(','))
}
h := md5.Sum(k)
hs := hex.EncodeToString(h[:])
a := matcher[hs]
a.A++
matcher[hs] = a
}
var c int
for i := 0; i < len(grid[0]); i++ {
k := make([]byte, 0)
for j := 0; j < len(grid); j++ {
k = append(k, []byte(strconv.Itoa(grid[j][i]))...)
k = append(k, byte(','))
}
h := md5.Sum(k)
hs := hex.EncodeToString(h[:])
b := matcher[hs]
b.B++
matcher[hs] = b
}
for _, pair := range matcher {
c += pair.A * pair.B
}
return c
}
================================================
FILE: Evaluate Boolean Binary Tree/kata.go
================================================
package kata
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func evaluateTree(root *TreeNode) bool {
if root.Left == nil && root.Right == nil {
if root.Val == 1 {
return true
} else {
return false
}
}
var b bool
if root.Left != nil {
b = evaluateTree(root.Left)
}
var a bool
if root.Right != nil {
a = evaluateTree(root.Right)
}
if root.Val == 2 {
return a || b
}
return a && b
}
================================================
FILE: Evaluate Boolean Expression/q.sql
================================================
SELECT
left_operand,
operator,
right_operand,
(CASE
WHEN operator = ">" AND v1.value > v2.value THEN "true"
WHEN operator = ">" AND v1.value <= v2.value THEN "false"
WHEN operator = "=" AND v1.value = v2.value THEN "true"
WHEN operator = "=" AND v1.value != v2.value THEN "false"
WHEN operator = "<" AND v1.value < v2.value THEN "true"
WHEN operator = "<" AND v1.value >= v2.value THEN "false"
END) AS value
FROM Expressions AS e
INNER JOIN Variables AS v1 ON v1.name = e.left_operand
INNER JOIN Variables AS v2 ON v2.name = e.right_operand;
================================================
FILE: Evaluate Reverse Polish Notation/kata.go
================================================
package kata
import "container/list"
func evalRPN(tokens []string) int {
nodes := Parse(tokens)
return Eval(nodes)
}
const (
NumberKind = iota
PlusKind
MinusKind
MultiplyKind
DvisionKind
)
type Node struct {
Kind int
Value int
}
const (
Multiply byte = 42
Dvision byte = 47
Plus byte = 43
Minus byte = 45
)
func Parse(tokens []string) *list.List {
nodes := list.New()
for i := 0; i < len(tokens); i++ {
if len(tokens[i]) == 1 && tokens[i][0] == Minus {
nodes.PushFront(Node{Kind: MinusKind})
} else if len(tokens[i]) == 1 && tokens[i][0] == Multiply {
nodes.PushFront(Node{Kind: MultiplyKind})
} else if len(tokens[i]) == 1 && tokens[i][0] == Plus {
nodes.PushFront(Node{Kind: PlusKind})
} else if len(tokens[i]) == 1 && tokens[i][0] == Dvision {
nodes.PushFront(Node{Kind: DvisionKind})
} else if len(tokens[i]) == 1 && tokens[i][0] >= 48 && tokens[i][0] <= 57 {
n := Node{Kind: NumberKind}
var sum int
sum = int(tokens[i][0]) - 48
n.Value = sum
nodes.PushFront(n)
} else if len(tokens[i]) == 2 && tokens[i][0] == Minus {
n := Node{Kind: NumberKind}
var sum int
sum = int(tokens[i][1]) - 48
n.Value = sum * -1
nodes.PushFront(n)
} else if len(tokens[i]) > 1 && tokens[i][0] >= 48 && tokens[i][0] <= 57 {
n := Node{Kind: NumberKind}
var sum int
j := len(tokens[i]) - 1
norm := 1
for j >= 0 {
if tokens[i][j] >= 48 && tokens[i][j] <= 57 {
sum += (int(tokens[i][j]) - 48) * norm
j--
norm = norm * 10
}
}
n.Value = sum
nodes.PushFront(n)
} else if len(tokens[i]) > 2 && tokens[i][0] == Minus {
n := Node{Kind: NumberKind}
var sum int
j := len(tokens[i]) - 1
norm := 1
for j >= 1 {
if tokens[i][j] >= 48 && tokens[i][j] <= 57 {
sum += (int(tokens[i][j]) - 48) * norm
j--
norm = norm * 10
}
}
n.Value = sum * -1
nodes.PushFront(n)
}
}
return nodes
}
func Eval(nodes *list.List) int {
if nodes.Len() == 0 {
return 0
}
for nodes.Len() != 1 {
doEval(nodes)
}
value := nodes.Back()
sum := value.Value.(Node).Value
return sum
}
func doEval(nodes *list.List) {
for e := nodes.Back(); e != nil; e = e.Prev() {
node := e.Value.(Node)
if node.Kind == MultiplyKind {
eA := e.Next()
nodeA := eA.Value.(Node)
eb := eA.Next()
nodeB := eb.Value.(Node)
sum := nodeB.Value * nodeA.Value
nodes.Remove(eb)
nodes.Remove(eA)
nodes.InsertBefore(Node{Kind: NumberKind, Value: sum}, e)
nodes.Remove(e)
return
} else if node.Kind == DvisionKind {
eA := e.Next()
nodeA := eA.Value.(Node)
eB := eA.Next()
nodeB := eB.Value.(Node)
sum := nodeB.Value / nodeA.Value
nodes.Remove(eB)
nodes.Remove(eA)
nodes.InsertBefore(Node{Kind: NumberKind, Value: sum}, e)
nodes.Remove(e)
return
} else if node.Kind == PlusKind {
eA := e.Next()
nodeA := eA.Value.(Node)
eb := eA.Next()
nodeB := eb.Value.(Node)
sum := nodeB.Value + nodeA.Value
nodes.Remove(eb)
nodes.Remove(eA)
nodes.InsertBefore(Node{Kind: NumberKind, Value: sum}, e)
nodes.Remove(e)
return
} else if node.Kind == MinusKind {
eA := e.Next()
nodeA := eA.Value.(Node)
eb := eA.Next()
nodeB := eb.Value.(Node)
sum := nodeB.Value - nodeA.Value
nodes.Remove(eb)
nodes.Remove(eA)
nodes.InsertBefore(Node{Kind: NumberKind, Value: sum}, e)
nodes.Remove(e)
return
}
}
}
================================================
FILE: Factorial Trailing Zeroes/kata.go
================================================
package Factorial_Trailing_Zeroes
import "math/big"
func trailingZeroes(n int) int {
s := factorial(big.NewInt(int64(n)))
var c int
b := s.String()
for i := len(b) - 1; i > 0; i-- {
if b[i] == '0' {
c++
} else {
break
}
}
return c
}
func init() {
factorialResults = make(map[string]*big.Int)
}
var factorialResults map[string]*big.Int
func factorial(n *big.Int) *big.Int {
if _, ok := factorialResults[n.String()]; ok {
return factorialResults[n.String()]
}
if n.Cmp(big.NewInt(0)) > 0 {
y := big.NewInt(0).Mul(n, factorial(big.NewInt(0).Sub(n, big.NewInt(1))))
factorialResults[n.String()] = y
return y
}
return big.NewInt(1)
}
================================================
FILE: Fibonacci Number/kata.go
================================================
package kata
func fib(N int) int {
if N == 0 {
return 0
}
if N == 1 {
return 1
}
return fib(N-1) + fib(N-2)
}
================================================
FILE: Fill Missing Data/kata.py
================================================
import pandas as pd
def fillMissingValues(products: pd.DataFrame) -> pd.DataFrame:
products['quantity'] = products['quantity'].fillna(0)
return products
================================================
FILE: Filter Elements from Array/kata.ts
================================================
type Fn = (n: number, i: number) => any
function filter(arr: number[], fn: Fn): number[] {
let i = -1;
return arr.filter(number => {
i++
return fn(number, i)
})
};
================================================
FILE: Filter Restaurants by Vegan-Friendly, Price and Distance/kata.go
================================================
package kata
import "sort"
const (
idIndex int = 0
ratingIndex int = 1
veganFriendlyIndex int = 2
priceIndex int = 3
distanceIndex int = 4
)
func filterRestaurants(restaurants [][]int, veganFriendly int, maxPrice int, maxDistance int) []int {
matchedRestaurant := make([][]int, 0)
for i := range restaurants {
if veganFriendly != 0 {
if restaurants[i][veganFriendlyIndex] != veganFriendly {
continue
}
}
if maxPrice < restaurants[i][priceIndex] {
continue
}
if maxDistance < restaurants[i][distanceIndex] {
continue
}
matchedRestaurant = append(matchedRestaurant, restaurants[i])
}
sort.Slice(matchedRestaurant, func(i, j int) bool {
if matchedRestaurant[i][ratingIndex] == matchedRestaurant[j][ratingIndex] {
return matchedRestaurant[i][idIndex] > matchedRestaurant[j][idIndex]
}
return matchedRestaurant[i][ratingIndex] > matchedRestaurant[j][ratingIndex]
})
ids := make([]int, len(matchedRestaurant))
for i, restaurant := range matchedRestaurant {
ids[i] = restaurant[idIndex]
}
return ids
}
================================================
FILE: Final Prices With a Special Discount in a Shop/kata.go
================================================
package kata
func finalPrices(prices []int) []int {
var i int
for j := 1; j < len(prices); j++ {
if prices[j] <= prices[i] {
prices[i] = prices[i] - prices[j]
i++
j = i
} else if j == len(prices)-1 && j-i != 1 {
i++
j = i
}
}
return prices
}
================================================
FILE: Final Value of Variable After Performing Operations/kata.go
================================================
package kata
func finalValueAfterOperations(operations []string) int {
x := 0
for _, operation := range operations {
if len(operation) != 3 {
panic("operation invalid")
}
if operation[0] == '-' {
if operation[1] == '-' {
if operation[2] == 'X' {
x = x - 1
continue
} else {
panic("operation invalid")
}
} else {
panic("operation invalid")
}
}
if operation[0] == '+' {
if operation[1] == '+' {
if operation[2] == 'X' {
x = x + 1
continue
} else {
panic("operation invalid")
}
} else {
panic("operation invalid")
}
}
if operation[0] == 'X' {
if operation[1] == '+' {
if operation[2] == '+' {
x = x + 1
continue
} else {
panic("operation invalid")
}
} else if operation[1] == '-' {
if operation[2] == '-' {
x = x - 1
continue
} else {
panic("operation invalid")
}
} else {
panic("operation invalid")
}
} else {
panic("operation invalid")
}
}
return x
}
================================================
FILE: Find All Duplicates in an Array/kata.go
================================================
package kata
import "sort"
func findDuplicates(nums []int) []int {
sort.Slice(nums, func(i, j int) bool {
return nums[i] < nums[j]
})
var j int
for i := 1; i < len(nums); i++ {
if nums[i] == nums[i-1] {
nums[j] = nums[i]
i++
j++
continue
}
}
return nums[:j]
}
================================================
FILE: Find All Lonely Numbers in the Array/kata.go
================================================
package kata
import "sort"
func findLonely(nums []int) []int {
sort.Ints(nums)
var res []int
for i := 1; i < len(nums); i++ {
if check(nums, i) {
continue
}
res = append(res, nums[i])
}
if !check(nums, 0) {
res = append(res, nums[0])
}
return res
}
func check(nums []int, i int) bool {
if (i > 0 && nums[i-1] == nums[i]-1) || (i+1 < len(nums) && nums[i+1] == nums[i]+1) || (i > 0 && nums[i-1] == nums[i]) || (i+1 < len(nums) && nums[i+1] == nums[i]) {
return true
}
return false
}
================================================
FILE: Find All Numbers Disappeared in an Array/kata.go
================================================
package kata
func findDisappearedNumbers(nums []int) []int {
b := make([]int, len(nums)+1)
for i := 0; i < len(nums); i++ {
b[nums[i]] = 1
}
c := make([]int, 0)
for i := 0; i < len(b); i++ {
if b[i] == 0 {
c = append(c, i)
}
}
return c[1:]
}
================================================
FILE: Find All The Lonely Nodes/kata.java
================================================
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<Integer> getLonelyNodes(TreeNode root) {
var nodes = new ArrayList<Integer>();
if (root == null) {
return nodes;
}
countNodes(nodes, root.left, root.right);
return nodes;
}
private void countNodes(ArrayList<Integer> nodes, TreeNode leftNode, TreeNode rightNode) {
if (leftNode == null && rightNode == null) {
return;
} else if (leftNode == null && rightNode != null) {
nodes.add(rightNode.val);
} else if (leftNode != null && rightNode == null) {
nodes.add(leftNode.val);
}
if (leftNode != null) countNodes(nodes, leftNode.left, leftNode.right);
if (rightNode != null) countNodes(nodes, rightNode.left, rightNode.right);
return;
}
}
================================================
FILE: Find Anagram Mappings/kata.go
================================================
package kata
func anagramMappings(nums1 []int, nums2 []int) []int {
indexLocation := make(map[int]int)
for i, n := range nums2 {
indexLocation[n] = i
}
mapping := make([]int, len(nums1))
for i, n := range nums1 {
mapping[i] = indexLocation[n]
}
return mapping
}
================================================
FILE: Find Bottom Left Tree Value/kata.go
================================================
package kata
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
type leftLeaf struct {
val int
level int
kind int
}
func findBottomLeftValue(root *TreeNode) int {
leafs := make([]leftLeaf, 0)
findNodes(root, 0, &leafs, 1)
max := -1
val := 0
for i := 0; i < len(leafs); i++ {
if max < leafs[i].level && leafs[i].kind == 1 {
max = leafs[i].level
val = leafs[i].val
} else if max < leafs[i].level && leafs[i].kind == 2 {
max = leafs[i].level
val = leafs[i].val
}
}
return val
}
func findNodes(node *TreeNode, level int, leafs *[]leftLeaf, kind int) {
if node == nil {
return
}
if node.Left == nil && node.Right == nil {
*leafs = append(*leafs, leftLeaf{val: node.Val, kind: kind, level: level})
return
}
level = level + 1
if node.Left != nil {
findNodes(node.Left, level, leafs, 1)
}
if node.Right != nil {
findNodes(node.Right, level, leafs, 2)
}
}
================================================
FILE: Find Center of Star Graph/kata.go
================================================
package kata
func findCenter(edges [][]int) int {
edgesCounter := make(map[int]int)
for _, nodePair := range edges {
edgesCounter[nodePair[0]]++
edgesCounter[nodePair[1]]++
if edgesCounter[nodePair[1]] == len(edges) {
return nodePair[1]
}
if edgesCounter[nodePair[0]] == len(edges) {
return nodePair[0]
}
}
return -1
}
================================================
FILE: Find Closest Number to Zero/kata.go
================================================
package Find_Closest_Number_to_Zero
import (
"math"
"sort"
)
func findClosestNumber(nums []int) int {
sort.Ints(nums)
min := math.MaxInt64
value := 0
for _, n := range nums {
nn := int(math.Abs(float64(n)))
if nn <= min {
min = nn
value = n
}
}
return value
}
================================================
FILE: Find Common Characters/kata.go
================================================
package kata
func commonChars(words []string) []string {
chars := []string{}
counter := make([][26]int, len(words))
for w, word := range words {
for i := 0; i < len(word); i++ {
counter[w][word[i]-97]++
}
}
outerLoop:
for j := 0; j < 26; j++ {
min := int(-1)
for i := 0; i < len(words); i++ {
counter := int(counter[i][j])
if counter == 0 {
continue outerLoop
}
if min == -1 || min > counter {
min = counter
}
}
for i := 0; i < min; i++ {
chars = append(chars, string([]byte{byte(j + 97)}))
}
}
return chars
}
================================================
FILE: Find Customer Referee/q.sql
================================================
SELECT name FROM Customer AS c WHERE c.referee_id != 2 OR c.referee_id IS NULL;
================================================
FILE: Find Customers With Positive Revenue this Year/q.sql
================================================
SELECT customer_id FROM Customers AS c WHERE c.year = 2021 GROUP BY customer_id HAVING SUM(c.revenue) > 0 ;
================================================
FILE: Find First Palindromic String in the Array/kata.go
================================================
package kata
func firstPalindrome(words []string) string {
for _, word := range words {
if isPalindrome(word) {
return word
}
}
return ""
}
func isPalindrome(s string) bool {
j := len(s) - 1
for i := 0; i < len(s)/2; i++ {
if s[j] != s[i] {
return false
}
j--
}
return true
}
================================================
FILE: Find First and Last Position of Element in Sorted Array/kata.go
================================================
package kata
func searchRange(nums []int, target int) []int {
idx := make([]int, 2)
idx[0] = -1
idx[1] = -1
first := true
for i, n := range nums {
if n == target {
if first {
idx[0] = i
first = false
} else {
idx[1] = i
}
}
}
if idx[1] == -1 {
idx[1] = idx[0]
}
return idx
}
================================================
FILE: Find Followers Count/q.sql
================================================
SELECT user_id, COUNT(follower_id) AS followers_count FROM Followers GROUP BY user_id ORDER BY user_id ASC;
================================================
FILE: Find Greatest Common Divisor of Array/kata.go
================================================
package Find_Greatest_Common_Divisor_of_Array
import "math"
func findGCD(nums []int) int {
min := int(math.Inf(-1))
max := int(math.Inf(-1))
for _, n := range nums {
if max == int(math.Inf(-1)) || n > max {
max = n
}
if min == int(math.Inf(-1)) || n < min {
min = n
}
}
for gcd := max; gcd > 0; gcd-- {
if min%gcd == 0 && max%gcd == 0 {
return gcd
}
}
return -1
}
================================================
FILE: Find K Closest Elements/kata.go
================================================
package kata
import (
"math"
"sort"
)
type value struct {
v int
d int
}
func findClosestElements(arr []int, k int, x int) []int {
dis := make([]value, len(arr))
for i := 0; i < len(arr); i++ {
elem := value{
v: arr[i],
d: int(math.Abs(float64(arr[i]) - float64(x))),
}
dis[i] = elem
}
sort.Slice(dis, func(i, j int) bool {
if dis[i].d == dis[j].d && dis[i].v < dis[j].v {
return true
} else if dis[i].d < dis[j].d {
return true
}
return false
})
res := make([]int, k)
for i := 0; i < len(dis[:k]); i++ {
res[i] = dis[i].v
}
sort.Slice(res, func(i, j int) bool {
return res[i] < res[j]
})
return res
}
================================================
FILE: Find K-Length Substrings With No Repeated Characters/kata.java
================================================
class Solution {
public int numKLenSubstrNoRepeats(String s, int k) {
if (s.length() < k) {
return 0;
}
var characterCount = 0;
var wordCount = 0;
HashMap<Character, Integer> windowTracker = new HashMap<>();
for (var i = 0; i < s.length(); i++) {
if (windowTracker.containsKey(s.charAt(i))) {
var otherIndex = windowTracker.get(s.charAt(i));
i = otherIndex + 1;
windowTracker.clear();
characterCount = 0;
}
windowTracker.put(s.charAt(i), i);
characterCount++;
if (characterCount == k) {
wordCount++;
windowTracker.remove(s.charAt(i - (k-1)));
characterCount = k-1 ;
}
}
return wordCount;
}
}
================================================
FILE: Find Largest Value in Each Tree Row/kata.go
================================================
package kata
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func largestValues(root *TreeNode) []int {
set := make(map[int]*largest)
findAll(root, set, 0)
a := make([]int, len(set))
var i int
for _, v := range set {
a[v.Level] = v.Val
i++
}
return a
}
type largest struct {
Val int
Level int
}
func findAll(node *TreeNode, set map[int]*largest, l int) {
if node == nil {
return
}
v, ok := set[l]
if ok {
if node.Val >= v.Val {
v.Val = node.Val
set[l] = v
}
} else {
set[l] = &largest{Val: node.Val, Level: l}
}
if node.Left != nil {
findAll(node.Left, set, l+1)
}
if node.Right != nil {
findAll(node.Right, set, l+1)
}
}
================================================
FILE: Find Lucky Integer in an Array/kata.go
================================================
package kata
import "sort"
func findLucky(arr []int) int {
sort.Slice(arr, func(i, j int) bool {
return arr[i] < arr[j]
})
var maxNumber int
lastNumber := arr[0]
count := 1
for i := 1; i < len(arr); i++ {
if arr[i] == lastNumber {
count++
} else {
if count == lastNumber && lastNumber > maxNumber {
maxNumber = lastNumber
}
lastNumber = arr[i]
count = 1
}
}
if count > 1 {
if count == lastNumber && lastNumber > maxNumber {
maxNumber = lastNumber
}
}
if maxNumber == 0 {
return -1
}
return maxNumber
}
================================================
FILE: Find Maximum Number of String Pairs/kata.go
================================================
package kata
func maximumNumberOfStringPairs(words []string) int {
pair := make(map[string]int, 0)
var c int
for i := 0; i < len(words); i++ {
pair[words[i]]++
reversedWord := string(words[i][1]) + string(words[i][0])
if reversedWord == words[i] {
continue
}
pair[reversedWord]++
if pair[reversedWord] == 2 {
pair[reversedWord] = pair[reversedWord] - 2
c++
}
}
return c
}
================================================
FILE: Find Median from Data Stream/kata.go
================================================
package kata
import "sort"
type MedianFinder struct {
list []int
}
/** initialize your data structure here. */
func Constructor() MedianFinder {
return MedianFinder{list: make([]int, 0)}
}
func (this *MedianFinder) AddNum(num int) {
this.list = append(this.list, num)
}
func (this *MedianFinder) FindMedian() float64 {
sort.Slice(this.list, func(i, j int) bool {
return this.list[i] < this.list[j]
})
if len(this.list)%2 == 1 {
return float64(this.list[len(this.list)/2])
}
return (float64(this.list[len(this.list)/2-1]) + float64(this.list[len(this.list)/2])) / 2
}
/**
* Your MedianFinder object will be instantiated and called as such:
* obj := Constructor();
* obj.AddNum(num);
* param_2 := obj.FindMedian();
*/
================================================
FILE: Find Minimum Time to Finish All Jobs II/kata.java
================================================
class Solution {
public int minimumTime(int[] jobs, int[] workers) {
Arrays.sort(jobs);
Arrays.sort(workers);
var minAmount = -1d;
for (var i = workers.length-1; i >= 0; i--) {
var amount = Math.ceil((double) jobs[i] / (double) workers[i]);
if (minAmount == -1 || amount > minAmount) {
minAmount = amount;
}
}
return (int) minAmount;
}
}
================================================
FILE: Find Minimum in Rotated Sorted Array/kata.go
================================================
package kata
func findMin(nums []int) int {
return search(nums, -1)
}
func search(nums []int, min int) int {
if len(nums) == 1 {
return nums[0]
}
if min == -1 {
min = nums[len(nums)/2]
}
r := search(nums[len(nums)/2:], min)
if r < min {
min = r
}
l := search(nums[:len(nums)/2], min)
if l < min {
min = l
}
return min
}
================================================
FILE: Find Minimum in Rotated Sorted Array II/kata.go
================================================
package kata
func findMin(nums []int) int {
if len(nums) == 1 {
return nums[0]
}
mid := len(nums) / 2
min := nums[mid]
leftMin := search(nums[mid:], min)
if leftMin < min {
min = leftMin
}
rightMin := search(nums[:mid], min)
if rightMin < min {
min = rightMin
}
return min
}
func search(nums []int, min int) int {
mid := len(nums) / 2
if nums[mid] < min {
min = nums[mid]
}
if len(nums) == 1 {
return min
}
leftMin := search(nums[mid:], min)
if leftMin < min {
min = leftMin
}
rightMin := search(nums[:mid], min)
if rightMin < min {
min = rightMin
}
return min
}
================================================
FILE: Find Missing and Repeated Values/kata.go
================================================
package kata
func findMissingAndRepeatedValues(grid [][]int) []int {
var gridRowCount = len(grid)
var gridColCount = len(grid[0])
var counter = make([]int, gridRowCount*gridColCount)
for i := 0; i < len(grid); i++ {
for j := 0; j < len(grid[0]); j++ {
counter[grid[i][j] - 1]++
}
}
var missingNumber int
var repeatingNumber int
for i := 0; i < len(counter); i++ {
if counter[i] == 0 {
missingNumber = i+1
} else if counter[i] == 2 {
repeatingNumber = i+1
}
}
return []int{repeatingNumber, missingNumber}
}
================================================
FILE: Find Mode in Binary Search Tree/kata.go
================================================
package kata
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func findMode(root *TreeNode) []int {
c := make(map[int]int)
nums := make([]int, 0)
collectModes(root, c)
max := -1
for _, n := range c {
if max == -1 || n >= max {
max = n
}
}
for num, counter := range c {
if counter == max {
nums = append(nums, num)
}
}
return nums
}
func collectModes(node *TreeNode, c map[int]int) {
if node == nil {
return
}
c[node.Val]++
if node.Left != nil {
collectModes(node.Left, c)
}
if node.Right != nil {
collectModes(node.Right, c)
}
}
================================================
FILE: Find N Unique Integers Sum up to Zero/kata.go
================================================
package kata
func sumZero(n int) []int {
nums := make([]int, 0)
if n%2 == 1 {
nums = append(nums, 0)
n = n - 1
}
for i := 1; i < n; i = i + 2 {
nums = append(nums, i, -i)
}
return nums
}
================================================
FILE: Find Nearest Point That Has the Same X or Y Coordinate/kata.java
================================================
class Solution {
public int nearestValidPoint(int x, int y, int[][] points) {
var index = -1;
var smallestDistance = -1;
var i = 0;
for (var point : points) {
if (point[0] == x || point[1] == y) {
var newDistance = Math.abs(point[0] - x) + Math.abs(point[1] - y);
if (index == -1) {
index = i;
smallestDistance = newDistance;
} else if (smallestDistance > newDistance) {
index = i;
smallestDistance = newDistance;
}
}
i++;
}
return index;
}
}
================================================
FILE: Find Numbers with Even Number of Digits/kata.go
================================================
package kata
func findNumbers(nums []int) int {
var c int
for _, number := range nums {
i := 0
for number != 0 {
i++
number /= 10
}
if i%2 == 0 {
c++
}
}
return c
}
================================================
FILE: Find Peak Element/kata.go
================================================
package kata
func findPeakElement(nums []int) int {
if len(nums) == 1 {
return 0
}
maxPeak := -1
idx := 0
for i := 0; i < len(nums); i++ {
if maxPeak == -1 || maxPeak < nums[i] {
maxPeak = nums[i]
idx = i
}
}
return idx
}
================================================
FILE: Find Pivot Index/kata.go
================================================
package kata
func pivotIndex(nums []int) int {
var sum int
for _, n := range nums {
sum = sum + n
}
var leftSum int
last := -1
for i := len(nums) - 1; i >= 0; i-- {
r := sum - nums[i]
l := leftSum
if r == l {
last = i
}
leftSum = leftSum + nums[i]
sum = sum - nums[i]
}
return last
}
================================================
FILE: Find Players With Zero or One Losses/kata.go
================================================
package kata
import "sort"
type player struct {
losses int
wins int
}
func findWinners(matches [][]int) [][]int {
allPlayers := make(map[int]player)
for _, match := range matches {
player := allPlayers[match[1]]
player.losses++
allPlayers[match[1]] = player
player = allPlayers[match[0]]
player.wins++
allPlayers[match[0]] = player
}
var exactlyOneMatch []int
var notLostAnyMatches []int
for player, stats := range allPlayers {
if stats.losses == 0 {
notLostAnyMatches = append(notLostAnyMatches, player)
} else if stats.losses == 1 {
exactlyOneMatch = append(exactlyOneMatch, player)
}
}
sort.Ints(notLostAnyMatches)
sort.Ints(exactlyOneMatch)
return [][]int{notLostAnyMatches, exactlyOneMatch}
}
================================================
FILE: Find Positive Integer Solution for a Given Equation/kata.py
================================================
package kata
"""
This is the custom function interface.
You should not implement it, or speculate about its implementation
class CustomFunction:
# Returns f(x, y) for any given positive integers x and y.
# Note that f(x, y) is increasing with respect to both x and y.
# i.e. f(x, y) < f(x + 1, y), f(x, y) < f(x, y + 1)
def f(self, x, y):
"""
import itertools
class Solution:
def findSolution(self, customfunction: 'CustomFunction', z: int) -> List[List[int]]:
numbersPairs = []
numbers = []
for i in range(1, z+1):
numbers.append(i)
numbersPairs.append([i, i])
numbersPairs.extend(list(itertools.permutations(numbers, 2)))
newNumbersPairs = []
for i in range(len(numbersPairs)):
z0 = customfunction.f(numbersPairs[i][0], numbersPairs[i][1])
if z == z0:
newNumbersPairs.append(numbersPairs[i])
return newNumbersPairs
================================================
FILE: Find Smallest Common Element in All Rows/kata.go
================================================
package Find_Smallest_Common_Element_in_All_Rows
func smallestCommonElement(mat [][]int) int {
min := -1
counters := make(map[int]int)
for i := 0; i < len(mat); i++ {
for j := 0; j < len(mat[i]); j++ {
c := counters[mat[i][j]]
if c == i+1 {
continue
}
c++
if c == i+1 && len(mat)-1 == i {
if min == -1 || mat[i][j] < min {
min = mat[i][j]
}
}
counters[mat[i][j]] = c
}
}
return min
}
================================================
FILE: Find Smallest Letter Greater Than Target/kata.go
================================================
package kata
func nextGreatestLetter(letters []byte, target byte) byte {
lastChar := byte(1)
for _, c := range letters {
if target < c {
lastChar = c
break
}
}
if lastChar == byte(1) {
lastChar = letters[0]
}
return lastChar
}
================================================
FILE: Find Target Indices After Sorting Array/kata.go
================================================
package kata
import "sort"
func targetIndices(nums []int, target int) []int {
sort.Ints(nums)
var indices []int
j := len(nums) - 1
for i := 0; i <= len(nums)/2; i++ {
if nums[i] == target {
indices = append(indices, i)
}
if j == len(nums)/2 {
continue
}
if nums[j] == target {
indices = append(indices, j)
}
j--
}
sort.Ints(indices)
return indices
}
================================================
FILE: Find The Original Array of Prefix Xor/kata.java
================================================
class Solution {
public int[] findArray(int[] pref) {
int[] res = new int[pref.length];
res[0] = pref[0];
if (pref.length == 1) return res;
for (var i = 1; i < pref.length; i++) {
res[i] = pref[i-1] ^ pref[i];
}
return res;
}
}
================================================
FILE: Find Triangular Sum of an Array/kata.go
================================================
package Find_Triangular_Sum_of_an_Array
func triangularSum(nums []int) int {
if len(nums) == 1 {
return nums[0]
}
i := len(nums) - 1
j := len(nums) - 2
k := 1
for {
nums = append(nums, (nums[k-1]+nums[k])%10)
k++
i--
if i == 0 {
k++
i += j
j = j - 1
}
if i == 0 {
break
}
}
return nums[len(nums)-1]
}
================================================
FILE: Find Users With Valid E-Mails/q.sql
================================================
SELECT * FROM Users WHERE REGEXP_LIKE(mail, '^([a-zA-Z]{1})([a-zA-Z0-9\_\.\-]*)\\@leetcode\\.com$')
================================================
FILE: Find Words Containing Character/kata.go
================================================
package kata
func findWordsContaining(words []string, x byte) []int {
var indices []int
for i, word := range words {
for _, char := range word {
if byte(char) == x {
indices = append(indices, i)
break
}
}
}
return indices
}
================================================
FILE: Find Words That Can Be Formed by Characters/kata.go
================================================
package kata
func countCharacters(words []string, chars string) int {
stats := make(map[rune]int, len(chars))
for _, c := range chars {
stats[c]++
}
var sum int
outerLoop:
for _, word := range words {
if len(word) > len(chars) {
continue
}
currentStats := make(map[rune]int)
for _, char := range word {
allowedCount, ok := stats[char]
if !ok || currentStats[char] >= allowedCount {
continue outerLoop
}
currentStats[char]++
}
sum += len(word)
}
return sum
}
================================================
FILE: Find and Replace Pattern/kata.go
================================================
package kata
func findAndReplacePattern(words []string, pattern string) []string {
cleanWords := cleanWords(words)
pattern = cleanWord(pattern)
var matched []string
for i, w := range cleanWords {
if w == pattern {
matched = append(matched, words[i])
}
}
return matched
}
func cleanWords(words []string) []string {
cws := make([]string, len(words))
for i, w := range words {
cws[i] = cleanWord(w)
}
return cws
}
func cleanWord(w string) string {
cleanWord := "A"
char := make(map[byte]byte)
lastChar := w[0]
char[w[0]] = 65
for i := 1; i < len(w); i++ {
if lastChar == w[i] {
cleanWord += string(cleanWord[i-1])
} else if e, ok := char[w[i]]; ok {
cleanWord += string(e)
} else {
cleanWord += string(cleanWord[i-1] + 1)
}
lastChar = w[i]
char[w[i]] = cleanWord[i-1] + 1
}
return cleanWord
}
================================================
FILE: Find the Array Concatenation Value/kata.java
================================================
class Solution {
public long findTheArrayConcVal(int[] nums) {
var j = nums.length-1;
long c = 0;
var i = 0;
for (;i < nums.length/2; i++) {
var al = (int) (Math.log10(nums[i]) + 1);
var bl = (int) (Math.log10(nums[j]) + 1);
var a = 0;
var b = 0;
if (al == bl) {
a = nums[i] * (int) Math.pow(10, (double)al);
b = nums[j];
} else {
a = nums[i] * (int) Math.pow(10, (double)bl);
b = nums[j];
}
c += a + b;
j--;
}
if (nums.length % 2 != 0) {
c += nums[i];
}
return c;
}
}
================================================
FILE: Find the Difference/kata.go
================================================
package kata
import "sort"
func findTheDifference(s string, t string) byte {
bs := []byte(s)
bt := []byte(t)
sort.Slice(bs, func(i, j int) bool {
return bs[i] < bs[j]
})
sort.Slice(bt, func(i, j int) bool {
return bt[i] < bt[j]
})
var max int
if len(bs) < len(bt) {
max = len(bs)
} else {
max = len(bt)
}
for i := 0; i < max; i++ {
if bs[i] != bt[i] {
return bt[i]
}
}
return bt[len(t)-1]
}
================================================
FILE: Find the Distance Value Between Two Arrays/kata.go
================================================
package kata
import "math"
func findTheDistanceValue(arr1 []int, arr2 []int, d int) int {
var c int
for _, n1 := range arr1 {
var has bool
for _, n2 := range arr2 {
newDistance := math.Abs(float64(n1) - float64(n2))
if newDistance <= float64(d) {
has = true
break
}
}
if !has {
c++
}
}
return c
}
================================================
FILE: Find the Duplicate Number/kata.go
================================================
package kata
import "sort"
func findDuplicate(nums []int) int {
sort.Ints(nums)
for i := 1; i < len(nums); i++ {
diff := nums[i-1] - nums[i]
if diff == 0 {
return nums[i]
}
}
return -1
}
================================================
FILE: Find the Highest Altitude/kata.go
================================================
package Find_the_Highest_Altitude
func largestAltitude(gain []int) int {
var current int
highestAltitude := current
for _, n := range gain {
current += n
if current > highestAltitude {
highestAltitude = current
}
}
return highestAltitude
}
================================================
FILE: Find the K-Beauty of a Number/kata.java
================================================
class Solution {
public int divisorSubstrings(int num, int k) {
var oldNum = num;
var digitCount = ((int) Math.log10((double) num));
var sum = 0;
var countK = k-1;
var count = 0;
for (; digitCount >= 0; digitCount--) {
var digit = (num/(int) Math.pow(10, (double) digitCount)) % 10;
sum += digit * Math.pow(10, (double) countK);
countK--;
if (countK < 0) {
if (sum > 0 && oldNum % sum == 0) count++;
countK = k - 1;
if (k != 1) {
digitCount += k-1;
}
sum = 0;
}
}
return count;
}
}
================================================
FILE: Find the Kth Largest Integer in the Array/kata.go
================================================
package Find_the_Kth_Largest_Integer_in_the_Array
import "sort"
func kthLargestNumber(nums []string, k int) string {
sort.Slice(nums, func(i, j int) bool {
if len(nums[i]) == len(nums[j]) && nums[i] > nums[j] {
return true
} else if len(nums[i]) > len(nums[j]) {
return true
}
return false
})
return nums[k-1]
}
================================================
FILE: Find the Maximum Achievable Number/kata.go
================================================
package kata
func theMaximumAchievableX(num int, t int) int {
return (num + t) + t
}
================================================
FILE: Find the Minimum and Maximum Number of Nodes Between Critical Points/kata.go
================================================
package Find_the_Minimum_and_Maximum_Number_of_Nodes_Between_Critical_Points
import "math"
type ListNode struct {
Val int
Next *ListNode
}
func nodesBetweenCriticalPoints(head *ListNode) []int {
if head == nil {
panic("node list head is nil")
}
previousNode := head
currentNode := head.Next
c := 1
matched := make([]int, 0)
min := math.Inf(1)
for currentNode != nil {
if currentNode.Val < previousNode.Val && (currentNode.Next != nil && currentNode.Next.Val > currentNode.Val) {
matched = append(matched, c)
} else if currentNode.Val > previousNode.Val && (currentNode.Next != nil && currentNode.Next.Val < currentNode.Val) {
matched = append(matched, c)
}
if len(matched) >= 2 && float64(matched[len(matched)-1]-matched[len(matched)-2]) < min {
min = float64(matched[len(matched)-1] - matched[len(matched)-2])
}
previousNode = currentNode
currentNode = currentNode.Next
c++
}
if len(matched) == 0 || len(matched) == 1 {
return []int{-1, -1}
}
return []int{int(min), matched[len(matched)-1] - matched[0]}
}
================================================
FILE: Find the Missing IDs/q.sql
================================================
WITH RECURSIVE nums AS (
SELECT 1 AS value
UNION ALL
SELECT value + 1 AS value
FROM nums
WHERE nums.value < (SELECT MAX(customer_id) FROM Customers))
SELECT value AS ids FROM nums WHERE value NOT IN(SELECT customer_id FROM Customers) ORDER BY value ASC;
================================================
FILE: Find the Peaks/kata.go
================================================
package kata
func findPeaks(mountain []int) []int {
var peaks []int
for i := 1; i < len(mountain)-1; i++ {
if mountain[i] > mountain[i-1] && mountain[i] > mountain[i+1] {
peaks = append(peaks, i)
}
}
return peaks
}
================================================
FILE: Find the Pivot Integer/kata.java
================================================
class Solution {
public int pivotInteger(int n) {
var sum = 0;
for (var num = 1; num < n+1; num++) {
sum += num;
var count = n - num;
if (sum == (count+1) * num + (count*(count+1)/2)) {
return num;
}
}
return -1;
}
}
================================================
FILE: Find the Sum of Encrypted Integers/kata.go
================================================
package kata
import "math"
func sumOfEncryptedInt(nums []int) int {
var sum int
for _, num := range nums {
var digitCount float64
var max int
for num > 0 {
digit := num % 10
if max < digit {
max = digit
}
num = num / 10
digitCount++
}
sum += max * (1 - int(math.Pow(10, digitCount))) / (1 - 10)
}
return sum
}
================================================
FILE: Find the Team Size/q.sql
================================================
SELECT employee_id, (SELECT COUNT(team_id) FROM Employee AS e1 WHERE e1.team_id = e.team_id) AS team_size FROM Employee AS e;
================================================
FILE: Find the Winner of the Circular Game/kata.java
================================================
class Solution {
public int findTheWinner(int n, int k) {
Queue<Integer> queue = new LinkedList<>();
for (var i = 1; i < n+1; i++) queue.add(i);
var i = 0;
while(queue.size() != 1) {
var element = queue.poll();
i++;
if (i == k) {
i = 0;
} else {
queue.add(element);
}
}
return queue.poll();
}
}
================================================
FILE: First Bad Version/kata.go
================================================
package kata
/**
* Forward declaration of isBadVersion API.
* @param version your guess about first bad version
* @return true if current version is bad
* false if current version is good
* func isBadVersion(version int) bool;
*/
func firstBadVersion(n int) int {
for i := 1; i <= n; i++ {
if isBadVersion(i) {
return i
}
}
return -1
}
================================================
FILE: First Letter to Appear Twice/kata.go
================================================
package kata
func repeatedCharacter(s string) byte {
indexLocation := make(map[rune]int)
for i, char := range s {
v, ok := indexLocation[char]
if !ok {
indexLocation[char] = -1
} else if v == -1 {
indexLocation[char] = i
}
}
var minChar rune
min := -1
for char, i := range indexLocation {
if i != -1 && (min == -1 || min > i) {
min = i
minChar = char
}
}
return byte(minChar)
}
================================================
FILE: First Missing Positive/kata.go
================================================
package kata
import (
"math"
"sort"
)
func firstMissingPositive(nums []int) int {
sort.Ints(nums)
currentNum := 1
preNum := math.Inf(-1)
for _, num := range nums {
if num > 0 {
if int(preNum) == num {
continue
}
if currentNum == num {
preNum = float64(num)
currentNum++
continue
}
break
}
}
return currentNum
}
================================================
FILE: First Unique Character in a String/kata.go
================================================
package kata
func firstUniqChar(s string) int {
type counter struct {
i int
c int
}
set := make(map[rune]*counter)
for i, c := range s {
v, ok := set[c]
if !ok {
set[c] = &counter{c: 1, i: i}
continue
}
v.c = v.c + 1
set[c] = v
}
index := -1
for _, v := range set {
if (index == -1 && v.c == 1) || (v.c == 1 && index > v.i) {
index = v.i
}
}
return index
}
================================================
FILE: Fix Names in a Table/q.sql
================================================
SELECT user_id, CONCAT(UPPER(LEFT(name, 1)), LOWER(SUBSTRING(name, 2))) AS name FROM Users ORDER BY user_id;
================================================
FILE: Fix Product Name Format/q.sql
================================================
SELECT
TRIM(LOWER(product_name)) AS product_name,
DATE_FORMAT(sale_date, '%Y-%m') AS sale_date,
COUNT(*) AS total
FROM
Sales
GROUP BY
1, 2
ORDER BY
product_name ASC,
sale_date ASC;
================================================
FILE: Fizz Buzz/kata.go
================================================
package kata
import "strconv"
func fizzBuzz(n int) []string {
values := make([]string, n)
var j int
for i := 1; i <= n; i++ {
if i%3 == 0 && i%5 == 0 {
values[j] = "FizzBuzz"
} else if i%3 == 0 {
values[j] = "Fizz"
} else if i%5 == 0 {
values[j] = "Buzz"
} else {
values[j] = string(strconv.Itoa(i))
}
j++
}
return values
}
================================================
FILE: Flatten 2D Vector/kata.go
================================================
package Flatten_2D_Vector
type Vector2D struct {
vec [][]int
i int
j int
end bool
}
func Constructor(vec [][]int) Vector2D {
return Vector2D{vec: vec}
}
func (this *Vector2D) Next() int {
n := this.vec[this.j][this.i]
if this.i+1 < len(this.vec[this.j]) {
this.i = this.i + 1
} else if this.j+1 < len(this.vec) {
this.j = this.j + 1
this.i = 0
} else {
this.end = true
}
return n
}
func (this *Vector2D) HasNext() bool {
if this.end {
return false
}
if len(this.vec) > 0 && this.j < len(this.vec) && len(this.vec[this.j]) == 0 {
this.j++
return this.HasNext()
}
if len(this.vec) > 0 && this.j < len(this.vec) && this.i < len(this.vec[this.j]) {
return true
}
if this.j+1 < len(this.vec) {
return true
}
return false
}
================================================
FILE: Flatten Nested List Iterator/kata.go
================================================
package kata
/**
* // This is the interface that allows for creating nested lists.
* // You should not implement it, or speculate about its implementation
* type NestedInteger struct {
* }
*
* // Return true if this NestedInteger holds a single integer, rather than a nested list.
* func (this NestedInteger) IsInteger() bool {}
*
* // Return the single integer that this NestedInteger holds, if it holds a single integer
* // The result is undefined if this NestedInteger holds a nested list
* // So before calling this method, you should have a check
* func (this NestedInteger) GetInteger() int {}
*
* // Set this NestedInteger to hold a single integer.
* func (n *NestedInteger) SetInteger(value int) {}
*
* // Set this NestedInteger to hold a nested list and adds a nested integer to it.
* func (this *NestedInteger) Add(elem NestedInteger) {}
*
* // Return the nested list that this NestedInteger holds, if it holds a nested list
* // The list length is zero if this NestedInteger holds a single integer
* // You can access NestedInteger's List element directly if you want to modify it
* func (this NestedInteger) GetList() []*NestedInteger {}
*/
type NestedIterator struct {
c chan int
currentValue *int
}
func Constructor(nestedList []*NestedInteger) *NestedIterator {
c := make(chan int)
go recursiveChannling(nestedList, c, true)
return &NestedIterator{c: c}
}
func (this *NestedIterator) Next() int {
if this.currentValue == nil {
panic("unknown order of operation")
}
v := this.currentValue
this.currentValue = nil
return *v
}
func (this *NestedIterator) HasNext() bool {
v, ok := <-this.c
if ok {
pv := new(int)
*pv = v
this.currentValue = pv
return true
}
return false
}
func recursiveChannling(nestedList []*NestedInteger, c chan int, firstLayer bool) {
for _, o := range nestedList {
if o.IsInteger() {
c <- o.GetInteger()
} else {
recursiveChannling(o.GetList(), c, false)
}
}
if firstLayer {
close(c)
}
}
================================================
FILE: Flatten a Multilevel Doubly Linked List/kata.go
================================================
package kata
/**
* Definition for a Node.
* type Node struct {
* Val int
* Prev *Node
* Next *Node
* Child *Node
* }
*/
func flatten(root *Node) *Node {
currentNode := root
for currentNode != nil {
if currentNode.Child != nil {
r(currentNode, currentNode.Next, currentNode.Child)
continue
}
currentNode = currentNode.Next
}
return root
}
func r(currentNode *Node, nextNode *Node, childNode *Node) {
currentNode.Child = nil
currentChildNode := childNode
prevChildNode := childNode
for currentChildNode != nil {
if currentChildNode.Child != nil {
r(currentChildNode, currentChildNode.Next, currentChildNode.Child)
continue
}
prevChildNode = currentChildNode
currentChildNode = currentChildNode.Next
}
currentNode.Next = childNode
childNode.Prev = currentNode
if nextNode != nil {
nextNode.Prev = prevChildNode
prevChildNode.Next = nextNode
}
}
================================================
FILE: Flipping an Image/kata.go
================================================
package kata
func flipAndInvertImage(A [][]int) [][]int {
for i := 0; i < len(A); i++ {
k := len(A[i]) - 1
for j := 0; j < len(A[i])/2; j++ {
A[i][j], A[i][k] = A[i][k], A[i][j]
k--
}
}
for i := 0; i < len(A); i++ {
for j := 0; j < len(A[i]); j++ {
A[i][j] = A[i][j] ^ 1
}
}
return A
}
================================================
FILE: Friendly Movies Streamed Last Month/q.sql
================================================
SELECT
DISTINCT(title)
FROM
TVProgram AS p
JOIN Content AS c ON c.content_id = p.content_id
WHERE
c.Kids_content = 'Y'
AND c.content_type = 'Movies'
AND MONTH(p.program_date) = 6
AND YEAR(p.program_date) = 2020;
================================================
FILE: Function Composition/kata.ts
================================================
type F = (x: number) => number;
function compose(functions: F[]): F {
return function(x) {
for (var i = functions.length-1; i >= 0; i--) {
x = functions[i](x)
}
return x
}
};
/**
* const fn = compose([x => x + 1, x => 2 * x])
* fn(4) // 9
*/
================================================
FILE: Game Play Analysis I/q.sql
================================================
SELECT player_id, min(event_date) AS first_login FROM Activity GROUP BY player_id ORDER BY event_date;
================================================
FILE: Generate a String With Characters That Have Odd Counts/kata.go
================================================
package kata
func generateTheString(n int) string {
s := make([]byte, n)
var i int
if n%2 == 1 {
i = 0
} else {
s[0] = byte('a')
i = 1
}
b := byte('b')
for ; i < n; i++ {
s[i] = b
}
return string(s)
}
================================================
FILE: Generate the Invoic/q.sql
================================================
WITH invoice_summary AS (SELECT
ps.invoice_id,
p.product_id,
ps.quantity,
SUM(ps.quantity * p.price) AS price,
SUM(ps.quantity * p.price) OVER(PARTITION BY invoice_id) AS invoice_sum
FROM
Products AS p
JOIN Purchases AS ps USING (product_id)
GROUP BY
invoice_id,
product_id
ORDER BY
invoice_sum DESC, invoice_id ASC
)
SELECT product_id, quantity, price FROM invoice_summary WHERE invoice_id = (
SELECT invoice_id FROM invoice_summary LIMIT 1
);
================================================
FILE: Get Maximum in Generated Array/kata.go
================================================
package get_Maximum_in_Generated_Array
func getMaximumGenerated(n int) int {
if n == 0 {
return 0
}
nums := make([]int, n+1)
var l int
nums[l] = 0
l++
nums[l] = 1
max := -1
for ; l < (n+1)/2; l++ {
i := 2 * l
nums[i] = nums[l]
if max < nums[i] {
max = nums[i]
}
nums[i+1] = nums[l] + nums[l+1]
if max < nums[i+1] {
max = nums[i]
}
}
for ; l <= n; l++ {
if max < nums[l] {
max = nums[l]
}
}
return max
}
================================================
FILE: Get the Size of a DataFrame/kata.py
================================================
import pandas as pd
def getDataframeSize(players: pd.DataFrame) -> List[int]:
return [players.shape[0], players.shape[1]]
================================================
FILE: Goal Parser Interpretation/kata.go
================================================
package kata
const o byte = 'o'
func interpret(command string) string {
var s []byte
for i := 0; i < len(command); i++ {
if isOpen(command[i]) && i+1 < len(command) && isClosed(command[i+1]) {
s = append(s, o)
i++
} else if !isOpen(command[i]) && !isClosed(command[i]) {
s = append(s, command[i])
} else if isClosed(command[i]) {
continue
}
}
return string(s)
}
func isClosed(c byte) bool {
if c == ')' {
return true
}
return false
}
func isOpen(c byte) bool {
if c == '(' {
return true
}
return false
}
================================================
FILE: Goat Latin/kata.java
================================================
class Solution {
public String toGoatLatin(String sentence) {
var sb = new StringBuilder("");
var aSuffix = new StringBuilder("a");
final var maSuffix = "ma";
var firstChar = ' ';
for (var i = 0; i < sentence.length(); i++) {
if (i == 0 || (i > 0 && sentence.charAt(i-1) == ' ')) {
if (sentence.charAt(i) != 'a'
&& sentence.charAt(i) != 'e'
&& sentence.charAt(i) != 'i'
&& sentence.charAt(i) != 'o'
&& sentence.charAt(i) != 'u'
&& sentence.charAt(i) != 'A'
&& sentence.charAt(i) != 'E'
&& sentence.charAt(i) != 'I'
&& sentence.charAt(i) != 'O'
&& sentence.charAt(i) != 'U') {
firstChar = sentence.charAt(i);
if (sentence.length()-1 == i) {
sb.append(firstChar);
sb.append(maSuffix);
sb.append(aSuffix);
}
} else {
sb.append(sentence.charAt(i));
if (sentence.length()-1 == i) {
sb.append(maSuffix);
sb.append(aSuffix);
}
}
} else if (sentence.charAt(i) == ' ' || sentence.length()-1 == i) {
if (sentence.length()-1 == i) {
sb.append(sentence.charAt(i));
}
if (firstChar != ' ') {
sb.append(firstChar);
firstChar = ' ';
}
sb.append(maSuffix);
sb.append(aSuffix);
aSuffix.append('a');
if (sentence.length()-1 != i) {
sb.append(' ');
}
} else {
sb.append(sentence.charAt(i));
}
}
return sb.toString();
}
}
================================================
FILE: Grand Slam Titles/q.sql
================================================
WITH cte AS (
(
SELECT
c.Wimbledon AS player_id
FROM
Championships AS c
)
UNION ALL
(
SELECT
c.Fr_open AS player_id
FROM
Championships AS c
)
UNION ALL
(
SELECT
c.US_open AS player_id
FROM
Championships AS c
)
UNION ALL
(
SELECT
c.Au_open AS player_id
FROM
Championships AS c
)
)
SELECT
p.player_id,
player_name,
COUNT(c.player_id) AS grand_slams_count
FROM
Players AS p
INNER JOIN cte AS c ON p.player_id = c.player_id
GROUP BY
p.player_id;
================================================
FILE: Greatest English Letter in Upper and Lower Case/kata.go
================================================
package Greatest_English_Letter_in_Upper_and_Lower_Case
import "sort"
func greatestLetter(s string) string {
b := []byte(s)
sort.Slice(b, func(i, j int) bool {
bj, bi := b[i], b[j]
if bi >= 97 && bi <= 122 {
bi = bi - 32
}
if bj >= 97 && bj <= 122 {
bj = bj - 32
}
return bi > bj
})
i := len(b) - 2
for j := len(b) - 1; j > 0; j-- {
bj, bi := b[i], b[j]
if bj == bi {
continue
}
if bi >= 97 && bi <= 122 {
if bi-32 == bj {
return string(bj)
}
}
if bj >= 97 && bj <= 122 {
if bi == bj-32 {
return string(bi)
}
}
i--
}
return ""
}
================================================
FILE: Group Anagrams/kata.go
================================================
package kata
import "sort"
func groupAnagrams(strs []string) [][]string {
set := make(map[string][]string)
lists := make([][]string, 0)
for _, s := range strs {
sb := []byte(s)
sort.Slice(sb, func(i, j int) bool {
return sb[i] < sb[j]
})
list, ok := set[string(sb)]
if ok {
list = append(list, s)
set[string(sb)] = list
} else {
l := []string{s}
set[string(sb)] = l
}
}
for _, list := range set {
lists = append(lists, list)
}
return lists
}
================================================
FILE: Group By/kata.js
================================================
/**
* @param {Function} fn
* @return {Object}
*/
Array.prototype.groupBy = function(fn) {
let groups = {}
this.forEach((element, index) => {
const key = fn(element)
if (groups[key]) {
groups[key].push(element)
} else {
groups[key] = []
groups[key].push(element)
}
})
return groups
};
/**
* [1,2,3].groupBy(String) // {"1":[1],"2":[2],"3":[3]}
*/
================================================
FILE: Group Sold Products By The Date/q.sql
================================================
SELECT
sell_date,
COUNT(DISTINCT product) AS num_sold,
GROUP_CONCAT(DISTINCT product ORDER BY product SEPARATOR ',') AS products
FROM
Activities AS a2
GROUP BY
sell_date;
================================================
FILE: Group the People Given the Group Size They Belong To/kata.go
================================================
package kata
func groupThePeople(groupSizes []int) [][]int {
buckets := make(map[int][]int, 0)
dividedGroups := make([][]int, 0)
for i, groupSize := range groupSizes {
bucket := buckets[groupSize]
if bucket == nil {
bucket = make([]int, 0)
}
bucket = append(bucket, i)
if len(bucket) == groupSize {
dividedGroups = append(dividedGroups, bucket)
buckets[groupSize] = nil
} else {
buckets[groupSize] = bucket
}
}
return dividedGroups
}
================================================
FILE: H-Index/kata.go
================================================
package H_Index
import "sort"
func hIndex(citations []int) int {
sort.Slice(citations, func(i, j int) bool {
return citations[i] > citations[j]
})
for i := len(citations) - 1; i >= 0; i-- {
if citations[i] >= i+1 {
return i + 1
}
}
return 0
}
================================================
FILE: HTML Entity Parser/kata.go
================================================
package kata
var token = map[string]string{""": "\"", "'": "'", "&": "&", ">": ">", "<": "<", "⁄": "/"}
func entityParser(text string) string {
output := make([]byte, 0)
tag := make([]byte, 0)
for i := 0; i < len(text); i++ {
if text[i] == ';' {
tag = append(tag, text[i])
v, ok := token[string(tag)]
if ok {
output = append(output, v...)
} else {
output = append(output, string(tag)...)
}
tag = make([]byte, 0)
continue
}
if text[i] == '&' {
tag = append(tag, text[i])
continue
}
if len(tag) != 0 {
tag = append(tag, text[i])
} else {
output = append(output, text[i])
}
}
if len(tag) != 0 {
output = append(output, tag...)
}
return string(output)
}
================================================
FILE: Hamming Distance/kata.go
================================================
package kata
func hammingDistance(x int, y int) int {
var count int
for y != 0 || x != 0 {
b2 := 0
if x != 0 {
b2 = x % 2
x = x / 2
}
b1 := 0
if y != 0 {
b1 = y % 2
y = y / 2
}
if b1 != b2 {
count++
}
}
return count
}
================================================
FILE: Happy Number/kata.go
================================================
package kata
func isHappy(n int) bool {
var ok bool
steps := make(map[int]int)
for n > 0 {
n = sumFunc(n)
if n == 1 {
ok = true
break
}
_, found := steps[n]
if found {
ok = false
break
}
steps[n] = 0
}
return ok
}
func sumFunc(n int) int {
var sum int
for n > 0 {
r := n % 10
n = n / 10
sum = sum + (r * r)
}
return sum
}
================================================
FILE: Harshad Number/kata.go
================================================
package kata
func sumOfTheDigitsOfHarshadNumber(x int) int {
num := x
var sum int
for num > 0 {
sum += num % 10
num = num / 10
}
if x%sum == 0 {
return sum
}
return -1
}
================================================
FILE: Height Checker/kata.go
================================================
package kata
import "sort"
func heightChecker(heights []int) int {
sortedHeights := make([]int, len(heights))
copy(sortedHeights, heights)
sort.Ints(sortedHeights)
var count int
for i := range heights {
if heights[i] != sortedHeights[i] {
count++
}
}
return count
}
================================================
FILE: High Five/kata.go
================================================
package High_Five
import "sort"
func highFive(items [][]int) [][]int {
sort.Slice(items, func(i, j int) bool {
if items[i][0] == items[j][0] {
return items[i][1] > items[j][1]
}
return items[i][0] < items[j][0]
})
currentNumber := items[0][0]
counter := 1
sum := items[0][1]
res := make([][]int, 0)
for i := 1; i < len(items); i++ {
if counter == 5 && currentNumber != items[i][0] {
res = append(res, []int{currentNumber, sum / 5})
currentNumber = items[i][0]
sum = items[i][1]
counter = 1
continue
} else if counter == 5 {
continue
}
sum += items[i][1]
counter++
}
if counter == 5 {
res = append(res, []int{currentNumber, sum / 5})
}
return res
}
================================================
FILE: How Many Apples Can You Put into the Basket/kata.java
================================================
import java.util.Arrays;
class Solution {
public int maxNumberOfApples(int[] weight) {
Arrays.sort(weight);
var total = 0;
var count = 0;
for (var item: weight) {
if (total + item > 5000) {
break;
}
total = total + item;
count++;
}
return count;
}
}
================================================
FILE: How Many Numbers Are Smaller Than the Current Number/kata.go
================================================
package kata
import (
"container/list"
"sort"
)
func smallerNumbersThanCurrent(nums []int) []int {
counterList := make(map[int]*list.List, len(nums))
for i, n := range nums {
l := counterList[n]
if l == nil {
l = new(list.List)
l.PushFront(i)
counterList[n] = l
} else {
l.PushFront(i)
}
}
sort.Slice(nums, func(i, j int) bool {
return nums[i] > nums[j]
})
counter := make([]int, len(nums))
for i := 0; i < len(nums); i++ {
c := len(nums) - i - counterList[nums[i]].Len()
e := counterList[nums[i]].Front()
counter[e.Value.(int)] = c
counterList[nums[i]].Remove(e)
}
return counter
}
================================================
FILE: Immediate Food Delivery I/q.sql
================================================
SELECT ROUND((SELECT COUNT(*) FROM Delivery AS d2 WHERE d2.order_date = d2.customer_pref_delivery_date)/COUNT(*)*100, 2) AS immediate_percentage FROM Delivery AS d1;
================================================
FILE: Implement Magic Dictionary/kata.go
================================================
package Implement_Magic_Dictionary
type MagicDictionary struct {
words map[int][]string
}
func Constructor() MagicDictionary {
return MagicDictionary{
words: nil,
}
}
func (this *MagicDictionary) BuildDict(dictionary []string) {
words := make(map[int][]string, 0)
for _, word := range dictionary {
_, ok := words[len(word)]
if !ok {
words[len(word)] = []string{}
}
words[len(word)] = append(words[len(word)], word)
}
this.words = words
}
func (this *MagicDictionary) Search(searchWord string) bool {
ws, ok := this.words[len(searchWord)]
if !ok {
return false
}
outer:
for _, word := range ws {
if word == searchWord {
continue
}
if len(word) == 1 {
return true
}
c := 0
for i := 0; i < len(searchWord); i++ {
if searchWord[i] != word[i] {
c++
}
if c > 1 {
continue outer
}
}
return true
}
return false
}
================================================
FILE: Implement Queue using Stacks/kata.go
================================================
package kata
type MyQueue struct {
list []int
}
/** Initialize your data structure here. */
func Constructor() MyQueue {
return MyQueue{
list: make([]int, 0),
}
}
/** Push element x to the back of queue. */
func (this *MyQueue) Push(x int) {
this.list = append([]int{x}, this.list...)
}
/** Removes the element from in front of queue and returns that element. */
func (this *MyQueue) Pop() int {
v := this.list[len(this.list)-1]
this.list = this.list[:len(this.list)-1]
return v
}
/** Get the front element. */
func (this *MyQueue) Peek() int {
return this.list[len(this.list)-1]
}
/** Returns whether the queue is empty. */
func (this *MyQueue) Empty() bool {
if len(this.list) == 0 {
return true
}
return false
}
/**
* Your MyQueue object will be instantiated and called as such:
* obj := Constructor();
* obj.Push(x);
* param_2 := obj.Pop();
* param_3 := obj.Peek();
* param_4 := obj.Empty();
*/
================================================
FILE: Implement Stack using Queues/kata.go
================================================
package kata
type MyStack struct {
values []int
}
/** Initialize your data structure here. */
func Constructor() MyStack {
return MyStack{
values: make([]int, 0),
}
}
/** Push element x onto stack. */
func (this *MyStack) Push(x int) {
this.values = append(this.values, x)
}
/** Removes the element on top of the stack and returns that element. */
func (this *MyStack) Pop() int {
v := this.values[len(this.values)-1]
this.values = this.values[:len(this.values)-1]
return v
}
/** Get the top element. */
func (this *MyStack) Top() int {
return this.values[len(this.values)-1]
}
/** Returns whether the stack is empty. */
func (this *MyStack) Empty() bool {
return len(this.values) == 0
}
/**
* Your MyStack object will be instantiated and called as such:
* obj := Constructor();
* obj.Push(x);
* param_2 := obj.Pop();
* param_3 := obj.Top();
* param_4 := obj.Empty();
*/
================================================
FILE: Implement Trie (Prefix Tree)/kata.go
================================================
package kata
type node struct {
Val rune
word bool
nodes map[rune]*node
}
type Trie struct {
node map[rune]*node
}
/** Initialize your data structure here. */
func Constructor() Trie {
return Trie{}
}
/** Inserts a word into the trie. */
func (this *Trie) Insert(word string) {
var current *node
v, ok := this.node[rune(word[0])]
if ok {
current = v
} else {
if this.node == nil {
this.node = make(map[rune]*node)
}
n := &node{Val: rune(word[0]), nodes: make(map[rune]*node)}
this.node[rune(word[0])] = n
current = n
}
for _, c := range word[1:] {
v, ok := current.nodes[c]
if ok {
current = v
} else {
n := &node{Val: c, nodes: make(map[rune]*node)}
current.nodes[c] = n
current = n
}
}
current.word = true
}
/* Returs if the word is in the trie. */
func (this *Trie) Search(word string) bool {
if this.node == nil {
return false
}
if len(word) == 0 {
return false
}
var current *node
v, ok := this.node[rune(word[0])]
if ok {
current = v
} else {
return false
}
for _, c := range word[1:] {
v, ok := current.nodes[c]
if ok {
current = v
} else {
return false
}
}
return current.word
}
/** Returns if there is any word in the trie that starts with the given prefix. */
func (this *Trie) StartsWith(prefix string) bool {
if this.node == nil {
return false
}
if len(prefix) == 0 {
return false
}
var current *node
v, ok := this.node[rune(prefix[0])]
if ok {
current = v
} else {
return false
}
for _, c := range prefix[1:] {
v, ok := current.nodes[c]
if ok {
current = v
} else {
return false
}
}
return true
}
/**
* Your Trie object will be instantiated and called as such:
* obj := Constructor();
* obj.Insert(word);
* param_2 := obj.Search(word);
* param_3 := obj.StartsWith(prefix);
*/
================================================
FILE: Implement strStr()/kata.go
================================================
package kata
func strStr(haystack string, needle string) (idx int) {
if haystack == needle {
return 0
}
idx = -1
for i := 0; i < len(haystack); i++ {
if (i + len(needle)) > len(haystack) {
return
}
if haystack[i:i+len(needle)] == needle {
idx = i
return
}
}
return
}
================================================
FILE: Increasing Order Search Tree/kata.go
================================================
package kata
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func increasingBST(root *TreeNode) *TreeNode {
nodes := inorderTraversal(root)
tmp := &TreeNode{}
current := tmp
for _, n := range nodes {
if current.Right == nil {
current.Right = &TreeNode{Val: n}
}
current = current.Right
}
return tmp.Right
}
func inorderTraversal(root *TreeNode) []int {
list := make([]int, 0)
inorder(root, &list)
return list
}
func inorder(node *TreeNode, list *[]int) {
if node == nil {
return
}
if node.Left != nil {
inorder(node.Left, list)
}
*list = append(*list, node.Val)
if node.Right != nil {
inorder(node.Right, list)
}
}
================================================
FILE: Index Pairs of a String/kata.java
================================================
class Solution {
public int[][] indexPairs(String text, String[] words) {
var list = new ArrayList<ArrayList<Integer>>();
for (var i = 0; i < text.length(); i++) {
for (var word: words) {
if ((i+word.length()) <= text.length()) {
if (text.substring(i, i+word.length()).equals(word)) {
final var index = i;
list.add(new ArrayList<Integer>(){{
add(index);
add(index+word.length()-1);
}});
}
}
}
}
Collections.sort(list, new Comparator<ArrayList<Integer>>() {
public int compare(ArrayList<Integer> a, ArrayList<Integer> b) {
if (a.get(0) == b.get(0)) {
if (a.get(1) == b.get(1)) {
return 0;
} else if (a.get(1) < b.get(1)) {
return -1;
} else {
return 1;
}
} else if (a.get(0) < b.get(0)) {
return -1;
} else {
return 1;
}
}
});
var res = new int[list.size()][2];
var i = 0;
for (var element : list) {
res[i] = new int[]{element.get(0), element.get(1)};
i++;
}
return res;
}
}
================================================
FILE: Insertion Sort List/kata.go
================================================
package kata
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func insertionSortList(head *ListNode) *ListNode {
if head == nil {
return nil
}
if head.Next == nil {
return head
}
nodes := make([]*ListNode, 0)
current := head
for current != nil {
nodes = append(nodes, current)
current = current.Next
}
Insertionsort(nodes)
return head
}
func Insertionsort(a []*ListNode) {
for j := 1; j < len(a); j++ {
key := a[j].Val
i := j - 1
for i >= 0 && a[i].Val > key {
a[i+1].Val = a[i].Val
i = i - 1
}
a[i+1].Val = key
}
}
================================================
FILE: Intersection of Multiple Arrays/kata.go
================================================
package Intersection_of_Multiple_Arrays
import "sort"
func intersection(nums [][]int) []int {
set := make(map[int]int)
for _, vec := range nums {
for _, n := range vec {
set[n]++
}
}
vec := make([]int, 0)
for n, c := range set {
if c == len(nums) {
vec = append(vec, n)
}
}
if len(vec) != 0 {
sort.Ints(vec)
}
return vec
}
================================================
FILE: Intersection of Three Sorted Arrays/kata.go
================================================
package kata
func arraysIntersection(arr1 []int, arr2 []int, arr3 []int) []int {
res := make([]int, 0)
var j, k int
for i := 0; i < len(arr1); {
if k == len(arr3) || j == len(arr2) || i == len(arr1) {
break
}
if arr1[i] == arr2[j] && arr2[j] == arr3[k] {
res = append(res, arr2[j])
j++
i++
k++
continue
}
if arr3[k] > arr1[i] && arr3[k] > arr2[j] {
j++
i++
continue
} else if arr2[j] > arr1[i] && arr2[j] > arr3[k] {
i++
k++
continue
} else if arr1[i] > arr3[k] && arr1[i] > arr2[j] {
j++
k++
continue
} else if arr3[k] > arr1[i] {
i++
continue
} else if arr3[k] > arr2[j] {
j++
continue
} else if arr2[j] > arr1[i] {
i++
continue
} else if arr2[j] > arr3[k] {
k++
continue
} else if arr1[i] > arr3[k] {
k++
continue
} else if arr1[i] > arr2[j] {
j++
continue
}
}
return res
}
================================================
FILE: Intersection of Two Arrays/kata.go
================================================
package kata
func intersection(nums1 []int, nums2 []int) []int {
seen := make(map[int]int)
for i := 0; i < len(nums1); i++ {
seen[nums1[i]] = 1
}
inter := make([]int, 0)
for i := 0; i < len(nums2); i++ {
counter, ok := seen[nums2[i]]
if ok && counter == 1 {
seen[nums2[i]] = seen[nums2[i]] + 1
inter = append(inter, nums2[i])
}
}
return inter
}
================================================
FILE: Intersection of Two Arrays II/kata.go
================================================
package kata
import "sort"
func intersect(nums1 []int, nums2 []int) []int {
intersection := make(map[int]int)
for i := 0; i < len(nums1); i++ {
intersection[nums1[i]] = intersection[nums1[i]] + 1
}
y := make([]int, 0)
for i := 0; i < len(nums2); i++ {
c, ok := intersection[nums2[i]]
if ok && c > 0 {
intersection[nums2[i]] = intersection[nums2[i]] - 1
y = append(y, nums2[i])
}
}
sort.Slice(y, func(i, j int) bool {
return y[i] < y[j]
})
return y
}
================================================
FILE: Intersection of Two Linked Lists/kata.go
================================================
package kata
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func getIntersectionNode(headA, headB *ListNode) *ListNode {
if headA == nil || headB == nil {
return nil
}
table := make(map[*ListNode]struct{}, 0)
current := headA
for current != nil {
table[current] = struct{}{}
current = current.Next
}
current = headB
for current != nil {
if _, ok := table[current]; ok {
return current
}
current = current.Next
}
return nil
}
================================================
FILE: Invalid Tweets/q.sql
================================================
SELECT tweet_id FROM Tweets WHERE CHAR_LENGTH(content) > 15;
================================================
FILE: Invert Binary Tree/kata.go
================================================
package kata
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func invertTree(root *TreeNode) *TreeNode {
swap(root)
return root
}
func swap(node *TreeNode) {
if node == nil {
return
}
if node.Left != nil && node.Right != nil {
node.Left, node.Right = node.Right, node.Left
swap(node.Right)
swap(node.Left)
return
}
if node.Left != nil {
node.Right = node.Left
node.Left = nil
swap(node.Right)
return
}
if node.Right != nil {
node.Left = node.Right
node.Right = nil
swap(node.Left)
return
}
return
}
================================================
FILE: Is Object Empty/kata.js
================================================
/**
* @param {Object|Array} obj
* @return {boolean}
*/
var isEmpty = function(obj) {
if (Array.isArray(obj)) {
return obj.length == 0
} else {
return Object.keys(obj).length == 0
}
};
================================================
FILE: Is Subsequence/kata.go
================================================
package kata
func isSubsequence(s string, t string) bool {
sub := make([]byte, len(s))
var i int
for j := 0; j < len(t); j++ {
if i == len(s) {
break
}
if s[i] == t[j] {
sub[i] = s[i]
i++
}
}
if string(sub) == s {
return true
}
return false
}
================================================
FILE: Island Perimeter/kata.go
================================================
package Island_Perimeter
func islandPerimeter(grid [][]int) int {
var sum int
for i := 0; i < len(grid); i++ {
for j := 0; j < len(grid[i]); j++ {
if grid[i][j] == 0 {
continue
}
left := j - 1
if left >= 0 && grid[i][left] == 0 {
sum++
} else if left < 0 {
sum++
}
right := j + 1
if right < len(grid[i]) && grid[i][right] == 0 {
sum++
} else if right == len(grid[i]) {
sum++
}
up := i - 1
if up >= 0 && grid[up][j] == 0 {
sum++
} else if up < 0 {
sum++
}
down := i + 1
if down < len(grid) && grid[down][j] == 0 {
sum++
} else if down == len(grid) {
sum++
}
}
}
return sum
}
================================================
FILE: Jewels and Stones/kata.go
================================================
package kata
func numJewelsInStones(J string, S string) int {
set := make(map[byte]bool, len(J))
for i := 0; i < len(J); i++ {
set[J[i]] = true
}
var counter int
for i := 0; i < len(S); i++ {
ok := set[S[i]]
if ok {
counter++
}
}
return counter
}
================================================
FILE: K Items With the Maximum Sum/kata.go
================================================
package kata
func kItemsWithMaximumSum(numOnes int, numZeros int, numNegOnes int, k int) int {
var sum int
if numOnes >= k {
sum += 1 * k
return sum
} else if numOnes > 0 {
sum += numOnes * 1
k = k - numOnes
}
if numZeros >= k {
return sum
} else if numZeros > 0 {
k = k - numZeros
}
if numNegOnes >= k {
sum += -1 * k
return sum
} else if numNegOnes > 0 {
sum += -1 * numNegOnes
}
return sum
}
================================================
FILE: K Radius Subarray Averages/kata.go
================================================
package K_Radius_Subarray_Averages
func getAverages(nums []int, k int) []int {
if k == 0 {
return nums
}
out := make([]int, len(nums))
for i := 0; i < len(nums); i++ {
out[i] = -1
}
if k > len(nums) || (k+k) >= len(nums) {
return out
}
var sum int
var c int
for i := 0; i < k+k+1; i++ {
sum += nums[i]
c++
}
avg := sum / c
out[k] = avg
for i := k + 1; i < len(nums); i++ {
if i+k >= len(nums) {
break
}
sum += nums[i+k]
sum -= nums[i-k-1]
out[i] = sum / c
}
return out
}
================================================
FILE: Keep Multiplying Found Values by Two/kata.go
================================================
package Keep_Multiplying_Found_Values_by_Two
func findFinalValue(nums []int, original int) int {
var i int
for {
i = i % len(nums)
n := nums[i]
if n == original {
i = 0
original = original * 2
continue
}
i++
if i == len(nums) {
break
}
}
return original
}
================================================
FILE: Kids With the Greatest Number of Candies/kata.go
================================================
package kata
import "math"
func kidsWithCandies(candies []int, extraCandies int) []bool {
max := int(math.Inf(1))
for _, count := range candies {
if max == int(math.Inf(1)) || count > max {
max = count
}
}
facts := make([]bool, len(candies))
for i, count := range candies {
if (count + extraCandies) >= max {
facts[i] = true
}
}
return facts
}
================================================
FILE: Kth Distinct String in an Array/kata.go
================================================
package kata
func kthDistinct(arr []string, k int) string {
distinct := make(map[string]int)
for _, a := range arr {
distinct[a]++
}
if len(distinct) < k {
return ""
}
i := 1
for _, a := range arr {
if distinct[a] == 1 {
if i == k {
return a
}
i++
}
}
return ""
}
================================================
FILE: Kth Largest Element in a Stream/kata.go
================================================
package kata
import "sort"
type KthLargest struct {
k int
nums []int
}
func Constructor(k int, nums []int) KthLargest {
return KthLargest{
k: k,
nums: nums,
}
}
func (thi
gitextract_1nm0h8c7/
├── Day of the Week/
│ └── kata.py
├── Find Total Time Spent by Each Employee/
│ └── q.sql
├── Students With Invalid Departments/
│ └── q.sql
├── .gitignore
├── 3042. Count Prefix and Suffix Pairs I/
│ └── kata.py
├── 3110. Score of a String/
│ └── main.scala
├── A Number After a Double Reversal/
│ └── kata.go
├── Account Balance/
│ └── q.sql
├── Account Balance After Rounded Purchase/
│ └── kata.go
├── Accounts Merge/
│ └── kata.go
├── Active Businesses/
│ └── q.sql
├── Add Binary/
│ └── kata.go
├── Add Digits/
│ └── kata.go
├── Add One Row to Tree/
│ └── kata.go
├── Add Strings/
│ └── kata.go
├── Add Two Integers/
│ └── kata.go
├── Adding Spaces to a String/
│ └── kata.go
├── All Elements in Two Binary Search Trees/
│ └── kata.go
├── All the Matches of the League/
│ └── q.sql
├── Allow One Function Call/
│ └── kata.ts
├── Alternating Digit Sum/
│ └── kata.java
├── Ant on the Boundary/
│ └── kata.go
├── Apple Redistribution into Boxes/
│ └── kata.go
├── Apples & Oranges/
│ └── q.sql
├── Apply Discount Every n Orders/
│ └── kata.go
├── Apply Transform Over Each Element in Array/
│ └── kata.ts
├── Armstrong Number/
│ └── kata.go
├── Arranging Coins/
│ └── kata.go
├── Array Partition I/
│ └── kata.go
├── Array Reduce Transformation/
│ └── kata.ts
├── Array Wrapper/
│ └── kata.ts
├── Article Views I/
│ └── q.sql
├── Assign Cookies/
│ └── kata.go
├── Average Salary Excluding the Minimum and Maximum Salary/
│ └── kata.go
├── Average Selling Price/
│ └── q.sql
├── Average Time of Process per Machine/
│ └── q.sql
├── Average Value of Even Numbers That Are Divisible by Three/
│ └── kata.java
├── Average of Levels in Binary Tree/
│ └── kata.go
├── Backspace String Compare/
│ └── kata.go
├── Bank Account Summary/
│ └── q.sql
├── Bank Account Summary II/
│ └── q.sql
├── Base 7/
│ └── kata.go
├── Baseball Game/
│ └── kata.go
├── Basic Calculator II/
│ └── kata.go
├── Best Poker Hand/
│ └── kata.go
├── Best Time to Buy and Sell Stock/
│ └── kata.go
├── Big Countries/
│ └── kata.sql
├── Biggest Single Number/
│ └── q.sql
├── Binary Gap/
│ └── kata.go
├── Binary Number with Alternating Bits/
│ └── kata.go
├── Binary Prefix Divisible By 5/
│ └── kata.py
├── Binary Search Tree Iterator/
│ └── kata.go
├── Binary Tree Inorder Traversal/
│ └── kata.go
├── Binary Tree Paths/
│ └── kata.go
├── Binary Tree Postorder Traversal/
│ └── kata.go
├── Binary Tree Preorder Traversal/
│ └── kata.go
├── Build Array from Permutation/
│ └── kata.go
├── Buildings With an Ocean View/
│ └── kata.java
├── Bulls and Cows/
│ └── kata.go
├── Calculate Amount Paid in Taxes/
│ └── kata.go
├── Calculate Money in Leetcode Bank/
│ └── kata.go
├── Calculate Salaries/
│ └── q.sql
├── Calculate Special Bonus/
│ └── q.sql
├── Calculate the Influence of Each Salesperson/
│ └── q.sql
├── Calculator with Method Chaining/
│ └── kata.js
├── Can Make Arithmetic Progression From Sequence/
│ └── kata.go
├── Can Place Flowers/
│ └── kata.go
├── Capital Gain-loss/
│ └── q.sql
├── Capitalize the Title/
│ └── kata.go
├── Categorize Box According to Criteria/
│ └── kata.java
├── Cells with Odd Values in a Matrix/
│ └── kata.go
├── Change Data Type/
│ └── kata.py
├── Check Distances Between Same Letters/
│ └── kata.java
├── Check If All 1's Are at Least Length K Places Away/
│ └── kata.go
├── Check If N and Its Double Exist/
│ └── kata.go
├── Check If Two String Arrays are Equivalent/
│ └── kata.go
├── Check If a Number Is Majority Element in a Sorted Array/
│ └── kata.java
├── Check If a Word Occurs As a Prefix of Any Word in a Sentence/
│ └── kata.go
├── Check Whether Two Strings are Almost Equivalent/
│ └── kata.go
├── Check if All A's Appears Before All B's/
│ └── kata.go
├── Check if All Characters Have Equal Number of Occurrences/
│ └── kata.go
├── Check if Binary String Has at Most One Segment of Ones/
│ └── kata.go
├── Check if Bitwise OR Has Trailing Zeros/
│ └── kata.go
├── Check if Number Has Equal Digit Count and Digit Value/
│ └── kata.go
├── Check if Numbers Are Ascending in a Sentence/
│ └── kata.go
├── Check if One String Swap Can Make Strings Equal/
│ └── kata.go
├── Check if The Number is Fascinating/
│ └── kata.go
├── Check if Word Equals Summation of Two Words/
│ └── kata.go
├── Check if an Array Is Consecutive/
│ └── kata.go
├── Check if the Sentence Is Pangram/
│ └── kata.go
├── Classes More Than 5 Students/
│ └── kata.sql
├── Climbing Stairs/
│ └── kata.go
├── Combine Two Tables/
│ └── kata.sql
├── Compare Strings by Frequency of the Smallest Character/
│ └── kata.go
├── Complement of Base 10 Integer/
│ └── kata.go
├── Compute the Rank as a Percentage/
│ └── q.sql
├── Concatenate the Name and the Profession/
│ └── q.sql
├── Concatenation of Array/
│ └── kata.go
├── Confusing Number/
│ └── kata.java
├── Consecutive Available Seats/
│ └── q.sql
├── Consecutive Characters/
│ └── kata.go
├── Construct Binary Search Tree from Preorder Traversal/
│ └── kata.go
├── Construct String from Binary Tree/
│ └── kata.java
├── Construct the Rectangle/
│ └── kata.go
├── Contains Duplicate/
│ └── kata.go
├── Contains Duplicate II/
│ └── kata.go
├── Convert 1D Array Into 2D Array/
│ └── kata.go
├── Convert Binary Number in a Linked List to Integer/
│ └── kata.go
├── Convert Date Format/
│ └── q.sql
├── Convert Integer to the Sum of Two No-Zero Integers/
│ └── kata.go
├── Convert a Number to Hexadecimal/
│ └── kata.go
├── Convert the Temperature/
│ └── kata.java
├── Count Apples and Oranges/
│ └── q.sql
├── Count Asterisks/
│ └── kata.java
├── Count Common Words With One Occurrence/
│ └── kata.go
├── Count Complete Tree Nodes/
│ └── kata.go
├── Count Elements With Maximum Frequency/
│ └── kata.go
├── Count Elements With Strictly Smaller and Greater Elements/
│ └── kata.go
├── Count Integers With Even Digit Sum/
│ └── kata.go
├── Count Items Matching a Rule/
│ └── kata.go
├── Count Largest Group/
│ └── kata.java
├── Count Negative Numbers in a Sorted Matrix/
│ └── kata.rs
├── Count Odd Numbers in an Interval Range/
│ └── kata.go
├── Count Operations to Obtain Zero/
│ └── kata.go
├── Count Prefixes of a Given String/
│ └── kata.go
├── Count Student Number in Departments/
│ └── q.sql
├── Count Substrings Starting and Ending with Given Character/
│ └── kata.py
├── Count Tested Devices After Test Operations/
│ └── kata.go
├── Count Total Number of Colored Cells/
│ └── kata.go
├── Count of Matches in Tournament/
│ └── kata.go
├── Count the Digits That Divide a Number/
│ └── kata.java
├── Count the Number of Consistent Strings/
│ └── kata.go
├── Counter/
│ └── kata.ts
├── Counter II/
│ └── kata.ts
├── Counting Bits/
│ └── kata.go
├── Counting Elements/
│ └── kata.go
├── Counting Words With a Given Prefix/
│ └── kata.go
├── Cousins in Binary Tree/
│ └── kata.go
├── Create Hello World Function/
│ └── kata.ts
├── Create Target Array in the Given Order/
│ └── kata.go
├── Create a DataFrame from List/
│ └── kata.py
├── Create a New Column/
│ └── kata.py
├── Create a Session Bar Chart/
│ └── q.sql
├── Custom Sort String/
│ └── kata.go
├── Customer Placing the Largest Number of Orders/
│ └── q.sql
├── Customer Who Visited but Did Not Make Any Transactions/
│ └── q.sql
├── Customers Who Never Order/
│ └── kata.sql
├── DI String Match/
│ └── kata.go
├── Daily Leads and Partners/
│ └── q.sql
├── Day of the Year/
│ └── kata.go
├── Decode XORed Array/
│ └── kata.go
├── Decode the Message/
│ └── kata.go
├── Decompress Run-Length Encoded List/
│ └── kata.go
├── Decrypt String from Alphabet to Integer Mapping/
│ └── kata.go
├── Deepest Leaves Sum/
│ └── kata.go
├── Defanging an IP Address/
│ └── kata.go
├── Delete Characters to Make Fancy String/
│ └── kata.go
├── Delete Duplicate Emails/
│ └── kata.sql
├── Delete Greatest Value in Each Row/
│ └── kata.go
├── Delete Leaves With a Given Value/
│ └── kata.go
├── Delete Node in a Linked List/
│ └── kata.go
├── Delete the Middle Node of a Linked List/
│ └── kata.go
├── Design Add and Search Words Data Structure/
│ └── kata.go
├── Design HashMap/
│ └── kata.go
├── Design HashSet/
│ └── kata.go
├── Design Linked List/
│ └── kata_test.go
├── Design Parking System/
│ └── kata.go
├── Design a Stack With Increment Operation/
│ └── kata.go
├── Design an Ordered Stream/
│ └── kata.go
├── Destination City/
│ └── kata.go
├── Detect Capital/
│ └── kata.go
├── Determine Color of a Chessboard Square/
│ └── kata.go
├── Determine if String Halves Are Alike/
│ └── kata.go
├── Determine if Two Events Have Conflict/
│ └── kata.java
├── Diet Plan Performance/
│ └── kata.java
├── Difference Between Element Sum and Digit Sum of an Array/
│ └── kata.java
├── Display the First Three Rows/
│ └── kata.py
├── Distinct Numbers in Each Subarray/
│ └── kata.java
├── Distribute Candies to People/
│ └── kata.go
├── Distribute Elements Into Two Arrays I/
│ └── kata.go
├── Divide Array Into Equal Pairs/
│ └── kata.go
├── Divide a String Into Groups of Size k/
│ └── kata.go
├── Divisible and Non-divisible Sums Difference/
│ └── kata.go
├── Dot Product of Two Sparse Vectors/
│ └── kata.go
├── Drop Duplicate Rows/
│ └── kata.py
├── Drop Missing Data/
│ └── kata.py
├── Duplicate Emails/
│ └── kata.sql
├── Duplicate Zeros/
│ └── kata.go
├── Element Appearing More Than 25% In Sorted Array/
│ └── kata.go
├── Employee Bonus/
│ └── q.sql
├── Employee Importance/
│ └── kata.py
├── Employees Earning More Than Their Managers/
│ └── kata.sql
├── Employees With Missing Information/
│ └── q.sql
├── Encode and Decode TinyURL/
│ └── kata.go
├── Equal Row and Column Pairs/
│ └── kata.go
├── Evaluate Boolean Binary Tree/
│ └── kata.go
├── Evaluate Boolean Expression/
│ └── q.sql
├── Evaluate Reverse Polish Notation/
│ └── kata.go
├── Factorial Trailing Zeroes/
│ └── kata.go
├── Fibonacci Number/
│ └── kata.go
├── Fill Missing Data/
│ └── kata.py
├── Filter Elements from Array/
│ └── kata.ts
├── Filter Restaurants by Vegan-Friendly, Price and Distance/
│ └── kata.go
├── Final Prices With a Special Discount in a Shop/
│ └── kata.go
├── Final Value of Variable After Performing Operations/
│ └── kata.go
├── Find All Duplicates in an Array/
│ └── kata.go
├── Find All Lonely Numbers in the Array/
│ └── kata.go
├── Find All Numbers Disappeared in an Array/
│ └── kata.go
├── Find All The Lonely Nodes/
│ └── kata.java
├── Find Anagram Mappings/
│ └── kata.go
├── Find Bottom Left Tree Value/
│ └── kata.go
├── Find Center of Star Graph/
│ └── kata.go
├── Find Closest Number to Zero/
│ └── kata.go
├── Find Common Characters/
│ └── kata.go
├── Find Customer Referee/
│ └── q.sql
├── Find Customers With Positive Revenue this Year/
│ └── q.sql
├── Find First Palindromic String in the Array/
│ └── kata.go
├── Find First and Last Position of Element in Sorted Array/
│ └── kata.go
├── Find Followers Count/
│ └── q.sql
├── Find Greatest Common Divisor of Array/
│ └── kata.go
├── Find K Closest Elements/
│ └── kata.go
├── Find K-Length Substrings With No Repeated Characters/
│ └── kata.java
├── Find Largest Value in Each Tree Row/
│ └── kata.go
├── Find Lucky Integer in an Array/
│ └── kata.go
├── Find Maximum Number of String Pairs/
│ └── kata.go
├── Find Median from Data Stream/
│ └── kata.go
├── Find Minimum Time to Finish All Jobs II/
│ └── kata.java
├── Find Minimum in Rotated Sorted Array/
│ └── kata.go
├── Find Minimum in Rotated Sorted Array II/
│ └── kata.go
├── Find Missing and Repeated Values/
│ └── kata.go
├── Find Mode in Binary Search Tree/
│ └── kata.go
├── Find N Unique Integers Sum up to Zero/
│ └── kata.go
├── Find Nearest Point That Has the Same X or Y Coordinate/
│ └── kata.java
├── Find Numbers with Even Number of Digits/
│ └── kata.go
├── Find Peak Element/
│ └── kata.go
├── Find Pivot Index/
│ └── kata.go
├── Find Players With Zero or One Losses/
│ └── kata.go
├── Find Positive Integer Solution for a Given Equation/
│ └── kata.py
├── Find Smallest Common Element in All Rows/
│ └── kata.go
├── Find Smallest Letter Greater Than Target/
│ └── kata.go
├── Find Target Indices After Sorting Array/
│ └── kata.go
├── Find The Original Array of Prefix Xor/
│ └── kata.java
├── Find Triangular Sum of an Array/
│ └── kata.go
├── Find Users With Valid E-Mails/
│ └── q.sql
├── Find Words Containing Character/
│ └── kata.go
├── Find Words That Can Be Formed by Characters/
│ └── kata.go
├── Find and Replace Pattern/
│ └── kata.go
├── Find the Array Concatenation Value/
│ └── kata.java
├── Find the Difference/
│ └── kata.go
├── Find the Distance Value Between Two Arrays/
│ └── kata.go
├── Find the Duplicate Number/
│ └── kata.go
├── Find the Highest Altitude/
│ └── kata.go
├── Find the K-Beauty of a Number/
│ └── kata.java
├── Find the Kth Largest Integer in the Array/
│ └── kata.go
├── Find the Maximum Achievable Number/
│ └── kata.go
├── Find the Minimum and Maximum Number of Nodes Between Critical Points/
│ └── kata.go
├── Find the Missing IDs/
│ └── q.sql
├── Find the Peaks/
│ └── kata.go
├── Find the Pivot Integer/
│ └── kata.java
├── Find the Sum of Encrypted Integers/
│ └── kata.go
├── Find the Team Size/
│ └── q.sql
├── Find the Winner of the Circular Game/
│ └── kata.java
├── First Bad Version/
│ └── kata.go
├── First Letter to Appear Twice/
│ └── kata.go
├── First Missing Positive/
│ └── kata.go
├── First Unique Character in a String/
│ └── kata.go
├── Fix Names in a Table/
│ └── q.sql
├── Fix Product Name Format/
│ └── q.sql
├── Fizz Buzz/
│ └── kata.go
├── Flatten 2D Vector/
│ └── kata.go
├── Flatten Nested List Iterator/
│ └── kata.go
├── Flatten a Multilevel Doubly Linked List/
│ └── kata.go
├── Flipping an Image/
│ └── kata.go
├── Friendly Movies Streamed Last Month/
│ └── q.sql
├── Function Composition/
│ └── kata.ts
├── Game Play Analysis I/
│ └── q.sql
├── Generate a String With Characters That Have Odd Counts/
│ └── kata.go
├── Generate the Invoic/
│ └── q.sql
├── Get Maximum in Generated Array/
│ └── kata.go
├── Get the Size of a DataFrame/
│ └── kata.py
├── Goal Parser Interpretation/
│ └── kata.go
├── Goat Latin/
│ └── kata.java
├── Grand Slam Titles/
│ └── q.sql
├── Greatest English Letter in Upper and Lower Case/
│ └── kata.go
├── Group Anagrams/
│ └── kata.go
├── Group By/
│ └── kata.js
├── Group Sold Products By The Date/
│ └── q.sql
├── Group the People Given the Group Size They Belong To/
│ └── kata.go
├── H-Index/
│ └── kata.go
├── HTML Entity Parser/
│ └── kata.go
├── Hamming Distance/
│ └── kata.go
├── Happy Number/
│ └── kata.go
├── Harshad Number/
│ └── kata.go
├── Height Checker/
│ └── kata.go
├── High Five/
│ └── kata.go
├── How Many Apples Can You Put into the Basket/
│ └── kata.java
├── How Many Numbers Are Smaller Than the Current Number/
│ └── kata.go
├── Immediate Food Delivery I/
│ └── q.sql
├── Implement Magic Dictionary/
│ └── kata.go
├── Implement Queue using Stacks/
│ └── kata.go
├── Implement Stack using Queues/
│ └── kata.go
├── Implement Trie (Prefix Tree)/
│ └── kata.go
├── Implement strStr()/
│ └── kata.go
├── Increasing Order Search Tree/
│ └── kata.go
├── Index Pairs of a String/
│ └── kata.java
├── Insertion Sort List/
│ └── kata.go
├── Intersection of Multiple Arrays/
│ └── kata.go
├── Intersection of Three Sorted Arrays/
│ └── kata.go
├── Intersection of Two Arrays/
│ └── kata.go
├── Intersection of Two Arrays II/
│ └── kata.go
├── Intersection of Two Linked Lists/
│ └── kata.go
├── Invalid Tweets/
│ └── q.sql
├── Invert Binary Tree/
│ └── kata.go
├── Is Object Empty/
│ └── kata.js
├── Is Subsequence/
│ └── kata.go
├── Island Perimeter/
│ └── kata.go
├── Jewels and Stones/
│ └── kata.go
├── K Items With the Maximum Sum/
│ └── kata.go
├── K Radius Subarray Averages/
│ └── kata.go
├── Keep Multiplying Found Values by Two/
│ └── kata.go
├── Kids With the Greatest Number of Candies/
│ └── kata.go
├── Kth Distinct String in an Array/
│ └── kata.go
├── Kth Largest Element in a Stream/
│ └── kata.go
├── Kth Largest Element in an Array/
│ └── kata.go
├── Kth Missing Positive Number/
│ └── kata.go
├── Kth Smallest Element in a BST/
│ └── kata.go
├── LRU Cache/
│ └── kata.go
├── Largest 3-Same-Digit Number in String/
│ └── kata.go
├── Largest Number After Digit Swaps by Parity/
│ └── kata.go
├── Largest Number At Least Twice of Others/
│ └── kata.go
├── Largest Perimeter Triangle/
│ └── kata.go
├── Largest Positive Integer That Exists With Its Negative/
│ └── kata.java
├── Largest Subarray Length K/
│ └── kata.java
├── Largest Unique Number/
│ └── kata.go
├── Last Person to Fit in the Bus/
│ └── q.sql
├── Last Stone Weight/
│ └── kata.go
├── Latest Time by Replacing Hidden Digits/
│ └── kata.go
├── Leaf-Similar Trees/
│ └── kata.go
├── Least Number of Unique Integers after K Removals/
│ └── kata.java
├── Left and Right Sum Differences/
│ └── kata.java
├── Length of Last Word/
│ └── kata.go
├── Letter Case Permutation/
│ └── kata.go
├── Lexicographical Numbers/
│ └── kata.go
├── Linked List Cycle/
│ └── kata.go
├── List the Products Ordered in a Period/
│ └── q.sql
├── Longer Contiguous Segments of Ones than Zeros/
│ └── kata.go
├── Longest Common Prefix/
│ └── kata.go
├── Longest Consecutive Sequence/
│ └── kata.go
├── Longest Continuous Increasing Subsequence/
│ └── kata.go
├── Longest Strictly Increasing or Strictly Decreasing Subarray/
│ └── kata.go
├── Longest Subsequence With Limited Sum/
│ └── kata.java
├── Low-Quality Problems/
│ └── q.sql
├── Lucky Numbers in a Matrix/
│ └── kata.go
├── Majority Element/
│ └── kata.go
├── Majority Element II/
│ └── kata.go
├── Make Array Zero by Subtracting Equal Amounts/
│ └── kata.java
├── Make The String Great/
│ └── kata.go
├── Make Two Arrays Equal by Reversing Sub-arrays/
│ └── kata.go
├── Map Sum Pairs/
│ └── kata.go
├── Matrix Diagonal Sum/
│ └── kata.go
├── Max Consecutive Ones/
│ └── kata.go
├── Max Stack/
│ └── kata.go
├── Maximize Sum Of Array After K Negations/
│ └── kata.go
├── Maximum 69 Number/
│ └── kata.go
├── Maximum Ascending Subarray Sum/
│ └── kata.go
├── Maximum Average Subarray I /
│ └── kata.go
├── Maximum Count of Positive Integer and Negative Integer/
│ └── kata.java
├── Maximum Depth of Binary Tree/
│ └── kata.go
├── Maximum Difference Between Increasing Elements/
│ └── kata.java
├── Maximum Difference by Remapping a Digit/
│ └── kata.java
├── Maximum Frequency Stack/
│ └── kata.go
├── Maximum Nesting Depth of the Parentheses/
│ └── kata.java
├── Maximum Number of Balloons/
│ └── kata.go
├── Maximum Number of Balls in a Box/
│ └── kata.go
├── Maximum Number of Coins You Can Get/
│ └── kata.java
├── Maximum Number of Pairs in Array/
│ └── kata.go
├── Maximum Number of Words Found in Sentences/
│ └── kata.go
├── Maximum Number of Words You Can Type/
│ └── kata.go
├── Maximum Odd Binary Number/
│ └── kata.go
├── Maximum Product Difference Between Two Pairs/
│ └── kata.go
├── Maximum Product of Three Numbers/
│ └── kata.go
├── Maximum Product of Two Elements in an Array/
│ └── kata.go
├── Maximum Score After Splitting a String/
│ └── kata.go
├── Maximum Subarray/
│ └── kata.go
├── Maximum Sum Score of Array/
│ └── kata.go
├── Maximum Sum With Exactly K Elements/
│ └── kata.go
├── Maximum Twin Sum of a Linked List/
│ └── kata.go
├── Maximum Units on a Truck/
│ └── kata.java
├── Maximum Value after Insertion/
│ └── kata.go
├── Maximum Value of a String in an Array/
│ └── kata.java
├── Maximum XOR After Operations /
│ └── kata.java
├── Mean of Array After Removing Some Elements/
│ └── kata.go
├── Meeting Rooms/
│ └── kata.java
├── Merge In Between Linked Lists/
│ └── kata.go
├── Merge Nodes in Between Zeros/
│ └── kata.go
├── Merge Similar Items/
│ └── kata.java
├── Merge Strings Alternately/
│ └── kata.go
├── Merge Two 2D Arrays by Summing Values/
│ └── kata.go
├── Merge Two Sorted Lists/
│ └── kata.go
├── Merge k Sorted Lists/
│ └── kata.go
├── Method Chaining/
│ └── kata.py
├── Middle of the Linked List/
│ └── kata.go
├── Min Cost Climbing Stairs/
│ └── kata.go
├── Min Max Game/
│ └── kata.go
├── Min Stack/
│ └── kata.go
├── Minimize Maximum Pair Sum in Array/
│ └── kata.go
├── Minimize Product Sum of Two Arrays/
│ └── kata.go
├── Minimize String Length/
│ └── kata.go
├── Minimum Absolute Difference/
│ └── kata.go
├── Minimum Absolute Difference in BST/
│ └── kata.go
├── Minimum Add to Make Parentheses Valid/
│ └── kata.java
├── Minimum Average Difference/
│ └── kata.go
├── Minimum Bit Flips to Convert Number/
│ └── kata.go
├── Minimum Common Value/
│ └── kata.java
├── Minimum Cuts to Divide a Circle/
│ └── kata.java
├── Minimum Depth of Binary Tree/
│ └── kata.go
├── Minimum Distance to the Target Element/
│ └── kata.go
├── Minimum Increment to Make Array Unique/
│ └── kata.go
├── Minimum Moves to Convert String/
│ └── kata.go
├── Minimum Number Game/
│ └── kata.go
├── Minimum Number of Steps to Make Two Strings Anagram II/
│ └── kata.go
├── Minimum Operations to Collect Elements/
│ └── kata.go
├── Minimum Operations to Exceed Threshold Value I/
│ └── kata.go
├── Minimum Operations to Make the Array Increasing/
│ └── kata.go
├── Minimum Recolors to Get K Consecutive Black Blocks/
│ └── kata.java
├── Minimum String Length After Removing Substrings/
│ └── kata.go
├── Minimum Subsequence in Non-Increasing Order/
│ └── kata.java
├── Minimum Sum of Four Digit Number After Splitting Digits/
│ └── kata.go
├── Minimum Value to Get Positive Step by Step Sum/
│ └── kata.java
├── Missing Number/
│ └── kata.go
├── Missing Ranges/
│ └── kata.java
├── Modify Columns/
│ └── kata.py
├── Modify the Matrix/
│ └── kata.go
├── Monotonic Array/
│ └── kata.go
├── Monthly Transactions I/
│ └── q.sql
├── Most Common Word/
│ └── kata.go
├── Most Frequent Even Element/
│ └── kata.go
├── Most Frequent Number Following Key In an Array/
│ └── kata.go
├── Move Zeroes/
│ └── kata.go
├── Moving Average from Data Stream/
│ └── kata.go
├── Multiply Strings/
│ └── kata.go
├── My Calendar I/
│ └── kata.go
├── N-Repeated Element in Size 2N Array/
│ └── kata.go
├── N-th Tribonacci Number/
│ └── kata.go
├── NPV Queries/
│ └── q.sql
├── Neither Minimum nor Maximum/
│ └── kata.go
├── Nested List Weight Sum/
│ └── kata.go
├── New Users Daily Count/
│ └── q.sql
├── Next Greater Element I/
│ └── kata.go
├── Not Boring Movies/
│ └── kata.sql
├── Nth Highest Salary/
│ └── kata.sql
├── Number Complement/
│ └── kata.go
├── Number Of Rectangles That Can Form The Largest Square/
│ └── kata.java
├── Number of 1 Bits/
│ └── kata.go
├── Number of Arithmetic Triplets/
│ └── kata.java
├── Number of Days Between Two Dates/
│ └── kata.go
├── Number of Days in a Month/
│ └── kata.java
├── Number of Different Integers in a String/
│ └── kata.go
├── Number of Distinct Averages/
│ └── kata.java
├── Number of Employees Who Met the Target/
│ └── kata.go
├── Number of Equivalent Domino Pairs/
│ └── kata.go
├── Number of Even and Odd Bits/
│ └── kata.go
├── Number of Good Pairs/
│ └── kata.go
├── Number of Laser Beams in a Bank/
│ └── kata.go
├── Number of Lines To Write String/
│ └── kata.java
├── Number of Recent Calls/
│ └── kata.go
├── Number of Segments in a String/
│ └── kata.go
├── Number of Senior Citizens/
│ └── kata.go
├── Number of Steps to Reduce a Number to Zero/
│ └── kata.go
├── Number of Strings That Appear as Substrings in Word/
│ └── kata.java
├── Number of Students Doing Homework at a Given Time/
│ └── kata.go
├── Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold/
│ └── kata.java
├── Number of Unique Subjects Taught by Each Teacher/
│ └── k.sql
├── Number of Visible People in a Queue/
│ └── kata.go
├── Occurrences After Bigram/
│ └── kata.go
├── One Edit Distance/
│ └── kata.go
├── Online Stock Span/
│ └── kata.go
├── Orders With Maximum Quantity Above Average/
│ └── q.sql
├── Palindrome Linked List/
│ └── kata.go
├── Palindrome Number/
│ └── kata.go
├── Parsing A Boolean Expression/
│ └── kata.go
├── Partition Array According to Given Pivot/
│ └── kata.go
├── Partitioning Into Minimum Number Of Deci-Binary Numbers/
│ └── kata.java
├── Pascal's Triangle/
│ └── kata.go
├── Pascal's Triangle II/
│ └── kata.go
├── Path Sum/
│ └── kata.go
├── Patients With a Condition/
│ └── q.sql
├── Peak Index in a Mountain Array/
│ └── kata.go
├── Peeking Iterator/
│ └── kata.go
├── Percentage of Letter in String/
│ └── kata.go
├── Percentage of Users Attended a Contest/
│ └── q.sql
├── Perfect Number/
│ └── kata.go
├── Perform String Shifts/
│ └── kata.go
├── Permutations/
│ └── kata.go
├── Permutations II/
│ └── kata.go
├── Plus One/
│ └── kata.go
├── Points That Intersect With Cars/
│ └── kata.go
├── Populating Next Right Pointers in Each Node/
│ └── kata.go
├── Positions of Large Groups/
│ └── kata.go
├── Power of Four/
│ └── kata.go
├── Power of Three/
│ └── kata.go
├── Power of Two/
│ └── kata.go
├── Powerful Integers/
│ └── kata.go
├── Prefix and Suffix Search/
│ └── kata.go
├── Primary Department for Each Employee/
│ └── q.sql
├── Prime Number of Set Bits in Binary Representation/
│ └── kata.java
├── Print Immutable Linked List in Reverse/
│ └── kata.go
├── Product Sales Analysis I/
│ └── q.sql
├── Product Sales Analysis II/
│ └── q.sql
├── Product of Array Except Self/
│ └── kata.go
├── Product of the Last K Numbers/
│ └── kata.go
├── Product's Price for Each Store/
│ └── q.sql
├── Product's Worth Over Invoices/
│ └── q.sql
├── Project Employees I/
│ └── q.sql
├── Queries Quality and Percentage/
│ └── q.sql
├── Queries on Number of Points Inside a Circle/
│ └── kata.java
├── Queries on a Permutation With Key/
│ └── kata.go
├── README.md
├── Random Pick Index/
│ └── kata.go
├── Range Sum Query - Immutable/
│ └── kata.go
├── Range Sum Query - Mutable/
│ └── kata.go
├── Range Sum Query 2D - Immutable/
│ └── kata.go
├── Range Sum of BST/
│ └── kata.go
├── Rank Scores/
│ └── kata.sql
├── Rank Transform of an Array/
│ └── kata.go
├── Ransom Note/
│ └── kata.go
├── Rearrange Array Elements by Sign/
│ └── kata.go
├── Rearrange Characters to Make Target String/
│ └── kata.go
├── Rearrange Products Table/
│ └── q.sql
├── Rearrange Spaces Between Words/
│ └── kata.go
├── Rearrange Words in a Sentence/
│ └── kata.go
├── Recyclable and Low Fat Products/
│ └── q.sql
├── Redistribute Characters to Make All Strings Equal/
│ └── kata.go
├── Reduce Array Size to The Half/
│ └── kata.go
├── Reformat Department Table/
│ └── q.sql
├── Relative Ranks/
│ └── kata.go
├── Remove All Adjacent Duplicates In String/
│ └── kata.java
├── Remove Colored Pieces if Both Neighbors are the Same Color/
│ └── kata.go
├── Remove Duplicates from Sorted List/
│ └── kata.go
├── Remove Duplicates from Sorted List II/
│ └── kata.go
├── Remove Element/
│ └── kata.go
├── Remove Linked List Elements/
│ └── kata.go
├── Remove Nth Node From End of List/
│ └── kata.go
├── Remove Stones to Minimize the Total/
│ └── kata.go
├── Remove Trailing Zeros From a String/
│ └── kata.go
├── Remove Vowels from a String/
│ └── kata.go
├── Removing Minimum and Maximum From Array/
│ └── kata.java
├── Removing Stars From a String/
│ └── kata.java
├── Rename Columns/
│ └── kata.py
├── Replace All 's to Avoid Consecutive Repeating Characters/
│ └── kata.go
├── Replace All Digits with Characters/
│ └── kata.go
├── Replace Employee ID With The Unique Identifier/
│ └── query.sql
├── Reshape Data: Concatenate/
│ └── kata.py
├── Reshape Data: Melt/
│ └── kata.py
├── Reshape Data: Pivot/
│ └── kata.py
├── Reshape the Matrix/
│ └── kata.go
├── Return Length of Arguments Passed/
│ └── kata.js
├── Reverse Integer/
│ └── kata.go
├── Reverse Linked List/
│ └── kata.go
├── Reverse Prefix of Word/
│ └── kata.go
├── Reverse String/
│ └── kata.go
├── Reverse Vowels of a String/
│ └── kata.go
├── Reverse Words in a String/
│ └── kata.go
├── Reverse Words in a String III/
│ └── kata.go
├── Richest Customer Wealth/
│ └── kata.go
├── Rings and Rods/
│ └── kata.go
├── Roman to Integer/
│ └── kata.go
├── Root Equals Sum of Children/
│ └── kata.go
├── Rotate Array/
│ └── kata.go
├── Rotate String/
│ └── kata.go
├── Row With Maximum Ones/
│ └── kata.go
├── Running Sum of 1d Array/
│ └── kata.go
├── Running Total for Different Genders/
│ └── q.sql
├── Sales Analysis I/
│ └── q.sql
├── Sales Person/
│ └── q.sql
├── Sales by Day of the Week/
│ └── q.sql
├── Same Tree/
│ └── kata.go
├── Score of a String/
│ └── kata.go
├── Search Insert Position/
│ └── kata.go
├── Search a 2D Matrix/
│ └── kata.go
├── Search a 2D Matrix II/
│ └── kata.go
├── Search in Rotated Sorted Array II/
│ └── kata.go
├── Search in a Binary Search Tree/
│ └── kata.go
├── Seat Reservation Manager/
│ └── kata.go
├── Second Highest Salary/
│ └── kata.sql
├── Second Largest Digit in a String/
│ └── kata.go
├── Second Minimum Node In a Binary Tree/
│ └── kata.go
├── Select Data/
│ └── kata.py
├── Self Dividing Numbers/
│ └── kata.go
├── Sellers With No Sales/
│ └── q.sql
├── Separate the Digits in an Array/
│ └── kata.java
├── Set Mismatch/
│ └── kata.go
├── Shift 2D Grid/
│ └── kata.go
├── Shortest Distance in a Line/
│ └── q.sql
├── Shortest Distance to a Character/
│ └── kata.go
├── Shortest Word Distance/
│ └── kata.go
├── Shortest Word Distance II/
│ └── kata.go
├── Shuffle String/
│ └── kata.go
├── Shuffle the Array/
│ └── kata.go
├── Sign of the Product of an Array/
│ └── kata.go
├── Simple Bank System/
│ └── kata.go
├── Single Element in a Sorted Array/
│ └── kata.go
├── Single Number/
│ └── kata.go
├── Single-Row Keyboard/
│ └── kata.go
├── Sliding Window Maximum/
│ └── kata.go
├── Sliding Window Median/
│ └── kata.go
├── Smallest Even Multiple/
│ └── kata.go
├── Smallest Index With Equal Value/
│ └── kata.go
├── Smallest Range I/
│ └── kata.go
├── Sort Array By Parity/
│ └── kata.go
├── Sort Array by Increasing Frequency/
│ └── kata.go
├── Sort Characters By Frequency/
│ └── kata.go
├── Sort Integers by The Number of 1 Bits/
│ └── kata.go
├── Sort Integers by The Power Value/
│ └── kata.go
├── Sort the Olympic Table/
│ └── q.sql
├── Sort the People/
│ └── kata.go
├── Sorting the Sentence/
│ └── kata.go
├── Split With Minimum Sum/
│ └── kata.go
├── Split a String in Balanced Strings/
│ └── kata.go
├── Split the Array/
│ └── kata.go
├── Sqrt(x)/
│ └── kata.go
├── Squares of a Sorted Array/
│ └── kata.go
├── Strong Password Checker II/
│ └── kata.go
├── Student Attendance Record I/
│ └── kata.go
├── Subdomain Visit Count/
│ └── kata.go
├── Subrectangle Queries/
│ └── kata.go
├── Substrings of Size Three with Distinct Characters/
│ └── kata.java
├── Subtract the Product and Sum of Digits of an Integer/
│ └── kata.go
├── Subtree of Another Tree/
│ └── kata.go
├── Sum Multiples/
│ └── kata.go
├── Sum Root to Leaf Numbers/
│ └── kata.go
├── Sum in a Matrix/
│ └── kata.go
├── Sum of Digits in Base K/
│ └── kata.go
├── Sum of Digits in the Minimum Number/
│ └── kata.go
├── Sum of Digits of String After Convert/
│ └── kata.go
├── Sum of Even Numbers After Queries/
│ └── kata.java
├── Sum of Left Leaves/
│ └── kata.go
├── Sum of Squares of Special Elements/
│ └── kata.go
├── Sum of Unique Elements/
│ └── kata.go
├── Sum of Values at Indices With K Set Bits/
│ └── kata.go
├── Summary Ranges/
│ └── kata.go
├── Swap Nodes in Pairs/
│ └── kata.go
├── Swap Salary/
│ └── kata.sql
├── Symmetric Tree/
│ └── kata.java
├── Take Gifts From the Richest Pile/
│ └── kata.java
├── Tasks Count in the Weekend/
│ └── q.sql
├── The Airport With the Most Traffic/
│ └── q.sql
├── The Employee That Worked on the Longest Task/
│ └── kata.java
├── The K Weakest Rows in a Matrix/
│ └── kata.go
├── The Latest Login in 2020/
│ └── q.sql
├── The Number of Employees Which Report to Each Employee/
│ └── q.sql
├── The Number of Rich Customers/
│ └── q.sql
├── The Number of Users That Are Eligible for Discount/
│ └── q.sql
├── The Users That Are Eligible for Discount/
│ └── q.sql
├── The Winner University/
│ └── q.sql
├── Third Maximum Number/
│ └── kata.go
├── Thousand Separator/
│ └── kata.go
├── Three Consecutive Odds/
│ └── kata.go
├── Time Based Key-Value Store/
│ └── kata.go
├── To Be Or Not To Be/
│ └── kata.ts
├── To Lower Case/
│ └── kata.go
├── Toeplitz Matrix/
│ └── kata.go
├── Top K Frequent Elements/
│ └── kata.go
├── Top K Frequent Words/
│ └── kata.go
├── Top Travellers/
│ └── q.sql
├── Transpose Matrix/
│ └── kata.go
├── Triangle Judgement/
│ └── kata.sql
├── Truncate Sentence/
│ └── kata.go
├── Two Furthest Houses With Different Colors/
│ └── kata.go
├── Two Out of Three/
│ └── kata.go
├── Two Sum/
│ └── kata.py
├── Ugly Number/
│ └── kata.go
├── Uncommon Words from Two Sentences/
│ └── kata.go
├── Unique Morse Code Words/
│ └── kata.go
├── Unique Number of Occurrences/
│ └── kata.go
├── Unique Orders and Customers Per Month/
│ └── q.sql
├── Univalued Binary Tree/
│ └── kata.go
├── Valid Anagram/
│ └── kata.go
├── Valid Mountain Array/
│ └── kata.go
├── Valid Palindrome/
│ └── kata.go
├── Valid Palindrome II/
│ └── kata.go
├── Valid Parentheses/
│ └── kata.go
├── Validate Binary Search Tree/
│ └── kata.go
├── Warehouse Manager/
│ └── q.sql
├── Water Bottles/
│ └── kata.go
├── Weather Type in Each Country/
│ └── q.sql
├── Widest Vertical Area Between Two Points Containing No Points/
│ └── kata.java
├── Word Pattern/
│ └── kata.go
└── XOR Operation in an Array/
└── kata.go
SYMBOL INDEX (1049 symbols across 588 files)
FILE: Day of the Week/kata.py
class Solution (line 2) | class Solution:
method dayOfTheWeek (line 3) | def dayOfTheWeek(self, d: int, m: int, y: int) -> str:
FILE: 3042. Count Prefix and Suffix Pairs I/kata.py
class Solution (line 3) | class Solution:
method countPrefixSuffixPairs (line 4) | def countPrefixSuffixPairs(self, words: List[str]) -> int:
method isPrefixAndSuffix (line 12) | def isPrefixAndSuffix(self, a: str, b :str) -> bool:
FILE: A Number After a Double Reversal/kata.go
function isSameAfterReversals (line 3) | func isSameAfterReversals(num int) bool {
FILE: Account Balance After Rounded Purchase/kata.go
function accountBalanceAfterPurchase (line 3) | func accountBalanceAfterPurchase(purchaseAmount int) int {
FILE: Accounts Merge/kata.go
function accountsMerge (line 5) | func accountsMerge(accounts [][]string) [][]string {
function merge (line 27) | func merge(accounts [][]string, toDelete map[int]bool) bool {
function emailUnion (line 48) | func emailUnion(a []string, startIdx int) []string {
FILE: Add Binary/kata.go
function addBinary (line 3) | func addBinary(a string, b string) string {
FILE: Add Digits/kata.go
function addDigits (line 3) | func addDigits(num int) int {
function sumFunc (line 16) | func sumFunc(num int) (int, int) {
FILE: Add One Row to Tree/kata.go
type TreeNode (line 3) | type TreeNode struct
function addOneRow (line 9) | func addOneRow(root *TreeNode, v int, d int) *TreeNode {
function add (line 17) | func add(node *TreeNode, count, v, d int) {
FILE: Add Strings/kata.go
function addStrings (line 3) | func addStrings(num1 string, num2 string) string {
function sumFunc (line 14) | func sumFunc(num1, num2 string) string {
function padding (line 39) | func padding(num2, num1 string) string {
FILE: Add Two Integers/kata.go
function sum (line 3) | func sum(num1 int, num2 int) int {
FILE: Adding Spaces to a String/kata.go
function addSpaces (line 3) | func addSpaces(s string, spaces []int) string {
FILE: All Elements in Two Binary Search Trees/kata.go
type TreeNode (line 5) | type TreeNode struct
function getAllElements (line 11) | func getAllElements(root1 *TreeNode, root2 *TreeNode) []int {
function inorder (line 21) | func inorder(node *TreeNode, list *[]int) {
FILE: Allow One Function Call/kata.ts
type JSONValue (line 1) | type JSONValue = null | boolean | number | string | JSONValue[] | { [key...
type OnceFn (line 2) | type OnceFn = (...args: JSONValue[]) => JSONValue | undefined
function once (line 4) | function once(fn: Function): OnceFn {
FILE: Alternating Digit Sum/kata.java
class Solution (line 1) | class Solution {
method alternateDigitSum (line 2) | public int alternateDigitSum(int n) {
FILE: Ant on the Boundary/kata.go
function returnToBoundaryCount (line 1) | func returnToBoundaryCount(nums []int) int {
FILE: Apple Redistribution into Boxes/kata.go
function minimumBoxes (line 5) | func minimumBoxes(apple []int, capacity []int) int {
FILE: Apply Discount Every n Orders/kata.go
type Cashier (line 3) | type Cashier struct
method GetBill (line 23) | func (this *Cashier) GetBill(product []int, amount []int) float64 {
function Constructor (line 10) | func Constructor(n int, discount int, products []int, prices []int) Cash...
FILE: Apply Transform Over Each Element in Array/kata.ts
function map (line 1) | function map(arr: number[], fn: (n: number, i: number) => number): numbe...
FILE: Armstrong Number/kata.go
function isArmstrong (line 5) | func isArmstrong(n int) bool {
FILE: Arranging Coins/kata.go
function arrangeCoins (line 3) | func arrangeCoins(n int) int {
FILE: Array Partition I/kata.go
function arrayPairSum (line 5) | func arrayPairSum(a []int) int {
FILE: Array Reduce Transformation/kata.ts
type Fn (line 1) | type Fn = (accum: number, curr: number) => number
function reduce (line 3) | function reduce(nums: number[], fn: Fn, init: number): number {
FILE: Array Wrapper/kata.ts
class ArrayWrapper (line 1) | class ArrayWrapper {
method constructor (line 5) | constructor(nums: number[]) {
method valueOf (line 9) | valueOf(): number {
method toString (line 17) | toString(): string {
FILE: Assign Cookies/kata.go
function findContentChildren (line 5) | func findContentChildren(g []int, s []int) int {
FILE: Average Salary Excluding the Minimum and Maximum Salary/kata.go
function average (line 5) | func average(salary []int) float64 {
FILE: Average Value of Even Numbers That Are Divisible by Three/kata.java
class Solution (line 1) | class Solution {
method averageValue (line 2) | public int averageValue(int[] nums) {
FILE: Average of Levels in Binary Tree/kata.go
type TreeNode (line 5) | type TreeNode struct
function averageOfLevels (line 11) | func averageOfLevels(node *TreeNode) []float64 {
FILE: Backspace String Compare/kata.go
function backspaceCompare (line 3) | func backspaceCompare(S string, T string) bool {
function mod (line 7) | func mod(S string) string {
FILE: Base 7/kata.go
function convertToBase7 (line 3) | func convertToBase7(num int) string {
FILE: Baseball Game/kata.go
function calPoints (line 5) | func calPoints(ops []string) int {
FILE: Basic Calculator II/kata.go
function calculate (line 7) | func calculate(s string) int {
constant NumberKind (line 13) | NumberKind = iota
constant PlusKind (line 14) | PlusKind
constant MinusKind (line 15) | MinusKind
constant MultiplyKind (line 16) | MultiplyKind
constant DvisionKind (line 17) | DvisionKind
type Node (line 20) | type Node struct
constant Multiply (line 28) | Multiply byte = 42
constant Dvision (line 29) | Dvision byte = 47
constant Plus (line 30) | Plus byte = 43
constant Minus (line 31) | Minus byte = 45
function Parse (line 34) | func Parse(expression []byte) *list.List {
function Eval (line 70) | func Eval(nodes *list.List) int {
FILE: Best Poker Hand/kata.go
function bestHand (line 3) | func bestHand(ranks []int, suits []byte) string {
FILE: Best Time to Buy and Sell Stock/kata.go
function maxProfit (line 3) | func maxProfit(prices []int) int {
FILE: Binary Gap/kata.go
function binaryGap (line 3) | func binaryGap(n int) int {
FILE: Binary Number with Alternating Bits/kata.go
function hasAlternatingBits (line 3) | func hasAlternatingBits(n int) bool {
FILE: Binary Prefix Divisible By 5/kata.py
class Solution (line 1) | class Solution(object):
method prefixesDivBy5 (line 2) | def prefixesDivBy5(self, nums):
FILE: Binary Search Tree Iterator/kata.go
type TreeNode (line 5) | type TreeNode struct
type BSTIterator (line 11) | type BSTIterator struct
method Next (line 42) | func (this *BSTIterator) Next() int {
method HasNext (line 49) | func (this *BSTIterator) HasNext() bool {
function Constructor (line 15) | func Constructor(root *TreeNode) BSTIterator {
function populateStack (line 26) | func populateStack(node *TreeNode, stack *[]int) {
FILE: Binary Tree Inorder Traversal/kata.go
type TreeNode (line 3) | type TreeNode struct
function inorderTraversal (line 9) | func inorderTraversal(root *TreeNode) []int {
function traversal (line 15) | func traversal(node *TreeNode, list *[]int) {
FILE: Binary Tree Paths/kata.go
type TreeNode (line 5) | type TreeNode struct
function binaryTreePaths (line 11) | func binaryTreePaths(root *TreeNode) []string {
function allPaths (line 20) | func allPaths(node *TreeNode, s string, all *[]string) {
FILE: Binary Tree Postorder Traversal/kata.go
type TreeNode (line 3) | type TreeNode struct
function postorderTraversal (line 9) | func postorderTraversal(root *TreeNode) []int {
function traversal (line 15) | func traversal(node *TreeNode, list *[]int) {
FILE: Binary Tree Preorder Traversal/kata.go
type TreeNode (line 3) | type TreeNode struct
function preorderTraversal (line 9) | func preorderTraversal(root *TreeNode) []int {
function traversal (line 15) | func traversal(node *TreeNode, list *[]int) {
FILE: Build Array from Permutation/kata.go
function buildArray (line 3) | func buildArray(nums []int) []int {
FILE: Buildings With an Ocean View/kata.java
class Solution (line 1) | class Solution {
method findBuildings (line 2) | public int[] findBuildings(int[] heights) {
FILE: Bulls and Cows/kata.go
function getHint (line 5) | func getHint(secret string, guess string) string {
FILE: Calculate Amount Paid in Taxes/kata.go
function calculateTax (line 3) | func calculateTax(brackets [][]int, income int) float64 {
FILE: Calculate Money in Leetcode Bank/kata.go
function totalMoney (line 3) | func totalMoney(n int) int {
FILE: Calculator with Method Chaining/kata.js
class Calculator (line 1) | class Calculator {
method constructor (line 6) | constructor(value) {
method add (line 15) | add(value){
method subtract (line 24) | subtract(value){
method multiply (line 33) | multiply(value) {
method divide (line 42) | divide(value) {
method power (line 56) | power(value) {
method getResult (line 64) | getResult() {
FILE: Can Make Arithmetic Progression From Sequence/kata.go
function canMakeArithmeticProgression (line 5) | func canMakeArithmeticProgression(arr []int) bool {
FILE: Can Place Flowers/kata.go
function canPlaceFlowers (line 3) | func canPlaceFlowers(flowerbed []int, n int) bool {
FILE: Capitalize the Title/kata.go
function capitalizeTitle (line 3) | func capitalizeTitle(title string) string {
FILE: Categorize Box According to Criteria/kata.java
class Solution (line 1) | class Solution {
method categorizeBox (line 2) | public String categorizeBox(int length, int width, int height, int mas...
FILE: Cells with Odd Values in a Matrix/kata.go
function oddCells (line 3) | func oddCells(n int, m int, indices [][]int) int {
FILE: Change Data Type/kata.py
function changeDatatype (line 3) | def changeDatatype(students: pd.DataFrame) -> pd.DataFrame:
FILE: Check Distances Between Same Letters/kata.java
class Solution (line 1) | class Solution {
method checkDistances (line 2) | public boolean checkDistances(String s, int[] distance) {
FILE: Check If All 1's Are at Least Length K Places Away/kata.go
function kLengthApart (line 3) | func kLengthApart(nums []int, k int) bool {
FILE: Check If N and Its Double Exist/kata.go
function checkIfExist (line 3) | func checkIfExist(arr []int) bool {
FILE: Check If Two String Arrays are Equivalent/kata.go
function arrayStringsAreEqual (line 3) | func arrayStringsAreEqual(word1 []string, word2 []string) bool {
FILE: Check If a Number Is Majority Element in a Sorted Array/kata.java
class Solution (line 1) | class Solution {
method isMajorityElement (line 2) | public boolean isMajorityElement(int[] nums, int target) {
FILE: Check If a Word Occurs As a Prefix of Any Word in a Sentence/kata.go
function isPrefixOfWord (line 3) | func isPrefixOfWord(sentence string, searchWord string) int {
FILE: Check Whether Two Strings are Almost Equivalent/kata.go
function checkAlmostEquivalent (line 5) | func checkAlmostEquivalent(word1 string, word2 string) bool {
FILE: Check if All A's Appears Before All B's/kata.go
function checkString (line 3) | func checkString(s string) bool {
FILE: Check if All Characters Have Equal Number of Occurrences/kata.go
function areOccurrencesEqual (line 5) | func areOccurrencesEqual(s string) bool {
FILE: Check if Binary String Has at Most One Segment of Ones/kata.go
function checkOnesSegment (line 3) | func checkOnesSegment(s string) bool {
FILE: Check if Bitwise OR Has Trailing Zeros/kata.go
function hasTrailingZeros (line 3) | func hasTrailingZeros(nums []int) bool {
FILE: Check if Number Has Equal Digit Count and Digit Value/kata.go
function digitCount (line 3) | func digitCount(num string) bool {
FILE: Check if Numbers Are Ascending in a Sentence/kata.go
function areNumbersAscending (line 5) | func areNumbersAscending(s string) bool {
FILE: Check if One String Swap Can Make Strings Equal/kata.go
function areAlmostEqual (line 3) | func areAlmostEqual(s1 string, s2 string) bool {
FILE: Check if The Number is Fascinating/kata.go
function isFascinating (line 3) | func isFascinating(n int) bool {
function countDigits (line 15) | func countDigits(n int, stats *[9]int, tracker *int) bool {
FILE: Check if Word Equals Summation of Two Words/kata.go
function isSumEqual (line 3) | func isSumEqual(firstWord string, secondWord string, targetWord string) ...
function sum (line 7) | func sum(s string) int {
FILE: Check if an Array Is Consecutive/kata.go
function isConsecutive (line 5) | func isConsecutive(nums []int) bool {
FILE: Check if the Sentence Is Pangram/kata.go
function checkIfPangram (line 3) | func checkIfPangram(sentence string) bool {
FILE: Climbing Stairs/kata.go
function climbStairs (line 3) | func climbStairs(n int) int {
FILE: Compare Strings by Frequency of the Smallest Character/kata.go
function numSmallerByFrequency (line 5) | func numSmallerByFrequency(queries []string, words []string) []int {
function f (line 27) | func f(s []byte) int {
FILE: Complement of Base 10 Integer/kata.go
function bitwiseComplement (line 5) | func bitwiseComplement(N int) int {
FILE: Concatenation of Array/kata.go
function getConcatenation (line 3) | func getConcatenation(nums []int) []int {
FILE: Confusing Number/kata.java
class Solution (line 1) | class Solution {
method confusingNumber (line 2) | public boolean confusingNumber(int num) {
FILE: Consecutive Characters/kata.go
function maxPower (line 5) | func maxPower(s string) int {
FILE: Construct Binary Search Tree from Preorder Traversal/kata.go
function bstFromPreorder (line 11) | func bstFromPreorder(preorder []int) *TreeNode {
function build (line 24) | func build(node *TreeNode, v int) {
FILE: Construct String from Binary Tree/kata.java
class Solution (line 16) | class Solution {
method tree2str (line 17) | public String tree2str(TreeNode root) {
method generatePattern (line 22) | private void generatePattern(TreeNode node, StringBuilder pattern) {
FILE: Construct the Rectangle/kata.go
function constructRectangle (line 5) | func constructRectangle(area int) []int {
FILE: Contains Duplicate II/kata.go
function containsNearbyDuplicate (line 3) | func containsNearbyDuplicate(nums []int, k int) bool {
FILE: Contains Duplicate/kata.go
function containsDuplicate (line 3) | func containsDuplicate(nums []int) bool {
FILE: Convert 1D Array Into 2D Array/kata.go
function construct2DArray (line 3) | func construct2DArray(original []int, m int, n int) [][]int {
FILE: Convert Binary Number in a Linked List to Integer/kata.go
type NodeBacklink (line 11) | type NodeBacklink struct
function getDecimalValue (line 16) | func getDecimalValue(head *ListNode) int {
FILE: Convert Integer to the Sum of Two No-Zero Integers/kata.go
function getNoZeroIntegers (line 3) | func getNoZeroIntegers(n int) []int {
function hasZeros (line 16) | func hasZeros(num int) bool {
FILE: Convert a Number to Hexadecimal/kata.go
function toHex (line 5) | func toHex(num int) string {
FILE: Convert the Temperature/kata.java
class Solution (line 1) | class Solution {
method convertTemperature (line 2) | public double[] convertTemperature(double celsius) {
FILE: Count Asterisks/kata.java
class Solution (line 1) | class Solution {
method countAsterisks (line 2) | public int countAsterisks(String s) {
FILE: Count Common Words With One Occurrence/kata.go
function countWords (line 3) | func countWords(words1 []string, words2 []string) int {
FILE: Count Complete Tree Nodes/kata.go
function countNodes (line 11) | func countNodes(root *TreeNode) int {
function count (line 21) | func count(node *TreeNode, c *int) {
FILE: Count Elements With Maximum Frequency/kata.go
function maxFrequencyElements (line 3) | func maxFrequencyElements(nums []int) int {
FILE: Count Elements With Strictly Smaller and Greater Elements/kata.go
function countElements (line 5) | func countElements(nums []int) int {
FILE: Count Integers With Even Digit Sum/kata.go
function countEven (line 5) | func countEven(num int) int {
FILE: Count Items Matching a Rule/kata.go
function countMatches (line 3) | func countMatches(items [][]string, ruleKey string, ruleValue string) int {
FILE: Count Largest Group/kata.java
class Solution (line 1) | class Solution {
method countLargestGroup (line 2) | public int countLargestGroup(int n) {
FILE: Count Negative Numbers in a Sorted Matrix/kata.rs
method count_negatives (line 4) | pub fn count_negatives(grid: Vec<Vec<i32>>) -> i32 {
FILE: Count Odd Numbers in an Interval Range/kata.go
function countOdds (line 3) | func countOdds(low int, high int) int {
FILE: Count Operations to Obtain Zero/kata.go
function countOperations (line 3) | func countOperations(num1 int, num2 int) int {
function max (line 26) | func max(a, b int) int {
function min (line 33) | func min(a, b int) int {
FILE: Count Prefixes of a Given String/kata.go
function countPrefixes (line 3) | func countPrefixes(words []string, s string) int {
FILE: Count Substrings Starting and Ending with Given Character/kata.py
class Solution (line 3) | class Solution(object):
method countSubstrings (line 4) | def countSubstrings(self, s, c):
FILE: Count Tested Devices After Test Operations/kata.go
function countTestedDevices (line 3) | func countTestedDevices(batteryPercentages []int) int {
FILE: Count Total Number of Colored Cells/kata.go
function coloredCells (line 3) | func coloredCells(n int) int64 {
FILE: Count of Matches in Tournament/kata.go
function numberOfMatches (line 3) | func numberOfMatches(n int) int {
FILE: Count the Digits That Divide a Number/kata.java
class Solution (line 1) | class Solution {
method countDigits (line 2) | public int countDigits(int num) {
FILE: Count the Number of Consistent Strings/kata.go
function countConsistentStrings (line 3) | func countConsistentStrings(allowed string, words []string) int {
FILE: Counter II/kata.ts
type Counter (line 1) | type Counter = {
function createCounter (line 7) | function createCounter(init: number): Counter {
class counter (line 11) | class counter implements Counter {
method constructor (line 15) | public constructor(init: number) {
method increment (line 20) | public increment() :number {
method decrement (line 25) | public decrement() :number {
method reset (line 30) | public reset() :number {
FILE: Counter/kata.ts
function createCounter (line 1) | function createCounter(n: number): () => number {
FILE: Counting Bits/kata.go
function countBits (line 3) | func countBits(n int) []int {
FILE: Counting Elements/kata.go
function countElements (line 5) | func countElements(arr []int) int {
FILE: Counting Words With a Given Prefix/kata.go
function prefixCount (line 3) | func prefixCount(words []string, pref string) int {
FILE: Cousins in Binary Tree/kata.go
type TreeNodeWrapper (line 14) | type TreeNodeWrapper struct
type check (line 20) | type check struct
function isCousins (line 25) | func isCousins(node *TreeNode, x int, y int) bool {
FILE: Create Hello World Function/kata.ts
function createHelloWorld (line 1) | function createHelloWorld() {
FILE: Create Target Array in the Given Order/kata.go
function createTargetArray (line 3) | func createTargetArray(nums []int, index []int) []int {
FILE: Create a DataFrame from List/kata.py
function createDataframe (line 3) | def createDataframe(student_data: List[List[int]]) -> pd.DataFrame:
FILE: Create a New Column/kata.py
function createBonusColumn (line 3) | def createBonusColumn(employees: pd.DataFrame) -> pd.DataFrame:
FILE: Custom Sort String/kata.go
function customSortString (line 5) | func customSortString(S string, T string) string {
FILE: DI String Match/kata.go
function diStringMatch (line 3) | func diStringMatch(S string) []int {
FILE: Day of the Year/kata.go
function dayOfYear (line 7) | func dayOfYear(date string) int {
FILE: Decode XORed Array/kata.go
function decode (line 3) | func decode(encoded []int, first int) []int {
FILE: Decode the Message/kata.go
function decodeMessage (line 3) | func decodeMessage(key string, message string) string {
FILE: Decompress Run-Length Encoded List/kata.go
function decompressRLElist (line 3) | func decompressRLElist(nums []int) []int {
FILE: Decrypt String from Alphabet to Integer Mapping/kata.go
function freqAlphabets (line 3) | func freqAlphabets(s string) string {
FILE: Deepest Leaves Sum/kata.go
function deepestLeavesSum (line 11) | func deepestLeavesSum(root *TreeNode) int {
function sum (line 18) | func sum(node *TreeNode, maxHeight int, currentHeight int) int {
function getHeight (line 38) | func getHeight(node *TreeNode, h int) int {
FILE: Defanging an IP Address/kata.go
function defangIPaddr (line 3) | func defangIPaddr(address string) string {
FILE: Delete Characters to Make Fancy String/kata.go
function makeFancyString (line 3) | func makeFancyString(s string) string {
FILE: Delete Greatest Value in Each Row/kata.go
function deleteGreatestValue (line 5) | func deleteGreatestValue(grid [][]int) int {
FILE: Delete Leaves With a Given Value/kata.go
function removeLeafNodes (line 11) | func removeLeafNodes(root *TreeNode, target int) *TreeNode {
type NodeType (line 23) | type NodeType
constant RootNodeType (line 26) | RootNodeType NodeType = 0
constant LeftNodeType (line 27) | LeftNodeType NodeType = 1
constant RightNodeType (line 28) | RightNodeType NodeType = 2
function removeLeafNode (line 31) | func removeLeafNode(parentNode *TreeNode, node *TreeNode, target int, no...
FILE: Delete Node in a Linked List/kata.go
type ListNode (line 3) | type ListNode struct
function deleteNode (line 8) | func deleteNode(node *ListNode) {
FILE: Delete the Middle Node of a Linked List/kata.go
type ListNode (line 3) | type ListNode struct
function deleteMiddle (line 8) | func deleteMiddle(head *ListNode) *ListNode {
FILE: Design Add and Search Words Data Structure/kata.go
type node (line 3) | type node struct
type WordDictionary (line 8) | type WordDictionary struct
method AddWord (line 18) | func (this *WordDictionary) AddWord(word string) {
method Search (line 30) | func (this *WordDictionary) Search(word string) bool {
function Constructor (line 12) | func Constructor() WordDictionary {
function searchInNode (line 34) | func searchInNode(rootNode *node, word string) bool {
FILE: Design HashMap/kata.go
type HashMapValue (line 5) | type HashMapValue struct
type MyHashMap (line 10) | type MyHashMap struct
method Put (line 25) | func (this *MyHashMap) Put(key int, value int) {
method Get (line 37) | func (this *MyHashMap) Get(key int) int {
method Remove (line 48) | func (this *MyHashMap) Remove(key int) {
function Constructor (line 15) | func Constructor() MyHashMap {
FILE: Design HashSet/kata.go
type MyHashSet (line 7) | type MyHashSet struct
method Add (line 22) | func (this *MyHashSet) Add(key int) {
method Remove (line 32) | func (this *MyHashSet) Remove(key int) {
method Contains (line 42) | func (this *MyHashSet) Contains(key int) bool {
function Constructor (line 12) | func Constructor() MyHashSet {
FILE: Design Linked List/kata_test.go
type Node (line 3) | type Node struct
type MyLinkedList (line 8) | type MyLinkedList struct
method Get (line 17) | func (this *MyLinkedList) Get(index int) int {
method AddAtHead (line 35) | func (this *MyLinkedList) AddAtHead(val int) {
method AddAtTail (line 44) | func (this *MyLinkedList) AddAtTail(val int) {
method AddAtIndex (line 63) | func (this *MyLinkedList) AddAtIndex(index int, val int) {
method DeleteAtIndex (line 96) | func (this *MyLinkedList) DeleteAtIndex(index int) {
function Constructor (line 13) | func Constructor() MyLinkedList {
FILE: Design Parking System/kata.go
type ParkingSystem (line 3) | type ParkingSystem struct
method AddCar (line 22) | func (ps *ParkingSystem) AddCar(carType int) bool {
function Constructor (line 7) | func Constructor(big int, medium int, small int) ParkingSystem {
constant _ (line 16) | _ = iota
constant CarTypeBig (line 17) | CarTypeBig
constant CarTypeMedium (line 18) | CarTypeMedium
constant CarTypeSmall (line 19) | CarTypeSmall
FILE: Design a Stack With Increment Operation/kata.go
type CustomStack (line 3) | type CustomStack struct
method Push (line 15) | func (this *CustomStack) Push(x int) {
method Pop (line 24) | func (this *CustomStack) Pop() int {
method Increment (line 35) | func (this *CustomStack) Increment(k int, val int) {
function Constructor (line 8) | func Constructor(maxSize int) CustomStack {
FILE: Design an Ordered Stream/kata.go
type OrderedStream (line 3) | type OrderedStream struct
method Insert (line 12) | func (this *OrderedStream) Insert(idKey int, value string) []string {
function Constructor (line 8) | func Constructor(n int) OrderedStream {
FILE: Destination City/kata.go
function destCity (line 3) | func destCity(paths [][]string) string {
FILE: Detect Capital/kata.go
function detectCapitalUse (line 3) | func detectCapitalUse(word string) bool {
FILE: Determine Color of a Chessboard Square/kata.go
function squareIsWhite (line 3) | func squareIsWhite(coordinates string) bool {
FILE: Determine if String Halves Are Alike/kata.go
function halvesAreAlike (line 3) | func halvesAreAlike(s string) bool {
function count (line 14) | func count(a string) int {
FILE: Determine if Two Events Have Conflict/kata.java
class Solution (line 3) | class Solution {
method haveConflict (line 4) | public boolean haveConflict(String[] event1, String[] event2) {
FILE: Diet Plan Performance/kata.java
class Solution (line 1) | class Solution {
method dietPlanPerformance (line 2) | public int dietPlanPerformance(int[] calories, int k, int lower, int u...
FILE: Difference Between Element Sum and Digit Sum of an Array/kata.java
class Solution (line 1) | class Solution {
method differenceOfSum (line 2) | public int differenceOfSum(int[] nums) {
FILE: Display the First Three Rows/kata.py
function selectFirstRows (line 3) | def selectFirstRows(employees: pd.DataFrame) -> pd.DataFrame:
FILE: Distinct Numbers in Each Subarray/kata.java
class Solution (line 1) | class Solution {
method distinctNumbers (line 2) | public int[] distinctNumbers(int[] nums, int k) {
FILE: Distribute Candies to People/kata.go
function distributeCandies (line 3) | func distributeCandies(candies int, num_people int) []int {
FILE: Distribute Elements Into Two Arrays I/kata.go
function resultArray (line 3) | func resultArray(nums []int) []int {
FILE: Divide Array Into Equal Pairs/kata.go
function divideArray (line 5) | func divideArray(nums []int) bool {
FILE: Divide a String Into Groups of Size k/kata.go
function divideString (line 3) | func divideString(s string, k int, fill byte) []string {
FILE: Divisible and Non-divisible Sums Difference/kata.go
function differenceOfSums (line 3) | func differenceOfSums(n int, m int) int {
FILE: Dot Product of Two Sparse Vectors/kata.go
type SparseVector (line 3) | type SparseVector struct
method dotProduct (line 18) | func (this *SparseVector) dotProduct(vec SparseVector) int {
function Constructor (line 7) | func Constructor(nums []int) SparseVector {
FILE: Drop Duplicate Rows/kata.py
function dropDuplicateEmails (line 3) | def dropDuplicateEmails(customers: pd.DataFrame) -> pd.DataFrame:
FILE: Drop Missing Data/kata.py
function dropMissingData (line 3) | def dropMissingData(students: pd.DataFrame) -> pd.DataFrame:
FILE: Duplicate Zeros/kata.go
function duplicateZeros (line 3) | func duplicateZeros(arr []int) {
FILE: Element Appearing More Than 25% In Sorted Array/kata.go
function findSpecialInteger (line 3) | func findSpecialInteger(arr []int) int {
FILE: Employee Importance/kata.py
class Solution (line 16) | class Solution:
method getImportance (line 17) | def getImportance(self, employees: List['Employee'], id: int) -> int:
method getSubImportance (line 27) | def getSubImportance(self, employees, employee) -> int:
FILE: Encode and Decode TinyURL/kata.go
type Codec (line 8) | type Codec struct
method encode (line 19) | func (c *Codec) encode(longURL string) string {
method decode (line 27) | func (c *Codec) decode(shortUrl string) string {
function Constructor (line 12) | func Constructor() Codec {
constant charset (line 31) | charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
function genID (line 36) | func genID(length int) string {
FILE: Equal Row and Column Pairs/kata.go
function equalPairs (line 9) | func equalPairs(grid [][]int) int {
FILE: Evaluate Boolean Binary Tree/kata.go
function evaluateTree (line 11) | func evaluateTree(root *TreeNode) bool {
FILE: Evaluate Reverse Polish Notation/kata.go
function evalRPN (line 5) | func evalRPN(tokens []string) int {
constant NumberKind (line 11) | NumberKind = iota
constant PlusKind (line 12) | PlusKind
constant MinusKind (line 13) | MinusKind
constant MultiplyKind (line 14) | MultiplyKind
constant DvisionKind (line 15) | DvisionKind
type Node (line 18) | type Node struct
constant Multiply (line 24) | Multiply byte = 42
constant Dvision (line 25) | Dvision byte = 47
constant Plus (line 26) | Plus byte = 43
constant Minus (line 27) | Minus byte = 45
function Parse (line 30) | func Parse(tokens []string) *list.List {
function Eval (line 89) | func Eval(nodes *list.List) int {
function doEval (line 103) | func doEval(nodes *list.List) {
FILE: Factorial Trailing Zeroes/kata.go
function trailingZeroes (line 5) | func trailingZeroes(n int) int {
function init (line 19) | func init() {
function factorial (line 25) | func factorial(n *big.Int) *big.Int {
FILE: Fibonacci Number/kata.go
function fib (line 3) | func fib(N int) int {
FILE: Fill Missing Data/kata.py
function fillMissingValues (line 3) | def fillMissingValues(products: pd.DataFrame) -> pd.DataFrame:
FILE: Filter Elements from Array/kata.ts
type Fn (line 1) | type Fn = (n: number, i: number) => any
function filter (line 3) | function filter(arr: number[], fn: Fn): number[] {
FILE: Filter Restaurants by Vegan-Friendly, Price and Distance/kata.go
constant idIndex (line 6) | idIndex int = 0
constant ratingIndex (line 7) | ratingIndex int = 1
constant veganFriendlyIndex (line 8) | veganFriendlyIndex int = 2
constant priceIndex (line 9) | priceIndex int = 3
constant distanceIndex (line 10) | distanceIndex int = 4
function filterRestaurants (line 13) | func filterRestaurants(restaurants [][]int, veganFriendly int, maxPrice ...
FILE: Final Prices With a Special Discount in a Shop/kata.go
function finalPrices (line 3) | func finalPrices(prices []int) []int {
FILE: Final Value of Variable After Performing Operations/kata.go
function finalValueAfterOperations (line 3) | func finalValueAfterOperations(operations []string) int {
FILE: Find All Duplicates in an Array/kata.go
function findDuplicates (line 5) | func findDuplicates(nums []int) []int {
FILE: Find All Lonely Numbers in the Array/kata.go
function findLonely (line 5) | func findLonely(nums []int) []int {
function check (line 23) | func check(nums []int, i int) bool {
FILE: Find All Numbers Disappeared in an Array/kata.go
function findDisappearedNumbers (line 3) | func findDisappearedNumbers(nums []int) []int {
FILE: Find All The Lonely Nodes/kata.java
class Solution (line 16) | class Solution {
method getLonelyNodes (line 17) | public List<Integer> getLonelyNodes(TreeNode root) {
method countNodes (line 26) | private void countNodes(ArrayList<Integer> nodes, TreeNode leftNode, T...
FILE: Find Anagram Mappings/kata.go
function anagramMappings (line 3) | func anagramMappings(nums1 []int, nums2 []int) []int {
FILE: Find Bottom Left Tree Value/kata.go
type leftLeaf (line 12) | type leftLeaf struct
function findBottomLeftValue (line 18) | func findBottomLeftValue(root *TreeNode) int {
function findNodes (line 35) | func findNodes(node *TreeNode, level int, leafs *[]leftLeaf, kind int) {
FILE: Find Center of Star Graph/kata.go
function findCenter (line 3) | func findCenter(edges [][]int) int {
FILE: Find Closest Number to Zero/kata.go
function findClosestNumber (line 8) | func findClosestNumber(nums []int) int {
FILE: Find Common Characters/kata.go
function commonChars (line 3) | func commonChars(words []string) []string {
FILE: Find First Palindromic String in the Array/kata.go
function firstPalindrome (line 3) | func firstPalindrome(words []string) string {
function isPalindrome (line 12) | func isPalindrome(s string) bool {
FILE: Find First and Last Position of Element in Sorted Array/kata.go
function searchRange (line 3) | func searchRange(nums []int, target int) []int {
FILE: Find Greatest Common Divisor of Array/kata.go
function findGCD (line 5) | func findGCD(nums []int) int {
FILE: Find K Closest Elements/kata.go
type value (line 8) | type value struct
function findClosestElements (line 13) | func findClosestElements(arr []int, k int, x int) []int {
FILE: Find K-Length Substrings With No Repeated Characters/kata.java
class Solution (line 1) | class Solution {
method numKLenSubstrNoRepeats (line 2) | public int numKLenSubstrNoRepeats(String s, int k) {
FILE: Find Largest Value in Each Tree Row/kata.go
function largestValues (line 11) | func largestValues(root *TreeNode) []int {
type largest (line 23) | type largest struct
function findAll (line 28) | func findAll(node *TreeNode, set map[int]*largest, l int) {
FILE: Find Lucky Integer in an Array/kata.go
function findLucky (line 5) | func findLucky(arr []int) int {
FILE: Find Maximum Number of String Pairs/kata.go
function maximumNumberOfStringPairs (line 3) | func maximumNumberOfStringPairs(words []string) int {
FILE: Find Median from Data Stream/kata.go
type MedianFinder (line 5) | type MedianFinder struct
method AddNum (line 14) | func (this *MedianFinder) AddNum(num int) {
method FindMedian (line 18) | func (this *MedianFinder) FindMedian() float64 {
function Constructor (line 10) | func Constructor() MedianFinder {
FILE: Find Minimum Time to Finish All Jobs II/kata.java
class Solution (line 1) | class Solution {
method minimumTime (line 2) | public int minimumTime(int[] jobs, int[] workers) {
FILE: Find Minimum in Rotated Sorted Array II/kata.go
function findMin (line 3) | func findMin(nums []int) int {
function search (line 23) | func search(nums []int, min int) int {
FILE: Find Minimum in Rotated Sorted Array/kata.go
function findMin (line 3) | func findMin(nums []int) int {
function search (line 7) | func search(nums []int, min int) int {
FILE: Find Missing and Repeated Values/kata.go
function findMissingAndRepeatedValues (line 3) | func findMissingAndRepeatedValues(grid [][]int) []int {
FILE: Find Mode in Binary Search Tree/kata.go
function findMode (line 11) | func findMode(root *TreeNode) []int {
function collectModes (line 29) | func collectModes(node *TreeNode, c map[int]int) {
FILE: Find N Unique Integers Sum up to Zero/kata.go
function sumZero (line 3) | func sumZero(n int) []int {
FILE: Find Nearest Point That Has the Same X or Y Coordinate/kata.java
class Solution (line 1) | class Solution {
method nearestValidPoint (line 2) | public int nearestValidPoint(int x, int y, int[][] points) {
FILE: Find Numbers with Even Number of Digits/kata.go
function findNumbers (line 3) | func findNumbers(nums []int) int {
FILE: Find Peak Element/kata.go
function findPeakElement (line 3) | func findPeakElement(nums []int) int {
FILE: Find Pivot Index/kata.go
function pivotIndex (line 3) | func pivotIndex(nums []int) int {
FILE: Find Players With Zero or One Losses/kata.go
type player (line 5) | type player struct
function findWinners (line 10) | func findWinners(matches [][]int) [][]int {
FILE: Find Positive Integer Solution for a Given Equation/kata.py
class Solution (line 16) | class Solution:
method findSolution (line 17) | def findSolution(self, customfunction: 'CustomFunction', z: int) -> Li...
FILE: Find Smallest Common Element in All Rows/kata.go
function smallestCommonElement (line 3) | func smallestCommonElement(mat [][]int) int {
FILE: Find Smallest Letter Greater Than Target/kata.go
function nextGreatestLetter (line 3) | func nextGreatestLetter(letters []byte, target byte) byte {
FILE: Find Target Indices After Sorting Array/kata.go
function targetIndices (line 5) | func targetIndices(nums []int, target int) []int {
FILE: Find The Original Array of Prefix Xor/kata.java
class Solution (line 1) | class Solution {
method findArray (line 2) | public int[] findArray(int[] pref) {
FILE: Find Triangular Sum of an Array/kata.go
function triangularSum (line 3) | func triangularSum(nums []int) int {
FILE: Find Words Containing Character/kata.go
function findWordsContaining (line 3) | func findWordsContaining(words []string, x byte) []int {
FILE: Find Words That Can Be Formed by Characters/kata.go
function countCharacters (line 3) | func countCharacters(words []string, chars string) int {
FILE: Find and Replace Pattern/kata.go
function findAndReplacePattern (line 3) | func findAndReplacePattern(words []string, pattern string) []string {
function cleanWords (line 17) | func cleanWords(words []string) []string {
function cleanWord (line 25) | func cleanWord(w string) string {
FILE: Find the Array Concatenation Value/kata.java
class Solution (line 1) | class Solution {
method findTheArrayConcVal (line 2) | public long findTheArrayConcVal(int[] nums) {
FILE: Find the Difference/kata.go
function findTheDifference (line 5) | func findTheDifference(s string, t string) byte {
FILE: Find the Distance Value Between Two Arrays/kata.go
function findTheDistanceValue (line 5) | func findTheDistanceValue(arr1 []int, arr2 []int, d int) int {
FILE: Find the Duplicate Number/kata.go
function findDuplicate (line 5) | func findDuplicate(nums []int) int {
FILE: Find the Highest Altitude/kata.go
function largestAltitude (line 3) | func largestAltitude(gain []int) int {
FILE: Find the K-Beauty of a Number/kata.java
class Solution (line 1) | class Solution {
method divisorSubstrings (line 2) | public int divisorSubstrings(int num, int k) {
FILE: Find the Kth Largest Integer in the Array/kata.go
function kthLargestNumber (line 5) | func kthLargestNumber(nums []string, k int) string {
FILE: Find the Maximum Achievable Number/kata.go
function theMaximumAchievableX (line 3) | func theMaximumAchievableX(num int, t int) int {
FILE: Find the Minimum and Maximum Number of Nodes Between Critical Points/kata.go
type ListNode (line 5) | type ListNode struct
function nodesBetweenCriticalPoints (line 10) | func nodesBetweenCriticalPoints(head *ListNode) []int {
FILE: Find the Peaks/kata.go
function findPeaks (line 3) | func findPeaks(mountain []int) []int {
FILE: Find the Pivot Integer/kata.java
class Solution (line 1) | class Solution {
method pivotInteger (line 2) | public int pivotInteger(int n) {
FILE: Find the Sum of Encrypted Integers/kata.go
function sumOfEncryptedInt (line 5) | func sumOfEncryptedInt(nums []int) int {
FILE: Find the Winner of the Circular Game/kata.java
class Solution (line 1) | class Solution {
method findTheWinner (line 2) | public int findTheWinner(int n, int k) {
FILE: First Bad Version/kata.go
function firstBadVersion (line 11) | func firstBadVersion(n int) int {
FILE: First Letter to Appear Twice/kata.go
function repeatedCharacter (line 3) | func repeatedCharacter(s string) byte {
FILE: First Missing Positive/kata.go
function firstMissingPositive (line 8) | func firstMissingPositive(nums []int) int {
FILE: First Unique Character in a String/kata.go
function firstUniqChar (line 3) | func firstUniqChar(s string) int {
FILE: Fizz Buzz/kata.go
function fizzBuzz (line 5) | func fizzBuzz(n int) []string {
FILE: Flatten 2D Vector/kata.go
type Vector2D (line 3) | type Vector2D struct
method Next (line 14) | func (this *Vector2D) Next() int {
method HasNext (line 27) | func (this *Vector2D) HasNext() bool {
function Constructor (line 10) | func Constructor(vec [][]int) Vector2D {
FILE: Flatten Nested List Iterator/kata.go
type NestedIterator (line 29) | type NestedIterator struct
method Next (line 40) | func (this *NestedIterator) Next() int {
method HasNext (line 49) | func (this *NestedIterator) HasNext() bool {
function Constructor (line 34) | func Constructor(nestedList []*NestedInteger) *NestedIterator {
function recursiveChannling (line 60) | func recursiveChannling(nestedList []*NestedInteger, c chan int, firstLa...
FILE: Flatten a Multilevel Doubly Linked List/kata.go
function flatten (line 13) | func flatten(root *Node) *Node {
function r (line 26) | func r(currentNode *Node, nextNode *Node, childNode *Node) {
FILE: Flipping an Image/kata.go
function flipAndInvertImage (line 3) | func flipAndInvertImage(A [][]int) [][]int {
FILE: Function Composition/kata.ts
type F (line 1) | type F = (x: number) => number;
function compose (line 3) | function compose(functions: F[]): F {
FILE: Generate a String With Characters That Have Odd Counts/kata.go
function generateTheString (line 3) | func generateTheString(n int) string {
FILE: Get Maximum in Generated Array/kata.go
function getMaximumGenerated (line 3) | func getMaximumGenerated(n int) int {
FILE: Get the Size of a DataFrame/kata.py
function getDataframeSize (line 3) | def getDataframeSize(players: pd.DataFrame) -> List[int]:
FILE: Goal Parser Interpretation/kata.go
constant o (line 3) | o byte = 'o'
function interpret (line 5) | func interpret(command string) string {
function isClosed (line 20) | func isClosed(c byte) bool {
function isOpen (line 27) | func isOpen(c byte) bool {
FILE: Goat Latin/kata.java
class Solution (line 1) | class Solution {
method toGoatLatin (line 2) | public String toGoatLatin(String sentence) {
FILE: Greatest English Letter in Upper and Lower Case/kata.go
function greatestLetter (line 5) | func greatestLetter(s string) string {
FILE: Group Anagrams/kata.go
function groupAnagrams (line 5) | func groupAnagrams(strs []string) [][]string {
FILE: Group the People Given the Group Size They Belong To/kata.go
function groupThePeople (line 3) | func groupThePeople(groupSizes []int) [][]int {
FILE: H-Index/kata.go
function hIndex (line 5) | func hIndex(citations []int) int {
FILE: HTML Entity Parser/kata.go
function entityParser (line 5) | func entityParser(text string) string {
FILE: Hamming Distance/kata.go
function hammingDistance (line 3) | func hammingDistance(x int, y int) int {
FILE: Happy Number/kata.go
function isHappy (line 3) | func isHappy(n int) bool {
function sumFunc (line 23) | func sumFunc(n int) int {
FILE: Harshad Number/kata.go
function sumOfTheDigitsOfHarshadNumber (line 3) | func sumOfTheDigitsOfHarshadNumber(x int) int {
FILE: Height Checker/kata.go
function heightChecker (line 5) | func heightChecker(heights []int) int {
FILE: High Five/kata.go
function highFive (line 5) | func highFive(items [][]int) [][]int {
FILE: How Many Apples Can You Put into the Basket/kata.java
class Solution (line 3) | class Solution {
method maxNumberOfApples (line 4) | public int maxNumberOfApples(int[] weight) {
FILE: How Many Numbers Are Smaller Than the Current Number/kata.go
function smallerNumbersThanCurrent (line 8) | func smallerNumbersThanCurrent(nums []int) []int {
FILE: Implement Magic Dictionary/kata.go
type MagicDictionary (line 3) | type MagicDictionary struct
method BuildDict (line 13) | func (this *MagicDictionary) BuildDict(dictionary []string) {
method Search (line 27) | func (this *MagicDictionary) Search(searchWord string) bool {
function Constructor (line 7) | func Constructor() MagicDictionary {
FILE: Implement Queue using Stacks/kata.go
type MyQueue (line 3) | type MyQueue struct
method Push (line 15) | func (this *MyQueue) Push(x int) {
method Pop (line 20) | func (this *MyQueue) Pop() int {
method Peek (line 27) | func (this *MyQueue) Peek() int {
method Empty (line 32) | func (this *MyQueue) Empty() bool {
function Constructor (line 8) | func Constructor() MyQueue {
FILE: Implement Stack using Queues/kata.go
type MyStack (line 3) | type MyStack struct
method Push (line 15) | func (this *MyStack) Push(x int) {
method Pop (line 20) | func (this *MyStack) Pop() int {
method Top (line 27) | func (this *MyStack) Top() int {
method Empty (line 32) | func (this *MyStack) Empty() bool {
function Constructor (line 8) | func Constructor() MyStack {
FILE: Implement Trie (Prefix Tree)/kata.go
type node (line 3) | type node struct
type Trie (line 9) | type Trie struct
method Insert (line 19) | func (this *Trie) Insert(word string) {
method Search (line 46) | func (this *Trie) Search(word string) bool {
method StartsWith (line 72) | func (this *Trie) StartsWith(prefix string) bool {
function Constructor (line 14) | func Constructor() Trie {
FILE: Implement strStr()/kata.go
function strStr (line 3) | func strStr(haystack string, needle string) (idx int) {
FILE: Increasing Order Search Tree/kata.go
function increasingBST (line 11) | func increasingBST(root *TreeNode) *TreeNode {
function inorderTraversal (line 24) | func inorderTraversal(root *TreeNode) []int {
function inorder (line 30) | func inorder(node *TreeNode, list *[]int) {
FILE: Index Pairs of a String/kata.java
class Solution (line 1) | class Solution {
method indexPairs (line 2) | public int[][] indexPairs(String text, String[] words) {
FILE: Insertion Sort List/kata.go
function insertionSortList (line 10) | func insertionSortList(head *ListNode) *ListNode {
function Insertionsort (line 27) | func Insertionsort(a []*ListNode) {
FILE: Intersection of Multiple Arrays/kata.go
function intersection (line 5) | func intersection(nums [][]int) []int {
FILE: Intersection of Three Sorted Arrays/kata.go
function arraysIntersection (line 3) | func arraysIntersection(arr1 []int, arr2 []int, arr3 []int) []int {
FILE: Intersection of Two Arrays II/kata.go
function intersect (line 5) | func intersect(nums1 []int, nums2 []int) []int {
FILE: Intersection of Two Arrays/kata.go
function intersection (line 3) | func intersection(nums1 []int, nums2 []int) []int {
FILE: Intersection of Two Linked Lists/kata.go
function getIntersectionNode (line 10) | func getIntersectionNode(headA, headB *ListNode) *ListNode {
FILE: Invert Binary Tree/kata.go
function invertTree (line 11) | func invertTree(root *TreeNode) *TreeNode {
function swap (line 16) | func swap(node *TreeNode) {
FILE: Is Subsequence/kata.go
function isSubsequence (line 3) | func isSubsequence(s string, t string) bool {
FILE: Island Perimeter/kata.go
function islandPerimeter (line 3) | func islandPerimeter(grid [][]int) int {
FILE: Jewels and Stones/kata.go
function numJewelsInStones (line 3) | func numJewelsInStones(J string, S string) int {
FILE: K Items With the Maximum Sum/kata.go
function kItemsWithMaximumSum (line 3) | func kItemsWithMaximumSum(numOnes int, numZeros int, numNegOnes int, k i...
FILE: K Radius Subarray Averages/kata.go
function getAverages (line 3) | func getAverages(nums []int, k int) []int {
FILE: Keep Multiplying Found Values by Two/kata.go
function findFinalValue (line 3) | func findFinalValue(nums []int, original int) int {
FILE: Kids With the Greatest Number of Candies/kata.go
function kidsWithCandies (line 5) | func kidsWithCandies(candies []int, extraCandies int) []bool {
FILE: Kth Distinct String in an Array/kata.go
function kthDistinct (line 3) | func kthDistinct(arr []string, k int) string {
FILE: Kth Largest Element in a Stream/kata.go
type KthLargest (line 5) | type KthLargest struct
method Add (line 17) | func (this *KthLargest) Add(val int) int {
function Constructor (line 10) | func Constructor(k int, nums []int) KthLargest {
FILE: Kth Largest Element in an Array/kata.go
function findKthLargest (line 5) | func findKthLargest(nums []int, k int) int {
FILE: Kth Missing Positive Number/kata.go
function findKthPositive (line 3) | func findKthPositive(arr []int, k int) int {
FILE: Kth Smallest Element in a BST/kata.go
function kthSmallest (line 11) | func kthSmallest(root *TreeNode, k int) int {
function inorder (line 20) | func inorder(node *TreeNode, list *[]int, k int) {
FILE: LRU Cache/kata.go
type element (line 7) | type element struct
type LRUCache (line 12) | type LRUCache struct
method Get (line 24) | func (this *LRUCache) Get(key int) int {
method Put (line 38) | func (this *LRUCache) Put(key int, value int) {
function Constructor (line 17) | func Constructor(capacity int) LRUCache {
FILE: Largest 3-Same-Digit Number in String/kata.go
function largestGoodInteger (line 3) | func largestGoodInteger(num string) string {
FILE: Largest Number After Digit Swaps by Parity/kata.go
function largestInteger (line 8) | func largestInteger(num int) int {
type IntHeap (line 57) | type IntHeap
method Len (line 59) | func (h IntHeap) Len() int {
method Less (line 63) | func (h IntHeap) Less(i, j int) bool {
method Swap (line 67) | func (h IntHeap) Swap(i, j int) {
method Push (line 75) | func (h *IntHeap) Push(x interface{}) {
method Pop (line 79) | func (h *IntHeap) Pop() interface{} {
FILE: Largest Number At Least Twice of Others/kata.go
function dominantIndex (line 3) | func dominantIndex(nums []int) int {
FILE: Largest Perimeter Triangle/kata.go
function largestPerimeter (line 5) | func largestPerimeter(nums []int) int {
FILE: Largest Positive Integer That Exists With Its Negative/kata.java
class Solution (line 4) | class Solution {
method findMaxK (line 5) | public int findMaxK(int[] nums) {
FILE: Largest Subarray Length K/kata.java
class Solution (line 1) | class Solution {
method largestSubarray (line 2) | public int[] largestSubarray(int[] nums, int k) {
FILE: Largest Unique Number/kata.go
function largestUniqueNumber (line 5) | func largestUniqueNumber(nums []int) int {
FILE: Last Stone Weight/kata.go
function lastStoneWeight (line 5) | func lastStoneWeight(stones []int) int {
FILE: Latest Time by Replacing Hidden Digits/kata.go
function maximumTime (line 3) | func maximumTime(time string) string {
FILE: Leaf-Similar Trees/kata.go
function leafSimilar (line 11) | func leafSimilar(root1 *TreeNode, root2 *TreeNode) bool {
function PickLeafValues (line 33) | func PickLeafValues(node *TreeNode, values *[]int) {
FILE: Least Number of Unique Integers after K Removals/kata.java
class Solution (line 1) | class Solution {
method findLeastNumOfUniqueInts (line 2) | public int findLeastNumOfUniqueInts(int[] arr, int k) {
FILE: Left and Right Sum Differences/kata.java
class Solution (line 1) | class Solution {
method leftRigthDifference (line 2) | public int[] leftRigthDifference(int[] nums) {
FILE: Length of Last Word/kata.go
function lengthOfLastWord (line 3) | func lengthOfLastWord(s string) (lastWordCounter int) {
FILE: Letter Case Permutation/kata.go
function letterCasePermutation (line 3) | func letterCasePermutation(S string) []string {
function permutation (line 9) | func permutation(permutations *[]string, b []byte, index int) []byte {
FILE: Lexicographical Numbers/kata.go
function lexicalOrder (line 8) | func lexicalOrder(n int) []int {
FILE: Linked List Cycle/kata.go
function hasCycle (line 10) | func hasCycle(head *ListNode) bool {
FILE: Longer Contiguous Segments of Ones than Zeros/kata.go
function checkZeroOnes (line 5) | func checkZeroOnes(s string) bool {
FILE: Longest Common Prefix/kata.go
function longestCommonPrefix (line 3) | func longestCommonPrefix(strs []string) string {
function Has (line 27) | func Has(strs []string, minString string, n int) bool {
FILE: Longest Consecutive Sequence/kata.go
function longestConsecutive (line 5) | func longestConsecutive(nums []int) int {
FILE: Longest Continuous Increasing Subsequence/kata.go
function findLengthOfLCIS (line 3) | func findLengthOfLCIS(nums []int) int {
FILE: Longest Strictly Increasing or Strictly Decreasing Subarray/kata.go
function longestMonotonicSubarray (line 3) | func longestMonotonicSubarray(nums []int) int {
FILE: Longest Subsequence With Limited Sum/kata.java
class Solution (line 1) | class Solution {
method answerQueries (line 2) | public int[] answerQueries(int[] nums, int[] queries) {
FILE: Lucky Numbers in a Matrix/kata.go
function luckyNumbers (line 3) | func luckyNumbers(matrix [][]int) []int {
FILE: Majority Element II/kata.go
function majorityElement (line 8) | func majorityElement(nums []int) []int {
FILE: Majority Element/kata.go
function majorityElement (line 7) | func majorityElement(nums []int) int {
FILE: Make Array Zero by Subtracting Equal Amounts/kata.java
class Solution (line 1) | class Solution {
method minimumOperations (line 2) | public int minimumOperations(int[] nums) {
FILE: Make The String Great/kata.go
function makeGood (line 3) | func makeGood(s string) string {
FILE: Make Two Arrays Equal by Reversing Sub-arrays/kata.go
function canBeEqual (line 5) | func canBeEqual(target []int, arr []int) bool {
FILE: Map Sum Pairs/kata.go
type MapSum (line 3) | type MapSum struct
method Insert (line 12) | func (this *MapSum) Insert(key string, val int) {
method Sum (line 16) | func (this *MapSum) Sum(prefix string) (sum int) {
function Constructor (line 8) | func Constructor() MapSum {
FILE: Matrix Diagonal Sum/kata.go
function diagonalSum (line 3) | func diagonalSum(mat [][]int) int {
FILE: Max Consecutive Ones/kata.go
function findMaxConsecutiveOnes (line 3) | func findMaxConsecutiveOnes(nums []int) int {
FILE: Max Stack/kata.go
type MaxStack (line 8) | type MaxStack struct
method Push (line 17) | func (this *MaxStack) Push(x int) {
method Pop (line 26) | func (this *MaxStack) Pop() int {
method Top (line 45) | func (this *MaxStack) Top() int {
method PeekMax (line 53) | func (this *MaxStack) PeekMax() int {
method PopMax (line 57) | func (this *MaxStack) PopMax() int {
function Constructor (line 13) | func Constructor() MaxStack {
FILE: Maximize Sum Of Array After K Negations/kata.go
function largestSumAfterKNegations (line 5) | func largestSumAfterKNegations(A []int, K int) int {
FILE: Maximum 69 Number/kata.go
function maximum69Number (line 5) | func maximum69Number(num int) int {
FILE: Maximum Ascending Subarray Sum/kata.go
function maxAscendingSum (line 3) | func maxAscendingSum(nums []int) int {
FILE: Maximum Average Subarray I /kata.go
function findMaxAverage (line 3) | func findMaxAverage(nums []int, k int) float64 {
FILE: Maximum Count of Positive Integer and Negative Integer/kata.java
class Solution (line 1) | class Solution {
method maximumCount (line 2) | public int maximumCount(int[] nums) {
FILE: Maximum Depth of Binary Tree/kata.go
function maxDepth (line 11) | func maxDepth(root *TreeNode) int {
function height (line 18) | func height(root *TreeNode, count int) int {
FILE: Maximum Difference Between Increasing Elements/kata.java
class Solution (line 1) | class Solution {
method maximumDifference (line 2) | public int maximumDifference(int[] nums) {
FILE: Maximum Difference by Remapping a Digit/kata.java
class Solution (line 1) | class Solution {
method minMaxDifference (line 2) | public int minMaxDifference(int n) {
FILE: Maximum Frequency Stack/kata.go
type FreqStack (line 3) | type FreqStack struct
method Push (line 15) | func (this *FreqStack) Push(x int) {
method Pop (line 20) | func (this *FreqStack) Pop() int {
function Constructor (line 8) | func Constructor() FreqStack {
FILE: Maximum Nesting Depth of the Parentheses/kata.java
class Solution (line 1) | class Solution {
method maxDepth (line 2) | public int maxDepth(String s) {
FILE: Maximum Number of Balloons/kata.go
function maxNumberOfBalloons (line 3) | func maxNumberOfBalloons(text string) int {
FILE: Maximum Number of Balls in a Box/kata.go
function countBalls (line 3) | func countBalls(lowLimit int, highLimit int) int {
FILE: Maximum Number of Coins You Can Get/kata.java
class Solution (line 1) | class Solution {
method maxCoins (line 2) | public int maxCoins(int[] piles) {
FILE: Maximum Number of Pairs in Array/kata.go
function numberOfPairs (line 5) | func numberOfPairs(nums []int) []int {
FILE: Maximum Number of Words Found in Sentences/kata.go
function mostWordsFound (line 3) | func mostWordsFound(sentences []string) int {
FILE: Maximum Number of Words You Can Type/kata.go
function canBeTypedWords (line 3) | func canBeTypedWords(text string, brokenLetters string) int {
FILE: Maximum Odd Binary Number/kata.go
function maximumOddBinaryNumber (line 3) | func maximumOddBinaryNumber(s string) string {
FILE: Maximum Product Difference Between Two Pairs/kata.go
function maxProductDifference (line 5) | func maxProductDifference(nums []int) int {
FILE: Maximum Product of Three Numbers/kata.go
function maximumProduct (line 5) | func maximumProduct(nums []int) int {
FILE: Maximum Product of Two Elements in an Array/kata.go
function maxProduct (line 5) | func maxProduct(nums []int) int {
FILE: Maximum Score After Splitting a String/kata.go
function maxScore (line 3) | func maxScore(s string) int {
FILE: Maximum Subarray/kata.go
function maxSubArray (line 5) | func maxSubArray(nums []int) int {
FILE: Maximum Sum Score of Array/kata.go
function maximumSumScore (line 5) | func maximumSumScore(nums []int) int64 {
function max (line 55) | func max(a, b int64) int64 {
FILE: Maximum Sum With Exactly K Elements/kata.go
function maximizeSum (line 1) | func maximizeSum(nums []int, k int) int {
FILE: Maximum Twin Sum of a Linked List/kata.go
type ListNode (line 3) | type ListNode struct
function pairSum (line 8) | func pairSum(head *ListNode) int {
function f (line 14) | func f(a *ListNode, b *ListNode, max *int) *ListNode {
FILE: Maximum Units on a Truck/kata.java
class Solution (line 1) | class Solution {
method maximumUnits (line 2) | public int maximumUnits(int[][] boxTypes, int truckSize) {
FILE: Maximum Value after Insertion/kata.go
function maxValue (line 3) | func maxValue(n string, x int) string {
FILE: Maximum Value of a String in an Array/kata.java
class Solution (line 1) | class Solution {
method maximumValue (line 2) | public int maximumValue(String[] strs) {
FILE: Maximum XOR After Operations /kata.java
class Solution (line 1) | class Solution {
method maximumXOR (line 2) | public int maximumXOR(int[] nums) {
FILE: Mean of Array After Removing Some Elements/kata.go
function trimMean (line 5) | func trimMean(arr []int) float64 {
FILE: Meeting Rooms/kata.java
class Solution (line 1) | class Solution {
method canAttendMeetings (line 2) | public boolean canAttendMeetings(int[][] intervals) {
FILE: Merge In Between Linked Lists/kata.go
type ListNode (line 3) | type ListNode struct
function mergeInBetween (line 8) | func mergeInBetween(list1 *ListNode, a int, b int, list2 *ListNode) *Lis...
FILE: Merge Nodes in Between Zeros/kata.go
type ListNode (line 3) | type ListNode struct
function mergeNodes (line 8) | func mergeNodes(head *ListNode) *ListNode {
FILE: Merge Similar Items/kata.java
class Solution (line 1) | class Solution {
method mergeSimilarItems (line 2) | public List<List<Integer>> mergeSimilarItems(int[][] items1, int[][] i...
FILE: Merge Strings Alternately/kata.go
function mergeAlternately (line 3) | func mergeAlternately(word1 string, word2 string) string {
FILE: Merge Two 2D Arrays by Summing Values/kata.go
function mergeArrays (line 3) | func mergeArrays(nums1 [][]int, nums2 [][]int) [][]int {
FILE: Merge Two Sorted Lists/kata.go
function mergeTwoLists (line 10) | func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
FILE: Merge k Sorted Lists/kata.go
type Item (line 13) | type Item struct
function mergeKLists (line 19) | func mergeKLists(lists []*ListNode) *ListNode {
type PriorityQueue (line 53) | type PriorityQueue
method Len (line 55) | func (pq PriorityQueue) Len() int { return len(pq) }
method Less (line 57) | func (pq PriorityQueue) Less(i, j int) bool {
method Swap (line 61) | func (pq PriorityQueue) Swap(i, j int) {
method Pop (line 67) | func (pq *PriorityQueue) Pop() interface{} {
method Push (line 76) | func (pq *PriorityQueue) Push(x interface{}) {
FILE: Method Chaining/kata.py
function findHeavyAnimals (line 3) | def findHeavyAnimals(animals: pd.DataFrame) -> pd.DataFrame:
FILE: Middle of the Linked List/kata.go
function middleNode (line 10) | func middleNode(head *ListNode) *ListNode {
FILE: Min Cost Climbing Stairs/kata.go
function minCostClimbingStairs (line 3) | func minCostClimbingStairs(cost []int) int {
function min (line 15) | func min(dp []int, i, j int) int {
FILE: Min Max Game/kata.go
function minMaxGame (line 3) | func minMaxGame(nums []int) int {
function min (line 25) | func min(a, b int) int {
function max (line 32) | func max(a, b int) int {
FILE: Min Stack/kata.go
type MinStack (line 3) | type MinStack struct
method Push (line 14) | func (this *MinStack) Push(x int) {
method Pop (line 18) | func (this *MinStack) Pop() {
method Top (line 25) | func (this *MinStack) Top() int {
method GetMin (line 32) | func (this *MinStack) GetMin() int {
function Constructor (line 8) | func Constructor() MinStack {
FILE: Minimize Maximum Pair Sum in Array/kata.go
function minPairSum (line 5) | func minPairSum(nums []int) int {
FILE: Minimize Product Sum of Two Arrays/kata.go
function minProductSum (line 5) | func minProductSum(nums1 []int, nums2 []int) int {
FILE: Minimize String Length/kata.go
function minimizedStringLength (line 3) | func minimizedStringLength(s string) int {
FILE: Minimum Absolute Difference in BST/kata.go
function getMinimumDifference (line 13) | func getMinimumDifference(root *TreeNode) int {
function traverse (line 30) | func traverse(node *TreeNode, ps *PrioritySlice) {
type PrioritySlice (line 44) | type PrioritySlice
method Len (line 46) | func (pq PrioritySlice) Len() int { return len(pq) }
method Less (line 48) | func (pq PrioritySlice) Less(i, j int) bool {
method Swap (line 52) | func (pq PrioritySlice) Swap(i, j int) {
FILE: Minimum Absolute Difference/kata.go
function minimumAbsDifference (line 5) | func minimumAbsDifference(arr []int) [][]int {
FILE: Minimum Add to Make Parentheses Valid/kata.java
class Solution (line 1) | class Solution {
method minAddToMakeValid (line 2) | public int minAddToMakeValid(String s) {
FILE: Minimum Average Difference/kata.go
function minimumAverageDifference (line 3) | func minimumAverageDifference(nums []int) int {
function abs (line 34) | func abs(a int) int {
FILE: Minimum Bit Flips to Convert Number/kata.go
function minBitFlips (line 3) | func minBitFlips(start int, goal int) int {
function max (line 33) | func max(a, b int) int {
function min (line 40) | func min(a, b int) int {
FILE: Minimum Common Value/kata.java
class Solution (line 1) | class Solution {
method getCommon (line 2) | public int getCommon(int[] nums1, int[] nums2) {
FILE: Minimum Cuts to Divide a Circle/kata.java
class Solution (line 1) | class Solution {
method numberOfCuts (line 2) | public int numberOfCuts(int n) {
FILE: Minimum Depth of Binary Tree/kata.go
function minDepth (line 14) | func minDepth(node *TreeNode) int {
FILE: Minimum Distance to the Target Element/kata.go
function getMinDistance (line 5) | func getMinDistance(nums []int, target int, start int) int {
FILE: Minimum Increment to Make Array Unique/kata.go
function minIncrementForUnique (line 5) | func minIncrementForUnique(A []int) int {
FILE: Minimum Moves to Convert String/kata.go
function minimumMoves (line 3) | func minimumMoves(s string) int {
FILE: Minimum Number Game/kata.go
function numberGame (line 5) | func numberGame(nums []int) []int {
FILE: Minimum Number of Steps to Make Two Strings Anagram II/kata.go
function minSteps (line 3) | func minSteps(s string, t string) int {
function abs (line 32) | func abs(a int) int {
FILE: Minimum Operations to Collect Elements/kata.go
function minOperations (line 3) | func minOperations(nums []int, k int) int {
FILE: Minimum Operations to Exceed Threshold Value I/kata.go
function minOperations (line 5) | func minOperations(nums []int, k int) int {
FILE: Minimum Operations to Make the Array Increasing/kata.go
function minOperations (line 3) | func minOperations(nums []int) int {
FILE: Minimum Recolors to Get K Consecutive Black Blocks/kata.java
class Solution (line 1) | class Solution {
method minimumRecolors (line 2) | public int minimumRecolors(String blocks, int k) {
FILE: Minimum String Length After Removing Substrings/kata.go
function minLength (line 3) | func minLength(s string) int {
FILE: Minimum Subsequence in Non-Increasing Order/kata.java
class Solution (line 1) | class Solution {
method minSubsequence (line 2) | public List<Integer> minSubsequence(int[] nums) {
FILE: Minimum Sum of Four Digit Number After Splitting Digits/kata.go
function minimumSum (line 5) | func minimumSum(num int) int {
FILE: Minimum Value to Get Positive Step by Step Sum/kata.java
class Solution (line 1) | class Solution {
method minStartValue (line 2) | public int minStartValue(int[] nums) {
FILE: Missing Number/kata.go
function missingNumber (line 3) | func missingNumber(nums []int) int {
FILE: Missing Ranges/kata.java
class Solution (line 1) | class Solution {
method findMissingRanges (line 2) | public List<String> findMissingRanges(int[] nums, int lower, int upper) {
FILE: Modify Columns/kata.py
function modifySalaryColumn (line 3) | def modifySalaryColumn(employees: pd.DataFrame) -> pd.DataFrame:
FILE: Modify the Matrix/kata.go
function modifiedMatrix (line 4) | func modifiedMatrix(matrix [][]int) [][]int {
FILE: Monotonic Array/kata.go
function isMonotonic (line 3) | func isMonotonic(A []int) bool {
FILE: Most Common Word/kata.go
function mostCommonWord (line 8) | func mostCommonWord(paragraph string, banned []string) string {
function hasBanned (line 44) | func hasBanned(banned []string, word string) bool {
FILE: Most Frequent Even Element/kata.go
function mostFrequentEven (line 5) | func mostFrequentEven(nums []int) int {
FILE: Most Frequent Number Following Key In an Array/kata.go
function mostFrequent (line 3) | func mostFrequent(nums []int, key int) int {
FILE: Move Zeroes/kata.go
function moveZeroes (line 3) | func moveZeroes(nums []int) {
FILE: Moving Average from Data Stream/kata.go
type MovingAverage (line 5) | type MovingAverage struct
method Next (line 19) | func (mv *MovingAverage) Next(val int) float64 {
function Constructor (line 12) | func Constructor(size int) MovingAverage {
FILE: Multiply Strings/kata.go
function multiply (line 5) | func multiply(num1 string, num2 string) string {
FILE: My Calendar I/kata.go
type BookingInfo (line 3) | type BookingInfo struct
type MyCalendar (line 8) | type MyCalendar struct
method Book (line 18) | func (this *MyCalendar) Book(start int, end int) bool {
function Constructor (line 12) | func Constructor() MyCalendar {
FILE: N-Repeated Element in Size 2N Array/kata.go
function repeatedNTimes (line 3) | func repeatedNTimes(A []int) (n int) {
FILE: N-th Tribonacci Number/kata.go
function tribonacci (line 5) | func tribonacci(n int) int {
function eq (line 25) | func eq() func() int {
FILE: Neither Minimum nor Maximum/kata.go
function findNonMinOrMax (line 7) | func findNonMinOrMax(nums []int) int {
FILE: Nested List Weight Sum/kata.go
function depthSum (line 28) | func depthSum(nestedList []*NestedInteger) int {
function f (line 35) | func f(nestedList []*NestedInteger, sum *int, l int) {
FILE: Next Greater Element I/kata.go
function nextGreaterElement (line 3) | func nextGreaterElement(nums1 []int, nums2 []int) []int {
FILE: Nth Highest Salary/kata.sql
function getNthHighestSalary (line 4) | CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT
FILE: Number Complement/kata.go
function findComplement (line 5) | func findComplement(num int) int {
FILE: Number Of Rectangles That Can Form The Largest Square/kata.java
class Solution (line 1) | class Solution {
method countGoodRectangles (line 2) | public int countGoodRectangles(int[][] rectangles) {
method min (line 16) | private int min(int a, int b) {
FILE: Number of 1 Bits/kata.go
function hammingWeight (line 3) | func hammingWeight(num uint32) int {
FILE: Number of Arithmetic Triplets/kata.java
class Solution (line 1) | class Solution {
method arithmeticTriplets (line 2) | public int arithmeticTriplets(int[] nums, int diff) {
FILE: Number of Days Between Two Dates/kata.go
constant layoutISO (line 5) | layoutISO = "2006-01-02"
function daysBetweenDates (line 7) | func daysBetweenDates(date1 string, date2 string) int {
FILE: Number of Days in a Month/kata.java
class Solution (line 14) | class Solution {
method numberOfDays (line 15) | public int numberOfDays(int year, int month) {
FILE: Number of Different Integers in a String/kata.go
function numDifferentIntegers (line 3) | func numDifferentIntegers(word string) int {
FILE: Number of Distinct Averages/kata.java
class Solution (line 4) | class Solution {
method distinctAverages (line 5) | public int distinctAverages(int[] nums) {
FILE: Number of Employees Who Met the Target/kata.go
function numberOfEmployeesWhoMetTarget (line 3) | func numberOfEmployeesWhoMetTarget(hours []int, target int) int {
FILE: Number of Equivalent Domino Pairs/kata.go
function numEquivDominoPairs (line 5) | func numEquivDominoPairs(dominoes [][]int) int {
function hash (line 24) | func hash(d []int) int {
function max (line 28) | func max(a, b int) int {
function min (line 35) | func min(a, b int) int {
function init (line 42) | func init() {
function Binomial (line 48) | func Binomial(n int) int {
FILE: Number of Even and Odd Bits/kata.go
function evenOddBit (line 3) | func evenOddBit(n int) []int {
FILE: Number of Good Pairs/kata.go
function numIdenticalPairs (line 5) | func numIdenticalPairs(nums []int) int {
FILE: Number of Laser Beams in a Bank/kata.go
function numberOfBeams (line 3) | func numberOfBeams(bank []string) int {
FILE: Number of Lines To Write String/kata.java
class Solution (line 1) | class Solution {
method numberOfLines (line 2) | public int[] numberOfLines(int[] widths, String s) {
FILE: Number of Recent Calls/kata.go
type RecentCounter (line 3) | type RecentCounter struct
method Ping (line 13) | func (rc *RecentCounter) Ping(t int) int {
function Constructor (line 7) | func Constructor() RecentCounter {
FILE: Number of Segments in a String/kata.go
function countSegments (line 3) | func countSegments(s string) int {
FILE: Number of Senior Citizens/kata.go
function countSeniors (line 3) | func countSeniors(details []string) int {
FILE: Number of Steps to Reduce a Number to Zero/kata.go
function numberOfSteps (line 3) | func numberOfSteps(num int) int {
FILE: Number of Strings That Appear as Substrings in Word/kata.java
class Solution (line 1) | class Solution {
method numOfStrings (line 2) | public int numOfStrings(String[] patterns, String word) {
FILE: Number of Students Doing Homework at a Given Time/kata.go
function busyStudent (line 3) | func busyStudent(startTime []int, endTime []int, queryTime int) int {
FILE: Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold/kata.java
class Solution (line 1) | class Solution {
method numOfSubarrays (line 2) | public int numOfSubarrays(int[] arr, int k, int threshold) {
FILE: Number of Visible People in a Queue/kata.go
function canSeePersonsCount (line 3) | func canSeePersonsCount(heights []int) []int {
FILE: Occurrences After Bigram/kata.go
function findOcurrences (line 3) | func findOcurrences(text string, first string, second string) []string {
FILE: One Edit Distance/kata.go
function isOneEditDistance (line 5) | func isOneEditDistance(s string, t string) bool {
FILE: Online Stock Span/kata.go
type StockSpanner (line 3) | type StockSpanner struct
method Next (line 11) | func (this *StockSpanner) Next(price int) int {
function Constructor (line 7) | func Constructor() StockSpanner {
FILE: Palindrome Linked List/kata.go
type ListNode (line 3) | type ListNode struct
function isPalindrome (line 8) | func isPalindrome(head *ListNode) bool {
function p (line 13) | func p(a *ListNode, b *ListNode) (*ListNode, bool) {
FILE: Palindrome Number/kata.go
function isPalindrome (line 3) | func isPalindrome(x int) bool {
FILE: Parsing A Boolean Expression/kata.go
function parseBoolExpr (line 3) | func parseBoolExpr(expression string) bool {
function IsBool (line 8) | func IsBool(c byte) bool {
function parseBool (line 12) | func parseBool(c byte) bool {
function IsNot (line 19) | func IsNot(c byte) bool {
function parseNot (line 23) | func parseNot(expression string, i int) (bool, int) {
function IsAnd (line 43) | func IsAnd(c byte) bool {
function parseAnd (line 47) | func parseAnd(expression string, i int) (bool, int) {
function IsOr (line 73) | func IsOr(c byte) bool {
function parseOr (line 77) | func parseOr(expression string, i int) (bool, int) {
function parseUnit (line 104) | func parseUnit(expression string, i int) (bool, int, bool) {
function IsClosed (line 125) | func IsClosed(c byte) bool {
FILE: Partition Array According to Given Pivot/kata.go
function pivotArray (line 5) | func pivotArray(nums []int, pivot int) []int {
FILE: Partitioning Into Minimum Number Of Deci-Binary Numbers/kata.java
class Solution (line 1) | class Solution {
method minPartitions (line 2) | public int minPartitions(String n) {
FILE: Pascal's Triangle II/kata.go
function getRow (line 3) | func getRow(rowIndex int) []int {
FILE: Pascal's Triangle/kata.go
function generate (line 3) | func generate(numRows int) [][]int {
FILE: Path Sum/kata.go
function hasPathSum (line 11) | func hasPathSum(root *TreeNode, sum int) bool {
function pathSum (line 18) | func pathSum(root *TreeNode, v int, sum int) bool {
FILE: Peak Index in a Mountain Array/kata.go
function peakIndexInMountainArray (line 3) | func peakIndexInMountainArray(A []int) int {
FILE: Peeking Iterator/kata.go
type PeekingIterator (line 18) | type PeekingIterator struct
method hasNext (line 28) | func (pt *PeekingIterator) hasNext() bool {
method next (line 32) | func (pt *PeekingIterator) next() int {
method peek (line 36) | func (pt *PeekingIterator) peek() int {
function Constructor (line 22) | func Constructor(iter *Iterator) *PeekingIterator {
FILE: Percentage of Letter in String/kata.go
function percentageLetter (line 5) | func percentageLetter(s string, letter byte) int {
FILE: Perfect Number/kata.go
function checkPerfectNumber (line 5) | func checkPerfectNumber(num int) bool {
FILE: Perform String Shifts/kata.go
constant RightShiftMode (line 4) | RightShiftMode int = 1
constant LeftShiftMode (line 5) | LeftShiftMode int = 0
function stringShift (line 8) | func stringShift(s string, shift [][]int) string {
function LeftShift (line 22) | func LeftShift(b []byte, amount int) []byte {
function RightShift (line 40) | func RightShift(b []byte, amount int) []byte {
FILE: Permutations II/kata.go
function permuteUnique (line 3) | func permuteUnique(nums []int) [][]int {
function perm (line 10) | func perm(nums []int, permutations *[][]int, i int, duplicates map[int]b...
FILE: Permutations/kata.go
function permute (line 3) | func permute(nums []int) [][]int {
function perm (line 9) | func perm(nums []int, permutations *[][]int, i int) {
FILE: Plus One/kata.go
function plusOne (line 5) | func plusOne(digits []int) []int {
FILE: Points That Intersect With Cars/kata.go
function numberOfPoints (line 5) | func numberOfPoints(nums [][]int) int {
FILE: Populating Next Right Pointers in Each Node/kata.go
function connect (line 13) | func connect(root *Node) *Node {
function f (line 21) | func f(l *Node, r *Node) {
FILE: Positions of Large Groups/kata.go
function largeGroupPositions (line 3) | func largeGroupPositions(S string) [][]int {
FILE: Power of Four/kata.go
function isPowerOfFour (line 5) | func isPowerOfFour(num int) bool {
FILE: Power of Three/kata.go
function isPowerOfThree (line 5) | func isPowerOfThree(num int) bool {
FILE: Power of Two/kata.go
function isPowerOfTwo (line 5) | func isPowerOfTwo(n int) bool {
FILE: Powerful Integers/kata.go
function powerfulIntegers (line 5) | func powerfulIntegers(x int, y int, bound int) []int {
FILE: Prefix and Suffix Search/kata.go
type WordFilter (line 3) | type WordFilter struct
method F (line 11) | func (this *WordFilter) F(prefix string, suffix string) int {
function Constructor (line 7) | func Constructor(words []string) WordFilter {
FILE: Prime Number of Set Bits in Binary Representation/kata.java
class Solution (line 3) | class Solution {
method countPrimeSetBits (line 4) | public int countPrimeSetBits(int left, int right) {
FILE: Print Immutable Linked List in Reverse/kata.go
function printLinkedListInReverse (line 18) | func printLinkedListInReverse(head ImmutableListNode) {
FILE: Product of Array Except Self/kata.go
function productExceptSelf (line 3) | func productExceptSelf(nums []int) []int {
FILE: Product of the Last K Numbers/kata.go
type ProductOfNumbers (line 3) | type ProductOfNumbers struct
method Add (line 11) | func (this *ProductOfNumbers) Add(num int) {
method GetProduct (line 15) | func (this *ProductOfNumbers) GetProduct(k int) int {
function Constructor (line 7) | func Constructor() ProductOfNumbers {
FILE: Queries on Number of Points Inside a Circle/kata.java
class Solution (line 1) | class Solution {
method countPoints (line 2) | public int[] countPoints(int[][] points, int[][] queries) {
FILE: Queries on a Permutation With Key/kata.go
function processQueries (line 5) | func processQueries(queries []int, m int) []int {
FILE: Random Pick Index/kata.go
type Solution (line 8) | type Solution struct
method Pick (line 22) | func (this *Solution) Pick(target int) int {
function Constructor (line 13) | func Constructor(nums []int) Solution {
FILE: Range Sum Query - Immutable/kata.go
type NumArray (line 3) | type NumArray struct
method SumRange (line 11) | func (this *NumArray) SumRange(i int, j int) int {
function Constructor (line 7) | func Constructor(nums []int) NumArray {
FILE: Range Sum Query - Mutable/kata.go
type NumArray (line 3) | type NumArray struct
method Update (line 13) | func (this *NumArray) Update(i int, val int) {
method SumRange (line 21) | func (this *NumArray) SumRange(i int, j int) int {
function Constructor (line 7) | func Constructor(nums []int) NumArray {
FILE: Range Sum Query 2D - Immutable/kata.go
type NumMatrix (line 3) | type NumMatrix struct
method SumRegion (line 13) | func (this *NumMatrix) SumRegion(row1 int, col1 int, row2 int, col2 in...
function Constructor (line 7) | func Constructor(matrix [][]int) NumMatrix {
FILE: Range Sum of BST/kata.go
function rangeSumBST (line 11) | func rangeSumBST(root *TreeNode, L int, R int) int {
function f (line 15) | func f(node *TreeNode, L int, R int, sum int) int {
FILE: Rank Transform of an Array/kata.go
function arrayRankTransform (line 5) | func arrayRankTransform(arr []int) []int {
FILE: Ransom Note/kata.go
function canConstruct (line 3) | func canConstruct(ransomNote string, magazine string) bool {
FILE: Rearrange Array Elements by Sign/kata.go
function rearrangeArray (line 5) | func rearrangeArray(nums []int) []int {
FILE: Rearrange Characters to Make Target String/kata.go
function rearrangeCharacters (line 3) | func rearrangeCharacters(s string, target string) int {
function normalise (line 38) | func normalise(a int) int {
FILE: Rearrange Spaces Between Words/kata.go
function reorderSpaces (line 3) | func reorderSpaces(text string) string {
FILE: Rearrange Words in a Sentence/kata.go
function arrangeWords (line 5) | func arrangeWords(text string) string {
FILE: Redistribute Characters to Make All Strings Equal/kata.go
function makeEqual (line 3) | func makeEqual(words []string) bool {
FILE: Reduce Array Size to The Half/kata.go
function minSetSize (line 5) | func minSetSize(arr []int) int {
FILE: Relative Ranks/kata.go
function findRelativeRanks (line 8) | func findRelativeRanks(nums []int) []string {
FILE: Remove All Adjacent Duplicates In String/kata.java
class Solution (line 1) | class Solution {
method removeDuplicates (line 2) | public String removeDuplicates(String s) {
FILE: Remove Colored Pieces if Both Neighbors are the Same Color/kata.go
function winnerOfGame (line 3) | func winnerOfGame(colors string) bool {
FILE: Remove Duplicates from Sorted List II/kata.go
function deleteDuplicates (line 10) | func deleteDuplicates(head *ListNode) *ListNode {
FILE: Remove Duplicates from Sorted List/kata.go
function deleteDuplicates (line 10) | func deleteDuplicates(head *ListNode) *ListNode {
FILE: Remove Element/kata.go
function removeElement (line 8) | func removeElement(nums []int, val int) int {
FILE: Remove Linked List Elements/kata.go
function removeElements (line 10) | func removeElements(head *ListNode, val int) *ListNode {
FILE: Remove Nth Node From End of List/kata.go
function removeNthFromEnd (line 10) | func removeNthFromEnd(head *ListNode, n int) *ListNode {
FILE: Remove Stones to Minimize the Total/kata.go
function minStoneSum (line 9) | func minStoneSum(piles []int, k int) int {
type IntHeap (line 28) | type IntHeap
method Len (line 30) | func (h IntHeap) Len() int {
method Less (line 34) | func (h IntHeap) Less(i, j int) bool {
method Swap (line 38) | func (h IntHeap) Swap(i, j int) {
method Push (line 43) | func (h *IntHeap) Push(x interface{}) {
method Pop (line 47) | func (h *IntHeap) Pop() interface{} {
FILE: Remove Trailing Zeros From a String/kata.go
function removeTrailingZeros (line 3) | func removeTrailingZeros(num string) string {
FILE: Remove Vowels from a String/kata.go
function removeVowels (line 3) | func removeVowels(s string) string {
FILE: Removing Minimum and Maximum From Array/kata.java
class Solution (line 1) | class Solution {
method minimumDeletions (line 2) | public int minimumDeletions(int[] nums) {
FILE: Removing Stars From a String/kata.java
class Solution (line 1) | class Solution {
method removeStars (line 2) | public String removeStars(String s) {
FILE: Rename Columns/kata.py
function renameColumns (line 3) | def renameColumns(students: pd.DataFrame) -> pd.DataFrame:
FILE: Replace All 's to Avoid Consecutive Repeating Characters/kata.go
function modifyString (line 8) | func modifyString(s string) string {
function pickChar (line 47) | func pickChar(char byte) byte {
FILE: Replace All Digits with Characters/kata.go
function replaceDigits (line 3) | func replaceDigits(s string) string {
function shift (line 14) | func shift(c byte, by byte) byte {
FILE: Reshape Data: Concatenate/kata.py
function concatenateTables (line 3) | def concatenateTables(df1: pd.DataFrame, df2: pd.DataFrame) -> pd.DataFr...
FILE: Reshape Data: Melt/kata.py
function meltTable (line 3) | def meltTable(report: pd.DataFrame) -> pd.DataFrame:
FILE: Reshape Data: Pivot/kata.py
function pivotTable (line 3) | def pivotTable(weather: pd.DataFrame) -> pd.DataFrame:
FILE: Reshape the Matrix/kata.go
function matrixReshape (line 3) | func matrixReshape(nums [][]int, r int, c int) [][]int {
FILE: Reverse Integer/kata.go
constant Negative (line 6) | Negative int = -1
constant Positive (line 7) | Positive int = 1
function reverse (line 10) | func reverse(x int) (sum int) {
FILE: Reverse Linked List/kata.go
function reverseList (line 10) | func reverseList(head *ListNode) *ListNode {
FILE: Reverse Prefix of Word/kata.go
function reversePrefix (line 3) | func reversePrefix(word string, ch byte) string {
FILE: Reverse String/kata.go
function reverseString (line 3) | func reverseString(s []byte) {
FILE: Reverse Vowels of a String/kata.go
function reverseVowels (line 3) | func reverseVowels(s string) string {
function isVowel (line 21) | func isVowel(char byte) bool {
FILE: Reverse Words in a String III/kata.go
function reverseWords (line 3) | func reverseWords(s string) string {
FILE: Reverse Words in a String/kata.go
function reverseWords (line 3) | func reverseWords(s string) string {
FILE: Richest Customer Wealth/kata.go
function maximumWealth (line 3) | func maximumWealth(accounts [][]int) int {
function sum (line 14) | func sum(values []int) int {
FILE: Rings and Rods/kata.go
function countPoints (line 5) | func countPoints(rings string) int {
type Pair (line 55) | type Pair struct
FILE: Roman to Integer/kata.go
function romanToInt (line 5) | func romanToInt(s string) int {
FILE: Root Equals Sum of Children/kata.go
type TreeNode (line 3) | type TreeNode struct
function checkTree (line 9) | func checkTree(root *TreeNode) bool {
FILE: Rotate Array/kata.go
function rotate (line 3) | func rotate(nums []int, k int) {
FILE: Rotate String/kata.go
function rotateString (line 3) | func rotateString(A string, B string) bool {
FILE: Row With Maximum Ones/kata.go
function rowAndMaximumOnes (line 3) | func rowAndMaximumOnes(mat [][]int) []int {
FILE: Running Sum of 1d Array/kata.go
function runningSum (line 3) | func runningSum(nums []int) []int {
FILE: Same Tree/kata.go
function isSameTree (line 11) | func isSameTree(p *TreeNode, q *TreeNode) bool {
FILE: Score of a String/kata.go
function scoreOfString (line 3) | func scoreOfString(s string) int {
function abs (line 11) | func abs(a int) int {
FILE: Search Insert Position/kata.go
function searchInsert (line 3) | func searchInsert(nums []int, target int) int {
FILE: Search a 2D Matrix II/kata.go
function searchMatrix (line 3) | func searchMatrix(matrix [][]int, target int) bool {
FILE: Search a 2D Matrix/kata.go
function searchMatrix (line 3) | func searchMatrix(matrix [][]int, target int) bool {
function searchVector (line 26) | func searchVector(v []int, target int) bool {
FILE: Search in Rotated Sorted Array II/kata.go
function search (line 3) | func search(nums []int, target int) bool {
FILE: Search in a Binary Search Tree/kata.go
function searchBST (line 11) | func searchBST(root *TreeNode, val int) *TreeNode {
FILE: Seat Reservation Manager/kata.go
type SeatManager (line 3) | type SeatManager struct
method Reserve (line 12) | func (this *SeatManager) Reserve() int {
method Unreserve (line 25) | func (this *SeatManager) Unreserve(seatNumber int) {
function Constructor (line 8) | func Constructor(n int) SeatManager {
FILE: Second Largest Digit in a String/kata.go
function secondHighest (line 5) | func secondHighest(s string) int {
FILE: Second Minimum Node In a Binary Tree/kata.go
function findSecondMinimumValue (line 14) | func findSecondMinimumValue(root *TreeNode) int {
function inorder (line 33) | func inorder(node *TreeNode, list map[int]struct{}) {
FILE: Select Data/kata.py
function selectData (line 3) | def selectData(students: pd.DataFrame) -> pd.DataFrame:
FILE: Self Dividing Numbers/kata.go
function selfDividingNumbers (line 3) | func selfDividingNumbers(left int, right int) []int {
FILE: Separate the Digits in an Array/kata.java
class Solution (line 1) | class Solution {
method separateDigits (line 2) | public int[] separateDigits(int[] nums) {
FILE: Set Mismatch/kata.go
function findErrorNums (line 3) | func findErrorNums(nums []int) []int {
FILE: Shift 2D Grid/kata.go
function shiftGrid (line 3) | func shiftGrid(grid [][]int, k int) [][]int {
FILE: Shortest Distance to a Character/kata.go
function shortestToChar (line 5) | func shortestToChar(S string, C byte) []int {
FILE: Shortest Word Distance II/kata.go
type WordDistance (line 5) | type WordDistance struct
method Shortest (line 15) | func (this *WordDistance) Shortest(word1 string, word2 string) int {
function Constructor (line 9) | func Constructor(wordsDict []string) WordDistance {
function shortestDistance (line 19) | func shortestDistance(wordsDict []string, word1 string, word2 string) int {
FILE: Shortest Word Distance/kata.go
function shortestDistance (line 5) | func shortestDistance(wordsDict []string, word1 string, word2 string) int {
FILE: Shuffle String/kata.go
function restoreString (line 3) | func restoreString(s string, indices []int) string {
FILE: Shuffle the Array/kata.go
function shuffle (line 3) | func shuffle(nums []int, n int) []int {
FILE: Sign of the Product of an Array/kata.go
function arraySign (line 3) | func arraySign(nums []int) int {
FILE: Simple Bank System/kata.go
type Bank (line 3) | type Bank struct
method Transfer (line 13) | func (this *Bank) Transfer(account1 int, account2 int, money int64) bo...
method Deposit (line 36) | func (this *Bank) Deposit(account int, money int64) bool {
method Withdraw (line 47) | func (this *Bank) Withdraw(account int, balance int64) bool {
function Constructor (line 7) | func Constructor(balance []int64) Bank {
FILE: Single Element in a Sorted Array/kata.go
function singleNonDuplicate (line 3) | func singleNonDuplicate(nums []int) (a int) {
FILE: Single Number/kata.go
function singleNumber (line 3) | func singleNumber(nums []int) int {
FILE: Single-Row Keyboard/kata.go
function calculateTime (line 5) | func calculateTime(keyboard string, word string) int {
FILE: Sliding Window Maximum/kata.go
function maxSlidingWindow (line 5) | func maxSlidingWindow(nums []int, k int) []int {
type maxNumber (line 33) | type maxNumber struct
function findMax (line 38) | func findMax(nums []int, i, k int) maxNumber {
FILE: Sliding Window Median/kata.go
function medianSlidingWindow (line 5) | func medianSlidingWindow(nums []int, k int) []float64 {
FILE: Smallest Even Multiple/kata.go
function smallestEvenMultiple (line 5) | func smallestEvenMultiple(n int) int {
FILE: Smallest Index With Equal Value/kata.go
function smallestEqual (line 5) | func smallestEqual(nums []int) int {
FILE: Smallest Range I/kata.go
function smallestRangeI (line 5) | func smallestRangeI(nums []int, k int) int {
FILE: Sort Array By Parity/kata.go
function sortArrayByParity (line 5) | func sortArrayByParity(A []int) []int {
FILE: Sort Array by Increasing Frequency/kata.go
function frequencySort (line 5) | func frequencySort(nums []int) []int {
FILE: Sort Characters By Frequency/kata.go
function frequencySort (line 5) | func frequencySort(s string) string {
FILE: Sort Integers by The Number of 1 Bits/kata.go
function sortByBits (line 8) | func sortByBits(arr []int) []int {
function countBits (line 25) | func countBits(n int64) int {
FILE: Sort Integers by The Power Value/kata.go
function getKth (line 5) | func getKth(lo int, hi int, k int) int {
FILE: Sort the People/kata.go
type Persons (line 5) | type Persons struct
method Len (line 10) | func (p Persons) Len() int { return len(p.Names) }
method Less (line 11) | func (p Persons) Less(i, j int) bool { return p.Heights[i] > p.Heights...
method Swap (line 12) | func (p Persons) Swap(i, j int) {
function sortPeople (line 17) | func sortPeople(names []string, heights []int) []string {
FILE: Sorting the Sentence/kata.go
constant whitespace (line 5) | whitespace = ' '
function sortSentence (line 7) | func sortSentence(s string) string {
FILE: Split With Minimum Sum/kata.go
function splitNum (line 8) | func splitNum(num int) int {
FILE: Split a String in Balanced Strings/kata.go
function balancedStringSplit (line 3) | func balancedStringSplit(s string) int {
FILE: Split the Array/kata.go
function isPossibleToSplit (line 3) | func isPossibleToSplit(nums []int) bool {
FILE: Sqrt(x)/kata.go
function mySqrt (line 7) | func mySqrt(x int) int {
FILE: Squares of a Sorted Array/kata.go
function sortedSquares (line 5) | func sortedSquares(A []int) []int {
FILE: Strong Password Checker II/kata.go
function strongPasswordCheckerII (line 5) | func strongPasswordCheckerII(password string) bool {
FILE: Student Attendance Record I/kata.go
constant A (line 3) | A int = 1
constant L (line 4) | L int = 2
function checkRecord (line 6) | func checkRecord(s string) bool {
FILE: Subdomain Visit Count/kata.go
function subdomainVisits (line 5) | func subdomainVisits(cpdomains []string) []string {
FILE: Subrectangle Queries/kata.go
type SubrectangleQueries (line 3) | type SubrectangleQueries struct
method UpdateSubrectangle (line 11) | func (this *SubrectangleQueries) UpdateSubrectangle(row1 int, col1 int...
method GetValue (line 19) | func (this *SubrectangleQueries) GetValue(row int, col int) int {
function Constructor (line 7) | func Constructor(rectangle [][]int) SubrectangleQueries {
FILE: Substrings of Size Three with Distinct Characters/kata.java
class Solution (line 1) | class Solution {
method countGoodSubstrings (line 2) | public int countGoodSubstrings(String s) {
FILE: Subtract the Product and Sum of Digits of an Integer/kata.go
function subtractProductAndSum (line 3) | func subtractProductAndSum(number int) int {
FILE: Subtree of Another Tree/kata.go
function isSubtree (line 11) | func isSubtree(root *TreeNode, subRoot *TreeNode) bool {
function SearchBST (line 15) | func SearchBST(root *TreeNode, subRoot *TreeNode, val int) bool {
function LeafsEqual (line 40) | func LeafsEqual(root1 *TreeNode, root2 *TreeNode) bool {
type NodeValue (line 65) | type NodeValue struct
function PickLeafValues (line 71) | func PickLeafValues(node *TreeNode, values *[]NodeValue, lvl int, direct...
FILE: Sum Multiples/kata.go
function sumOfMultiples (line 3) | func sumOfMultiples(n int) int {
FILE: Sum Root to Leaf Numbers/kata.go
function sumNumbers (line 13) | func sumNumbers(root *TreeNode) int {
function f (line 31) | func f(node *TreeNode, sums *[]string, n string) {
FILE: Sum in a Matrix/kata.go
function matrixSum (line 5) | func matrixSum(nums [][]int) int {
FILE: Sum of Digits in Base K/kata.go
function sumBase (line 5) | func sumBase(n int, k int) int {
FILE: Sum of Digits in the Minimum Number/kata.go
function sumOfDigits (line 3) | func sumOfDigits(nums []int) int {
FILE: Sum of Digits of String After Convert/kata.go
function getLucky (line 3) | func getLucky(s string, k int) int {
FILE: Sum of Even Numbers After Queries/kata.java
class Solution (line 1) | class Solution {
method sumEvenAfterQueries (line 2) | public int[] sumEvenAfterQueries(int[] nums, int[][] queries) {
FILE: Sum of Left Leaves/kata.go
function sumOfLeftLeaves (line 11) | func sumOfLeftLeaves(root *TreeNode) int {
function findLeftLeaves (line 18) | func findLeftLeaves(node *TreeNode, kind int, sum *int) {
FILE: Sum of Squares of Special Elements/kata.go
function sumOfSquares (line 3) | func sumOfSquares(nums []int) int {
FILE: Sum of Unique Elements/kata.go
function sumOfUnique (line 3) | func sumOfUnique(nums []int) int {
FILE: Sum of Values at Indices With K Set Bits/kata.go
function sumIndicesWithKSetBits (line 3) | func sumIndicesWithKSetBits(nums []int, k int) int {
FILE: Summary Ranges/kata.go
function summaryRanges (line 5) | func summaryRanges(nums []int) []string {
FILE: Swap Nodes in Pairs/kata.go
function swapPairs (line 10) | func swapPairs(head *ListNode) *ListNode {
FILE: Symmetric Tree/kata.java
class Solution (line 16) | class Solution {
method isSymmetric (line 17) | public boolean isSymmetric(TreeNode root) {
method verify (line 20) | private boolean verify(TreeNode nodeLeft, TreeNode nodeRight) {
FILE: Take Gifts From the Richest Pile/kata.java
class Solution (line 1) | class Solution {
method pickGifts (line 2) | public long pickGifts(int[] gifts, int k) {
FILE: The Employee That Worked on the Longest Task/kata.java
class Solution (line 1) | class Solution {
method hardestWorker (line 2) | public int hardestWorker(int n, int[][] logs) {
FILE: The K Weakest Rows in a Matrix/kata.go
function kWeakestRows (line 5) | func kWeakestRows(mat [][]int, k int) []int {
FILE: The Number of Users That Are Eligible for Discount/q.sql
function getUserIDs (line 1) | CREATE FUNCTION getUserIDs(startDate DATE, endDate DATE, minAmount INT) ...
FILE: Third Maximum Number/kata.go
function thirdMax (line 7) | func thirdMax(nums []int) int {
FILE: Thousand Separator/kata.go
function thousandSeparator (line 5) | func thousandSeparator(n int) string {
FILE: Three Consecutive Odds/kata.go
function threeConsecutiveOdds (line 3) | func threeConsecutiveOdds(arr []int) bool {
FILE: Time Based Key-Value Store/kata.go
type item (line 3) | type item struct
type TimeMap (line 8) | type TimeMap struct
method Set (line 17) | func (this *TimeMap) Set(key string, value string, timestamp int) {
method Get (line 30) | func (this *TimeMap) Get(key string, timestamp int) string {
function Constructor (line 13) | func Constructor() TimeMap {
FILE: To Be Or Not To Be/kata.ts
type ToBeOrNotToBe (line 1) | type ToBeOrNotToBe = {
function expect (line 6) | function expect(val: any): ToBeOrNotToBe {
class toBeOrNotToBe (line 11) | class toBeOrNotToBe implements ToBeOrNotToBe {
method constructor (line 14) | public constructor(val: any) {
method toBe (line 18) | public toBe(val: any) :boolean {
method notToBe (line 27) | public notToBe(val: any) :boolean {
FILE: To Lower Case/kata.go
function toLowerCase (line 3) | func toLowerCase(str string) string {
FILE: Toeplitz Matrix/kata.go
function isToeplitzMatrix (line 3) | func isToeplitzMatrix(matrix [][]int) bool {
FILE: Top K Frequent Elements/kata.go
type Item (line 5) | type Item struct
function topKFrequent (line 11) | func topKFrequent(nums []int, k int) []int {
type PriorityQueue (line 39) | type PriorityQueue
method Len (line 41) | func (pq PriorityQueue) Len() int { return len(pq) }
method Less (line 43) | func (pq PriorityQueue) Less(i, j int) bool {
method Swap (line 50) | func (pq PriorityQueue) Swap(i, j int) {
method Pop (line 56) | func (pq *PriorityQueue) Pop() interface{} {
method Push (line 65) | func (pq *PriorityQueue) Push(x interface{}) {
FILE: Top K Frequent Words/kata.go
type Prio (line 5) | type Prio struct
function topKFrequent (line 10) | func topKFrequent(words []string, k int) []string {
FILE: Transpose Matrix/kata.go
function transpose (line 3) | func transpose(matrix [][]int) [][]int {
FILE: Truncate Sentence/kata.go
constant whitespace (line 3) | whitespace = ' '
function truncateSentence (line 5) | func truncateSentence(s string, k int) string {
FILE: Two Furthest Houses With Different Colors/kata.go
function maxDistance (line 3) | func maxDistance(colors []int) int {
FILE: Two Out of Three/kata.go
function twoOutOfThree (line 3) | func twoOutOfThree(nums1 []int, nums2 []int, nums3 []int) []int {
FILE: Two Sum/kata.py
class Solution (line 6) | class Solution:
method twoSum (line 7) | def twoSum(self, nums: List[int], target: int) -> List[int]:
FILE: Ugly Number/kata.go
function isUgly (line 3) | func isUgly(num int) bool {
FILE: Uncommon Words from Two Sentences/kata.go
function uncommonFromSentences (line 3) | func uncommonFromSentences(A string, B string) []string {
FILE: Unique Morse Code Words/kata.go
function uniqueMorseRepresentations (line 5) | func uniqueMorseRepresentations(words []string) int {
FILE: Unique Number of Occurrences/kata.go
function uniqueOccurrences (line 5) | func uniqueOccurrences(arr []int) bool {
FILE: Univalued Binary Tree/kata.go
function isUnivalTree (line 11) | func isUnivalTree(root *TreeNode) bool {
function isValid (line 20) | func isValid(node *TreeNode, set map[int]struct{}) {
FILE: Valid Anagram/kata.go
function isAnagram (line 5) | func isAnagram(s string, t string) bool {
FILE: Valid Mountain Array/kata.go
function validMountainArray (line 3) | func validMountainArray(A []int) bool {
FILE: Valid Palindrome II/kata.go
function validPalindrome (line 3) | func validPalindrome(s string) bool {
function makeValid (line 25) | func makeValid(s string, idx int) []byte {
function IsValid (line 36) | func IsValid(b []byte) bool {
FILE: Valid Palindrome/kata.go
function isPalindrome (line 3) | func isPalindrome(s string) bool {
function isValidChar (line 31) | func isValidChar(char byte) (bool, int) {
FILE: Valid Parentheses/kata.go
function isValid (line 3) | func isValid(s string) bool {
FILE: Validate Binary Search Tree/kata.go
function isValidBST (line 11) | func isValidBST(root *TreeNode) bool {
function inorderTraversal (line 21) | func inorderTraversal(root *TreeNode) []int {
function inorder (line 27) | func inorder(node *TreeNode, list *[]int) {
FILE: Water Bottles/kata.go
function numWaterBottles (line 3) | func numWaterBottles(numBottles int, numExchange int) int {
FILE: Widest Vertical Area Between Two Points Containing No Points/kata.java
class Solution (line 1) | class Solution {
method maxWidthOfVerticalArea (line 2) | public int maxWidthOfVerticalArea(int[][] points) {
FILE: Word Pattern/kata.go
function wordPattern (line 3) | func wordPattern(pattern string, s string) bool {
FILE: XOR Operation in an Array/kata.go
function xorOperation (line 3) | func xorOperation(n int, start int) int {
Condensed preview — 689 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (415K chars).
[
{
"path": " Day of the Week/kata.py",
"chars": 749,
"preview": "# math equation by Tomohiko Sakamoto\nclass Solution:\n def dayOfTheWeek(self, d: int, m: int, y: int) -> str:\n "
},
{
"path": " Find Total Time Spent by Each Employee/q.sql",
"chars": 113,
"preview": "SELECT event_day AS day, emp_id, SUM(out_time - in_time) AS total_time\nFROM Employees\nGROUP BY event_day, emp_id;"
},
{
"path": " Students With Invalid Departments/q.sql",
"chars": 86,
"preview": "SELECT id, name FROM Students WHERE department_id NOT IN (SELECT id FROM Departments);"
},
{
"path": ".gitignore",
"chars": 276,
"preview": "# Binaries for programs and plugins\n*.exe\n*.exe~\n*.dll\n*.so\n*.dylib\n\n# Test binary, built with `go test -c`\n*.test\n\n# Ou"
},
{
"path": "3042. Count Prefix and Suffix Pairs I/kata.py",
"chars": 531,
"preview": "import itertools\n\nclass Solution:\n def countPrefixSuffixPairs(self, words: List[str]) -> int: \n matched = 0\n"
},
{
"path": "3110. Score of a String/main.scala",
"chars": 211,
"preview": "object Solution {\n def scoreOfString(s: String): Int = {\n var sum: Int = 0\n for (i <- 1 to s.length-1) "
},
{
"path": "A Number After a Double Reversal/kata.go",
"chars": 137,
"preview": "package A_Number_After_a_Double_Reversal\n\nfunc isSameAfterReversals(num int) bool {\n\tif num == 0 {\n\t\treturn true\n\t}\n\tret"
},
{
"path": "Account Balance/q.sql",
"chars": 174,
"preview": "SELECT\n account_id,\n day,\n SUM(IF(type = 'Deposit', amount, -amount)) OVER (\n PARTITION BY account_id\n OR"
},
{
"path": "Account Balance After Rounded Purchase/kata.go",
"chars": 310,
"preview": "package kata\n\nfunc accountBalanceAfterPurchase(purchaseAmount int) int {\n initAccount := 100\n point := purchaseAmo"
},
{
"path": "Accounts Merge/kata.go",
"chars": 1133,
"preview": "package kata\n\nimport \"sort\"\n\nfunc accountsMerge(accounts [][]string) [][]string {\n\ttoDelete := make(map[int]bool)\n\tfor {"
},
{
"path": "Active Businesses/q.sql",
"chars": 375,
"preview": "WITH EventsAVG AS (\n SELECT\n event_type,\n AVG(occurences) AS occurences_avg\n FROM\n Events\n "
},
{
"path": "Add Binary/kata.go",
"chars": 976,
"preview": "package kata\n\nfunc addBinary(a string, b string) string {\n\n\tif len(a) == 0 && len(b) == 0 {\n\t\treturn \"0\"\n\t}\n\n\tbb := []by"
},
{
"path": "Add Digits/kata.go",
"chars": 319,
"preview": "package kata\n\nfunc addDigits(num int) int {\n\tif num == 0 {\n\t\treturn 0\n\t}\n\tvar digitCount int\n\tfor {\n\t\tnum, digitCount = "
},
{
"path": "Add One Row to Tree/kata.go",
"chars": 597,
"preview": "package kata\n\ntype TreeNode struct {\n\tVal int\n\tLeft *TreeNode\n\tRight *TreeNode\n}\n\nfunc addOneRow(root *TreeNode, v in"
},
{
"path": "Add Strings/kata.go",
"chars": 886,
"preview": "package kata\n\nfunc addStrings(num1 string, num2 string) string {\n\tif len(num1) < len(num2) {\n\t\tnum1 = padding(num2, num1"
},
{
"path": "Add Two Integers/kata.go",
"chars": 83,
"preview": "package Add_Two_Integers\n\nfunc sum(num1 int, num2 int) int {\n\treturn num1 + num2\n}\n"
},
{
"path": "Adding Spaces to a String/kata.go",
"chars": 309,
"preview": "package Adding_Spaces_to_a_String\n\nfunc addSpaces(s string, spaces []int) string {\n\tb := make([]byte, len(s)+len(spaces)"
},
{
"path": "All Elements in Two Binary Search Trees/kata.go",
"chars": 536,
"preview": "package kata\n\nimport \"sort\"\n\ntype TreeNode struct {\n\tVal int\n\tLeft *TreeNode\n\tRight *TreeNode\n}\n\nfunc getAllElements("
},
{
"path": "All the Matches of the League/q.sql",
"chars": 133,
"preview": "SELECT a.team_name AS home_team,\n b.team_name AS away_team\nFROM Teams AS a\nINNER JOIN Teams AS b ON b.team_name !="
},
{
"path": "Allow One Function Call/kata.ts",
"chars": 543,
"preview": "type JSONValue = null | boolean | number | string | JSONValue[] | { [key: string]: JSONValue };\ntype OnceFn = (...args: "
},
{
"path": "Alternating Digit Sum/kata.java",
"chars": 381,
"preview": "class Solution {\n public int alternateDigitSum(int n) {\n var digitCount = ((int) Math.log10((double) n));\n "
},
{
"path": "Ant on the Boundary/kata.go",
"chars": 181,
"preview": "func returnToBoundaryCount(nums []int) int {\n\tvar prefixSum int\n\tvar count int\n\tfor _, num := range nums {\n\t\tprefixSum +"
},
{
"path": "Apple Redistribution into Boxes/kata.go",
"chars": 378,
"preview": "package kata\n\nimport \"sort\"\n\nfunc minimumBoxes(apple []int, capacity []int) int {\n\tsort.Slice(capacity, func(i, j int) b"
},
{
"path": "Apples & Oranges/q.sql",
"chars": 238,
"preview": "SELECT\n sale_date,\n SUM(\n CASE WHEN fruit = 'apples' THEN sold_num END\n )\n - SUM(\n CAS"
},
{
"path": "Apply Discount Every n Orders/kata.go",
"chars": 1172,
"preview": "package kata\n\ntype Cashier struct {\n\tCustomerCounter int\n\tn int\n\tdiscount float64\n\tproducts "
},
{
"path": "Apply Transform Over Each Element in Array/kata.ts",
"chars": 314,
"preview": "function map(arr: number[], fn: (n: number, i: number) => number): number[] {\n if (arr.length == 0) {\n return "
},
{
"path": "Armstrong Number/kata.go",
"chars": 272,
"preview": "package kata\n\nimport \"math\"\n\nfunc isArmstrong(n int) bool {\n\n\tl := n\n\tvar c int\n\tfor l != 0 {\n\t\tl /= 10\n\t\tc++\n\t}\n\n\tvar m"
},
{
"path": "Arranging Coins/kata.go",
"chars": 166,
"preview": "package kata\n\nfunc arrangeCoins(n int) int {\n\tif n == 1 {\n\t\treturn 1\n\t}\n\ti := 1\n\tc := 0\n\tfor n > 0 {\n\t\tn = n - i\n\t\tif n "
},
{
"path": "Array Partition I/kata.go",
"chars": 205,
"preview": "package kata\n\nimport \"sort\"\n\nfunc arrayPairSum(a []int) int {\n\tsort.Slice(a, func(i, j int) bool {\n\t\treturn a[i] < a[j]\n"
},
{
"path": "Array Reduce Transformation/kata.ts",
"chars": 223,
"preview": "type Fn = (accum: number, curr: number) => number\n\nfunction reduce(nums: number[], fn: Fn, init: number): number {\n f"
},
{
"path": "Array Wrapper/kata.ts",
"chars": 522,
"preview": "class ArrayWrapper {\n \n nums: number[];\n\n constructor(nums: number[]) {\n this.nums = nums;\n }\n \n "
},
{
"path": "Article Views I/q.sql",
"chars": 90,
"preview": "SELECT DISTINCT author_id AS id FROM Views WHERE author_id = viewer_id ORDER BY author_id;"
},
{
"path": "Assign Cookies/kata.go",
"chars": 410,
"preview": "package Assign_Cookies\n\nimport \"sort\"\n\nfunc findContentChildren(g []int, s []int) int {\n\tif len(s) == 0 {\n\t\treturn 0\n\t}\n"
},
{
"path": "Average Salary Excluding the Minimum and Maximum Salary/kata.go",
"chars": 243,
"preview": "package kata\n\nimport \"sort\"\n\nfunc average(salary []int) float64 {\n\tsort.Ints(salary)\n\tsalary = salary[1 : len(salary)-1]"
},
{
"path": "Average Selling Price/q.sql",
"chars": 307,
"preview": "SELECT p.product_id,\n ROUND(Sum(p.price * us.units) / Sum(us.units), 2) AS average_price\nFROM unitssold AS us\n "
},
{
"path": "Average Time of Process per Machine/q.sql",
"chars": 294,
"preview": "SELECT\n machine_id,\n ROUND(\n (\n SUM(\n CASE WHEN activity_type = \"end\" THEN timestamp ELSE 0 END\n )"
},
{
"path": "Average Value of Even Numbers That Are Divisible by Three/kata.java",
"chars": 404,
"preview": "class Solution {\n public int averageValue(int[] nums) {\n var sum = 0;\n var count = 0;\n\n for (var"
},
{
"path": "Average of Levels in Binary Tree/kata.go",
"chars": 909,
"preview": "package kata\n\nimport \"container/list\"\n\ntype TreeNode struct {\n\tVal int\n\tLeft *TreeNode\n\tRight *TreeNode\n}\n\nfunc avera"
},
{
"path": "Backspace String Compare/kata.go",
"chars": 370,
"preview": "package kata\n\nfunc backspaceCompare(S string, T string) bool {\n\treturn mod(S) == mod(T)\n}\n\nfunc mod(S string) string {\n\t"
},
{
"path": "Bank Account Summary/q.sql",
"chars": 775,
"preview": "SELECT\n Ux.user_id,\n Ux.user_name,\n (credit + SUM(COALESCE(Tx.amount, 0))) AS credit,\n (\n CASE WHEN ("
},
{
"path": "Bank Account Summary II/q.sql",
"chars": 148,
"preview": "SELECT u.name, SUM(amount) AS balance FROM Users AS u INNER JOIN Transactions AS t ON t.account = u.account GROUP BY u.n"
},
{
"path": "Base 7/kata.go",
"chars": 515,
"preview": "package kata\n\nfunc convertToBase7(num int) string {\n\n\tif num == 0 {\n\t\treturn \"0\"\n\t}\n\n\tvar neg bool\n\tif num < 0 {\n\t\tnum ="
},
{
"path": "Baseball Game/kata.go",
"chars": 561,
"preview": "package kata\n\nimport \"strconv\"\n\nfunc calPoints(ops []string) int {\n\thistory := make([]int, 0)\n\tfor _, op := range ops {\n"
},
{
"path": "Basic Calculator II/kata.go",
"chars": 2422,
"preview": "package kata\n\nimport (\n\t\"container/list\"\n)\n\nfunc calculate(s string) int {\n\tnodes := Parse([]byte(s))\n\treturn Eval(nodes"
},
{
"path": "Best Poker Hand/kata.go",
"chars": 421,
"preview": "package kata\n\nfunc bestHand(ranks []int, suits []byte) string {\n\n\tc := make([]int, 13+4)\n\tfor i, suit := range suits {\n\t"
},
{
"path": "Best Time to Buy and Sell Stock/kata.go",
"chars": 268,
"preview": "package kata\n\nfunc maxProfit(prices []int) int {\n\tmin := -1\n\tvar maxProfit int\n\tfor i := 0; i < len(prices); i++ {\n\t\tif "
},
{
"path": "Big Countries/kata.sql",
"chars": 101,
"preview": "package kata\n\nSELECT name,population,area FROM World WHERE area > 3000000 OR population > 25000000;\n\n"
},
{
"path": "Biggest Single Number/q.sql",
"chars": 126,
"preview": "(SELECT num\n FROM mynumbers GROUP BY num\n HAVING Count(num) = 1\n ORDER BY num DESC\n LIMIT 1)\nUNION\n(SELECT NULL)\nL"
},
{
"path": "Binary Gap/kata.go",
"chars": 334,
"preview": "package kata\n\nfunc binaryGap(n int) int {\n\tvar globalMax int\n\tvar max int\n\tfor n != 0 {\n\t\tr := n % 2\n\t\tn = n / 2\n\t\tif r "
},
{
"path": "Binary Number with Alternating Bits/kata.go",
"chars": 193,
"preview": "package kata\n\nfunc hasAlternatingBits(n int) bool {\n\tlastBit := n % 2\n\tn = n >> 1\n\tfor n > 0 {\n\t\tb := n % 2\n\t\tn = n >> 1"
},
{
"path": "Binary Prefix Divisible By 5/kata.py",
"chars": 767,
"preview": "class Solution(object):\n def prefixesDivBy5(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: Li"
},
{
"path": "Binary Search Tree Iterator/kata.go",
"chars": 1060,
"preview": "package kata\n\nimport \"sort\"\n\ntype TreeNode struct {\n\tVal int\n\tLeft *TreeNode\n\tRight *TreeNode\n}\n\ntype BSTIterator str"
},
{
"path": "Binary Tree Inorder Traversal/kata.go",
"chars": 418,
"preview": "package kata\n\ntype TreeNode struct {\n\tVal int\n\tLeft *TreeNode\n\tRight *TreeNode\n}\n\nfunc inorderTraversal(root *TreeNod"
},
{
"path": "Binary Tree Paths/kata.go",
"chars": 622,
"preview": "package kata\n\nimport \"strconv\"\n\ntype TreeNode struct {\n\tVal int\n\tLeft *TreeNode\n\tRight *TreeNode\n}\n\nfunc binaryTreePa"
},
{
"path": "Binary Tree Postorder Traversal/kata.go",
"chars": 420,
"preview": "package kata\n\ntype TreeNode struct {\n\tVal int\n\tLeft *TreeNode\n\tRight *TreeNode\n}\n\nfunc postorderTraversal(root *TreeN"
},
{
"path": "Binary Tree Preorder Traversal/kata.go",
"chars": 419,
"preview": "package kata\n\ntype TreeNode struct {\n\tVal int\n\tLeft *TreeNode\n\tRight *TreeNode\n}\n\nfunc preorderTraversal(root *TreeNo"
},
{
"path": "Build Array from Permutation/kata.go",
"chars": 174,
"preview": "package kata\n\nfunc buildArray(nums []int) []int {\n\n\tpermNums := make([]int, len(nums))\n\tfor i := 0; i < len(nums); i++ {"
},
{
"path": "Buildings With an Ocean View/kata.java",
"chars": 578,
"preview": "class Solution {\n public int[] findBuildings(int[] heights) {\n var n = heights.length;\n Stack<Integer> "
},
{
"path": "Bulls and Cows/kata.go",
"chars": 804,
"preview": "package kata\n\nimport \"strconv\"\n\nfunc getHint(secret string, guess string) string {\n\tvar bulls int\n\tvar cows int\n\n\tchars "
},
{
"path": "Calculate Amount Paid in Taxes/kata.go",
"chars": 562,
"preview": "package Calculate_Amount_Paid_in_Taxes\n\nfunc calculateTax(brackets [][]int, income int) float64 {\n\n\tif income == 0 {\n\t\tr"
},
{
"path": "Calculate Money in Leetcode Bank/kata.go",
"chars": 238,
"preview": "package kata\n\nfunc totalMoney(n int) int {\n\tcount := 0\n\tdays := 0\n\tbouns := 0\n\tmoney := 1\n\tfor i := 0; i < n; i++ {\n\t\tco"
},
{
"path": "Calculate Salaries/q.sql",
"chars": 454,
"preview": "select\n company_id,\n employee_id,\n employee_name,\n (CASE\n WHEN (MAX(salary) OVER(PARTITION BY compan"
},
{
"path": "Calculate Special Bonus/q.sql",
"chars": 138,
"preview": "SELECT employee_id,\n CASE\n WHEN employee_id % 2 = 1 AND LEFT(name, 1) != 'M' THEN salary\n ELSE 0\nEND AS bon"
},
{
"path": "Calculate the Influence of Each Salesperson/q.sql",
"chars": 216,
"preview": "SELECT salesperson_id,\n name,\n IFNULL(SUM(price), 0) AS total\nFROM Salesperson AS s\n LEFT JOIN Custo"
},
{
"path": "Calculator with Method Chaining/kata.js",
"chars": 1297,
"preview": "class Calculator {\n \n /** \n * @param {number} value\n */\n constructor(value) {\n this.currentValue"
},
{
"path": "Can Make Arithmetic Progression From Sequence/kata.go",
"chars": 292,
"preview": "package kata\n\nimport \"sort\"\n\nfunc canMakeArithmeticProgression(arr []int) bool {\n\tif len(arr) == 2 {\n\t\treturn true\n\t}\n\n\t"
},
{
"path": "Can Place Flowers/kata.go",
"chars": 316,
"preview": "package kata\n\nfunc canPlaceFlowers(flowerbed []int, n int) bool {\n\n\tfor i := 0; i < len(flowerbed); i++ {\n\t\tif flowerbed"
},
{
"path": "Capital Gain-loss/q.sql",
"chars": 153,
"preview": "SELECT\n s.stock_name,\n SUM(CASE WHEN s.operation=\"Buy\" THEN -s.price ELSE s.price END) AS capital_gain_loss\nFROM S"
},
{
"path": "Capitalize the Title/kata.go",
"chars": 540,
"preview": "package Capitalize_the_Title\n\nfunc capitalizeTitle(title string) string {\n\n\tb := make([]byte, len(title))\n\tvar c int\n\tva"
},
{
"path": "Categorize Box According to Criteria/kata.java",
"chars": 1347,
"preview": "class Solution {\n public String categorizeBox(int length, int width, int height, int mass) {\n var bulky = fals"
},
{
"path": "Cells with Odd Values in a Matrix/kata.go",
"chars": 500,
"preview": "package kata\n\nfunc oddCells(n int, m int, indices [][]int) int {\n\tif n == 0 {\n\t\treturn 0\n\t}\n\tmatrix := make([][]int, n)\n"
},
{
"path": "Change Data Type/kata.py",
"chars": 154,
"preview": "import pandas as pd\n\ndef changeDatatype(students: pd.DataFrame) -> pd.DataFrame:\n students['grade'] = students['grade"
},
{
"path": "Check Distances Between Same Letters/kata.java",
"chars": 824,
"preview": "class Solution {\n public boolean checkDistances(String s, int[] distance) {\n for (var i = 0; i < s.length(); i"
},
{
"path": "Check If All 1's Are at Least Length K Places Away/kata.go",
"chars": 338,
"preview": "package kata\n\nfunc kLengthApart(nums []int, k int) bool {\n\tvar currentK *int\n\tfor i := 0; i < len(nums); i++ {\n\t\tif nums"
},
{
"path": "Check If N and Its Double Exist/kata.go",
"chars": 276,
"preview": "package kata\n\nfunc checkIfExist(arr []int) bool {\n\n\tdoubles := make(map[int]int)\n\tfor i := 0; i < len(arr); i++ {\n\t\tdoub"
},
{
"path": "Check If Two String Arrays are Equivalent/kata.go",
"chars": 634,
"preview": "package kata\n\nfunc arrayStringsAreEqual(word1 []string, word2 []string) bool {\n\n\tvar i int\n\tvar j int\n\tvar a int\n\tvar b "
},
{
"path": "Check If a Number Is Majority Element in a Sorted Array/kata.java",
"chars": 270,
"preview": "class Solution {\n public boolean isMajorityElement(int[] nums, int target) {\n var count = 0;\n for (va"
},
{
"path": "Check If a Word Occurs As a Prefix of Any Word in a Sentence/kata.go",
"chars": 495,
"preview": "package kata\n\nfunc isPrefixOfWord(sentence string, searchWord string) int {\n\tvar wordCounter int\n\tvar matched bool\n\tvar "
},
{
"path": "Check Whether Two Strings are Almost Equivalent/kata.go",
"chars": 510,
"preview": "package Check_Whether_Two_Strings_are_Almost_Equivalent\n\nimport \"math\"\n\nfunc checkAlmostEquivalent(word1 string, word2 s"
},
{
"path": "Check if All A's Appears Before All B's/kata.go",
"chars": 188,
"preview": "package Check_if_All_A_s_Appears_Before_All_B_s\n\nfunc checkString(s string) bool {\n\tfor i := 1; i < len(s); i++ {\n\t\tif s"
},
{
"path": "Check if All Characters Have Equal Number of Occurrences/kata.go",
"chars": 361,
"preview": "package kata\n\nimport \"math\"\n\nfunc areOccurrencesEqual(s string) bool {\n\n\tchars := make(map[byte]int)\n\tfor i := 0; i < le"
},
{
"path": "Check if Binary String Has at Most One Segment of Ones/kata.go",
"chars": 446,
"preview": "package Check_if_Binary_String_Has_at_Most_One_Segment_of_Ones\n\nfunc checkOnesSegment(s string) bool {\n\n\tif len(s) == 1 "
},
{
"path": "Check if Bitwise OR Has Trailing Zeros/kata.go",
"chars": 189,
"preview": "package kata\n\nfunc hasTrailingZeros(nums []int) bool {\n\tvar count int\n\tfor _, num := range nums {\n\t\tif num%2 == 0 {\n\t\t\tc"
},
{
"path": "Check if Number Has Equal Digit Count and Digit Value/kata.go",
"chars": 272,
"preview": "package Check_if_Number_Has_Equal_Digit_Count_and_Digit_Value\n\nfunc digitCount(num string) bool {\n\n\tc := map[rune]int{}\n"
},
{
"path": "Check if Numbers Are Ascending in a Sentence/kata.go",
"chars": 590,
"preview": "package kata\n\nimport \"math\"\n\nfunc areNumbersAscending(s string) bool {\n\n\tcurrentNumber := int(math.Inf(-1))\n\tfor i := le"
},
{
"path": "Check if One String Swap Can Make Strings Equal/kata.go",
"chars": 497,
"preview": "package kata\n\nfunc areAlmostEqual(s1 string, s2 string) bool {\n\tif len(s1) != len(s1) {\n\t\treturn false\n\t}\n\tif s1 == s2 {"
},
{
"path": "Check if The Number is Fascinating/kata.go",
"chars": 455,
"preview": "package kata\n\nfunc isFascinating(n int) bool {\n\tvar stats = [9]int{}\n\tvar tracker int = 0\n\tfor i := 1; i <= 3; i++ {\n\t\to"
},
{
"path": "Check if Word Equals Summation of Two Words/kata.go",
"chars": 314,
"preview": "package kata\n\nfunc isSumEqual(firstWord string, secondWord string, targetWord string) bool {\n\treturn sum(firstWord)+sum("
},
{
"path": "Check if an Array Is Consecutive/kata.go",
"chars": 378,
"preview": "package Check_if_an_Array_Is_Consecutive\n\nimport \"sort\"\n\nfunc isConsecutive(nums []int) bool {\n\n\tsort.Ints(nums)\n\n\tmin, "
},
{
"path": "Check if the Sentence Is Pangram/kata.go",
"chars": 240,
"preview": "package kata\n\nfunc checkIfPangram(sentence string) bool {\n\n\tvar abc [26]int\n\tvar count int\n\tfor _, char := range sentenc"
},
{
"path": "Classes More Than 5 Students/kata.sql",
"chars": 93,
"preview": "package kata\n\nSELECT class FROM courses GROUP BY class HAVING COUNT(DISTINCT(student)) >= 5;\n"
},
{
"path": "Climbing Stairs/kata.go",
"chars": 191,
"preview": "package kata\n\nfunc climbStairs(n int) int {\n\tif n == 1 {\n\t\treturn 1\n\t}\n\tdp := make([]int, n+1)\n\tdp[1] = 1\n\tdp[2] = 2\n\tfo"
},
{
"path": "Combine Two Tables/kata.sql",
"chars": 162,
"preview": "package kata\n\n# Write your MySQL query statement below\nSELECT p.FirstName, p.LastName, City, State FROM Person p LEFT JO"
},
{
"path": "Compare Strings by Frequency of the Smallest Character/kata.go",
"chars": 724,
"preview": "package kata\n\nimport \"sort\"\n\nfunc numSmallerByFrequency(queries []string, words []string) []int {\n\tnums := make([]int, l"
},
{
"path": "Complement of Base 10 Integer/kata.go",
"chars": 300,
"preview": "package kata\n\nimport \"math\"\n\nfunc bitwiseComplement(N int) int {\n\tif N == 0 {\n\t\treturn 1\n\t} else if N == 1 {\n\t\treturn 0\n"
},
{
"path": "Compute the Rank as a Percentage/q.sql",
"chars": 532,
"preview": "\nWITH cte\n AS (SELECT student_id,\n department_id,\n RANK() OVER (PARTITION "
},
{
"path": "Concatenate the Name and the Profession/q.sql",
"chars": 106,
"preview": "SELECT person_id, CONCAT(name, '(', LEFT(profession, 1) ,')') as name FROM Person ORDER BY person_id DESC;"
},
{
"path": "Concatenation of Array/kata.go",
"chars": 218,
"preview": "package kata\n\nfunc getConcatenation(nums []int) []int {\n\n\tnumsDouble := make([]int, len(nums)*2)\n\tfor i := 0; i < len(nu"
},
{
"path": "Confusing Number/kata.java",
"chars": 739,
"preview": "class Solution {\n public boolean confusingNumber(int num) {\n var digitCount = ((int) Math.log10((double) num))"
},
{
"path": "Consecutive Available Seats/q.sql",
"chars": 448,
"preview": "((\n SELECT\n b.seat_id\n FROM\n Cinema AS a\n INNER JOIN\n Cinema AS b\n O"
},
{
"path": "Consecutive Characters/kata.go",
"chars": 403,
"preview": "package kata\n\nimport \"math\"\n\nfunc maxPower(s string) int {\n\tif len(s) == 0 {\n\t\treturn 0\n\t}\n\tif len(s) == 1 {\n\t\treturn 1\n"
},
{
"path": "Construct Binary Search Tree from Preorder Traversal/kata.go",
"chars": 633,
"preview": "package kata\n\n/**\n * Definition for a binary tree node.\n * type TreeNode struct {\n * Val int\n * Left *TreeNode\n "
},
{
"path": "Construct String from Binary Tree/kata.java",
"chars": 1176,
"preview": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNo"
},
{
"path": "Construct the Rectangle/kata.go",
"chars": 377,
"preview": "package Construct_the_Rectangle\n\nimport \"math\"\n\nfunc constructRectangle(area int) []int {\n\tif area == 1 {\n\t\treturn []int"
},
{
"path": "Contains Duplicate/kata.go",
"chars": 228,
"preview": "package kata\n\nfunc containsDuplicate(nums []int) bool {\n\tcounter := make(map[int]int)\n\tfor i := 0; i < len(nums); i++ {\n"
},
{
"path": "Contains Duplicate II/kata.go",
"chars": 297,
"preview": "package kata\n\nfunc containsNearbyDuplicate(nums []int, k int) bool {\n\n\ti := 0\n\tj := i + 1\n\tfor i < len(nums) {\n\n\t\tif j ="
},
{
"path": "Convert 1D Array Into 2D Array/kata.go",
"chars": 375,
"preview": "package kata\n\nfunc construct2DArray(original []int, m int, n int) [][]int {\n\n\tif m*n != len(original) {\n\t\treturn [][]int"
},
{
"path": "Convert Binary Number in a Linked List to Integer/kata.go",
"chars": 635,
"preview": "package kata\n\n/**\n * Definition for singly-linked list.\n * type ListNode struct {\n * Val int\n * Next *ListNode\n "
},
{
"path": "Convert Date Format/q.sql",
"chars": 58,
"preview": "SELECT DATE_FORMAT(day, \"%W, %M %e, %Y\") AS day FROM Days;"
},
{
"path": "Convert Integer to the Sum of Two No-Zero Integers/kata.go",
"chars": 325,
"preview": "package Convert_Integer_to_the_Sum_of_Two_No_Zero_Integers\n\nfunc getNoZeroIntegers(n int) []int {\n\ti := 1\n\tvar k int\n\tfo"
},
{
"path": "Convert a Number to Hexadecimal/kata.go",
"chars": 502,
"preview": "package kata\n\nimport \"math/bits\"\n\nfunc toHex(num int) string {\n\tif num == 0 {\n\t\treturn \"0\"\n\t}\n\n\tn := uint(num)\n\n\thex := "
},
{
"path": "Convert the Temperature/kata.java",
"chars": 235,
"preview": "class Solution {\n public double[] convertTemperature(double celsius) {\n double fahrenheit = (celsius * 9/5) + "
},
{
"path": "Count Apples and Oranges/q.sql",
"chars": 228,
"preview": "SELECT (SUM(b.apple_count)+COALESCE(SUM(c.apple_count), 0)) AS apple_count,\n (SUM(b.orange_count)+COALESCE(SUM(c.o"
},
{
"path": "Count Asterisks/kata.java",
"chars": 560,
"preview": "class Solution {\n public int countAsterisks(String s) {\n var skip = false;\n var count = 0;\n for "
},
{
"path": "Count Common Words With One Occurrence/kata.go",
"chars": 521,
"preview": "package kata\n\nfunc countWords(words1 []string, words2 []string) int {\n\n\ttype wordCounter struct {\n\t\tA, B int\n\t}\n\n\tcounte"
},
{
"path": "Count Complete Tree Nodes/kata.go",
"chars": 453,
"preview": "package kata\n\n/**\n * Definition for a binary tree node.\n * type TreeNode struct {\n * Val int\n * Left *TreeNode\n "
},
{
"path": "Count Elements With Maximum Frequency/kata.go",
"chars": 436,
"preview": "package kata\n\nfunc maxFrequencyElements(nums []int) int {\n var max = 0\n var total = 0\n frequencies := make(map["
},
{
"path": "Count Elements With Strictly Smaller and Greater Elements/kata.go",
"chars": 543,
"preview": "package Count_Elements_With_Strictly_Smaller_and_Greater_Elements\n\nimport \"sort\"\n\nfunc countElements(nums []int) int {\n\t"
},
{
"path": "Count Integers With Even Digit Sum/kata.go",
"chars": 392,
"preview": "package Count_Integers_With_Even_Digit_Sum\n\nvar mem = map[int]int{}\n\nfunc countEven(num int) int {\n\n\tc := 0\n\ti := 1\n\tfor"
},
{
"path": "Count Items Matching a Rule/kata.go",
"chars": 332,
"preview": "package kata\n\nfunc countMatches(items [][]string, ruleKey string, ruleValue string) int {\n\n\tidx := 0\n\tif ruleKey == \"typ"
},
{
"path": "Count Largest Group/kata.java",
"chars": 1296,
"preview": "class Solution {\n public int countLargestGroup(int n) {\n HashMap<Integer, Integer> bucket = new HashMap<>();\n "
},
{
"path": "Count Negative Numbers in a Sorted Matrix/kata.rs",
"chars": 389,
"preview": "package kata\n\nimpl Solution {\n pub fn count_negatives(grid: Vec<Vec<i32>>) -> i32 {\n let mut counter: i32 = 0;"
},
{
"path": "Count Odd Numbers in an Interval Range/kata.go",
"chars": 150,
"preview": "package kata\n\nfunc countOdds(low int, high int) int {\n\tvar count int\n\tfor ; low < high+1; low++ {\n\t\tif low%2 == 1 {\n\t\t\tc"
},
{
"path": "Count Operations to Obtain Zero/kata.go",
"chars": 413,
"preview": "package Count_Operations_to_Obtain_Zero\n\nfunc countOperations(num1 int, num2 int) int {\n\n\tif num1 == 0 || num2 == 0 {\n\t\t"
},
{
"path": "Count Prefixes of a Given String/kata.go",
"chars": 231,
"preview": "package Count_Prefixes_of_a_Given_String\n\nfunc countPrefixes(words []string, s string) int {\n\tvar count int\n\tfor _, w :="
},
{
"path": "Count Student Number in Departments/q.sql",
"chars": 229,
"preview": "SELECT dept_name,\n COUNT(s.dept_id) AS student_number\nFROM Department AS d\n LEFT JOIN Student AS s\n "
},
{
"path": "Count Substrings Starting and Ending with Given Character/kata.py",
"chars": 320,
"preview": "import math\n \nclass Solution(object):\n def countSubstrings(self, s, c):\n \"\"\"\n :type s: str\n "
},
{
"path": "Count Tested Devices After Test Operations/kata.go",
"chars": 283,
"preview": "package kata\n\nfunc countTestedDevices(batteryPercentages []int) int {\n\tvar counter int\n\tfor i := 0; i < len(batteryPerce"
},
{
"path": "Count Total Number of Colored Cells/kata.go",
"chars": 90,
"preview": "package kata\n\nfunc coloredCells(n int) int64 {\n\tk := int64(n)\n\treturn k*k + (k-1)*(k-1)\n}\n"
},
{
"path": "Count of Matches in Tournament/kata.go",
"chars": 229,
"preview": "package kata\n\nfunc numberOfMatches(n int) int {\n\n\tvar totalMatches int\n\tfor n > 1 {\n\t\tif n%2 == 0 {\n\t\t\tn = n / 2\n\t\t\ttota"
},
{
"path": "Count the Digits That Divide a Number/kata.java",
"chars": 280,
"preview": "class Solution {\n public int countDigits(int num) {\n var c = 0;\n var oldNum = num;\n do {\n "
},
{
"path": "Count the Number of Consistent Strings/kata.go",
"chars": 351,
"preview": "package kata\n\nfunc countConsistentStrings(allowed string, words []string) int {\n\n\tset := make(map[rune]bool)\n\tfor _, cha"
},
{
"path": "Counter/kata.ts",
"chars": 206,
"preview": "function createCounter(n: number): () => number { \n return function() {\n return n++\n }\n}\n\n\n/** \n * const co"
},
{
"path": "Counter II/kata.ts",
"chars": 718,
"preview": "type Counter = {\n increment: () => number,\n decrement: () => number,\n reset: () => number,\n}\n\nfunction createCo"
},
{
"path": "Counting Bits/kata.go",
"chars": 207,
"preview": "package kata\n\nfunc countBits(n int) []int {\n\to := make([]int, n+1)\n\tfor k := 0; k <= n; k++ {\n\t\tvar num = k\n\t\tvar count "
},
{
"path": "Counting Elements/kata.go",
"chars": 718,
"preview": "package kata\n\nimport \"math\"\n\nfunc countElements(arr []int) int {\n\tinit := int(math.Inf(-1))\n\n\tmax := init\n\tmin := init\n\t"
},
{
"path": "Counting Words With a Given Prefix/kata.go",
"chars": 212,
"preview": "package Counting_Words_With_a_Given_Prefix\n\nfunc prefixCount(words []string, pref string) int {\n\tvar c int\n\tfor _, w := "
},
{
"path": "Cousins in Binary Tree/kata.go",
"chars": 1247,
"preview": "package kata\n\nimport \"container/list\"\n\n/**\n * Definition for a binary tree node.\n * type TreeNode struct {\n * Val in"
},
{
"path": "Create Hello World Function/kata.ts",
"chars": 179,
"preview": "function createHelloWorld() {\n \n return function(...args): string {\n return \"Hello World\"\n };\n};\n\n/**\n *"
},
{
"path": "Create Target Array in the Given Order/kata.go",
"chars": 528,
"preview": "package kata\n\nfunc createTargetArray(nums []int, index []int) []int {\n\tif len(nums) != len(index) {\n\t\tpanic(\"index and n"
},
{
"path": "Create a DataFrame from List/kata.py",
"chars": 158,
"preview": "import pandas as pd\n\ndef createDataframe(student_data: List[List[int]]) -> pd.DataFrame:\n return pd.DataFrame(student"
},
{
"path": "Create a New Column/kata.py",
"chars": 155,
"preview": "import pandas as pd\n\ndef createBonusColumn(employees: pd.DataFrame) -> pd.DataFrame:\n employees[\"bonus\"] = employees["
},
{
"path": "Create a Session Bar Chart/q.sql",
"chars": 685,
"preview": "\nWITH cte AS (SELECT\n COUNT(CASE WHEN (duration/60) <= 5 THEN session_id END) AS total_1,\n COUNT(CASE WHEN (durati"
},
{
"path": "Custom Sort String/kata.go",
"chars": 299,
"preview": "package kata\n\nimport \"sort\"\n\nfunc customSortString(S string, T string) string {\n\torder := 1\n\torders := make(map[rune]int"
},
{
"path": "Customer Placing the Largest Number of Orders/q.sql",
"chars": 107,
"preview": "SELECT customer_number FROM Orders AS o GROUP BY customer_number ORDER BY COUNT(order_number) DESC LIMIT 1;"
},
{
"path": "Customer Who Visited but Did Not Make Any Transactions/q.sql",
"chars": 138,
"preview": "SELECT customer_id, COUNT(*) AS count_no_trans FROM Visits WHERE visit_id NOT IN (SELECT visit_id FROM Transactions) GRO"
},
{
"path": "Customers Who Never Order/kata.sql",
"chars": 120,
"preview": "package kata\n\nSELECT c.name as Customers FROM Customers c left join Orders o on o.CustomerId = c.Id WHERE o.Id IS NULL;\n"
},
{
"path": "DI String Match/kata.go",
"chars": 293,
"preview": "package kata\n\nfunc diStringMatch(S string) []int {\n\tn := make([]int, len(S)+1)\n\tj := len(S)\n\tk := 0\n\tfor i := 0; i < len"
},
{
"path": "Daily Leads and Partners/q.sql",
"chars": 158,
"preview": "SELECT date_id, make_name, COUNT(DISTINCT lead_id) AS unique_leads, COUNT(DISTINCT partner_id) AS unique_partners\nFROM D"
},
{
"path": "Day of the Year/kata.go",
"chars": 335,
"preview": "package Day_of_the_Year\n\nimport (\n\t\"time\"\n)\n\nfunc dayOfYear(date string) int {\n\td, err := time.Parse(\"2006-01-02\", date)"
},
{
"path": "Decode XORed Array/kata.go",
"chars": 259,
"preview": "package Decode_XORed_Array]\n\nfunc decode(encoded []int, first int) []int {\n\tdecoded := make([]int, len(encoded)+1)\n\tdeco"
},
{
"path": "Decode the Message/kata.go",
"chars": 498,
"preview": "package Decode_the_Message\n\nfunc decodeMessage(key string, message string) string {\n\n\tdecoderTable := map[rune]rune{}\n\n\t"
},
{
"path": "Decompress Run-Length Encoded List/kata.go",
"chars": 231,
"preview": "package kata\n\nfunc decompressRLElist(nums []int) []int {\n\tvalues := make([]int, 0, len(nums)/2)\n\tfor i := 0; i < len(num"
},
{
"path": "Decrypt String from Alphabet to Integer Mapping/kata.go",
"chars": 792,
"preview": "package kata\n\nfunc freqAlphabets(s string) string {\n\n\tts := make([]byte, 0, len(s)/3*2)\n\n\tfor i := len(s) - 1; i >= 0; i"
},
{
"path": "Deepest Leaves Sum/kata.go",
"chars": 995,
"preview": "package kata\n\n/**\n * Definition for a binary tree node.\n * type TreeNode struct {\n * Val int\n * Left *TreeNode\n "
},
{
"path": "Defanging an IP Address/kata.go",
"chars": 311,
"preview": "package kata\n\nfunc defangIPaddr(address string) string {\n\tdefangAddress := make([]rune, 0, len(address)+6)\n\tfor _, char "
},
{
"path": "Delete Characters to Make Fancy String/kata.go",
"chars": 327,
"preview": "package Delete_Characters_to_Make_Fancy_String\n\nfunc makeFancyString(s string) string {\n\tc := 1\n\tchar := s[0]\n\tb := make"
},
{
"path": "Delete Duplicate Emails/kata.sql",
"chars": 114,
"preview": "package kata\n\nDELETE p1 FROM Person p1\nINNER JOIN Person p2\nWHERE\n p1.id > p2.id AND \n p1.email = p2.email;\n"
},
{
"path": "Delete Greatest Value in Each Row/kata.go",
"chars": 322,
"preview": "package kata\n\nimport \"sort\"\n\nfunc deleteGreatestValue(grid [][]int) int {\n\tfor i := 0; i < len(grid); i++ {\n\t\tsort.Ints("
},
{
"path": "Delete Leaves With a Given Value/kata.go",
"chars": 1065,
"preview": "package kata\n\n/**\n * Definition for a binary tree node.\n * type TreeNode struct {\n * Val int\n * Left *TreeNode\n "
},
{
"path": "Delete Node in a Linked List/kata.go",
"chars": 146,
"preview": "package Delete_Node_in_a_Linked_List\n\ntype ListNode struct {\n\tVal int\n\tNext *ListNode\n}\n\nfunc deleteNode(node *ListNode"
},
{
"path": "Delete the Middle Node of a Linked List/kata.go",
"chars": 548,
"preview": "package Delete_the_Middle_Node_of_a_Linked_List\n\ntype ListNode struct {\n\tVal int\n\tNext *ListNode\n}\n\nfunc deleteMiddle(h"
},
{
"path": "Design Add and Search Words Data Structure/kata.go",
"chars": 1225,
"preview": "package Design_Add_and_Search_Words_Data_Structure\n\ntype node struct {\n\tword bool\n\tnodes [26]*node\n}\n\ntype WordDictiona"
},
{
"path": "Design HashMap/kata.go",
"chars": 1460,
"preview": "package kata\n\nimport \"container/list\"\n\ntype HashMapValue struct {\n\tkey int\n\tvalue int\n}\n\ntype MyHashMap struct {\n\tbuck"
},
{
"path": "Design HashSet/kata.go",
"chars": 1121,
"preview": "package kata\n\nimport (\n\t\"container/list\"\n)\n\ntype MyHashSet struct {\n\tbuckets []*list.List\n}\n\n/** Initialize your data st"
},
{
"path": "Design Linked List/kata_test.go",
"chars": 2193,
"preview": "package Design_Linked_List\n\ntype Node struct {\n\tval int\n\tnext *Node\n}\n\ntype MyLinkedList struct {\n\trootNode *Node\n\tleng"
},
{
"path": "Design Parking System/kata.go",
"chars": 783,
"preview": "package kata\n\ntype ParkingSystem struct {\n\tbig, medium, small int\n}\n\nfunc Constructor(big int, medium int, small int) Pa"
},
{
"path": "Design a Stack With Increment Operation/kata.go",
"chars": 870,
"preview": "package kata\n\ntype CustomStack struct {\n\telements []int\n\tmaxSize int\n}\n\nfunc Constructor(maxSize int) CustomStack {\n\tre"
},
{
"path": "Design an Ordered Stream/kata.go",
"chars": 671,
"preview": "package Design_an_Ordered_Stream\n\ntype OrderedStream struct {\n\tvalues []*string\n\tcurrentIndex int\n}\n\nfunc Construc"
},
{
"path": "Destination City/kata.go",
"chars": 253,
"preview": "package kata\n\nfunc destCity(paths [][]string) string {\n\tstart := make(map[string]bool)\n\n\tfor _, v := range paths {\n\t\tsta"
},
{
"path": "Detect Capital/kata.go",
"chars": 392,
"preview": "package kata\n\nfunc detectCapitalUse(word string) bool {\n\tvar capitals int\n\tvar lowers int\n\tfor i := 0; i < len(word); i+"
},
{
"path": "Determine Color of a Chessboard Square/kata.go",
"chars": 276,
"preview": "package kata\n\nfunc squareIsWhite(coordinates string) bool {\n\ta := int(coordinates[0]) - 96\n\tb := int(coordinates[1]) - 4"
},
{
"path": "Determine if String Halves Are Alike/kata.go",
"chars": 355,
"preview": "package kata\n\nfunc halvesAreAlike(s string) bool {\n\taCount := count(s[len(s)/2:])\n\tbCount := count(s[:len(s)/2])\n\n\tif aC"
},
{
"path": "Determine if Two Events Have Conflict/kata.java",
"chars": 739,
"preview": "import java.time.LocalTime;\n\nclass Solution {\n public boolean haveConflict(String[] event1, String[] event2) {\n "
},
{
"path": "Diet Plan Performance/kata.java",
"chars": 650,
"preview": "class Solution {\n public int dietPlanPerformance(int[] calories, int k, int lower, int upper) {\n var gained = "
},
{
"path": "Difference Between Element Sum and Digit Sum of an Array/kata.java",
"chars": 408,
"preview": "class Solution {\n public int differenceOfSum(int[] nums) {\n var elementSum = 0;\n var digitSum = 0;\n "
},
{
"path": "Display the First Three Rows/kata.py",
"chars": 112,
"preview": "import pandas as pd\n\ndef selectFirstRows(employees: pd.DataFrame) -> pd.DataFrame:\n return employees.iloc[:3]"
},
{
"path": "Distinct Numbers in Each Subarray/kata.java",
"chars": 781,
"preview": "class Solution {\n public int[] distinctNumbers(int[] nums, int k) {\n var ans = new int[nums.length-k+1];\n "
},
{
"path": "Distribute Candies to People/kata.go",
"chars": 305,
"preview": "package kata\n\nfunc distributeCandies(candies int, num_people int) []int {\n\tpeople := make([]int, num_people)\n\tcd := 1\n\tv"
},
{
"path": "Distribute Elements Into Two Arrays I/kata.go",
"chars": 342,
"preview": "package kata\n\nfunc resultArray(nums []int) []int {\n\tvar a, b = make([]int, 0), make([]int, 0)\n\n\ta = append(a, nums[0])\n\t"
},
{
"path": "Divide Array Into Equal Pairs/kata.go",
"chars": 215,
"preview": "package Divide_Array_Into_Equal_Pairs\n\nimport \"sort\"\n\nfunc divideArray(nums []int) bool {\n\tsort.Ints(nums)\n\n\tfor i := 1;"
},
{
"path": "Divide a String Into Groups of Size k/kata.go",
"chars": 563,
"preview": "package Divide_a_String_Into_Groups_of_Size_k\n\nfunc divideString(s string, k int, fill byte) []string {\n\n\tres := make([]"
},
{
"path": "Divisible and Non-divisible Sums Difference/kata.go",
"chars": 268,
"preview": "package main\n\nfunc differenceOfSums(n int, m int) int {\n\tvar sumDivisible, sumNotDivisible = 0, 0\n\tfor num := 1; num <= "
},
{
"path": "Dot Product of Two Sparse Vectors/kata.go",
"chars": 609,
"preview": "package Dot_Product_of_Two_Sparse_Vectors\n\ntype SparseVector struct {\n\tValues map[int]int\n}\n\nfunc Constructor(nums []int"
},
{
"path": "Drop Duplicate Rows/kata.py",
"chars": 167,
"preview": "import pandas as pd\n\ndef dropDuplicateEmails(customers: pd.DataFrame) -> pd.DataFrame:\n customers = customers.drop_du"
},
{
"path": "Drop Missing Data/kata.py",
"chars": 149,
"preview": "import pandas as pd\n\ndef dropMissingData(students: pd.DataFrame) -> pd.DataFrame:\n students = students.dropna(subset="
},
{
"path": "Duplicate Emails/kata.sql",
"chars": 88,
"preview": "package kata\n\nSELECT DISTINCT(email) FROM Person GROUP BY email HAVING count(email) > 1\n"
},
{
"path": "Duplicate Zeros/kata.go",
"chars": 210,
"preview": "package kata\n\nfunc duplicateZeros(arr []int) {\n\tfor i := 0; i < len(arr); i++ {\n\t\tif arr[i] == 0 {\n\t\t\tk := 0\n\t\t\tfor j :="
},
{
"path": "Element Appearing More Than 25% In Sorted Array/kata.go",
"chars": 354,
"preview": "package kata\n\nfunc findSpecialInteger(arr []int) int {\n\tcounter := make(map[int]int)\n\tfragment := float64(len(arr)) / 10"
},
{
"path": "Employee Bonus/q.sql",
"chars": 125,
"preview": "SELECT e.name, b.bonus\nFROM Employee AS e LEFT JOIN Bonus AS b ON e.empId = b.empId WHERE b.bonus < 1000 OR b.bonus IS N"
},
{
"path": "Employee Importance/kata.py",
"chars": 1221,
"preview": "package kata\n\n\"\"\"\n# Employee info\nclass Employee:\n def __init__(self, id: int, importance: int, subordinates: List[in"
},
{
"path": "Employees Earning More Than Their Managers/kata.sql",
"chars": 134,
"preview": "package kata\n\nselect Name as Employee from Employee as e where Salary > (select Salary from Employee as ie where ie.Id ="
},
{
"path": "Employees With Missing Information/q.sql",
"chars": 286,
"preview": "(SELECT e.employee_id\n FROM Employees AS e\n LEFT JOIN Salaries AS s ON s.employee_id=e.employee_id\n WHERE salar"
},
{
"path": "Encode and Decode TinyURL/kata.go",
"chars": 815,
"preview": "package kata\n\nimport (\n\t\"math/rand\"\n\t\"time\"\n)\n\ntype Codec struct {\n\turlContainer map[string]string\n}\n\nfunc Constructor()"
},
{
"path": "Equal Row and Column Pairs/kata.go",
"chars": 819,
"preview": "package kata\n\nimport (\n\t\"crypto/md5\"\n\t\"encoding/hex\"\n\t\"strconv\"\n)\n\nfunc equalPairs(grid [][]int) int {\n\n\ttype pair struc"
},
{
"path": "Evaluate Boolean Binary Tree/kata.go",
"chars": 500,
"preview": "package kata\n\n/**\n * Definition for a binary tree node.\n * type TreeNode struct {\n * Val int\n * Left *TreeNode\n "
},
{
"path": "Evaluate Boolean Expression/q.sql",
"chars": 627,
"preview": "SELECT\n left_operand,\n operator,\n right_operand,\n (CASE\n WHEN operator = \">\" AND v1.value > v2.value"
},
{
"path": "Evaluate Reverse Polish Notation/kata.go",
"chars": 3422,
"preview": "package kata\n\nimport \"container/list\"\n\nfunc evalRPN(tokens []string) int {\n\tnodes := Parse(tokens)\n\treturn Eval(nodes)\n}"
},
{
"path": "Factorial Trailing Zeroes/kata.go",
"chars": 668,
"preview": "package Factorial_Trailing_Zeroes\n\nimport \"math/big\"\n\nfunc trailingZeroes(n int) int {\n\ts := factorial(big.NewInt(int64("
},
{
"path": "Fibonacci Number/kata.go",
"chars": 120,
"preview": "package kata\n\nfunc fib(N int) int {\n\tif N == 0 {\n\t\treturn 0\n\t}\n\tif N == 1 {\n\t\treturn 1\n\t}\n\treturn fib(N-1) + fib(N-2)\n}\n"
}
]
// ... and 489 more files (download for full content)
About this extraction
This page contains the full source code of the donutloop/leetcode.com GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 689 files (326.5 KB), approximately 124.9k tokens, and a symbol index with 1049 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.