In readme, added link to javadoc

Author: tdebatty

README.md

@@ -25,7 +25,7 @@ Using maven:
 </dependency>
 ```
 
-See [releases](https://github.com/tdebatty/java-string-similarity/releases).
+Or check the [releases](https://github.com/tdebatty/java-string-similarity/releases).
 
 ## Interfaces
 Although the topic might seem simple, a lot of different algorithms exist to measure text similarity or distance. Therefore the library defines some interfaces to categorize them.
@@ -42,6 +42,8 @@ Generally, algorithms that implement NormalizedStringSimilarity also implement N
 ### Metric distances
 The MetricStringDistance interface : A few of the distances are actually metric distances, which means that verify the triangle inequality d(x, y) <= d(x,z) + d(z,y). For example, Levenshtein is a metric distance, but NormalizedLevenshtein is not.
 
+[Read Javadoc for details](http://api123.web-d.be/api/java-string-similarity/head/index.html)
+
 ## Shingles (n-gram) based similarity and distance
 A few algorithms work by converting strings into sets of n-grams (sequences of n characters, also sometimes called k-shingles). The similarity or distance between the strings is then the similarity or distance between the sets.
 

src/main/java/info/debatty/java/stringsimilarity/KShingling.java

@@ -7,6 +7,7 @@
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.regex.Pattern;
 
 /**
@@ -190,8 +191,14 @@ private HashMap<Integer, Integer> getHashProfile(String s) {
 
         return hash_profile;
     }
-    
-    
-    
-    
+
+    String getNGram(int key) {
+        for (Map.Entry<String, Integer> entry : shingles.entrySet()) {
+            if (entry.getValue().equals(key)) {
+                return entry.getKey();
+            }
+        }
+        
+        throw new InvalidParameterException("No ngram coresponds to key " + key);
+    }
 }

src/main/java/info/debatty/java/stringsimilarity/StringProfile.java

@@ -32,6 +32,22 @@
  * @author Thibault Debatty
  */
 public class StringProfile {
+    
+    public static void main(String[] args) {
+        KShingling ks = new KShingling(2);
+        for (String ngram : ks.getProfile("ABCABC").getMostFrequentNGrams(2)) {
+            System.out.println(ngram);
+        }
+        
+        for (String ngram : ks.getProfile("A").getMostFrequentNGrams(2)) {
+            System.out.println(ngram);
+        }
+        
+        for (String ngram : ks.getProfile("This is a string...").getMostFrequentNGrams(2)) {
+            System.out.println(ngram);
+        }
+    }
+    
     private final SparseIntegerVector vector;
     private final KShingling ks;
 
@@ -71,4 +87,39 @@ public double qgramDistance(StringProfile other) throws Exception {
     public SparseIntegerVector getSparseVector() {
         return this.vector;
     }
+    
+    public String[] getMostFrequentNGrams(int number) {
+        String[] strings = new String[number];
+        int[] frequencies = new int[number];
+        
+        int position_smallest_frequency = 0;
+        
+        for (int i = 0; i < vector.size(); i++) {
+            int key = vector.getKey(i);
+            int frequency = vector.getValue(i);
+            String ngram = ks.getNGram(key);
+            
+            if (frequency > frequencies[position_smallest_frequency]) {
+                // 1. replace the element with currently the smallest frequency
+                strings[position_smallest_frequency] = ngram;
+                frequencies[position_smallest_frequency] = frequency;
+                
+                // 2. loop over frequencies to find which one is now the lowest
+                // frequency
+                int smallest_frequency = Integer.MAX_VALUE;
+                for (int j = 0; j < frequencies.length; j++) {
+                    if (frequencies[j] < smallest_frequency) {
+                        position_smallest_frequency = j;
+                        smallest_frequency = frequencies[j];
+                    }
+                }
+                
+            }
+            
+        }
+        
+        return strings;
+
+        
+    }
 }

src/main/java/info/debatty/java/stringsimilarity/examples/MetricLCS.java

@@ -46,6 +46,5 @@ public static void main(String[] args) {
         // longest = ABDEF => length = 5
         // => 1 - 4 / 5 = 0.2
         System.out.println(lcs.distance("ABDEF", "ABDIF"));
-    }
-    
+    } 
 }

src/main/java/info/debatty/java/utils/SparseIntegerVector.java

@@ -262,4 +262,12 @@ public double qgram(SparseIntegerVector other) {
     public int size() {
         return this.size;
     }
+
+    public int getKey(int i) {
+        return this.keys[i];
+    }
+
+    public int getValue(int i) {
+        return this.values[i];
+    }
 }