kedarmhaswade

package fx.jvm.hotspot.tools;

import java.util.List;

import sun.jvm.hotspot.tools.Tool;

public class PrintThreadIds extends Tool {
    public static void main(String[] args) {
        PrintThreadIds tool = new PrintThreadIds();
        tool.start(args);

kedarmhaswade

➜  /tmp tree com
com
└── test
    └── Test.java

1 directory, 2 files
➜  /tmp more com/test/Test.java 
package com.test;

class Test {

kedarmhaswade

package tmp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;

/**
 * Created by kmhaswade on 3/31/16.

kedarmhaswade

import java.util.*;

public class SubsetSum {
    public static void main(String[] args) {
        subsetHasSum(new int[]{1, 2, 3, 4, 5, 6, 7}, 22);
    }
    static void subsetHasSum(int[] set, int sum) {
        // basic validations
        Arrays.sort(set);
        System.out.println(Arrays.toString(set));

kedarmhaswade

/** Trying out the solution to:
 *  http://stackoverflow.com/questions/5739024/finding-duplicates-in-on-time-and-o1-space
 * Created by kmhaswade on 3/5/16.
 * Have I translated @caf's pseudocode correctly?
 */
public class DuplicateFinder {
    public static void main(String[] args) throws IOException {
        int[] a = new int[]{3, 0, 1, 3, 2};
        int n = a.length;
        for (int i = 0; i <= n-1; i++) {

kedarmhaswade

/Library/Java/JavaVirtualMachines/8/Contents/Home/bin/java 
-agentlib:jdwp=transport=dt_socket,address=127.0.0.1:64661,suspend=y,server=n -ea -Didea.junit.sm_runner -Dfile.encoding=UTF-8 
-classpath "/Applications/IntelliJ IDEA 15.app/Contents/lib/idea_rt.jar:/Applications/IntelliJ IDEA 15.app/Contents/plugins/junit/lib/junit-rt.jar:/Library/Java/JavaVirtualMachines/8/Contents/Home/jre/lib/charsets.jar:/Library/Java/JavaVirtualMachines/8/Contents/Home/jre/lib/deploy.jar:/Library/Java/JavaVirtualMachines/8/Contents/Home/jre/lib/ext/cldrdata.jar:/Library/Java/JavaVirtualMachines/8/Contents/Home/jre/lib/ext/dnsns.jar:/Library/Java/JavaVirtualMachines/8/Contents/Home/jre/lib/ext/jaccess.jar:/Library/Java/JavaVirtualMachines/8/Contents/Home/jre/lib/ext/jfxrt.jar:
/Library/Java/JavaVirtualMachines/8/Contents/Home/jre/lib/ext/localedata.jar:/Library/Java/JavaVirtualMachines/8/Contents/Home/jre/lib/ext/nashorn.jar:/Library/Java/JavaVirtualMachines/8/Contents/Home/jre/lib/ext/sunec.jar:/Library/Java/JavaVirtualMachine

kedarmhaswade

import java.util.*;
class Quicksort {
  public static void qsort(int[] ints, int fi, int li) {
    /* the recursive procedure */
    if (fi < li) {
      //int p = partition(ints, fi, li);
      int p = partition1(ints, fi, li);
      qsort(ints, fi, p - 1);
      qsort(ints, p + 1, li);
    }

kedarmhaswade

package tmp;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/** <p>
 *      Find the lucky numbers amongst natural numbers from 1 to n.

kedarmhaswade

/**
 * This program tries to demonstrate the surprising sequential consistency.
 * A program is sequentially consistent as long as calls made in a single
 * thread follow the program order. Program order however, does not apply
 * to the executions across threads.
 * It's hard to demonstrate that a counterintuitive behavior might actually
 * be sequentially consistent. Let's say, we have a FIFO queue, q and two threads: A, B
 *
 * Thread A does:
 *   q.enq(x); returns at time 1.

kedarmhaswade

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;
public class DiningPhilosophers {

  volatile static boolean done;
  final private Integer[] chopsticks;

  public DiningPhilosophers(int n) {
    chopsticks = new Integer[n];
    for (int i = 0 ; i < n ; i++)