package sring;

/**
 * 压缩字符串中的连续出现的重复字符,如aaaxxxxyyyy压缩为3a4x4y.如果不连续出现则不压缩.
 * 
 * @param args
 */
public class CompressedString
{

public static void main(String[] args)
{
// String input = "abcaabbbcccxvcxxxx";
// String input = "xxxx";
//String input = "xxyy";
String[] inputs= {
"xxxx","xxxy","abcxxxx","aaabcccddde"
};
for (int i = 0; i < inputs.length; i++)
{
System.out.println(inputs[i]+"--->"+zipString1(inputs[i]));
}

}
/**
 * @param input
 * @param length
 */
public static String zipString1(String input)
{
StringBuilder sb=new StringBuilder(input.length());
// 获取字符串的长度.
int length = input.length();

int count = 0;
int start = 0;
int end = 0;
boolean isEndChongFu = false;
while (end + 1 < length)
{
// 前移一格
end = end + 1;
// 判断后面的元素是否和前面的元素相等
while (input.charAt(start) == input.charAt(end))
{
// 如果结束下标不是最后一个元素的下标
if (end + 1 < length)
{
end++;
}
// 如果是最后一个元素也重复
else
{
// endIndex已经位于最后一个下标不能再加1
// 这里引入最后一个元素也重复的下标
isEndChongFu = true;
break;
}
}
// 如果有重复的字符
if (end > start)
{
// 计算重复字符的数量
count = (end - start);
// 如果是最后一个字符也是重复的
if (isEndChongFu)
count = count + 1;
// 如果数量大于1的话,在前面添加数字
if (count > 1)
{
//System.out
//.print(String.valueOf(count) + input.charAt(start));
sb.append(String.valueOf(count) + input.charAt(start));
}
// 如果数量等于1,则只打印字母
else
{
//System.out.print(input.charAt(start));
sb.append(input.charAt(start));
}
// 当前指针移动到前面
start = end;
}
}
if (!isEndChongFu && start < length)
{
//System.out.print(input.substring(start));
sb.append(input.substring(start));
}
return sb.toString();
//System.out.println();
}
}

/**
 * 对数组前k的数字使用一种排序,剩下的用另一种排序.
 * 
 * @param array
 *            整型数组.
 * @param k
 * @param isAscendingFirst
 *            如果为true表示第一部分升序,剩下的降序.
 */
public static void bubbleSortSplit(int[] array, int k,
boolean isAscendingFirst)
{
// 前面升序后面降序
if (isAscendingFirst)
{
for (int i = 1; i < array.length; i++)
{
for (int j = 1; j < array.length - i + 1; j++)
{
if (j < k)
{
// 升序排列:前面的要大于后面的元素
// 所以当前面小的时候要交换
if (array[j] < array[j - 1])
{
array[j] ^= array[j - 1];
array[j - 1] ^= array[j];
array[j] ^= array[j - 1];
}
} else
{
// 降序排列:前面的要小于后面的元素
// 所以当前面大的时候要交换
if (array[j] > array[j - 1])
{
array[j] ^= array[j - 1];
array[j - 1] ^= array[j];
array[j] ^= array[j - 1];
}
}
}
}
}
// 前面降序后面升序
else
{
for (int i = 1; i < array.length; i++)
{
for (int j = 1; j < array.length - i + 1; j++)
{
if (j < k)
{
// 降序排列:前面的要小于后面的元素
// 所以当前面大的时候要交换
if (array[j] > array[j - 1])
{
array[j] ^= array[j - 1];
array[j - 1] ^= array[j];
array[j] ^= array[j - 1];
}
} else
{
// 升序排列:前面的要大于后面的元素
// 所以当前面小的时候要交换
if (array[j] < array[j - 1])
{
array[j] ^= array[j - 1];
array[j - 1] ^= array[j];
array[j] ^= array[j - 1];
}
}
}
}
}
}

package yiyuanercifangcheng;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test
{
public static void main(String[] args)
{
// String text="ax^2+bx+c";
// String text = "x^2+3x-4";
// String text = "x^2+4x+4";
// String text = "x^2+10x+25";
// String text = "x^2-10x+25";
// String text = "x^2+8x+16";
String text = "x^2-8x+16";
System.out.println("二次方程:" + text);
Pattern fun = Pattern.compile("(.*?)x\\^2(.*?)x(.*?)");
Matcher matcher = fun.matcher(text);
int[] a = new int[3];
int b = 0;
int[] c = new int[3];
// a是否已经分解
boolean isADiv = false;
// C是否已经分解
boolean isCDiv = false;
if (matcher.matches())
{
String astr = matcher.group(1), bstr = matcher.group(2),
cstr = matcher.group(3);
// 如果有正号则移除正号
bstr = bstr.replaceAll("\\+", "");
// 如果有正号则移除正号
cstr = cstr.replaceAll("\\+", "");
// 这说明系数1忽略没有写
if (astr == null || astr.equals(""))
{
a[0] = 1;
a[1] = 1;
a[2] = 1;
isADiv = true;
} else
{
a[0] = Integer.parseInt(astr);
}
// 这说明系数1忽略没有写
if (bstr == null || bstr.equals(""))
{
b = 1;
} else
{
b = Integer.parseInt(bstr);
}
c[0] = Integer.parseInt(cstr);
}
// a=1的情况
if (isADiv)
{
for (int i = 1, first = -Math.abs(c[0]), length = 2
* Math.abs(c[0]); i < length; i++)
{
c[1] = first++;
// 跳过分母为0的情况
if (c[1] == 0)
continue;
c[2] = c[0] / c[1];
// 判断是否能整除
if (c[1] * c[2] == c[0])
{
System.out.print("可以整除: " + c[1] + " * " + c[2] + " = "
+ (c[1] * c[2]) + "  =" + c[0]);
if ((a[1] * c[2] + a[2] * c[1]) == b)
{
System.out.print(",(" + a[1] + "*" + c[2] + "+" + a[2]
+ "*" + c[1] + ")=" + b);
System.out.print(",满足十字相乘法: ");
System.out.println(printResult(a, c));
// 得到结果,终止循环
break;
}
System.out.println();
} else
{
System.out.println("不可整除: " + c[1] + " * " + c[2] + " = "
+ (c[1] * c[2]) + " !=" + c[0]);
// 跳过不能整除的情况
continue;
}
}
}
}
/**
 * 拼接公式
 * @param a x^2的系数数组
 * @param c 常数c的系数数组
 * return 拼接好的形如(a_1x+c_1)(a_2x+c_2)公式
 */
public static String printResult(int[] a, int[] c)
{
StringBuffer sb = new StringBuffer();
sb.append("(");
// 如果系数是1或者-1
if (Math.abs(a[1]) == 1)
{
// 如果是-1则显示负号
if (a[1] == -1)
{
sb.append("-");
}
// 如果是+1则什么都不显示
} else
{
sb.append(a[1]);
}
sb.append("x");
if (c[1] >= 0)
{
System.out.print("+");
sb.append("+");
}
sb.append(c[1] + ")(");
// 如果系数是1或者-1
if (Math.abs(a[1]) == 1)
{
// 如果是-1则显示负号
if (a[1] == -1)
{
sb.append("-");
}
// 如果是+1则什么都不显示
} else
{
sb.append(a[1]);
}
sb.append("x");
if (c[2] >= 0)
{
sb.append("+");
}
sb.append(c[2] + ")");
return sb.toString();
}
}