Recieving Comparator Class type

Recieving Comparator Class type - java

I have two Comparators. One for sorting words by first letter (in sort used only for vowel words)
public class FirstLetterComparator extends ComparatorType {
#Override
public int compare(String o1, String o2) {
String upperObject1 = o1.toUpperCase();
String upperObject2 = o2.toUpperCase();
return upperObject1.charAt(0) - upperObject2.charAt(0);
}
}
Another for sorting by length/vowelsCount coef(used for all words in sort class)
public class VowelColComparator extends ComparatorType {
String vowelGroup = "AEIOUaeiou";
#Override
public int compare(String o1, String o2) {
int vCount1 = getVowelCount(o1);
int vCount2 = getVowelCount(o2);
float compareCoef1 = o1.length()/vCount1;
float compareCoef2 = o2.length()/vCount2;
return (int)(compareCoef1 - compareCoef2);
}
public int getVowelCount(String word){
int vowelCount = 0;
for (int i = 0; i < word.length(); i++){
char ch = word.charAt(i);
for (int j = 0; j < vowelGroup.length(); j++){
char v = vowelGroup.charAt(j);
if(ch == v)
vowelCount++;
}
}
return vowelCount;
}
And their superclass
public class ComparatorType implements Comparator<String> {
#Override
public int compare(String o1, String o2) {
return 0;
}
}
In sort class i have two similar methods for sorting my list
public class SortWords {
public static void sortVowelCol(String text, String regex){
Scanner scanner = new Scanner(text);
List<String> words = new ArrayList<>();
System.out.println();
System.out.println("Task1:");
while (scanner.hasNext()){
String word = scanner.next();
if(word.matches(regex)){
words.add(word);
}
}
Collections.sort(words, new VowelColComparator());
int lineCounter = 1;
System.out.println();
System.out.println();
System.out.println("Sorted Words:");
lineCounter = 1;
for(String w : words){
if(lineCounter == 12) {
System.out.print(w + "\n");
lineCounter = 0;
}
else
System.out.print(w + " ");
lineCounter++;
}
}
public static void sortVowelWords(String text, String regex) {
Scanner scanner = new Scanner(text);
List<String> vowelWords = new ArrayList<>();
System.out.println();
System.out.println("Task2: ");
while(scanner.hasNext()){
String word = scanner.next();
if(word.matches(regex)){
vowelWords.add(word);
}
}
Collections.sort(vowelWords, new FirstLetterComparator());
System.out.println();
System.out.println();
System.out.println("Sorted List:");
int lineCounter = 1;
for(String w : vowelWords){
if(lineCounter == 12) {
System.out.print(w + "\n");
lineCounter = 0;
}
else
System.out.print(w + " ");
lineCounter++;
}
}
}
Main class
public class Main {
public static void main(String[] args) {
// write your code here
SingletonText.getInstance().parse();
SingletonText.getInstance().print();
SortWords.sortVowelWords(SingletonText.getInstance().getText().toString(), "^[AEIOUaeiou].*");
SortWords.sortVowelCol(SingletonText.getInstance().getText().toString(), "^[A-Za-z].*");
}
}
The quesuion is how can i make only one method instead of two similar methods in SortWords class? Or how to get comparator type in for Collections.sort argument?

You may use a third parameter to define the comparator to use.
public static void sort(String text, String regex, ComparatorType comp) {
// Code
Collections.sort(words, comp);
// Code
}

you need refactor two function like that:
public static void sortVowel(String text, String regex,Comparator comparator) {
Scanner scanner = new Scanner(text);
List<String> vowelWords = new ArrayList<>();
System.out.println();
System.out.println("Task2: ");
while(scanner.hasNext()){
String word = scanner.next();
if(word.matches(regex)){
vowelWords.add(word);
}
}
Collections.sort(vowelWords, comparator);
System.out.println();
System.out.println();
System.out.println("Sorted List:");
int lineCounter = 1;
for(String w : vowelWords){
if(lineCounter == 12) {
System.out.print(w + "\n");
lineCounter = 0;
}
else
System.out.print(w + " ");
lineCounter++;
}
}
}

public static void sort(String text, String regex, String sortType) {
Collections.sort(words, sorttype.equals("Vowel") ? new VowelColComparator() : new FirstLetterComparator());
// Your code
}
Then we can call like this
SortWords.sort(SingletonText.getInstance().getText().toString(), "^[AEIOUaeiou].*", "Vowel");
SortWords.sort(SingletonText.getInstance().getText().toString(), "^[A-Za-z].*", "firstletter");

First of all your VowelColComparator.getVowelCount may fail due to division by zero when there is no vowel in given string. As you are comparing ratios of length and vowel count, you can do the following:
float compareCoef1 = o1.length()/(vCount1+1);
float compareCoef2 = o2.length()/(vCount2+1);
You can use factory pattern in ComparatorType class. i.e ComparatorType class will decide which instance (comparator) to use depending upon regex. You can add as many comparators as you like.
public abstract class ComparatorType implements Comparator<String> {
final public String vowelFirstLetterRegex = "^[A-Za-z].*";
final public String vowelColRegex = "^[AEIOUaeiou].*]";
public static ComparatorType getInstance(String regex) {
if (regex.equals(vowelColRegex))
return new VowelColComparator();
else if(regex.equals(vowelFirstLetterRegex ))
return new FirstLetterComparator();
return null;
}
}
And your SortWords class will have following method:
public static void sort(String text, String regex){
Scanner scanner = new Scanner(text);
List<String> words = new ArrayList<>();
System.out.println();
System.out.println("Task1:");
while (scanner.hasNext()){
String word = scanner.next();
if(word.matches(regex)){
words.add(word);
}
}
Collections.sort(words, ComparatorType.getInstance(regex));
int lineCounter = 1;
System.out.println();
System.out.println();
System.out.println("Sorted Words:");
lineCounter = 1;
for(String w : words){
if(lineCounter == 12) {
System.out.print(w + "\n");
lineCounter = 0;
}
else
System.out.print(w + " ");
lineCounter++;
}
}

Well, as everyone said, you need to pass Comparator<String> as the third argument to your method:
sortVowelWords(String text, String regex, Comparator<String> cmp) {
//...
}
I'd like to suggest some improvements to comparators themselves. Using lambda syntax, they may be written far more easily:
static final Comparator<String> CMP_BY_FIRST_CHAR =
Comparator.comparing(s -> Character.toUpperCase(s.charAt(0)));
static final Comparator<String> CMP_BY_VOWEL_COEF =
Comparator.comparing(s -> 1f * s.length() / s.replaceAll("[^AEIOUaeiou]+", "").length());
In second comparator, I added explicit cast to float to handle possible infinity values properly.

Related

How to make sure the Print statement is executed only when the characters are distinct?

So, I'm writing a program for String compression. if the input is aabbccc, the output should be a2b2c3.
But in my program, my output is a2a2b2b2c3c3c3. That is because my Print statement is in a for loop. Which isn't supposed to be there.
How can I execute the print statement only when two characters in the String are not equal? so that I get the right output?
I've tried other ways of doing the String Compression program, but this way using Collections seems the easiest to me.
public class Compress {
static int i;
static int freq;
public static void main(String args[]) {
System.out.println("Enter a String");
Scanner sc= new Scanner(System.in);
String str=sc.nextLine();
List<Character> arrlist = new ArrayList<Character>();
for(int i=0; i<str.length();i++){
arrlist.add(str.charAt(i));
}
for(int i=0; i<str.length();i++){
freq = Collections.frequency(arrlist, str.charAt(i));
System.out.print(str.charAt(i)+""+freq);
}
}
}
Desired result
Input: aabbccc
Output: a2b2c3
What I'm getting
Input: aabbccc
Output: a2a2b2b2c3c3c3

You can use the following code, there is no need to have 2 nested loops to do the compression. One loop passing through the input string is more than enough.
class Compress {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a string: ");
String inputString = scanner.nextLine();
scanner.close();
System.out.println("Compressed Input: " + compressInput(inputString));
}
private static String compressInput(String str) {
if(str.isEmpty())
return "";
if(str.length() == 1)
return str + "1";
StringBuilder result = new StringBuilder();
int cmpt = 1;
for (int i = 1; i < str.length(); i++) {
if(str.charAt(i - 1) == str.charAt(i))
cmpt++;
else {
result.append(str.charAt(i-1));
result.append(cmpt);
cmpt=1;
}
}
result.append(str.charAt(str.length()-1));
result.append(cmpt);
return result.toString();
}
}
Example of output:
Enter a string: aaabbbbccddddeeeefg
Compressed Input: a3b4c2d4e4f1g1

Collections.frequency does give you the count as you can see in your output, but the problem here is that you need to group by each character in the String.
Make use of a Map:
Map<Character, Long> countMap = new HashMap<>();
for (int i = 0; i < inputString.length(); i++) {
countMap.merge(Character.valueOf(inputString.charAt(i)), 1L, (k, v) -> k + v);
}
countMap.forEach((k, v) -> System.out.print(k + "" + v));

You could also do it in a similar manner as below. I have made use of a map wherein the key is the character and the value is the frequency of occurrence.
public class Compress {
static int i;
static int freq;
public static void main(String args[]) {
System.out.println("Enter a String");
Scanner sc = new Scanner(System.in);
HashMap<Character, Integer> hmap = new HashMap<>();
String str = sc.nextLine();
List<Character> arrlist = new ArrayList<Character>();
for (int i = 0; i < str.length(); i++) {
arrlist.add(str.charAt(i));
}
for (int i = 0; i < str.length(); i++) {
freq = Collections.frequency(arrlist, str.charAt(i));
hmap.put(str.charAt(i), freq);
}
for (Character c : hmap.keySet()) {
System.out.print(c + "" + hmap.get(c));
}
}
}

Same word occurrence in a string. Java [duplicate]

I am writing a very basic java program that calculates frequency of each word in a sentence so far i managed to do this much
import java.io.*;
class Linked {
public static void main(String args[]) throws IOException {
BufferedReader br = new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Enter the sentence");
String st = br.readLine();
st = st + " ";
int a = lengthx(st);
String arr[] = new String[a];
int p = 0;
int c = 0;
for (int j = 0; j < st.length(); j++) {
if (st.charAt(j) == ' ') {
arr[p++] = st.substring(c,j);
c = j + 1;
}
}
}
static int lengthx(String a) {
int p = 0;
for (int j = 0; j < a.length(); j++) {
if (a.charAt(j) == ' ') {
p++;
}
}
return p;
}
}
I have extracted each string and stored it in a array , now problem is actually how to count the no of instances where each 'word' is repeated and how to display so that repeated words not get displayed multiple times , can you help me in this one ?

Use a map with word as a key and count as value, somthing like this
Map<String, Integer> map = new HashMap<>();
for (String w : words) {
Integer n = map.get(w);
n = (n == null) ? 1 : ++n;
map.put(w, n);
}
if you are not allowed to use java.util then you can sort arr using some sorting algoritm and do this
String[] words = new String[arr.length];
int[] counts = new int[arr.length];
words[0] = words[0];
counts[0] = 1;
for (int i = 1, j = 0; i < arr.length; i++) {
if (words[j].equals(arr[i])) {
counts[j]++;
} else {
j++;
words[j] = arr[i];
counts[j] = 1;
}
}
An interesting solution with ConcurrentHashMap since Java 8
ConcurrentMap<String, Integer> m = new ConcurrentHashMap<>();
m.compute("x", (k, v) -> v == null ? 1 : v + 1);

In Java 8, you can write this in two simple lines! In addition you can take advantage of parallel computing.
Here's the most beautiful way to do this:
Stream<String> stream = Stream.of(text.toLowerCase().split("\\W+")).parallel();
Map<String, Long> wordFreq = stream
.collect(Collectors.groupingBy(String::toString,Collectors.counting()));

import java.util.*;
public class WordCounter {
public static void main(String[] args) {
String s = "this is a this is this a this yes this is a this what it may be i do not care about this";
String a[] = s.split(" ");
Map<String, Integer> words = new HashMap<>();
for (String str : a) {
if (words.containsKey(str)) {
words.put(str, 1 + words.get(str));
} else {
words.put(str, 1);
}
}
System.out.println(words);
}
}
Output:
{a=3, be=1, may=1, yes=1, this=7, about=1, i=1, is=3, it=1, do=1, not=1, what=1, care=1}

Try this
public class Main
{
public static void main(String[] args)
{
String text = "the quick brown fox jumps fox fox over the lazy dog brown";
String[] keys = text.split(" ");
String[] uniqueKeys;
int count = 0;
System.out.println(text);
uniqueKeys = getUniqueKeys(keys);
for(String key: uniqueKeys)
{
if(null == key)
{
break;
}
for(String s : keys)
{
if(key.equals(s))
{
count++;
}
}
System.out.println("Count of ["+key+"] is : "+count);
count=0;
}
}
private static String[] getUniqueKeys(String[] keys)
{
String[] uniqueKeys = new String[keys.length];
uniqueKeys[0] = keys[0];
int uniqueKeyIndex = 1;
boolean keyAlreadyExists = false;
for(int i=1; i<keys.length ; i++)
{
for(int j=0; j<=uniqueKeyIndex; j++)
{
if(keys[i].equals(uniqueKeys[j]))
{
keyAlreadyExists = true;
}
}
if(!keyAlreadyExists)
{
uniqueKeys[uniqueKeyIndex] = keys[i];
uniqueKeyIndex++;
}
keyAlreadyExists = false;
}
return uniqueKeys;
}
}
Output:
the quick brown fox jumps fox fox over the lazy dog brown
Count of [the] is : 2
Count of [quick] is : 1
Count of [brown] is : 2
Count of [fox] is : 3
Count of [jumps] is : 1
Count of [over] is : 1
Count of [lazy] is : 1
Count of [dog] is : 1

From Java 10 you can use the following:
import java.util.Arrays;
import java.util.stream.Collectors;
public class StringFrequencyMap {
public static void main(String... args){
String[] wordArray = {"One", "One", "Two","Three", "Two", "two"};
var freq = Arrays.stream(wordArray)
.collect(Collectors.groupingBy(x -> x, Collectors.counting()));
System.out.println(freq);
}
}
Output:
{One=2, two=1, Two=2, Three=1}

You could try this
public static void frequency(String s) {
String trimmed = s.trim().replaceAll(" +", " ");
String[] a = trimmed.split(" ");
ArrayList<Integer> p = new ArrayList<>();
for (int i = 0; i < a.length; i++) {
if (p.contains(i)) {
continue;
}
int d = 1;
for (int j = i+1; j < a.length; j++) {
if (a[i].equals(a[j])) {
d += 1;
p.add(j);
}
}
System.out.println("Count of "+a[i]+" is:"+d);
}
}

package naresh.java;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
public class StringWordDuplicates {
static void duplicate(String inputString){
HashMap<String, Integer> wordCount = new HashMap<String,Integer>();
String[] words = inputString.split(" ");
for(String word : words){
if(wordCount.containsKey(word)){
wordCount.put(word, wordCount.get(word)+1);
}
else{
wordCount.put(word, 1);
}
}
//Extracting of all keys of word count
Set<String> wordsInString = wordCount.keySet();
for(String word : wordsInString){
if(wordCount.get(word)>1){
System.out.println(word+":"+wordCount.get(word));
}
}
}
public static void main(String args[]){
duplicate("I am Java Programmer and IT Server Programmer with Java as Best Java lover");
}
}

class find
{
public static void main(String nm,String w)
{
int l,i;
int c=0;
l=nm.length();String b="";
for(i=0;i<l;i++)
{
char d=nm.charAt(i);
if(d!=' ')
{
b=b+d;
}
if(d==' ')
{
if(b.compareTo(w)==0)
{
c++;
}
b="";
}
}
System.out.println(c);
}
}

public class wordFrequency {
private static Scanner scn;
public static void countwords(String sent) {
sent = sent.toLowerCase().replaceAll("[^a-z ]", "");
ArrayList<String> arr = new ArrayList<String>();
String[] sentarr = sent.split(" ");
Map<String, Integer> a = new HashMap<String, Integer>();
for (String word : sentarr) {
arr.add(word);
}
for (String word : arr) {
int count = Collections.frequency(arr, word);
a.put(word, count);
}
for (String key : a.keySet()) {
System.out.println(key + " = " + a.get(key));
}
}
public static void main(String[] args) {
scn = new Scanner(System.in);
System.out.println("Enter sentence:");
String inp = scn.nextLine();
countwords(inp);
}
}

Determine the frequency of words in a file.
File f = new File(fileName);
Scanner s = new Scanner(f);
Map<String, Integer> counts =
new Map<String, Integer>();
while( s.hasNext() ){
String word = s.next();
if( !counts.containsKey( word ) )
counts.put( word, 1 );
else
counts.put( word,
counts.get(word) + 1 );
}

The following program finds the frequency, sorts it accordingly, and prints it.
Below is the output grouped by frequency:
0-10:
The 2
Is 4
11-20:
Have 13
Done 15
Here is my program:
package com.company;
import java.io.*;
import java.util.*;
import java.lang.*;
/**
* Created by ayush on 12/3/17.
*/
public class Linked {
public static void main(String args[]) throws IOException {
BufferedReader br = new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Enter the sentence");
String st = br.readLine();
st=st.trim();
st = st + " ";
int count = lengthx(st);
System.out.println(count);
String arr[] = new String[count];
int p = 0;
int c = 0;
for (int i = 0; i < st.length(); i++) {
if (st.charAt(i) == ' ') {
arr[p] = st.substring(c,i);
System.out.println(arr[p]);
c = i + 1;
p++;
}
}
Map<String, Integer> map = new HashMap<>();
for (String w : arr) {
Integer n = map.get(w);
n = (n == null) ? 1 : ++n;
map.put(w, n);
}
for (String key : map.keySet()) {
System.out.println(key + " = " + map.get(key));
}
Set<Map.Entry<String, Integer>> entries = map.entrySet();
Comparator<Map.Entry<String, Integer>> valueComparator = new Comparator<Map.Entry<String,Integer>>() {
#Override
public int compare(Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2) {
Integer v1 = e1.getValue();
Integer v2 = e2.getValue();
return v1.compareTo(v2); }
};
List<Map.Entry<String, Integer>> listOfEntries = new ArrayList<Map.Entry<String, Integer>>(entries);
Collections.sort(listOfEntries, valueComparator);
LinkedHashMap<String, Integer> sortedByValue = new LinkedHashMap<String, Integer>(listOfEntries.size());
for(Map.Entry<String, Integer> entry : listOfEntries){
sortedByValue.put(entry.getKey(), entry.getValue());
}
for(Map.Entry<String, Integer> entry : listOfEntries){
sortedByValue.put(entry.getKey(), entry.getValue());
}
System.out.println("HashMap after sorting entries by values ");
Set<Map.Entry<String, Integer>> entrySetSortedByValue = sortedByValue.entrySet();
for(Map.Entry<String, Integer> mapping : entrySetSortedByValue){
System.out.println(mapping.getKey() + " ==> " + mapping.getValue());
}
}
static int lengthx(String a) {
int count = 0;
for (int j = 0; j < a.length(); j++) {
if (a.charAt(j) == ' ') {
count++;
}
}
return count;
}
}

import java.io.*;
class Linked {
public static void main(String args[]) throws IOException {
BufferedReader br = new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Enter the sentence");
String st = br.readLine();
st = st + " ";
int a = lengthx(st);
String arr[] = new String[a];
int p = 0;
int c = 0;
for (int j = 0; j < st.length(); j++) {
if (st.charAt(j) == ' ') {
arr[p++] = st.substring(c,j);
c = j + 1;
}
}
}
static int lengthx(String a) {
int p = 0;
for (int j = 0; j < a.length(); j++) {
if (a.charAt(j) == ' ') {
p++;
}
}
return p;
}
}

Simply use Java 8 Stream collectors groupby function:
import java.util.function.Function;
import java.util.stream.Collectors;
static String[] COUNTRY_NAMES
= { "China", "Australia", "India", "USA", "USSR", "UK", "China",
"France", "Poland", "Austria", "India", "USA", "Egypt", "China" };
Map<String, Long> result = Stream.of(COUNTRY_NAMES).collect(
Collectors.groupingBy(Function.identity(), Collectors.counting()));

Count frequency of elements of list in java 8
List<Integer> list = new ArrayList<Integer>();
Collections.addAll(list,3,6,3,8,4,9,3,6,9,4,8,3,7,2);
Map<Integer, Long> frequencyMap = list.stream().collect(Collectors.groupingBy(Function.identity(),Collectors.counting()));
System.out.println(frequencyMap);
Note :
For String frequency counting split the string and convert it to list and use streams for count frequency => (Map frequencyMap)*
Check below link

String s[]=st.split(" ");
String sf[]=new String[s.length];
int count[]=new int[s.length];
sf[0]=s[0];
int j=1;
count[0]=1;
for(int i=1;i<s.length;i++)
{
int t=j-1;
while(t>=0)
{
if(s[i].equals(sf[t]))
{
count[t]++;
break;
}
t--;
}
if(t<0)
{
sf[j]=s[i];
count[j]++;
j++;
}
}

Created a simple easy to understand solution for this problem covers all test cases-
import java.util.HashMap;
import java.util.Map;
/*
* Problem Statement - Count Frequency of each word in a given string, ignoring special characters and space
* Input 1 - "To be or Not to be"
* Output 1 - to(2 times), be(2 times), or(1 time), not(1 time)
*
* Input 2 -"Star 123 ### 123 star"
* Output - Star(2 times), 123(2 times)
*/
public class FrequencyofWords {
public static void main(String[] args) {
String s1="To be or not **** to be! is all i ask for";
fnFrequencyofWords(s1);
}
//-------Supporting Function-----------------
static void fnFrequencyofWords(String s1) {
//------- Convert String to proper format----
s1=s1.replaceAll("[^A-Za-z0-9\\s]","");
s1=s1.replaceAll(" +"," ");
s1=s1.toLowerCase();
//-------Create String to an array with words------
String[] s2=s1.split(" ");
System.out.println(s1);
//-------- Create a HashMap to store each word and its count--
Map <String , Integer> map=new HashMap<String, Integer>();
for(int i=0;i<s2.length;i++) {
if(map.containsKey(s2[i])) //---- Verify if Word Already Exits---
{
map.put(s2[i], 1+ map.get(s2[i])); //-- Increment value by 1 if word already exits--
}
else {
map.put(s2[i], 1); // --- Add Word to map and set value as 1 if it does not exist in map--
}
}
System.out.println(map); //--- Print the HashMap with Key, Value Pair-------
}
}

public class WordFrequencyProblem {
public static void main(String args[]){
String s="the quick brown fox jumps fox fox over the lazy dog brown";
String alreadyProcessedWords="";
boolean isCount=false;
String[] splitWord = s.split("\\s|\\.");
for(int i=0;i<splitWord.length;i++){
String word = splitWord[i];
int count = 0;
isCount=false;
if(!alreadyProcessedWords.contains(word)){
for(int j=0;j<splitWord.length;j++){
if(word.equals(splitWord[j])){
count++;
isCount = true;
alreadyProcessedWords=alreadyProcessedWords+word+" ";
}
}
}
if(isCount)
System.out.println(word +"Present "+ count);
}
}
}

public class TestSplit {
public static void main(String[] args) {
String input="Find the repeated word which is repeated in this string";
List<String> output= (List) Arrays.asList(input.split(" "));
for(String str: output) {
int occurrences = Collections.frequency(output, str);
System.out.println("Occurence of " + str+ " is "+occurrences);
}
System.out.println(output);
}
}

Please try these it may be help for you
public static void main(String[] args) {
String str1="I am indian , I am proud to be indian proud.";
Map<String,Integer> map=findFrquenciesInString(str1);
System.out.println(map);
}
private static Map<String,Integer> findFrquenciesInString(String str1) {
String[] strArr=str1.split(" ");
Map<String,Integer> map=new HashMap<>();
for(int i=0;i<strArr.length;i++) {
int count=1;
for(int j=i+1;j<strArr.length;j++) {
if(strArr[i].equals(strArr[j]) && strArr[i]!="-1") {
strArr[j]="-1";
count++;
}
}
if(count>1 && strArr[i]!="-1") {
map.put(strArr[i], count);
strArr[i]="-1";
}
}
return map;
}

try this
public void count()throws IOException
{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
System.out.println("enetr the strring");
String s = in.readLine();
int l = s.length();
int a=0,b=0,c=0,i,j,y=0;
char d;
String x;
String n[] = new String [50];
int m[] = new int [50];
for (i=0;i<50;i++)
{
m[i]=0;
}
for (i=0;i<l;i++)
{
d = s.charAt(i);
if((d==' ')||(d=='.'))
{
x = s.substring(a,i);
a= i+1;
for(j=0;j<b;j++)
{
if(x.equalsIgnoreCase(n[j]) == true)
{
m[j]++;
c = 1;
}
}
if(c==0)
{
n[b] = x;
m[b] = 1;
b++;
}
}
c=0;
}
for(i=0;i<b;i++)
{
for (j=0;j<b;j++)
{
if(y<m[j])
{
y=m[j];
}
}
if(m[i]==y)
{
System.out.println(n[i] + " : " + m[i]);
m[i]=0;
}
y=0;
}
}

Sorting a list of strings based on number of words

I have a file that dumps every line into a position in an ArrayList and I want the user to be able to sort the list to only having lines that have a certain number of words. I can't figure out how to make it print the remaining list (of correct numbered entries).
It starts by finding the first word in the list then it iterates through the CharSequence and checks if the character is equal to a space, ' ' If it is, then it increments nWords by 1 and if nWords is not equal to userInput(the number the user inputs to sort the list by number of words), it should remove that item from the list.
ArrayList<CharSequence> str = new ArrayList();
str.add("Hello");
str.add("Hi there");
str.add("toad");
str.add("i see you");
System.out.println("How many words?");
Scanner scan = new Scanner(System.in);
int userInput = scan.nextInt();
for (int loopNumber = 0; loopNumber < str.size(); ) {
int nWords = 1;
for (int i = 0; i < str.get(loopNumber).length(); i++) {
if ( str.get(loopNumber).charAt(i) == ' ') {
nWords++;
if (nWords != userInput) {
str.remove(loopNumber);
}
}
}
loopNumber++;
}

You don't need to sort. You need to remove those lines without the correct number of words.
for this task, an Iterator is the weapon of choice, because you can call its remove() method while iterating:
for (Iterator<String> i = str.iterator(); i.hasNext();) {
if (i.next().split(" +").length != userInput)
i.remove();
}
That's all there is to it.
Also note the considerably more succinct way of counting words via the split() method.

Try something like this ..... (the compare method might not be the most efficient one!)
ArrayList<String> str = new ArrayList<String>();
str.add("Hello");
str.add("Hi there");
str.add("toad");
str.add("i see you");
Comparator<String> stringComparator = new Comparator<String>() {
#Override
public int compare(String o1, String o2) {
String [] words1 = null;
String [] words2 = null;
try {
words1 = o1.split(" ");
words2 = o2.split(" ");
} catch (Exception e) {
//ignore
}
if (words1 != null && words2 != null) {
if (words1.length > words2.length) {
return 1;
} else if (words1.length == words2.length) {
return 0;
} else {
return -1;
}
} else if (words1 != null) {
return 1;
} else {
return -1;
}
}
};
Collections.sort(str, stringComparator);

You can use the Comparator interface. Check below example
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class SortedList {
public static void main(String[] args) {
ArrayList<SimpleString> strArray = new ArrayList<SimpleString>();
strArray.add(new SimpleString("String"));
strArray.add(new SimpleString("abc"));
strArray.add(new SimpleString("Test String"));
Collections.sort(strArray, new SimpleString(""));
for (SimpleString str : strArray) {
System.out.println(str.getTestString());
}
}
}
class SimpleString implements Comparator<SimpleString> {
String testString;
public SimpleString(String testString) {
this.testString = testString;
}
public String getTestString() {
return testString;
}
public void setTestString(String testString) {
this.testString = testString;
}
#Override
public int compare(SimpleString o1, SimpleString o2) {
// TODO Auto-generated method stub
int strLength = o1.getTestString().length()
- o2.getTestString().length();
return strLength;
}
}

Single character instance from string

i was wondering how can i create a method where i can get the single instance from a string and give it a numericValue for example, if theres a String a = "Hello what the hell" there are 4 l characters and i want to give a substring from the String a which is Hello and give it numeric values. Right now in my program it gets all the character instances from string so the substring hello would get number values from the substring hell too because it also has the same characters.
my code :
public class Puzzle {
private static char[] letters = {'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'};
private static String input;
private static String delimiters = "\\s+|\\+|//+|=";
public static void main(String[]args)
{
input = "help + me = please";
System.out.println(putValues(input));
}
//method to put numeric values for substring from input
#SuppressWarnings("static-access")
public static long putValues(String input)
{
Integer count;
long answer = 0;
String first="";
String second = "";
StringBuffer sb = new StringBuffer(input);
int wordCounter = Countwords();
String[] words = countLetters();
System.out.println(input);
if(input.isEmpty())
{
System.out.println("Sisestage mingi s6na");
}
if(wordCounter == -1 ||countLetters().length < 1){
return -1;
}
for(Character s : input.toCharArray())
{
for(Character c : letters)
{
if(s.equals(c))
{
count = c.getNumericValue(c) - 9;
System.out.print(s.toUpperCase(s) +"="+ count + ", ");
}
}
if(words[0].contains(s.toString()))
{
count = s.getNumericValue(s);
//System.out.println(count);
first += count.toString();
}
if(words[3].contains(s.toString())){
count = s.getNumericValue(s);
second += count.toString();
}
}
try {
answer = Long.parseLong(first)+ Long.parseLong(second);
} catch(NumberFormatException ex)
{
System.out.println(ex);
}
System.out.println("\n" + first + " + " + second + " = " + answer);
return answer;
}
public static int Countwords()
{
String[] countWords = input.split(" ");
int counter = countWords.length - 2;
if(counter == 0) {
System.out.println("Sisend puudu!");
return -1;
}
if(counter > 1 && counter < 3) {
System.out.println("3 sõna peab olema");
return -1;
}
if(counter > 3) {
System.out.println("3 sõna max!");
return -1;
}
return counter;
}
//method which splits input String and returns it as an Array so i can put numeric values after in the
//putValue method
public static String[] countLetters()
{
int counter = 0;
String[] words = input.split(delimiters);
for(int i = 0; i < words.length;i++) {
counter = words[i].length();
if(words[i].length() > 18) {
System.out.println("One word can only be less than 18 chars");
}
}
return words;
}
Program has to solve the word puzzles where you have to guess which digit corresponds to which letter to make a given equality valid. Each letter must correspond to a different decimal digit, and leading zeros are not allowed in the numbers.
For example, the puzzle SEND+MORE=MONEY has exactly one solution: S=9, E=5, N=6, D=7, M=1, O=0, R=8, Y=2, giving 9567+1085=10652.

import java.util.ArrayList;
public class main {
private static String ChangeString;
private static String[] ArrayA;
private static String a;
private static int wordnumber;
private static String temp;
public static void main(String[] args) {
// TODO Auto-generated method stub
a = "hello what the hell";
wordnumber = 0;
identifyint(a,wordnumber);
}
public static void identifyint (String a, int WhichWord){
ChangeString = a.split(" ")[WhichWord];
ArrayA = a.split(" ");
replaceword();
ArrayA[wordnumber] = ChangeString;
//System.out.print(ArrayA[wordnumber]);
a = "";
for(int i = 0; i<ArrayA.length;i++){
if(i==wordnumber){
a = a.concat(temp+ " ");
}
else{
a = a.concat(ArrayA[i]+" ");
}
}
System.out.print(a);
}
public static void replaceword(){
temp = "";
Character arr[] = new Character[ChangeString.length()];
for(int i = 0; i<ChangeString.length();i++){
arr[i] = ChangeString.charAt(i);
Integer k = arr[i].getNumericValue(arr[i])-9;
temp = temp.concat(""+k);
}
a = temp;
}
}
Change wordnumber to the word you want to replace each time. If this is not what you have asked for, please explain your question in more detail.

How to reverse words of a Java String

Im trying to make a program to take input for a string from the scanner, but i want to break up the string that was inputed and reverse the order of words. This is what i have so far.
Scanner input = new Scanner(System.in);
System.out.println("Enter your string");
StringBuilder welcome = new StringBuilder(input.next());
int i;
for( i = 0; i < welcome.length(); i++ ){
// Will recognize a space in words
if(Character.isWhitespace(welcome.charAt(i))) {
Character a = welcome.charAt(i);
}
}
What I want to do is after it recognizes the space, capture everything before it and so on for every space, then rearrange the string.

Edit after questions.
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main( String[] args ) {
final String welcome = "How should we get words in string form a List?";
final List< String > words = Arrays.asList( welcome.split( "\\s" ));
Collections.reverse( words );
final String rev = words.stream().collect( Collectors.joining( ", " ));
System.out.println( "Your sentence, reversed: " + rev );
}
}
Execution:
Your sentence, reversed: List?, a, form, string, in, words, get, we, should, How

I did suggest first reverse the whole string.
Then reverse the substring between two spaces.
public class ReverseByWord {
public static String reversePart (String in){
// Reverses the complete string
String reversed = "";
for (int i=0; i<in.length(); i++){
reversed=in.charAt(i)+reversed;
}
return reversed;
}
public static String reverseByWord (String in){
// First reverses the complete string
// "I am going there" becomes "ereht gniog ma I"
// After that we just need to reverse each word.
String reversed = reversePart(in);
String word_reversal="";
int last_space=-1;
int j=0;
while (j<in.length()){
if (reversed.charAt(j)==' '){
word_reversal=word_reversal+reversePart(reversed.substring(last_space+1, j));
word_reversal=word_reversal+" ";
last_space=j;
}
j++;
}
word_reversal=word_reversal+reversePart(reversed.substring(last_space+1, in.length()));
return word_reversal;
}
public static void main(String[] args) {
// TODO code application logic here
System.out.println(reverseByWord("I am going there"));
}
}

Here is the way you can reversed the word in entered string:
Scanner input = new Scanner(System.in);
System.out.println("Enter your string");
String s = input.next();
if(!s.trim().contains(' ')) {
return s;
}
else {
StringBuilder reversedString = new StringBuilder();
String[] sa = s.trim().split(' ');
for(int i = sa.length() - 1; i >= 0: i - 1 ) {
reversedString.append(sa[i]);
reversedString.append(' ');
}
return reversedString.toString().trim();
}
Hope this helps.

If you wanted to reduce the number of line of code, I think you can look into my code :
package com.sujit;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class StatementReverse {
public static void main(String[] args) throws IOException {
String str;
String arr[];
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter a string:");
str = br.readLine();
arr = str.split("\\s+");
for (int i = arr.length - 1;; i--) {
if (i >= 0) {
System.out.print(arr[i] + " ");
} else {
break;
}
}
}
}

public class StringReverse {
public static void main(String[] args) {
String str="This is anil thakur";
String[] arr=str.split(" ");
StringBuilder builder=new StringBuilder("");
for(int i=arr.length-1; i>=0;i--){
builder.append(arr[i]+" ");
}
System.out.println(builder.toString());
}
}
Output: thakur anil is This

public class ReverseWordTest {
public static String charRev(String str) {
String revString = "";
String[] wordSplit = str.split(" ");
for (int i = 0; i < wordSplit.length; i++) {
String revWord = "";
String s2 = wordSplit[i];
for (int j = s2.length() - 1; j >= 0; j--) {
revWord = revWord + s2.charAt(j);
}
revString = revString + revWord + " ";
}
return revString;
}
public static void main(String[] args) {
System.out.println("Enter Your String: ");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
System.out.println(charRev(str));
}

public static void main(String[]args)
{
String one="Hello my friend, another way here";
String[]x=one.split(" ");
one="";
int count=0;
for(String s:x){
if(count==0||count==x.length) //that's for two edges.
one=s+one;
else
one=s+" "+one;
count++;
}
System.out.println(one); //reverse.
}

We Keep Coding

Java is a programming language and computing platform first released by Sun Microsystems in 1995.

Recieving Comparator Class type - java

You may use a third parameter to define the comparator to use. public static void sort(String text, String regex, ComparatorType comp) { // Code Collections.sort(words, comp); // Code }

Related

How to make sure the Print statement is executed only when the characters are distinct?

Same word occurrence in a string. Java [duplicate]

Sorting a list of strings based on number of words

Single character instance from string

How to reverse words of a Java String

Categories

Resources