C++/2108.cpp

@@ -9,19 +9,19 @@ using std::string;
 class Solution {
 public:
     string firstPalindrome(vector<string>& words) {
-        auto isPalindrome = [](string s) {
-            unsigned int i = 0;
-            unsigned int j = s.size() - 1;
-            while ( j > i ) {
-                if ( s[i] != s[j] ) { return false; }
-                ++i; --j;
-            }
-            return true;
-        };
         auto len = words.size();
         auto i = len;
         for ( i = 0; i < len; ++i ) {
-            if ( isPalindrome(words[i]) ) { return words[i]; }
+            string s = words[i];
+            unsigned int slen = (unsigned int)s.length() - 1;
+            unsigned int end = ((unsigned int) (slen / 2)) + 1;
+
+            for ( unsigned int j = 0; j < end; ++j ) {
+                if ( s[j] != s[slen-j] ) { goto outer; }
+            }
+
+            return s;
+        outer: ;
         }
         return "";
     }

C/1260.c

@@ -0,0 +1,155 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * Return an array of arrays of size *returnSize.
+ * The sizes of the arrays are returned as *returnColumnSizes array.
+ * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ */
+int**
+shiftGrid(int** grid, int gridSize, int* gridColSize, int k, int* returnSize,
+          int** returnColumnSizes)
+{
+    int **ret = calloc(gridSize + 1, sizeof(int*));
+
+    long total_size = 0;
+
+    *returnSize = gridSize;
+    *returnColumnSizes = calloc(gridSize + 1, sizeof(int));
+    for ( int i = 0; i < gridSize; ++i ) {
+        int col_size = gridColSize[i];
+
+        (*returnColumnSizes)[i] = col_size;
+        ret[i] = calloc(col_size + 1, sizeof(**ret));
+
+        total_size += col_size;
+    }
+
+    int *intermed = calloc(total_size + 1, sizeof(int));
+    long intermed_size = 0;
+
+    for ( int i = 0; i < gridSize; ++i ) {
+        int col_size = gridColSize[i];
+        for ( int j = 0; j < col_size; ++j ) {
+            intermed[intermed_size++] = grid[i][j];
+        }
+    }
+
+    for ( int i = 0; i < k; ++i ) {
+        int last = intermed[intermed_size-1];
+        for ( int j = intermed_size-1; j > 0; --j ) {
+            intermed[j] = intermed[j-1];
+        }
+        intermed[0] = last;
+    }
+
+    intermed_size = 0;
+    for ( int i = 0; i < gridSize; ++i ) {
+        int col_size = gridColSize[i];
+        for ( int j = 0; j < col_size; ++j ) {
+            ret[i][j] = intermed[intermed_size++];
+        }
+    }
+    free(intermed);
+    return ret;
+}
+
+struct matrix {
+    int **data;
+    unsigned long first_size;
+    unsigned long second_size;
+};
+
+char *
+matrix_to_cstr(const struct matrix *m)
+{
+    static char data[1024] = {0};
+    static unsigned long cap = 1024;
+
+    unsigned long size = 0;
+
+    memset(data, 0, cap);
+
+    data[size++] = '[';
+    for ( unsigned long i = 0; i < m->first_size; ++i ) {
+        if ( i == 0 ) {
+            data[size++] = '[';
+        } else {
+            data[size++] = ',';
+            data[size++] = '[';
+        }
+        for ( unsigned long j = 0; j < m->second_size; ++j ) {
+            if ( j == 0 ) {
+                data[size++] = m->data[i][j] + 48;
+            } else {
+                data[size++] = ',';
+                data[size++] = m->data[i][j] + 48;
+            }
+        }
+        data[size++] = ']';
+    }
+
+    data[size++] = ']';
+    data[size++] = '\0';
+
+    char *ret = calloc(size+1, sizeof(char));
+    memcpy(ret, data, size);
+
+    return ret;
+}
+
+
+void
+r(const struct matrix *m, int k, const struct matrix *exp)
+{
+
+    (void) exp;
+    struct matrix ret = *m;
+    int t1;
+    int *t2 = NULL;
+    int sizes[m->first_size];
+    for ( unsigned long i = 0; i < m->first_size; ++i ) {
+        sizes[i] = m->second_size;
+    }
+    ret.data = shiftGrid(m->data, m->first_size, sizes, k, &t1, &t2);
+    char *m_cstr = matrix_to_cstr(m);
+    char *ret_cstr = matrix_to_cstr(&ret);
+    char *exp_cstr = matrix_to_cstr(exp);
+    printf("shiftGrid(%s, %d) = %s | exp: %s\n", m_cstr, k, ret_cstr, exp_cstr);
+
+    free(m_cstr);
+    free(ret_cstr);
+    free(exp_cstr);
+    free(t2);
+    for ( unsigned long i = 0; i < m->first_size; ++i ) {
+        free(ret.data[i]);
+    }
+    free(ret.data);
+}
+
+int
+main(void)
+{
+    int in11[] = {1,2,3};
+    int in12[] = {4,5,6};
+    int in13[] = {7,8,9};
+    int *in1[] = {in11,in12,in13};
+    struct matrix min1 = {in1, 3, 3};
+    int exp11[] = {9,1,2};
+    int exp12[] = {3,4,5};
+    int exp13[] = {6,7,8};
+    int *exp1[] = {exp11,exp12,exp13};
+    struct matrix mexp1 = {exp1, 3, 3};
+    r(&min1, 1, &mexp1);
+
+    int in21[] = {1};
+    int *in2[] = {in21};
+    struct matrix min2 = {in2, 1, 1};
+    int exp21[] = {1};
+    int *exp2[] = {exp21};
+    struct matrix mexp2 = {exp2, 1, 1};
+    r(&min2, 100, &mexp2);
+
+    return 0;
+}

C/2788.c

@@ -0,0 +1,83 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+char**
+splitWordsBySeparator(char** words, int wordsSize, char separator,
+                      int* returnSize)
+{
+    struct {
+        char **data;
+        unsigned long cap;
+        unsigned long size;
+    } ret = {0};
+    char buf[21] = {0};
+
+    ret.cap = wordsSize;
+    for ( int i = 0; i < wordsSize; ++i ) {
+        char *cstr = words[i];
+        while ( *cstr != '\0' ) {
+            ret.cap += ( *cstr == separator );
+            ++cstr;
+        }
+    }
+    ret.data = malloc((ret.cap+1) * sizeof(*ret.data));
+    memset(ret.data, 0, (ret.cap+1) * sizeof(*ret.data));
+
+    ret.size = 0;
+    for ( int i = 0; i < wordsSize; ++i ) {
+        unsigned long wsize = 0;
+
+        char *cstr = words[i];
+        while ( *cstr != '\0' ) {
+            if ( *cstr == separator ) {
+                ++cstr;
+                if ( wsize == 0 ) { continue; }
+                ret.data[ret.size] = calloc(wsize + 1, sizeof(char));
+                memcpy(ret.data[ret.size], buf, wsize);
+                ++ret.size;
+                wsize = 0;
+                continue;
+            }
+            buf[wsize++] = *cstr;
+            ++cstr;
+        }
+
+        if ( wsize == 0 ) { continue; }
+        ret.data[ret.size] = calloc(wsize + 1, sizeof(char));
+        memcpy(ret.data[ret.size], buf, wsize);
+        ++ret.size;
+    }
+
+    *returnSize = ret.size;
+    return ret.data;
+}
+
+void
+r(char **ws, int s, char sep)
+{
+    int ret_size = 0;
+    char **retorig = splitWordsBySeparator(ws, s, sep, &ret_size);
+    printf("RetSize = %d\n", ret_size);
+    if ( retorig == NULL ) return;
+    char **ret = retorig;
+
+    printf("Ret = [");
+    while ( *ret != NULL ) {
+        printf("\"%s\", ", *ret);
+        free(*ret++);
+    }
+    printf("]\n");
+    free(retorig);
+}
+
+int
+main(void)
+{
+    char *words[] = {"one.two.three","four.five","six"};
+    r(words, 3, '.');
+    return 0;
+}

C/build.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+newest_file="$(find ./ -type f -printf "%T@ %p\n" | sort -n | cut -d' ' -f 2- | tail -n 1)"
+
+set -x
+gcc -std=c99 -O0 -ggdb -Wall -Wextra -Werror --sanitize=address $newest_file -o /tmp/out || exit 1
+/tmp/out

Go/897.go

@@ -0,0 +1,73 @@
+package main;
+
+import (
+	"os"
+	"fmt"
+)
+
+type TreeNode struct {
+    Val int
+    Left *TreeNode
+    Right *TreeNode
+}
+
+func (tn *TreeNode) Dump() string {
+	l := "nil"
+	if tn.Left != nil { l = tn.Left.Dump()}
+	r := "nil"
+	if tn.Right != nil { r = tn.Right.Dump()}
+	return fmt.Sprintf("TreeNode(%v, %s, %s)", tn.Val, l, r)
+}
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func increasingBST(root *TreeNode) *TreeNode {
+	var vals []int
+
+	var getVals func(r *TreeNode) []int
+	getVals = func(r *TreeNode) []int {
+		if r == nil { return []int{} }
+		var vs []int = []int{ r.Val }
+		vs = append(vs, getVals(r.Left)[:]...)
+		vs = append(vs, getVals(r.Right)[:]...)
+		return vs
+	}
+
+	vals = getVals(root)
+	for {
+		var changed bool = false
+		for i := range (len(vals)-1) {
+			if vals[i] > vals[i+1] {
+				vals[i+1], vals[i] = vals[i], vals[i+1]
+				changed = true
+			}
+		}
+		if changed == false { break }
+	}
+
+	var ret TreeNode
+
+	var tail *TreeNode = &ret
+
+	for i, v := range vals {
+		tail.Val = v
+		if i < (len(vals) - 1) { tail.Right = &(TreeNode {}) }
+		tail = tail.Right
+	}
+
+	return &ret
+}
+
+func main() {
+	r := TreeNode { 5, &(TreeNode {1, nil, nil}), &(TreeNode {7, nil, nil})}
+	t := increasingBST(&r)
+	fmt.Println(r.Dump())
+	fmt.Println(t.Dump())
+	os.Exit(0)
+}

PHP/2315.php

@@ -0,0 +1,31 @@
+<?php
+
+class Solution {
+    /**
+     * @param String $s
+     * @return Integer
+     */
+    function countAsterisks($s) {
+        $in = false;
+        $count = 0;
+        foreach ( str_split($s) as $c ) {
+            if ( $c == '|' ) { $in = !$in; }
+            if ( $in == false && $c == '*' ) { ++$count; }
+        }
+        return $count;
+    }
+}
+
+function main() {
+    function r($s) {
+        $S = new Solution;
+        $t = $S->countAsterisks($s);
+        echo "Solution().countAsterisks(\"$s\") = $t\n";
+    }
+
+    r("l|*e*et|c**o|*de|");
+    r("iamprogrammer");
+    r("yo|uar|e**|b|e***au|tifu|l");
+}
+
+main();

PHP/build.sh

@@ -0,0 +1,4 @@
+newest_file="$(find ./ -type f -printf "%T@ %p\n" | sort -n | cut -d' ' -f 2- | tail -n 1)"
+
+set -x
+php $newest_file

README.md

@@ -0,0 +1,10 @@
+# LeetCode Solutions
+
+This repo holds all the code of the solution of the problems from [LeetCode](leetcode.com)
+
+# Structure
+
+Every directory in the root of the repo denotes languages that the solutions
+inside used.
+
+The source code file name is always `<problem_number>.<language_ext>`.

Racket/2670.rkt

@@ -0,0 +1,29 @@
+#lang racket
+
+(define/contract (distinct-difference-array nums)
+  (-> (listof exact-integer?) (listof exact-integer?))
+  (let
+    ([len (length nums)])
+    (for/list
+      ([i (in-range len)])
+      (let
+        ([head (remove-duplicates (take nums (+ i 1)))]
+         [tail (remove-duplicates (drop nums (+ i 1)))])
+        (- (length head) (length tail))
+        )
+     )
+    )
+  )
+
+(define (main)
+  (define (r l e)
+    (printf
+      "(distinct-difference-array ~a) = ~a | Exp: ~a\n"
+      l (distinct-difference-array l) e
+      )
+    )
+  (r '(1 2 3 4 5) '(-3 -1 1 3 5))
+  (r '(3 2 3 4 2) '(-2 -1 0 2 3))
+  )
+
+(main)

Racket/3065.rkt

@@ -0,0 +1,20 @@
+#lang racket
+
+(define/contract (min-operations nums k)
+  (-> (listof exact-integer?) exact-integer? exact-integer?)
+  (length (filter (lambda (x) (< x k)) nums))
+  )
+
+(define (main)
+  (define (r l k e)
+    (printf
+      "(min-operations ~a ~a) = ~a | Exp: ~a\n"
+      l k (min-operations l k) e
+      )
+    )
+  (r '(2 11 10 1 3) 10 3)
+  (r '(1 1 2 4 9) 1 0)
+  (r '(1 1 2 4 9) 9 4)
+  )
+
+(main)

Racket/908.rkt

@@ -0,0 +1,33 @@
+#lang racket
+
+(define/contract (smallest-range-i nums k)
+  (-> (listof exact-integer?) exact-integer? exact-integer?)
+  (if (<= (length nums) 1) 0
+    (let ([mi (apply min nums)]
+          [ma (apply max nums)])
+      (for*/fold
+        ([c ma])
+        ([i (in-range (+ k 1))]
+         [j (in-range (+ k 1))])
+        (min c (abs (- (- ma i) (+ mi j))))
+        )
+      )
+    )
+  )
+
+(define (main)
+  (define (r l k e)
+    (display
+      (format
+        "(smallest-range-i ~a ~a) = ~a | Exp: ~a\n"
+        l k (smallest-range-i l k) e
+        )
+      )
+    )
+  (r '(1) 0 0)
+  (r '(0 10) 2 6)
+  (r '(1 3 6) 3 0)
+  (r '(506 4763 8681 4243 4040 8587 9235 442 1865 2820) 5899 0)
+  )
+
+(main)

Racket/build.sh

@@ -0,0 +1,4 @@
+newest_file="$(find ./ -type f -printf "%T@ %p\n" | sort -n | cut -d' ' -f 2- | tail -n 1)"
+
+set -x
+racket $newest_file

Ruby/268.rb

@@ -0,0 +1,32 @@
+# 268. Missing Number
+
+# @param {Integer[]} nums
+# @return {Integer}
+def missing_number(nums)
+  ns = nums.size()
+
+  nums = nums.sort()
+
+  i = 0
+  while i < ns
+    return i if nums[i] != i
+    i += 1
+  end
+  return ns
+end
+
+def main()
+  def r(n, exp)
+    puts "missing_number(#{n}) = #{missing_number(n)} | exp: #{exp}"
+  end
+
+  r([3,0,1], 2)
+  r([0,1], 2)
+  r([9,6,4,2,3,5,7,0,1], 8)
+
+end
+
+
+if __FILE__ == $0
+  main()
+end

TypeScript/169.ts

@@ -0,0 +1,29 @@
+// 169. Majority Element
+
+function majorityElement(nums: number[]): number {
+    var ns: number = nums.length;
+    var ns_half: number = ns / 2;
+
+    nums.sort((a, b) => a - b);
+
+    var count: number = 0;
+    var ln: number = nums[0];
+    for ( var i = 0; i < ns; ++i ) {
+        if ( ln != nums[i] ) { count = 0; }
+        ln = nums[i];
+        ++count;
+        if ( count > ns_half ) { return ln; }
+    }
+    return -1;
+};
+
+function main() {
+    function r(n: number[], exp: number) {
+        console.log(`majorityElement(${n}) = ${majorityElement(n)} | exp: ${exp}`)
+    }
+
+    r([3,2,3], 3)
+    r([2,2,1,1,1,2,2], 2)
+}
+
+main()

language_chooser.sh

@@ -1,15 +1,23 @@
 #!/bin/sh
 
 
-languages="C++
-Python
-TypeScript
-C
-Go
-Ruby
-PHP
-Elixir
-Erlang
-Racket"
-
-echo "$languages" | shuf | head -n5
+#languages="C++
+#Python
+#TypeScript
+#C
+#Go
+#Ruby
+#PHP
+#Racket"
+#
+#echo "$languages" | shuf | head -n5
+
+lang_frek="$(find . -maxdepth 1 -mindepth 1 -not -path './.git' -type d \
+    | parallel -j1 'find {} -maxdepth 1 -mindepth 1 -type f | wc -l | xargs echo {}' \
+    | sort -k2)"
+
+lest_amount="$(echo "$lang_frek" | head -n1 | cut -d' ' -f2)"
+
+possibles="$(echo "$lang_frek" | grep "$lest_amount" | sed "s/ ${lest_amount}//g")"
+
+echo "$possibles" | shuf | head -n5