## 911. Online Election

In an election, the `i`-th vote was cast for `persons[i]` at time `times[i]`.

Now, we would like to implement the following query function: `TopVotedCandidate.q(int t)` will return the number of the person that was leading the election at time `t`.

Votes cast at time `t` will count towards our query.  In the case of a tie, the most recent vote (among tied candidates) wins.

Example 1:

Input:

```["TopVotedCandidate","q","q","q","q","q","q"], [[[0,1,1,0,0,1,0],[0,5,10,15,20,25,30]],[3],[12],[25],[15],[24],[8]]
```

Output:

```[null,0,1,1,0,0,1]
```

Explanation:

```At time 3, the votes are [0], and 0 is leading.
At time 12, the votes are [0,1,1], and 1 is leading.
At time 25, the votes are [0,1,1,0,0,1], and 1 is leading (as ties go to the most recent vote.)
This continues for 3 more queries at time 15, 24, and 8.
```

Note:

1. `1 <= persons.length = times.length <= 5000`
2. `0 <= persons[i] <= persons.length`
3. `times` is a strictly increasing array with all elements in `[0, 10^9]`.
4. `TopVotedCandidate.q` is called at most `10000` times per test case.
5. `TopVotedCandidate.q(int t)` is always called with `t >= times[0]`.

#### Here’s my rejected solution

```<?php
class TopVotedCandidate {

public \$dic=[];
public \$r =[];

public \$keys = [];
/**
* @param Integer[] \$persons
* @param Integer[] \$times
*/
function __construct(\$persons, \$times) {
\$max = 0;
\$prev_person = null;
for(\$i = 0; \$i < count(\$times); \$i ++){
\$this->inc(\$persons[\$i]);
arsort(\$this->\$dic);

foreach(\$this->\$dic as \$k=>\$v){
\$max_this_round = \$k;
break;
}
\$person_this_round = \$persons[\$i];

if(\$i > 0){
if(\$max_this_round === \$max){
\$person_this_round = \$prev_person;
}
}
echo \$person_this_round;
\$this->\$r[\$times[\$i]] = \$person_this_round;
\$max = \$max_this_round;
\$prev_person = \$persons[\$i];
}
var_dump(\$this->\$r);
ksort(\$this->\$r);
var_dump(\$this->\$r);
\$this->\$keys = array_keys(\$this->\$r);

}

/**
* @param Integer \$t
* @return Integer
*/
function q(\$t) {
\$k =  \$this->binarySearch(\$t);
return \$this->\$r[\$k];
}

function inc(\$p){
if(isset(\$this->\$dic[\$p])){
\$this->\$dic[\$p] ++;
} else {
\$this->\$dic[\$p] = 1;
}
}

function binarySearch(\$x) {
\$arr =  \$this->\$keys;
\$low = 0;
\$high = count(\$arr) - 1;

while (\$low <= \$high) {

// compute middle index
\$mid = floor((\$low + \$high) / 2);

// element found at mid
if(\$arr[\$low] <= \$x && \$arr[\$mid] >= \$x &&  \$mid - \$low <= 1) {
return \$low;
}

if (\$x < \$arr[\$mid]) {
// search the left side of the array
\$high = \$mid -1;
}
else {
// search the right side of the array
\$low = \$mid + 1;
}
echo "\$low-\$mid-\$high\n";
}

return false;
}
}

/**
* Your TopVotedCandidate object will be instantiated and called as such:
* \$obj = TopVotedCandidate(\$persons, \$times);
* \$ret_1 = \$obj->q(\$t);
*/

?>```

Here are the problems:

• Just like the previous problem, my PHP syntax is wrong,  and the prev problem is accepted.  I didn’t even ever question about the syntax
• And I wasted too much time on debugging, caused by syntax.
• And my modified binary search isn’t working
• And yes, that’s totally a mess

#### Here’s the my accepted solution

```<?php
class TopVotedCandidate {

public \$dic=[];
public \$r =[];

public \$keys = [];
/**
* @param Integer[] \$persons
* @param Integer[] \$times
*/
function __construct(\$persons, \$times) {
\$prev_max = 0;
\$prev_winner = null;

for(\$i = 0; \$i < count(\$times); \$i ++){
\$this->inc(\$persons[\$i]);

arsort(\$this->dic);

reset(\$this->dic);
\$winner = key(\$this->dic);

\$max = \$this->dic[\$winner];
if(\$prev_winner !== null){
if(\$max == \$prev_max){
\$winner = \$prev_winner;
}
}
if(\$this->dic[\$persons[\$i]] == \$this->dic[\$winner]){
\$winner = \$persons[\$i];
}

\$prev_max = max(\$prev_max, \$max);
\$prev_winner = \$winner;
\$this->r[\$times[\$i]] = \$winner;

}
ksort(\$this->r);
\$this->keys = array_keys(\$this->r);

}

/**
* @param Integer \$t
* @return Integer
*/
function q(\$t) {
\$k =  \$this->binarySearch(\$t);
echo "\$t => \$k";
return \$this->r[\$k];
}

function inc(\$p){
if(isset(\$this->dic[\$p])){
\$this->dic[\$p] ++;
} else {
\$this->dic[\$p] = 1;
}
}

// This is a modified binary search, finding the nearest smaller index
// just like floorKey in Java's TreeMap
function binarySearch(\$x) {
\$arr =  \$this->keys;
\$low = 0;
\$high = count(\$arr) - 1;

if(\$x < \$arr[\$low]){
return false;
}

while (\$high >= \$low) {
\$mid = \$low + floor((\$high - \$low) / 2);

if(\$x >= \$arr[\$high]){
return (int) \$arr[\$high];
}

if(\$arr[\$mid] == \$x) {
return (int) \$arr[\$mid];
}

if (\$x < \$arr[\$mid]) {
\$high = \$mid-1;
} else {
\$low = \$mid+1;
}

}
return (int) \$arr[\$low-1];

}
}
?>
/**
* Your TopVotedCandidate object will be instantiated and called as such:
* \$obj = TopVotedCandidate(\$persons, \$times);
* \$ret_1 = \$obj->q(\$t);
*/```

## 1094. Car Pooling

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:

#### 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;
}
}

?>```

## 1100. Find K-Length Substrings With No Repeated Characters

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

Example 1:

Input:

```S = "havefunonleetcode", K = 5
```

Output:

```6
```

Explanation:

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

Example 2:

Input:

```S = "home", K = 5
```

Output:

```0
```

Explanation:

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

Note:

1. `1 <= S.length <= 10^4`
2. All characters of S are lowercase English letters.
3. `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;
}
}
?>```

## 917. Reverse Only Letters

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:

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

Straightforward solution.

1. collect letters in reverse order.
2. go through string from beginning, if it’s letter, replace with letter from reverse string, else keep special chars and adjust pointer accordingly
3. 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;
}
}

?>```

## 7. Reverse Integer

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

Example 1:

Input:

``` 123
```

Output:

``` 321
```

Example 2:

Input:

``` -123
```

Output:

``` -321
```

Example 3:

Input:

``` 120
```

Output:

``` 21
```

Note:
Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231,  231 − 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;
}
}```

## 9. Palindrome Number

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

Example 1:

Input:

``` 121
```

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:

``` 10
```

Output:

``` false
```

Explanation:

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

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)

## 24. Swap Nodes in Pairs

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
*/
if(\$head === null || \$head->next === null){
}

\$temp = \$r->next;
\$r->next ->next = \$this->swapPairs(\$temp);
return \$r;
}
}```

## 26. Remove Duplicates from Sorted Array

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;
}
}```