Competition : Win a ticket to GeeCON Prague 2014

[Tim Cooke]

CodeRanch is offering 1 free ticket (yes, a free ticket!) to GeeCON Prague 2014 which is scheduled for 23 - 24 October 2014.

The event boasts Java and JVM based technologies, dynamic languages, enterprise architectures, patterns, distributed computing, software craftsmanship, mobile and much more...

To stand a chance of winning the ticket, all you have to do is enter our fun programming competition, posting your solutions in this very thread. You can even post more than once. The solution that we, the CodeRanch staff, think is the best will win the ticket to GeeCON Prague 2014. Also, as an added bonus, the winner will have the opportunity to meet one of our esteemed Marshal's Ulf Dittmer who will be attending the conference too.

The contest ends Friday 10th October, with the winner announced by Saturday 11th October. Good luck, and have fun!!

The Competition: Java obfuscated word occurrence counter

The Problem

Write a program that takes a sentence, a String with words delimited by whitespace, and returns the occurrence of each word as a Map of words (key) to occurrence count (value).

The Criteria

Write a program that solves the problem, while being as unreadable to the human eye as possible. (Obfuscation)

Bonus points for achieving it in the least amount of code. (Code Golf)

The Rules

The sentence is a String delimited by single whitespace characters. Assume no punctuation.

Words are case insensitive. "CodeRanch" is the same as "coderanch"

Words are mapped in lowercase form. "CodeRanch" is mapped as "coderanch"

Java SE only. No third party libraries allowed.

Must compile and run with Java8 JDK and JRE

Must comply with the following method signature

public static Map<String, Integer> wordOccurrence(String sentence) {
    // Your solution goes here
}

For example
The sentence (String) "I really REALLY love CodeRanch" returns the occurrence (Map) {i=1, really=2, love=1, coderanch=1}

A test harness to get you started
Provided is a simple Java class with the skeleton method signature and a couple of tests that you can use to verify the correct functionality. For writing your solution you are only interested in the method skeleton on lines 6 - 9, this is where you complete the method with your solution to make it function correctly.

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

public class GeeConComp {

    public static Map<String, Integer> wordOccurrence(String sentence) {
        // Your solution goes here
        return null;
    }

    public static void main(String[] args) {
        System.out.println("CodeRanch GeeCON Prague 2014 competition");
        System.out.println("========================================");
        String sentence1 = "I really REALLY love CodeRanch";
        Map<String, Integer> expectedWordOccurrence1 = new HashMap<>();
        expectedWordOccurrence1.put("i", 1);
        expectedWordOccurrence1.put("really", 2);
        expectedWordOccurrence1.put("love", 1);
        expectedWordOccurrence1.put("coderanch", 1);
        assertOccurrences(expectedWordOccurrence1, wordOccurrence(sentence1));

        String sentence2 = "Good better best may I never rest until my good is better and my better best";
        Map<String, Integer> expectedWordOccurrence2 = new HashMap<>();
        expectedWordOccurrence2.put("good", 2);
        expectedWordOccurrence2.put("better", 3);
        expectedWordOccurrence2.put("best", 2);
        expectedWordOccurrence2.put("may", 1);
        expectedWordOccurrence2.put("i", 1);
        expectedWordOccurrence2.put("never", 1);
        expectedWordOccurrence2.put("rest", 1);
        expectedWordOccurrence2.put("until", 1);
        expectedWordOccurrence2.put("my", 2);
        expectedWordOccurrence2.put("is", 1);
        expectedWordOccurrence2.put("and", 1);
        assertOccurrences(expectedWordOccurrence2, wordOccurrence(sentence2));
    }

    private static void assertOccurrences(Map<String, Integer> expected, Map<String, Integer> actual) {
        if (expected.equals(actual)) {
            System.out.println("Test PASS :)");
        } else {
            System.out.println("Test FAIL :(");
            System.out.println("Expected: " + expected);
            System.out.println("Actual  : " + actual);
        }
    }
}

How to run the test harness
Take a copy of this code and paste it into a file called GeeConComp.java.

Compile it

javac GeeConComp.java

Run it

java GeeConComp

Initially the output will report test failures, which is expected as the solution has not been written yet.

CodeRanch GeeCON Prague 2014 competition
========================================
Test FAIL :(
Expected: {love=1, coderanch=1, i=1, really=2}
Actual : null
Test FAIL :(
Expected: {better=3, never=1, rest=1, may=1, and=1, i=1, best=2, until=1, is=1, my=2, good=2}
Actual : null

What you want to see is passing tests

CodeRanch GeeCON Prague 2014 competition
========================================
Test PASS :)
Test PASS :)

That's it! Enjoy.

[M Ga]

import static java.util.stream.Collectors.*;

import java.util.Arrays;
import java.util.Map;

public class GeeConComp {

    public static Map< String, Integer > wordOccurrence( String sentence )
    {
        return Arrays.stream( sentence.toLowerCase().split( " " ) )
            .collect( groupingBy( s -> s, reducing( 0, e -> 1, Integer::sum ) ) );
    }
}

[Robert LaValley]

    public static Map<String, Integer> wordOccurrence(String sentence) {
        Map<String,Integer> wordMap = new HashMap<String,Integer> ();
        for (String word : sentence.toLowerCase().split("\\s")) {
            if (!wordMap.containsKey(word)) wordMap.put(word,new Integer(0));
            wordMap.put(word, new Integer(wordMap.get(word).intValue () + 1));
        }
        return wordMap;
    }

[Jakub Milkiewicz]

Using pure reduction

public static Map<String, Integer> wordOccurrence(String sentence) {
        HashMap<String, Integer> reduce = Pattern.compile(" ").splitAsStream(sentence).map(x -> x.toLowerCase()).reduce(new HashMap<String, Integer>(),
                (HashMap<String,Integer> acc, String elem) -> {
                    HashMap<String, Integer> map = new HashMap<>(acc);
                    if (acc.containsKey(elem)) {
                        map.put(elem, acc.get(elem) + 1);
                    } else {
                        map.put(elem, 1);
                    }
                    return map;
                }, (x,y) -> {
                        HashMap result = new HashMap<>();
                        result.putAll(x);
                        result.putAll(y);
                        return result;
                }
        );
        return reduce;

or using grouping

 return Pattern.compile(" ").splitAsStream(sentence).map(x->x.toLowerCase()).collect(groupingBy(x -> x, Collectors.reducing(0, x -> 1, Integer::sum)));

[Joanne Neal]

Seems like a good way to attract people to the ranch.
Three attempts so far - two from newly registered people and one that's a first post from someone who registered two and a half years ago.

[Tim Cooke]

Joanne Neal wrote:one that's a first post from someone who registered two and a half years ago.

Yea who does that! (ActiveStaff#timcooke)

Tim Cooke wrote:Tim joined CodeRanch in 2008 but didn't post a single thing until early 2013. Nobody knows why

Remember, obfuscation is the name of the game in this competition. We're looking for the most unreadable code you can muster while being functionally correct.

[Pawel Szulc]

public static Map<String, Integer> wordOccurrence(String sentence) {
        return stream(sentence.split(" ")).collect(groupingBy(String::toLowerCase, summingInt(x -> 1)));
    }

[Jim Young]

Not so obscure but my first attempt.

public static Map<String, Integer> wordOccurrence(String sentence) {
        Map<String, Integer> wm = new HashMap<>();
        for (String s : sentence.toLowerCase().split(" ")) {
            wm.put(s, (wm.get(s) == null ? 1 : wm.get(s) + 1));
        }
        return wm;
    }

[D Tom]

	public static Map<String, Integer> wordOccurrence(String sentence) {
		Map<String, Integer> map = new HashMap<String, Integer>();
		List<String> la = new ArrayList<String>(Arrays.asList(sentence.toLowerCase().split("\\s")));
		for (String s : la.toArray(new String[la.size()])) {
			int count = 0;
			if (!map.containsKey(s)) {
				while (la.indexOf(s) != -1) {
					count++;
					la.remove(la.indexOf(s));
				}
				map.put(s, count);
			}
		}
		return map;
	}

[Campbell Ritchie]

Welcome to the Ranch all of you.

[Pawel Szulc]

I've entered the competition but I still am amazed that you promote "unreadable" code. Whenever at any conference I see companies promoting them selves with contests like "what this Java puzzler do" or "what will be the output of that function" I simply scream and run away. Would you really like to work in a place were you are promoted for understanding unreadable code?

I like the idea of the "golf rule" as concise code can be still comprehensible. But "unreadable" code by its nature will not.

[Campbell Ritchie]

We do not believe that anybody would produce unreadable code in real life, but wanted to try something along the lines of the famous International Obfuscated C Contests.

[Joe San]

Assuming that I can call a Scala method from a Java file, here is my scalafied version:

def countWords(in: String): Map[String, Int] = in.toLowerCase.split(" ").toList.groupBy((w: String) => w).mapValues(_.length)

[Tim Cooke]

Joe, remember the rules:

Java SE only. No third party libraries allowed.

Must compile and run with Java8 JDK and JRE

That means no Scala. Sorry Joe.

[Joe San]

I will give it another try with Java SE!

[Tim Cooke]

Pawel Szulc wrote:I've entered the competition but I still am amazed that you promote "unreadable" code.

Hi Pawel. None of us here at the Ranch would ever promote that you write unreadable code in the real world. But for this competition we wanted to make it fun and interesting by getting you thinking a little differently and have you write the most obscure code you can come up with that still solves a simple problem.

@Joe Harry, You can enter as many times as you like, so go nuts.

[Joe San]

Here is my obfuscated version:

       public static Map<String, Integer> wordOccurrence(String sentence) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        String input = sentence.trim().toLowerCase();
        do {
            int index = input.indexOf(" ", 0);
            if(input.indexOf(" ") == -1) {
                if(map.containsKey(input)) { map.put(input, map.get(input) + 1); input = null;}
                else { map.put(input, 1); input = null; }
            } else {
                String splitWord = input.substring(0, input.indexOf(" "));
                if (map.containsKey(splitWord.trim())) {
                    map.put(splitWord, map.get(splitWord) + 1);
                    input = input.substring(index +1, input.length());
                } else {
                    map.put(splitWord, 1);
                    input = input.substring(index +1, input.length());
                }
            }
        } while(input!= null && input.length() != 0);
        return map;
    }

[Joe San]

I can already see that my obfuscated version fails the test for a String input

"This  is    a test"

Of course, I can obfuscate it further and fix it. Is it necessary?

[Adalberto Toledo]

/**
 * 
 */
package model;

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

/**
 * @author Adalberto Toledo, [e-mail]
 *
 */
public class WordCounter {

	/**
	 * Takes a sentence, a String with words delimited by whitespace, and returns the occurrence of each word as a Map of words (key) to occurrence count (value).
	 * @param sentence String with words delimited by whitespace
	 * @return returns the occurrence of each word as a Map of words (key) to occurrence count (value).
	 */
	public static Map<String, Integer> wordOccurrence(String sentence) {
		// My solution is here
		String arraySentence[] = sentence.split(" "); //Split the sentence by whitespace into an array
		
		Map<String, Integer> mapOcurrences = new HashMap<String, Integer>(); //Initialize my map
		
		//begin foreach
		for (String string : arraySentence) { //Loop my splitted array to get each item
			string = string.toLowerCase(); //transform the string to Lower Case
			
			/*
			 * If the string is not contained in the map, I put the string and 1 as the value
			 * If the string is contained in the map, I get the Value, add 1 and put it again
			 */
			mapOcurrences.put(string, mapOcurrences.containsKey(string)? mapOcurrences.get(string) + 1: 1);
		}//end foreach
		
		return mapOcurrences; //return the map of Word Occurrences
	}
	
}

[Adalberto Toledo]

package model;
import java.util.HashMap;
import java.util.Map;
public class WordCounterObfuscated {
	public static Map<String, Integer> wordOccurrence(String sentence) {
		Map<String, Integer> mapOcurrences = new HashMap<String, Integer>();
		for (String string : sentence.toLowerCase().split(" ")) {
			mapOcurrences.put(string, mapOcurrences.containsKey(string)? mapOcurrences.get(string) + 1: 1);
		}
		return mapOcurrences;
	}
}

[Adalberto Toledo]

import java.util.HashMap;
import java.util.Map;
public class WordCounterObfuscated {
	public static Map<String, Integer> wordOccurrence(String sentence){Map<String, Integer> mapOcurrences = new HashMap<String, Integer>();
		for (String string : sentence.toLowerCase().split(" "))
			mapOcurrences.put(string, mapOcurrences.containsKey(string)? mapOcurrences.get(string) + 1: 1);
		return mapOcurrences;}}

[Campbell Ritchie]

Please don't use this thread to develop your applications. Please only post the final versions here.
If you want to discuss what happens if you post "Campbell Ritchie     is a dreadful nuisance" please go to one of the Java fora.

Don't copy‑and‑paste this post.

[Adalberto Toledo]

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

import org.apache.commons.lang3.StringUtils;
public class WordCounterObfuscated {
	public static Map<String, Integer> wordOccurrence(String sentence){Map<String, Integer> mapOcurrences = new HashMap<String, Integer>();
		for (String string : sentence.toLowerCase().split(" "))
			mapOcurrences.put(string, mapOcurrences.containsKey(string)? mapOcurrences.get(string) + 1: 1);
		return mapOcurrences;}
	public static void main(String[] args) {
		System.out.println(wordOccurrence(StringUtils.join(args, ' ')));
	}	
}

[Adalberto Toledo]

Sorry, I only was uploading some versions, so you can check which one match the best with the criteria...

[Tim Cooke]

Joe Harry wrote:I can already see that my obfuscated version fails the test for a String input

"This  is    a test"

Of course, I can obfuscate it further and fix it. Is it necessary?

No.

The Rules wrote:The sentence is a String delimited by single whitespace characters. Assume no punctuation.

That means you don't have to handle multiple whitespace. You can assume it never happens.

As a general note to all. Please don't forget to UseCodeTags when posting code. Omitting their use does not qualify as a valid obfuscation technique.

[Campbell Ritchie]

Adalberto Toledo wrote: . . . which one match the best with the criteria...

If the code fulfils the rules of the contest compiles and produces a PASS result from Tim's test harness, each would count as a separate entry. Multiple entries are welcomed

[Campbell Ritchie]

Adalberto Toledo wrote:

//...

import org.apache.commons.lang3.StringUtils;
//...

This does not comply with the rules that only standard JavaSE classes may be used. I suggest you resubmit with that import removed. Consider StringJoiner instead.

[Adalberto José Toledo]

import java.util.HashMap;
import java.util.Map;
  
public class GeeConComp {  

    public static Map<String, Integer> wordOccurrence(String sentence) { Map<String, Integer> m = new HashMap<String, Integer>();  
        for (String s : sentence.trim().toLowerCase().split(" ")) if(s.trim().length() > 0) m.put(s.trim(), m.containsKey(s.trim())? m.get(s.trim()) + 1: 1);
        return m;
    }
  
    public static void main(String[] args) {
    	System.out.println("CodeRanch GeeCON Prague 2014 competition");
        System.out.println("========================================");
        String sentence1 = "I really REALLY love CodeRanch";
        Map<String, Integer> expectedWordOccurrence1 = new HashMap<>();  
        expectedWordOccurrence1.put("i", 1);
        expectedWordOccurrence1.put("really", 2);  
        expectedWordOccurrence1.put("love", 1);
        expectedWordOccurrence1.put("coderanch", 1);
        assertOccurrences(expectedWordOccurrence1, wordOccurrence(sentence1));
  
        String sentence2 = "Good better best may I never rest until my good is better and my better best";
        Map<String, Integer> expectedWordOccurrence2 = new HashMap<>();
        expectedWordOccurrence2.put("good", 2);
        expectedWordOccurrence2.put("better", 3);
        expectedWordOccurrence2.put("best", 2);
        expectedWordOccurrence2.put("may", 1); 
        expectedWordOccurrence2.put("i", 1);
        expectedWordOccurrence2.put("never", 1);
        expectedWordOccurrence2.put("rest", 1); 
        expectedWordOccurrence2.put("until", 1);
        expectedWordOccurrence2.put("my", 2);
        expectedWordOccurrence2.put("is", 1); 
        expectedWordOccurrence2.put("and", 1);
        assertOccurrences(expectedWordOccurrence2, wordOccurrence(sentence2));  
    }
  
    private static void assertOccurrences(Map<String, Integer> expected, Map<String, Integer> actual) {  
        if (expected.equals(actual)) {
            System.out.println("Test PASS :)");  
        } else {
            System.out.println("Test FAIL :(");  
            System.out.println("Expected: " + expected);  
            System.out.println("Actual  : " + actual);  
        }  
    }  
}

[vamsee priya]

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

public class GeeConComp {

    public static Map<String, Integer> wordOccurrence(String sentence) {
        Map<String,Integer> contest = new HashMap<String,Integer>();
        for(String word :sentence.toLowerCase().split(" "))
        {
            if(contest.containsKey(word.trim()))
            {
                contest.put(word,contest.get(word)+1);
            } else
            {
                contest.put(word,1) ;
            }
        }
        return contest;
    }

    public static void main(String[] args) {
        System.out.println("CodeRanch GeeCON Prague 2014 competition");
        System.out.println("========================================");
        String sentence1 = "I really REALLY love CodeRanch";
        Map<String, Integer> expectedWordOccurrence1 = new HashMap<String, Integer>();
        expectedWordOccurrence1.put("i", 1);
        expectedWordOccurrence1.put("really", 2);
        expectedWordOccurrence1.put("love", 1);
        expectedWordOccurrence1.put("coderanch", 1);
        assertOccurrences(expectedWordOccurrence1, wordOccurrence(sentence1));

        String sentence2 = "Good better best may I never rest until my good is better and my better best";
        Map<String, Integer> expectedWordOccurrence2 = new HashMap<String, Integer>();
        expectedWordOccurrence2.put("good", 2);
        expectedWordOccurrence2.put("better", 3);
        expectedWordOccurrence2.put("best", 2);
        expectedWordOccurrence2.put("may", 1);
        expectedWordOccurrence2.put("i", 1);
        expectedWordOccurrence2.put("never", 1);
        expectedWordOccurrence2.put("rest", 1);
        expectedWordOccurrence2.put("until", 1);
        expectedWordOccurrence2.put("my", 2);
        expectedWordOccurrence2.put("is", 1);
        expectedWordOccurrence2.put("and", 1);
        assertOccurrences(expectedWordOccurrence2, wordOccurrence(sentence2));
    }

    private static void assertOccurrences(Map<String, Integer> expected, Map<String, Integer> actual) {
        if (expected.equals(actual)) {
            System.out.println("Test PASS :)");
        } else {
            System.out.println("Test FAIL :(");
            System.out.println("Expected: " + expected);
            System.out.println("Actual  : " + actual);
        }
    }
}

[Adalberto Toledo]

Campbell Ritchie wrote:

Adalberto Toledo wrote:

//...

import org.apache.commons.lang3.StringUtils;
//...

This does not comply with the rules that only standard JavaSE classes may be used. I suggest you resubmit with that import removed. Consider StringJoiner instead.

You are right however, my solution is only the wordOccurrence method, that library is only used in the Main method, just for running the program and convert the arguments passed by the Command Line Interface (CLI), to a String delimited by a single whitespace.

Anyway, I appreciate your suggestion and I will consider the StringJoiner Class instead of the StringUtils Class.

Please, try to evaluate only my wordOccurrence method because that is my solution.

Before that solution, I submitted a solution without the Main method and it doesn't have that library imported, do you want me to submit it again?

Thanks a lot

Best Regards

[Tim Cooke]

Adalberto Toledo wrote:that library is only used in the Main method

Noted. Solution accepted.

[Piotr Kalinowski]

    public static Map<String, Integer> wordOccurrence(String sentence) {
    	StringTokenizer a = new StringTokenizer(sentence.toLowerCase(), "\u0020");
        Map<String, Integer> x = new HashMap<>();    	
    	while (a.hasMoreElements()) {
    		String y = a.nextToken();
    		try {
    			x.put(y, 1==1 ? x.get(y) + (0x7FFFFFFF >> 30) : 15);	
    		} catch (NullPointerException surprise) {
    			x.put(y, (int)Math.round(Math.atan(Math.PI/2)));
    		}
    	}
		return x ;
    }

[subh kumar]

//soln by [e-mail]

import java.util.HashMap;
import java.util.Map;[code=java]

public class GeeConComp {

    public static Map<String, Integer> wordOccurrence(String sentence) {
        // Your solution goes here
    	Map<String, Integer> MyWordOccurrence1 = new HashMap<>();
    	String parts[]=sentence.split(" "); // stores sentence word in string array(parts)
    	int count=0;
    	for(String s:parts) //picks one by one words from string array(parts)
    	{
    		count=0;
    		for(int i=0;i<parts.length;i++) //moves from each word to next word of sentence
    		{
    			if(s.equalsIgnoreCase(parts[i]))//if match found
    					{
    						count++;  
    						
    					}
    		}
    		MyWordOccurrence1.put(s.toLowerCase(), count); //puts string lower case in Map which puts  unique name and no duplication  
    		
    	}    	
    	
        return MyWordOccurrence1;       
    	
    }

    public static void main(String[] args) {
        System.out.println("CodeRanch GeeCON Prague 2014 competition");
        System.out.println("========================================");
        String sentence1 = "I really REALLY love CodeRanch";
        Map><String, Integer> expectedWordOccurrence1 = new HashMap<>();
        expectedWordOccurrence1.put("i", 1);
        expectedWordOccurrence1.put("really", 2);
        expectedWordOccurrence1.put("love", 1);
        expectedWordOccurrence1.put("coderanch", 1);
        assertOccurrences(expectedWordOccurrence1, wordOccurrence(sentence1));

        String sentence2 = "Good better best may I never rest until my good is better and my better best";
        Map<String, Integer> expectedWordOccurrence2 = new HashMap<>();
        expectedWordOccurrence2.put("good", 2);
        expectedWordOccurrence2.put("better", 3);
        expectedWordOccurrence2.put("best", 2);
        expectedWordOccurrence2.put("may", 1);
        expectedWordOccurrence2.put("i", 1);
        expectedWordOccurrence2.put("never", 1);
        expectedWordOccurrence2.put("rest", 1);
        expectedWordOccurrence2.put("until", 1);
        expectedWordOccurrence2.put("my", 2);
        expectedWordOccurrence2.put("is", 1);
        expectedWordOccurrence2.put("and", 1);
        assertOccurrences(expectedWordOccurrence2, wordOccurrence(sentence2));
    }

    private static void assertOccurrences(Map<String, Integer> expected, Map<String, Integer> actual) {
        if (expected.equals(actual)) {
            System.out.println("Test PASS :)");
        } else {
            System.out.println("Test FAIL :(");
            System.out.println("Expected: " + expected);
            System.out.println("Actual  : " + actual);
        }
    }
}

[subh kumar]

subh kumar wrote://soln by [e-mail]

/////////////////////////////////////////////////////[color=darkred]solution 1[/color]///////////////////////////////////////////////////////////
 public static Map<String, Integer> wordOccurrence(String sentence)
    { 
    	  
    	final Map<String, Integer> hshmap = new HashMap<String, Integer>();  
    	Arrays.asList(sentence.toLowerCase().split(" ")).forEach(new Consumer<String>() {
    	    public void accept(String value) {
    	    	hshmap.put(value, hshmap.containsKey(value)? hshmap.get(value) + 1: 1);  
    	    }
    	});    		
        return hshmap;  
    }  
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////[color=darkblue]solution 2[/color] //////////////////////////////////////////////////////////////

import java.util.HashMap;
import java.util.Map;[code=java]

public class GeeConComp {

    public static Map<String, Integer> wordOccurrence(String sentence) {
        // Your solution goes here
    	Map<String, Integer> MyWordOccurrence1 = new HashMap<>();
    	String parts[]=sentence.split(" "); // stores sentence word in string array(parts)
    	int count=0;
    	for(String s:parts) //picks one by one words from string array(parts)
    	{
    		count=0;
    		for(int i=0;i<parts.length;i++) //moves from each word to next word of sentence
    		{
    			if(s.equalsIgnoreCase(parts[i]))//if match found
    					{
    						count++;  
    						
    					}
    		}
    		MyWordOccurrence1.put(s.toLowerCase(), count); //puts string lower case in Map which puts  unique name and no duplication  
    		
    	}    	
    	
        return MyWordOccurrence1;       
    	
    }

    public static void main(String[] args) {
        System.out.println("CodeRanch GeeCON Prague 2014 competition");
        System.out.println("========================================");
        String sentence1 = "I really REALLY love CodeRanch";
        Map><String, Integer> expectedWordOccurrence1 = new HashMap<>();
        expectedWordOccurrence1.put("i", 1);
        expectedWordOccurrence1.put("really", 2);
        expectedWordOccurrence1.put("love", 1);
        expectedWordOccurrence1.put("coderanch", 1);
        assertOccurrences(expectedWordOccurrence1, wordOccurrence(sentence1));

        String sentence2 = "Good better best may I never rest until my good is better and my better best";
        Map<String, Integer> expectedWordOccurrence2 = new HashMap<>();
        expectedWordOccurrence2.put("good", 2);
        expectedWordOccurrence2.put("better", 3);
        expectedWordOccurrence2.put("best", 2);
        expectedWordOccurrence2.put("may", 1);
        expectedWordOccurrence2.put("i", 1);
        expectedWordOccurrence2.put("never", 1);
        expectedWordOccurrence2.put("rest", 1);
        expectedWordOccurrence2.put("until", 1);
        expectedWordOccurrence2.put("my", 2);
        expectedWordOccurrence2.put("is", 1);
        expectedWordOccurrence2.put("and", 1);
        assertOccurrences(expectedWordOccurrence2, wordOccurrence(sentence2));
    }

    private static void assertOccurrences(Map<String, Integer> expected, Map<String, Integer> actual) {
        if (expected.equals(actual)) {
            System.out.println("Test PASS :)");
        } else {
            System.out.println("Test FAIL :(");
            System.out.println("Expected: " + expected);
            System.out.println("Actual  : " + actual);
        }
    }
}

[subh kumar]

subh kumar wrote:

subh kumar wrote://soln by [e-mail]

/////////////////////////////////////////////////////[color=darkred]solution 1[/color]///////////////////////////////////////////////////////////
 public static Map<String, Integer> wordOccurrence(String sentence)
    { 
    	  
    	final Map<String, Integer> hshmap = new HashMap<String, Integer>();  
    	Arrays.asList(sentence.toLowerCase().split(" ")).forEach(new Consumer<String>() {
    	    public void accept(String value) {
    	    	hshmap.put(value, hshmap.containsKey(value)? hshmap.get(value) + 1: 1);  
    	    }
    	});    		
        return hshmap;  
    }  
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////[color=darkblue]solution 2[/color] //////////////////////////////////////////////////////////////

import java.util.HashMap;
import java.util.Map;[code=java]

public class GeeConComp {

    public static Map<String, Integer> wordOccurrence(String sentence) {
        // Your solution goes here
    	Map<String, Integer> MyWordOccurrence1 = new HashMap<>();
    	String parts[]=sentence.split(" "); // stores sentence word in string array(parts)
    	int count=0;
    	for(String s:parts) //picks one by one words from string array(parts)
    	{
    		count=0;
    		for(int i=0;i<parts.length;i++) //moves from each word to next word of sentence
    		{
    			if(s.equalsIgnoreCase(parts[i]))//if match found
    					{
    						count++;  
    						
    					}
    		}
    		MyWordOccurrence1.put(s.toLowerCase(), count); //puts string lower case in Map which puts  unique name and no duplication  
    		
    	}    	
    	
        return MyWordOccurrence1;       
    	
    }

    public static void main(String[] args) {
        System.out.println("CodeRanch GeeCON Prague 2014 competition");
        System.out.println("========================================");
        String sentence1 = "I really REALLY love CodeRanch";
        Map><String, Integer> expectedWordOccurrence1 = new HashMap<>();
        expectedWordOccurrence1.put("i", 1);
        expectedWordOccurrence1.put("really", 2);
        expectedWordOccurrence1.put("love", 1);
        expectedWordOccurrence1.put("coderanch", 1);
        assertOccurrences(expectedWordOccurrence1, wordOccurrence(sentence1));

        String sentence2 = "Good better best may I never rest until my good is better and my better best";
        Map<String, Integer> expectedWordOccurrence2 = new HashMap<>();
        expectedWordOccurrence2.put("good", 2);
        expectedWordOccurrence2.put("better", 3);
        expectedWordOccurrence2.put("best", 2);
        expectedWordOccurrence2.put("may", 1);
        expectedWordOccurrence2.put("i", 1);
        expectedWordOccurrence2.put("never", 1);
        expectedWordOccurrence2.put("rest", 1);
        expectedWordOccurrence2.put("until", 1);
        expectedWordOccurrence2.put("my", 2);
        expectedWordOccurrence2.put("is", 1);
        expectedWordOccurrence2.put("and", 1);
        assertOccurrences(expectedWordOccurrence2, wordOccurrence(sentence2));
    }

    private static void assertOccurrences(Map<String, Integer> expected, Map<String, Integer> actual) {
        if (expected.equals(actual)) {
            System.out.println("Test PASS :)");
        } else {
            System.out.println("Test FAIL :(");
            System.out.println("Expected: " + expected);
            System.out.println("Actual  : " + actual);
        }
    }
}

[subh kumar]

subh kumar wrote:

subh kumar wrote:

subh kumar wrote://soln by [e-mail]

/////////////////////////////////////////////FINAL SOLUTION   ///////////////////////////////////////////////////////
 public static Map<String, Integer> wordOccurrence(String sentence)
    { 
    	  
    	final Map<String, Integer> hshmap = new HashMap<String, Integer>();  
    	Arrays.asList(sentence.toLowerCase().split(" ")).forEach(new Consumer<String>() {
    	    public void accept(String value) {
    	    	hshmap.put(value, hshmap.containsKey(value)? hshmap.get(value) + 1: 1);  
    	    }
    	});    		
        return hshmap;  
    }  
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[subh kumar]

subh kumar wrote:

subh kumar wrote:

subh kumar wrote:

subh kumar wrote://soln by [e-mail]

/////////////////////////////////////////////FINAL SOLUTION   ///////////////////////////////////////////////////////
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;
 public static Map<String, Integer> wordOccurrence(String sentence)
    { 
    	  
    	final Map<String, Integer> hshmap = new HashMap<String, Integer>();  
    	Arrays.asList(sentence.toLowerCase().split("\\s+")).forEach(new Consumer<String>() {
    	    public void accept(String value) {
    	    	hshmap.put(value, hshmap.containsKey(value)? hshmap.get(value) + 1: 1);  
    	    }
    	});    		
        return hshmap;  
    }