Merge pull request #44 from remy727/20230324

205, 392, 1466

Author: remy727

README.md

@@ -41,12 +41,14 @@
 | 121 | Best Time to Buy and Sell Stock | [Ruby](./algorithms/ruby/0121-best-time-to-buy-and-sell-stock.rb) | Easy |
 | 129 | Sum Root to Leaf Numbers | [Ruby](./algorithms/ruby/0129-sum-root-to-leaf-numbers.rb) | Medium |
 | 142 | Linked List Cycle II | [Ruby](./algorithms/ruby/0142-linked-list-cycle-ii.rb) | Medium |
+| 205 | Isomorphic Strings | [Ruby](./algorithms/ruby/0205-isomorphic-strings.rb) | Easy |
 | 208 | Implement Trie (Prefix Tree) | [Ruby](./algorithms/ruby/0208-implement-trie-prefix-tree.rb) | Medium |
 | 211 | Design Add and Search Words Data Structure | [Ruby](./algorithms/ruby/0211-design-add-and-search-words-data-structure.rb) | Medium |
 | 226 | Invert Binary Tree | [Ruby](./algorithms/ruby/0226-invert-binary-tree.rb) | Easy |
 | 344 | Reverse String | [Ruby](./algorithms/ruby/0344-reverse-string.rb) | Easy |
 | 382 | Linked List Random Node | [Ruby](./algorithms/ruby/0382-linked-list-random-node.rb) | Medium |
 | 387 | First Unique Character in a String | [Ruby](./algorithms/ruby/0387-first-unique-character-in-a-string.rb) | Easy |
+| 392 | Is Subsequence | [Ruby](./algorithms/ruby/0392-is-subsequence.rb) | Easy |
 | 427 | Construct Quad Tree | [Ruby](./algorithms/ruby/0427-construct-quad-tree.rb) | Medium |
 | 438 | Find All Anagrams in a String | [Ruby](./algorithms/ruby/0438-find-all-anagrams-in-a-string.rb) | Medium |
 | 443 | String Compression | [Ruby](./algorithms/ruby/0443-string-compression.rb) [Python3](./algorithms/python3/0443-string-compression.py) | Medium |
@@ -75,6 +77,7 @@
 | 1162 | As Far from Land as Possible | [Ruby](./algorithms/ruby/1162-as-far-from-land-as-possible.rb) | Medium |
 | 1319 | Number of Operations to Make Network Connected | [Ruby](./algorithms/ruby/1319-number-of-operations-to-make-network-connected.rb) | Medium |
 | 1345 | Jump Game IV | [Ruby](./algorithms/ruby/1345-jump-game-iv.rb) | Hard |
+| 1466 | Reorder Routes to Make All Paths Lead to the City Zero | [Ruby](./algorithms/ruby/1466-eorder-routes-to-make-all-paths-lead-to-the-city-zero.rb) | Medium |
 | 1470 | Shuffle the Array | [Ruby](./algorithms/ruby/1470-shuffle-the-array.rb) | Easy |
 | 1472 | Design Browser History | [Ruby](./algorithms/ruby/1472-design-browser-history.rb) | Medium |
 | 1480 | Running Sum of 1d Array | [Ruby](./algorithms/ruby/1480-running-sum-of-1d-array.rb) | Easy |

algorithms/ruby/0205-isomorphic-strings.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# 205. Isomorphic Strings
+# https://leetcode.com/problems/isomorphic-strings
+
+=begin
+
+Given two strings s and t, determine if they are isomorphic.
+
+Two strings s and t are isomorphic if the characters in s can be replaced to get t.
+
+All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character, but a character may map to itself.
+
+### Example 1:
+
+Input: s = "egg", t = "add"
+Output: true
+
+### Example 2:
+
+Input: s = "foo", t = "bar"
+Output: false
+
+### Example 3:
+
+Input: s = "paper", t = "title"
+Output: true
+
+### Constraints:
+
+* 1 <= s.length <= 5 * 104
+* t.length == s.length
+* s and t consist of any valid ascii character.
+
+=end
+
+# Runtime 258 ms
+# Memory 211.3 MB
+# @param {String} s
+# @param {String} t
+# @return {Boolean}
+def is_isomorphic(s, t)
+  ms = {}
+  mt = {}
+  n = s.length
+  i = 0
+
+  while i < n && ms[s[i]] == mt[t[i]]
+    ms[s[i]] = mt[t[i]] = i + 1
+    i += 1
+  end
+
+  i == n
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_is_isomorphic < Test::Unit::TestCase
+  def test_
+    assert_equal true, is_isomorphic("egg", "add")
+    assert_equal false, is_isomorphic("foo", "bar")
+    assert_equal true, is_isomorphic("paper", "title")
+  end
+end

algorithms/ruby/0392-is-subsequence.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# 392. Is Subsequence
+# https://leetcode.com/problems/is-subsequence
+
+=begin
+
+Given two strings s and t, return true if s is a subsequence of t, or false otherwise.
+
+A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).
+
+### Example 1:
+
+Input: s = "abc", t = "ahbgdc"
+Output: true
+
+### Example 2:
+
+Input: s = "axc", t = "ahbgdc"
+Output: false
+
+### Constraints:
+
+* 0 <= s.length <= 100
+* 0 <= t.length <= 104
+* s and t consist only of lowercase English letters.
+
+=end
+
+# Runtime 86 ms
+# Memory 212.1 MB
+# @param {String} s
+# @param {String} t
+# @return {Boolean}
+def is_subsequence(s, t)
+  return true if s.size == 0
+  return false if s.size > t.size
+
+  sp = 0
+  t.chars.each do |char|
+    if s[sp] == char
+      sp += 1
+      return true if sp == s.size
+    end
+  end
+
+  false
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_is_subsequence < Test::Unit::TestCase
+  def test_
+    assert_equal true, is_subsequence("abc", "ahbgdc")
+    assert_equal false, is_subsequence("axc", "ahbgdc")
+  end
+end

algorithms/ruby/1466-eorder-routes-to-make-all-paths-lead-to-the-city-zero.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# 1466. Reorder Routes to Make All Paths Lead to the City Zero
+# https://leetcode.com/problems/reorder-routes-to-make-all-paths-lead-to-the-city-zero
+
+=begin
+
+There are n cities numbered from 0 to n - 1 and n - 1 roads such that there is only one way to travel between two different cities (this network form a tree). Last year, The ministry of transport decided to orient the roads in one direction because they are too narrow.
+
+Roads are represented by connections where connections[i] = [ai, bi] represents a road from city ai to city bi.
+
+This year, there will be a big event in the capital (city 0), and many people want to travel to this city.
+
+Your task consists of reorienting some roads such that each city can visit the city 0. Return the minimum number of edges changed.
+
+It's guaranteed that each city can reach city 0 after reorder.
+
+### Example 1:
+Input: n = 6, connections = [[0,1],[1,3],[2,3],[4,0],[4,5]]
+Output: 3
+Explanation: Change the direction of edges show in red such that each node can reach the node 0 (capital).
+
+### Example 2:
+Input: n = 5, connections = [[1,0],[1,2],[3,2],[3,4]]
+Output: 2
+Explanation: Change the direction of edges show in red such that each node can reach the node 0 (capital).
+
+### Example 3:
+Input: n = 3, connections = [[1,0],[2,0]]
+Output: 0
+
+=end
+
+# Runtime 396 ms
+# Memory 234 MB
+# @param {Integer} n
+# @param {Integer[][]} connections
+# @return {Integer}
+def min_reorder(n, connections)
+  al = {}
+  connections.each do |c|
+    al[c[0]] = al[c[0]].to_a + [c[1]]
+    al[c[1]] = al[c[1]].to_a + [-c[0]]
+  end
+
+  dfs(al, [], 0)
+end
+
+def dfs(al, visited, from)
+  change = 0
+  visited[from] = true
+
+  al[from].each do |to|
+    unless visited[to.abs]
+      change += dfs(al, visited, to.abs) + (to > 0 ? 1 : 0)
+    end
+  end
+
+  change
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_min_reorder < Test::Unit::TestCase
+  def test_
+    assert_equal 3, min_reorder(6, [[0, 1], [1, 3], [2, 3], [4, 0], [4, 5]])
+    assert_equal 2, min_reorder(5, [[1, 0], [1, 2], [3, 2], [3, 4]])
+    assert_equal 0, min_reorder(3, [[1, 0], [2, 0]])
+  end
+end