Tasks Details
hard
1.
ABSwaps
Calculate the minimum required number of swaps of neighbouring letters in a string built from the letters 'a' and 'b', after which the string would contain both "aaa" and "bbb" as substrings.
Task Score
100%
Correctness
100%
Performance
100%
You are given a string S consisting of letters 'a' and 'b'. The task is to rearrange letters in S so that it contains three consecutive letters 'a' and three consecutive letters 'b'. What is the minimum necessary number of swaps of neighbouring letters to achieve this?
Write a function:
class Solution { public int solution(String S); }
that, given a string S of length N, returns the number of swaps after which S would contain "aaa" and "bbb" as substrings. If it's not possible to rearrange the letters in such a way, the function should return −1.
Examples:
1. Given S = "ababab", the function should return 3. The sequence of swaps could be as follows: ababab → abaabb → aababb → aaabbb.
2. Given S = "abbbbaa", the function should return 4. The sequence of four swaps is: abbbbaa → babbbaa → bbabbaa → bbbabaa → bbbbaaa.
3. Given S = "bbbababaaab", the function should return 0. S already contains both "aaa" and "bbb" as substrings.
4. Given S = "abbabb", the function should return −1. It is not possible to obtain the required result from S as there are only two letters 'a'.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- string S is made only of the characters 'a' and/or 'b'.
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Java 21
Time spent on task 18 minutes
Notes
not defined yet
Code: 07:44:49 UTC,
java,
autosave
Code: 07:45:22 UTC,
java,
autosave
Code: 07:45:52 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps =
}
}
Code: 07:46:02 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
}
Code: 07:46:14 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str,
}
Code: 07:46:27 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
}
}
Code: 07:46:39 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
}
}
Code: 07:46:49 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
}
}
Code: 07:47:19 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
}
}
Code: 07:47:31 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
}
}
Code: 07:47:52 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
}
}
Code: 07:48:02 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
}
}
Code: 07:48:12 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
}
}
}
Code: 07:48:28 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter
}
}
}
}
Code: 07:48:39 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}
}
}
}
Code: 07:48:52 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
}
}
}
Code: 07:49:22 UTC,
java,
autosave
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
}
}
Code: 07:49:32 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
}
}
}
Code: 07:49:51 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
}
}
}
}
Code: 07:50:09 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
}
}
}
}
}
Code: 07:50:26 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
}
}
}
}
}
}
Code: 07:50:36 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
}
}
}
}
}
}
Code: 07:50:50 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
}
}
}
}
}
Code: 07:51:12 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
}
}
}
}
}
}
Code: 07:51:22 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
}
}
}
Code: 07:51:33 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swa)
}
}
}
Code: 07:51:45 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps)
}
}
}
Code: 07:51:56 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
}
}
Code: 07:52:10 UTC,
java,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
}
}
}
Code: 07:52:30 UTC,
java,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
}
}
}
}
Code: 07:52:54 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
}else if(dir<0){
}else{
}
}
}
}
}
Code: 07:53:08 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
}else{
}
}
}
}
}
Code: 07:53:22 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
}
}
}
}
Code: 07:53:52 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.
}
}
}
Code: 07:54:03 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}
}
Code: 07:54:22 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
Code: 07:55:08 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
Code: 07:57:09 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
Code: 07:57:27 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
Code: 07:57:37 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
Code: 07:57:48 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 07:58:03 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 07:58:14 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.index
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 07:58:27 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
}
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 07:58:57 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 07:59:23 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dira=-1; dira<2; dira++){
}
}
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 07:59:37 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
}
}
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 07:59:51 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
}
}
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 08:00:05 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
}
}
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 08:00:21 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
if (swa<0||swb<0){
return -1;
}
swaps = swa+swb;
if (swaps<2){
return swaps;
}
}
}
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 08:00:42 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
if (swa<0||swb<0){
return -1;
}
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
}
}
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 08:00:55 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
if (swa<0||swb<0){
return -1;
}
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
strb = swapLetters(str,"b",dirb,true);
stra = swapLetters(strb[0],"a",dira,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
}
}
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 08:01:07 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
if (swa<0||swb<0){
return -1;
}
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
strb = swapLetters(str,"b",dirb,true);
stra = swapLetters(strb[0],"a",dira,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
}
}
return minSwaps;
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 08:01:49 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1;
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
if (swa<0||swb<0){
return -1;
}
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
strb = swapLetters(str,"b",dirb,true);
stra = swapLetters(strb[0],"a",dira,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
}
}
return minSwaps;
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 08:02:17 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1;
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
if (swa<0||swb<0){
return -1;
}
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
strb = swapLetters(str,"b",dirb,true);
stra = swapLetters(strb[0],"a",dira,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
}
}
return minSwaps;
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int i = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Code: 08:02:29 UTC,
java,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1;
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
if (swa<0||swb<0){
return -1;
}
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
strb = swapLetters(str,"b",dirb,true);
stra = swapLetters(strb[0],"a",dira,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
}
}
return minSwaps;
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int i = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Analysis
Code: 08:02:35 UTC,
java,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1;
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
if (swa<0||swb<0){
return -1;
}
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
strb = swapLetters(str,"b",dirb,true);
stra = swapLetters(strb[0],"a",dira,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
}
}
return minSwaps;
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int i = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Analysis
Code: 08:02:40 UTC,
java,
final,
score:
100
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String str) {
// write your code in Java SE 8
String[] stra;
String[] strb;
int swaps=-1;
int swa;
int swb;
int minSwaps = -1;
if (str.indexOf("aababb",0)>=0||str.indexOf("bbabaa",0)>=0){
if(str.indexOf("aaa",0)>=0 && str.indexOf("bbb",0)>=0){
return 0;
}else{
return 1;
}
}
for (int dira=-1; dira<2; dira++){
for (int dirb=-1; dirb<2; dirb++){
stra = swapLetters(str,"a",dira,true);
strb = swapLetters(stra[0],"b",dirb,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
if (swa<0||swb<0){
return -1;
}
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
strb = swapLetters(str,"b",dirb,true);
stra = swapLetters(strb[0],"a",dira,false);
swa = Integer.parseInt(stra[1]);
swb = Integer.parseInt(strb[1]);
swaps = swa+swb;
if (swaps<2){
return swaps;
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
}
}
}
return minSwaps;
}
private String[] swapLetters(String str, String letter, int dir, boolean needNewStr){
int swaps=0;
int p1=-1;
int p2=-1;
int p3=-1;
int mp1=-1;
int mp2=-1;
int mp3=-1;
int minSwaps = -1;
String newStr ="";
String winPattern = letter+letter+letter;
String otherLetter = letter.equals("a")?"b":"a";
String almostWin1 = letter+otherLetter+letter+letter;
String almostWin2 = letter+letter+otherLetter+letter;
int aw1 = str.indexOf(almostWin1);
int aw2 = str.indexOf(almostWin2);
String[] result = {"",""};
if (str.indexOf(winPattern,0)<0){
if (aw1>=0||aw2>=0){
if (aw1>=0){
result[0]=str.substring(0,aw1)+otherLetter+winPattern+str.substring(aw1+4,str.length());
}else{
result[0]=str.substring(0,aw2)+winPattern+otherLetter+str.substring(aw2+4,str.length());
}
result[1]="1";
return result;
}
int i = -1;
while (i<str.length()){
i=str.indexOf(letter,i+1);
if(i<0){
break;
}else{
p3=p2;
p2=p1;
p1=i;
if (p3>=0){
switch (dir){
case 1: swaps = (p1-p3-2)+(p1-p2-1);
break;
case -1: swaps = (p1-p3-2)+(p2-p3-1);
break;
case 0: swaps = (p1-p2-1)+(p2-p3-1);
break;
default: result[0]="";
result[1]="-1";
}
if (swaps<minSwaps||minSwaps<0){
minSwaps=swaps;
mp1=p1;
mp2=p2;
mp3=p3;
}
}
}
if (swaps==1){
break;
}
}
if(p3<0){
result[0]="";
result[1]="-1";
}else{
if (needNewStr){
newStr = str.substring(0,mp3);
if (dir>0){
newStr += str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1)+winPattern;
}else if(dir<0){
newStr += winPattern + str.substring(mp3+1,mp2)+str.substring(mp2+1,mp1);
}else{
newStr += str.substring(mp3+1,mp2)+winPattern+str.substring(mp2+1,mp1);
}
newStr+= str.substring(mp1+1,str.length());
}else{
newStr="";
}
result[0]=newStr;
result[1]=Integer.toString(minSwaps);
}
}else{
result[0]=str;
result[1]="0";
}
return result;
}
}
Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N)
expand all
Correctness tests
1.
0.012 s
OK
2.
0.004 s
OK
3.
0.008 s
OK
4.
0.008 s
OK
5.
0.008 s
OK
6.
0.008 s
OK
7.
0.012 s
OK
8.
0.004 s
OK
9.
0.004 s
OK
10.
0.008 s
OK
11.
0.008 s
OK
12.
0.008 s
OK
13.
0.008 s
OK
14.
0.004 s
OK
15.
0.012 s
OK
16.
0.008 s
OK
1.
0.008 s
OK
2.
0.004 s
OK
3.
0.008 s
OK
4.
0.012 s
OK
5.
0.008 s
OK
6.
0.008 s
OK
7.
0.012 s
OK
8.
0.004 s
OK
9.
0.008 s
OK
10.
0.008 s
OK
11.
0.008 s
OK
12.
0.008 s
OK
13.
0.008 s
OK
14.
0.012 s
OK
15.
0.008 s
OK
16.
0.004 s
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.012 s
OK
4.
0.012 s
OK
5.
0.004 s
OK
6.
0.004 s
OK
7.
0.008 s
OK
8.
0.004 s
OK
9.
0.012 s
OK
10.
0.008 s
OK
11.
0.004 s
OK
12.
0.012 s
OK
13.
0.008 s
OK
14.
0.008 s
OK
15.
0.008 s
OK
16.
0.012 s
OK
17.
0.004 s
OK
18.
0.008 s
OK
1.
0.008 s
OK
2.
0.004 s
OK
3.
0.008 s
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.004 s
OK
4.
0.012 s
OK
1.
0.008 s
OK
2.
0.012 s
OK
3.
0.004 s
OK
4.
0.008 s
OK
expand all
Performance tests
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.012 s
OK
4.
0.008 s
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.004 s
OK
4.
0.008 s
OK
5.
0.004 s
OK
6.
0.004 s
OK
7.
0.004 s
OK
8.
0.008 s
OK
9.
0.012 s
OK
10.
0.008 s
OK
11.
0.008 s
OK
12.
0.004 s
OK
1.
0.328 s
OK
2.
0.332 s
OK
3.
0.328 s
OK
4.
0.280 s
OK
1.
0.060 s
OK
2.
0.060 s
OK
3.
0.468 s
OK
4.
0.008 s
OK
5.
0.056 s
OK
6.
0.004 s
OK
1.
0.056 s
OK
2.
0.392 s
OK
3.
0.712 s
OK
4.
0.476 s
OK
5.
0.556 s
OK
6.
0.448 s
OK
7.
0.004 s
OK
8.
0.072 s
OK
9.
0.080 s
OK
10.
0.076 s
OK
11.
0.068 s
OK