Need help to remove duplicate from a string using recursion

[Winston Gutkowski]

Campbell Ritchie wrote:Can you have a sensible result from toString() on a Stream? A Stream is an Object, so you can use the un‑overridden version of toString, but how are you going to print its contents? A Stream does not “have” any contents...

Sure it does; it has elements. I just don't care how, where or when they're produced, providing they ARE produced when I use it.

And I say that an IntStream produced by String.chars() (which I - and I suspect Pawel - think should have been a CharStream) has very specific contents, which we are likely to want to convert back to a String at some point; so why not provide us with a simple way of doing it rather than having to faff about with that 'orrible collect() function.

Winston

[Campbell Ritchie]

Winston Gutkowski wrote:. . . Sure it does; it has elements. I just don't care how, where or when they're produced, providing they ARE produced when I use it. . . .

They are not so much produced as come from somewhere else, e.g. a List, or the preceding Stream. They don't so much exist in the Stream as run along it, so how are you going to catch them?

Yes, a CharSequence#charStream method would probably have been useful. And a CharStream class. But if it is so easy to write
mapToObj(i -> Character.valueOf((char)i)
I don't think it is going to happen.

[Winston Gutkowski]

Campbell Ritchie wrote:Yes, a CharSequence#charStream method would probably have been useful. And a CharStream class. But if it is so easy to write
mapToObj(i -> Character.valueOf((char)i)
I don't think it is going to happen.

Ooof. To get a Stream<Character> which is even more difficult to convert back to a String (or a char[])?

The fact is - as we tell beginners often enough - that characters are NOT numbers, even though char is a numeric type, so the likelihood of needing to do any number crunching with an IntStream returned by String.chars() seems very remote.

What doesn't seem remote to me is that I might want to do all kinds of filtering or replacement on such a stream - including stuff like using regexes - but all these tools are designed to work with chars, not ints. Furthermore, I'm likely to want to convert the result back (or into) to a String, or even an OutputStream.

It's not particularly the business of carrying the value of a char in an int that I object to; it's that no provision appears to have been made for the fact that people might want to manipulate streams of characters.

Winston

[Campbell Ritchie]

System.out.println(s.chars()
                    .mapToObj(i -> Character.valueOf((char)i)
                    .filter(c -> !Character.isVowel(c))
                    .map(String::valueOf)
                    .collect(collectors.joining()));

You are right, Winston, that this sort of code makes s.replaceAll("[aeiouAEIUO]", "") look really beautiful. I couldn't get such code to compile without the .map() call.

[Yousef Salah]

Hi all
i solved this problem this way

public class String_clean_recursion_problem {

    private static String temp = "";
    public static void main(String[] args) {
        clean_string(0, "xxxyyyzzx");
        System.out.println(temp);
    }
    public static String clean_string(int i , String str){
        char x;
        x = str.charAt(i);
        if(!(x == str.charAt(i+1))){temp += x;} 
        i++;
        if(i >= str.length()-1) {
            temp += str.charAt(i);
            return temp;
        }
        clean_string(i, str);
        return temp;
    }
    
}

this is my first participation , hope it was useful

[Knute Snortum]

Welcome to the Ranch!

What happens if you try this in your main method?

System.out.println(clean_string(0, "x"));

Some other thoughts: what happens when you make two calls to clean_string in main?

The Java convention for naming with multiple "words" is ThisIsAClassName and thisIsAMethodName. That is, camel case with classes starting with an uppercase letter and methods starting with a lowercase letter, no underscores.

[Yousef Salah]

Knute Snortum wrote:Welcome to the Ranch!

What happens if you try this in your main method?

System.out.println(clean_string(0, "x"));

Some other thoughts: what happens when you make two calls to clean_string in main?

The Java convention for naming with multiple "words" is ThisIsAClassName and thisIsAMethodName. That is, camel case with classes starting with an uppercase letter and methods starting with a lowercase letter, no underscores.

thanks for your corrections , i highly appreciate them

i fix the issues you mentioned except the case if i call cleanString multiple time because of the static string field ,
i tried to solve this issue by trying to copy the string object with "new" and return new string
but when clear the temp string it clears the new string object too
here is my code to clarify

public class String_clean_recursion_problem {

    private static String temp = "";
    public static void main(String[] args) {
        String result = cleanString(0, "x");
        System.out.println(result);
    }
    public static String cleanString(int i , String str){
        String result;
        if(i >= str.length()-1) {
            temp += str.charAt(i);
            result = new String(temp);
            //temp = "";  =====> this line
            return result;
        }
        char x = str.charAt(i);
        if(!(x == str.charAt(i+1))){temp += x;} 
        i++;
        cleanString(i, str);
        return temp;
    }
    
}

[Knute Snortum]

In general -- and especially when you are a beginning programmer -- the use of a static variable is a sign that something is wrong with the design. Can you think of a way to not use a static variable?

[Yousef Salah]

Knute Snortum wrote:In general -- and especially when you are a beginning programmer -- the use of a static variable is a sign that something is wrong with the design. Can you think of a way to not use a static variable?

yes , i just migrated from php +2 years exp. with strong understanding of oop , so do you have any advices for me about that ?
regarding the problem i removed the static variable but the problem is the same

variables in java have big difference from php

public class StringCleanProblem {

    private String temp = "";
    public static void main(String[] args) {
        StringCleanProblem newObj = new StringCleanProblem();
        String result = newObj.cleanString(0, "xxxyyvvz");
//        String result = cleanString(0, "x");
        System.out.println(result);
    }
    public String cleanString(int i , String str){
        String result;
        if(i >= str.length()-1) {
            temp += str.charAt(i);
            result = new String(temp);
//            temp = "";  //=====> this line
            return result;
        }
        char x = str.charAt(i);
        if(!(x == str.charAt(i+1))){temp += x;} 
        i++;
        cleanString(i, str);
        return temp;
    }
    
}

[Knute Snortum]

That code is better -- more OOP -- but what about not using any static or instance variable? What if you worked on the passed string itself?

[Javco Aract]

package javaapplication7;

public class JavaApplication7 {

    static public String stringClean(String str) {
        String Result = "";
        char[] strArry = str.toCharArray();

        for (int i = 1; i < str.length(); i++) {
            if (strArry[i] != strArry[i - 1]) {
                Result += strArry[i - 1];
            }
            
        }
        Result += strArry[str.length()-1];
        return Result;
    }


public static void main(String[] args) {
        System.out.println(stringClean("abbbcdd"));
                System.out.println(stringClean("Hello"));

    }}

[Knute Snortum]

Thank you Javco Aract for the contribution. I have hidden your post because in this forum we don't like to post complete solutions, but instead provide help to the OP so that they can discover their own solution.

Edit: I unhide the post because we have had another solution visible for 13 hours.

[Chaveen Ekanayake]

public class Main {
	public static String stringClean(final String input) {
		final int len = input.length();
		if (len == 0 || len == 1) {
			return input;
		}
		
		if (len == 2) {
			if (input.charAt(0) == input.charAt(1)) {
				return String.valueOf(input.charAt(0));
			}
			
			return input;
		}
		
		final String cleanedLeft = stringClean(input.substring(0, len / 2));
		final String cleanedRight = stringClean(input.substring(len /2));
		
		if (cleanedLeft.length() > 0 && cleanedRight.length() > 0 && cleanedLeft.charAt(cleanedLeft.length() - 1) == cleanedRight.charAt(0)) {
			return cleanedLeft + cleanedRight.substring(1);
		}
		
		return cleanedLeft + cleanedRight;
	}
	
	public static void main(String[] args) {
		// test 1 "" -> ""
		System.out.println(stringClean(""));
		
		// test 2 a -> a
		System.out.println(stringClean("a"));
		
		// test 3 ab -> ab
		System.out.println(stringClean("ab"));
		
		// test 4 aab -> ab
		System.out.println(stringClean("aab"));
		
		// test 4 aab -> ab
		System.out.println(stringClean("aab"));
		
		// test 5 aabbb -> ab
		System.out.println(stringClean("aabbb"));
		
		// test 6 aaabbaaa -> aba
		System.out.println(stringClean("aaabbaaa"));
	}
}

Check this solution out. My test cases all passed. The key point is that even though left and righ are "cleaned" the concatenation of them may be not. All other conditions are base cases.

[Knute Snortum]

Normally we don't provide complete solutions, but this solution has been visible for 13 hours so far, so I think we can compare solutions now.

package net.snortum.play;

public class CleanString {
	
	public String cleanString(String str, int index) {
		if (index >= str.length() - 1) {
			return str;
		}
		
		if (str.charAt(index) == str.charAt(index + 1)) {
			return cleanString( str.substring(0, index) + str.substring(index + 1), index );
		} else {
			return cleanString(str, index + 1);
		}
	}

	public static void main(String[] args) {
		CleanString cs = new CleanString();
		System.out.println(cs.cleanString("", 0));
		System.out.println(cs.cleanString("x", 0));
		System.out.println(cs.cleanString("xx", 0));
		System.out.println(cs.cleanString("axx", 0));
		System.out.println(cs.cleanString("xxa", 0));
		System.out.println(cs.cleanString("xxayy", 0));
		System.out.println(cs.cleanString("axxbyyc", 0));
	}

}

[Vipin kumar sharma]

Ranajoy Saha wrote:Hi, Everyone

Here's the question

Given a string, return recursively a "cleaned" string where adjacent chars that are the same have been reduced to a single char. So "yyzzza" yields "yza".

stringClean("yyzzza") → "yza"
stringClean("abbbcdd") → "abcd"
stringClean("Hello") → "Helo"

The iterative approach would be this.

public class StringClean 
{
    static String temp = "";
    static public void stringClean(String str) 
    {
        int length = str.length();
        for(int i = 0; i<length; i++)
        {
            if(str.charAt(i) != ' ')
            {
                char curr_letter = str.charAt(i);
                temp += curr_letter;
                str = str.replace(str.charAt(i), ' ');
            }
        }
    }
    public static void main(String[] args) 
    {
        stringClean("yyzzza");
        System.out.println(temp);
    }
}

The signature that I must stick to is public String stringClean(String str) and have to solve it without using replace() or replaceWith(). How should I approach writing my program now?

Regards,
Ranajoy Saha

A very nice and challenging question.