Renamed packages

.github/workflows/php.yml

@@ -12,14 +12,14 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Validate composer.json and composer.lock
         run: composer validate --strict
 
       - name: Cache Composer packages
         id: composer-cache
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: vendor
           key: ${{ runner.os }}-php-${{ hashFiles('**/composer.lock') }}
@@ -31,6 +31,3 @@ jobs:
       - name: Run test suite
         run: vendor/bin/phpunit
 
-      - name: phpunit-coverage-badge
-        uses: timkrase/[email protected]
-

composer.json

@@ -4,7 +4,12 @@
   "license": "MIT",
   "autoload": {
     "psr-4": {
-      "Javadev\\LeetCodePhp\\": ""
+      "\\": "src/Algorithms/s0001_two_sum"
+    }
+  },
+  "autoload-dev": {
+    "psr-4": {
+      "\\": "tests"
     }
   },
   "authors": [

phpunit.xml.dist

@@ -9,6 +9,14 @@
         convertWarningsToExceptions="true"
         processIsolation="false"
         stopOnFailure="false">
+    <coverage includeUncoveredFiles="true" processUncoveredFiles="true">
+        <include>
+            <directory suffix=".php">./tests</directory>
+        </include>
+        <report>
+            <clover outputFile="build/logs/clover.xml"/>
+        </report>
+    </coverage>
     <testsuites>
         <testsuite name="Test Suite">
             <directory suffix=".php">./tests</directory>
@@ -17,7 +25,7 @@
 
     <filter>
         <whitelist>
-            <directory suffix=".php">./src</directory>
+            <directory suffix=".php">./tests</directory>
         </whitelist>
     </filter>
 </phpunit>

src/Algorithms/0001.two-sum/two-sum.php → src/Algorithms/s0001_two_sum/Solution.php

@@ -1,21 +1,21 @@
-class Solution {
-
-    /**
-     * @param Integer[] $nums
-     * @param Integer $target
-     * @return Integer[]
-     */
-    function twoSum($nums, $target) {
-        $map = [];
-        for ($i = 0; $i < count($nums); $i++) {
-            $map[$nums[$i]] = $i;
-        }
-        for ($i = 0; $i < count($nums); $i++) {
-            $complement = $target - $nums[$i];
-            if (array_key_exists($complement, $map) && $map[$complement] != $i) {
-                return [$i, $map[$complement] ];
-            }
-        }
-        throw new IllegalArgumentException("No two sum solution");      
-    }
+class Solution {
+
+    /**
+     * @param Integer[] $nums
+     * @param Integer $target
+     * @return Integer[]
+     */
+    function twoSum($nums, $target) {
+        $map = [];
+        for ($i = 0; $i < count($nums); $i++) {
+            $map[$nums[$i]] = $i;
+        }
+        for ($i = 0; $i < count($nums); $i++) {
+            $complement = $target - $nums[$i];
+            if (array_key_exists($complement, $map) && $map[$complement] != $i) {
+                return [$i, $map[$complement] ];
+            }
+        }
+        throw new IllegalArgumentException("No two sum solution");      
+    }
 }

src/Algorithms/s0001_two_sum/readme.md

@@ -0,0 +1,38 @@
+1\. Two Sum
+
+Easy
+
+Given an array of integers `nums` and an integer `target`, return _indices of the two numbers such that they add up to `target`_.
+
+You may assume that each input would have **_exactly_ one solution**, and you may not use the _same_ element twice.
+
+You can return the answer in any order.
+
+**Example 1:**
+
+**Input:** nums = [2,7,11,15], target = 9
+
+**Output:** [0,1]
+
+**Explanation:** Because nums[0] + nums[1] == 9, we return [0, 1]. 
+
+**Example 2:**
+
+**Input:** nums = [3,2,4], target = 6
+
+**Output:** [1,2] 
+
+**Example 3:**
+
+**Input:** nums = [3,3], target = 6
+
+**Output:** [0,1] 
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
+*   **Only one valid answer exists.**
+
+**Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>)</code> time complexity?

src/Algorithms/0002.add-two-numbers/add-two-numbers.php → src/Algorithms/s0002_add_two_numbers/Solution.php

@@ -1,35 +1,35 @@
-/**
- * Definition for a singly-linked list.
- * class ListNode {
- *     public $val = 0;
- *     public $next = null;
- *     function __construct($val) { $this->val = $val; }
- * }
- */
-class Solution {
-
-    /**
-     * @param ListNode $l1
-     * @param ListNode $l2
-     * @return ListNode
-     */
-    function addTwoNumbers($l1, $l2) {
-        $dummyHead = new ListNode(0);
-        $p = $l1; $q = $l2; $curr = $dummyHead;
-        $carry = 0;
-        while ($p != null || $q != null) {
-            $x = ($p != null) ? $p->val : 0;
-            $y = ($q != null) ? $q->val : 0;
-            $sum = $carry + $x + $y;
-            $carry = intval($sum / 10);
-            $curr->next = new ListNode($sum % 10);
-            $curr = $curr->next;
-            if ($p != null) $p = $p->next;
-            if ($q != null) $q = $q->next;
-        }
-        if ($carry > 0) {
-            $curr->next = new ListNode($carry);
-        }
-        return $dummyHead->next;
-    }
+/**
+ * Definition for a singly-linked list.
+ * class ListNode {
+ *     public $val = 0;
+ *     public $next = null;
+ *     function __construct($val) { $this->val = $val; }
+ * }
+ */
+class Solution {
+
+    /**
+     * @param ListNode $l1
+     * @param ListNode $l2
+     * @return ListNode
+     */
+    function addTwoNumbers($l1, $l2) {
+        $dummyHead = new ListNode(0);
+        $p = $l1; $q = $l2; $curr = $dummyHead;
+        $carry = 0;
+        while ($p != null || $q != null) {
+            $x = ($p != null) ? $p->val : 0;
+            $y = ($q != null) ? $q->val : 0;
+            $sum = $carry + $x + $y;
+            $carry = intval($sum / 10);
+            $curr->next = new ListNode($sum % 10);
+            $curr = $curr->next;
+            if ($p != null) $p = $p->next;
+            if ($q != null) $q = $q->next;
+        }
+        if ($carry > 0) {
+            $curr->next = new ListNode($carry);
+        }
+        return $dummyHead->next;
+    }
 }

src/Algorithms/s0002_add_two_numbers/readme.md

@@ -0,0 +1,35 @@
+2\. Add Two Numbers
+
+Medium
+
+You are given two **non-empty** linked lists representing two non-negative integers. The digits are stored in **reverse order**, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg)
+
+**Input:** l1 = [2,4,3], l2 = [5,6,4]
+
+**Output:** [7,0,8]
+
+**Explanation:** 342 + 465 = 807. 
+
+**Example 2:**
+
+**Input:** l1 = [0], l2 = [0]
+
+**Output:** [0] 
+
+**Example 3:**
+
+**Input:** l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+
+**Output:** [8,9,9,9,0,0,0,1] 
+
+**Constraints:**
+
+*   The number of nodes in each linked list is in the range `[1, 100]`.
+*   `0 <= Node.val <= 9`
+*   It is guaranteed that the list represents a number that does not have leading zeros.

src/Algorithms/0003.longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.php → src/Algorithms/s0003_longest_substring_without_repeating_characters/Solution.php

@@ -1,20 +1,20 @@
-class Solution {
-
-    /**
-     * @param String $s
-     * @return Integer
-     */
-    function lengthOfLongestSubstring($s) {
-        if (strlen($s)==0) return 0;
-        $map = [];
-        $max = 0;
-        for ($i=0, $j=0; $i < strlen($s); ++$i) {
-            if (array_key_exists($s[$i], $map)){
-                $j = max($j, $map[$s[$i]] + 1);
-            }
-            $map[$s[$i]] = $i;
-            $max = max($max, $i - $j + 1);
-        }
-        return $max;
-    }
+class Solution {
+
+    /**
+     * @param String $s
+     * @return Integer
+     */
+    function lengthOfLongestSubstring($s) {
+        if (strlen($s)==0) return 0;
+        $map = [];
+        $max = 0;
+        for ($i=0, $j=0; $i < strlen($s); ++$i) {
+            if (array_key_exists($s[$i], $map)){
+                $j = max($j, $map[$s[$i]] + 1);
+            }
+            $map[$s[$i]] = $i;
+            $max = max($max, $i - $j + 1);
+        }
+        return $max;
+    }
 }

src/Algorithms/s0003_longest_substring_without_repeating_characters/readme.md

@@ -0,0 +1,40 @@
+3\. Longest Substring Without Repeating Characters
+
+Medium
+
+Given a string `s`, find the length of the **longest substring** without repeating characters.
+
+**Example 1:**
+
+**Input:** s = "abcabcbb"
+
+**Output:** 3
+
+**Explanation:** The answer is "abc", with the length of 3. 
+
+**Example 2:**
+
+**Input:** s = "bbbbb"
+
+**Output:** 1
+
+**Explanation:** The answer is "b", with the length of 1. 
+
+**Example 3:**
+
+**Input:** s = "pwwkew"
+
+**Output:** 3
+
+**Explanation:** The answer is "wke", with the length of 3. Notice that the answer must be a substring, "pwke" is a subsequence and not a substring. 
+
+**Example 4:**
+
+**Input:** s = ""
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= s.length <= 5 * 10<sup>4</sup></code>
+*   `s` consists of English letters, digits, symbols and spaces.