Jimexist

Design for reuse

You should aim to design for reuse, otherwise, hide it!

The reasoning behind this is that your users, including yourself in future, will naturally ignore any documentation and convention that you put in code, and use it the way they like.

If you design the class, you should aim for reusability and otherwise hide them, leaving yourself with leeway to redo.

Jimexist

Prefer immutable objects by default

POJO

public class Person {
  
  private firstName;
  private lastName;
  private email;

Jimexist

import java.util.*;

public class Solution {
  
    public static void main(String[] args) {
        int[][] deps = {{1, 0}};
        System.out.printf("%s\n", Arrays.toString(new Solution().findOrder(2, deps)));
    }
    
    private static Integer append(int i, Map<Integer, List<Integer>> map, Map<Integer, Integer> depthMap) {

Jimexist

import java.util.HashMap;
import java.util.Map;

public class LRUCache<K, V> {

    private final Map<K, Node<K, V>> map;
    private final Node<K, V> head, tail;
    private final int maxSize;

    private static class Node<K, V> {

Jimexist

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class OOSTest {

    public static void main(String[] args) throws Exception {
        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
             ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream)) {

Jimexist

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class InterruptThreadPools<V> {

    private final ExecutorService threadPool = Executors.newCachedThreadPool();
    private final CompletionService<V> completionService = new ExecutorCompletionService<>(threadPool);
    private final BlockingQueue<Future<V>> tasks = new LinkedBlockingQueue<>();

Jimexist

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define max(A, B) ((A) > (B) ? (A) : (B))
#define min(A, B) ((A) < (B) ? (A) : (B))

int contained(int *cont, size_t len) {
    if (len == 0) {
        return 0;

Jimexist

subset :: Int -> Int -> [[Int]]
subset 0 _ = [[]]
subset _ 0 = [[]]
subset n k = [i:y | i <- [k..n], y <- subset (i-1) (k-1)]

Jimexist

public class BadNeighbors {

    public static void main(String[] args) {
        int[] collections = new int[args.length];
        for (int i=0; i<args.length; ++i) {
            collections[i] = Integer.parseInt(args[i]);
        }
        System.out.printf("%d\n", maxDonations(collections));
    }

Jimexist

public class ZigZag {

	public static int longestZigZag(int[] sequence) {
		final int n = sequence.length;
		
		int[] positive = new int[n];
		int[] negative = new int[n];
		for (int i=0; i<n; ++i) {
			positive[i] = negative[i] = 1;
		}