Java ScheduledExecutorService

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ConcurrentStuff {

	  public static void main(String[] args) {
	    System.out.println("begin");
	    ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

	    System.out.println("scheduling a task to run after 2 seconds");
	    // Schedule a task to run after a delay of 2 seconds
	    executor.schedule(new MyTask(), 2, TimeUnit.SECONDS);

	    System.out.println("scheduling a task to delay 3 seconds then repeat every 5 seconds");
	    // Schedule a task to run after a delay of 3 seconds and repeat every 5 seconds
	    executor.scheduleAtFixedRate(new MyTask(), 3, 5, TimeUnit.SECONDS);

	    // Wait for scheduled tasks to complete
	    try {
	      System.out.println("sleeping to demo scheduling at work");
	      Thread.sleep(15000);
	    } catch (InterruptedException e) {
	      e.printStackTrace();
	    }

	    // Shutdown the executor
	    executor.shutdown();
	    System.out.println("end");
	  }

	  static class MyTask implements Runnable {
	    @Override
	    public void run() {
	      System.out.println("Task executed at: " + new java.util.Date());
	    }
	  }
}

Determinant of a matrix

This little program calculates the determinant of an matrix.. using recursion. You don't even need ad - bc for a 2x2 [[a b][c d]] https://en.wikipedia.org/wiki/Determinant

public class CodeWar {

	public static int[][] buildSubmatrix(int[][] matrix, int r, int c) {
		int size = matrix.length - 1;
		int result[][] = new int[size][size];
		int a = 0, b = 0;

		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix.length; j++) {
				if (i != 0 && j != c) {
					result[a][b] = matrix[i][j];
					b++;
				}
			}
			if (i != r) {
				a++;
				b = 0;
			}
		}
		return result;
	}


	public static int determinant(int[][] matrix) {
		if (matrix.length == 1)
			return matrix[0][0];

		int sign = 1;
		int sum = 0;
		for (int i = 0; i < matrix[0].length; i++) {
			int n = matrix[0][i];
			int submatrix[][] = buildSubmatrix(matrix, 0,i);
			sum += sign * n * determinant(submatrix);

			sign = sign * -1;
		}
		return sum;

	}

	public static void main(String arg[]) {
		int[][] matrix = { 
				{ -2, -1,2 }, 
				{ 2,1,4 }, 
				{ -3,3,1 } };
		System.out.println(determinant(matrix));
	}
}

Java: of list and set

There are multiple ways to construct a list in java. (easier in python and other languages). To eliminate duplicates, you can use the stream distinct, or put it in a set (HashSet or LinkedHashSet to retain order) then make it back to a list.

	public static void main(String arg[]) {
		
		String a[] = new String[] { "A", "B", "C", "D", "A", "C", "E" };
        List<String> list = Arrays.asList(a);  // constructed one way
        List<String> list2 = List.of(a); // constructed another way (java 9+)
        List<String> list3 = List.of( "A", "B", "C", "D", "A", "C", "E" ); // yet another way 

        // using stream distinct one way
        List<String> noDups = list.stream().distinct().collect(Collectors.toList());
        // using stream distinct another way
        List<String> noDups2 = list2.stream().distinct().toList();
        
        // put on a set and make a iist out of it
        Set<String> set = new LinkedHashSet<>(); 
        set.addAll(list3); 
        List<String> noDups3 = new ArrayList<>(set);
        
        System.out.println(noDups);
        System.out.println(noDups2);
        System.out.println(noDups3);
	}

Python linear 2x2 system

This is a fun tool for any algebra 1 student. Solve a 2x2 linear system, and graph it.

import matplotlib.pyplot as plt
import numpy as np
import math

"""
Simple little 2x2 system example:
 x + 2y = 1
 3x + 5y = 2
 
 This can be written as matrix form [A][x] = [B]:
 
 [1 2][x] =  [1]
 [3 5][y]    [2]
"""
A = np.array([[1, 2], 
              [3, 5]])
B = np.array([1, 2])

XMIN, XMAX = -5, 5
YMIN, YMAX = -5, 5
GRIDSIZE = 1

STEPS = 101


a11 = A[0][0];
a12 = A[0][1];
a21 = A[1][0];
a22 = A[1][1];
b11 = B[0];
b12 = B[1];

def f(x):
    return (-a11*x+b11)/a12

def g(x):
    return (-a21*x+b12)/a22

x = np.linspace(XMIN,XMAX,STEPS)
plt.axis([XMIN,XMAX,YMIN,YMAX]) 

y1v = np.zeros(len(x))
y2v = np.zeros(len(x))
for i in range(len(x)):
    try: 
        y1v[i] = f(x[i])
        y2v[i] = g(x[i])
    except:
        pass

try:
    solution = np.linalg.solve(A, B)
    print("Solution")
    print(solution)
    solutionpoint =  "(${0:.2f}, ${1:.2f})".format(solution[0], solution[1]);
    plt.plot(solution[0],solution[1],'bo'); # blue circle
    plt.annotate( solutionpoint,(solution[0],solution[1]));
except:
    print("No solution")
    
eq1 = "{0}x+{1}y={2}".format(a11,a12,b11);
eq2 = "{0}x+{1}y={2}".format(a21,a22,b12);
plt.plot(x,y1v, color='r',label=eq1)
plt.plot(x,y2v, color='g',label=eq2)


# make axes
plt.axhline(y=0, color='k') # 'k' means black
plt.axvline(x=0, color='k')
# gca is get current axes 
plt.gca().set_aspect('equal')
plt.gca().set_xticks(np.arange(XMIN,XMAX,GRIDSIZE))
plt.gca().set_yticks(np.arange(YMIN,YMAX,GRIDSIZE))
plt.grid(True)
plt.legend() 
plt.show()

Python linear algebra

Every algebra 1 student should learn about solving a system of 2 equations and 2 unknowns. Then they will learn about 3 by 3... then gosh n by n. There is gotta be easier way to do this than combining equations, well yes there is, enter linear algebra. But solving a linear system of equation is still hard to do by hand, painful to punch it on your calculator too. Enter computer programming! Python can effortless do this with the Numpy library. Programming this from scratch is not a very pleasant programming task.

import numpy as np
 
"""
Simple little 2x2 system example:
 x + 2y = 1
 3x + 5y = 2
 
 This can be written as matrix form [A][x] = [B]:
 
 [1 2][x] =  [1]
 [3 5][y]    [2]
 
 
 So the solution is inv(A)B
 
 Inverse matrix is painful to do by hand, but numpy can do it easy,
 It even has a solve method
 """
 
A = np.array([[1, 2], 
              [3, 5]])
B = np.array([1, 2])

Ainv = np.linalg.inv(A)
solution = np.matmul(Ainv,B)
print("Solution by multiply inverse: ")
print(solution)

solution2 = np.linalg.solve(A, B)
print("Solution by linalg solve: ")
print(solution2)

Output:

Solution by multiply inverse matrix and right hand side: 
[-1.  1.]
or by linalg solve: 
[-1.  1.]

That means x=-1, y =1.