Added racket

Author: javadev

src/main/racket/g0001_0100/s0064_minimum_path_sum/readme.md

@@ -0,0 +1,87 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 64\. Minimum Path Sum
+
+Medium
+
+Given a `m x n` `grid` filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.
+
+**Note:** You can only move either down or right at any point in time.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/05/minpath.jpg)
+
+**Input:** grid = \[\[1,3,1],[1,5,1],[4,2,1]]
+
+**Output:** 7
+
+**Explanation:** Because the path 1 → 3 → 1 → 1 → 1 minimizes the sum.
+
+**Example 2:**
+
+**Input:** grid = \[\[1,2,3],[4,5,6]]
+
+**Output:** 12
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 200`
+*   `0 <= grid[i][j] <= 100`
+
+## Solution
+
+```racket
+; dynamic programming helper function
+(define (mpsAux grid curpos dpTable ub)
+	(local
+		[(define (get grid pos) (list-ref (list-ref grid (car pos)) (cdr pos)))]
+		(cond
+			; return start value
+			[(equal? curpos (cons 0 0)) (car (car grid))]
+
+			; handle out of bounds
+			[(or (< (car curpos) 0) (< (cdr curpos) 0)) +inf.0]
+
+			; position appeared before
+			[(hash-ref dpTable curpos #f) (hash-ref dpTable curpos)]
+
+			; inductive case
+			[else
+				(let*
+					(
+						; go up
+						[u_val (mpsAux grid (cons (- (car curpos) 1) (cdr curpos)) dpTable ub)]
+
+						; go left 
+						[l_val (mpsAux grid (cons (car curpos) (- (cdr curpos) 1)) dpTable ub)]
+
+						; compute the current least cost
+						[cur-least-cost (+ (get grid curpos) (min u_val l_val))]
+					)
+					(hash-set! dpTable curpos cur-least-cost)
+					cur-least-cost
+				)
+			]
+		)
+	)
+)
+
+; the (x . y) position of the grid is the x'th row and y'th column of the grid
+(define/contract (min-path-sum grid)
+	(-> (listof (listof exact-integer?)) exact-integer?)
+	(local
+		[(define dpTable (make-hash))]
+		(let*
+			(
+				[curpos (cons (- (length grid) 1) (- (length (car grid)) 1))]
+				[least-val (mpsAux grid curpos dpTable 200)]
+			)
+			(inexact->exact least-val)
+		)
+	)
+)
+```

src/main/racket/g0001_0100/s0070_climbing_stairs/readme.md

@@ -0,0 +1,80 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 70\. Climbing Stairs
+
+Easy
+
+You are climbing a staircase. It takes `n` steps to reach the top.
+
+Each time you can either climb `1` or `2` steps. In how many distinct ways can you climb to the top?
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 2
+
+**Explanation:** There are two ways to climb to the top. 
+
+1. 1 step + 1 step 
+
+2. 2 steps
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Explanation:** There are three ways to climb to the top. 
+
+1. 1 step + 1 step + 1 step 
+
+2. 1 step + 2 steps 
+
+3. 2 steps + 1 step
+
+**Constraints:**
+
+*   `1 <= n <= 45`
+
+## Solution
+
+```racket
+(define (clmHelp n hTable)
+	(cond
+		; base cases
+		((= 1 n) 1)
+		((= 2 n) 2)
+		((hash-ref hTable n #f) (hash-ref hTable n))
+
+		; inductive case
+		(else
+			(let*
+				; the local variables
+				(
+					(a (clmHelp (- n 1) hTable))
+					(b (clmHelp (- n 2) hTable))
+					(numPos (+ a b))
+				)
+
+				; the body
+				(hash-set! hTable n numPos)
+				numPos
+			)
+		)
+	)
+)
+
+(define/contract (climb-stairs n)
+	(-> exact-integer? exact-integer?)
+	(local
+		; local definitions
+		((define hTable (make-hash)))
+
+		; function body
+		(clmHelp n hTable)
+	)
+)
+```

src/main/racket/g0001_0100/s0072_edit_distance/readme.md

@@ -0,0 +1,76 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 72\. Edit Distance
+
+Hard
+
+Given two strings `word1` and `word2`, return _the minimum number of operations required to convert `word1` to `word2`_.
+
+You have the following three operations permitted on a word:
+
+*   Insert a character
+*   Delete a character
+*   Replace a character
+
+**Example 1:**
+
+**Input:** word1 = "horse", word2 = "ros"
+
+**Output:** 3
+
+**Explanation:** 
+
+horse -> rorse (replace 'h' with 'r') 
+
+rorse -> rose (remove 'r') 
+
+rose -> ros (remove 'e')
+
+**Example 2:**
+
+**Input:** word1 = "intention", word2 = "execution"
+
+**Output:** 5
+
+**Explanation:** 
+
+intention -> inention (remove 't') 
+
+inention -> enention (replace 'i' with 'e') 
+
+enention -> exention (replace 'n' with 'x') 
+
+exention -> exection (replace 'n' with 'c') 
+
+exection -> execution (insert 'u')
+
+**Constraints:**
+
+*   `0 <= word1.length, word2.length <= 500`
+*   `word1` and `word2` consist of lowercase English letters.
+
+## Solution
+
+```racket
+(define/contract (min-distance word1 word2)
+  (-> string? string? exact-integer?)
+  (let* ((n1 (string-length word1))
+         (n2 (string-length word2)))
+    (if (> n2 n1)
+        (min-distance word2 word1)
+        (let ((dp (make-vector (+ n2 1) 0)))
+          (for ([j (in-range (+ n2 1))])
+            (vector-set! dp j j))
+          (for ([i (in-range 1 (+ n1 1))])
+            (let ((pre (vector-ref dp 0)))
+              (vector-set! dp 0 i)
+              (for ([j (in-range 1 (+ n2 1))])
+                (let* ((tmp (vector-ref dp j))
+                       (cost (if (char=? (string-ref word1 (- i 1)) (string-ref word2 (- j 1)))
+                                 pre
+                                 (+ 1 (min pre (vector-ref dp j) (vector-ref dp (- j 1)))))))
+                  (vector-set! dp j cost)
+                  (set! pre tmp)))))
+          (vector-ref dp n2)))))
+```

src/main/racket/g0001_0100/s0074_search_a_2d_matrix/readme.md

@@ -0,0 +1,42 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 74\. Search a 2D Matrix
+
+Medium
+
+Write an efficient algorithm that searches for a value `target` in an `m x n` integer matrix `matrix`. This matrix has the following properties:
+
+*   Integers in each row are sorted from left to right.
+*   The first integer of each row is greater than the last integer of the previous row.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/05/mat.jpg)
+
+**Input:** matrix = \[\[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
+
+**Output:** true
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/10/05/mat2.jpg)
+
+**Input:** matrix = \[\[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
+
+**Output:** false
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= m, n <= 100`
+*   <code>-10<sup>4</sup> <= matrix[i][j], target <= 10<sup>4</sup></code>
+
+## Solution
+
+```racket
+(define/contract (search-matrix matrix target)
+  (-> (listof (listof exact-integer?)) exact-integer? boolean?)
+  (not (equal? #f (member target (apply append matrix)))))
+```