solve: 88. Merge two sorted list in Racket

C solution with XOR operator

7.reverse-integer.org

@@ -0,0 +1,179 @@
+#+title: 7 Reverse Integer
+
+* Subject
+
+Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range \([-2^{31}, 2^{31} - 1]\), then return 0.
+
+Assume the environment does not allow you to store 64-bit integers (signed or unsigned).
+
+** Example 1:
+
+Input: x = 123
+Output: 321
+
+** Example 2:
+
+Input: x = -123
+Output: -321
+
+** Example 3:
+
+Input: x = 120
+Output: 21
+
+** Constraints:
+
+    -231 <= x <= 231 - 1
+
+* Solution
+#+name: lang
+#+begin_src racket
+#lang racket
+#+end_src
+
+#+RESULTS: lang
+
+#+begin_src racket
+#lang racket/base
+(for/list ([i (in-naturals)]
+           #:break (> i 10))
+  i)
+#+end_src
+
+#+RESULTS:
+| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
+
+#+name: ten-power-below
+#+begin_src racket
+(define/contract (ten-power-below x)
+  (-> exact-integer? exact-integer?)
+  (let ((power-of-ten 1))
+    (for/list ([exponent (in-naturals)])
+               #:break (> power-of-ten x)
+               (set! power-of-ten (* 10 power-of-ten)))
+    (/ power-of-ten 10)))
+#+end_src
+
+#+RESULTS: ten-power-below
+
+
+#+begin_src racket :noweb yes
+#lang racket
+<<ten-power-below>>
+(ten-power-below 11)
+#+end_src
+
+#+RESULTS:
+: 10
+
+#+begin_src racket :noweb yes
+#lang racket
+<<ten-power-below>>
+(ten-power-below 100)
+#+end_src
+
+#+RESULTS:
+: 100
+
+#+begin_src racket :noweb yes
+#lang racket
+<<ten-power-below>>
+(ten-power-below 1111)
+#+end_src
+
+#+RESULTS:
+: 1000
+
+#+begin_src racket :noweb yes
+<<ten-power-below>>
+(for/list ([i (list 1 100 271091029 (- 123001))])
+  (ten-power-below i))
+#+end_src
+
+#+RESULTS:
+| 1 | 100 | 1000000000 | 1 |
+
+#+name: reverse
+#+begin_src racket :noweb yes
+<<ten-power-below>>
+(define/contract (reverse x)
+  (-> exact-integer? exact-integer?)
+  (cond ((= x 0) 0)
+        ((< x 0) (- (reverse (- x))))
+        (#t (let* ((remains x)
+               (previous remains)
+               (number 0)
+               (power-of-ten (ten-power-below x))
+               (current-number-power-of-ten 1)
+               (digit 0))
+          (for/list ([i (in-naturals)]
+                     #:break (< power-of-ten 1))
+            (set! previous remains)
+            (set! remains (modulo remains power-of-ten))
+            (set! digit (/ (- previous remains) power-of-ten))
+            (set! number (+ number (* digit current-number-power-of-ten)))
+            (set! power-of-ten (/ power-of-ten 10))
+            (set! current-number-power-of-ten (* current-number-power-of-ten 10))
+            )
+          number))))
+#+end_src
+
+#+RESULTS: reverse
+
+#+begin_src racket :noweb yes
+#lang racket
+<<reverse>>
+(reverse 123)
+#+end_src
+
+#+RESULTS:
+: 321
+
+#+begin_src racket :noweb yes
+#lang racket
+<<reverse>>
+(reverse 21)
+#+end_src
+
+#+RESULTS:
+: 12
+
+#+begin_src racket :noweb yes
+#lang racket
+<<reverse>>
+(reverse -1)
+#+end_src
+
+#+RESULTS:
+: -1
+
+#+begin_src racket :noweb yes
+#lang racket
+<<reverse>>
+(reverse -124)
+#+end_src
+
+#+RESULTS:
+: -421
+
+#+begin_src racket :noweb yes
+#lang racket
+<<reverse>>
+(reverse 123456789012345678901234567890)
+#+end_src
+
+#+RESULTS:
+: 98765432109876543210987654321
+
+#+begin_src racket :noweb yes
+#lang racket
+<<reverse>>
+(reverse 10)
+#+end_src
+
+#+RESULTS:
+: 1
+
+* Reference
+
+https://leetcode.com/problems/reverse-integer/

c/136.single-number/136.single-number.org

@@ -0,0 +1,65 @@
+#+title: 136 Single Number
+
+Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.
+
+You must implement a solution with a linear runtime complexity and use only constant extra space.
+
+
+
+Example 1:
+
+Input: nums = [2,2,1]
+
+Output: 1
+
+Example 2:
+
+Input: nums = [4,1,2,1,2]
+
+Output: 4
+
+Example 3:
+
+Input: nums = [1]
+
+Output: 1
+
+
+
+Constraints:
+
+    1 <= nums.length <= 3 * 104
+    -3 * 104 <= nums[i] <= 3 * 104
+    Each element in the array appears twice except for one element which appears only once.
+
+* Solution
+
+#+name: solution
+#+begin_src C
+int xor(int a, int b) {
+   return a ^ b;
+}
+
+int singleNumber(int* nums, int numsSize) {
+    int number = 0;
+    for (int i=0; i < numsSize; i++) {
+        number = xor(number, nums[i]);
+    }
+    return number;
+}
+#+end_src
+
+#+RESULTS: solution
+
+#+begin_src C :noweb yes
+#include <stdio.h>
+
+<<solution>>
+
+int numbers[3] = {1, 1, 2};
+int single = singleNumber(numbers, 3);
+printf("%d\n", single);
+#+end_src
+
+#+RESULTS:
+: -2

racket/88.merge-sorted-array.rkt

@@ -0,0 +1,20 @@
+; 88. Merge Sorted Array
+;
+; We consider that the function returns the sorted list
+; instead of overwriting the nums1 list (as specified in the subject)
+
+
+#lang racket
+
+(define/contract (merge nums1 nums2)
+  (-> (listof number?) (listof number?) (listof number?))
+  "Merge recursively two sorted lists NUMS1 and NUMS2."
+  (cond
+    [(null? nums1) nums2]
+    [(null? nums2) nums1]
+    [(< (car nums1) (car nums2))
+         (cons (car nums1) (merge (if (list? nums1) (cdr nums1) '()) nums2))]
+    [else (cons (car nums2) (merge (if (list? nums2) (cdr nums2) '()) nums1))]))
+
+(for/list ([item (merge '(1 2 3) '(1 3 5))])
+   (println item))