Учитывая целочисленный массив чисел, отсортированный в неубывающем порядке, удалите дубликаты на месте так, чтобы каждый уникальный элемент появлялся только один раз. Относительный порядок элементов должен оставаться неизменным. Затем верните количество уникальных элементов в числах.

Считайте, что количество уникальных элементов чисел равно k. Чтобы вас приняли, вам нужно сделать следующее:

Измените массив nums так, чтобы первые k элементов nums содержали уникальные элементы в том порядке, в котором они присутствовали в nums изначально. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

class Solution {
  function removeDuplicates(&$nums) { $index = 1;
    for ($i = 1; $i < count($nums); $i++) {
     if($nums[$i] !== $nums[$i-1]){ 
         $nums[$index++] = $nums[$i];
     }  
    }  
      return $index;
  }
}

Учитывая целочисленный массив nums и целочисленное значение, удалите все вхождения val в nums на месте. Порядок элементов может быть изменен. Затем верните количество элементов в виде чисел, которые не равны val.

Учитывайте количество элементов в nums, которые не равны val be k. Чтобы вас приняли, вам необходимо сделать следующее:

Измените массив nums так, чтобы первые k элементов nums содержали элементы, не равные val. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

/**
 * @param Integer[] $nums * @param Integer $val
 * @return Integer
 */
function removeElement(&$a, $val) {
    $k =0; for ($i =0 ; $i < count($a);$i++){ if($a[$i] != $val){
                $a[$k] = $a[$i];
                $k++; } } return $k;
    
}       

Учитывая две строки, игла и стог сена, верните индекс первого вхождения иглы в стоге сена или -1, если игла не является частью стога сена.

class Solution {

    /**
     * @param String $haystack
     * @param String $needle
     * @return Integer
     */
    function strStr($haystack, $needle) {
        $needleLen = strlen($needle);
        $haylen = strlen($haystack);
        $start = 0;
        while (true) {
            $substring = substr($haystack, $start, $needleLen);

            if ($substring == $needle) {
                return $start;
            }
            if ($start == $haylen-1) {
                return -1;
            }

            $start++;
        }

        return -1;
    }
}

Учитывая два целых числа: делимое и делитель, разделите два целых числа, не используя операторы умножения, деления и модификатора.

Целочисленное деление должно сокращаться до нуля, что означает потерю дробной части. Например, 8,345 будет сокращено до 8, а -2,7335 будет сокращено до -2.

Возвращает частное после деления делимого на делитель.

Примечание. Предположим, мы имеем дело со средой, которая может хранить целые числа только в пределах 32-битного целого диапазона со знаком: [−2^31, 2^31 − 1]. В этой задаче, если частное строго больше 2^31 - 1, верните 2^31 - 1, а если частное строго меньше -2^31, верните -2^31.

class Solution {

    /**
     * @param Integer $dividend
     * @param Integer $divisor
     * @return Integer
     */
    function divide($dividend, $divisor) {
        $result = $dividend / $divisor;
        if(pow(2,31)-1 < $result){
            $result = pow(2,31)-1;
        }else if(pow(-2,31) > $result){
            $result = pow(-2,31);
        }
        return (int)$result;
    }
}

Вам дана строка s и массив строк-слов. Все строки слов имеют одинаковую длину.

Объединенная строка — это строка, которая в точности содержит все строки любой перестановки объединенных слов.

Например, если слова = ["ab", "cd", "ef"], то "abcdef", "abefcd", "cdabef", "cdefab", "efabcd" и "efcdab" являются объединенными строками. «acdbef» не является объединенной строкой, поскольку не является объединением какой-либо перестановки слов.
Возвращает массив начальных индексов всех объединенных подстрок в s. Вы можете вернуть ответ в любом порядке.

    $result = []; if (count($words) < 1) return $result; $strLength  = strlen($s); $wordLength = strlen($words[0]); $subLength  = $wordLength * count($words);
  
    sort($words); for ($i = 0; $i <= ($strLength-$subLength); $i++) {
  
        $strToArr = str_split(substr($s, $i, $subLength), $wordLength); sort($strToArr);
    
        if (count($words) === count($strToArr) 
        && empty(array_diff_assoc($strToArr, $words))
        ){
            $result[] = $i;
        }
    }
    return $result;
}
'''

Перестановка массива целых чисел — это расположение его членов в последовательность или линейный порядок.

Например, для arr = [1,2,3] следующие перестановки arr: [1,2,3], [1,3,2], [2, 1, 3], [2, 3, 1], [3,1,2], [3,2,1].
Следующая перестановка массива целых чисел — это следующая лексикографически большая перестановка его целого числа. Более формально, если все перестановки массива отсортированы в одном контейнере в соответствии с их лексикографическим порядком, то следующей перестановкой этого массива будет перестановка, следующая за ней в отсортированном контейнере. Если такое расположение невозможно, массив необходимо переупорядочить в наименьшем возможном порядке (т. е. отсортировать по возрастанию).

Например, следующая перестановка arr = [1,2,3] — это [1,3,2].
Аналогично, следующая перестановка arr = [2,3,1] — это [3,1,2].
А следующая перестановка arr = [3,2,1] — это [1,2,3], потому что [3,2,1] не имеет более крупной лексикографической перестановки.
Учитывая массив целых чисел nums, найдите следующую перестановку чисел.

Замена должна быть на месте и использовать только постоянную дополнительную память.

class Solution {

    /**
     * @param Integer[] $nums
     * @return NULL
     */
    function nextPermutation(&$nums) {
        if(sizeof($nums) == 1) return;
        if(sizeof($nums) == 2) return $this->swap($nums, 0, 1);
        $n = sizeof($nums);
        for($i= $n-2; $i>0; $i--){
           if( $this->checkAsc($nums, $i)){
               $this->swap($nums, $n-1, $n-2);
               return;
           }else{
               //get the next max number next to $i and place it $i pos
              if($this->getNextMax($nums, $i-1)){
                   // rearrange in asc order after $i
                   $this->arrangeAsc($nums, $i);
                   return;
               }
           }
        
        }
        sort($nums);
        return;
        
    }
    function swap(&$nums, $i, $j){
        $temp = $nums[$i];
        $nums[$i] = $nums[$j];
        $nums[$j] = $temp;
    }
    function checkAsc(&$nums, $i){
        $n = sizeof($nums);
        for($j=$n-1; $j>$i; $j--){
            if($nums[$j]<$nums[$j-1]|| $nums[$j] == $nums[$j-1])
                return false;
        }
        return true;
    }
    //get the next max after i position and swap.
    function getNextMax(&$nums, $i){
        $min = $i+1;
        for($j=$i+1; $j<=sizeof($nums)-1;$j++){
            if($nums[$j]<$nums[$min] && $nums[$j]>$nums[$i]){
                $min = $j;
            }
        }
        echo "next min is " . $nums[$min] ."<br />";
        if($nums[$min] > $nums[$i]){
            $this->swap($nums, $i, $min);
            return true;
              }

        return false;
    }
    //arrange the numbers after $i.
   function arrangeAsc(&$nums, $i){
        $n = sizeof($nums);
        for($j= $i;$j<=$n-2;$j++){
            for($k=$j+1; $k<=$n-1;$k++){
                if($nums[$j]>$nums[$k]) $this->swap($nums, $j, $k);
            }
        }
        return;
    }
}

Учитывая строку, содержащую только символы «(» и «)», верните длину самых длинных допустимых (правильно сформированных) круглых скобок.
подстрока

class Solution {

    /**
     * @param String $s
     * @return Integer
     */
    function longestValidParentheses($s) {
        $s2 = ')'.$s;
        $n = strlen($s2);
        $dp = array_fill(0, $n, 0);

        for ($i = 1; $i < $n; $i++) {
            if ($s2[$i] === ')' && $s2[$i-$dp[$i-1]-1] === '(') {
                $dp[$i] = $dp[$i-1] + $dp[$i-$dp[$i-1]-2] + 2;
            }
        }

        return max($dp);
    }
}

Существует целочисленный массив nums, отсортированный по возрастанию (с разными значениями).

Перед передачей в вашу функцию nums, возможно, поворачивается с неизвестным индексом поворота k (1 <= k < nums.length), так что результирующий массив имеет вид [nums[k], nums[k+1],... , nums[n-1], nums[0], nums[1], ..., nums[k-1]] (с индексом 0). Например, [0,1,2,4,5,6,7] можно повернуть с опорным индексом 3 и превратить в [4,5,6,7,0,1,2].

Учитывая массив nums после возможного поворота и целочисленную цель, верните индекс цели, если он находится в nums, или -1, если он не в nums.

Вы должны написать алгоритм со сложностью выполнения O(log n).

class Solution {

    /**
     * @param Integer[] $nums
     * @param Integer $target
     * @return Integer
     */
    function search($nums, $target) {
        for($i=0;$i<count($nums);$i++){
            if($nums[$i]==$target){
                return $i;
            }
            
        }
        return -1;
    }
}

Учитывая массив целых чисел, отсортированных в порядке неубывания, найдите начальную и конечную позицию заданного целевого значения.

Если цель не найдена в массиве, верните [-1, -1].

Вы должны написать алгоритм со сложностью выполнения O(log n).

class Solution {

    /**
     * @param Integer[] $nums
     * @param Integer $target
     * @return Integer[]
     */ 

    function searchRange($nums, $target) {
        $result = [];
        foreach ($nums as $key => $value) {
            if ($value === $target) {
                $result[] = $key;
            }
        }
        if(empty($result)){
            $result = [-1,-1];
            return $result;
        }else{
           return [min($result), max($result)];
        }
    }
}

Учитывая отсортированный массив различных целых чисел и целевое значение, верните индекс, если цель найдена. Если нет, верните индекс там, где он был бы, если бы он был вставлен по порядку.

Вы должны написать алгоритм со сложностью выполнения O(log n).

        foreach($nums as $key => $num){
            if($target<$num ||$target===$num){
                $target = $key;
                return $target;
            }
        }
        return sizeof($nums);