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 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 bucket = new HashMap<>(); HashMap 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 entry : count.entrySet()) { if (max == -1 || max < entry.getValue()) { max = entry.getValue(); } } for (Map.Entry 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>) -> 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 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 getLonelyNodes(TreeNode root) { var nodes = new ArrayList(); if (root == null) { return nodes; } countNodes(nodes, root.left, root.right); return nodes; } private void countNodes(ArrayList 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 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 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>(); 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(){{ add(index); add(index+word.length()-1); }}); } } } } Collections.sort(list, new Comparator>() { public int compare(ArrayList a, ArrayList 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 (this *KthLargest) Add(val int) int { this.nums = append(this.nums, val) sort.Slice(this.nums, func(i, j int) bool { return this.nums[i] < this.nums[j] }) return this.nums[len(this.nums)-this.k] } /** * Your KthLargest object will be instantiated and called as such: * obj := Constructor(k, nums); * param_1 := obj.Add(val); */ ================================================ FILE: Kth Largest Element in an Array/kata.go ================================================ package kata import "sort" func findKthLargest(nums []int, k int) int { if len(nums) == 1 { return nums[0] } sort.Slice(nums, func(i, j int) bool { return nums[i] < nums[j] }) return nums[len(nums)-k] } ================================================ FILE: Kth Missing Positive Number/kata.go ================================================ package kata func findKthPositive(arr []int, k int) int { lastN := 0 missingNumbers := 0 for i := 0; i < len(arr); i++ { diff := (arr[i]) - lastN if diff > 1 { missingNumbers++ lastN++ i-- if missingNumbers == k { return lastN } continue } lastN = arr[i] } return len(arr) + k } ================================================ FILE: Kth Smallest Element in a BST/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func kthSmallest(root *TreeNode, k int) int { if root == nil { return -1 } list := make([]int, 0) inorder(root, &list, k) return list[k-1] } func inorder(node *TreeNode, list *[]int, k int) { if k == len(*list) { return } if node == nil { return } if node.Left != nil { inorder(node.Left, list, k) } *list = append(*list, node.Val) if node.Right != nil { inorder(node.Right, list, k) } } ================================================ FILE: LRU Cache/kata.go ================================================ package LRU_Cache import ( "time" ) type element struct { value int time int64 } type LRUCache struct { elements map[int]*element capacity int } func Constructor(capacity int) LRUCache { return LRUCache{ elements: make(map[int]*element), capacity: capacity, } } func (this *LRUCache) Get(key int) int { element, ok := this.elements[key] if !ok { return -1 } element.time = time.Now().UnixNano() this.elements[key] = element return element.value } func (this *LRUCache) Put(key int, value int) { e, ok := this.elements[key] if !ok { if len(this.elements) == this.capacity { max := int64(-1) foundKey := -1 for key, value := range this.elements { if max == -1 || max > value.time { foundKey = key max = value.time } } delete(this.elements, foundKey) } this.elements[key] = &element{value: value, time: time.Now().UnixNano()} return } e.value = value e.time = time.Now().UnixNano() this.elements[key] = e } /** * Your LRUCache object will be instantiated and called as such: * obj := Constructor(capacity); * param_1 := obj.Get(key); * obj.Put(key,value); */ ================================================ FILE: Largest 3-Same-Digit Number in String/kata.go ================================================ package Largest_3_Same_Digit_Number_in_String func largestGoodInteger(num string) string { k := -1 window := "" for i := 2; i < len(num); i++ { if num[i] == num[i-1] && num[i-1] == num[i-2] && k < int(num[i]-48) { window = num[i-2 : i+1] k = int(num[i] - 48) } } return window } ================================================ FILE: Largest Number After Digit Swaps by Parity/kata.go ================================================ package Largest_Number_After_Digit_Swaps_by_Parity import ( "container/heap" "math" ) func largestInteger(num int) int { odd := &IntHeap{} even := &IntHeap{} var i int var bitSet int for { n := num % 10 num = num / 10 if n%2 == 0 { even.Push(n) if bitSet&(1< 0 { bitSet ^= 1 << i } } if num == 0 { break } i++ } heap.Init(odd) heap.Init(even) num = 0 u := int(math.Pow(10, float64(i))) for ; i >= 0; i-- { if (bitSet & (1 << i)) == 0 { num += heap.Pop(odd).(int) * u } else { num += heap.Pop(even).(int) * u } u = u / 10 } return num } type IntHeap []int func (h IntHeap) Len() int { return len(h) } func (h IntHeap) Less(i, j int) bool { return h[i] > h[j] } func (h IntHeap) Swap(i, j int) { if h.Len() < 2 { return } h[i], h[j] = h[j], h[i] } func (h *IntHeap) Push(x interface{}) { *h = append(*h, x.(int)) } func (h *IntHeap) Pop() interface{} { old := *h n := len(old) if n == 0 { return -1 } x := old[n-1] *h = old[0 : n-1] return x } ================================================ FILE: Largest Number At Least Twice of Others/kata.go ================================================ package kata func dominantIndex(nums []int) int { var index int var max int var i int for i = 0; i < len(nums); i++ { if (max * 2) <= nums[i] { max = nums[i] index = i } } for i = 0; i < len(nums); i++ { if max != nums[i] && max < (2*nums[i]) { return -1 } } return index } ================================================ FILE: Largest Perimeter Triangle/kata.go ================================================ package Largest_Perimeter_Triangle import "sort" func largestPerimeter(nums []int) int { sort.Ints(nums) for i := len(nums) - 1; i >= 2; i-- { a := nums[i-1] + nums[i] b := nums[i-2] + nums[i-1] c := nums[i-2] + nums[i] if a > nums[i-2] && b > nums[i] && c > nums[i-1] { return nums[i-2] + nums[i-1] + nums[i] } } return 0 } ================================================ FILE: Largest Positive Integer That Exists With Its Negative/kata.java ================================================ import java.util.Arrays; import java.util.Comparator; class Solution { public int findMaxK(int[] nums) { Integer[] boxedNums = new Integer[nums.length]; for (int i = 0; i < nums.length; i++) { boxedNums[i] = nums[i]; } Arrays.sort(boxedNums, new Comparator() { @Override public int compare(Integer n1, Integer n2) { if (n2 < 0) { n2 = n2 * -1; } if (n1 < 0) { n1 = n1 * -1; } return Integer.compare(n1, n2); } }); var i = nums.length - 2; var k = -1; for (; i >= 0; i--) { var j = i+1; if (boxedNums[j].intValue() == boxedNums[i].intValue()) { continue; } var ni = boxedNums[i]; if (boxedNums[i] < 0) { ni = ni * -1; } var nj = boxedNums[j]; if (boxedNums[j] < 0) { nj = nj * -1; } if (nj.intValue() == ni.intValue()) { return nj; } } return k; } } ================================================ FILE: Largest Subarray Length K/kata.java ================================================ class Solution { public int[] largestSubarray(int[] nums, int k) { var max = 0l; var res = new int[k]; var index = 0; for (var i = 0; i < nums.length-k+1; i++) { var localMax = nums[i]; if (localMax > max) { max = localMax; index = i; } } var j = 0; for (var i = index; i < index+k; i++) { res[j] = nums[i]; j++; } return res; } } ================================================ FILE: Largest Unique Number/kata.go ================================================ package Largest_Unique_Number import "sort" func largestUniqueNumber(nums []int) int { if len(nums) == 1 { return nums[0] } sort.Slice(nums, func(i, j int) bool { return nums[i] > nums[j] }) for i := 1; i < len(nums); i++ { if i > 1 && (nums[i-1] == nums[i-2]) { continue } else if nums[i-1] == nums[i] { i++ continue } else { return nums[i-1] } } if len(nums)%2 == 1 { return nums[len(nums)-1] } return -1 } ================================================ FILE: Last Person to Fit in the Bus/q.sql ================================================ WITH cte AS ( SELECT person_name, SUM(weight) OVER ( ORDER BY turn ROWS UNBOUNDED PRECEDING) AS running_total FROM Queue ) SELECT person_name FROM cte WHERE running_total <= 1000 ORDER BY running_total DESC LIMIT 1; ================================================ FILE: Last Stone Weight/kata.go ================================================ package kata import "sort" func lastStoneWeight(stones []int) int { if len(stones) == 1 { return stones[0] } for len(stones) != 0 && len(stones) != 1 { if !sort.IntsAreSorted(stones) { sort.Ints(stones) } diff := stones[len(stones)-1] - stones[len(stones)-2] stones = stones[:len(stones)-2] if diff > 0 { stones = append(stones, diff) } } if len(stones) == 1 { return stones[0] } return 0 } ================================================ FILE: Latest Time by Replacing Hidden Digits/kata.go ================================================ package kata func maximumTime(time string) string { b := []byte(time) if b[0] == '?' && (b[1] >= '4' && b[1] <= '9') { b[0] = '1' } else if b[0] == '?' { b[0] = '2' } if b[1] == '?' && (b[0] == '0' || b[0] == '1') { b[1] = '9' } else if b[1] == '?' { b[1] = '3' } if b[3] == '?' { b[3] = '5' } if b[4] == '?' { b[4] = '9' } return string(b) } ================================================ FILE: Leaf-Similar Trees/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func leafSimilar(root1 *TreeNode, root2 *TreeNode) bool { if root1 == nil && root2 == nil { return true } if root1 == nil || root2 == nil { return false } values1 := make([]int, 0) values2 := make([]int, 0) PickLeafValues(root1, &values2) PickLeafValues(root2, &values1) if len(values2) != len(values1) { return false } for i := 0; i < len(values1); i++ { if values1[i] != values2[i] { return false } } return true } func PickLeafValues(node *TreeNode, values *[]int) { if node != nil && node.Left == nil && node.Right == nil { *values = append(*values, node.Val) return } if node == nil { return } if node.Left != nil { PickLeafValues(node.Left, values) } if node.Right != nil { PickLeafValues(node.Right, values) } } ================================================ FILE: Least Number of Unique Integers after K Removals/kata.java ================================================ class Solution { public int findLeastNumOfUniqueInts(int[] arr, int k) { Map counter = new LinkedHashMap<>(); for (var num: arr) { counter.put(num, counter.getOrDefault(num, 0)+1); } PriorityQueue pq = new PriorityQueue<>(); counter.forEach((key, value) -> pq.add(value)); while(k != 0) { var value = pq.poll(); value--; if (value > 0) pq.add(value); k--; } return pq.size(); } } ================================================ FILE: Left and Right Sum Differences/kata.java ================================================ class Solution { public int[] leftRigthDifference(int[] nums) { var res = new int[nums.length]; var j = nums.length-1; var leftSum = 0; var rightSum = 0; for (var i = 0; i < nums.length-1; i++) { leftSum += nums[i]; rightSum += nums[j]; if (res[i+1] > 0) { res[i+1] -= leftSum; res[i+1] = Math.abs(res[i+1]); } else { res[i+1] = leftSum; } if (res[j-1] > 0) { res[j-1] -= rightSum; res[j-1] = Math.abs(res[j-1]); } else { res[j-1] = rightSum; } j--; } return res; } } ================================================ FILE: Length of Last Word/kata.go ================================================ package kata func lengthOfLastWord(s string) (lastWordCounter int) { if s == "" { return 0 } for i := len(s) - 1; i >= 0; i-- { if s[i] == ' ' && lastWordCounter != 0 { return } if s[i] != ' ' { lastWordCounter++ } } return } ================================================ FILE: Letter Case Permutation/kata.go ================================================ package kata func letterCasePermutation(S string) []string { permutations := make([]string, 0) permutations = append(permutations, string(permutation(&permutations, []byte(S), 0))) return permutations } func permutation(permutations *[]string, b []byte, index int) []byte { if len(b) <= index { return b } for i := index; i < len(b); i++ { if b[i] >= 97 && b[i] <= 122 { b[i] = b[i] - 32 *permutations = append(*permutations, string(permutation(permutations, b, i+1))) b[i] = b[i] + 32 } else if b[i] >= 65 && b[i] <= 90 { b[i] = b[i] + 32 *permutations = append(*permutations, string(permutation(permutations, b, i+1))) b[i] = b[i] - 32 } } return b } ================================================ FILE: Lexicographical Numbers/kata.go ================================================ package kata import ( "sort" "strconv" ) func lexicalOrder(n int) []int { nums := make([]int, n) for i := 0; i < n; i++ { nums[i] = i + 1 } sort.Slice(nums, func(i, j int) bool { return strconv.Itoa(nums[i]) < strconv.Itoa(nums[j]) }) return nums } ================================================ FILE: Linked List Cycle/kata.go ================================================ package kata /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func hasCycle(head *ListNode) bool { if head == nil { return false } current := head.Next if current == nil { return false } count := map[*ListNode]struct{}{} for current != nil { _, ok := count[current] if ok { return true } count[current] = struct{}{} current = current.Next } return false } ================================================ FILE: List the Products Ordered in a Period/q.sql ================================================ SELECT p.product_name, Sum(o.unit) AS unit FROM products AS p INNER JOIN orders AS o ON o.product_id = p.product_id WHERE Month(o.order_date) = 2 GROUP BY p.product_name, Year(o.order_date), Month(o.order_date) HAVING unit >= 100; ================================================ FILE: Longer Contiguous Segments of Ones than Zeros/kata.go ================================================ package kata import "math" func checkZeroOnes(s string) bool { zeroCountMax := int(math.Inf(-1)) oneCountMax := int(math.Inf(-1)) var zeroCount int var oneCount int for i := 0; i < len(s); i++ { if zeroCountMax == int(math.Inf(-1)) || zeroCount > zeroCountMax { zeroCountMax = zeroCount } if oneCountMax == int(math.Inf(-1)) || oneCount > oneCountMax { oneCountMax = oneCount } if s[i] == '0' { oneCount = 0 zeroCount++ } else if s[i] == '1' { zeroCount = 0 oneCount++ } if i == len(s)-1 { if zeroCountMax == int(math.Inf(-1)) || zeroCount > zeroCountMax { zeroCountMax = zeroCount } if oneCountMax == int(math.Inf(-1)) || oneCount > oneCountMax { oneCountMax = oneCount } } } return oneCountMax > zeroCountMax } ================================================ FILE: Longest Common Prefix/kata.go ================================================ package kata func longestCommonPrefix(strs []string) string { if len(strs) == 0 { return "" } if len(strs) == 1 { return strs[0] } min := -1 minString := "" for _, s := range strs { if min == -1 || min > len(s) { min = len(s) minString = s } } for n := len(minString); n >= 0; n-- { if Has(strs, minString, n) { return minString[:n] } } return "" } func Has(strs []string, minString string, n int) bool { for _, s := range strs { if minString[:n] != s[:n] { return false } } return true } ================================================ FILE: Longest Consecutive Sequence/kata.go ================================================ package Longest_Consecutive_Sequence import "sort" func longestConsecutive(nums []int) int { if len(nums) == 0 || len(nums) == 1 { return len(nums) } sort.Ints(nums) if len(nums) == 2 { if nums[1]-nums[0] == 1 { return 2 } return 1 } globalMax := 1 max := 1 for i := 1; i < len(nums); i++ { if nums[i]-nums[i-1] == 0 { continue } if nums[i]-nums[i-1] == 1 { max++ } else { if max > globalMax { globalMax = max } max = 1 } } if max > globalMax { globalMax = max } return globalMax } ================================================ FILE: Longest Continuous Increasing Subsequence/kata.go ================================================ package kata func findLengthOfLCIS(nums []int) int { if len(nums) == 0 { return 0 } l := 0 a := 0 for i := 1; i < len(nums); i++ { if nums[i-1] < nums[i] { a++ continue } if a > l { l = a } a = 0 } if a > l { l = a } return l + 1 } ================================================ FILE: Longest Strictly Increasing or Strictly Decreasing Subarray/kata.go ================================================ package kata func longestMonotonicSubarray(nums []int) int { var lsi int var lsd int var currentLsi = 1 var currentLsd = 1 for i := 1; i < len(nums); i++ { if nums[i-1] < nums[i] { currentLsi++ if lsd < currentLsd { lsd = currentLsd } currentLsd = 1 } else if nums[i-1] > nums[i] { currentLsd++ if lsi < currentLsi { lsi = currentLsi } currentLsi = 1 } else { if lsi < currentLsi { lsi = currentLsi } if lsd < currentLsd { lsd = currentLsd } currentLsd = 1 currentLsi = 1 } } if lsd < currentLsd { lsd = currentLsd } if lsi < currentLsi { lsi = currentLsi } if lsi < lsd { return lsd } return lsi } ================================================ FILE: Longest Subsequence With Limited Sum/kata.java ================================================ class Solution { public int[] answerQueries(int[] nums, int[] queries) { var res = new int[queries.length]; var i = 0; Arrays.sort(nums); for (var query : queries) { var sum = 0; var subsequenceCount = 0; for (var num : nums) { if (sum + num > query) continue; sum += num; subsequenceCount++; } res[i] = subsequenceCount; i++; } return res; } } ================================================ FILE: Low-Quality Problems/q.sql ================================================ SELECT problem_id FROM Problems WHERE (likes/(likes+dislikes))<0.60 ORDER BY problem_id; ================================================ FILE: Lucky Numbers in a Matrix/kata.go ================================================ package kata func luckyNumbers(matrix [][]int) []int { type point struct { i, j int } allMins := make([]point, 0) for i := 0; i < len(matrix); i++ { currentMin := -1 var p point for j := 0; j < len(matrix[i]); j++ { if currentMin == -1 || currentMin > matrix[i][j] { currentMin = matrix[i][j] p = point{i: i, j: j} } } allMins = append(allMins, p) } validValues := make([]int, 0) outerLoop: for _, point := range allMins { for i := 0; i < len(matrix); i++ { if matrix[point.i][point.j] < matrix[i][point.j] { continue outerLoop } } validValues = append(validValues, matrix[point.i][point.j]) } return validValues } ================================================ FILE: Majority Element/kata.go ================================================ package kata import ( "math" ) func majorityElement(nums []int) int { if len(nums) == 1 { return nums[0] } n := len(nums) max := int(math.Ceil(float64(n) / 2)) counter := make(map[int]int) var val int for i := 0; i < len(nums); i++ { counter[nums[i]] = counter[nums[i]] + 1 if counter[nums[i]] == max { val = nums[i] break } } return val } ================================================ FILE: Majority Element II/kata.go ================================================ package kata import ( "math" "sort" ) func majorityElement(nums []int) []int { sort.Ints(nums) currentNumber := nums[0] border := math.Floor(float64(len(nums)) / 3) count := 1 var j int for i := 1; i < len(nums); i++ { if currentNumber == nums[i] { count++ } else { if float64(count) > border { nums[j] = currentNumber j++ } currentNumber = nums[i] count = 1 } } if count > 0 && float64(count) > border { nums[j] = currentNumber j++ } return nums[:j] } ================================================ FILE: Make Array Zero by Subtracting Equal Amounts/kata.java ================================================ class Solution { public int minimumOperations(int[] nums) { var countOperation = 0; Arrays.sort(nums); var sum = 0; for (var i = 0; i < nums.length; i++) { if (nums[i] == 0) { continue; } if (sum < nums[i]) { sum += Math.abs(sum-nums[i]); countOperation++; } } return countOperation; } } ================================================ FILE: Make The String Great/kata.go ================================================ package kata func makeGood(s string) string { var stack []byte for i := 0; i < len(s); i++ { if s[i] >= 'a' && s[i] <= 'z' { if len(stack) > 0 && stack[len(stack)-1] >= 'A' && stack[len(stack)-1] <= 'Z' { if (stack[len(stack)-1] + 32) == s[i] { stack = stack[:len(stack)-1] continue } stack = append(stack, s[i]) continue } stack = append(stack, s[i]) } else { if len(stack) > 0 && stack[len(stack)-1] == (s[i]+32) { stack = stack[:len(stack)-1] continue } stack = append(stack, s[i]) } } return string(stack) } ================================================ FILE: Make Two Arrays Equal by Reversing Sub-arrays/kata.go ================================================ package kata import "sort" func canBeEqual(target []int, arr []int) bool { if len(target) != len(arr) { return false } sort.Ints(arr) sort.Ints(target) for i, elem := range arr { if target[i] != elem { return false } } return true } ================================================ FILE: Map Sum Pairs/kata.go ================================================ package kata type MapSum struct { values map[string]int } /** Initialize your data structure here. */ func Constructor() MapSum { return MapSum{values: make(map[string]int)} } func (this *MapSum) Insert(key string, val int) { this.values[key] = val } func (this *MapSum) Sum(prefix string) (sum int) { for key, value := range this.values { if len(key) >= len(prefix) && key[:len(prefix)] == prefix { sum = sum + value } } return } /** * Your MapSum object will be instantiated and called as such: * obj := Constructor(); * obj.Insert(key,val); * param_2 := obj.Sum(prefix); */ ================================================ FILE: Matrix Diagonal Sum/kata.go ================================================ package kata func diagonalSum(mat [][]int) int { var sum int var i, j int l := len(mat) - 1 for i < len(mat) { sum += mat[i][j] if l == j { l-- i++ j++ continue } sum += mat[i][l] l-- i++ j++ } return sum } ================================================ FILE: Max Consecutive Ones/kata.go ================================================ package kata func findMaxConsecutiveOnes(nums []int) int { var max int var c int for i := 0; i < len(nums); i++ { if nums[i] == 0 { if c > max { max = c } c = 0 continue } c++ } if c > max { max = c } return max } ================================================ FILE: Max Stack/kata.go ================================================ package Max_Stack import ( "container/list" "math" ) type MaxStack struct { list *list.List max *list.Element } func Constructor() MaxStack { return MaxStack{list: list.New()} } func (this *MaxStack) Push(x int) { e := this.list.PushBack(x) if this.max == nil { this.max = e } else if x >= this.max.Value.(int) { this.max = e } } func (this *MaxStack) Pop() int { e := this.list.Back() if e == nil { return -1 } this.list.Remove(e) if e == this.max { this.max = nil max := math.MaxInt64 for e1 := this.list.Front(); e1 != nil; e1 = e1.Next() { if max == math.MaxInt64 || max <= e1.Value.(int) { max = e1.Value.(int) this.max = e1 } } } return e.Value.(int) } func (this *MaxStack) Top() int { e := this.list.Back() if e == nil { return -1 } return e.Value.(int) } func (this *MaxStack) PeekMax() int { return this.max.Value.(int) } func (this *MaxStack) PopMax() int { e := this.max this.list.Remove(e) max := math.MaxInt64 this.max = nil for e1 := this.list.Front(); e1 != nil; e1 = e1.Next() { if max == math.MaxInt64 || max <= e1.Value.(int) { max = e1.Value.(int) this.max = e1 } } return e.Value.(int) } ================================================ FILE: Maximize Sum Of Array After K Negations/kata.go ================================================ package kata import "sort" func largestSumAfterKNegations(A []int, K int) int { sort.Slice(A, func(i, j int) bool { return A[i] < A[j] }) var i int for K > 0 { if A[i] > A[i+1] { i++ } if A[i] == 0 { break } A[i] = -1 * A[i] K-- } var sum int for _, a := range A { sum += a } return sum } ================================================ FILE: Maximum 69 Number/kata.go ================================================ package kata import "strconv" func maximum69Number(num int) int { b := []byte(strconv.Itoa(num)) for i := 0; i < len(b); i++ { if b[i] == '6' { b[i] = '9' break } } n, _ := strconv.Atoi(string(b)) return n } ================================================ FILE: Maximum Ascending Subarray Sum/kata.go ================================================ package kata func maxAscendingSum(nums []int) int { if len(nums) == 0 { return 0 } var globalMax int var localMax int localMax = nums[0] for i := 1; i < len(nums); i++ { if nums[i-1] < nums[i] { localMax += nums[i] } else { if localMax > globalMax { globalMax = localMax } localMax = nums[i] } } if localMax > globalMax { globalMax = localMax } return globalMax } ================================================ FILE: Maximum Average Subarray I /kata.go ================================================ package Maximum_Average_Subarray_I_ func findMaxAverage(nums []int, k int) float64 { var sum int for i := range nums { if i == k { break } sum = sum + nums[i] } max := sum for i := k; i < len(nums); i++ { sum = sum - nums[i-k] sum = sum + nums[i] if sum > max { max = sum } } return float64(max) / float64(k) } ================================================ FILE: Maximum Count of Positive Integer and Negative Integer/kata.java ================================================ class Solution { public int maximumCount(int[] nums) { var posCount = 0; var negCount = 0; for (var num : nums) { if (num >= 1) { posCount++; } else if (num <= -1) { negCount++; } } if (negCount > posCount) { return negCount; } return posCount; } } ================================================ FILE: Maximum Depth of Binary Tree/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func maxDepth(root *TreeNode) int { if root == nil { return 0 } return height(root, 1) } func height(root *TreeNode, count int) int { leftHeight := count if root.Left != nil { leftHeight = height(root.Left, leftHeight+1) } rightHeight := count if root.Right != nil { rightHeight = height(root.Right, rightHeight+1) } if rightHeight > leftHeight { return rightHeight } return leftHeight } ================================================ FILE: Maximum Difference Between Increasing Elements/kata.java ================================================ class Solution { public int maximumDifference(int[] nums) { var min = -1; var maximumDifference = -1; for (var i = 1; i < nums.length; i++) { if (min == -1 || nums[i-1] < min) { min = nums[i-1]; } if (min < nums[i]) { var maximumDifferenceLocal = Math.abs(nums[i]-min); if (maximumDifferenceLocal > maximumDifference) { maximumDifference = maximumDifferenceLocal; } } } return maximumDifference; } } ================================================ FILE: Maximum Difference by Remapping a Digit/kata.java ================================================ class Solution { public int minMaxDifference(int n) { var digitCount = ((int) Math.log10((double) n)); var minSum = 0; var maxSum = 0; Integer maxDigit = null; Integer minDigit = null; for (; digitCount >= 0; digitCount--) { var base = (int) Math.pow(10, (double) digitCount); var digit = (n/base) % 10; if (maxDigit == null && digit < 9) { maxDigit = digit; } if(maxDigit != null && maxDigit.intValue() == digit) { maxSum += 9 * base; } else { maxSum += digit * base; } if (minDigit == null && digit > 0) { minDigit = digit; } if (minDigit != null && minDigit.intValue() == digit) { minSum += 0; } else { minSum += digit * base; } } return maxSum-minSum; } } ================================================ FILE: Maximum Frequency Stack/kata.go ================================================ package kata type FreqStack struct { counter map[int]int list []int } func Constructor() FreqStack { return FreqStack{ counter: make(map[int]int), list: make([]int, 0), } } func (this *FreqStack) Push(x int) { this.counter[x] = this.counter[x] + 1 this.list = append(this.list, x) } func (this *FreqStack) Pop() int { if len(this.list) == 1 { v := this.list[0] this.list = this.list[1:] return v } max := 0 index := 0 for i := len(this.list) - 1; i > 0; i-- { c := this.counter[this.list[i]] if c > max { max = c index = i } } v := this.list[index] this.counter[v] = this.counter[v] - 1 this.list = append(this.list[:index], this.list[index+1:]...) return v } /** * Your FreqStack object will be instantiated and called as such: * obj := Constructor(); * obj.Push(x); * param_2 := obj.Pop(); */ ================================================ FILE: Maximum Nesting Depth of the Parentheses/kata.java ================================================ class Solution { public int maxDepth(String s) { var openParentheses = 0; var maxParentheses = 0; for (var i = 0; i < s.length(); i++) { if (s.charAt(i) == '(') { openParentheses++; } else if (s.charAt(i) == ')') { if (maxParentheses < openParentheses) { maxParentheses = openParentheses; } openParentheses--; } else if (Character.isDigit(s.charAt(i)) || s.charAt(i) == '+' || s.charAt(i) == '-' || s.charAt(i) == '/' || s.charAt(i) == '*') { if (maxParentheses < openParentheses) { maxParentheses = openParentheses; } } } return maxParentheses; } } ================================================ FILE: Maximum Number of Balloons/kata.go ================================================ package kata func maxNumberOfBalloons(text string) int { chars := make(map[rune]int, 0) for _, char := range text { if char == 'b' || char == 'a' || char == 'l' || char == 'o' || char == 'n' { chars[char]++ } } if len(chars) < 5 { return 0 } var min = -1 for char, count := range chars { if char == 'l' || char == 'o' { count = int(count / 2) } if min == -1 || min > count { min = count } } return min } ================================================ FILE: Maximum Number of Balls in a Box/kata.go ================================================ package Maximum_Number_of_Balls_in_a_Box func countBalls(lowLimit int, highLimit int) int { counter := make(map[int]int, highLimit-lowLimit+1) max := -1 for i := lowLimit; i <= highLimit; i++ { n := i var sum int for n > 0 { sum += n % 10 n = n / 10 } counter[sum]++ if max == -1 || counter[sum] > max { max = counter[sum] } } return max } ================================================ FILE: Maximum Number of Coins You Can Get/kata.java ================================================ class Solution { public int maxCoins(int[] piles) { Arrays.sort(piles); var j = 0; var sum = 0; for (var i = piles.length-2; i >= j; i=i-2) { sum += piles[i]; j++; } return sum; } } ================================================ FILE: Maximum Number of Pairs in Array/kata.go ================================================ package kata import "sort" func numberOfPairs(nums []int) []int { sort.Ints(nums) var r int var p int for i := 1; i < len(nums); i++ { if nums[i-1] == nums[i] { i++ p++ } else { r++ } } if p == 0 { r++ } if 2*p+r != len(nums) { r++ } return []int{p, r} } ================================================ FILE: Maximum Number of Words Found in Sentences/kata.go ================================================ package kata func mostWordsFound(sentences []string) int { var globalMax int for _, sentence := range sentences { var max int for i := 0; i < len(sentence); i++ { if sentence[i] == ' ' { max++ } } max++ if max > globalMax { globalMax = max } } return globalMax } ================================================ FILE: Maximum Number of Words You Can Type/kata.go ================================================ package Maximum_Number_of_Words_You_Can_Type func canBeTypedWords(text string, brokenLetters string) int { chars := make(map[rune]bool) for _, char := range brokenLetters { chars[char] = true } var goodWordsCounter int nextWord := false for i, char := range text { if nextWord { if char == 32 { nextWord = false } continue } if chars[char] { nextWord = true continue } if char == 32 || (len(text)-1) == i { goodWordsCounter++ } } return goodWordsCounter } ================================================ FILE: Maximum Odd Binary Number/kata.go ================================================ package kata func maximumOddBinaryNumber(s string) string { var countOnes int var countAll int for _, digit := range s { if digit == '1' { countOnes++ } countAll++ } if countOnes == 0 { return s } maximumOddBinary := make([]byte, countAll) countOnes-- maximumOddBinary[countAll-1] = '1' for i := 0; i < countAll-1; i++ { if countOnes > 0 { maximumOddBinary[i] = '1' countOnes-- } else { maximumOddBinary[i] = '0' } } return string(maximumOddBinary) } ================================================ FILE: Maximum Product Difference Between Two Pairs/kata.go ================================================ package kata import "sort" func maxProductDifference(nums []int) int { sort.Ints(nums) return nums[len(nums)-1]*nums[len(nums)-2] - nums[0]*nums[1] } ================================================ FILE: Maximum Product of Three Numbers/kata.go ================================================ package kata import "sort" func maximumProduct(nums []int) int { sort.Ints(nums) var sumA, sumB = 1, 1 for _, n := range nums[len(nums)-3:] { sumB = n * sumB } for _, n := range nums[:3] { sumA = n * sumA } if sumA < sumB { sumA = sumB } sumB = 1 for _, n := range nums[:2] { sumB = n * sumB } sumB = sumB * nums[len(nums)-1] if sumA > sumB { return sumA } return sumB } ================================================ FILE: Maximum Product of Two Elements in an Array/kata.go ================================================ package kata import "sort" func maxProduct(nums []int) int { sort.Ints(nums) return (nums[len(nums)-1] - 1) * (nums[len(nums)-2] - 1) } ================================================ FILE: Maximum Score After Splitting a String/kata.go ================================================ package Maximum_Score_After_Splitting_a_String func maxScore(s string) int { ones := 0 for _, char := range s { if char != '0' { ones++ } } max := 0 leftZeros := 0 for i, char := range s { if char == '0' { leftZeros++ } else { ones-- } if ones+leftZeros > max && i != len(s)-1 { max = ones + leftZeros } } if leftZeros == len(s) { return leftZeros - 1 } return max } ================================================ FILE: Maximum Subarray/kata.go ================================================ package kata import "math" func maxSubArray(nums []int) int { var currentSum int var globalMax int var negativCounter int max := math.Inf(-1) for _, num := range nums { if num < 0 { negativCounter++ } if max == math.Inf(-1) || float64(num) > max { max = float64(num) } currentSum = int(math.Max(0, float64(currentSum+num))) globalMax = int(math.Max(float64(globalMax), float64(currentSum))) } if negativCounter == len(nums) { return int(max) } return globalMax } ================================================ FILE: Maximum Sum Score of Array/kata.go ================================================ package Maximum_Sum_Score_of_Array import "math" func maximumSumScore(nums []int) int64 { var globalMax int64 for _, n := range nums { globalMax += int64(n) } finalMax := int64(math.MaxInt64) * -1 rightMax := int64(nums[len(nums)-1]) r := max(rightMax, globalMax) if r > finalMax { finalMax = r } leftMax := int64(nums[0]) r = max(leftMax, globalMax) if r > finalMax { finalMax = r } if len(nums) == 2 { return finalMax } leftMax = int64(0) leftMaxGlobal := globalMax for i := 0; i < len(nums)-1; i++ { leftMax += int64(nums[i]) leftMaxGlobal -= int64(nums[i]) r := max(leftMax, leftMaxGlobal) if r > finalMax { finalMax = r } } rightMax = int64(0) rightMaxGlobal := globalMax for i := len(nums) - 1; i > 0; i-- { rightMax += int64(nums[i]) rightMaxGlobal -= int64(nums[i]) r := max(rightMax, rightMaxGlobal) if r > finalMax { finalMax = r } } return finalMax } func max(a, b int64) int64 { if a > b { return a } return b } ================================================ FILE: Maximum Sum With Exactly K Elements/kata.go ================================================ func maximizeSum(nums []int, k int) int { var max int for _, num := range nums { if num > max { max = num } } var score int score += max for i := 1; i < k; i++ { max = max + 1 score += max } return score } ================================================ FILE: Maximum Twin Sum of a Linked List/kata.go ================================================ package kata type ListNode struct { Val int Next *ListNode } func pairSum(head *ListNode) int { max := new(int) f(head, head, max) return *max } func f(a *ListNode, b *ListNode, max *int) *ListNode { if a.Next == nil { sum := a.Val + b.Val if sum > *max { *max = sum } return b.Next } c := f(a.Next, b, max) sum := a.Val + c.Val if sum > *max { *max = sum } return c.Next } ================================================ FILE: Maximum Units on a Truck/kata.java ================================================ class Solution { public int maximumUnits(int[][] boxTypes, int truckSize) { Arrays.sort(boxTypes, Comparator.comparingInt(a -> a[1])); var sum = 0; for (var i = boxTypes.length-1; i >= 0; i--) { if (boxTypes[i][0] <= truckSize) { sum += boxTypes[i][0] * boxTypes[i][1]; truckSize -= boxTypes[i][0]; } else { sum += truckSize * boxTypes[i][1]; truckSize = 0; } if (truckSize == 0) { break; } } return sum; } } ================================================ FILE: Maximum Value after Insertion/kata.go ================================================ package Maximum_Value_after_Insertion func maxValue(n string, x int) string { b := make([]byte, len(n)+1) y := byte(x + 48) var i int if n[0] == '-' { i = 1 b[0] = '-' } ok := true if i == 0 { k := i for j := i; j < len(n); j++ { if ok && y > n[j] { b[k] = y k++ b[k] = n[j] ok = false } else { b[k] = n[j] } k++ } } else { k := i for j := i; j < len(n); j++ { if ok && y < n[j] { b[k] = y k++ b[k] = n[j] ok = false } else { b[k] = n[j] } k++ } } if ok { b[len(b)-1] = y } return string(b) } ================================================ FILE: Maximum Value of a String in an Array/kata.java ================================================ class Solution { public int maximumValue(String[] strs) { var max = 0; outerLoop: for (var str: strs) { var localMax = 0; var j = 0; for (var i = str.length()-1; i >= 0; i--) { if (Character.isLetter(str.charAt(i))) { if (max < str.length()) { max = str.length(); } continue outerLoop; } var digit = Character.getNumericValue(str.charAt(i)); localMax += (digit * Math.pow(10.0, (double) j)); j++; } if (localMax > max) { max = localMax; } } return max; } } ================================================ FILE: Maximum XOR After Operations /kata.java ================================================ class Solution { public int maximumXOR(int[] nums) { var max = 0; for (var num : nums) { max |= num; } return max; } } ================================================ FILE: Mean of Array After Removing Some Elements/kata.go ================================================ package kata import "sort" func trimMean(arr []int) float64 { sort.Ints(arr) p := int(float64(len(arr)) / float64(100) * float64(5)) var mean float64 for _, n := range arr[p : len(arr)-p] { mean = mean + float64(n) } return mean / float64(len(arr[p:len(arr)-p])) } ================================================ FILE: Meeting Rooms/kata.java ================================================ class Solution { public boolean canAttendMeetings(int[][] intervals) { // sort intervals by first and second element in []int asscending order Arrays.sort(intervals, new Comparator() { @Override public int compare(int[] a, int[] b) { // Compare the first element of each sub-array var compared = Integer.compare(a[0], b[0]); if(compared > 0) { // a is greater than b return compared; } else if(compared < 0) { // a is smaller than b return compared; } // if first element of a and b is equal then compare the second element of each sub array return Integer.compare(a[1], b[1]); } }); for (int i = 1; i < intervals.length; i++) { if (intervals[i-1][1] <= intervals[i][0]) { // if end of interval of a is smaller or equal to start of interval b then no overlapp continue; } return false; } return true; } } ================================================ FILE: Merge In Between Linked Lists/kata.go ================================================ package Merge_In_Between_Linked_Lists type ListNode struct { Val int Next *ListNode } func mergeInBetween(list1 *ListNode, a int, b int, list2 *ListNode) *ListNode { rootNodeB := list2 var tailNodeB *ListNode currentNodeB := list2 for currentNodeB != nil { if currentNodeB.Next == nil { tailNodeB = currentNodeB } currentNodeB = currentNodeB.Next } var aNode, bNode *ListNode currentNode := list1 var previousNode *ListNode var c int for currentNode != nil { if aNode == nil && c == a { aNode = previousNode } if bNode == nil && c == b { bNode = currentNode.Next break } previousNode = currentNode currentNode = currentNode.Next c++ } aNode.Next = rootNodeB tailNodeB.Next = bNode return list1 } ================================================ FILE: Merge Nodes in Between Zeros/kata.go ================================================ package Merge_Nodes_in_Between_Zeros type ListNode struct { Val int Next *ListNode } func mergeNodes(head *ListNode) *ListNode { currentNode := head var newChain *ListNode var currentNewChain *ListNode var sumNode *ListNode for currentNode != nil { if currentNode.Val == 0 { newSumNode := currentNode.Next if newSumNode == nil { sumNode.Next = nil break } sumNode = newSumNode if currentNode.Next != nil { currentNode = currentNode.Next.Next } else { break } if newChain == nil { newChain = sumNode currentNewChain = newChain } else { currentNewChain.Next = sumNode currentNewChain = currentNewChain.Next } continue } else { sumNode.Val += currentNode.Val sumNode.Next = currentNode.Next currentNode = currentNode.Next } } return newChain } ================================================ FILE: Merge Similar Items/kata.java ================================================ class Solution { public List> mergeSimilarItems(int[][] items1, int[][] items2) { Map> mergedItems = new TreeMap<>(); for (var item: items1) { mergedItems.put(item[0], new ArrayList<>(Arrays.asList(item[0], item[1]))); } for (var item: items2) { if (mergedItems.containsKey(item[0])) { var element = mergedItems.get(item[0]); element.set(1, element.get(1)+item[1]); mergedItems.put(item[0], element); } else { mergedItems.put(item[0], new ArrayList<>(Arrays.asList(item[0], item[1]))); } } var list = new ArrayList>(mergedItems.values()); return list; } } ================================================ FILE: Merge Strings Alternately/kata.go ================================================ package kata func mergeAlternately(word1 string, word2 string) string { var max int var word2IsLongest bool if len(word1) > len(word2) { max = len(word2) } else { max = len(word1) word2IsLongest = true } word3 := make([]byte, len(word2)+len(word1)) i := 0 j := 0 for ; i < max; i++ { word3[j] = word1[i] j++ word3[j] = word2[i] j++ } if max == len(word1) && max == len(word2) { return string(word3) } if word2IsLongest { for ; i < len(word2); i++ { word3[j] = word2[i] j++ } } else { for ; i < len(word1); i++ { word3[j] = word1[i] j++ } } return string(word3) } ================================================ FILE: Merge Two 2D Arrays by Summing Values/kata.go ================================================ package kata func mergeArrays(nums1 [][]int, nums2 [][]int) [][]int { merged := make([][]int, 0) i, j := 0, 0 for i < len(nums1) || j < len(nums2) { if i < len(nums1) && j < len(nums2) { if nums1[i][0] == nums2[j][0] { nums1[i][1] += nums2[j][1] merged = append(merged, nums1[i]) i++ j++ } else if nums1[i][0] < nums2[j][0] { merged = append(merged, nums1[i]) i++ } else { merged = append(merged, nums2[j]) j++ } } else if i < len(nums1) { merged = append(merged, nums1[i]) i++ } else if j < len(nums2) { merged = append(merged, nums2[j]) j++ } } return merged } ================================================ FILE: Merge Two Sorted Lists/kata.go ================================================ package kata /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode { currentA := l1 currentB := l2 root := &ListNode{} current := root for currentB != nil || currentA != nil { if currentB != nil && currentA != nil { if currentB.Val <= currentA.Val { current.Next = currentB current = currentB currentB = currentB.Next } else if currentB.Val >= currentA.Val { current.Next = currentA current = currentA currentA = currentA.Next } } else if currentB != nil { current.Next = currentB currentB = nil } else if currentA != nil { current.Next = currentA currentA = nil } } return root.Next } ================================================ FILE: Merge k Sorted Lists/kata.go ================================================ package kata import "container/heap" /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ type Item struct { value *ListNode priority int index int } func mergeKLists(lists []*ListNode) *ListNode { if len(lists) == 0 { return nil } pq := make(PriorityQueue, 0) i := 0 var current *ListNode for _, root := range lists { current = root for current != nil { item := &Item{ value: current, priority: current.Val, index: i, } pq = append(pq, item) i++ current = current.Next } } if pq.Len() == 0 { return nil } heap.Init(&pq) root := heap.Pop(&pq).(*Item).value current = root for pq.Len() > 0 { current.Next = heap.Pop(&pq).(*Item).value current = current.Next } current.Next = nil return root } type PriorityQueue []*Item func (pq PriorityQueue) Len() int { return len(pq) } func (pq PriorityQueue) Less(i, j int) bool { return pq[i].priority < pq[j].priority } func (pq PriorityQueue) Swap(i, j int) { pq[i], pq[j] = pq[j], pq[i] pq[i].index = i pq[j].index = j } func (pq *PriorityQueue) Pop() interface{} { old := *pq n := len(old) item := old[n-1] item.index = -1 *pq = old[0 : n-1] return item } func (pq *PriorityQueue) Push(x interface{}) { n := len(*pq) item := x.(*Item) item.index = n *pq = append(*pq, item) } ================================================ FILE: Method Chaining/kata.py ================================================ import pandas as pd def findHeavyAnimals(animals: pd.DataFrame) -> pd.DataFrame: animals = animals.query('weight > 100') animals = animals.sort_values(by='weight', ascending=False) return animals.filter(['name']) ================================================ FILE: Middle of the Linked List/kata.go ================================================ package kata /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func middleNode(head *ListNode) *ListNode { var current *ListNode nodes := make([]*ListNode, 0) current = head for current != nil { nodes = append(nodes, current) current = current.Next } if len(nodes) == 1 { return nodes[0] } if len(nodes)%2 == 1 { return nodes[len(nodes)/2] } mid := (len(nodes) + 1) / 2 if mid >= len(nodes) { mid = len(nodes) - 1 } return nodes[mid] } ================================================ FILE: Min Cost Climbing Stairs/kata.go ================================================ package kata func minCostClimbingStairs(cost []int) int { dp := make([]int, len(cost)) dp[len(cost)-1] = 0 for i := len(cost) - 1; i >= 0; i-- { dp[i] = cost[i] + min(dp, i+1, i+2) } return min(dp, 0, 1) } func min(dp []int, i, j int) int { var a int if i < len(dp) { a = dp[i] } var b int if j < len(dp) { b = dp[j] } if a > b { return b } return a } ================================================ FILE: Min Max Game/kata.go ================================================ package Min_Max_Game func minMaxGame(nums []int) int { if len(nums) == 1 { return nums[0] } for len(nums) != 1 { var j int for i := 0; i < len(nums)/2; i++ { if i%2 == 0 { nums[j] = min(nums[2*i], nums[2*i+1]) } else { nums[j] = max(nums[2*i], nums[2*i+1]) } j++ } nums = nums[:len(nums)/2] } return nums[0] } func min(a, b int) int { if a > b { return b } return a } func max(a, b int) int { if a > b { return a } return b } ================================================ FILE: Min Stack/kata.go ================================================ package kata type MinStack struct { list []int } /** initialize your data structure here. */ func Constructor() MinStack { return MinStack{ list: make([]int, 0), } } func (this *MinStack) Push(x int) { this.list = append(this.list, x) } func (this *MinStack) Pop() { if len(this.list) == 0 { return } this.list = this.list[:len(this.list)-1] } func (this *MinStack) Top() int { if len(this.list) == 0 { return -1 } return this.list[len(this.list)-1] } func (this *MinStack) GetMin() int { var min *int for i := 0; i < len(this.list); i++ { if min == nil || *min > this.list[i] { if min == nil { min = new(int) } *min = this.list[i] } } return *min } /** * Your MinStack object will be instantiated and called as such: * obj := Constructor(); * obj.Push(x); * obj.Pop(); * param_3 := obj.Top(); * param_4 := obj.GetMin(); */ ================================================ FILE: Minimize Maximum Pair Sum in Array/kata.go ================================================ package kata import "sort" func minPairSum(nums []int) int { sort.Ints(nums) i := 0 j := len(nums) - 1 var max int for ; i < len(nums)/2; i++ { sum := nums[i] + nums[j] if sum > max { max = sum } j-- } return max } ================================================ FILE: Minimize Product Sum of Two Arrays/kata.go ================================================ package Minimize_Product_Sum_of_Two_Arrays import "sort" func minProductSum(nums1 []int, nums2 []int) int { sort.Sort(sort.Reverse(sort.IntSlice(nums1))) sort.Ints(nums2) var sum int for i := 0; i < len(nums1); i++ { sum += nums1[i] * nums2[i] } return sum } ================================================ FILE: Minimize String Length/kata.go ================================================ package kata func minimizedStringLength(s string) int { var minimizedLength = len(s) sb := []byte(s) sort.Slice(sb, func(i int, j int) bool { return sb[i] < sb[j] }) for i := 1; i < len(sb); i++ { if sb[i] == sb[i-1] { minimizedLength-- } } return minimizedLength } ================================================ FILE: Minimum Absolute Difference/kata.go ================================================ package kata import "sort" func minimumAbsDifference(arr []int) [][]int { sort.Slice(arr, func(i, j int) bool { return arr[i] < arr[j] }) globalMin := -1 for i := 1; i < len(arr); i++ { min := arr[i] - arr[i-1] if globalMin == -1 || min < globalMin { globalMin = min } } pairs := make([][]int, 0) for i := 1; i < len(arr); i++ { min := arr[i] - arr[i-1] if globalMin == min { pairs = append(pairs, []int{arr[i-1], arr[i]}) } } return pairs } ================================================ FILE: Minimum Absolute Difference in BST/kata.go ================================================ package kata import "sort" /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func getMinimumDifference(root *TreeNode) int { ps := make(PrioritySlice, 0) traverse(root, &ps) globalMin := -1 for i := 1; i < len(ps); i++ { min := ps[i] - ps[i-1] if globalMin == -1 || min < globalMin { globalMin = min } if globalMin == 0 { return globalMin } } return globalMin } func traverse(node *TreeNode, ps *PrioritySlice) { if node == nil { return } *ps = append(*ps, node.Val) sort.Sort(ps) if node.Left != nil { traverse(node.Left, ps) } if node.Right != nil { traverse(node.Right, ps) } } type PrioritySlice []int func (pq PrioritySlice) Len() int { return len(pq) } func (pq PrioritySlice) Less(i, j int) bool { return pq[i] < pq[j] } func (pq PrioritySlice) Swap(i, j int) { pq[i], pq[j] = pq[j], pq[i] } ================================================ FILE: Minimum Add to Make Parentheses Valid/kata.java ================================================ class Solution { public int minAddToMakeValid(String s) { var count = 0; var stack = new Stack(); for (var i = 0; i < s.length(); i++) { if (s.charAt(i) == '(') stack.add('('); if (s.charAt(i) == ')') { if (stack.isEmpty()) { count++; } else { stack.pop(); } } } return count + stack.size(); } } ================================================ FILE: Minimum Average Difference/kata.go ================================================ package kata func minimumAverageDifference(nums []int) int { var suffixSum int var suffixCount int for _, num := range nums { suffixSum += num suffixCount++ } var prefixSum int var min = -1 var idx = 0 for i, num := range nums { suffixSum = suffixSum - num suffixCount-- prefixSum += num var a int if suffixSum != 0 { a = (suffixSum / suffixCount) } v := abs((prefixSum / (i + 1)) - a) if min == -1 || v < min { min = v idx = i } } return idx } func abs(a int) int { if a < 0 { return -a } return a } ================================================ FILE: Minimum Bit Flips to Convert Number/kata.go ================================================ package Minimum_Bit_Flips_to_Convert_Number func minBitFlips(start int, goal int) int { maxNum, minNum := max(start, goal), min(start, goal) c := maxNum i := 0 k := 0 for c != 0 { c = c / 2 a := 0 if maxNum&(1< 0 { a = 1 } b := 0 if minNum&(1< 0 { b = 1 } if a != b { k++ } i++ } return k } 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: Minimum Common Value/kata.java ================================================ class Solution { public int getCommon(int[] nums1, int[] nums2) { var i = 0; var j = 0; HashMap counter = new HashMap<>(); while(i < nums1.length || j < nums2.length) { if (i < nums1.length) { var c = 0; if (counter.containsKey(counter.get(nums1[i]))) { c = counter.get(nums1[i]); } counter.put(nums1[i]+Integer.MIN_VALUE, c + 1); if (counter.containsKey(nums1[i]) && counter.get(nums1[i]) > 0 && counter.get(nums1[i]+Integer.MIN_VALUE) > 0){ return nums1[i]; } } if (j < nums2.length) { var c = 0; if (counter.containsKey(counter.get(nums2[j]))) { c = counter.get(nums2[j]); } counter.put(nums2[j], c + 1); if (counter.get(nums2[j]) > 0 && counter.containsKey(nums2[j]+Integer.MIN_VALUE) && counter.get(nums2[j]+Integer.MIN_VALUE) > 0){ return nums2[j]; } } i++; j++; } return -1; } } ================================================ FILE: Minimum Cuts to Divide a Circle/kata.java ================================================ class Solution { public int numberOfCuts(int n) { if (n == 1) { return 0; } if (n % 2 == 1) { return n; } return n / 2; } } ================================================ FILE: Minimum Depth of Binary Tree/kata.go ================================================ package kata import "math" /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func minDepth(node *TreeNode) int { if node == nil { return 0 } if node.Left == nil && node.Right == nil { return 1 } if node.Left == nil { return (minDepth(node.Right) + 1) } if node.Right == nil { return (minDepth(node.Left) + 1) } return int(math.Min(float64(minDepth(node.Right)), float64(minDepth(node.Left)))) + 1 } ================================================ FILE: Minimum Distance to the Target Element/kata.go ================================================ package kata import "math" func getMinDistance(nums []int, target int, start int) int { secondRound := false min := int(math.Inf(-1)) for i := start; i < len(nums); i++ { if nums[i] == target { d := int(math.Abs(float64(i) - float64(start))) if min == int(math.Inf(-1)) || min > d { min = d } } if !secondRound && i+1 == len(nums) { i = -1 secondRound = true } } return min } ================================================ FILE: Minimum Increment to Make Array Unique/kata.go ================================================ package kata import "sort" func minIncrementForUnique(A []int) int { sort.Ints(A) var count int for i := 1; i < len(A); i++ { if A[i] == A[i-1] { A[i]++ count++ continue } if A[i-1] > A[i] { diff := A[i-1] + 1 - A[i] A[i] += diff count += diff continue } } return count } ================================================ FILE: Minimum Moves to Convert String/kata.go ================================================ package Minimum_Moves_to_Convert_String func minimumMoves(s string) int { var c int for i := 0; i < len(s); i++ { if s[i] == 'X' { c++ i = i + 2 } } return c } ================================================ FILE: Minimum Number Game/kata.go ================================================ package kata import "sort" func numberGame(nums []int) []int { sort.Slice(nums, func(i, j int) bool { return nums[i] < nums[j] }) for i := 0; i < len(nums)-1; i = i + 2 { if i+1 > len(nums) { continue } nums[i], nums[i+1] = nums[i+1], nums[i] } return nums } ================================================ FILE: Minimum Number of Steps to Make Two Strings Anagram II/kata.go ================================================ package kata func minSteps(s string, t string) int { type pair struct { a, b int } var tracker = make(map[rune]pair) for _, codepoint := range s { pair := tracker[codepoint] pair.a++ tracker[codepoint] = pair } for _, codepoint := range t { pair := tracker[codepoint] pair.b++ tracker[codepoint] = pair } var diffTotal int for _, count := range tracker { if count.b > count.a { diff := abs(count.b - count.a) diffTotal += diff } } return diffTotal + len(s) + diffTotal - len(t) } func abs(a int) int { if a < 0 { return -a } return a } ================================================ FILE: Minimum Operations to Collect Elements/kata.go ================================================ package kata func minOperations(nums []int, k int) int { collection := make(map[int]bool) var counter int for i := len(nums)-1; i >= 0 ; i-- { if len(collection) == k { break } if nums[i] <= k { v := collection[nums[i]] if v == false { collection[nums[i]] = true } } counter++ } return counter } ================================================ FILE: Minimum Operations to Exceed Threshold Value I/kata.go ================================================ package kata import "sort" func minOperations(nums []int, k int) int { if k == 1 { return 0 } sort.Slice(nums, func(i, j int) bool { return nums[i] < nums[j] }) var countOfsmaller int for _, num := range nums { if num >= k { break } countOfsmaller++ } return countOfsmaller } ================================================ FILE: Minimum Operations to Make the Array Increasing/kata.go ================================================ package Minimum_Operations_to_Make_the_Array_Increasing func minOperations(nums []int) int { if len(nums) == 1 { return 0 } var operations int for i := 1; i < len(nums); i++ { if nums[i-1] < nums[i] { continue } n := nums[i-1] - nums[i] + 1 operations += n nums[i] += n } return operations } ================================================ FILE: Minimum Recolors to Get K Consecutive Black Blocks/kata.java ================================================ class Solution { public int minimumRecolors(String blocks, int k) { var i = 0; var whiteColorCount = 0; for ( ;i < k; i++) { if (blocks.charAt(i) == 'W') { whiteColorCount++; } } var min = whiteColorCount; for (i = k; i < blocks.length(); i++) { if (blocks.charAt(i) == 'W') { whiteColorCount++; } if (blocks.charAt(i-k) == 'W') { whiteColorCount--; } if (min > whiteColorCount) { min = whiteColorCount; } } return min; } } ================================================ FILE: Minimum String Length After Removing Substrings/kata.go ================================================ package kata func minLength(s string) int { if len(s) == 0 { return 0 } var stack []byte var minimumLength = len(s) stack = append(stack, s[0]) for i := 1; i < len(s); i++ { if len(stack) > 0 && ((s[i] == 'B' && stack[len(stack)-1] == 'A') || (s[i] == 'D' && stack[len(stack)-1] == 'C')) { minimumLength -= 2 stack = stack[:len(stack)-1] continue } stack = append(stack, s[i]) } return minimumLength } ================================================ FILE: Minimum Subsequence in Non-Increasing Order/kata.java ================================================ class Solution { public List minSubsequence(int[] nums) { Arrays.sort(nums); var maximumTotalSum = 0; for (var num: nums) { maximumTotalSum += num; } var partialSum = 0; List foundNumbers = new ArrayList<>(); for (var i = nums.length-1; i >= 0; i--) { partialSum += nums[i]; foundNumbers.add(nums[i]); maximumTotalSum -= nums[i]; if (partialSum > maximumTotalSum) { break; } } return foundNumbers; } } ================================================ FILE: Minimum Sum of Four Digit Number After Splitting Digits/kata.go ================================================ package Minimum_Sum_of_Four_Digit_Number_After_Splitting_Digits import "sort" func minimumSum(num int) int { var nums []int for { r := num % 10 num = num / 10 nums = append(nums, r) if num == 0 { break } } sort.Ints(nums) uB, uA := 1, 1 var a, b int for i := len(nums) - 1; i >= 0; i-- { if nums[i] == 0 { continue } if (uA*nums[i])+a > (uB*nums[i])+b { b = (uB * nums[i]) + b uB = uB * 10 } else { a = (uA * nums[i]) + a uA = uA * 10 } } return a + b } ================================================ FILE: Minimum Value to Get Positive Step by Step Sum/kata.java ================================================ class Solution { public int minStartValue(int[] nums) { var n = nums.length+1; var sums = new int[n]; Integer min = null; for (var k = 1; k < n; k++) { sums[k] = sums[k-1] + nums[k-1]; if (sums[k] < 1 && (min == null || sums[k] < min)) { min = sums[k]; } } if (min == null) { return 1; } sums[0] = min.intValue(); if (sums[0] < 0) sums[0] = sums[0] * -1; min = null; for (var k = 1; k < n; k++) { sums[k] = sums[k-1] + nums[k-1]; if (sums[k] < 1 && (min == null || sums[k] < min)) { min = sums[k]; } } var correction = 0; if (min != null) { correction = Math.abs(min.intValue())+1; } return sums[0]+correction; } } ================================================ FILE: Missing Number/kata.go ================================================ package kata func missingNumber(nums []int) int { count := make([]int, len(nums)+1) for i := 0; i < len(nums); i++ { count[nums[i]] = count[nums[i]] + 1 } for i := 0; i < len(count); i++ { if count[i] == 0 { return i } } return -1 } ================================================ FILE: Missing Ranges/kata.java ================================================ class Solution { public List findMissingRanges(int[] nums, int lower, int upper) { var ranges = new ArrayList(); if (nums.length == 0) { if (lower != upper) { ranges.add( Integer.toString(lower) + "->" + Integer.toString(upper)); } else { ranges.add( Integer.toString(lower)); } return ranges; } if (nums[0] != lower) { if (nums[0]-1 == lower) { ranges.add(Integer.toString(lower)); } else { ranges.add(Integer.toString(lower) + "->" + Integer.toString(nums[0]-1)); } } for (var i = 1; i < nums.length; i++) { var d = nums[i] - nums[i-1]; if (d == 1) { continue; } var numA = nums[i-1] + 1; var numB = nums[i] - 1; if (numA != numB) { ranges.add( Integer.toString(numA) + "->" + Integer.toString(numB)); } else { ranges.add( Integer.toString(numA)); } } if (nums[nums.length-1] != upper) { if (nums[nums.length-1]+1 == upper) { ranges.add( Integer.toString(upper)); } else { ranges.add(Integer.toString(nums[nums.length-1]+1) + "->" + Integer.toString(upper)); } } return ranges; } } ================================================ FILE: Modify Columns/kata.py ================================================ import pandas as pd def modifySalaryColumn(employees: pd.DataFrame) -> pd.DataFrame: employees['salary'] = employees['salary'].apply(lambda x: x*2) return employees ================================================ FILE: Modify the Matrix/kata.go ================================================ package kata func modifiedMatrix(matrix [][]int) [][]int { var maxPerCol = make([]int, len(matrix[0])) for i := range maxPerCol { maxPerCol[i] = int(math.MinInt64) } for i := 0; i < len(matrix); i++ { for j := 0; j < len(matrix[i]); j++ { if matrix[i][j] == -1 { if maxPerCol[j] == int(math.MinInt64) { currentMax := 0 for k := 0; k < len(matrix); k++ { if matrix[k][j] > currentMax { currentMax = matrix[k][j] } } matrix[i][j] = currentMax maxPerCol[j] = currentMax } else { matrix[i][j] = maxPerCol[j] } } } } return matrix } ================================================ FILE: Monotonic Array/kata.go ================================================ package kata func isMonotonic(A []int) bool { var dec, inc int for i := 1; i < len(A); i++ { if A[i-1] < A[i] { inc++ } else if A[i-1] > A[i] { dec++ } } if (dec == 0 && inc != 0) || (dec != 0 && inc == 0) || (dec == 0 && inc == 0) { return true } return false } ================================================ FILE: Monthly Transactions I/q.sql ================================================ SELECT DATE_FORMAT(trans_date, '%Y-%m') AS month, country, COUNT(*) AS trans_count, SUM( CASE WHEN state = "approved" THEN 1 ELSE 0 END ) AS approved_count, SUM(amount) AS trans_total_amount, SUM( CASE WHEN state = "approved" THEN amount ELSE 0 END ) AS approved_total_amount FROM Transactions GROUP BY country, DATE_FORMAT(trans_date, '%Y-%m'); ================================================ FILE: Most Common Word/kata.go ================================================ package kata import ( "fmt" "strings" ) func mostCommonWord(paragraph string, banned []string) string { if len(paragraph) == 0 { return "" } words := make(map[string]int) var word string for i := 0; i < len(paragraph); i++ { if (paragraph[i] >= 65 && paragraph[i] <= 90) || (paragraph[i] >= 97 && paragraph[i] <= 122) { word += string(paragraph[i]) if len(paragraph)-1 != i { continue } } if word == "" { continue } word = strings.ToLower(word) if !hasBanned(banned, word) { words[word] = words[word] + 1 } word = "" } if len(words) == 0 { return strings.ToLower(word) } max := -1 for w, c := range words { fmt.Println(w, c) if max == -1 || c > max { word = w max = c } } return word } func hasBanned(banned []string, word string) bool { for i := 0; i < len(banned); i++ { if strings.ToLower(banned[i]) == word { return true } } return false } ================================================ FILE: Most Frequent Even Element/kata.go ================================================ package Most_Frequent_Even_Element import "sort" func mostFrequentEven(nums []int) int { sort.Ints(nums) var max int var globalMax int var currentMaxNumber int var currentNumber int for i, n := range nums { if n%2 == 0 || n == 0 { if n != currentNumber { if globalMax < max { globalMax = max currentMaxNumber = nums[i-1] } max = 0 } currentNumber = n max++ } else { if globalMax < max { globalMax = max currentMaxNumber = nums[i-1] } max = 0 } } if globalMax < max { currentMaxNumber = nums[len(nums)-1] globalMax = max } if globalMax == 0 { currentMaxNumber = -1 } return currentMaxNumber } ================================================ FILE: Most Frequent Number Following Key In an Array/kata.go ================================================ package Most_Frequent_Number_Following_Key_In_an_Array func mostFrequent(nums []int, key int) int { counter := map[int]int{} for i := 0; i < len(nums)-1; i++ { if nums[i] == key { counter[nums[i+1]]++ } } var max, num int for n, c := range counter { if c > max { max = c num = n } } return num } ================================================ FILE: Move Zeroes/kata.go ================================================ package kata func moveZeroes(nums []int) { stack := make([]int, 0) for _, num := range nums { if num == 0 { continue } stack = append(stack, num) } for i := 0; i < len(nums); i++ { if len(stack) == 0 { nums[i] = 0 } else { nums[i] = stack[0] stack = stack[1:] } } } ================================================ FILE: Moving Average from Data Stream/kata.go ================================================ package Moving_Average_from_Data_Stream import "container/list" type MovingAverage struct { currentLen int size int list *list.List sum float64 } func Constructor(size int) MovingAverage { return MovingAverage{ size: size, list: list.New(), } } func (mv *MovingAverage) Next(val int) float64 { mv.currentLen++ mv.list.PushBack(val) if mv.currentLen > mv.size { n := mv.list.Front().Value.(int) mv.list.Remove(mv.list.Front()) mv.sum = mv.sum - float64(n) mv.currentLen-- } mv.sum = mv.sum + float64(val) return mv.sum / float64(mv.currentLen) } ================================================ FILE: Multiply Strings/kata.go ================================================ package kata import "math/big" func multiply(num1 string, num2 string) string { a, _ := big.NewInt(0).SetString(num1, 10) b, _ := big.NewInt(0).SetString(num2, 10) y := big.NewInt(0).Mul(a, b) return y.String() } ================================================ FILE: My Calendar I/kata.go ================================================ package kata type BookingInfo struct { start int end int } type MyCalendar struct { booked []BookingInfo } func Constructor() MyCalendar { return MyCalendar{ booked: make([]BookingInfo, 0), } } func (this *MyCalendar) Book(start int, end int) bool { if len(this.booked) == 0 { this.booked = append(this.booked, BookingInfo{start: start, end: end}) return true } for _, booking := range this.booked { if booking.start < end && start < booking.end { return false } } this.booked = append(this.booked, BookingInfo{start: start, end: end}) return true } /** * Your MyCalendar object will be instantiated and called as such: * obj := Constructor(); * param_1 := obj.Book(start,end); */ ================================================ FILE: N-Repeated Element in Size 2N Array/kata.go ================================================ package kata func repeatedNTimes(A []int) (n int) { set := make(map[int]int) for i := 0; i < len(A); i++ { set[A[i]]++ if set[A[i]] > 1 { n = A[i] return } } return } ================================================ FILE: N-th Tribonacci Number/kata.go ================================================ package kata // 0, 0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149, 274, 504, 927, 1705, 3136, 5768, 10609, 19513, 35890, 66012 func tribonacci(n int) int { if n == 0 { return 0 } if n == 1 { return 1 } if n == 2 { return 1 } solver := eq() var k int for i := 0; i < n-2; i++ { k = solver() } return k } func eq() func() int { x1, x2, x3 := 0, 1, 1 return func() int { x1, x2, x3 = x2, x3, x1+x2+x3 return x3 } } ================================================ FILE: NPV Queries/q.sql ================================================ SELECT q.id, q.year, COALESCE(npv, 0) AS npv FROM Queries AS q LEFT JOIN NPV AS n ON q.id=n.id AND q.year=n.year ================================================ FILE: Neither Minimum nor Maximum/kata.go ================================================ package kata import ( "sort" ) func findNonMinOrMax(nums []int) int { if len(nums) <= 2 { return -1 } sort.Ints(nums) return nums[1] } ================================================ FILE: Nested List Weight Sum/kata.go ================================================ package Nested_List_Weight_Sum /** * // 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 (n 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 (n 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 (n *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 (n NestedInteger) GetList() []*NestedInteger {} */ func depthSum(nestedList []*NestedInteger) int { l := 1 sum := 0 f(nestedList, &sum, l) return sum } func f(nestedList []*NestedInteger, sum *int, l int) { for _, o := range nestedList { if o.IsInteger() { *sum += l * o.GetInteger() } else { f(o.GetList(), sum, l+1) } } } ================================================ FILE: New Users Daily Count/q.sql ================================================ WITH summary AS ( SELECT MIN(activity_date) AS activity_date, user_id FROM Traffic WHERE activity = "login" GROUP BY user_id ) SELECT activity_date AS login_date, COUNT(DISTINCT user_id) AS user_count FROM summary WHERE ( activity_date >= (DATE_SUB("2019-06-30", INTERVAL 90 DAY)) AND activity_date <= "2019-06-30" ) GROUP BY activity_date; ================================================ FILE: Next Greater Element I/kata.go ================================================ package kata func nextGreaterElement(nums1 []int, nums2 []int) []int { set := make(map[int]int) for i := 0; i < len(nums2); i++ { set[nums2[i]] = i } n := make([]int, len(nums1)) o := 0 for i := 0; i < len(nums1); i++ { j := set[nums1[i]] found := false for k := j + 1; k < len(nums2); k++ { if nums2[j] < nums2[k] { n[o] = nums2[k] found = true break } } if !found { n[o] = -1 } o++ } return n } ================================================ FILE: Not Boring Movies/kata.sql ================================================ package kata SELECT * FROM cinema c WHERE c.description != "boring" AND c.id % 2 = 1 ORDER BY c.rating DESC; ================================================ FILE: Nth Highest Salary/kata.sql ================================================ package kata CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT BEGIN DECLARE o INT; SET o := N-1; RETURN ( SELECT CASE WHEN Salary IS NULL THEN NULL ELSE Salary END AS Salary FROM (select distinct Salary from Employee) AS E ORDER BY Salary DESC LIMIT 1 OFFSET o ); END ================================================ FILE: Number Complement/kata.go ================================================ package kata import "math" func findComplement(num int) int { bin := make([]int, 0) for num > 0 { k := num % 2 num = num / 2 bin = append(bin, k) } for i := range bin { if bin[i] == 1 { bin[i] = 0 } else { bin[i] = 1 } } num = 0 for i := 0; i < len(bin); i++ { num += bin[i] * int(math.Pow(float64(2), float64(i))) } return num } ================================================ FILE: Number Of Rectangles That Can Form The Largest Square/kata.java ================================================ class Solution { public int countGoodRectangles(int[][] rectangles) { var count = 0; var maxLen = -1; for (var rectangle : rectangles) { var minLen = min(rectangle[0], rectangle[1]); if (maxLen == -1 || minLen > maxLen) { maxLen = minLen; count = 1; } else if (minLen == maxLen) { count++; } } return count; } private int min(int a, int b) { if (a < b) { return a; } return b; } } ================================================ FILE: Number of 1 Bits/kata.go ================================================ package kata func hammingWeight(num uint32) int { var countSetBits int for num > 0 { bit := num % 2 num = num / 2 if bit == 1 { countSetBits++ } } return countSetBits } ================================================ FILE: Number of Arithmetic Triplets/kata.java ================================================ class Solution { public int arithmeticTriplets(int[] nums, int diff) { Set set = new HashSet(); for (var num : nums) { set.add(num); } var tripletCount = 0; for (var i = 0; i < nums.length; i++) { var jump = nums[i]+diff; if (set.contains(jump) && set.contains(jump+diff)) { tripletCount++; } } return tripletCount; } } ================================================ FILE: Number of Days Between Two Dates/kata.go ================================================ package kata import "time" const layoutISO = "2006-01-02" func daysBetweenDates(date1 string, date2 string) int { dA, err := time.Parse(layoutISO, date2) if err != nil { panic(err) } dB, err := time.Parse(layoutISO, date1) if err != nil { panic(err) } d := int(dA.Sub(dB).Hours() / 24) if d < 0 { return d * -1 } return d } ================================================ FILE: Number of Days in a Month/kata.java ================================================ // January: 31 days // February: 28 days in a common year, 29 days in a leap year // March: 31 days // April: 30 days // May: 31 days // June: 30 days // July: 31 days // August: 31 days // September: 30 days // October: 31 days // November: 30 days // December: 31 days class Solution { public int numberOfDays(int year, int month) { if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) { return 31; } if (month == 2) { if (year % 4 != 0) return 28; else if (year % 100 != 0) return 29; else if (year % 400 != 0) return 28; return 29; } return 30; } } ================================================ FILE: Number of Different Integers in a String/kata.go ================================================ package kata func numDifferentIntegers(word string) int { var found int count := make(map[string]int) digit := []rune{} for _, char := range word { if char >= 48 && char <= 57 { found++ digit = append(digit, char) } if char >= 97 && char <= 122 { if found >= 1 { found = 0 var i int for _, n := range digit { if n == '0' { i++ } else { break } } count[string(digit[i:])] = 0 digit = []rune{} } } } if found >= 1 { var i int for _, n := range digit { if n == '0' { i++ } else { break } } count[string(digit[i:])] = 0 } return len(count) } ================================================ FILE: Number of Distinct Averages/kata.java ================================================ import java.util.Arrays; import java.util.HashSet; class Solution { public int distinctAverages(int[] nums) { Arrays.sort(nums); var i = 0; var j = nums.length-1; var distinctAverages = new HashSet(); for (; i < nums.length; i++) { distinctAverages.add(((double) (nums[i] + nums[j])) / 2); j--; } return distinctAverages.size(); } } ================================================ FILE: Number of Employees Who Met the Target/kata.go ================================================ package kata func numberOfEmployeesWhoMetTarget(hours []int, target int) int { var employeeCount int for i := 0; i < len(hours); i++ { if hours[i] >= target { employeeCount++ } } return employeeCount } ================================================ FILE: Number of Equivalent Domino Pairs/kata.go ================================================ package Number_of_Equivalent_Domino_Pairs import "math/big" func numEquivDominoPairs(dominoes [][]int) int { var matrix [100]int var c int for _, d := range dominoes { n := hash(d) matrix[n]++ } for _, d := range matrix { if d >= 2 { c += Binomial(d) } } return c } func hash(d []int) int { return 10*max(d[0], d[1]) + min(d[0], d[1]) } 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 } func init() { cache = make(map[int]int) } var cache map[int]int func Binomial(n int) int { if _, ok := cache[n]; ok { return cache[n] } k := new(big.Int) return int(k.Binomial(int64(n), 2).Int64()) } ================================================ FILE: Number of Even and Odd Bits/kata.go ================================================ package kata func evenOddBit(n int) []int { var i int var odd int var even int for n > 0 { b := n % 2 n = n / 2 if b == 1 { if i%2 == 0 { even++ } else { odd++ } } i++ } return []int{even, odd} } ================================================ FILE: Number of Good Pairs/kata.go ================================================ package kata import "sort" func numIdenticalPairs(nums []int) int { sort.Ints(nums) var c int var knowNumber *int var k int for i := 0; i < len(nums); i++ { if knowNumber == nil { knowNumber = new(int) *knowNumber = i k++ continue } if nums[*knowNumber] != nums[i] || (i == len(nums)-1 && nums[i] == nums[*knowNumber]) { if i == len(nums)-1 && nums[i] == nums[*knowNumber] { k++ } if k == 1 { *knowNumber = i k = 1 continue } if k == 2 { c += 1 } else { c += (k - 1) * (k) / 2 } *knowNumber = i k = 0 } k++ } return c } ================================================ FILE: Number of Laser Beams in a Bank/kata.go ================================================ package Number_of_Laser_Beams_in_a_Bank func numberOfBeams(bank []string) int { var sum int preCurrentDevices := -1 for i := 0; i < len(bank); i++ { var currentDevices int for j := 0; j < len(bank[i]); j++ { if bank[i][j] == '1' { currentDevices++ } } if preCurrentDevices == -1 { preCurrentDevices = currentDevices } else { if preCurrentDevices > 0 && currentDevices > 0 { sum += preCurrentDevices * currentDevices preCurrentDevices = currentDevices } else if preCurrentDevices == 0 && currentDevices > 0 { preCurrentDevices = currentDevices } } } return sum } ================================================ FILE: Number of Lines To Write String/kata.java ================================================ class Solution { public int[] numberOfLines(int[] widths, String s) { var res = new int[2]; final var threshold = 100; var currentLineWidth = 0; for (var i = 0; i < s.length(); i++) { if (currentLineWidth + widths[s.codePointAt(i)-97] > threshold) { currentLineWidth = widths[s.codePointAt(i)-97]; res[0]++; } else { currentLineWidth = currentLineWidth + widths[s.codePointAt(i)-97]; } } if (currentLineWidth > 0) { res[1] = currentLineWidth; res[0]++; } return res; } } ================================================ FILE: Number of Recent Calls/kata.go ================================================ package kata type RecentCounter struct { pings []int } func Constructor() RecentCounter { return RecentCounter{ pings: make([]int, 0), } } func (rc *RecentCounter) Ping(t int) int { rc.pings = append(rc.pings, t) var count int min := t - 3000 i := len(rc.pings) - 1 for ; i >= 0; i-- { if rc.pings[i] < min { break } count++ } rc.pings = rc.pings[i+1:] return count } /** * Your RecentCounter object will be instantiated and called as such: * obj := Constructor(); * param_1 := obj.Ping(t); */ ================================================ FILE: Number of Segments in a String/kata.go ================================================ package kata func countSegments(s string) int { var c int var word int for i := 0; i < len(s); i++ { if s[i] != ' ' { word++ } if (s[i] == ' ' || len(s)-1 == i) && word > 0 { c++ word = 0 } } return c } ================================================ FILE: Number of Senior Citizens/kata.go ================================================ package kata func countSeniors(details []string) int { var count int for _, detail := range details { var age int var multipler = 1 i := len(detail)-3 for { if i == 10 { break } age += (int(detail[i])-48) * multipler multipler *= 10 i-- } if age > 60 { count++ } } return count } ================================================ FILE: Number of Steps to Reduce a Number to Zero/kata.go ================================================ package kata func numberOfSteps(num int) int { var steps int for num > 0 { if num%2 == 0 { num = num / 2 } else { num -= 1 } steps++ } return steps } ================================================ FILE: Number of Strings That Appear as Substrings in Word/kata.java ================================================ class Solution { public int numOfStrings(String[] patterns, String word) { var count = 0; for (var pattern : patterns) { if (word.contains(pattern)) { count++; } } return count; } } ================================================ FILE: Number of Students Doing Homework at a Given Time/kata.go ================================================ package kata func busyStudent(startTime []int, endTime []int, queryTime int) int { var matched int for i := 0; i < len(startTime); i++ { if startTime[i] > queryTime { continue } if endTime[i] < queryTime { continue } matched++ } return matched } ================================================ FILE: Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold/kata.java ================================================ class Solution { public int numOfSubarrays(int[] arr, int k, int threshold) { var i = 0; var sum = 0; for (; i < k; i++) { sum += arr[i]; } var avg = sum/k; var matchedCount = 0; if (avg >= threshold) { matchedCount++; } for (; i < arr.length; i++) { sum += arr[i]; sum -= arr[i-k]; avg = sum/k; if (avg >= threshold) { matchedCount++; } } return matchedCount; } } ================================================ FILE: Number of Unique Subjects Taught by Each Teacher/k.sql ================================================ SELECT teacher_id, COUNT(DISTINCT subject_id) AS cnt FROM Teacher GROUP BY teacher_id; ================================================ FILE: Number of Visible People in a Queue/kata.go ================================================ package kata func canSeePersonsCount(heights []int) []int { var stack []int result := make([]int, len(heights)) for i := len(heights) - 1; i >= 0; i-- { for len(stack) > 0 && heights[i] > heights[stack[len(stack)-1]] { stack = stack[:len(stack)-1] result[i]++ } if len(stack) >= 1 { result[i]++ } stack = append(stack, i) } return result } ================================================ FILE: Occurrences After Bigram/kata.go ================================================ package kata func findOcurrences(text string, first string, second string) []string { var j int matchedFirst := -1 matchedSecond := -1 wordCount := 0 words := make([]string, 0) for i := 0; i < len(text); i++ { if text[i] == ' ' || len(text)-1 == i { if len(text)-1 == i { i = i + 1 } wordCount++ if matchedFirst == -1 && text[j:i] == first { matchedFirst = wordCount j = i + 1 continue } else if wordCount-1 == matchedFirst && text[j:i] == second { matchedSecond = wordCount j = i + 1 continue } else if wordCount-1 == matchedSecond { words = append(words, text[j:i]) matchedSecond = -1 matchedFirst = -1 if text[j:i] == first { matchedFirst = wordCount } j = i + 1 continue } matchedFirst = -1 if text[j:i] == first { matchedFirst = wordCount } matchedSecond = -1 j = i + 1 } } return words } ================================================ FILE: One Edit Distance/kata.go ================================================ package One_Edit_Distance import "math" func isOneEditDistance(s string, t string) bool { if s == t { return false } if math.Abs(float64(len(s))-float64(len(t))) > 1 { return false } var c int if len(s) == len(t) { for i := 0; i < len(t); i++ { if s[i] != t[i] { c++ } } return c == 1 } if len(s) > len(t) { if len(t) == 0 { return true } if s[:len(s)-1] == t { return true } j := 0 for i := 0; i < len(s); i++ { if s[i] != t[j] { c++ continue } j++ } return c == 1 || c == 0 } if string(t[0])+s == t { return true } if s+string(t[len(t)-1]) == t { return true } j := 0 for i := 0; i < len(t); i++ { if s[j] != t[i] { c++ continue } j++ } return c == 1 || c == 0 } ================================================ FILE: Online Stock Span/kata.go ================================================ package kata type StockSpanner struct { prices []int } func Constructor() StockSpanner { return StockSpanner{prices: make([]int, 0)} } func (this *StockSpanner) Next(price int) int { this.prices = append(this.prices, price) if len(this.prices) == 1 { return 1 } var c int for i := len(this.prices) - 1; i >= 0; i-- { if this.prices[i] <= price { c++ continue } break } return c } /** * Your StockSpanner object will be instantiated and called as such: * obj := Constructor(); * param_1 := obj.Next(price); */ ================================================ FILE: Orders With Maximum Quantity Above Average/q.sql ================================================ WITH cte AS (SELECT order_id, (SUM(quantity)/COUNT(product_id)) AS average_quantity, MAX(quantity) AS max_quantity FROM OrdersDetails GROUP BY order_id) SELECT order_id FROM cte AS c WHERE c.max_quantity > (SELECT MAX(average_quantity) FROM cte); ================================================ FILE: Palindrome Linked List/kata.go ================================================ package kata type ListNode struct { Val int Next *ListNode } func isPalindrome(head *ListNode) bool { _, ok := p(head, head) return ok } func p(a *ListNode, b *ListNode) (*ListNode, bool) { if a.Next == nil { if a.Val != b.Val { return nil, false } return b.Next, true } c, ok := p(a.Next, b) if !ok { return nil, false } if c.Val == a.Val { return c.Next, true } return nil, false } ================================================ FILE: Palindrome Number/kata.go ================================================ package kata func isPalindrome(x int) bool { if x < 0 { return false } nums := make([]int, 0) for x > 0 { k := x % 10 x = x / 10 nums = append(nums, k) } j := len(nums) - 1 for i := 0; i < len(nums)/2; i++ { if nums[j] != nums[i] { return false } j-- } return true } ================================================ FILE: Parsing A Boolean Expression/kata.go ================================================ package kata func parseBoolExpr(expression string) bool { v, _, _ := parseUnit(expression, 0) return v } func IsBool(c byte) bool { return c == 'f' || c == 't' } func parseBool(c byte) bool { if c == 'f' { return false } return true } func IsNot(c byte) bool { return c == '!' } func parseNot(expression string, i int) (bool, int) { var value bool var j int for ; i < len(expression); i++ { if IsClosed(expression[i]) { j = i break } v, k, match := parseUnit(expression, i) if k != -1 { i = k } if match { value = v } } return !value, j } func IsAnd(c byte) bool { return c == '&' } func parseAnd(expression string, i int) (bool, int) { var value *bool var j int for ; i < len(expression); i++ { if IsClosed(expression[i]) { j = i break } v, k, match := parseUnit(expression, i) if k != -1 { i = k } if match && value == nil { value = new(bool) *value = v match = false } else if match { *value = *value && v match = false } } return *value, j } func IsOr(c byte) bool { return c == '|' } func parseOr(expression string, i int) (bool, int) { var value *bool var j int for ; i < len(expression); i++ { if IsClosed(expression[i]) { j = i break } v, k, match := parseUnit(expression, i) if k != -1 { i = k } if match && value == nil { value = new(bool) *value = v match = false } else if match { *value = *value || v match = false } } return *value, j } func parseUnit(expression string, i int) (bool, int, bool) { var v bool k := -1 var match bool if IsOr(expression[i]) { v, k = parseOr(expression, i+1) match = true } else if IsAnd(expression[i]) { v, k = parseAnd(expression, i+1) match = true } else if IsNot(expression[i]) { v, k = parseNot(expression, i+1) match = true } else if IsBool(expression[i]) { v = parseBool(expression[i]) match = true k = -1 } return v, k, match } func IsClosed(c byte) bool { return c == ')' } ================================================ FILE: Partition Array According to Given Pivot/kata.go ================================================ package kata import "container/list" func pivotArray(nums []int, pivot int) []int { smaller := list.New() middle := list.New() greater := list.New() for _, n := range nums { if n < pivot { smaller.PushBack(n) } else if n == pivot { middle.PushBack(n) } else { greater.PushBack(n) } } for i := 0; i < len(nums); i++ { if smaller.Front() != nil { nums[i] = smaller.Front().Value.(int) smaller.Remove(smaller.Front()) } else if middle.Front() != nil { nums[i] = middle.Front().Value.(int) middle.Remove(middle.Front()) } else { nums[i] = greater.Front().Value.(int) greater.Remove(greater.Front()) } } return nums } ================================================ FILE: Partitioning Into Minimum Number Of Deci-Binary Numbers/kata.java ================================================ class Solution { public int minPartitions(String n) { if (n.length() == 1) { return n.charAt(0)-48; } var lastDigit = -1; for (var i = 0; i < n.length(); i++) { var a = n.charAt(i)-48; if (lastDigit == -1 || lastDigit < a) { lastDigit = a; } if (lastDigit == 9) { break; } } return lastDigit; } } ================================================ FILE: Pascal's Triangle/kata.go ================================================ package Pascal_s_Triangle func generate(numRows int) [][]int { if numRows == 1 { return [][]int{[]int{1}} } if numRows == 2 { return [][]int{[]int{1}, []int{1, 1}} } o := make([][]int, numRows) l := 0 o[l] = []int{1} l++ o[l] = []int{1, 1} for i := 2; i < numRows; i++ { row := make([]int, i+1) row[0] = 1 row[len(row)-1] = 1 k := 1 for j := 0; j < len(o[i-1])-1; j++ { n := o[i-1][j] + o[i-1][j+1] row[k] = n k++ } l++ o[l] = row } return o } ================================================ FILE: Pascal's Triangle II/kata.go ================================================ package Pascal_s_Triangle_II func getRow(rowIndex int) []int { if rowIndex == 0 { return []int{1} } if rowIndex == 1 { return []int{1, 1} } o := make([]int, 0) o = []int{1, 1} for i := 2; i < rowIndex+1; i++ { row := make([]int, i+1) row[0] = 1 row[len(row)-1] = 1 k := 1 for j := 0; j < len(o)-1; j++ { n := o[j] + o[j+1] row[k] = n k++ } o = row } return o } ================================================ FILE: Path Sum/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func hasPathSum(root *TreeNode, sum int) bool { if root == nil { return false } return pathSum(root, root.Val, sum) } func pathSum(root *TreeNode, v int, sum int) bool { if root.Left == nil && root.Right == nil { if sum == v { return true } return false } var l bool if root.Left != nil { l = pathSum(root.Left, v+root.Left.Val, sum) } var r bool if root.Right != nil { r = pathSum(root.Right, v+root.Right.Val, sum) } if l || r { return true } return false } ================================================ FILE: Patients With a Condition/q.sql ================================================ SELECT patient_id, patient_name, conditions FROM Patients WHERE conditions LIKE '% DIAB1%' OR conditions LIKE 'DIAB1%'; ================================================ FILE: Peak Index in a Mountain Array/kata.go ================================================ package kata func peakIndexInMountainArray(A []int) int { max := -1 idx := -1 for i := 0; i < len(A); i++ { if max == -1 || A[i] > max { max = A[i] idx = i } } return idx } ================================================ FILE: Peeking Iterator/kata.go ================================================ package kata /* Below is the interface for Iterator, which is already defined for you. * * type Iterator struct { * * } * * func (this *Iterator) hasNext() bool { * // Returns true if the iteration has more elements. * } * * func (this *Iterator) next() int { * // Returns the next element in the iteration. * } */ type PeekingIterator struct { iter *Iterator } func Constructor(iter *Iterator) *PeekingIterator { return &PeekingIterator{ iter: iter, } } func (pt *PeekingIterator) hasNext() bool { return pt.iter.hasNext() } func (pt *PeekingIterator) next() int { return pt.iter.next() } func (pt *PeekingIterator) peek() int { n := pt.iter.next() pt.iter.index-- return n } ================================================ FILE: Percentage of Letter in String/kata.go ================================================ package Percentage_of_Letter_in_String import "math" func percentageLetter(s string, letter byte) int { c := 0 for _, char := range s { if rune(letter) == char { c++ } } if c > 0 { return int(math.Floor(float64(c) / float64(len(s)) * 100)) } return c } ================================================ FILE: Percentage of Users Attended a Contest/q.sql ================================================ SELECT contest_id, ROUND( COUNT(*) / ( SELECT COUNT(*) FROM Users ) * 100, 2 ) AS percentage FROM Register AS r INNER JOIN Users AS u ON u.user_id = r.user_id GROUP BY contest_id ORDER BY percentage DESC, contest_id ASC; ================================================ FILE: Perfect Number/kata.go ================================================ package Perfect_Number import "math" func checkPerfectNumber(num int) bool { var sum float64 for i := 1; i <= int(math.Sqrt(float64(num))); i++ { if num%i == 0 { if num/i == i { sum += float64(i) } else { sum += float64(i) + float64(num)/float64(i) } } } return int(sum-float64(num)) == num } ================================================ FILE: Perform String Shifts/kata.go ================================================ package kata const ( RightShiftMode int = 1 LeftShiftMode int = 0 ) func stringShift(s string, shift [][]int) string { b := []byte(s) for _, operation := range shift { amount := operation[1] shiftMode := operation[0] if shiftMode == RightShiftMode { b = RightShift(b, amount) } else if shiftMode == LeftShiftMode { b = LeftShift(b, amount) } } return string(b) } func LeftShift(b []byte, amount int) []byte { if amount == 0 { return b } if len(b) <= 2 { return b } tmp := b[0] for i := 0; i < len(b)-1; i++ { b[i] = b[i+1] } b[len(b)-1] = tmp return LeftShift(b, amount-1) } func RightShift(b []byte, amount int) []byte { if amount == 0 { return b } if len(b) <= 2 { return b } tmp := b[len(b)-1] for i := len(b) - 1; i >= 1; i-- { b[i] = b[i-1] } b[0] = tmp return RightShift(b, amount-1) } ================================================ FILE: Permutations/kata.go ================================================ package kata func permute(nums []int) [][]int { permutations := make([][]int, 0) perm(nums, &permutations, 0) return permutations } func perm(nums []int, permutations *[][]int, i int) { if i > len(nums) { numsCopy := make([]int, len(nums)) copy(numsCopy, nums) *permutations = append(*permutations, numsCopy) return } perm(nums, permutations, i+1) for j := i + 1; j < len(nums); j++ { // swap i and j value nums[i], nums[j] = nums[j], nums[i] perm(nums, permutations, i+1) // revert swap between i and j values nums[i], nums[j] = nums[j], nums[i] } } ================================================ FILE: Permutations II/kata.go ================================================ package Permutations_II func permuteUnique(nums []int) [][]int { permutations := make([][]int, 0) duplicates := make(map[int]bool) perm(nums, &permutations, 0, duplicates) return permutations } func perm(nums []int, permutations *[][]int, i int, duplicates map[int]bool) { if i > len(nums) { n := 1 var sum int for i := 0; i < len(nums); i++ { sum += nums[i] * n n = n * 10 } if duplicates[sum] { return } duplicates[sum] = true numsCopy := make([]int, len(nums)) copy(numsCopy, nums) *permutations = append(*permutations, numsCopy) return } perm(nums, permutations, i+1, duplicates) for j := i + 1; j < len(nums); j++ { nums[i], nums[j] = nums[j], nums[i] perm(nums, permutations, i+1, duplicates) nums[i], nums[j] = nums[j], nums[i] } } ================================================ FILE: Plus One/kata.go ================================================ package kata var one []int = []int{1} func plusOne(digits []int) []int { if len(digits) == 0 { return one } var reminder bool if digits[len(digits)-1] == 9 { for i := len(digits) - 1; i >= 0; i-- { if reminder && (digits[i]+1) == 10 { digits[i] = 0 reminder = true } else if reminder { digits[i] += 1 reminder = false break } else if (digits[i] + 1) == 10 { digits[i] = 0 reminder = true } } if reminder { return append(one, digits...) } } else { digits[len(digits)-1] = digits[len(digits)-1] + 1 } return digits } ================================================ FILE: Points That Intersect With Cars/kata.go ================================================ package main import "sort" func numberOfPoints(nums [][]int) int { sort.Slice(nums, func(i, j int) bool { return nums[i][0] < nums[j][0] }) var left, right = nums[0][0], nums[0][1] var sum = 0 for _, num := range nums[1:] { if num[0] > left && right < num[0] { sum += right - (left - 1) right = num[1] left = num[0] } else if num[1] > right { right = num[1] } } sum += right - (left - 1) return sum } ================================================ FILE: Populating Next Right Pointers in Each Node/kata.go ================================================ package Populating_Next_Right_Pointers_in_Each_Node /** * Definition for a Node. * type Node struct { * Val int * Left *Node * Right *Node * Next *Node * } */ func connect(root *Node) *Node { if root == nil { return nil } f(root.Left, root.Right) return root } func f(l *Node, r *Node) { if l == nil || r == nil { return } l.Next = r f(r.Left, r.Right) f(l.Right, r.Left) f(l.Left, l.Right) return } ================================================ FILE: Positions of Large Groups/kata.go ================================================ package kata func largeGroupPositions(S string) [][]int { lastSeenChar := S[0] firstIdx := 0 c := 1 groups := make([][]int, 0) for i := 1; i < len(S); i++ { if i == len(S)-1 { k := i - 1 if lastSeenChar == S[i] { k = i c++ } if c >= 3 { groups = append(groups, []int{firstIdx, k}) } } else if lastSeenChar != S[i] { if c >= 3 { groups = append(groups, []int{firstIdx, i - 1}) } firstIdx = i lastSeenChar = S[i] c = 1 continue } else { c++ } } return groups } ================================================ FILE: Power of Four/kata.go ================================================ package kata import "math" func isPowerOfFour(num int) bool { if 0 == num { return false } k := math.Log(float64(num)) / math.Log(4) return math.Floor(k) == k } ================================================ FILE: Power of Three/kata.go ================================================ package kata import "math" func isPowerOfThree(num int) bool { if 0 == num { return false } k := math.Log(float64(num)) / math.Log(3) n1 := math.Pow(3, float64(int(k))) return int(n1) == num } ================================================ FILE: Power of Two/kata.go ================================================ package kata import "math" func isPowerOfTwo(n int) bool { if 0 == n { return false } k := math.Log2(float64(n)) return math.Floor(k) == k } ================================================ FILE: Powerful Integers/kata.go ================================================ package kata import "math" func powerfulIntegers(x int, y int, bound int) []int { i := 0 j := 0 set := make(map[int]bool) var hit bool outerLoop: for { xi := int(math.Pow(float64(x), float64(i))) if xi >= bound || (hit && x == 1) { break } i++ for { hit = true yj := int(math.Pow(float64(y), float64(j))) z := xi + yj if z > bound { j = 0 continue outerLoop } set[z] = true if y == 1 { j = 0 continue outerLoop } j++ } } nums := make([]int, len(set)) i = 0 for z := range set { nums[i] = z i++ } return nums } ================================================ FILE: Prefix and Suffix Search/kata.go ================================================ package kata type WordFilter struct { words []string } func Constructor(words []string) WordFilter { return WordFilter{words: words} } func (this *WordFilter) F(prefix string, suffix string) int { if prefix == "" && suffix == "" && len(this.words) != 0 { return 0 } for i := len(this.words) - 1; i >= 0; i-- { if len(suffix) > len(this.words[i]) { continue } if len(prefix) > len(this.words[i]) { continue } if suffix != "" && prefix != "" { s := this.words[i][len(this.words[i])-len(suffix):] p := this.words[i][:len(prefix)] if s == suffix && p == prefix { return i } } else if suffix != "" { s := this.words[i][len(this.words[i])-len(suffix):] if s == suffix { return i } continue } else if prefix != "" { p := this.words[i][:len(prefix)] if p == prefix { return i } } } return -1 } /** * Your WordFilter object will be instantiated and called as such: * obj := Constructor(words); * param_1 := obj.F(prefix,suffix); */ ================================================ FILE: Primary Department for Each Employee/q.sql ================================================ SELECT employee_id, department_id FROM Employee GROUP BY employee_id HAVING COUNT(*) = 1 UNION SELECT employee_id, department_id FROM Employee WHERE primary_flag = "Y" GROUP BY employee_id ================================================ FILE: Prime Number of Set Bits in Binary Representation/kata.java ================================================ import java.math.BigInteger; class Solution { public int countPrimeSetBits(int left, int right) { var count = 0; for (var num = left; num <= right; num++) { var bitCount = BigInteger.valueOf(Integer.bitCount(num)); if (bitCount.isProbablePrime(30)) { count++; } } return count; } } ================================================ FILE: Print Immutable Linked List in Reverse/kata.go ================================================ package Print_Immutable_Linked_List_in_Reverse /* Below is the interface for ImmutableListNode, which is already defined for you. * * type ImmutableListNode struct { * * } * * func (this *ImmutableListNode) getNext() ImmutableListNode { * // return the next node. * } * * func (this *ImmutableListNode) printValue() { * // print the value of this node. * } */ func printLinkedListInReverse(head ImmutableListNode) { n := head.getNext() if n != nil { printLinkedListInReverse(n) } head.printValue() } ================================================ FILE: Product Sales Analysis I/q.sql ================================================ SELECT p.product_name, s.year, s.price FROM Product AS p INNER JOIN Sales AS s ON s.product_id = p.product_id GROUP BY s.sale_id; ================================================ FILE: Product Sales Analysis II/q.sql ================================================ SELECT product_id, SUM(quantity) AS total_quantity FROM Sales GROUP BY product_id ================================================ FILE: Product of Array Except Self/kata.go ================================================ package kata func productExceptSelf(nums []int) []int { sum := 0 sumZero := 0 first := true zeros := 0 for _, n := range nums { if n == 0 { sumZero *= n zeros++ if zeros > 1 { sum *= n } continue } if first { sum = 1 sumZero = 1 first = false } sum *= n sumZero *= n } for i := range nums { if nums[i] == 0 { nums[i] = sum continue } nums[i] = sumZero / nums[i] } return nums } ================================================ FILE: Product of the Last K Numbers/kata.go ================================================ package kata type ProductOfNumbers struct { numbers []int } func Constructor() ProductOfNumbers { return ProductOfNumbers{numbers: make([]int, 0)} } func (this *ProductOfNumbers) Add(num int) { this.numbers = append(this.numbers, num) } func (this *ProductOfNumbers) GetProduct(k int) int { if len(this.numbers) < k { panic("k is greater than len(this.numbers)") } sum := 1 for _, n := range this.numbers[len(this.numbers)-k:] { sum = sum * n } return sum } /** * Your ProductOfNumbers object will be instantiated and called as such: * obj := Constructor(); * obj.Add(num); * param_2 := obj.GetProduct(k); */ ================================================ FILE: Product's Price for Each Store/q.sql ================================================ SELECT product_id, MAX(store1) AS store1, MAX(store2) AS store2, MAX(store3) AS store3 FROM ( SELECT product_id, price AS store1, NULL AS store2, NULL AS store3 FROM Products WHERE store = "store1" UNION ALL SELECT product_id, NULL AS store1, price AS store2, NULL AS store3 FROM Products WHERE store = "store2" UNION ALL SELECT product_id, NULL AS store1, NULL AS store2, price AS store3 FROM Products WHERE store = "store3" ) AS transpose GROUP BY product_id ================================================ FILE: Product's Worth Over Invoices/q.sql ================================================ SELECT p.name, COALESCE(SUM(rest), 0) AS rest, COALESCE(SUM(paid), 0) AS paid, COALESCE(SUM(canceled), 0) AS canceled, COALESCE(SUM(refunded), 0) AS refunded FROM Product AS p LEFT JOIN Invoice AS i ON i.product_id = p.product_id GROUP BY p.product_id ORDER BY p.name ================================================ FILE: Project Employees I/q.sql ================================================ SELECT project_id, ROUND(SUM(e.experience_years)/COUNT(p.employee_id), 2) AS average_years FROM Project AS p INNER JOIN Employee AS e ON p.employee_id = e.employee_id GROUP BY project_id; ================================================ FILE: Queries Quality and Percentage/q.sql ================================================ SELECT query_name, ROUND(SUM(rating / position) / COUNT(*), 2) AS quality, ROUND( ( SUM(CASE WHEN rating < 3 THEN 1 ELSE 0 END) / COUNT(*) ) * 100, 2 ) AS poor_query_percentage FROM Queries GROUP BY query_name ================================================ FILE: Queries on Number of Points Inside a Circle/kata.java ================================================ class Solution { public int[] countPoints(int[][] points, int[][] queries) { var res = new int[queries.length]; var i = 0; for (var query : queries) { for (var point : points) { // d= √(xA − xB)2 + (yA − yB)2 var distance = Math.sqrt(Math.pow(query[0]-point[0],2) + Math.pow(query[1]-point[1],2)); if (distance <= (double) query[2]) { res[i]++; } } i++; } return res; } } ================================================ FILE: Queries on a Permutation With Key/kata.go ================================================ package kata import "container/list" func processQueries(queries []int, m int) []int { l := list.New() for i := 1; i < m+1; i++ { l.PushBack(i) } idx := make([]int, len(queries)) j := 0 for _, q := range queries { var i int for e := l.Front(); e != nil; e = e.Next() { if e.Value.(int) == q { l.MoveToFront(e) idx[j] = i j++ break } i++ } } return idx } ================================================ FILE: README.md ================================================ # leetcode.com Leetcode solutions A collection of 500+ LeetCode problems that I've solved primarily in Go, SQL, and Java some of them definitely would deserve a refactoring. Each directory includes a solution to the problem and the directory name is the challenge name. ================================================ FILE: Random Pick Index/kata.go ================================================ package kata import ( "math/rand" "time" ) type Solution struct { seededRand *rand.Rand nums []int } func Constructor(nums []int) Solution { var seededRand *rand.Rand = rand.New( rand.NewSource(time.Now().UnixNano())) return Solution{ seededRand: seededRand, nums: nums, } } func (this *Solution) Pick(target int) int { idx := make(map[int][]int) for i, _ := range this.nums { if target == this.nums[i] { v, ok := idx[target] if !ok { v = make([]int, 0) v = append(v, i) idx[target] = v continue } v = append(v, i) idx[target] = v } } i := this.seededRand.Intn(len(idx[target])) return idx[target][i] } ================================================ FILE: Range Sum Query - Immutable/kata.go ================================================ package kata type NumArray struct { nums []int } func Constructor(nums []int) NumArray { return NumArray{nums: nums} } func (this *NumArray) SumRange(i int, j int) int { if j+1 > len(this.nums) || i > len(this.nums) || i < 0 || j < 0 || i > j { return 0 } var sum int for _, n := range this.nums[i : j+1] { sum += n } return sum } /** * Your NumArray object will be instantiated and called as such: * obj := Constructor(nums); * param_1 := obj.SumRange(i,j); */ ================================================ FILE: Range Sum Query - Mutable/kata.go ================================================ package kata type NumArray struct { nums []int } func Constructor(nums []int) NumArray { return NumArray{ nums: nums, } } func (this *NumArray) Update(i int, val int) { if i > len(this.nums) { return } this.nums[i] = val } func (this *NumArray) SumRange(i int, j int) int { var sum int for _, n := range this.nums[i : j+1] { sum += n } return sum } /** * Your NumArray object will be instantiated and called as such: * obj := Constructor(nums); * obj.Update(i,val); * param_2 := obj.SumRange(i,j); */ ================================================ FILE: Range Sum Query 2D - Immutable/kata.go ================================================ package kata type NumMatrix struct { values [][]int } func Constructor(matrix [][]int) NumMatrix { return NumMatrix{ values: matrix, } } func (this *NumMatrix) SumRegion(row1 int, col1 int, row2 int, col2 int) int { var sum int for i := row1; i <= row2; i++ { for j := col1; j <= col2; j++ { sum += this.values[i][j] } } return sum } /** * Your NumMatrix object will be instantiated and called as such: * obj := Constructor(matrix); * param_1 := obj.SumRegion(row1,col1,row2,col2); */ ================================================ FILE: Range Sum of BST/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func rangeSumBST(root *TreeNode, L int, R int) int { return f(root, L, R, 0) } func f(node *TreeNode, L int, R int, sum int) int { if node.Val >= L && node.Val <= R { sum = sum + node.Val } if node.Left != nil && L < node.Val { sum = f(node.Left, L, R, sum) } if node.Right != nil && node.Val < R { sum = f(node.Right, L, R, sum) } return sum } ================================================ FILE: Rank Scores/kata.sql ================================================ package kata select Score, dense_rank() over(order by Score desc) "Rank" from Scores; ================================================ FILE: Rank Transform of an Array/kata.go ================================================ package kata import "sort" func arrayRankTransform(arr []int) []int { if len(arr) == 0 { return arr } if len(arr) == 1 { return []int{1} } tmp := make([]int, len(arr)) copy(tmp, arr) set := make(map[int]int) sort.Ints(tmp) r := 1 for _, elm := range tmp { _, ok := set[elm] if !ok { set[elm] = r r++ } } for i := range arr { arr[i] = set[arr[i]] } return arr } ================================================ FILE: Ransom Note/kata.go ================================================ package kata func canConstruct(ransomNote string, magazine string) bool { if len(ransomNote) > len(magazine) { return false } set := make(map[byte]int) var i int for i = 0; i < len(magazine); i++ { set[magazine[i]]++ } var c int var ok bool for i = 0; i < len(ransomNote); i++ { c, ok = set[ransomNote[i]] if !ok || c <= 0 { return false } set[ransomNote[i]]-- } return true } ================================================ FILE: Rearrange Array Elements by Sign/kata.go ================================================ package kata import "container/list" func rearrangeArray(nums []int) []int { negative := list.New() positive := list.New() for _, n := range nums { if n < 0 { negative.PushBack(n) } else { positive.PushBack(n) } } nums[0] = positive.Front().Value.(int) positive.Remove(positive.Front()) for i := 1; i < len(nums); i++ { if i%2 == 1 { nums[i] = negative.Front().Value.(int) negative.Remove(negative.Front()) } else { nums[i] = positive.Front().Value.(int) positive.Remove(positive.Front()) } } return nums } ================================================ FILE: Rearrange Characters to Make Target String/kata.go ================================================ package kata func rearrangeCharacters(s string, target string) int { targetCharStats := [26]int{} for i := range target { targetCharStats[normalise(int(target[i]))]++ } sCharStats := [26]int{} for i := range s { sCharStats[normalise(int(s[i]))]++ } targetCount := -1 for i := 0; i < 26; i++ { if (sCharStats[i] == 0 && targetCharStats[i] == 0) || (sCharStats[i] > 0 && targetCharStats[i] == 0) { continue } if targetCharStats[i] > 0 && sCharStats[i] == 0 { return 0 } if sCharStats[i] >= targetCharStats[i] { possibleTargetCount := float64(sCharStats[i]) / float64(targetCharStats[i]) if targetCount == -1 || int(possibleTargetCount) < targetCount { targetCount = int(possibleTargetCount) } } else { return 0 } } return targetCount } func normalise(a int) int { return a - 97 } ================================================ FILE: Rearrange Products Table/q.sql ================================================ SELECT product_id, "store1" AS store, store1 AS price FROM Products WHERE store1 IS NOT NULL UNION ALL SELECT product_id, "store2" AS store, store2 AS price FROM Products WHERE store2 IS NOT NULL UNION ALL SELECT product_id, "store3" AS store, store3 AS price FROM Products WHERE store3 IS NOT NULL ================================================ FILE: Rearrange Spaces Between Words/kata.go ================================================ package kata func reorderSpaces(text string) string { var words [][]byte var spaceCount int var word []byte for i := 0; i < len(text); i++ { if text[i] == 32 || len(text)-1 == i { if len(text)-1 == i && text[i] != 32 { word = append(word, text[i]) } else { spaceCount++ } if len(word) != 0 { words = append(words, word) word = []byte{} } } else { word = append(word, text[i]) } } if len(words) == 1 && spaceCount == 0 { return text } var inbetweenCount int if len(words) == 1 { inbetweenCount = 1 } else { inbetweenCount = (len(words) - 1) } mod := spaceCount % inbetweenCount spaceCount = spaceCount / inbetweenCount var space string for i := 0; i < spaceCount; i++ { space += " " } var restSpace string for i := 0; i < mod; i++ { restSpace += " " } if len(words) == 1 { return string(words[0]) + space } text = "" for i, word := range words { if len(words)-1 == i { text += string(word) + restSpace } else { text += string(word) + space } } return text } ================================================ FILE: Rearrange Words in a Sentence/kata.go ================================================ package kata import "sort" func arrangeWords(text string) string { if len(text) == 0 { return text } type Word struct { value []byte idx int } word := make([]byte, 0) wordEmpty := make([]byte, 0) wordList := make([]Word, 0) var wordCounter int for i := 0; i < len(text); i++ { if text[i] != ' ' { word = append(word, text[i]) } if text[i] == ' ' || len(text)-1 == i { wordList = append(wordList, Word{value: word, idx: wordCounter}) word = wordEmpty wordCounter++ } } sort.Slice(wordList, func(i, j int) bool { if len(wordList[i].value) == len(wordList[j].value) && wordList[i].idx < wordList[j].idx { return true } else if len(wordList[i].value) < len(wordList[j].value) { return true } return false }) if len(wordList) == 0 { return text } if wordList[0].value[0] >= 97 && wordList[0].value[0] <= 122 { wordList[0].value[0] = wordList[0].value[0] - 32 } text = "" text += string(wordList[0].value) + " " for _, word := range wordList[1:] { if word.value[0] >= 65 && word.value[0] <= 90 { word.value[0] = word.value[0] + 32 } text += string(word.value) + " " } return text[:len(text)-1] } ================================================ FILE: Recyclable and Low Fat Products/q.sql ================================================ SELECT product_id FROM Products WHERE low_fats = "Y" AND recyclable = "Y"; ================================================ FILE: Redistribute Characters to Make All Strings Equal/kata.go ================================================ package kata func makeEqual(words []string) bool { charStats := [26]int{} countOfchars := 0 for _, word := range words { for _, codepoint := range word { var normalisedCodepoint = codepoint - 97 charStats[normalisedCodepoint]++ countOfchars++ } } if countOfchars%len(words) == 1 { return false } for _, oneCharStat := range charStats { if oneCharStat > 0 && oneCharStat%len(words) != 0 { return false } } return true } ================================================ FILE: Reduce Array Size to The Half/kata.go ================================================ package kata import "sort" func minSetSize(arr []int) int { if len(arr) < 2 { return -1 } if len(arr) == 2 { return 1 } counter := make(map[int]int) for i := range arr { counter[arr[i]]++ } if len(counter) == 1 { return 1 } countes := make([]int, len(counter)) var i int for _, c := range counter { countes[i] = c i++ } sort.Slice(countes, func(i, j int) bool { return countes[i] > countes[j] }) half := len(arr) / 2 var sum int var many int for _, c := range countes { sum += c many++ if sum >= half { break } } return many } ================================================ FILE: Reformat Department Table/q.sql ================================================ WITH cte AS (SELECT id, case when month = "Jan" then revenue end as Jan_Revenue, case when month = "Feb" then revenue end as Feb_Revenue, case when month = "Mar" then revenue end as Mar_Revenue, case when month = "Apr" then revenue end as Apr_Revenue, case when month = "May" then revenue end as May_Revenue, case when month = "Jun" then revenue end as Jun_Revenue, case when month = "Jul" then revenue end as Jul_Revenue, case when month = "Aug" then revenue end as Aug_Revenue, case when month = "Sep" then revenue end as Sep_Revenue, case when month = "Oct" then revenue end as Oct_Revenue, case when month = "Nov" then revenue end as Nov_Revenue, case when month = "Dec" then revenue end as Dec_Revenue FROM Department) SELECT id, MAX(Jan_Revenue) AS Jan_Revenue, MAX(Feb_Revenue) AS Feb_Revenue, MAX(Mar_Revenue) AS Mar_Revenue, MAX(Apr_Revenue) AS Apr_Revenue, MAX(May_Revenue) AS May_Revenue, MAX(Jun_Revenue) AS Jun_Revenue, MAX(Jul_Revenue) AS Jul_Revenue, MAX(Aug_Revenue) AS Aug_Revenue, MAX(Sep_Revenue) AS Sep_Revenue, MAX(Oct_Revenue) AS Oct_Revenue, MAX(Nov_Revenue) AS Nov_Revenue, MAX(Dec_Revenue) AS Dec_Revenue FROM cte GROUP BY id; ================================================ FILE: Relative Ranks/kata.go ================================================ package kata import ( "sort" "strconv" ) func findRelativeRanks(nums []int) []string { tmp := make([]int, len(nums)) copy(tmp, nums) scores := []string{"Gold Medal", "Silver Medal", "Bronze Medal"} sort.Slice(tmp, func(i, j int) bool { return tmp[i] > tmp[j] }) res := make([]string, len(nums)) set := make(map[int]string, len(nums)) for i, n := range tmp { if len(scores) > 0 { set[n] = scores[0] scores = scores[1:] continue } set[n] = strconv.Itoa(i + 1) } for i, n := range nums { res[i] = set[n] } return res } ================================================ FILE: Remove All Adjacent Duplicates In String/kata.java ================================================ class Solution { public String removeDuplicates(String s) { var sb = new StringBuilder(s); for (var i = 1; i < sb.length(); i++) { if (sb.charAt(i) == sb.charAt(i-1)) { sb.deleteCharAt(i); sb.deleteCharAt(i-1); if (i - 2 >= 0) i = i - 2; else i = 0; } } return sb.toString(); } } ================================================ FILE: Remove Colored Pieces if Both Neighbors are the Same Color/kata.go ================================================ package Remove_Colored_Pieces_if_Both_Neighbors_are_the_Same_Color func winnerOfGame(colors string) bool { if len(colors) < 3 { return false } cb := []byte(colors) a := 0 b := 0 for i := 2; i < len(cb); i++ { if cb[i-2] == 'A' && cb[i-1] == 'A' && cb[i] == 'A' { a++ cb[i-2] = 'N' } else if cb[i-2] == 'B' && cb[i-1] == 'B' && cb[i] == 'B' { b++ cb[i-2] = 'N' } } if a == b { return false } return a > b } ================================================ FILE: Remove Duplicates from Sorted List/kata.go ================================================ package kata /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func deleteDuplicates(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } current := head.Next n := head for current != nil { if current.Val == n.Val { if current.Next != nil { n.Next = current.Next current = current.Next } else { n.Next = nil current = nil } continue } n = current current = current.Next } return head } ================================================ FILE: Remove Duplicates from Sorted List II/kata.go ================================================ package kata /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func deleteDuplicates(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } count := make(map[int]int) current := head for current != nil { count[current.Val] = count[current.Val] + 1 current = current.Next } tmp := new(ListNode) current = head pre := tmp pre.Next = head for current != nil { v := count[current.Val] if v > 1 { pre.Next = current.Next current = current.Next continue } pre = current current = current.Next } return tmp.Next } ================================================ FILE: Remove Element/kata.go ================================================ package kata import ( "math" "sort" ) func removeElement(nums []int, val int) int { var counter int for i := 0; i < len(nums); i++ { if nums[i] == val { nums[i] = int(math.Inf(1)) counter++ } } sort.Slice(nums, func(i, j int) bool { return nums[i] > nums[j] }) nums = nums[counter:] return len(nums) } ================================================ FILE: Remove Linked List Elements/kata.go ================================================ package kata /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func removeElements(head *ListNode, val int) *ListNode { if head == nil { return nil } if head.Next == nil && head.Val == val { return nil } current := head.Next pre := head for current != nil { if current.Val == val { pre.Next = current.Next current = current.Next } else { pre = current current = current.Next } } if head != nil && head.Val == val { return head.Next } return head } ================================================ FILE: Remove Nth Node From End of List/kata.go ================================================ package kata /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func removeNthFromEnd(head *ListNode, n int) *ListNode { if head == nil { return head } current := head var max int for current != nil { max = max + 1 current = current.Next } nth := max - n if nth == 0 { return head.Next } current = head.Next pre := head counter := 1 for current != nil { if counter == nth { pre.Next = current.Next break } pre = current current = current.Next counter = counter + 1 } return head } ================================================ FILE: Remove Stones to Minimize the Total/kata.go ================================================ package Remove_Stones_to_Minimize_the_Total import ( "container/heap" "math" "sort" ) func minStoneSum(piles []int, k int) int { h := IntHeap(piles) sort.Sort(h) for i := 0; i < k; i++ { n := heap.Pop(&h).(int) n = n - int(math.Floor(float64(n)/2)) heap.Push(&h, n) } var sum int for i := 0; i < h.Len(); i++ { sum += h[i] } return sum } type IntHeap []int func (h IntHeap) Len() int { return len(h) } func (h IntHeap) Less(i, j int) bool { return h[i] > h[j] } func (h IntHeap) Swap(i, j int) { h[j], h[i] = h[i], h[j] } func (h *IntHeap) Push(x interface{}) { *h = append(*h, x.(int)) } func (h *IntHeap) Pop() interface{} { old := *h n := len(old) if n == 0 { return -1 } x := old[n-1] *h = old[0 : n-1] return x } ================================================ FILE: Remove Trailing Zeros From a String/kata.go ================================================ package kata func removeTrailingZeros(num string) string { i := len(num)-1 for ; i >= 0; i-- { if num[i] != '0' { break } } return num[:i+1] } ================================================ FILE: Remove Vowels from a String/kata.go ================================================ package Remove_Vowels_from_a_String func removeVowels(s string) string { b := make([]rune, 0, len(s)/3) for _, char := range s { if char == 'a' || char == 'e' || char == 'i' || char == 'o' || char == 'u' { continue } b = append(b, char) } return string(b) } ================================================ FILE: Removing Minimum and Maximum From Array/kata.java ================================================ class Solution { public int minimumDeletions(int[] nums) { if (nums.length == 2) { return 2; } if (nums.length == 1) { return 1; } Integer min = null; var indexMax = 0; Integer max = null; var indexMin = 0; for (var i = 0; i < nums.length; i++) { if (max == null || max < nums[i]) { max = nums[i]; indexMax = i; } if (min == null || min > nums[i]) { min = nums[i]; indexMin = i; } } var a = Math.abs(0-(indexMax+1)); var b = Math.abs(nums.length-indexMin); var c = Math.abs(0-(indexMin+1)); var d = Math.abs(nums.length-indexMax); var p = 0; if (a == c ) { p = a; } else if (c > a) { p = c; } else { p = a; } var k = 0; if (b == d ) { k = d; } else if (b > d) { k = b; } else { k = d; } if (k <= p && k <= a+b && k <= c+d) { return k; } if (p <= k && p <= a+b && p <= c+d) { return p; } if (c+d <= k && c+d <= a+b && c+d <= p) { return c+d; } if (a+b <= k && a+b <= c+d && a+b <= p) { return a+b; } return a+b; } } ================================================ FILE: Removing Stars From a String/kata.java ================================================ class Solution { public String removeStars(String s) { StringBuilder sb = new StringBuilder(s); for (int i = 0; i < sb.length(); i++) { if (sb.charAt(i) == '*') { sb.deleteCharAt(i); sb.deleteCharAt(i-1); i = i - 2; } } return sb.toString(); } } ================================================ FILE: Rename Columns/kata.py ================================================ import pandas as pd def renameColumns(students: pd.DataFrame) -> pd.DataFrame: students = students.rename(columns={ 'id': 'student_id', 'first': 'first_name', 'last': 'last_name', 'age': 'age_in_years' }) return students ================================================ FILE: Replace All 's to Avoid Consecutive Repeating Characters/kata.go ================================================ package kata import ( "math/rand" "time" ) func modifyString(s string) string { b := []byte(s) for i := 0; i < len(b); i++ { if b[i] == '?' { if i-1 >= 0 { b[i] = pickChar(b[i-1]) if i+1 < len(b) && b[i+1] != '?' && b[i] == b[i+1] { for { rand.Seed(time.Now().UnixNano()) n := rand.Intn(26) if n == 0 { n++ } b[i] = byte(n + 96) if b[i] != b[i-1] && b[i+1] != b[i] { break } } } } else if i+1 < len(b) { if b[i] == '?' { char := b[i+1] if b[i+1] == '?' { char = 97 } b[i] = pickChar(char) } } else { b[i] = 97 } } } return string(b) } func pickChar(char byte) byte { if char == 122 { return char - 1 } if char == 97 { return char + 1 } return char - 1 } ================================================ FILE: Replace All Digits with Characters/kata.go ================================================ package kata func replaceDigits(s string) string { b := []byte(s) for i := 0; i < len(b); i = i + 2 { if i+1 == len(b) { break } b[i+1] = shift(b[i], b[i+1]) } return string(b) } func shift(c byte, by byte) byte { return c + by - 48 } ================================================ FILE: Replace Employee ID With The Unique Identifier/query.sql ================================================ SELECT eu.unique_id, e.name FROM Employees AS e LEFT JOIN EmployeeUNI AS eu ON eu.id = e.id; ================================================ FILE: Reshape Data: Concatenate/kata.py ================================================ import pandas as pd def concatenateTables(df1: pd.DataFrame, df2: pd.DataFrame) -> pd.DataFrame: frames = [df1, df2] return pd.concat(frames) ================================================ FILE: Reshape Data: Melt/kata.py ================================================ import pandas as pd def meltTable(report: pd.DataFrame) -> pd.DataFrame: report = pd.melt(report, id_vars=['product'], value_vars=['quarter_1', 'quarter_2', 'quarter_3', 'quarter_4'], var_name='quarter', value_name='sales') return report ================================================ FILE: Reshape Data: Pivot/kata.py ================================================ import pandas as pd def pivotTable(weather: pd.DataFrame) -> pd.DataFrame: weather = weather.pivot_table(index='month', columns='city', values='temperature', aggfunc='max') return weather ================================================ FILE: Reshape the Matrix/kata.go ================================================ package kata func matrixReshape(nums [][]int, r int, c int) [][]int { if nums == nil { return nums } if len(nums[0])*len(nums) != r*c { return nums } res := make([][]int, 0) n := c i := 0 res = append(res, make([]int, 0)) for _, row := range nums { for _, col := range row { if n == 0 { n = c i = i + 1 res = append(res, make([]int, 0)) } n = n - 1 res[i] = append(res[i], col) } } return res } ================================================ FILE: Return Length of Arguments Passed/kata.js ================================================ /** * @param {...(null|boolean|number|string|Array|Object)} args * @return {number} */ var argumentsLength = function(...args) { return args.length }; ================================================ FILE: Reverse Integer/kata.go ================================================ package kata import "math" const ( Negative int = -1 Positive int = 1 ) func reverse(x int) (sum int) { var sign int if x < 0 { sign = Negative x = x * Negative } else if x > 0 { sign = Positive } step := 1 for i := int(math.Log10(float64(x)+1)) - 1; i >= 0; i-- { step = step * 10 } for x != 0 { n := x % 10 x = x / 10 sum += n * step step = step / 10 } if sum > math.MaxInt32 { return 0 } if sign == Negative { sum = sum * sign } return sum } ================================================ FILE: Reverse Linked List/kata.go ================================================ package kata /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func reverseList(head *ListNode) *ListNode { if head == nil { return nil } current := head.Next next := &ListNode{Val: head.Val} for current != nil { head = &ListNode{Val: current.Val, Next: next} next = head current = current.Next } return head } ================================================ FILE: Reverse Prefix of Word/kata.go ================================================ package kata func reversePrefix(word string, ch byte) string { j := -1 for i := 0; i < len(word); i++ { if word[i] == ch { j = i break } } if j == -1 { return word } b := []byte(word) k := 0 for i := j; i > (j / 2); i-- { b[i], b[k] = b[k], b[i] k++ } return string(b) } ================================================ FILE: Reverse String/kata.go ================================================ package kata func reverseString(s []byte) { if len(s) == 0 { return } j := len(s) - 1 for i := 0; i < len(s)/2; i++ { s[i], s[j] = s[j], s[i] j-- } } ================================================ FILE: Reverse Vowels of a String/kata.go ================================================ package kata func reverseVowels(s string) string { b := []byte(s) j := len(b) - 1 i := 0 for j > i { if isVowel(b[i]) { if isVowel(b[j]) { b[i], b[j] = b[j], b[i] i++ } j-- continue } i++ } return string(b) } func isVowel(char byte) bool { switch char { case 'a', 'i', 'e', 'o', 'u', 'A', 'I', 'E', 'O', 'U': return true } return false } ================================================ FILE: Reverse Words in a String/kata.go ================================================ package kata func reverseWords(s string) string { var word string var ss string for i := len(s) - 1; i >= 0; i-- { if s[i] == ' ' && word == "" { continue } else if s[i] == ' ' { ss = ss + " " + word if (i-1) > 0 && s[i-1] != ' ' { word = string(s[i-1]) i-- } else { word = "" } continue } word = string(s[i]) + word } if word != "" { ss = ss + " " + word } if ss == "" { return ss } return ss[1:] } ================================================ FILE: Reverse Words in a String III/kata.go ================================================ package kata func reverseWords(s string) string { b := []byte(s) var k int for i := 0; i < len(b); i++ { if b[i] == 32 || len(b) == (i+1) { if len(b) == (i + 1) { i = i + 1 } j := i - 1 n := (i - k) % 2 var m int if n == 0 { m = (i - 1 - k) / 2 } else { m = (i - 0 - k) / 2 } for l := 0; l <= m; l++ { b[k], b[j] = b[j], b[k] j-- k++ } k = i + 1 } } return string(b) } ================================================ FILE: Richest Customer Wealth/kata.go ================================================ package kata func maximumWealth(accounts [][]int) int { var max int for _, account := range accounts { n := sum(account) if max < n { max = n } } return max } func sum(values []int) int { var sum int for i := 0; i < len(values)/2; i++ { sum += values[i] + values[len(values)-i-1] } if len(values)%2 == 1 { sum += values[len(values)/2] } return sum } ================================================ FILE: Rings and Rods/kata.go ================================================ package Rings_and_Rods import "sort" func countPoints(rings string) int { pairs := make([]Pair, len(rings)/2) var j int for i := 0; i < len(rings); i = i + 2 { pairs[j] = Pair{ Key: rings[i+1], Value: rings[i], } j++ } sort.Slice(pairs, func(i, j int) bool { if pairs[i].Key == pairs[j].Key { return pairs[i].Value < pairs[j].Value } return pairs[i].Key < pairs[j].Key }) currentRode := pairs[0].Key currentColor := pairs[0].Value counter := 1 all := 0 for i := 1; i < len(pairs); i++ { if currentRode != pairs[i].Key || (len(pairs)-1 == i) { if len(pairs)-1 == i && currentColor != pairs[i].Value && pairs[i].Key == currentRode { counter++ } if counter == 3 { all++ } currentRode = pairs[i].Key currentColor = pairs[i].Value counter = 1 continue } if currentColor != pairs[i].Value { counter++ currentColor = pairs[i].Value } } return all } type Pair struct { Key byte Value byte } ================================================ FILE: Roman to Integer/kata.go ================================================ package kata var mapping = map[string]int{"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000, "IV": 4, "IX": 9, "XL": 40, "XC": 90, "CD": 400, "CM": 900} func romanToInt(s string) int { var sum int for i := 0; i < len(s); { if i+2 <= len(s) { v, ok := mapping[string(s[i:i+2])] if ok { sum += v i = i + 2 continue } } sum += mapping[string(s[i])] i++ } return sum } ================================================ FILE: Root Equals Sum of Children/kata.go ================================================ package Root_Equals_Sum_of_Children type TreeNode struct { Val int Left *TreeNode Right *TreeNode } func checkTree(root *TreeNode) bool { return root.Val == (root.Left.Val + root.Right.Val) } ================================================ FILE: Rotate Array/kata.go ================================================ package kata func rotate(nums []int, k int) { for ; k > 0; k-- { tmp := nums[len(nums)-1] for j := len(nums) - 2; j >= 0; j-- { nums[j+1] = nums[j] } nums[0] = tmp } } ================================================ FILE: Rotate String/kata.go ================================================ package kata func rotateString(A string, B string) bool { if A == "" && B == "" { return true } if A == "" { return false } oldA := A first := true for { if first != true && oldA == A { return false } first = false a := A[0] A = A[1:len(A)] + string(a) if A == B { return true } } return false } ================================================ FILE: Row With Maximum Ones/kata.go ================================================ package kata func rowAndMaximumOnes(mat [][]int) []int { var globalMaxOnesPerRow int var rowIndex = 0 for i, row := range mat { var localCountOnesPerRow int for _, col := range row { if col == 1 { localCountOnesPerRow++ } } if localCountOnesPerRow > globalMaxOnesPerRow { globalMaxOnesPerRow = localCountOnesPerRow rowIndex = i } } return []int{rowIndex, globalMaxOnesPerRow} } ================================================ FILE: Running Sum of 1d Array/kata.go ================================================ package kata func runningSum(nums []int) []int { sumNums := make([]int, len(nums)) subTotal := 0 for i := 0; i < len(nums); i++ { subTotal += nums[i] sumNums[i] = subTotal } return sumNums } ================================================ FILE: Running Total for Different Genders/q.sql ================================================ SELECT gender, DAY, SUM(score_points) OVER (PARTITION BY gender ORDER BY gender, DAY) AS total FROM Scores GROUP BY gender, DAY ORDER BY gender ASC, DAY ASC ================================================ FILE: Sales Analysis I/q.sql ================================================ SELECT s1.seller_id FROM Sales AS s1 GROUP BY s1.seller_id HAVING SUM(price) = (SELECT SUM(price) AS total FROM Sales AS s GROUP BY s.seller_id ORDER BY total DESC LIMIT 1); ================================================ FILE: Sales Person/q.sql ================================================ SELECT name FROM SalesPerson WHERE name NOT IN ( SELECT sp.name FROM SalesPerson AS sp INNER JOIN Orders AS o ON o.sales_id = sp.sales_id INNER JOIN Company AS c ON c.com_id = o.com_id WHERE c.name = "RED" ); ================================================ FILE: Sales by Day of the Week/q.sql ================================================ WITH sales_matrix AS (SELECT item_category AS CATEGORY, SUM(quantity) AS MONDAY, 0 AS TUESDAY, 0 AS WEDNESDAY, 0 AS THURSDAY, 0 AS FRIDAY, 0 AS SATURDAY, 0 AS SUNDAY FROM Items JOIN Orders USING (item_id) WHERE WEEKDAY(order_date) = 0 GROUP BY item_category UNION SELECT item_category AS CATEGORY, 0 AS MONDAY, SUM(quantity) AS TUESDAY, 0 AS WEDNESDAY, 0 AS THURSDAY, 0 AS FRIDAY, 0 AS SATURDAY, 0 AS SUNDAY FROM Items JOIN Orders USING (item_id) WHERE WEEKDAY(order_date) = 1 GROUP BY item_category UNION ALL SELECT item_category AS CATEGORY, 0 AS MONDAY, 0 AS TUESDAY, SUM(quantity) AS WEDNESDAY, 0 AS THURSDAY, 0 AS FRIDAY, 0 AS SATURDAY, 0 AS SUNDAY FROM Items JOIN Orders USING (item_id) WHERE WEEKDAY(order_date) = 2 GROUP BY item_category UNION ALL SELECT item_category AS CATEGORY, 0 AS MONDAY, 0 AS TUESDAY, 0 AS WEDNESDAY, SUM(quantity) AS THURSDAY, 0 AS FRIDAY, 0 AS SATURDAY, 0 AS SUNDAY FROM Items JOIN Orders USING (item_id) WHERE WEEKDAY(order_date) = 3 GROUP BY item_category UNION ALL SELECT item_category AS CATEGORY, 0 AS MONDAY, 0 AS TUESDAY, 0 AS WEDNESDAY, 0 AS THURSDAY, SUM(quantity) AS FRIDAY, 0 AS SATURDAY, 0 AS SUNDAY FROM Items JOIN Orders USING (item_id) WHERE WEEKDAY(order_date) = 4 GROUP BY item_category UNION ALL SELECT item_category AS CATEGORY, 0 AS MONDAY, 0 AS TUESDAY, 0 AS WEDNESDAY, 0 AS THURSDAY, 0 AS FRIDAY, SUM(quantity) AS SATURDAY, 0 AS SUNDAY FROM Items JOIN Orders USING (item_id) WHERE WEEKDAY(order_date) = 5 GROUP BY item_category UNION ALL SELECT item_category AS CATEGORY, 0 AS MONDAY, 0 AS TUESDAY, 0 AS WEDNESDAY, 0 AS THURSDAY, 0 AS FRIDAY, 0 AS SATURDAY, SUM(quantity) AS SUNDAY FROM Items JOIN Orders USING (item_id) WHERE WEEKDAY(order_date) = 6 GROUP BY item_category UNION ALL SELECT item_category AS CATEGORY, 0 AS MONDAY, 0 AS TUESDAY, 0 AS WEDNESDAY, 0 AS THURSDAY, 0 AS FRIDAY, 0 AS SATURDAY, 0 AS SUNDAY FROM Items AS i LEFT JOIN Orders AS o ON i.item_id = o.item_id WHERE o.item_id IS NULL GROUP BY item_category) SELECT CATEGORY, SUM(MONDAY) AS MONDAY, SUM(TUESDAY) AS TUESDAY, SUM(WEDNESDAY) AS WEDNESDAY, SUM(THURSDAY) AS THURSDAY, SUM(FRIDAY) AS FRIDAY, SUM(SATURDAY) AS SATURDAY, SUM(SUNDAY) AS SUNDAY FROM sales_matrix GROUP BY CATEGORY ORDER BY CATEGORY; ================================================ FILE: Same Tree/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func isSameTree(p *TreeNode, q *TreeNode) bool { if p == nil && q == nil { return true } if p != nil || q != nil { if (p == nil && q != nil) || (p != nil && q == nil) { return false } if p.Val != q.Val { return false } } var leftValid bool if p.Left != nil || q.Left != nil { if (p.Left == nil && q.Left != nil) || (p.Left != nil && q.Left == nil) { return false } leftValid = isSameTree(p.Left, q.Left) if !leftValid { return false } } var rightValid bool if p.Right != nil || q.Right != nil { if (p.Right == nil && q.Right != nil) || (p.Right != nil && q.Right == nil) { return false } rightValid = isSameTree(p.Right, q.Right) if !rightValid { return false } } return true } ================================================ FILE: Score of a String/kata.go ================================================ package kata func scoreOfString(s string) int { var sum int for i := 1; i < len(s); i++ { sum += abs(int(s[i]) - int(s[i-1])) } return sum } func abs(a int) int { if a < 0 { return -a } return a } ================================================ FILE: Search Insert Position/kata.go ================================================ package kata func searchInsert(nums []int, target int) int { if target > nums[len(nums)-1] { return len(nums) } if target < nums[0] { return 0 } for i := 0; i < len(nums); i++ { if target < nums[i] { return i } if nums[i] == target { return i } } return -1 } ================================================ FILE: Search a 2D Matrix/kata.go ================================================ package kata func searchMatrix(matrix [][]int, target int) bool { if len(matrix) == 1 { return searchVector(matrix[0], target) } for i := 0; i < len(matrix); i++ { if len(matrix[i]) == 0 { continue } if target == matrix[i][0] { return true } if matrix[i][0] < target && len(matrix)-1 != i { continue } row := i if matrix[i][0] > target && i != 0 { row = i - 1 } return searchVector(matrix[row], target) } return false } func searchVector(v []int, target int) bool { if len(v) == 0 { return false } if len(v) == 1 { return v[0] == target } mid := len(v) / 2 if v[mid] == target { return true } if v[mid] > target { return searchVector(v[:mid], target) } if v[mid] < target { return searchVector(v[mid:], target) } return false } ================================================ FILE: Search a 2D Matrix II/kata.go ================================================ package kata func searchMatrix(matrix [][]int, target int) bool { outerLoop: for _, vector := range matrix { if len(vector) == 0 { continue } if vector[len(vector)/2] == target { return true } if vector[len(vector)/2] > target { for i := 0; i < len(vector)/2; i++ { if vector[i] > target { continue outerLoop } if vector[i] == target { return true } } } else if vector[len(vector)/2] < target { for i := len(vector) - 1; i > len(vector)/2; i-- { if vector[i] < target { continue outerLoop } if vector[i] == target { return true } } } } return false } ================================================ FILE: Search in Rotated Sorted Array II/kata.go ================================================ package kata func search(nums []int, target int) bool { if len(nums) == 1 && nums[0] == target { return true } else if len(nums) == 1 && nums[0] != target { return false } if len(nums) == 0 { return false } mid := len(nums) / 2 if nums[mid] == target { return true } ok := search(nums[:mid], target) if ok { return true } ok = search(nums[mid:], target) if ok { return true } return false } ================================================ FILE: Search in a Binary Search Tree/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func searchBST(root *TreeNode, val int) *TreeNode { if root == nil { return nil } if root.Val == val { return root } if root.Left != nil { node := searchBST(root.Left, val) if node != nil { return node } } if root.Right != nil { node := searchBST(root.Right, val) if node != nil { return node } } return nil } ================================================ FILE: Seat Reservation Manager/kata.go ================================================ package Seat_Reservation_Manager type SeatManager struct { seats []int current int } func Constructor(n int) SeatManager { return SeatManager{seats: make([]int, n)} } func (this *SeatManager) Reserve() int { if this.seats[this.current] == 1 { for this.seats[this.current] != 0 { this.current++ } } this.seats[this.current] = 1 seat := this.current + 1 this.current++ return seat } func (this *SeatManager) Unreserve(seatNumber int) { this.seats[seatNumber-1] = 0 if this.current > (seatNumber - 1) { this.current = seatNumber - 1 } } ================================================ FILE: Second Highest Salary/kata.sql ================================================ package kata SELECT MAX(Salary) AS 'SecondHighestSalary' FROM Employee WHERE Salary < (SELECT MAX(Salary) FROM Employee) ================================================ FILE: Second Largest Digit in a String/kata.go ================================================ package kata import "sort" func secondHighest(s string) int { b := []byte(s) sort.Slice(b, func(i, j int) bool { bi := int(b[i]) bj := int(b[j]) if !(bi >= 48 && bi <= 57) { bi = -9999 } if !(bj >= 48 && bj <= 57) { bj = -9999 } return bi < bj }) max := b[len(b)-1] for i := len(b) - 2; i >= 0; i-- { if max != b[i] { if b[i] >= 48 && b[i] <= 57 { return int(b[i] - 48) } break } } return -1 } ================================================ FILE: Second Minimum Node In a Binary Tree/kata.go ================================================ package kata import "sort" /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func findSecondMinimumValue(root *TreeNode) int { if root == nil { return -1 } list := make(map[int]struct{}) inorder(root, list) if len(list) == 1 { return -1 } a := make([]int, 0) for n := range list { a = append(a, n) } sort.Slice(a, func(i, j int) bool { return a[i] < a[j] }) return a[1] } func inorder(node *TreeNode, list map[int]struct{}) { if node == nil { return } if node.Left != nil { inorder(node.Left, list) } list[node.Val] = struct{}{} if node.Right != nil { inorder(node.Right, list) } } ================================================ FILE: Select Data/kata.py ================================================ import pandas as pd def selectData(students: pd.DataFrame) -> pd.DataFrame: students = students.query("student_id == 101") return students[['name', 'age']] ================================================ FILE: Self Dividing Numbers/kata.go ================================================ package kata func selfDividingNumbers(left int, right int) []int { nums := make([]int, 0) outerLoop: for i := left; i <= right; i++ { if i < 10 { nums = append(nums, i) } else { num := i for num > 0 { k := num % 10 if k == 0 || i%k != 0 { continue outerLoop } num = num / 10 } nums = append(nums, i) } } return nums } ================================================ FILE: Sellers With No Sales/q.sql ================================================ SELECT seller_name FROM Seller AS s WHERE seller_id NOT IN (SELECT seller_id FROM Orders AS o WHERE YEAR(o.sale_date) = 2020) ORDER BY s.seller_name ================================================ FILE: Separate the Digits in an Array/kata.java ================================================ class Solution { public int[] separateDigits(int[] nums) { ArrayList newNums = new ArrayList(); for (var num : nums) { var digitCount = ((int) Math.log10((double) num)); for (; digitCount >= 0; digitCount--) { var digit = (num/(int) Math.pow(10, (double) digitCount)) % 10; newNums.add(digit); } } var res = new int[newNums.size()]; for (var i = 0; i < newNums.size(); i++) { res[i] = newNums.get(i); } return res; } } ================================================ FILE: Set Mismatch/kata.go ================================================ package kata func findErrorNums(nums []int) []int { counter := make([]int, len(nums)) for i := 0; i < len(nums); i++ { counter[nums[i]-1] = counter[nums[i]-1] + 1 } res := make([]int, 2) for i := 0; i < len(nums); i++ { if counter[i] == 0 { res[1] = i + 1 } else if counter[i] > 1 { res[0] = i + 1 } } return res } ================================================ FILE: Shift 2D Grid/kata.go ================================================ package Shift_2D_Grid func shiftGrid(grid [][]int, k int) [][]int { swap := -1001 for ; k >= 1; k-- { for i := 0; i < len(grid); i++ { for j := 0; j < len(grid[i]); j++ { c := swap if c != -1001 { if i == (len(grid)-1) && j == (len(grid[i])-1) { grid[0][0] = swap swap = -1001 } else if i+1 < len(grid) && j == (len(grid[i])-1) { oldSwap := swap swap = grid[i+1][0] grid[i+1][0] = oldSwap } else if j < len(grid[i]) { oldSwap := swap swap = grid[i][j+1] grid[i][j+1] = oldSwap } } else { if i == (len(grid)-1) && j == (len(grid[i])-1) { return grid } else if i+1 < len(grid) && j == (len(grid[i])-1) { swap = grid[i+1][0] grid[i+1][0] = grid[i][j] } else if j < len(grid[i]) { swap = grid[i][j+1] grid[i][j+1] = grid[i][j] } } } } } return grid } ================================================ FILE: Shortest Distance in a Line/q.sql ================================================ SELECT ABS(b.x-c.x) AS shortest FROM (SELECT a.x, ROW_NUMBER() OVER ( ORDER BY a.x ) AS 'row_number' FROM Point AS a ) AS b INNER JOIN ( SELECT a.x, ROW_NUMBER() OVER ( ORDER BY a.x ) AS 'row_number' FROM Point AS a ) AS c ON (c.row_number > b.row_number) ORDER BY ABS(b.x-c.x) LIMIT 1 ================================================ FILE: Shortest Distance to a Character/kata.go ================================================ package kata import "math" func shortestToChar(S string, C byte) []int { Cs := make([]int, 0) for i := 0; i < len(S); i++ { if S[i] == C { Cs = append(Cs, i) } } allDis := make([]int, 0) for i := 0; i < len(S); i++ { min := -1 for j := 0; j < len(Cs); j++ { dis := math.Abs(float64(i - Cs[j])) if min == -1 || int(dis) < min { min = int(dis) } if min == 0 { break } } allDis = append(allDis, min) } return allDis } ================================================ FILE: Shortest Word Distance/kata.go ================================================ package Shortest_Word_Distance import "math" func shortestDistance(wordsDict []string, word1 string, word2 string) int { k, j := -1, -1 globalDiff := -1 for i, word := range wordsDict { if word == word1 { k = i if k > -1 && j > -1 { localDiff := int(math.Abs(float64(k) - float64(j))) if globalDiff == -1 || localDiff < globalDiff { globalDiff = localDiff } } } else if word == word2 { j = i if k > -1 && j > -1 { localDiff := int(math.Abs(float64(k) - float64(j))) if globalDiff == -1 || localDiff < globalDiff { globalDiff = localDiff } } } } return globalDiff } ================================================ FILE: Shortest Word Distance II/kata.go ================================================ package Shortest_Word_Distance_II import "math" type WordDistance struct { wordsDict []string } func Constructor(wordsDict []string) WordDistance { return WordDistance{ wordsDict: wordsDict, } } func (this *WordDistance) Shortest(word1 string, word2 string) int { return shortestDistance(this.wordsDict, word1, word2) } func shortestDistance(wordsDict []string, word1 string, word2 string) int { k, j := -1, -1 globalDiff := -1 for i, word := range wordsDict { if word == word1 { k = i if k > -1 && j > -1 { localDiff := int(math.Abs(float64(k) - float64(j))) if globalDiff == -1 || localDiff < globalDiff { globalDiff = localDiff } } } else if word == word2 { j = i if k > -1 && j > -1 { localDiff := int(math.Abs(float64(k) - float64(j))) if globalDiff == -1 || localDiff < globalDiff { globalDiff = localDiff } } } } return globalDiff } /** * Your WordDistance object will be instantiated and called as such: * obj := Constructor(wordsDict); * param_1 := obj.Shortest(word1,word2); */ ================================================ FILE: Shuffle String/kata.go ================================================ package kata func restoreString(s string, indices []int) string { newS := make([]byte, len(s)) for i, j := range indices { newS[j] = s[i] } return string(newS) } ================================================ FILE: Shuffle the Array/kata.go ================================================ package kata func shuffle(nums []int, n int) []int { shuffled := make([]int, len(nums)) toggle := true j := 0 for i := 0; i < len(nums); i++ { if toggle { shuffled[i] = nums[j] } else { shuffled[i] = nums[j+n] j++ } toggle = !toggle } return shuffled } ================================================ FILE: Sign of the Product of an Array/kata.go ================================================ package kata func arraySign(nums []int) int { var negativ int for i := 0; i < len(nums); i++ { if nums[i] == 0 { return 0 } if nums[i] < 0 { negativ++ } } if negativ%2 == 0 { return 1 } else if negativ%2 == 1 { return -1 } return 1 } ================================================ FILE: Simple Bank System/kata.go ================================================ package kata type Bank struct { balance []int64 } func Constructor(balance []int64) Bank { return Bank{ balance: balance, } } func (this *Bank) Transfer(account1 int, account2 int, money int64) bool { if account1 < 0 || account1 > len(this.balance) { return false } if account2 < 0 || account2 > len(this.balance) { return false } account1 = account1 - 1 account2 = account2 - 1 account1Balance := this.balance[account1] if account1Balance < money { return false } account1Balance = account1Balance - money this.balance[account1] = account1Balance this.balance[account2] = this.balance[account2] + money return true } func (this *Bank) Deposit(account int, money int64) bool { if account < 0 || account > len(this.balance) { return false } account = account - 1 this.balance[account] = this.balance[account] + money return true } func (this *Bank) Withdraw(account int, balance int64) bool { if account < 0 || account > len(this.balance) { return false } account = account - 1 money := this.balance[account] money = money - balance if money >= 0 { this.balance[account] = money return true } return false } /** * Your Bank object will be instantiated and called as such: * obj := Constructor(balance); * param_1 := obj.Transfer(account1,account2,money); * param_2 := obj.Deposit(account,money); * param_3 := obj.Withdraw(account,money); */ ================================================ FILE: Single Element in a Sorted Array/kata.go ================================================ package kata func singleNonDuplicate(nums []int) (a int) { for _, n := range nums { a = a ^ n } return } ================================================ FILE: Single Number/kata.go ================================================ package kata func singleNumber(nums []int) int { if len(nums) == 0 { return 0 } x := nums[0] for _, n := range nums[1:] { x = n ^ x } return x } ================================================ FILE: Single-Row Keyboard/kata.go ================================================ package Single_Row_Keyboard import "math" func calculateTime(keyboard string, word string) int { keyMap := make(map[rune]int) for i, key := range keyboard { keyMap[key] = i } var startPoint int var sum int for _, char := range word { sum += int(math.Abs(float64(keyMap[char] - startPoint))) startPoint = keyMap[char] } return sum } ================================================ FILE: Sliding Window Maximum/kata.go ================================================ package kata import "math" func maxSlidingWindow(nums []int, k int) []int { if len(nums) == 1 { return nums } l := 0 max := findMax(nums, 0, k-1) nums[l] = max.n for i := k; i < len(nums); i++ { l++ j := i - k + 1 if max.i < j { max = findMax(nums, j, i) } if max.n > nums[i] { nums[l] = max.n } else { nums[l] = nums[i] max = maxNumber{n: nums[i], i: i} } } return nums[:l+1] } type maxNumber struct { i int n int } func findMax(nums []int, i, k int) maxNumber { max := int(math.Inf(-1)) var j int for ; i <= k; i++ { if nums[i] > max { max = nums[i] j = i } } return maxNumber{i: j, n: max} } // calc max // if current is in window then compare it // otherwise trigger calc max ================================================ FILE: Sliding Window Median/kata.go ================================================ package kata import "sort" func medianSlidingWindow(nums []int, k int) []float64 { if len(nums) == 1 { return []float64{float64(nums[0])} } medians := make([]float64, 0) var j int for i := k; i <= len(nums); i++ { window := make([]int, k) copy(window, nums[j:i]) sort.Slice(window, func(m, k int) bool { return window[m] < window[k] }) if len(window)%2 == 1 { medians = append(medians, float64(window[len(window)/2])) } else { medians = append(medians, (float64(window[len(window)/2-1])+float64(window[len(window)/2]))/2) } j++ } return medians } ================================================ FILE: Smallest Even Multiple/kata.go ================================================ package Smallest_Even_Multiple import "math" func smallestEvenMultiple(n int) int { k := float64(n) / 2 u := math.Floor(k) if u == k { return n } return 2 * n } ================================================ FILE: Smallest Index With Equal Value/kata.go ================================================ package kata import "math" func smallestEqual(nums []int) int { index := int(math.Inf(-1)) for i, n := range nums { if i%10 == n { if index == int(math.Inf(-1)) || index > i { index = i } } } if index == int(math.Inf(-1)) { return -1 } return index } ================================================ FILE: Smallest Range I/kata.go ================================================ package Smallest_Range_I import "sort" func smallestRangeI(nums []int, k int) int { if len(nums) == 1 { return 0 } sort.Ints(nums) min := nums[0] max := nums[len(nums)-1] min = min + k diff := max - min if diff > k { diff = k } return (max - diff) - min } ================================================ FILE: Sort Array By Parity/kata.go ================================================ package kata import "sort" func sortArrayByParity(A []int) []int { sort.Slice(A, func(i, j int) bool { return A[i]%2 == 0 }) return A } ================================================ FILE: Sort Array by Increasing Frequency/kata.go ================================================ package kata import "sort" func frequencySort(nums []int) []int { frequencies := make(map[int]int) for _, n := range nums { frequencies[n]++ } sort.Slice(nums, func(i, j int) bool { if frequencies[nums[i]] < frequencies[nums[j]] { return true } else if frequencies[nums[i]] == frequencies[nums[j]] { return nums[i] > nums[j] } return false }) return nums } ================================================ FILE: Sort Characters By Frequency/kata.go ================================================ package kata import "sort" func frequencySort(s string) string { set := make(map[rune]int) for _, c := range s { set[c]++ } b := []rune(s) sort.Slice(b, func(i, j int) bool { if set[b[i]] == set[b[j]] && b[i] < b[j] { return true } else if set[b[i]] > set[b[j]] { return true } return false }) return string(b) } ================================================ FILE: Sort Integers by The Number of 1 Bits/kata.go ================================================ package kata import ( "sort" "strconv" ) func sortByBits(arr []int) []int { mapping := make(map[int]int) for _, n := range arr { if _, ok := mapping[n]; !ok { count := countBits(int64(n)) mapping[n] = count } } sort.Slice(arr, func(i, j int) bool { if mapping[arr[i]] == mapping[arr[j]] { return arr[i] < arr[j] } return mapping[arr[i]] < mapping[arr[j]] }) return arr } func countBits(n int64) int { var count int b := strconv.FormatInt(n, 2) for _, char := range b { if char == '1' { count++ } } return count } ================================================ FILE: Sort Integers by The Power Value/kata.go ================================================ package kata import "sort" func getKth(lo int, hi int, k int) int { type powerValue struct { n, p int } ns := make([]powerValue, hi-lo+1) var i int for x := lo; x <= hi; x++ { y := x count := 0 for y != 1 { if y%2 == 0 { y = y / 2 } else if y%2 == 1 { y = 3*y + 1 } count++ } ns[i] = powerValue{n: x, p: count} i++ } sort.Slice(ns, func(i, j int) bool { if ns[i].p == ns[j].p { return ns[i].n < ns[j].n } return ns[i].p < ns[j].p }) return ns[k-1].n } ================================================ FILE: Sort the Olympic Table/q.sql ================================================ SELECT * FROM Olympic ORDER BY gold_medals DESC, silver_medals DESC, bronze_medals DESC, country ASC; ================================================ FILE: Sort the People/kata.go ================================================ package Sort_the_People import "sort" type Persons struct { Names []string Heights []int } func (p Persons) Len() int { return len(p.Names) } func (p Persons) Less(i, j int) bool { return p.Heights[i] > p.Heights[j] } func (p Persons) Swap(i, j int) { p.Heights[i], p.Heights[j] = p.Heights[j], p.Heights[i] p.Names[i], p.Names[j] = p.Names[j], p.Names[i] } func sortPeople(names []string, heights []int) []string { p := &Persons{Names: names, Heights: heights} sort.Sort(p) return p.Names } ================================================ FILE: Sorting the Sentence/kata.go ================================================ package kata import "sort" const whitespace = ' ' func sortSentence(s string) string { type word struct { idx int chars []byte } words := make([]word, 0) w := word{idx: -1, chars: make([]byte, 0)} for i := 0; i < len(s); i++ { if (i+1 < len(s) && whitespace == s[i+1]) || len(s)-1 == i { idx := s[i] - 48 i++ w.idx = int(idx) words = append(words, w) w = word{idx: -1, chars: make([]byte, 0)} continue } w.chars = append(w.chars, s[i]) } sort.Slice(words, func(i, j int) bool { return words[i].idx < words[j].idx }) sortedS := make([]byte, 0) for _, word := range words { sortedS = append(sortedS, word.chars...) sortedS = append(sortedS, ' ') } return string(sortedS[:len(sortedS)-1]) } ================================================ FILE: Split With Minimum Sum/kata.go ================================================ package kata import ( "math" "sort" ) func splitNum(num int) int { if num <= 9 { return num } digits := make([]int, int(math.Log10(float64(num)))+1) var i int for num > 0 { var digit = num % 10 num = num / 10 digits[i] = digit i++ } if len(digits) == 2 { return digits[0] + digits[1] } sort.Slice(digits, func(i, j int) bool { return digits[i] > digits[j] }) a := digits[0] b := digits[1] var multiplierOfA, multiplierOfB = 10, 10 for i := 2; i < len(digits); i++ { if i%2 == 0 { b += digits[i] * multiplierOfB multiplierOfB = multiplierOfB * 10 } else { a += digits[i] * multiplierOfA multiplierOfA = multiplierOfA * 10 } } return a + b } ================================================ FILE: Split a String in Balanced Strings/kata.go ================================================ package kata func balancedStringSplit(s string) int { max := 0 current := s[0] seekCounter := 1 var seek byte if current == 'R' { seek = 'L' } else { seek = 'R' } for i := 1; i < len(s); i++ { if seek == s[i] && seekCounter == 1 { max++ i++ if i == len(s) { break } current = s[i] seekCounter = 1 if current == 'R' { seek = 'L' } else { seek = 'R' } } else if s[i] == current { seekCounter++ } else if s[i] == seek { seekCounter-- } } return max } ================================================ FILE: Split the Array/kata.go ================================================ package kata func isPossibleToSplit(nums []int) bool { frequency := make(map[int]int, 0) for _, num := range nums { frequency[num]++ if frequency[num] > 2 { return false } } return true } ================================================ FILE: Sqrt(x)/kata.go ================================================ package kata import ( "math" ) func mySqrt(x int) int { return int(math.Sqrt(float64(x))) } ================================================ FILE: Squares of a Sorted Array/kata.go ================================================ package kata import "sort" func sortedSquares(A []int) []int { for i := 0; i < len(A); i++ { A[i] = A[i] * A[i] } sort.Slice(A, func(i, j int) bool { return A[i] < A[j] }) return A } ================================================ FILE: Strong Password Checker II/kata.go ================================================ package Strong_Password_Checker_II var specialCharacters = map[byte]bool{'!': true, '@': true, '#': true, '$': true, '%': true, '^': true, '&': true, '*': true, '(': true, ')': true, '-': true, '+': true} func strongPasswordCheckerII(password string) bool { if len(password) < 8 { return false } var lowerCase bool var upperCase bool var digit bool var specialCharacter bool var adjacent bool j := 1 for i := 0; i < len(password); i++ { if j < len(password) && password[j] == password[i] { adjacent = true } if specialCharacters[password[i]] { specialCharacter = true } else if password[i] >= 48 && password[i] <= 57 { digit = true } else if password[i] >= 97 && password[i] <= 122 { lowerCase = true } else if password[i] >= 65 && password[i] <= 90 { upperCase = true } j++ } return lowerCase && upperCase && digit && specialCharacter && !adjacent } ================================================ FILE: Student Attendance Record I/kata.go ================================================ package kata const A int = 1 const L int = 2 func checkRecord(s string) bool { aCounter := 0 lCounter := 0 for i, c := range s { if c == 'A' { aCounter++ if aCounter > A { return false } } else if c == 'L' { j := i - 1 if j >= 0 && rune(s[j]) == c { lCounter++ if lCounter > L { return false } } else { lCounter = 1 } } } return true } ================================================ FILE: Subdomain Visit Count/kata.go ================================================ package kata import "strconv" func subdomainVisits(cpdomains []string) []string { if len(cpdomains) == 0 { return make([]string, 0) } stats := make(map[string]int) for _, u := range cpdomains { levelBIndex := -1 levelAIndex := -1 countDot := 0 i := 0 for ; i < len(u); i++ { if u[i] == ' ' { break } } i++ domainStartIndex := i c, _ := strconv.Atoi(string(u[:i-1])) markedA := false for ; i < len(u); i++ { if u[i] == '.' { countDot++ } if countDot == 1 && !markedA { levelAIndex = i + 1 markedA = true } if countDot == 2 { levelBIndex = i + 1 break } } stats[string(u[domainStartIndex:])] += c if levelAIndex != -1 { stats[u[levelAIndex:]] += c } if levelBIndex != -1 { stats[u[levelBIndex:]] += c } } res := make([]string, len(stats)) i := 0 for id, stat := range stats { res[i] = strconv.Itoa(stat) + " " + id i++ } return res } ================================================ FILE: Subrectangle Queries/kata.go ================================================ package kata type SubrectangleQueries struct { rectangle [][]int } func Constructor(rectangle [][]int) SubrectangleQueries { return SubrectangleQueries{rectangle: rectangle} } func (this *SubrectangleQueries) UpdateSubrectangle(row1 int, col1 int, row2 int, col2 int, newValue int) { for currentRow := row1; currentRow <= row2; currentRow++ { for currentCol := col1; currentCol <= col2; currentCol++ { this.rectangle[currentRow][currentCol] = newValue } } } func (this *SubrectangleQueries) GetValue(row int, col int) int { return this.rectangle[row][col] } /** * Your SubrectangleQueries object will be instantiated and called as such: * obj := Constructor(rectangle); * obj.UpdateSubrectangle(row1,col1,row2,col2,newValue); * param_2 := obj.GetValue(row,col); */ ================================================ FILE: Substrings of Size Three with Distinct Characters/kata.java ================================================ class Solution { public int countGoodSubstrings(String s) { var k = 3; if (s.length() < k) { return 0; } var characterCount = 0; var wordCount = 0; HashMap 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: Subtract the Product and Sum of Digits of an Integer/kata.go ================================================ package kata func subtractProductAndSum(number int) int { multiplySum := 1 plusSum := 0 for number > 0 { val := number % 10 multiplySum *= val plusSum += val number = number / 10 } return multiplySum - plusSum } ================================================ FILE: Subtree of Another Tree/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func isSubtree(root *TreeNode, subRoot *TreeNode) bool { return SearchBST(root, subRoot, subRoot.Val) } func SearchBST(root *TreeNode, subRoot *TreeNode, val int) bool { if root == nil { return false } if root.Val == val { ok := LeafsEqual(root, subRoot) if ok { return true } } if root.Left != nil { ok := SearchBST(root.Left, subRoot, val) if ok { return true } } if root.Right != nil { ok := SearchBST(root.Right, subRoot, val) if ok { return true } } return false } func LeafsEqual(root1 *TreeNode, root2 *TreeNode) bool { if root1 == nil && root2 == nil { return true } if root1 == nil || root2 == nil { return false } values1 := make([]NodeValue, 0) values2 := make([]NodeValue, 0) PickLeafValues(root1, &values2, 0, 0) PickLeafValues(root2, &values1, 0, 0) if len(values2) != len(values1) { return false } for i := 0; i < len(values1); i++ { if values1[i].value != values2[i].value || values1[i].lvl != values2[i].lvl || values1[i].direction != values2[i].direction { return false } } return true } type NodeValue struct { lvl int value int direction int } func PickLeafValues(node *TreeNode, values *[]NodeValue, lvl int, direction int) { if node == nil { return } *values = append(*values, NodeValue{lvl: lvl, value: node.Val, direction: direction}) if node.Left != nil { PickLeafValues(node.Left, values, lvl+1, 1) } if node.Right != nil { PickLeafValues(node.Right, values, lvl+1, 2) } } ================================================ FILE: Sum Multiples/kata.go ================================================ package kata func sumOfMultiples(n int) int { sum := 0 for i := 1; i < n+1 ; i++ { if i % 3 == 0 || i % 5 == 0 || i % 7 == 0 { sum += i } } return sum } ================================================ FILE: Sum Root to Leaf Numbers/kata.go ================================================ package kata import "strconv" /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func sumNumbers(root *TreeNode) int { if root == nil { return 0 } sums := make([]string, 0) f(root, &sums, "") var max int for _, s := range sums { sum, err := strconv.Atoi(s) if err != nil { panic(err) } max = max + sum } return max } func f(node *TreeNode, sums *[]string, n string) { val := strconv.Itoa(node.Val) n = n + val if node.Left == nil && node.Right == nil { *sums = append(*sums, n) return } if node.Left != nil { f(node.Left, sums, n) } if node.Right != nil { f(node.Right, sums, n) } } ================================================ FILE: Sum in a Matrix/kata.go ================================================ package kata import "sort" func matrixSum(nums [][]int) int { for i := 0; i < len(nums); i++ { sort.Ints(nums[i]) } var sum int for i := 0; i < len(nums[0]); i++ { var max int for j := len(nums) - 1; j >= 0; j-- { if max < nums[j][i] { max = nums[j][i] } } sum += max } return sum } ================================================ FILE: Sum of Digits in Base K/kata.go ================================================ package kata import "math/bits" func sumBase(n int, k int) int { var sum int for n != 0 { q, r := bits.Div(0, uint(n), uint(k)) n = int(q) sum += int(r) } return sum } ================================================ FILE: Sum of Digits in the Minimum Number/kata.go ================================================ package kata func sumOfDigits(nums []int) int { min := -1 for _, n := range nums { if min == -1 || min > n { min = n } } var sum int for { r := min % 10 min = min / 10 sum += r if min == 0 { break } } if sum%2 == 0 { return 1 } return 0 } ================================================ FILE: Sum of Digits of String After Convert/kata.go ================================================ package kata func getLucky(s string, k int) int { var sum uint64 for i := len(s) - 1; i >= 0; i-- { k := uint64(s[i] - 96) if k > 9 { for k != 0 { r := k % 10 k /= 10 sum += r } } else { sum += k } } for k-1 > 0 { newSum := sum sum = 0 for newSum != 0 { r := newSum % 10 newSum /= 10 sum += r } k-- } return int(sum) } ================================================ FILE: Sum of Even Numbers After Queries/kata.java ================================================ class Solution { public int[] sumEvenAfterQueries(int[] nums, int[][] queries) { var res = new int[queries.length]; var sum = 0; for (var num : nums) { if (num % 2 == 0) { sum += num; } } for (var i = 0; i < queries.length; i++) { var oldNum = nums[queries[i][1]]; var newNum = nums[queries[i][1]] + queries[i][0]; if (oldNum % 2 == 0) { sum = sum - oldNum; } if (newNum % 2 == 0) { sum = sum + newNum; } nums[queries[i][1]] = newNum; res[i] = sum; } return res; } } ================================================ FILE: Sum of Left Leaves/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func sumOfLeftLeaves(root *TreeNode) int { sum := new(int) findLeftLeaves(root, -1, sum) return *sum } func findLeftLeaves(node *TreeNode, kind int, sum *int) { if node == nil { return } if kind == 1 && node.Left == nil && node.Right == nil { *sum += node.Val return } if node.Left != nil { findLeftLeaves(node.Left, 1, sum) } if node.Right != nil { findLeftLeaves(node.Right, 0, sum) } } ================================================ FILE: Sum of Squares of Special Elements/kata.go ================================================ package kata func sumOfSquares(nums []int) int { n := len(nums) var sum int for i := 0; i < n; i++ { if n%(i+1) == 0 { sum += nums[i] * nums[i] } } return sum } ================================================ FILE: Sum of Unique Elements/kata.go ================================================ package kata func sumOfUnique(nums []int) int { set := make(map[int]int) for _, num := range nums { set[num]++ } var sum int for num, count := range set { if count > 1 { continue } sum += num } return sum } ================================================ FILE: Sum of Values at Indices With K Set Bits/kata.go ================================================ package kata func sumIndicesWithKSetBits(nums []int, k int) int { var sum int outerLoop: for i, num := range nums { var count int for i > 0 { count += i & 1 if count > k { continue outerLoop } i >>= 1 } if count == k { sum += num } } return sum } ================================================ FILE: Summary Ranges/kata.go ================================================ package kata import "strconv" func summaryRanges(nums []int) []string { if len(nums) == 0 { return nil } if len(nums) == 1 { return []string{strconv.Itoa(nums[0])} } begin := nums[0] last := -1 counter := 0 continuous := make([]string, 0) for i := 1; i < len(nums); i++ { if nums[i]-nums[i-1] == 1 { last = nums[i] counter = counter + 1 if len(nums)-1 == i { continuous = append(continuous, strconv.Itoa(begin)+"->"+strconv.Itoa(last)) } continue } if counter > 0 { continuous = append(continuous, strconv.Itoa(begin)+"->"+strconv.Itoa(last)) } else { continuous = append(continuous, strconv.Itoa(begin)) } begin = nums[i] counter = 0 if len(nums)-1 == i { continuous = append(continuous, strconv.Itoa(nums[i])) } } return continuous } ================================================ FILE: Swap Nodes in Pairs/kata.go ================================================ package kata /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func swapPairs(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } current := head.Next pre := head for current != nil && pre != nil { pre.Val, current.Val = current.Val, pre.Val pre = current.Next if current.Next != nil { current = current.Next.Next } } return head } ================================================ FILE: Swap Salary/kata.sql ================================================ package kata UPDATE salary SET sex = CASE sex WHEN 'm' THEN 'f' ELSE 'm' END; ================================================ FILE: Symmetric 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 boolean isSymmetric(TreeNode root) { return verify(root.left, root.right); } private boolean verify(TreeNode nodeLeft, TreeNode nodeRight) { if (nodeLeft == null && nodeRight == null) { return true; } else if (nodeLeft == null || nodeRight == null) { return false; }else if (nodeLeft.val != nodeRight.val) { return false; } var a = verify(nodeLeft.left, nodeRight.right); var b = verify(nodeLeft.right, nodeRight.left); return a & b; } } ================================================ FILE: Take Gifts From the Richest Pile/kata.java ================================================ class Solution { public long pickGifts(int[] gifts, int k) { PriorityQueue q = new PriorityQueue(gifts.length, Collections.reverseOrder()); for (var gift: gifts) { q.add(gift); } while(k >= 1) { var gift = q.poll(); q.add((int) Math.floor(Math.sqrt((double) gift))); k--; } var sum = 0l; while(!q.isEmpty()) { sum += q.poll().intValue(); } return sum; } } ================================================ FILE: Tasks Count in the Weekend/q.sql ================================================ SELECT Sum(CASE WHEN Weekday(submit_date) <= 4 THEN 1 ELSE 0 END) AS weekend_cnt, Sum(CASE WHEN Weekday(submit_date) > 4 THEN 1 ELSE 0 END) AS working_cnt FROM tasks; ================================================ FILE: The Airport With the Most Traffic/q.sql ================================================ WITH cte (airport_id, flights_count_max) AS ( SELECT airport_id, SUM(flights_count) AS flights_count_max FROM ( SELECT departure_airport AS airport_id, flights_count FROM Flights UNION ALL SELECT arrival_airport AS airport_id, flights_count FROM Flights ) AS Flights GROUP BY airport_id ) SELECT airport_id FROM cte WHERE flights_count_max = ( SELECT MAX(flights_count_max) FROM cte ) ; ================================================ FILE: The Employee That Worked on the Longest Task/kata.java ================================================ class Solution { public int hardestWorker(int n, int[][] logs) { if (logs.length == 0) { return -1; } var id = logs[0][0]; var taskSpanTime = logs[0][1]; for (var i = 1; i < logs.length; i++) { var currentSpan = logs[i][1] - logs[i-1][1]; if (taskSpanTime == currentSpan && id > logs[i][0]) { id = logs[i][0]; taskSpanTime = currentSpan; } else if (taskSpanTime < currentSpan) { id = logs[i][0]; taskSpanTime = currentSpan; } } return id; } } ================================================ FILE: The K Weakest Rows in a Matrix/kata.go ================================================ package kata import "sort" func kWeakestRows(mat [][]int, k int) []int { pair := make([][]int, len(mat)) for i := 0; i < len(mat); i++ { var sum int for j := 0; j < len(mat[i]); j++ { sum += mat[i][j] } pair[i] = []int{sum, i} } sort.Slice(pair, func(i, j int) bool { if pair[i][0] == pair[j][0] { return pair[i][1] < pair[j][1] } return pair[i][0] < pair[j][0] }) idx := make([]int, k) for i := 0; i < k; i++ { idx[i] = pair[i][1] } return idx } ================================================ FILE: The Latest Login in 2020/q.sql ================================================ SELECT user_id, MAX(time_stamp) AS last_stamp FROM Logins WHERE YEAR(time_stamp) = 2020 GROUP BY user_id; ================================================ FILE: The Number of Employees Which Report to Each Employee/q.sql ================================================ SELECT a.reports_to as employee_id, b.name, COUNT(a.reports_to) AS reports_count, ROUND(AVG(a.age), 0) AS average_age FROM Employees AS a INNER JOIN Employees AS b ON a.reports_to = b.employee_id WHERE a.employee_id IN (SELECT DISTINCT(employee_id) FROM Employees WHERE reports_to IS NOT NULL) GROUP BY a.reports_to ORDER BY a.reports_to; ================================================ FILE: The Number of Rich Customers/q.sql ================================================ SELECT COUNT(DISTINCT(customer_id)) AS rich_count FROM Store WHERE amount > 500 ================================================ FILE: The Number of Users That Are Eligible for Discount/q.sql ================================================ CREATE FUNCTION getUserIDs(startDate DATE, endDate DATE, minAmount INT) RETURNS INT BEGIN RETURN ( SELECT COUNT(DISTINCT(user_id)) FROM Purchases WHERE time_stamp <= endDate AND time_stamp >= startDate AND amount >= minAmount ); END ================================================ FILE: The Users That Are Eligible for Discount/q.sql ================================================ CREATE PROCEDURE getUserIDs(startDate DATE, endDate DATE, minAmount INT) BEGIN SELECT DISTINCT(user_id) FROM Purchases WHERE time_stamp <= endDate AND time_stamp >= startDate AND amount >= minAmount ORDER BY user_id ASC; END ================================================ FILE: The Winner University/q.sql ================================================ SELECT CASE WHEN ((SELECT COUNT(*) FROM NewYork WHERE score >= 90) < (SELECT COUNT(*) FROM California WHERE score >= 90)) THEN "California University" WHEN ((SELECT COUNT(*) FROM NewYork WHERE score >= 90) = (SELECT COUNT(*) FROM California WHERE score >= 90)) THEN "No Winner" ELSE "New York University" END AS winner FROM DUAL; ================================================ FILE: Third Maximum Number/kata.go ================================================ package kata import ( "sort" ) func thirdMax(nums []int) int { if len(nums) == 0 { return -1 } sort.Slice(nums, func(i, j int) bool { return nums[i] > nums[j] }) seen := map[int]struct{}{} count := 0 for i := 0; i < len(nums); i++ { _, ok := seen[nums[i]] if ok { continue } seen[nums[i]] = struct{}{} count = count + 1 if count == 3 { return nums[i] } } return nums[0] } ================================================ FILE: Thousand Separator/kata.go ================================================ package kata import "strconv" func thousandSeparator(n int) string { s := strconv.Itoa(n) k := make([]byte, 0) var count int for i := len(s) - 1; i >= 0; i-- { if count == 3 { k = append(k, byte(46)) count = 0 } count++ k = append(k, s[i]) } l := make([]byte, len(k)) j := 0 for i := len(k) - 1; i >= 0; i-- { l[j] = k[i] j++ } return string(l) } ================================================ FILE: Three Consecutive Odds/kata.go ================================================ package kata func threeConsecutiveOdds(arr []int) bool { var c int for _, n := range arr { if n%2 == 1 { c++ if c == 3 { return true } } else { c = 0 } } return false } ================================================ FILE: Time Based Key-Value Store/kata.go ================================================ package kata type item struct { value string timestamp int } type TimeMap struct { store map[string][]item } /** Initialize your data structure here. */ func Constructor() TimeMap { return TimeMap{store: make(map[string][]item)} } func (this *TimeMap) Set(key string, value string, timestamp int) { v, ok := this.store[key] if !ok { list := make([]item, 1) list[0].value = value list[0].timestamp = timestamp this.store[key] = list return } v = append(v, item{value: value, timestamp: timestamp}) this.store[key] = v } func (this *TimeMap) Get(key string, timestamp int) string { list, ok := this.store[key] if !ok { return "" } max := -1 index := 0 min := -1 for i, item := range list { if item.timestamp == timestamp { return item.value } if max == -1 || max < item.timestamp && timestamp > item.timestamp { max = item.timestamp index = i } if min == -1 || min > item.timestamp { min = item.timestamp } } if min > timestamp { return "" } return list[index].value } /** * Your TimeMap object will be instantiated and called as such: * obj := Constructor(); * obj.Set(key,value,timestamp); * param_2 := obj.Get(key,timestamp); */ ================================================ FILE: To Be Or Not To Be/kata.ts ================================================ type ToBeOrNotToBe = { toBe: (val: any) => boolean; notToBe: (val: any) => boolean; }; function expect(val: any): ToBeOrNotToBe { return new toBeOrNotToBe(val); }; class toBeOrNotToBe implements ToBeOrNotToBe { private val: any; public constructor(val: any) { this.val = val; } public toBe(val: any) :boolean { let ok: boolean = this.val === val if (!ok) { throw new Error("Not Equal"); } return ok } public notToBe(val: any) :boolean { let ok: boolean = this.val !== val if (!ok) { throw new Error("Equal"); } return ok } } /** * expect(5).toBe(5); // true * expect(5).notToBe(5); // throws "Equal" */ ================================================ FILE: To Lower Case/kata.go ================================================ package kata func toLowerCase(str string) string { if len(str) == 0 { return str } b := []byte(str) var i int for _, c := range b { if c >= 65 && c <= 90 { b[i] = b[i] + 32 } i++ } return string(b) } ================================================ FILE: Toeplitz Matrix/kata.go ================================================ package kata func isToeplitzMatrix(matrix [][]int) bool { for i := 0; i < len(matrix[0]); i++ { j := 0 k := i lastValue := matrix[0][k] for { if len(matrix) <= j { break } if len(matrix[0]) <= k { break } if lastValue != matrix[j][k] { return false } lastValue = matrix[j][k] j = j + 1 k++ } } for i := len(matrix) - 1; i >= 1; i-- { j := i k := 0 lastValue := matrix[j][k] for { if len(matrix) <= j { break } if len(matrix[0]) <= k { break } if lastValue != matrix[j][k] { return false } lastValue = matrix[j][k] j = j + 1 k++ } } return true } ================================================ FILE: Top K Frequent Elements/kata.go ================================================ package kata import "container/heap" type Item struct { value int priority int index int } func topKFrequent(nums []int, k int) []int { if len(nums) == 0 { return nil } pq := make(PriorityQueue, 0) counter := make(map[int]int) for _, n := range nums { counter[n] = counter[n] + 1 } var i int for n, c := range counter { item := &Item{ value: n, priority: c, index: i, } pq = append(pq, item) i++ } nums = nil heap.Init(&pq) for pq.Len() > 0 && k > 0 { nums = append(nums, heap.Pop(&pq).(*Item).value) k-- } return nums } type PriorityQueue []*Item func (pq PriorityQueue) Len() int { return len(pq) } func (pq PriorityQueue) Less(i, j int) bool { if pq[i].priority > pq[j].priority { return true } return false } func (pq PriorityQueue) Swap(i, j int) { pq[i], pq[j] = pq[j], pq[i] pq[i].index = i pq[j].index = j } func (pq *PriorityQueue) Pop() interface{} { old := *pq n := len(old) item := old[n-1] item.index = -1 *pq = old[0 : n-1] return item } func (pq *PriorityQueue) Push(x interface{}) { n := len(*pq) item := x.(*Item) item.index = n *pq = append(*pq, item) } ================================================ FILE: Top K Frequent Words/kata.go ================================================ package kata import "sort" type Prio struct { word string freq int } func topKFrequent(words []string, k int) []string { if len(words) == 0 { return nil } counter := make(map[string]int) for i := range words { counter[words[i]]++ } prios := make([]Prio, len(counter)) var i int for w, c := range counter { prio := Prio{ word: w, freq: c, } prios[i] = prio i++ } sort.Slice(prios, func(i, j int) bool { if prios[i].freq == prios[j].freq { return prios[i].word < prios[j].word } return prios[i].freq > prios[j].freq }) prios = prios[:k] matchedWords := make([]string, len(prios)) for i := range prios { matchedWords[i] = prios[i].word } return matchedWords } ================================================ FILE: Top Travellers/q.sql ================================================ SELECT name, COALESCE(SUM(distance), 0) AS travelled_distance FROM Users AS u LEFT JOIN Rides AS r ON r.user_id = u.id GROUP BY u.id ORDER BY travelled_distance DESC, name ASC; ================================================ FILE: Transpose Matrix/kata.go ================================================ package kata func transpose(matrix [][]int) [][]int { transposeMatrix := make([][]int, len(matrix[0])) for i := 0; i < len(matrix[0]); i++ { transposeMatrix[i] = make([]int, len(matrix)) } var k, l int for i := 0; i < len(matrix); i++ { for j := 0; j < len(matrix[i]); j++ { transposeMatrix[j][i] = matrix[i][j] k++ } k = 0 l++ } return transposeMatrix } ================================================ FILE: Triangle Judgement/kata.sql ================================================ SELECT x, y, z, IF((z+y > x AND x+y > z AND z+x > y), 'Yes', 'No') AS triangle FROM Triangle ================================================ FILE: Truncate Sentence/kata.go ================================================ package kata const whitespace = ' ' func truncateSentence(s string, k int) string { var count int for i := 0; i < len(s); i++ { if s[i] == whitespace { count++ } if count == k { return s[:i] } } return s } ================================================ FILE: Two Furthest Houses With Different Colors/kata.go ================================================ package Two_Furthest_Houses_With_Different_Colors func maxDistance(colors []int) int { a := colors[0] b := colors[len(colors)-1] left := -1 right := -1 var i int for j := len(colors) - 1; j >= 1; j-- { if left == -1 && a != colors[j] { left = j } if right == -1 && b != colors[i] { right = j } i++ } if left > right { return left } return right } ================================================ FILE: Two Out of Three/kata.go ================================================ package Two_Out_of_Three func twoOutOfThree(nums1 []int, nums2 []int, nums3 []int) []int { type numCounter struct { a, b, c int } counter := make(map[int]numCounter) for _, num := range nums1 { if counter[num].a == 0 { counter[num] = numCounter{a: 1, b: 0, c: 0} } } for _, num := range nums2 { c := counter[num] if c.b == 0 { c.b++ counter[num] = c } } for _, num := range nums3 { c := counter[num] if c.c == 0 { c.c++ counter[num] = c } } matched := make([]int, 0) for num, c := range counter { if (c.a + c.b + c.c) >= 2 { matched = append(matched, num) } } return matched } ================================================ FILE: Two Sum/kata.py ================================================ package kata from itertools import permutations class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: perm = permutations(nums, 2) a = None b = None for pair in perm: if target == pair[0] + pair[1]: a = pair[0] b = pair[1] break j = None k = None for i in range(len(nums)): if k != None and j != None: break if j == None and nums[i] == b: j = i elif k == None and nums[i] == a: k = i return [j, k] ================================================ FILE: Ugly Number/kata.go ================================================ package kata func isUgly(num int) bool { if num == 1 { return true } if num <= 0 { return false } for { if num == 3 || num == 5 || num == 2 { return true } if num%2 == 0 { num = num / 2 continue } else if num%3 == 0 { num = num / 3 continue } else if num%5 == 0 { num = num / 5 continue } break } return false } ================================================ FILE: Uncommon Words from Two Sentences/kata.go ================================================ package kata func uncommonFromSentences(A string, B string) []string { type WordCounter struct { A int B int } raw := make([]byte, 0) set := make(map[string]WordCounter) for i := 0; i < len(A); i++ { if A[i] == ' ' || len(A)-1 == i { if len(A)-1 == i { raw = append(raw, A[i]) } word := string(raw) v, ok := set[word] if ok { v.A = v.A + 1 set[word] = v } else { set[word] = WordCounter{A: 1} } raw = make([]byte, 0) continue } raw = append(raw, A[i]) } raw = make([]byte, 0) for i := 0; i < len(B); i++ { if B[i] == ' ' || len(B)-1 == i { if len(B)-1 == i { raw = append(raw, B[i]) } word := string(raw) v, ok := set[word] if ok { v.B = v.B + 1 set[word] = v } else { set[word] = WordCounter{B: 1} } raw = make([]byte, 0) continue } raw = append(raw, B[i]) } words := make([]string, 0) for w, c := range set { if c.A == 1 && c.B == 0 || c.A == 0 && c.B == 1 { words = append(words, w) } } return words } ================================================ FILE: Unique Morse Code Words/kata.go ================================================ package kata var encoder []string = []string{".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."} func uniqueMorseRepresentations(words []string) int { uniqueTransformations := map[string]bool{} for _, word := range words { var encodedWord string for _, char := range word { encodedWord += encoder[int(char-97)] } uniqueTransformations[encodedWord] = true } return len(uniqueTransformations) } ================================================ FILE: Unique Number of Occurrences/kata.go ================================================ package kata import "sort" func uniqueOccurrences(arr []int) bool { counter := make(map[int]int) for i := 0; i < len(arr); i++ { counter[arr[i]] = counter[arr[i]] + 1 } values := make([]int, len(counter)) var i int for _, c := range counter { values[i] = c i++ } sort.Slice(values, func(i, j int) bool { return values[i] < values[j] }) last := -1 for _, a := range values { if a == last { return false } last = a } return true } ================================================ FILE: Unique Orders and Customers Per Month/q.sql ================================================ SELECT DATE_FORMAT(order_date, "%Y-%m") AS month, COUNT(order_id) AS order_count, COUNT(DISTINCT customer_id) AS customer_count FROM Orders WHERE invoice > 20 GROUP BY DATE_FORMAT(order_date, "%Y-%m"); ================================================ FILE: Univalued Binary Tree/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func isUnivalTree(root *TreeNode) bool { set := make(map[int]struct{}) isValid(root, set) if len(set) == 1 { return true } return false } func isValid(node *TreeNode, set map[int]struct{}) { if node == nil { return } set[node.Val] = struct{}{} if node.Left != nil { isValid(node.Left, set) } if node.Right != nil { isValid(node.Right, set) } } ================================================ FILE: Valid Anagram/kata.go ================================================ package kata import "sort" func isAnagram(s string, t string) bool { if len(s) != len(t) { return false } sb := []byte(s) tb := []byte(t) sort.Slice(tb, func(i, j int) bool { return tb[i] < tb[j] }) sort.Slice(sb, func(i, j int) bool { return sb[i] < sb[j] }) if string(tb) == string(sb) { return true } return false } ================================================ FILE: Valid Mountain Array/kata.go ================================================ package kata func validMountainArray(A []int) bool { if len(A) < 2 { return false } if A[0] >= A[1] || A[len(A)-2] < A[len(A)-1] { return false } var down bool for i := 1; i < len(A); i++ { if A[i-1] > A[i] { down = true } if (A[i-1] < A[i] && down) || A[i-1] == A[i] { return false } } return true } ================================================ FILE: Valid Palindrome/kata.go ================================================ package kata func isPalindrome(s string) bool { if len(s) == 0 { return true } j := len(s) - 1 for i := 0; i < len(s)/2; i++ { ok, addI := isValidChar(s[i]) if !ok { continue } ok, addJ := isValidChar(s[j]) if !ok { j-- i-- continue } if (int(s[i]) + addI) != (int(s[j]) + addJ) { return false } j-- } return true } func isValidChar(char byte) (bool, int) { if char >= 97 && char <= 122 { return true, 0 } else if char >= 65 && char <= 90 { return true, 32 } else if char >= 48 && char <= 57 { return true, 0 } return false, 0 } ================================================ FILE: Valid Palindrome II/kata.go ================================================ package kata func validPalindrome(s string) bool { j := len(s) - 1 Jidx := -1 Iidx := -1 for i := 0; i < len(s)/2; i++ { if s[i] != s[j] { Jidx = j Iidx = i break } j-- } b := makeValid(s, Iidx) validI := IsValid(b) b = makeValid(s, Jidx) validJ := IsValid(b) return validJ || validI } func makeValid(s string, idx int) []byte { b := make([]byte, 0) for i := 0; i < len(s); i++ { if i == idx && idx != -1 { continue } b = append(b, s[i]) } return b } func IsValid(b []byte) bool { valid := true j := len(b) - 1 for i := 0; i < len(b)/2; i++ { if b[i] != b[j] { valid = false } j-- } return valid } ================================================ FILE: Valid Parentheses/kata.go ================================================ package kata func isValid(s string) bool { stack := make([]rune, 0) if len(s)%2 == 1 { return false } var openChar rune for _, char := range s { if char == '(' || char == '{' || char == '[' { stack = append(stack, char) continue } openChar = rune(1) if len(stack)-1 > -1 { openChar = stack[len(stack)-1] stack = stack[:len(stack)-1] } if char == '}' && openChar != '{' || char == ')' && openChar != '(' || char == ']' && openChar != '[' { return false } } if len(stack) > 0 { return false } return true } ================================================ FILE: Validate Binary Search Tree/kata.go ================================================ package kata /** * Definition for a binary tree node. * type TreeNode struct { * Val int * Left *TreeNode * Right *TreeNode * } */ func isValidBST(root *TreeNode) bool { list := inorderTraversal(root) for i := 1; i < len(list); i++ { if !(list[i-1] < list[i]) { return false } } return true } 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: Warehouse Manager/q.sql ================================================ SELECT w.name AS warehouse_name, SUM(p.Width*p.Length*p.Height*w.units) AS volume FROM Warehouse AS w INNER JOIN Products AS p ON p.product_id = w.product_id GROUP BY w.name ================================================ FILE: Water Bottles/kata.go ================================================ package kata func numWaterBottles(numBottles int, numExchange int) int { max := numBottles for numExchange <= numBottles { numBottles = numBottles - numExchange numBottles++ max++ } return max } ================================================ FILE: Weather Type in Each Country/q.sql ================================================ SELECT country_name, CASE WHEN SUM(weather_state) / COUNT(*) <= 15 THEN 'Cold' WHEN SUM(weather_state) / COUNT(*) >= 25 THEN 'Hot' ELSE 'Warm' END AS weather_type FROM Countries INNER JOIN Weather ON Weather.country_id = Countries.country_id WHERE YEAR(day) = 2019 AND MONTH(day) = 11 GROUP BY country_name; ================================================ FILE: Widest Vertical Area Between Two Points Containing No Points/kata.java ================================================ class Solution { public int maxWidthOfVerticalArea(int[][] points) { Integer[] convertedPoints = new Integer[points.length]; for (int i = 0; i < points.length; i++) { convertedPoints[i] = Integer.valueOf(points[i][0]); } Arrays.sort(convertedPoints, new Comparator() { public int compare(Integer p1, Integer p2) { return p1.compareTo(p2); } }); var max = 0; for (int i = 1; i < convertedPoints.length; i++) { var d = convertedPoints[i]-convertedPoints[i-1]; if (d > max) { max = d; } } return max; } } ================================================ FILE: Word Pattern/kata.go ================================================ package Word_Pattern func wordPattern(pattern string, s string) bool { var k int p := pattern[k] patternMapping := make(map[string]string) var j int for i := 0; i < len(s); i++ { if s[i] == ' ' || (len(s)-1) == i { if (len(s) - 1) == i { i = i + 1 } word, ok := patternMapping[string(p-64)] if ok { if s[j:i] != word { return false } } else { _, ok := patternMapping[s[j:i]] if ok { return false } patternMapping[string(p-64)] = s[j:i] patternMapping[s[j:i]] = string(p - 64) } j = i + 1 if (k + 1) < len(pattern) { k++ p = pattern[k] } else { k++ } } } return k == len(pattern) } ================================================ FILE: XOR Operation in an Array/kata.go ================================================ package kata func xorOperation(n int, start int) int { var k int for i := 0; i < n; i++ { k ^= start + 2*i } return k }