Notre Dame street view

g.co/maps/uzxqq

Pi to any precision ported to Dart

try.dartlang.org/s/q2Ui

Click the link, then click the button in the upper left part of the pane.

It works in Chrome and Firefox, I'm not sure if they have it working in IE yet.

It takes 7 to 10 seconds to do 1000 digits of Pi on my machine with Dart, which is based on javascript.
With Java, it only takes 0.09 seconds, so java is way faster (so far).

Doug

/** Pi
 * I found an old C program which 
 * prints out lots of digits of pi.
 * I ported it to java (and now to dart)
 *  © 2011 Douglas A. Bauman
 * Here it is in case you are interested.
 * -Doug
 */

class Pi {
 
    static final int MAXPRC = 20000;
    StringBuffer bufDigits;
    StringBuffer buf;
    StringBuffer bufTime;
    List<int> p; // = new List<int>(MAXPRC); // byte[]
    List<int> t; // = new List<int>(MAXPRC); // byte[]
    int q;

    Pi(){
    }

    setQ(int q) {
        this.q = q;
        bufDigits = new StringBuffer();
        bufDigits.add("digits: "+q);
        buf = new StringBuffer();
        bufTime = new StringBuffer();
    }

    arctan(int s) {
        int n;
        t[0] = 1;
        div6(s);   /* t[] = 1/s */
        add5();
        n = 1;
        do {
            mul7(n);
            div6(s * s);
            div6(n += 2);
            if (((n-1) / 2) % 2 == 0) {
                add5();
            } else {
                sub8();
            }
        } while (!tiszero());
    }
 
    add5() {
        int j;
        for (j = q; j >= 0; j--) {
            if (t[j] + p[j] > 9) {
                p[j] += t[j] - 10;
                if (j>=0) p[j-1] += 1;
            } else {
                p[j] += t[j];
            }
        }
    }
 
    sub8() {
        int j;
        for (j = q; j >= 0; j--) {
            if (p[j] < t[j]) {
                p[j] -= t[j] - 10;
                if (j>=0) p[j-1] -= 1;
            } else {
                p[j] -= t[j];
            }
        }
    }
 
    mul7(int multiplier) {
        int b;
        int i;
        num carry=0;
        int digit = 0;
        for (i = q; i >= 0; i--) {
            b = (t[i] * multiplier + carry);
            digit = b % 10;
            carry = (b / 10).floor();
            t[i] = digit; //(byte)
        }
    }
    
    /* t[] /= l */
    div6(int divisor) {
        int i, b;
        num quotient, remainder = 0;
        for (i = 0; i <= q; i++) {
            b = (10 * remainder + t[i]);
            quotient = (b / divisor).floor();
            remainder = b % divisor;
            t[i] = quotient; // (byte)
        }
    }
    
    div4() {
        int i=0, d = 0;
        num c=0;
        for (; i <= q; i++) {
            c = ((10 * d + p[i]) / 4).floor();
            d = (10 * d + p[i]) % 4;
            p[i] = c; // (byte)
        }
    }
    
    mul4() {
        int i;
        num d=0;
        num c=0;
        for (i = q; i >= 0; i--) {
            d = (p[i] * 4 + c) % 10;
            c = (p[i] * 4 + c) / 10;
            p[i] = d.floor(); // (byte)
        }
    }
    
    bool tiszero() {
        int k;
        for (k = 0; k <= q; k++)
            if (t[k] != 0)
                return(false);
        return(true);
    }

    compute() {
        int i;
        print(getAppletInfo());
        print("..compute..");
        if (q > MAXPRC) {
            buf.add("Precision too large: "+q+", >MAX: "+MAXPRC);
            return;
        }
 
        /* compute pi */
        p = new List<int>(MAXPRC+1);
        t = new List<int>(MAXPRC+1);
        for(int ii=0; ii<=q; ii++) {p[ii]=0; t[ii]=0;}

        Date startime = new Date.now();
        print("..arctan(2)..");
        arctan(2);
        print("..arctan(3)..");
        arctan(3);
        print("..mul..");
        mul4();

        Date endtime = new Date.now();
        Duration diff = endtime.difference(startime);
 
        /* print pi */
        bufTime.add(""+diff.toString()+
          " seconds to compute "+q+" digits of pi");
        print(bufDigits.toString());

        print("pi = ");
        i = 0;
        int km = 79;
        int f = 1;
        do {
          for (int k=0; i <= q && k < km; i++, k++) {
            buf.add(""+(p[i]==null?'?':p[i]));
            if (i==0) buf.add(".");
          }
          print(buf.toString());
          buf = new StringBuffer();
          km+= f;
          f=0;
        } while (i <= q);

        print(buf.toString());
        print(bufTime.toString());
    }
    
    String getAppletInfo() {
        return "Pi by Douglas A. Bauman";
    }
}
main() {
    int q = 1000;
    print("calculating Pi for " + q + " digits...");
    Pi pi = new Pi();
    pi.setQ(q);
    pi.compute();

}

tabs, tabs and more tabs

MyHashMap

import java.util.*;
public class MyHashMap {

    class HashEntry {
        Object key;
        Object val;
        HashEntry(Object key, Object val) {
            this.key=key; this.val=val;
        }
        public String toString() {return "{"+key+","+val+"}";}
        public int hashCode() {if (key!=null) return key.hashCode(); return 0;}
        public boolean equals(Object o) {
            if (o==null) return false;
            if (key==null && ((HashEntry)o).key==null) return true;
            if (key!=null && ((HashEntry)o)!=null) return key.equals(((HashEntry)o).key);
            return false;
        }
    }

    private Set[] arr; // keep the set of HashEntry
    

    public MyHashMap(int size) {
        arr = new Set[size];
    }

    public MyHashMap() {
        this(100);
    }

    private int computeHash(Object key, int size) {
        int h = key.hashCode() % size;
        if (h < 0) h = 0 - h;
        return h;
    }
    /** assumes params are not null */
    public Object get(Object key) {
        if (key==null) return null;
        int h = computeHash(key, arr.length);
        if (arr[h]==null) return null;
        for(Iterator i=arr[h].iterator(); i.hasNext(); ) {
            HashEntry next = (HashEntry) i.next();
            if (next.key.equals(key)) return next.val;
        }
        return null;
    }
    /** assumes params are not null */
    public boolean put(Object key, Object value) {
        if (key==null) return false;
        if (value==null) return false;
        HashEntry e = new HashEntry(key, value);
        int h = computeHash(key, arr.length);
        if (arr[h] == null) {
            arr[h] = new HashSet();
        }
        if (arr[h].contains(e)) {
            arr[h].remove(e);//remove old value
        }
        arr[h].add(e);
        return true;
    }

    public String toString() {
        StringBuffer b = new StringBuffer();
        for(int i=0; i<arr.length; i++) {
            b.append("arr["+i+"]:"+arr[i]);
            b.append("\n");
        }
        return b.toString();
    }

    public static void main(String[] args) {
        MyHashMap map = new MyHashMap(22);
        map.put("bob the builder", new Integer(77));
        map.put("TomTom", new Integer(99));
        map.put("Gale", new Integer(1));
        map.put("birdy 23", new Integer(-3));
        map.put("Food for thought", new Integer(55));
        map.put("A", new Integer(4));
        map.put("0123", new Integer(44));
        map.put("7", new Integer(-8));
        map.put("I am me", new Integer(-77));
        map.put("other", new Integer(1000));
        map.put("some", new Integer(100));
        map.put("THING", new Integer(10));
        map.put("that", new Integer(1));
        map.put("can", new Integer(11));
        map.put("be", new Integer(18));
        map.put("HERE", new Integer(2));
        map.put("IS GOING TO BE HERE", new Integer(-9999));
        System.out.println("map...");
        System.out.println(map.toString());
        System.out.println("get('7'): "+map.get("7"));
        System.out.println("get('bob the builder'): "+map.get("bob the builder"));
        map.put("bob the builder", new Integer(177));
        System.out.println("get('bob the builder'), is now: "+map.get("bob the builder"));

        System.out.println("get('HERE'): "+map.get("HERE"));
        map.put("HERE", new Integer(111111111));
        System.out.println("get('HERE'), is now: "+map.get("HERE"));

        System.out.println("get('TomTom'):"+map.get("TomTom"));
        System.out.println("get('Not in HashMap'):"+map.get("Not in HashMap"));

        System.out.println("add 50 Integer values...");
        for(int i=0; i<50; i++) {
            map.put("i:"+i, new Integer(i));
        }
        System.out.println("map...");
        System.out.println(map.toString());
        System.out.println("\nshow the 50 Integer values backwards...");
        for(int i=49; i>=0; i--) {
            System.out.print(":"+ map.get("i:"+i));
        }
    }
}

map...
arr[0]:null
arr[1]:null
arr[2]:null
arr[3]:null
arr[4]:[{can,11}]
arr[5]:null
arr[6]:[{IS GOING TO BE HERE,-9999}]
arr[7]:null
arr[8]:null
arr[9]:null
arr[10]:[{other,1000}, {Food for thought,55}]
arr[11]:[{7,-8}, {I am me,-77}]
arr[12]:[{HERE,2}, {some,100}]
arr[13]:[{birdy 23,-3}, {Gale,1}]
arr[14]:[{TomTom,99}]
arr[15]:[{that,1}, {be,18}]
arr[16]:[{0123,44}]
arr[17]:null
arr[18]:[{THING,10}]
arr[19]:null
arr[20]:null
arr[21]:[{A,4}, {bob the builder,77}]

get('7'): -8
get('bob the builder'): 77
get('bob the builder'), is now: 177
get('HERE'): 2
get('HERE'), is now: 111111111
get('TomTom'):99
get('Not in HashMap'):null
add 50 Integer values...
map...
arr[0]:[{i:32,32}]
arr[1]:[{i:33,33}]
arr[2]:[{i:10,10}, {i:34,34}]
arr[3]:[{i:11,11}, {i:35,35}]
arr[4]:[{can,11}, {i:12,12}, {i:36,36}]
arr[5]:[{i:13,13}, {i:37,37}]
arr[6]:[{i:14,14}, {i:38,38}, {IS GOING TO BE HERE,-9999}]
arr[7]:[{i:15,15}, {i:40,40}, {i:39,39}]
arr[8]:[{i:16,16}, {i:41,41}]
arr[9]:[{i:17,17}, {i:42,42}]
arr[10]:[{other,1000}, {i:43,43}, {i:18,18}, {Food for thought,55}]
arr[11]:[{i:0,0}, {7,-8}, {i:44,44}, {i:20,20}, {i:19,19}, {I am me,-77}]
arr[12]:[{i:21,21}, {i:45,45}, {HERE,111111111}, {i:1,1}, {some,100}]
arr[13]:[{birdy 23,-3}, {i:22,22}, {i:46,46}, {i:2,2}, {Gale,1}]
arr[14]:[{i:23,23}, {TomTom,99}, {i:47,47}, {i:3,3}]
arr[15]:[{that,1}, {i:24,24}, {i:48,48}, {i:4,4}, {be,18}]
arr[16]:[{i:25,25}, {i:5,5}, {0123,44}, {i:49,49}]
arr[17]:[{i:26,26}, {i:6,6}]
arr[18]:[{i:27,27}, {THING,10}, {i:7,7}]
arr[19]:[{i:28,28}, {i:8,8}]
arr[20]:[{i:30,30}, {i:9,9}, {i:29,29}]
arr[21]:[{i:31,31}, {A,4}, {bob the builder,177}]


show the 50 Integer values backwards...
:49:48:47:46:45:44:43:42:41:40:39:38:37:36:35:34:33:32:31:30:29:28:27:26:25:24:2
3:22:21:20:19:18:17:16:15:14:13:12:11:10:9:8:7:6:5:4:3:2:1:0

import java.util.*;
/** Given a Data Structure having first n integers and next n chars.
 * A = i1 i2 i3 ... iN c1 c2 c3 ... cN.
 * Write an in-place algorithm to rearrange the elements of the array ass A = i1 c1 i2 c2 ... in cn
 *
 * Divide the array in four sections:[X,Y|A,B]
 * With swaps modify it to the form [X,A|Y,B].
 * Do recursion to solve [X|A] and [Y|B] separately, using divide and conquer.
 */
public class DivArr {

    private static int num=5;
    int arr[] = null;

    void swap(int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    public int getK(int a[]) {
      int k = a.length;
      int j=0;
      for(; k>1; j++) {
        k = k >> 1;
      }
      for(k=1; j>0; j--) {
        k = k << 1;
      } // k is now the power of 2 <= a.length
      return k;
    }

    public void swapMiddle(int a[], int len) {
      swapMiddle(a, 0, len-1);
    }
    /* only handles powers of 2 */
    public void swapMiddle(int a[], int left, int right) {
        int diff = (right-left+1)/2;
        int mid = diff + left;
        int leftM = left+diff/2;  // middle of left side
        int rightM = mid+diff/2; // middle of right side
        if (leftM+1 >= rightM) return; // end cond
        int i=leftM; // i walks the left part
        int j=mid; // j walks the right part
        for (; i<mid; i++,j++) swap(i, j);
        // recursion on left side
        swapMiddle(a, left, mid);
        // recursion on left side
        swapMiddle(a, mid, right);
    }

    public static void main(String[] args) {
        DivArr inst = new DivArr();
        if (args.length>0) num= (new Integer(args[0])).intValue();
        inst.arr = new int[num];
        int k = inst.getK(inst.arr);
        System.out.println("k:"+k);
        int j=0;
        int mid= (k%2==0 ? k/2 : k/2+1);
        for (; j<mid; j++) inst.arr[j]=j;
        for (; j<k; j++) inst.arr[j]='A'+j-mid;
        System.out.println("\nin:");
        j=0;
        for (; j<mid; j++) {
          System.out.print(","+inst.arr[j]);
        }
        for (; j<k; j++) {
          System.out.print(","+(new Character((char)inst.arr[j])).toString());
        }
        System.out.println("\n");
        inst.swapMiddle(inst.arr, k); // pass reference so that it can do recursion
        System.out.println("\nout:");
        for (j=0; j<k; j++) {
          if (inst.arr[j] < 'A') {
            System.out.print(","+inst.arr[j]);
          } else {
            System.out.print(","+(new Character((char)inst.arr[j])).toString());
          }
        }
    }
}

k:64

in:
,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O
,P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,_,`


out:
,0,A,1,B,2,C,3,D,4,E,5,F,6,G,7,H
,8,I,9,J,10,K,11,L,12,M,13,N,14,O,15,P
,16,Q,17,R,18,S,19,T,20,U,21,V,22,W,23,X
,24,Y,25,Z,26,[,27,\,28,],29,^,30,_,31,`

---

k random numbers from n

import java.util.*;
/** There is a linked list of numbers of length N. N is very large and you don't know N.
 *  You have to write a function that will return k random numbers from the list.
 *  Numbers should be completely random.
 */
public class KrandN {

    public class Number implements Comparable<Number> {
        private int value;
        Number(int v) {
            value = v;
        }
        public int getValue() {return value;}
        public String toString(){
            return ""+value;
        }
        public int compareTo(Number other) {
            return value - other.value;
        }
    }
    public class KNumber implements Comparable<KNumber> {
        private int k;
        private Number num;
        KNumber(int v, int k) {
          this.num = new Number(v);
          this.k = k;
        }
        public int getValue() {return num.getValue();}
        public int getK() {return k;}
        public String toString(){
            return "[k:"+k+","+getValue()+"]";
        }
        public int compareTo(KNumber other) {
            return k - other.k;
        }
    }

    /* traverse the list, generating a new random number for each entry.
     * remember the top k highest random numbers, and their associated entries.
     * When we hit the end of the list, the numbers in the chart are the required random numbers.
     */
    public PriorityQueue<KNumber> krandn(Vector<Number> list) {
      PriorityQueue<KNumber> p = new PriorityQueue<KNumber>();
      int size = list.size();
      System.out.println("\n\nrands for k including repeats, PriorityQueue will take care of it:");
      for (Number n : list) {
        int r=rand.nextInt(size);
        System.out.print(","+r);
        KNumber k = new KNumber(n.getValue(), r);
        p.add(k);
      }
      System.out.println("\n");
      return p;
    }

    private static final int num=152;
    private static final int maxnumk=20;
    Vector<Number> list = new Vector<Number>();

    public Vector<Number> shuffle(Vector<Number> list){
        if (list == null || list.size() < num) {
            System.out.println("\ninitialize list");
            list = new Vector<Number>(); // new list
            for (int i=0; i<num; i++) {
                Number c = new Number(i);
                list.add(c);
            }
        }
        int [] arr = new int[num];
        int j=0;
        for (Number n : list) {
            arr[j++] = n.getValue();
        }
        shuffleArr(arr);
        list = new Vector<Number>(); // new list
        for (int i=0; i<num; i++) {
            Number c = new Number(arr[i]);
            list.add(c);
        }
        return list;
    }
    Random rand = new Random();
    public void shuffleArr(int [] arr){
        for (int i=0; i<arr.length-1; i++) {
            int rnd = i+ rand.nextInt(arr.length-i);
            //swap arr[i] and a[rnd]
            int tmp = arr[i];
            arr[i] = arr[rnd];
            arr[rnd] = tmp;
        }
    }

    public static void main(String[] args) {
        KrandN inst = new KrandN();
        Vector<Number> list = null;
        list = inst.shuffle(list);
        System.out.println("\nout:");
        for (Number n : list) {
          System.out.print(","+n.toString());
        }
        PriorityQueue<KNumber> p = inst.krandn(list);
        System.out.println("\n top k list, random k elements (up to "+maxnumk+"):");
        int i = 0;
        while (!p.isEmpty() && i++ < maxnumk) { 
            KNumber n = p.remove();
            System.out.print(","+n);
        }

        //System.out.println("\nsorted:");
        //Collections.<Number>sort(list);
        //for (Number n : list) {
        //    System.out.print(","+n.toString());
        //}
    }
}

 top k list, random k elements (up to 20):
,[k:1,29],[k:2,27],[k:2,105],[k:4,23],[k:6,30],[k:7,64],[k:9,102],[k:9,8],[k:9,1
7],[k:11,82],[k:12,128],[k:13,58],[k:13,135],[k:13,145],[k:13,15],[k:14,109],[k:
16,126],[k:17,111],[k:19,37],[k:19,53]

Unique

import java.util.*;
public class Unique {

    private final int num=52;
    int [] arr = new int[num];
    public int[] uniquen(){
        int cost=0;
        int l = arr.length;
        int [] o = new int[l]; // the values cannot exceed the length!
        for(int i=0; i<l; i++) {
            o[i] = -1; // init to -1
            //cost++;
        }        
        int [] newa = new int[l];
        int s=0;
        for(int i=0; i<l; i++) {
            o[arr[i]] = arr[i]; // assumes values in arr don't exceed the length of arr
            // could have done a max(arr) as the length of o instead.
            cost++;
        }
        for(int i=0; i<l; i++) {
            if (o[i] != -1) {
                newa[s++] = o[i];
                cost++;
            }
        }
        int [] result = new int[s];
        System.out.print("result:");
        for(int k=0; k<s; k++) {
            result[k] = newa[k];
            System.out.print(","+result[k]);
            cost++;
        }
        System.out.println("");
        System.out.println("cost:"+cost+"\n");
        return result;
    }

    public int[] uniquen2(){
        int cost=0;
        int l = arr.length;
        int [] newa = new int[l];
        int s=0;
        for(int i=0; i<l; i++) {
            for(int j=i+1; j<l; j++) {
                if (arr[i] == arr[j]) j = ++i;
                cost++;
            }
            newa[s++] = arr[i];
        }
        int [] result = new int[s];
        System.out.print("result:");
        for(int k=0; k<s; k++) {
            result[k] = newa[k];
            System.out.print(","+result[k]);
            cost++;
        }
        System.out.println("");
        System.out.println("cost:"+cost+"\n");
        return result;
    }

    Random rand = new Random();
    public void shuffleArr(){
        for (int i=0; i<arr.length-1; i++) {
            arr[i] = i/3;
        }
        for (int i=0; i<arr.length-1; i++) {
            int rnd = i+ rand.nextInt(arr.length-i);
            //swap arr[i] and a[rnd]
            int tmp = arr[i];
            arr[i] = arr[rnd];
            arr[rnd] = tmp;
        }
        System.out.print("\nin:");
        for(int i=0; i<arr.length; i++) {
            System.out.print(","+arr[i]);
        }
        System.out.println("\n");
    }


    public static void main(String[] args) {
        Unique inst = new Unique();
        inst.shuffleArr();
        inst.uniquen2();
        inst.uniquen();
    }
}