All posts by shiji

1094. Car Pooling

2019/09/26 shiji

You are driving a vehicle that has capacity empty seats initially available for passengers. The vehicle only drives east (ie. it cannot turn around and drive west.)

Given a list of trips, trip[i] = [num_passengers, start_location, end_location] contains information about the i-th trip: the number of passengers that must be picked up, and the locations to pick them up and drop them off. The locations are given as the number of kilometers due east from your vehicle’s initial location.

Return true if and only if it is possible to pick up and drop off all passengers for all the given trips.

Example 1:

Input:

trips = [[2,1,5],[3,3,7]], capacity = 4

Output:

false

Example 2:

Input:

trips = [[2,1,5],[3,3,7]], capacity = 5

Output:

true

Example 3:

Input:

trips = [[2,1,5],[3,5,7]], capacity = 3

Output:

true

Example 4:

Input:

trips = [[3,2,7],[3,7,9],[8,3,9]], capacity = 11

Output:

true

Accepted Solution in wrong PHP syntax (don’t drink and code)

<?php
class Solution {

     public $dic=[];
    /**
     * @param Integer[][] $trips
     * @param Integer $capacity
     * @return Boolean
     */
    function carPooling($trips, $capacity) {
        $max = 0;
        $sum = 0;
        $this->$dic = [];
        foreach ($trips as $c){
            if(!isset($this->$dic[$c[1]])){
                $this->$dic[$c[1]] = 0;
            }
            $this->$dic[$c[1]] += $c[0];
            $this->$dic[$c[2]] -= $c[0];
        }
        // 
        ksort($this->$dic);
    
        // Calculate least expected capacity
        foreach($this->$dic as $d){
            $sum += $d;
            if($sum > $max){
                $max  = $sum;
            }
        }
   
        return $max <= $capacity;
    }
}
?>

And Here’s the solution in my mind..

<?php
class Solution {

     public $dic=[];
    /**
     * @param Integer[][] $trips
     * @param Integer $capacity
     * @return Boolean
     */
    function carPooling($trips, $capacity) {
        $max = 0;
        $sum = 0;
        $this->dic = [];
        foreach ($trips as $c){
            if(!isset($this->dic[$c[1]])){
                $this->dic[$c[1]] = 0;
            }
            $this->dic[$c[1]] += $c[0];
            $this->dic[$c[2]] -= $c[0];
        }

        ksort($this->dic);
    
        // I'm finding the min capacity here, but it's not necessary 
        foreach($this->dic as $d){
            $sum += $d;
            if($sum > $max){
                $max  = $sum;
            }
        }
   
        return $max <= $capacity;
    }   
}

?>

Leetcode

1100. Find K-Length Substrings With No Repeated Characters

2019/09/18 shiji

Given a string S, return the number of substrings of length K with no repeated characters.

Example 1:

Input:

S = "havefunonleetcode", K = 5

Output:

Explanation:

There are 6 substrings they are : 'havef','avefu','vefun','efuno','etcod','tcode'.

Example 2:

Input:

S = "home", K = 5

Output:

Explanation:

Notice K can be larger than the length of S. In this case is not possible to find any substring.

Note:

1 <= S.length <= 10^4
All characters of S are lowercase English letters.
1 <= K <= 10^4

Quite straight forward solution.

the brute force way is foreach K chars, check dupes.

to optimize that, push next char and remove last instead, so same work won’t be done multiple times

<?php
class Solution {

    /**
     * @param String $S
     * @param Integer $K
     * @return Integer
     */
    function numKLenSubstrNoRepeats($S, $K) {
        if($K > strlen($S)){
            return 0;
        }
        // This is not necessary in PHP
        $arr = str_split($S);
        $dic = [];
        $result = 0;
        
        // Helper, any repeated chars so far?
        $unique = static function() use (&$dic) {
            foreach($dic as $v){
                if ($v > 1){
                    return false;
                }
            }
            return true;
        };

        // Load first K chars
        for($i = 0; $i < $K; $i ++){
            if(isset($dic[$arr[$i]])){
                $dic[$arr[$i]]++;
            } else {
                $dic[$arr[$i]] = 1;
            }
            
        }
        // First K has repeat? update counter
        if($unique()){
             $result++;
        }

        // Starting from K, take next char and remove the last one, update dictionary, and check after each round
        for($in = $K; $in < strlen($S); $in ++){
            if(isset($dic[$arr[$in]])){
                $dic[$arr[$in]]++;
            } else {
                $dic[$arr[$in]] = 1;
            }
            
            $out = $in-$K;
            $dic[$arr[$out]]--;
            
            if($unique()){
                $result++;
            }
        }
            
        return $result;
    }
}
?>

Leetcode

917. Reverse Only Letters

2019/09/18 shiji

Given a string S, return the “reversed” string where all characters that are not a letter stay in the same place, and all letters reverse their positions.

Example 1:

Input:

"ab-cd"

Output:

"dc-ba"

Example 2:

Input:

"a-bC-dEf-ghIj"

Output:

"j-Ih-gfE-dCba"

Example 3:

Input:

"Test1ng-Leet=code-Q!"

Output:

"Qedo1ct-eeLg=ntse-T!"

Note:

S.length <= 100
33 <= S[i].ASCIIcode <= 122
S doesn’t contain \ or "

Straightforward solution.

collect letters in reverse order.
go through string from beginning, if it’s letter, replace with letter from reverse string, else keep special chars and adjust pointer accordingly
of course there’s space for improvement, but not necessary

<?php
class Solution {

    /**
     * @param String $S
     * @return String
     */
    function reverseOnlyLetters($S) {
        $x = '';
        $y = '';
        for($i = strlen($S)-1; $i >=0; $i -- ){
            if(ctype_alpha($S[$i])){
                $x .= $S[$i];
            }
        }
        $xi = 0;
        for($i = 0; $i < strlen($S); $i ++){
            if(!ctype_alpha($S[$i])){
                $y .= $S[$i];
            } else {
                $y .= $x[$xi];
                $xi ++;
            }
             
        }
        
        return $y;
    }
}

?>

Leetcode

7. Reverse Integer

2019/05/05 shiji

Given a 32-bit signed integer, reverse digits of an integer.

Example 1:

Input:

Output:

Example 2:

Input:

 -123

Output:

 -321

Example 3:

Input:

Output:

Note:
Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2³¹, 2³¹− 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

class Solution {

    /**
     * @param Integer $x
     * @return Integer
     */
    function reverse($x) {
        
        $r =  (int) (strrev(trim($x,"+-")) * ($x>0?1:-1));
        
        if($r >  pow(2,31)-1 || $r < -pow(2,31)){
            return 0;
        }
        return $r;
    }
}

Leetcode

9. Palindrome Number

2019/05/05 shiji

Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward.

Example 1:

Input:

Output:

 true

Example 2:

Input:

 -121

Output:

 false

Explanation:

 From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.

Example 3:

Input:

Output:

 false

Explanation:

 Reads 01 from right to left. Therefore it is not a palindrome.

Follow up:

Coud you solve it without converting the integer to a string?

class Solution {

    /**
     * @param Integer $x
     * @return Boolean
     */
    function isPalindrome($x) {
        if($x < 0){
            return false;
        }
        return strrev($x) == $x;
    }
}

For the followup

not converting to string? Create a stack of integers instead (like a push down automata)

Leetcode

24. Swap Nodes in Pairs

2019/05/05 shiji

Given a linked list, swap every two adjacent nodes and return its head.

You may not modify the values in the list’s nodes, only nodes itself may be changed.

Example:

Given 1->2->3->4, you should return the list as 2->1->4->3.

/**
 * Definition for a singly-linked list.
 * class ListNode {
 *     public $val = 0;
 *     public $next = null;
 *     function __construct($val) { $this->val = $val; }
 * }
 */
class Solution {

    /**
     * @param ListNode $head
     * @return ListNode
     */
    function swapPairs($head) {
        if($head === null || $head->next === null){
            return $head;
        }
        
        $r = $head->next;
        $temp = $r->next;
        $r->next = $head;
        $r->next ->next = $this->swapPairs($temp);
        return $r;
    }
}

Leetcode

26. Remove Duplicates from Sorted Array

2019/05/05 shiji

Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

Example 1:

Given nums = [1,1,2],

Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.

It doesn’t matter what you leave beyond the returned length.
Example 2:

Given nums = [0,0,1,1,1,2,2,3,3,4],

Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.

It doesn’t matter what values are set beyond the returned length.
Clarification:

Confused why the returned value is an integer but your answer is an array?

Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.

Internally you can think of this:

// nums is passed in by reference. (i.e., without making a copy)
int len = removeDuplicates(nums);

// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
print(nums[i]);
}

class Solution {

    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function removeDuplicates(&$nums) {
        if(empty($nums)){
            return 0;
        }
        $i = 0;
        $r = 1;
        while($i < count($nums)-1){
            if($nums[$i] != $nums[$i+1]){
                $nums[$r] = $nums[$i+1];
                $r ++;
                
            }
            $i ++;
        }
        return $r;
    }
}

Leetcode

1032. Stream of Characters

2019/04/22 shiji

Implement the StreamChecker class as follows:

StreamChecker(words): Constructor, init the data structure with the given words.
query(letter): returns true if and only if for some k >= 1, the last k characters queried (in order from oldest to newest, including this letter just queried) spell one of the words in the given list.

Example:

StreamChecker streamChecker = new StreamChecker(["cd","f","kl"]); // init the dictionary.
streamChecker.query('a');          // return false
streamChecker.query('b');          // return false
streamChecker.query('c');          // return false
streamChecker.query('d');          // return true, because 'cd' is in the wordlist
streamChecker.query('e');          // return false
streamChecker.query('f');          // return true, because 'f' is in the wordlist
streamChecker.query('g');          // return false
streamChecker.query('h');          // return false
streamChecker.query('i');          // return false
streamChecker.query('j');          // return false
streamChecker.query('k');          // return false
streamChecker.query('l');          // return true, because 'kl' is in the wordlist

Note:

1 <= words.length <= 2000
1 <= words[i].length <= 2000
Words will only consist of lowercase English letters.
Queries will only consist of lowercase English letters.
The number of queries is at most 40000.

TLE Version (First Draft)

This is the version I submitted during the contest, TLE. (obviously, for a hard question)

My idea was building a tree, well, I just hate writing another class…. so I tried in a hard way during the contest.

class StreamChecker {
    public $max = 0;
    public $hist = "";
    public $d;

    /**
     * @param String[] $words
     */
    function __construct($words) {
        error_reporting(0);
        ini_set('display_errors', 0);
        $this-> d = $words;
        foreach($words as $w){
           $this ->max = max(strlen($w), $this ->max); 
        }
        
    }
  
    /**
     * @param String $letter
     * @return Boolean
     */
    function query($letter) {

        $this ->hist .= $letter;
        foreach($this->d as $f){
            if ($this -> endsWith($this -> hist,$f)) {
                
                return true;
            }
        } 
        if(strlen($this->hist) > $max){
            $this->hist = substr($this->hist, -($this->max));
        }
        
        return false;
    }
    
    function endsWith($haystack, $needle)
    {
        $length = strlen($needle);
        if ($length == 0) {
            return true;
        }
        return (substr($haystack, -$length) === $needle);
    }
}

/**
 * Your StreamChecker object will be instantiated and called as such:
 * $obj = StreamChecker($words);
 * $ret_1 = $obj->query($letter);
 */

Another Try

for the query part, if the char is not the last char of any word in the dictionary, return false. The method actually passed all the tests, 2000+ms.

It’s actually a single level trie tree.. in the form of an array.

class StreamChecker {
    public $max = 0;
    public $hist = "";
    public $first = [];
    public $d;

    /**
     * @param String[] $words
     */
    function __construct($words) {
        error_reporting(0);
        ini_set('display_errors', 0);
        $this-> d = $words;
        foreach($words as $w){
            $this ->max = max(strlen($w), $this ->max); 
            $this -> first[] = $w[strlen($w)-1];
        }
        
    }
  
    /**
     * @param String $letter
     * @return Boolean
     */
    function query($letter) {
        $this ->hist .= $letter;
        if(!in_array($letter,$this->first)){
            return false;
        }
        foreach($this->d as $f){
            if ($this -> endsWith($this -> hist,$f)) {
                
                return true;
            }
        } 
        if(strlen($this->hist) > $max){
            $this->hist = substr($this->hist, -($this->max));
        }
        
        return false;
    }
    
    function endsWith($haystack, $needle)
    {
        $length = strlen($needle);
        if ($length == 0) {
            return true;
        }
        return (substr($haystack, -$length) === $needle);
    }
}

/**
 * Your StreamChecker object will be instantiated and called as such:
 * $obj = StreamChecker($words);
 * $ret_1 = $obj->query($letter);
 */