We Keep Coding

Find all common substrings with a minimum length of 2 characters

Task's content:
Find all (starting from the longest, the shortest ending) common substrings with a minimum length of 2 characters, which do not overlap with previously found.
My task is to remake below code or write new one. I don't even know how to start with it :/
public static void main(String[] args) {
String text1 = "AABABB";
String text2 = "BAABAB";
int len1 = text1.length();
int len2 = text2.length();
int max = 0;
int position_w1 = -1;
int position_w2 = -1;
for (int i = 0; i < len1 - max; i++)
{
for (int k = len2 - 1; k >= 0; k--)
{
int counter = 0;
int limit = Math.min(len2, (len1 -i + k) );
for (int j = k; j < limit; j++)
{
if (text1.charAt(i+j-k) == text2.charAt(j))
{
counter++;
if (max < counter)
{
max = counter;
position_w1 = i + j - k - max + 1;
position_w2 = j - max + 1;
}
}
else counter = 0;
}
}
}
System.out.println("Position of text1: " + position_w1 + ", position of text2: " + position_w2 + ", length: " + max);
System.out.println(text1.substring(0, position_w1) + "\u001B[31m"
+ text1.substring(position_w1, max + position_w1) + "\u001B[0m" + text1.substring(max + position_w1) );
System.out.println(text2.substring(0, position_w2) + "\u001B[31m"
+ text2.substring(position_w2, max + position_w2) + "\u001B[0m" + text2.substring(max + position_w2) );
}

Maybe try something like this :
public static void main(String[] args){
String text1 = "AABABB";
String text2 = "BAABAB";
int maxLen = 3;
for (int len = 2; len < maxLen; len++) {
ArrayList<Pair<Integer, Integer>> intervalsText1 = new ArrayList<>();
ArrayList<Pair<Integer, Integer>> intervalsText2 = new ArrayList<>();
for (int i = 0; i < text1.length() - len; i++) {
String sub1 = text1.substring(i, i + len);
for (int j = 0; j < text2.length() - len; i++) {
String sub2 = text2.substring(j, j + len);
if(sub1.equals(sub2)){
//check if overlapping
for(Pair<Integer, Integer> inter : intervalsText1){
for(Pair<Integer, Integer> inter : intervalsText1){
if(!isInsideInterval(inter, i) && !isInsideInterval(inter, i + len)){
if(!isInsideInterval(inter, j) && !isInsideInterval(inter, j + len)){
//the strings are equal and outside previous strings
intervalsText1.add(Pair.of(i, i + len));
intervalsText2.add(Pair.of(j, j + len));
}
}
}
}
}
}
}
}
}
public static boolean isInsideInterval(Pair<Integer, Integer> interval, int toCheck){
if(interval.getLeft() < toCheck && interval.getRight() > toCheck)
return true;
return false;
}
*Please note that I haven't checked it working

As this is home work, just some mental help.
Immediately diving into for-i like loops is hard to read and/or change.
Consider how one would do the task oneself, and see what the original writer did.
Starting with the maximal subsequence, would be:
int max = Math.min(len1, len2);
...
--max;
or even
for (int max = Math.min(len1, len2); may > 0; --max) {
for (int i = 0; i + max <= len1; ++i) {
if (match found) {
print match;
i += max - 1;
}
}
}
The for-k loop does a --k; a bit needlessly IMHO.
Matching a substring and when matched skip by i += max; or i += max - 1; would benefit from the String.substring or your own function for that.
By the way, when ready try to consider things like skipping a second occurrence of a sought substring: "AB" appears twice in text1. Good names important, comments might help. Otherwise demerits for "circumstantial code" might follow.
int notEarlierPos = text1.indexOf(text1.subtring(i, i + max));
if (notEarlierPos == i) { // Not already treated earlier.
int matchPos = text2.indexOf(text1.subtring(i, i + max));
if (matchPos != -1) {
print match;
i += max - 1;
}
}

illegal forward reference with labels

I'm having trouble with this...
unlike my last post i have googled and nothing has helped.
Why am i getting the: illegal forward reference error here, and how can i go about fixing it?
public class guihanging extends javax.swing.JFrame {
int re;
String [] A = new String[10];
String word;
String dash = "";
int picture = 2;
String letter = "qw";
int startOver;
int qq=0;
int ww=0;
int ee=0;
int rr=0;
int tt=0;
int yy=0;
int uu=0;
int ii=0;
int oo=0;
int pp=0;
int aa=0;
int ss=0;
int dd=0;
int ff=0;
int gg=0;
int hh=0;
int jj=0;
int kk=0;
int ll=0;
int zz=0;
int xx=0;
int cc=0;
int vv=0;
int bb=0;
int nn=0;
int mm=0;
public guihanging() {
initComponents();
{
A[0]="rob";
A[1]= "welcome";
A[2]= "carbohydrates";
A[3]= "resiprocity";
A[4]="fatty";
A[5]="baggy";
A[6]="laptop";
A[7]="personalcomputer";
A[8]="monitor";
A[9]="mouse";
}
}
public void letters()
{System.out.println("");}
{
int wordleng = word.length();
for (int i2 = 0; i2 < wordleng; i2++)
{
int position = word.indexOf(letter);
if (position >= 0)
{
String before = word.substring(0,position);
String after = word.substring(position+1);
word = before + "#" + after;
int dashPosition = position * 2;
String dashBefore = dash.substring(0,dashPosition);
String dashAfter = dash.substring(dashPosition + 1);
dash = dashBefore + letter + dashAfter;
lblWord.setText(dash);//error
}
else
{
lblPicture.setIcon(new javax.swing.ImageIcon(getClass().getResource("/pictures/"+picture+".png")));// error
picture++;
if (picture == 7)
{
JOptionPane.showConfirmDialog(rootPane, "Unluck, You just did a burpee!!"+"/n"+"do you want to start again?");
if (true)
{
re = (int) (Math.random ()*10);
word = "aaabcqdefghiqjklmnopqrstuvwxyz"; //A[re];
for (int i1 = 0; wordleng < 10; i1++)
{
dash = dash + "_ ";
}
lblWord.setText(dash);/error
}
}
}
}
}
the errors are all by the labels
EDIT LEFT THIS OUT
private void btnStartActionPerformed(java.awt.event.ActionEvent evt) {
re = (int) (Math.random ()*10);
word = A[re];
int wordleng = word.length();
for (int i1 = 0; i1 < wordleng; i1++)
{
dash = dash + "_ ";
}
lblWord.setText(dash)

"Illegal forward reference" means you use a variable which is not defined. Maybe you miss to define your variables: dash or lblWord?

Rotate a given String layout clockwise

Given a String layout of the following form:
X......X
....X..X
....X..X
Rotate the above layout by 90 degrees clockwise which should be:
..X
...
...
...
XX.
...
...
XXX
What's the easiest way to rotate the String characters clockwise by 90 degrees? The String layout can be of any form and any size. What if I have 100000x100000 size String layout?
public String rotate(String layout)
or
public void rotate(String layout)

Edit
I fixed the mistake as pointed out by the OP in the comments below. This should produce exactly what was required in the original question above.
public static String rotateStringMatrixBy90(String matrix) {
int numberOfRows = 3; // this I leave as an exercise
int numberOfColumns = 8; // same with this one
String newMatrix = "";
int count = 0;
String[] newMatrixColumns= matrix.split("\n");
while (count < matrix.split("\n")[0].length()) {
for (int i = newMatrixColumns.length - 1; i > -1; i--) {
newMatrix = newMatrix + newMatrixColumns[i].charAt(count);
}
newMatrix = newMatrix + "\n";
count++;
}
return newMatrix;
}
And this is how you would use it:
String m = "X......X\n" +
"....X..X\n" +
"....X..X";
System.out.println(m);
m = rotateStringMatrixBy90(m);
System.out.println(m);
(Note: this assumes your using \n as the separator between the rows):

public static String[] rotate(String[] originalArray) {
String[] rotatedArray = new String[originalArray[0].length()];
for (int i=0;i<rotatedArray.length;i++) {
rotatedArray[i]="";
}
for (int j = 0; j < originalArray[0].length(); j++) {
for (int i = originalArray.length - 1; i >= 0; i--) {
rotatedArray[j] += originalArray[i].charAt(j);
}
}
return rotatedArray;
}

Edit: just saw that you wanted a String as the arg
You could use this:
public class SO {
public static void main(String[] args) throws Exception {
String string = "X......X\n" +
"....X..X\n" +
"....X..X\n";
System.out.println(string);
string = rotateClockwise(string);
System.out.println(string);
}
static String rotateClockwise(String input) {
String[] arr = input.split("\n");
int length = arr[0].length();
String[] ret = new String[length];
for (int i = 0; i < ret.length; i++) {
ret[i] = "";
}
for (int i = arr.length-1; i >= 0; i--) {
char[] chars = arr[i].toCharArray();
for (int j = 0; j < ret.length; j++) {
ret[j] += chars[j];
}
}
String output = "";
for (String str: ret)
output += str + "\n";
return output;
}
}
Please note this has NO error checking.

Alternating characters of two different inputs

I want to take two strings and alternate the characters into a new string using a for method.
Example: "two" and "one"
Result: "townoe"
This is what I have so far, and I really don't know how to finish it.
public class Alternator {
String alternate(String a, String b) {
String s = "";
for (int i = 0; i < a.length(); i++) {
s += i;
System.out.println(s);
}
return null;
}
}

public class Alternator{
public static String alternate(String a, String b){
String s = "";
int i = 0;
while (i < a.length() && i < b.length()){
s += a.charAt(i) +""+ b.charAt(i);
i++;
}
while (i < a.length() ){
s += a.charAt(i);
i++;
}
while (i < b.length()){
s += b.charAt(i);
i++;
}
return s;
}
public static void main(String[] args){
String a = "two", b = "one";
String s = Alternator.alternate(a,b);
System.out.println(s);
}
}
To use for loop instead of while loop, simply remove all while lines with for lines like the following, then remove the i++ line from each while loop
for(; i < a.length() && i < b.length(); i++){
//the inside of the loop MINUS THE LINE i++
}
for(; i < a.length(); i++){
//the inside of the loop MINUS THE LINE i++
}
for(; i < b.length(); i++){
//the inside of the loop MINUS THE LINE i++
}

Here is some compact way of doing that:
String alternate(String a, String b) {
StringBuilder builder = new StringBuilder();
int smallerStringLength = Math.min(a.length(), b.length());
for (int i = 0; i < smallerStringLength; i++) {
builder.append(a.charAt(i));
builder.append(b.charAt(i));
}
return builder.toString();
}
Or even more optimized:
String alternate(String first, String second) {
char[] firstChars = first.toCharArray();
char[] secondChars = second.toCharArray();
int smallerCharsCount = Math.min(firstChars.length, secondChars.length);
StringBuilder builder = new StringBuilder(smallerCharsCount * 2);
for (int i = 0; i < smallerCharsCount; i++) {
builder.append(firstChars[i]);
builder.append(secondChars[i]);
}
return builder.toString();
}

This will work if string are of same length or of the different lengths.
static void mergeStrings(String a, String b) {
StringBuilder mergedBuilder = new StringBuilder();
char[] aCharArr = a.toCharArray();
char[] bCharArr = b.toCharArray();
int minLength = aCharArr.length >= bCharArr.length ? bCharArr.length : aCharArr.length;
for (int i=0; i<minLength; i++) {
mergedBuilder.append(aCharArr[i]).append(bCharArr[i]);
}
if(minLength < aCharArr.length) {
mergedBuilder.append(a.substring(minLength));
}
else{
mergedBuilder.append(b.substring(minLength));
}
Systemout.println(mergedBuilder.toString());
}

Assuming that the two strings are the exact same length, you can do the following. If they are different length, then currently your prompt doesn't say how you want the resultant string to be set up.
public class Alternator {
String alternate(String a, String b) {
String s = "";
for (int i = 0; i < 2*a.length(); i++) {
if (i%2==0) // modular arithmetic to alternate
s += a.charAt(i/2); // Note the integer division
else
s += b.charAt(i/2);
}
System.out.println(s);
return s;
}
}
Alternatively, even easier, but the index i doesn't mark the length of your string s:
public class Alternator {
String alternate(String a, String b) {
String s = "";
for(int i = 0; i < a.length(); i++){
s += a.charAt(i);
s += b.charAt(i);
}
return s;
}
}

Use this:
String alternate(String a, String b){
StringBuilder builder = new StringBuilder();
final int greaterLength = a.length() > b.length() ? a.length() : b.length();
for(int i = 0; i < greaterLength; i++){
if (i < a.length()) {
builder.append(a.charAt(i));
}
if (i < b.length()) {
builder.append(b.charAt(i));
}
}
return builder.toString();
}
It uses the String.charAt method to obtain letters, and a StringBuilder to create the string.
(When given two strings of non-equal length, this returns an alternation of the first two chars, and then does just the remaining string. EG: Hello and Hi --> HHeillo)

According to the comments I've read, you are having trouble understanding for loops, and how to use them with strings.
For loops are most often used to iterate over arrays, or to perform a task a given number of times.
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
This would give the output
0
1
2
3
4
For loops start at the value of the initializer, the first thing you put in int i = 0;
They then check the expression, the second part of the for loop, and if it returns true, it executes all of the code inside the braces. i < 5;
Once it has done that, it runs the incrementor, the last part of the for loop. i++
After that, it checks the expression again. I guess you can see where this is going. Until the expression returns false, everything inside the curly braces of the for loop gets executed over and over again.
Strings can be iterated over with a for loop, but you can't reference it like an array using array[index]. You have to either convert it into an array, using .toCharArray() on your String, and return the result to an empty char array char[], or use the .charAt(index) method on your string.
This code will go over a string, and output each character, one by one:
for (int i = 0; i < myString.length(); i++) {
System.out.println(myString.charAt(i));
}
If the string had a value of "Hello", the output would be:
H
e
l
l
o
Using this, instead of outputting the characters using System.out.println();, we can put them into an empty string, using +=:
myOtherString += myString.charAt(i);
That means, if we want to go over two Strings at a time, and alternate them, like you do, we can iterate over two strings at the same time, and add them to a new string:
myAlternatedString += myString.charAt(i);
myAlternatedString += myOtherString.charAt(i);
if MyString was still "Hello" and myOtherString was "World", the new string would be:
Hweolrllod

following code reads 2 different inputs and merges into a single string.
public class PrintAlternnateCharacterString {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String a = in.next();
String b = in.next();
String mergedString = "";
int lenA = a.length();
int lenB = b.length();
if (lenA >= lenB) {
for (int i = 0; i < lenA; i++) {
if (i < lenB) {
mergedString += a.charAt(i) + "" + b.charAt(i);
} else {
mergedString += a.charAt(i);
}
}
}
if (lenB > lenA) {
for (int i = 0; i < lenB; i++) {
if (i < lenA) {
mergedString += a.charAt(i) + "" + b.charAt(i);
} else {
mergedString += b.charAt(i);
}
}
}
System.out.println("the merged string is-->" + mergedString);
}
}

public static String stringConcate(String str1,String str2){
String str3="";
if(str1!=null && str2!=null && !str1.isEmpty() && !str2.isEmpty()){
if(str1.length()==str2.length()){
for(int i=0;i<=str1.length()-1;i++){
str3+=str1.charAt(i);
str3+=str2.charAt(i);
}
}
if(str1.length()>str2.length()){
for(int i=0;i<=str1.length()-1;i++){
str3+=str1.charAt(i);
if(i<str2.length()){
str3+=str2.charAt(i);
}
}
}
if(str2.length()>str1.length()){
for(int i=0;i<=str2.length()-1;i++){
if(i<str1.length()){
str3+=str1.charAt(i);
}
str3+=str2.charAt(i);
}
}
}
return str3;
}

String str1 = "one"; String str2 = "two";
StringBuilder sb = new StringBuilder();
int i = 0;
for (; i < str1.length() && i < str2.length(); i++) {
sb.append(str1.charAt(i)).append(str2.charAt(i));
}
for(; i < str1.length(); i++) {
sb.append(str1.charAt(i));
}
for(; i < str2.length(); i++) {
sb.append(str2.charAt(i));
}
System.out.println("result = " + sb.toString());// otnweo
This will handle for different length too

This could be donw with very simple if...else.
public static void main(String... args) {
int[] one = { 1, 2, 3 };
int[] two = { 44, 55, 66, 77, 88 };
System.out.println(Arrays.toString(alternate(one, two)));
}
public static int[] alternate(int[] one, int[] two) {
int[] res = new int[one.length + two.length];
for (int i = 0, j = 0, k = 0; i < res.length; i++) {
if (i % 2 == 0)
res[i] = j < one.length ? one[j++] : two[k++];
else
res[i] = k < two.length ? two[k++] : one[j++];
}
return res;
}
Output:
[1, 44, 2, 55, 3, 66, 77, 88]

How to find the longest substring containing two unique repeating characters

The task is to find the longest substring in a given string that is composed of any two unique repeating characters
Ex. in an input string "aabadefghaabbaagad", the longest such string is "aabbaa"
I came up with the following solution but wanted to see if there is a more efficient way to do the same
import java.util.*;
public class SubString {
public static void main(String[] args) {
//String inStr="defghgadaaaaabaababbbbbbd";
String inStr="aabadefghaabbaagad";
//String inStr="aaaaaaaaaaaaaaaaaaaa";
System.out.println("Input string is "+inStr);
StringBuilder sb = new StringBuilder(inStr.length());
String subStr="";
String interStr="";
String maxStr="";
int start=0,length=0, maxStart=0, maxlength=0, temp=0;
while(start+2<inStr.length())
{ int i=0;
temp=start;
char x = inStr.charAt(start);
char y = inStr.charAt(start+1);
sb.append(x);
sb.append(y);
while( (x==y) && (start+2<inStr.length()) )
{ start++;
y = inStr.charAt(start+1);
sb.append(y);
}
subStr=inStr.substring(start+2);
while(i<subStr.length())
{ if(subStr.charAt(i)==x || subStr.charAt(i)==y )
{ sb.append(subStr.charAt(i));
i++;
}
else
break;
}
interStr= sb.toString();
System.out.println("Intermediate string "+ interStr);
length=interStr.length();
if(maxlength<length)
{ maxlength=length;
length=0;
maxStr = new String(interStr);
maxStart=temp;
}
start++;
sb.setLength(0);
}
System.out.println("");
System.out.println("Longest string is "+maxStr.length()+" chars long "+maxStr);
}
}

Here's a hint that might guide you towards a linear-time algorithm (I assume that this is homework, so I won't give the entire solution): At the point where you have found a character that is neither equal to x nor to y, it is not necessary to go all the way back to start + 1 and restart the search. Let's take the string aabaaddaa. At the point where you have seen aabaa and the next character is d, there is no point in restarting the search at index 1 or 2, because in those cases, you'll only get abaa or baa before hitting d again. As a matter of fact, you can move start directly to index 3 (the first index of the last group of as), and since you already know that there is a contiguous sequene of as up to d, you can move i to index 5 and continue.
Edit: Pseudocode below.
// Find the first letter that is not equal to the first one,
// or return the entire string if it consists of one type of characters
int start = 0;
int i = 1;
while (i < str.length() && str[i] == str[start])
i++;
if (i == str.length())
return str;
// The main algorithm
char[2] chars = {str[start], str[i]};
int lastGroupStart = 0;
while (i < str.length()) {
if (str[i] == chars[0] || str[i] == chars[1]) {
if (str[i] != str[i - 1])
lastGroupStart = i;
}
else {
//TODO: str.substring(start, i) is a locally maximal string;
// compare it to the longest one so far
start = lastGroupStart;
lastGroupStart = i;
chars[0] = str[start];
chars[1] = str[lastGroupStart];
}
i++;
}
//TODO: After the loop, str.substring(start, str.length())
// is also a potential solution.

Same question to me, I wrote this code
public int getLargest(char [] s){
if(s.length<1) return s.length;
char c1 = s[0],c2=' ';
int start = 1,l=1, max=1;
int i = 1;
while(s[start]==c1){
l++;
start++;
if(start==s.length) return start;
}
c2 = s[start];
l++;
for(i = l; i<s.length;i++){
if(s[i]==c1 || s[i]==c2){
if(s[i]!=s[i-1])
start = i;
l++;
}
else {
l = i-start+1;
c1 = s[start];
c2 = s[i];
start = i;
}
max = Math.max(l, max);
}
return max;
}

so the way I think of this is to solve it in 2 steps
scan the entire string to find continuous streams of the same letter
loop the extracted segments and condense them until u get a gap.
This way you can also modify the logic to scan for longest sub-string of any length not just 2.
class Program
{
static void Main(string[] args)
{
//.
string input = "aabbccdddxxxxxxxxxxxxxxxxx";
int max_chars = 2;
//.
int flip = 0;
var scanned = new List<string>();
while (flip > -1)
{
scanned.Add(Scan(input, flip, ref flip));
}
string found = string.Empty;
for(int i=0;i<scanned.Count;i++)
{
var s = Condense(scanned, i, max_chars);
if (s.Length > found.Length)
{
found = s;
}
}
System.Console.WriteLine("Found:" + found);
System.Console.ReadLine();
}
/// <summary>
///
/// </summary>
/// <param name="s"></param>
/// <param name="start"></param>
/// <returns></returns>
private static string Scan(string s, int start, ref int flip)
{
StringBuilder sb = new StringBuilder();
flip = -1;
sb.Append(s[start]);
for (int i = start+1; i < s.Length; i++)
{
if (s[i] == s[i - 1]) { sb.Append(s[i]); continue; } else { flip=i; break;}
}
return sb.ToString();
}
/// <summary>
///
/// </summary>
/// <param name="list"></param>
/// <param name="start"></param>
/// <param name="repeat"></param>
/// <param name="flip"></param>
/// <returns></returns>
private static string Condense(List<string> list, int start, int repeat)
{
StringBuilder sb = new StringBuilder();
List<char> domain = new List<char>(){list[start][0]};
for (int i = start; i < list.Count; i++)
{
bool gap = false;
for (int j = 0; j < domain.Count; j++)
{
if (list[i][0] == domain[j])
{
sb.Append(list[i]);
break;
}
else if (domain.Count < repeat)
{
domain.Add(list[i][0]);
sb.Append(list[i]);
break;
}
else
{
gap=true;
break;
}
}
if (gap) { break;}
}
return sb.ToString();
}
}

A general solution: Longest Substring Which Contains K Unique Characters.
int longestKCharSubstring(string s, int k) {
int i, max_len = 0, start = 0;
// either unique char & its last pos
unordered_map<char, int> ht;
for (i = 0; i < s.size(); i++) {
if (ht.size() < k || ht.find(s[i]) != ht.end()) {
ht[s[i]] = i;
} else {
// (k + 1)-th char
max_len = max(max_len, i - start);
// start points to the next of the earliest char
char earliest_char;
int earliest_char_pos = INT_MAX;
for (auto key : ht)
if (key.second < earliest_char_pos)
earliest_char = key.first;
start = ht[earliest_char] + 1;
// replace earliest_char
ht.erase(earliest_char);
ht[s[i]] = i;
}
}
// special case: e.g., "aaaa" or "aaabb" when k = 2
if (k == ht.size())
max_len = max(max_len, i - start);
return max_len;
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap; import java.util.Iterator; import java.util.List;
import java.util.Map;
public class PrintLLargestSubString {
public static void main(String[] args){ String string =
"abcdefghijklmnopqrstuvbcdefghijklmnopbcsdcelfabcdefghi";
List<Integer> list = new ArrayList<Integer> (); List<Integer>
keyList = new ArrayList<Integer> (); List<Integer> Indexlist = new
ArrayList<Integer> (); List<Integer> DifferenceList = new
ArrayList<Integer> (); Map<Integer, Integer> map = new
HashMap<Integer, Integer>(); int index = 0; int len = 1; int
j=1; Indexlist.add(0); for(int i = 0; i< string.length() ;i++) {
if(j< string.length()){
if(string.charAt(i) < string.charAt(j)){
len++;
list.add(len);
} else{
index= i+1;
Indexlist.add(index); // System.out.println("\nindex" + index);
len=1;
} } j++; } // System.out.println("\nlist" +list); System.out.println("index List" +Indexlist); // int n =
Collections.max(list); // int ind = Collections.max(Indexlist);
// System.out.println("Max number in IndexList " +n);
// System.out.println("Index Max is " +ind);
//Finding max difference in a list of elements for(int diff = 0;
diff< Indexlist.size()-1;diff++){ int difference =
Indexlist.get(diff+1)-Indexlist.get(diff);
map.put(Indexlist.get(diff), difference);
DifferenceList.add(difference); }
System.out.println("Difference between indexes" +DifferenceList); // Iterator<Integer> keySetIterator = map.keySet().iterator(); // while(keySetIterator.hasNext()){
// Integer key = keySetIterator.next();
// System.out.println("index: " + key + "\tDifference "
+map.get(key)); // // } // System.out.println("Diffferenece List" +DifferenceList); int maxdiff = Collections.max(DifferenceList); System.out.println("Max diff is " + maxdiff); ////// Integer
value = maxdiff; int key = 0; keyList.addAll(map.keySet());
Collections.sort(keyList); System.out.println("List of al keys"
+keyList); // System.out.println(map.entrySet()); for(Map.Entry entry: map.entrySet()){ if(value.equals(entry.getValue())){
key = (int) entry.getKey(); } } System.out.println("Key value of max difference starting element is " + key);
//Iterating key list and finding next key value int next = 0 ;
int KeyIndex = 0; int b; for(b= 0; b<keyList.size(); b++) {
if(keyList.get(b)==key){
KeyIndex = b; } } System.out.println("index of key\t" +KeyIndex); int nextIndex = KeyIndex+1; System.out.println("next Index = " +nextIndex); next = keyList.get(nextIndex);
System.out.println("next Index value is = " +next);
for( int z = KeyIndex; z < next ; z++) {
System.out.print(string.charAt(z)); } }
}

The problem can be solved in O(n). Idea is to maintain a window and add elements to the window till it contains less or equal 2, update our result if required while doing so. If unique elements exceeds than required in window, start removing the elements from left side.
#code
from collections import defaultdict
def solution(s, k):
length = len(set(list(s)))
count_dict = defaultdict(int)
if length < k:
return "-1"
res = []
final = []
maxi = -1
for i in range(0, len(s)):
res.append(s[i])
if len(set(res)) <= k:
if len(res) >= maxi and len(set(res)) <= k :
maxi = len(res)
final = res[:]
count_dict[maxi] += 1
else:
while len(set(res)) != k:
res = res[1:]
if maxi <= len(res) and len(set(res)) <= k:
maxi = len(res)
final = res[:]
count_dict[maxi] += 1
return len(final)
print(solution(s, k))

The idea here is to add occurrence of each character to a hashmap, and when the hasmap size increases more than k, remove the unwanted character.
private static int getMaxLength(String str, int k) {
if (str.length() == k)
return k;
var hm = new HashMap<Character, Integer>();
int maxLength = 0;
int startCounter = 0;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (hm.get(c) != null) {
hm.put(c, hm.get(c) + 1);
} else {
hm.put(c, 1);
}
//atmost K different characters
if (hm.size() > k) {
maxLength = Math.max(maxLength, i - startCounter);
while (hm.size() > k) {
char t = str.charAt(startCounter);
int count = hm.get(t);
if (count > 1) {
hm.put(t, count - 1);
} else {
hm.remove(t);
}
startCounter++;
}
}
}
return maxLength;
}