华为机考Java版

/*第一题的题目大概是输入整型数组求数组的最小数和最大数之和，例如输入1,2,3,4则输出为5，当输入只有一个数的时候，
 则最小数和最大数都是该数，例如只输入1，则输出为2；另外数组的长度不超过50
 */
import java.util.Scanner;
public class Huawei01
{
	public static void main(String[] args)
	{
		System.out.println("请输入数组长度1~50：");
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		System.out.println("请输入数组：");
		Scanner sc = new Scanner(System.in);
		int []a=new int[n];
		
		for(int i=0;i<n;i++)

		  {
				a[i] = sc.nextInt();
		  }

		int max=a[0],min=a[0];//这两个一定要放到数组赋值以后不然min始终为0
		
		for(int j=0;j<n;j++)
		{
			if(max<a[j])
				max=a[j];
		
			else if(min>a[j])
				min=a[j];
		}
		System.out.println("max=" + max);
		System.out.println("min=" + min);
		int sum=min+max;
		System.out.println(sum + ",");
      
		s.close();
		sc.close();

	}
}

/*求两个长长整型的数据的和并输出，例如输入1233333333333333 。。。 3111111111111111111111111.。。。，则输出*/
import java.math.BigDecimal;
import java.util.Scanner;

public class Huawei02 {

	public static void main(String[] args) {

		Huawei02 c = new Huawei02();

		System.out.println("请输入两个长整形数：");
		Scanner s = new Scanner(System.in);

		long n = s.nextLong();
		String str1 = "" + n;
		BigDecimal bi1 = new BigDecimal(str1);

		long m = s.nextLong();
		String str2 = "" + m;
		BigDecimal bi2 = new BigDecimal(str2);

		BigDecimal bi3 = bi1.add(bi2);

		// System.out.println(c.add("1234567890123456789043876945","123456781098765432112345622232323232323"));

		System.out.println("bi3=" + bi3);
	}

	public String add(String a, String b) {

		if (a.length() > b.length()) {

			return adds(a.trim(), b.trim());
		} else {

			return adds(b.trim(), a.trim());
		}
	}

	private String adds(String a, String b) {
		int tmp = 0;
		int t = 0;

		char[] nc = new char[a.length()];

		for (int i = a.length() - 1, j = i - (a.length() - b.length()); i >= 0; i--) {

			if (a.charAt(i) > 47 && a.charAt(i) < 58) {

				t = tmp + (int) a.charAt(i) - 48;

			} else {

				throw new FormatException(a + "第" + (i + 1) + "个字符不是数字");

			}

			if (j >= 0) {

				if (b.charAt(j) > 47 && b.charAt(j) < 58) {

					t = t + (int) b.charAt(j) - 48;

				} else {

					throw new FormatException(b + "第" + (j + 1) + "个字符不是数字");

				}

			}
			tmp = t / 10;
			nc[i] = (char) (t % 10 + 48);
			j--;
		}
		if (tmp > 0) {
			return tmp + new String(nc);
		} else {
			return new String(nc);
		}

	}
}

class FormatException extends RuntimeException {
	public FormatException(String string) {
		super(string);
	}

/*03. 通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。
 比如字符串“abacacde”过滤结果为“abcde”。
 要求实现函数： 
 void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);
 【输入】 pInputStr： 输入字符串
 lInputLen： 输入字符串长度 
 【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长；
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei03 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		str = str.trim();
		
		StringBuffer sb = new StringBuffer(str);

		for (int i = 0; i < sb.length(); i++) {

			for (int j = i + 1; j < sb.length(); j++) {
				if (sb.charAt(i) == (sb.charAt(j))) {

					sb.deleteCharAt(j);
					j--;
				}
			}
		}
		System.out.println(sb);
	}
}

/*04. 通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。
 压缩规则：
 1. 仅压缩连续重复出现的字符。比如字符串"abcbc"由于无连续重复字符，压缩后的字符串还是"abcbc".
 2. 压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz"压缩后就成为"3x6yz"

 要求实现函数： 
 void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr);

 【输入】 pInputStr： 输入字符串
 lInputLen： 输入字符串长度 
 【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长；
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei04 {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		str = str.trim();

		StringBuffer sb = new StringBuffer(str);
		StringBuffer sb1 = new StringBuffer();
		
		int len = sb.length();
		
		String str1 = sb.toString() + "  ";

		char[] chars = str1.toCharArray();

		int i;
		int count = 1;

		for (i = 0; i < len; i++) {
			if (chars[i] == chars[i + 1]) {
				count++;
				continue;
			}
			if (count != 0 && count != 1)
				sb1.append(count).append(chars[i]).toString();
			else
				sb1.append(chars[i]).toString();
			count = 1;
		}
		System.out.print(sb1);
	}
}

/*30. 计算重复字符个数 
 描述: 输入一行字符串。如果字符是英文字母，则输出为输入的英文字符+连续出现的次数 ，
 例如 “ABBCCCC”-> “A1B2C4”；否则，丢弃该字符，不输出。
 运行时间限制: 无限制 
 内存限制: 无限制 
 输入: 输入的字符串，长度小于1024
 输出: ?输入的英文字符以及其重复的次数

 样例输入: ABBC67%%%CCCAA99 
 样例输出: A1B2C4A2
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class Huawei30 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		str = str.trim();
		int len = str.length();

		String[] str1 = new String[len];
		str1 = str.split("[^a-zA-Z]+");
		int len1 = str1.length;
		int i = 0;

		StringBuffer sb = new StringBuffer();
		StringBuffer sb1 = new StringBuffer();
		for (i = 0; i < len1; i++) {
			sb.append(str1[i]).toString();

		}
		sb.toString();
		String str2 = sb.toString();
	
		str2=str2+"  ";
		int len2 = sb.length();
		char[] chars=str2.toCharArray();
		int counter = 1;


		for (i = 0; i < len2; i++) {
			if (chars[i] == chars[i + 1]) {
				counter++;
				continue;
			}
			sb1.append(chars[i]).append(counter).toString();
			counter = 1;

		}
		System.out.print(sb1);
	}
}


/*27.统计数字出现的次数，最大次数的统计出来
 举例：
 输入：323324423343
 输出：3,6
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class Huawei27 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		str = str.trim();
		int maxnum = 0;
		int temp = 0;
		int j;
		char[] chars = str.toCharArray();
		ArrayList<Character> list = new ArrayList<Character>();
		for (char c : chars) {
			if (!list.contains(c)) {
				list.add(c);
			}
		}

		int len = list.size();
		int lenc = chars.length;
		for (int i = 0; i < len; i++) {
			int count = 0;
			for (j = 0; j < lenc; j++) {
				if (list.get(i).equals(chars[j])) {
					count++;
					if (count > maxnum) {
						maxnum = count;
						temp = j;

					}

				}
			}

		}
		System.out.println(chars[temp] + "," + maxnum);

	}

}

/*07. 输入一串字符，只包含“0-10”和“，”找出其中最小的数字和最大的数字（可能不止一个），
输出最后剩余数字个数。如 输入 “3,3,4,5,6,7,7”
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Huawei07 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		str = str.trim();
		char[] chars = str.toCharArray();

		int len = chars.length;

		int array[] = new int[100];
		int count = 0;
		for (int i = 0; i < len; i++) {
			if (chars[i] >= '0' && chars[i] <= '9')
				array[count++] = chars[i] - '0';

		}
		int result = count;
		int min = array[0];
		int max = array[0];
		for (int j = 0; j < count; j++) {
			if (max < array[j])
				max = array[j];
			else if (min > array[j])
				min = array[j];

		}
		System.out.println("最大数是:" + max);
		System.out.println("最小数是:" + min);
		StringBuffer sb = new StringBuffer();
		for (int k = 0; k < count; k++) {
			if (array[k] == min)
				result--;

			if (array[k] == max)
				result--;

		}
		for (int k = 0; k < count; k++) {
			if (array[k] != min && array[k] != max)
				sb.append(array[k] + " ");

		}
		System.out.println("除去最大值与最小值，剩余数字个数为：" + result + "个");
		System.out.println("剩余的数字为：" + sb);
	}
}

/*9. 删除子串，只要是原串中有相同的子串就删掉，不管有多少个，返回子串个数。*/
public class Huawei09 {

	public static void main(String[] args) {
		String str = "123abc12de1234fg1hi34j123k";
		String sub_str = "123";

		int count = 0;
		StringBuffer sb = new StringBuffer(str);

		// if (str.length() != str.replace(sub_str, "").length()) 判断字符串包含

		while (sb.indexOf(sub_str) != -1) {

			int a = sb.indexOf(sub_str);
			sb.delete(a, a + 3);
			count++;

		}

		System.out.println("包含子串个数为：" + count);
		System.out.println("去除子串后的字符串为：" + sb);
	}
}



/*14. 字串转换
 问题描述：
 将输入的字符串（字符串仅包含小写字母‘a’到‘z’），按照如下规则，循环转换后输出：a->b,b->c,…,y->z,z->a
 ；若输入的字符串连续出现两个字母相同时，后一个字母需要连续转换2次。
 例如：aa 转换为 bc，zz 转换为 ab；当连续相同字母超过两个时，第三个出现的字母按第一次出现算。
 要求实现函数：
 void convert(char *input,char* output)
 【输入】 char *input , 输入的字符串
 【输出】 char *output ，输出的字符串
 【返回】 无
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei14 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		str = str.trim();

		char[] input = str.toCharArray();
		char[] output = new char[256];
		int len = input.length;
		int i;
		int flag = 0;
		char temp = (char) ((input[0] - 'a' + 1) % 26 + 'a');
			
		

		for (i = 0; i < len; i++) {
			if (input[i]!=temp) {
				output[i] = (char) ((input[i] - 'a' + 1) % 26 + 'a');
				temp = input[i];
				flag = 1;
			} else

			if (flag == 1) {
				output[i] = (char) ((input[i] - 'a' + 2) % 26 + 'a');
				temp = input[i];
				flag = 0;
			} else {
				output[i] = (char) ((input[i] - 'a' + 1) % 26 + 'a');
				temp = input[i];
				flag = 1;
			}

		}
		System.out.print("变换后字符串为：");
		for(i=0;i<len;i++)
		System.out.print(" "+ output[i]);

	}

}


/*35给定一个字符串，把字符串内的字母转换成该字母的下一个字母，a换成b，z换成a，Z换成A，
 * 如aBf转换成bCg，字符串内的其他字符不改变，给定函数，编写函数

 void  Stringchang（const  char*inpu,char*output）
 其中input是输入字符串，output是输出字符串
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Huawei35 {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();

		char[] chars = str.toCharArray();

		int len = chars.length;
		StringBuffer sb = new StringBuffer();
		char[] chars1 = new char[len];
		int i;
		for (i = 0; i < len; i++) {
			if (String.valueOf(chars[i]).matches("[a-zA-Z]+")) {
				if (chars[i] == 'z')
					chars1[i] = 'a';
				else if (chars[i] == 'Z')
					chars1[i] = 'A';
				else {

					chars1[i] = (char) (chars[i] + 1);
				}

			} else
				chars1[i] = chars[i];
			sb.append(chars1[i]).append(" ").toString();
		}

		System.out.println(sb.toString());

	}

}


/*29. 子串分离 
题目描述：   
通过键盘输入任意一个字符串序列，字符串可能包含多个子串，子串以空格分隔。请编写一
个程序，自动分离出各个子串，并使用’,’将其分隔，并且在最后也补充一个’,’并将子
串存储。  
如果输入“abc def gh i        d”，结果将是abc,def,gh,i,d, 
要求实现函数：   
void DivideString(const char *pInputStr, long lInputLen, char *pOutputStr); 
【输入】  pInputStr：  输入字符串 
         lInputLen：  输入字符串长度                   
【输出】  pOutputStr：  输出字符串，空间已经开辟好，与输入字符串等长； 
  */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Huawei29 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		int len = str.length();
		char[] str1=str.toCharArray();
		int cnt=0;
		StringBuffer sb=new StringBuffer();
		
		for (int i=0;i<len;i++)
		{
			if (str1[i]!=' ')
			{
				cnt=0;
				sb.append(str1[i]).toString();
				
			}
			else
			{
				cnt++;
				if(cnt==1)
				{
					sb.append(",").toString();
				}
				
			}
			
		}
		sb.append(",").toString();
		System.out.println(sb);
	}
}

/*28. .字符串首字母转换成大写
 举例：
 输入：this is a book
 返回：This Is A Book
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei28 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("请输入小写字符串:");
		String str = br.readLine();
		str = str.trim();
		char[] str1 = str.toCharArray();

		int len = str1.length;
		char[] str2 = new char[len];
		StringBuffer sb=new StringBuffer();
		StringBuffer sb1=new StringBuffer();

		sb.append(str1).toString();
		for (int i = 0; i < len; i++) {
			
			if (str1[0] != ' ')
				str1[0] -= 32;
			if (str1[i] == ' ')
				str1[i + 1] -= 32;
			str2[i] = str1[i];
			
			
			sb1.append(str2[i]).toString();

		}
		
		
		System.out.println("您输入的字符串为:"+ sb);
		System.out.println("变换后的字符串为:"+sb1);

	}

}

/*34. 输入若干（不超过1000个）非负整数数字，请先取出为奇数的数字按从大到小排序，
 * 再取出偶数从小到大排序
 * 输入8 12 3 7 6 5 9
 * 9 8 6 3
 * 5 7 12
 * 输出9 5 8 7 6 12 3
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei34 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		int len = str.length();

		String[] str1 = str.split(" ");
		int len1 = str1.length;

		StringBuffer sb = new StringBuffer();
		StringBuffer sb1 = new StringBuffer();
		int i;
		for (i = 0; i < len1; i += 2) {

			sb.append(str1[i]).append(",").toString();

		}

		String[] str22 = sb.toString().split(",");
		int len2 = str22.length;
		int[] str2 = new int[len2];

		for (i = 0; i < len2; i++) {

			str2[i] = Integer.parseUnsignedInt(str22[i]);
		}
		int temp;
		int m, n;
		for (m = 0; m < len2; m++) {
			for (n = 0; n < len2 - m - 1; n++) {
				if (str2[n] < str2[n + 1]) {
					temp = str2[n];
					str2[n] = str2[n + 1];
					str2[n + 1] = temp;
				}
			}
		}
		for ( i=0;i< len2;i++)
			System.out.print(str2[i]);
		for (i = 1; i < len1; i += 2) {
			sb1.append(str1[i]).append(",").toString();
		}
		String[] str33 = sb1.toString().split(",");
		int len3 = str33.length;
		int[] str3 = new int[len3];
		for (i = 0; i < len3; i++) {
			str3[i] = Integer.parseUnsignedInt(str33[i]);
		}
		for (m = 0; m < len3; m++) {
			for (n = 0; n < len3 - m - 1; n++) {
				if (str3[n] > str3[n + 1]) {
					temp = str3[n];
					str3[n] = str3[n + 1];
					str3[n + 1] = temp;
				}
			}
		}
		System.out.println();
		for ( i=0;i< len3;i++)
			System.out.print(str3[i]);
		System.out.println();
		int len4 = len2+len3;
		int[] str4 = new int[len4];
		int j=0,k=0;
		for (i = 0; i < len4; i++) {
			if(i % 2 == 0)
			{
				str4[i] = str2[j];
				j++;
			}
			else 
			{
				str4[i] = str3[k];
				k++;
			}
		}
		for (i = 0; i < len4; i++) {
			System.out.print(str4[i] + " ");
		}
	}
}

/*38. 识别字符串中的整数并转换为数字形式（40分）
 问题描述： 
 识别输入字符串中所有的整数，统计整数个数并将这些字符串形式的整数转换为数字形式整数。
 要求实现函数： 
 void take_num(const char *strIn, int *n, unsigned int *outArray)
 【输入】 strIn：   输入的字符串
 【输出】 n：       统计识别出来的整数个数
 outArray：识别出来的整数值，其中outArray[0]是输入字符串中从左到右第一个整数，
 outArray[1]是第二个整数，以此类推。数组地址已经分配，可以直接使用
 【返回】 无
 注：
 I、     不考虑字符串中出现的正负号(+, -)，即所有转换结果为非负整数（包括0和正整数）
 II、    不考虑转换后整数超出范围情况，即测试用例中可能出现的最大整数不会超过unsigned int可处理的范围
 III、   需要考虑 '0' 开始的数字字符串情况，比如 "00035" ，应转换为整数35；
 "000" 应转换为整数0；"00.0035" 应转换为整数0和35（忽略小数点：mmm.nnn当成两个数mmm和nnn来识别）
 IV、   输入字符串不会超过100 Bytes，请不用考虑超长字符串的情况。
 示例 
 输入：strIn = "ab00cd+123fght456-25  3.005fgh"
 输出：n = 6
 outArray = {0, 123, 456, 25, 3, 5}
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei38 {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();

		String[] str1 = str.split("[^0-9]+");
		int len = str1.length;
		
		System.out.println();
		for(int m=0;m<len;m++)
		{
			System.out.print(str1[m] + " ");
		}
		StringBuffer sb = new StringBuffer();
		int i,count=0;
		for (i = 0; i < len; i++) {

			if (str1[i].matches("[0]+")) {

				str1[i]="0";
				sb.append(str1[i]).append(",").toString();
				count++;
			}
			else if(str1[i].matches("[1-9]+"))
			{
				sb.append(str1[i]).append(",").toString();
				count++;
			}
			else if(str1[i].matches("[0-9]+"))
			{
				String s1 = str1[i].replaceFirst("^0*", "");
				sb.append(s1).append(",").toString();
				count++;
			}
		}

		int sb1 = sb.length();
		sb.deleteCharAt(sb1-1);
		System.out.println(count);
		System.out.println(sb.toString());
	}
}


/*15. 在给定字符串中找出单词（ “单词”由大写字母和小写字母字符构成，
 其他非字母字符视为单词的间隔，如空格、问号、数字等等；另外单个字母不算单词）；
 找到单词后，按照长度进行降序排序，（排序时如果长度相同，则按出现的顺序进行排列），然后输出到一个新的字符串中；
 如果某个单词重复出现多次，则只输出一次；如果整个输入的字符串中没有找到单词，请输出空串。
 输出的单词之间使用一个“空格”隔开，最后一个单词后不加空格。
 要求实现函数：
 void my_word(charinput[], char output[])
 【输入】 char input[], 输入的字符串
 【输出】 char output[]，输出的字符串
 【返回】 无
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei15 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("请输入字符串:");
		String str = br.readLine();
		int len = str.length();
		System.out.println("筛选之前的字符串为： \n" + str);

	
		if(str.matches("[^a-zA-Z]+"))
		{
			System.out.println("null");
		}else{
			
		String[] str1 = new String[len];
		str1 = str.split("[^a-zA-Z]+");

		System.out.println("单词提取为:");
		for (int i = 0; i < str1.length; i++) {
			System.out.print(str1[i] + " ");
		}

		int i, j;
		String temp;
		for (i = 0; i < str1.length; i++) {
			for (j = 1; j < str1.length - i; j++) {
				if ((str1[j - 1]).length() < str1[j].length()) {
					temp = str1[j];
					str1[j] = str1[j - 1];
					str1[j - 1] = temp;
				}
			}

		}

		StringBuffer sb = new StringBuffer();
		int len1 = str1.length;
		System.out.println();
		System.out.println("按照单词长度排序为:");
		for (i = 0; i < len1; i++) {

			System.out.print(str1[i] + " ");
		}

		for (i = 0; i < len1; i++) {
			for (j = i + 1; j < len1; j++) {
				if (str1[i].equals(str1[j]))
					str1[j] = "\0";

			}

		}
		for (j = 0; j < len1; j++) {
			if (!(str1[j] == "\0")) {

				sb.append(str1[j]).append(" ").toString();
			}

		}
		int len2= sb.length();
		sb.deleteCharAt(len2-1);
		System.out.println();
		System.out.println(sb);

		}
	
	}

}

/*32：根据指定的分隔符分隔字符串，并输出指定的段
 描述
 根据指定的分隔符分隔字符串，并输出指定的段。如果指定的段超过分隔的段数，输出：NULL

 举例： 
 AAA?BBB?CCC??2 
 字符串为：AAA?BBB?CCC? 
 分隔符为：？ 
 指定的段为：2 
 字符串分割为：AAA BBB CCC共三段，第2段字符串为：BBB
 输入输出格式要求
 输入分隔字符串长度小于128个字符，指定的段是一个正整数。
 样例
 输入：AAA?BBB?CCC??2 
 输出：BBB
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei32 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		int len = str.length();

		int i;
		String[] str1 = new String[len];
		str1 = str.split("\\?");
		int len1 = str1.length;

		int num = Integer.parseInt(str1[len1 - 1]);
		
		StringBuffer sb = new StringBuffer();

		for (i = 0; i < len1; i++) {
			
			if (!str1[i].equals("")) {
				sb.append(str1[i]).append(",").toString();

			}
		}
		int len2 = sb.length();
		System.out.println(sb);
		sb.delete(len2-3,len2+1);
		System.out.print(sb);
		String str3 = sb.toString();

		int len3 = str3.length();
		String[] str2 = new String[len3];
		str2 = str3.split(",");

		int len4 = str2.length;
		System.out.println();

		if (num > len4)
			System.out.println("null");
		else
			System.out.print(str2[num - 1]);
	}
}


/*２１．将第一行中含有第二行中“23”的数输出并排序
 2.输入一行数字：123 423 5645 875 186523
 在输入第二行：23
 将第一行中含有第二行中“23”的数输出并排序
 结果即：123 423 186523
 */
import java.util.Scanner;
public class Huawei21 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int i, j, temp;
		int[] sort = new int[20];
		int k = 0;

		System.out.println("请输入一组数字，不超过20个:");
		Scanner sc = new Scanner(System.in);
		String inputString = sc.next().toString();
		String stringArray[] = inputString.split(",");
		System.out.println("请输入检测数字：");
		String inputStrin1 = sc.next().toString();
		sc.close();

		int len = stringArray.length;
		for (i = 0; i < len; i++) {
			StringBuffer sb = new StringBuffer(stringArray[i]);

			if (sb.indexOf(inputStrin1) != -1) {
				sort[k] = Integer.parseInt(stringArray[i]);
				k++;
			}
		}
		for (i = 0; i < k - 1; i++) {
			for (j = i + 1; j < k; j++) {
				if (sort[i] > sort[j]) { // 交换两数的位置
					temp = sort[i];
					sort[i] = sort[j];
					sort[j] = temp;
				}
			}
		}
		System.out.print("结果为：");
		for (i = 0; i < k; i++) {

			System.out.print(" " + sort[i]);
		}
	}

}


/*２２输入m个字符串 和一个整数n, 把字符串M化成以N为单位的段，不足的位数用0补齐。
 如 n=8 m=9 ，
 123456789划分为：  12345678
                90000000
 123化为 ：12300000
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
public class Huawei22 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		int i, j = 0;
		char[] c = new char[200];
		System.out.println("请输入字符串：");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		str = str.trim();
		int len = str.length();
		System.out.println("请输入单位n：");
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.close();

		c = str.toCharArray();
		for (i = 1; i <= len; i++) {
			j = i % n;
			System.out.print(c[i - 1]);
			if (j == 0)
				System.out.println();
		}
		if (j != 0) {
			for (i = j + 1; i <= n; i++)
				System.out.print("0");
		}

	}
}

/*8.输入一组身高在170到190之间（5个身高），比较身高差，选出身高差最小的两个身高；
若身高差相同，选平均身高高的那两个身高；从小到大输出；
如 输入 170 181 173 186 190   输出 170 173
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
public class Huawei08 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		int[] Height = new int[5];
		int dmin;
		int H1, H2;
		int i, j, temp;
		System.out.println("请输入一组身高在170到190之间的数据（共5个）:");

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		String stringArray[] = str.split(" ");

		System.out.println("您输入的5个身高数据为：");
		for (i = 0; i < stringArray.length; i++) {
			System.out.print(stringArray[i] + " ");
		}

		System.out.println();

		System.out.println("转换为整形数组：");
		for (int k = 0; k < 5; k++) {
			Height[k] = Integer.parseInt(stringArray[k]);
			System.out.print(Height[k] + " ");
		}

		for (i = 0; i < 5; i++) {
			for (j = i; j < 5; j++) {
				
				if (Height[i] > Height[j]) {
					temp = Height[i];
					Height[i] = Height[j];
					Height[j] = temp;
					
				}
			}
		}
		
		System.out.println();
		System.out.println("排序后输出：");
		for (int k = 0; k < 5; k++) {
			
			System.out.print(Height[k] + " ");
		}


		H1 = Height[0];
		H2 = Height[1];
		dmin = H2 - H1;
		for (int m = 2; m < 5; m++) {
			if (Height[m] - Height[m - 1] <= dmin) {

				H1 = Height[m - 1];
				H2 = Height[m];
				dmin = Height[m] - Height[m - 1];
			}
		}

		System.out.println();
		System.out.println("身高差最小的两个身高为：");
		System.out.println(H1 + " " + H2);

	}

}

/*11. 描述：10个学生考完期末考试评卷完成后，A老师需要划出及格线，要求如下：
 (1) 及格线是10的倍数；
 (2) 保证至少有60%的学生及格；
 (3) 如果所有的学生都高于60分，则及格线为60分
 输入：输入10个整数，取值0~100
 输出：输出及格线，10的倍数
 */
import java.util.Scanner;
public class Huawei11 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int[] a = new int[10];
		int pass;
		int temp; // 记录临时中间值   
	    int size = 10; // 数组大小   
		System.out.println("请随机输入10个成绩（0-100）:");
		Scanner sc = new Scanner(System.in);
		String inputString = sc.next().toString();
		String stringArray[] = inputString.split(",");

		for (int k = 0; k < 10; k++) {
			a[k] = Integer.parseInt(stringArray[k]);
			System.out.print(a[k] + " ");

		}
		System.out.println();
	    
	    for (int i = 0; i < size - 1; i++) {   
	        for (int j = i + 1; j < size; j++) {   
	            if (a[i] > a[j]) { // 交换两数的位置   
	                temp = a[i];   
	                a[i] = a[j];   
	                a[j] = temp;   
	            }   
	        }   
	    }

		for (int k = 0; k < 10; k++) {

			System.out.print(a[k] + " ");

		}
		if (a[0] >= 60)
			System.out.println("及格线为：60");
		else {
			pass = (((int) a[4] / 10) * 10);
			System.out.println("及格线为：" + pass);
		}

	}

}

/*12. 描述：一条长廊里依次装有n(1 ≤ n ≤ 65535)盏电灯，从头到尾编号1、2、3、…n-1、n。
 每盏电灯由一个拉线开关控制。开始，电灯全部关着。
 有n个学生从长廊穿过。第一个学生把号码凡是1的倍数的电灯的开关拉一下；
 接着第二个学生把号码凡是2的倍数的电灯的开关拉一下；接着第三个学生把号码凡是3的倍数的电灯的开关拉一下；
 如此继续下去，最后第n个学生把号码凡是n的倍数的电灯的开关拉一下。n个学生按此规定走完后，长廊里电灯有几盏亮着。
 注：电灯数和学生数一致。
 输入：电灯的数量
 输出：亮着的电灯数量
 样例输入：3
 样例输出：1
 */
import java.util.Scanner;
public class Huawei12 {
	private static int GetLightLampNum(int n) {

		int ret = 0;
		boolean[] flag = new boolean[n];
		// 初始化电灯，全部关着
		for (int i = 0; i < n; i++) {
			flag[i] = false;
		}

		// 拉灯操作，true为亮，灭为false
		for (int i = 1; i <= n; i++) {
			for (int j = i; j <= n; j++) {
				if (0 == j % i) {
					flag[j - 1] = !flag[j - 1];
				}
			}
		}

		// 找出所有亮的灯
		for (int i = 0; i < n; i++) {
			if (flag[i]) {
				ret++;
			}
		}

		return ret;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int n, result;
		System.out.println("请输入灯的数量（1-65535）:");
		Scanner input = new Scanner(System.in);
		n = input.nextInt();
		input.close();
		if ((n < 1) || (n > 65535)) {
			System.out.println("输入数值超出范围！");
		} else {

			result = GetLightLampNum(n);
			System.out.println("最后亮灯的数量为:" + result);
		}

	}

}


/*１６. 数组中数字都两两相同，只有一个不同，找出该数字：
 异或运算的性质：任何一个数字异或它自己都等于0 
因为其他数字都出现了两次，在异或中全部抵消掉了。
算法步骤：1，对1-n个数做异或运算，得到XOR = 1^2^3^4....^n。
       2,   用XOR与当前n-1数组的所有元素依次取异或：
因为XOR中与当前数字相同的数，都在异或运算中抵消掉了，最终剩下的，就是我们要找的那个丢失的数。
所谓抵消：举个例子： 1，1，2
1： 0001
2:   0010                   1^1=0000              
 1^1^2 ===== 0000 ^ 0010 = 0010=2，也就是说两个1抵消了。
任何一个数字异或它自己都等于0，而0与任何数字求异或，都为原数字！
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
public class Huawei16 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		System.out.println("请输入整数：");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		int len = str.length();
		String[] chars = str.split("");
		

		int[] a = new int[len];
		for (int i = 0; i < len; i++) {
			int num = Integer.parseInt(chars[i]);
			a[i]=num;
		}
			int temp = a[0];
			for (int j = 1; j < len; j++) {
				temp ^= a[j];
			}
			System.out.println(temp);

		}
	}

/*17. 题目二：数组中数字两两相同，有两个不同，找出这两个：*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei17 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		System.out.println("请输入整数：");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		int len = str.length();
		String[] chars = str.split("");

		int[] a = new int[len];
		for (int i = 0; i < len; i++) {
			int num = Integer.parseInt(chars[i]);
			a[i] = num;
		}
		int result = 0;
		for (int i = 0; i < a.length; i++) {// 异或结束相当于两个数异或的结果
			result ^= a[i];
			
		}
		int count = 1;
		int b = 1;
		while (true) {
			if ((result & b) == 1) {
				break;
			}
			result = result >> 1;
			count = count << 1;
		}
		int num1 = 0;
		int num2 = 0;

		for (int i = 0; i < a.length; i++) {
			if ((a[i] & count) == 0) {
				num1 ^= a[i];
			} else {
				num2 ^= a[i];
			}
		}
		System.out.println("num1=" + num1 + " num2=" + num2);
	}
}


/*05. 通过键盘输入100以内正整数的加、减运算式，请编写一个程序输出运算结果字符串。 
 输入字符串的格式为：“操作数1 运算符 操作数2”，“操作数”与“运算符”之间以一个空格隔开。 
 补充说明： 
 1. 操作数为正整数，不需要考虑计算结果溢出的情况。 
 2. 若输入算式格式错误，输出结果为“0”。 
 要求实现函数：  
 void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr); 
 【输入】 pInputStr：  输入字符串 
 lInputLen：  输入字符串长度          
 【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长； 
 【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出 
 示例  
 输入：“4 + 7”  输出：“11” 
 输入：“4 - 7”  输出：“-3” 
 输入：“9 ++ 7”  输出：“0” 注：格式错误 
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei05 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		int len = str.length();
		char[] chars = str.toCharArray();
		int len1 = chars.length;

		char ch;
		int index1 = 0;
		int index2 = 0;
		int index3 = 0;

		char[] op1 = new char[10];
		char[] op = new char[10];
		char[] op2 = new char[10];

		int i, j;
		int cnt = 0;
		for (i = 0; i < len1; i++) {
			ch = chars[i];
			if (!Character.isDigit(ch) && ch != ' ' && ch != '+' && ch != '-' && ch !='*' && ch != '/')
				return;
		}

		for (j = 0; j < len1; j++) {
			ch = chars[j];

			if (ch == ' ') {
				cnt++;
				if (cnt > 2) {
					System.out.println("too much space!");
					return;
				}
				continue;
			}

			if (cnt == 0) {
				op1[index1++] = ch;

			} else if (cnt == 1) {
				op[index2++] = chars[j];
				if (index2 > 1) {
					System.out.println("0");
					return;
				}
			} else if (cnt == 2) {
				op2[index3++] = chars[j];
			}

		}

		int iop1 = Integer.parseInt(String.valueOf(op1[0]));
		int iop2 = Integer.parseInt(String.valueOf(op2[0]));
		;
		int temp = 0;

		StringBuffer sb = new StringBuffer();
		if (op[0] == '*') {
			temp = iop1 * iop2;
			sb.append(temp).toString();
			
		} else if (op[0] == '/') {
			temp = iop1 / iop2;
			sb.append(temp).toString();
		} else if (op[0] == '+') {

			temp = iop1 + iop2;
			sb.append(temp).toString();

		} else if (op[0] == '-') {
			if (iop1 > iop2) {
				temp = iop1 - iop2;
				sb.append(temp).toString();
			} else {
				temp = iop2 - iop1;
				sb.append("-").append(temp).toString();
			}
		}

		for (i = 1; i < len; i++) {
			sb.append(" ").toString();
		}
		String str1 = sb.toString();
		System.out.println(str1);

	}

}

/*18. 链表翻转。给出一个链表和一个数k，比如链表1→2→3→4→5→6，k=2，
则翻转后2→1→4→3→6→5，若k=3,翻转后3→2→1→6→5→4，若k=4，翻转后4→3→2→1→5→6，用程序实现
思想：采用遍历链表，分成length/k组，对每组进行逆转，逆转的同时要将逆转后的尾和头连接起来
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Huawei18<T> {

	private Node firstNode;
	private int length;

	public Huawei18() {
		clear();
	}

	public final void clear() {
		firstNode = null;
		length = 0;
	}

	public boolean add(T newEntry) {
		Node newNode = new Node(newEntry);
		if (isEmpty())
			firstNode = newNode;
		else {
			Node lastNode = getNodeAt(length);
			lastNode.next = newNode;
		}
		length++;
		return true;
	}

	public boolean add(int newPosition, T newEntry) {
		boolean isSuccessful = true;
		if ((newPosition >= 1) && (newPosition <= length + 1)) {
			Node newNode = new Node(newEntry);
			if (isEmpty() || (newPosition == 1)) {
				newNode.next = firstNode;
				firstNode = newNode;
			} else {
				Node nodeBefore = getNodeAt(newPosition - 1);
				Node nodeAfter = nodeBefore.next;
				newNode.next = nodeAfter;
				nodeBefore.next = newNode;
			}
			length++;
		} else
			isSuccessful = false;
		return isSuccessful;
	}

	private Node getNodeAt(int givenPosition) {
		assert !isEmpty() && (1 <= givenPosition) && (givenPosition <= length);
		Node currentNode = firstNode;
		for (int counter = 1; counter < givenPosition; counter++) {
			currentNode = currentNode.next;
		}
		assert currentNode != null;
		return currentNode;

	}

	public boolean isEmpty() {
		boolean result;
		if (length == 0) {
			assert firstNode == null;
			result = true;
		} else {
			assert firstNode != null;
			result = false;
		}
		return result;
	}

	public void display() {
		Node currentNode = firstNode;
		while (currentNode != null) {
			System.out.print(currentNode.data + " ");
			currentNode = currentNode.next;
		}
	}

	public Object remove(int givenPosition) {
		Object result = null;
		if (!isEmpty() && (1 <= givenPosition) && (givenPosition <= length)) {
			if (givenPosition == 1) {
				result = firstNode.data;
				firstNode = firstNode.next;
			} else {
				Node nodeBefore = getNodeAt(givenPosition);
				Node nodeToRemove = nodeBefore.next;
				Node nodeAfter = nodeToRemove.next;
				nodeBefore.next = nodeAfter;
				result = nodeToRemove.data;
			}
			length--;
		}
		return result;
	}

	public boolean replace(int givenPosition, T newEntry) {
		boolean isSuccessful = true;
		if (!isEmpty() && (1 <= givenPosition) && (givenPosition <= length)) {
			Node desiredNode = getNodeAt(givenPosition);
			desiredNode.data = newEntry;
		} else
			isSuccessful = false;
		return isSuccessful;
	}

	public T getEntry(int givenPosition) {
		T result = null;
		if (!isEmpty() && (1 <= givenPosition) && (givenPosition <= length)) {
			result = getNodeAt(givenPosition).data;

		}
		return result;
	}

	public boolean contains(T anEntry) {
		boolean found = false;
		Node currentNode = firstNode;
		while (!found && (currentNode != null)) {
			if (anEntry.equals(currentNode.data)) {
				found = true;
			} else {
				currentNode = currentNode.next;
			}
		}
		return found;
	}

	private class Node {
		private T data;
		private Node next;

		private Node(T dataPortion) {
			data = dataPortion;
			next = null;
		}

		private Node(T dataPortion, Node nextNode) {
			data = dataPortion;
			next = nextNode;
		}
	}

	public Node reverse(Node head) {
		if (head == null)
			return null;
		Node p, q, t = null;
		p = head;
		q = p.next;
		if (q != null)
			t = q.next;
		// 把头结点设置成尾节点
		head.next = null;
		while (q != null) {
			q.next = p;
			p = q;
			q = t;
			if (t != null)
				t = t.next;
		}
		return p;

	}

	public void reverseKGroup(int k) {
		if (isEmpty()) {
			System.out.println("链表为空！");
		} else {

			Node p;
			Node firstNode1, nextfirstNode;// 反转后的子链表的头指针和下一段链表的头指针，供反转后连接母链表时使用
			Node headNode = firstNode;// 待翻转的子链表的头指针
			Node preTail = null;// 指向上一段链表的尾节点
			p = firstNode;

			int count = 0;

			while (p != null) {
				if (count == 0)
					headNode = p;
				count++;
				if (count == k) {
					count = 0;
					nextfirstNode = p.next;
					p.next = null;
					firstNode1 = reverse(headNode);
					headNode.next = nextfirstNode;// 连接上母链表,现在headNode指向的是尾节点
					if (preTail != null)
						preTail.next = firstNode1;
					if (preTail == null)
						firstNode = firstNode1;
					preTail = headNode;// 指向本次被翻转的链表的尾节点,作为下一次的上一段链表的尾节点
					p = preTail.next;
					continue;
				}
				p = p.next;
			}

		}
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		Huawei18<String> myList = new Huawei18<>();
		System.out.println("请输入：");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		int len = str.length();
		String[] str1 = new String[len];
		str1 = str.split(" ");
		for (int i = 0; i < str1.length; i++) {
			myList.add(str1[i]);
		}

		myList.display();
		System.out.println();
		
		myList.display();

		System.out.println();

		myList.reverseKGroup(3);
		myList.display();

	}

/*19. 链表相邻元素翻转，如a->b->c->d->e->f-g，翻转后变为：b->a->d->c->f->e->g*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei19<T> {
	private Node firstNode;
	private int length;

	public Huawei19() {
		clear();
	}

	public final void clear() {
		firstNode = null;
		length = 0;
	}

	public boolean add(T newEntry) {
		Node newNode = new Node(newEntry);
		if (isEmpty())
			firstNode = newNode;
		else {
			Node lastNode = getNodeAt(length);
			lastNode.next = newNode;
		}
		length++;
		return true;
	}

	public boolean add(int newPosition, T newEntry) {
		boolean isSuccessful = true;
		if ((newPosition >= 1) && (newPosition <= length + 1)) {
			Node newNode = new Node(newEntry);
			if (isEmpty() || (newPosition == 1)) {
				newNode.next = firstNode;
				firstNode = newNode;
			} else {
				Node nodeBefore = getNodeAt(newPosition - 1);
				Node nodeAfter = nodeBefore.next;
				newNode.next = nodeAfter;
				nodeBefore.next = newNode;
			}
			length++;
		} else
			isSuccessful = false;
		return isSuccessful;
	}

	private Node getNodeAt(int givenPosition) {
		assert !isEmpty() && (1 <= givenPosition) && (givenPosition <= length);
		Node currentNode = firstNode;
		for (int counter = 1; counter < givenPosition; counter++) {
			currentNode = currentNode.next;
		}
		assert currentNode != null;
		return currentNode;

	}

	public boolean isEmpty() {
		boolean result;
		if (length == 0) {
			assert firstNode == null;
			result = true;
		} else {
			assert firstNode != null;
			result = false;
		}
		return result;
	}

	public void display() {
		Node currentNode = firstNode;
		while (currentNode != null) {
			System.out.print(currentNode.data + " ");
			currentNode = currentNode.next;
		}
	}

	public Object remove(int givenPosition) {
		Object result = null;
		if (!isEmpty() && (1 <= givenPosition) && (givenPosition <= length)) {
			if (givenPosition == 1) {
				result = firstNode.data;
				firstNode = firstNode.next;
			} else {
				Node nodeBefore = getNodeAt(givenPosition);
				Node nodeToRemove = nodeBefore.next;
				Node nodeAfter = nodeToRemove.next;
				nodeBefore.next = nodeAfter;
				result = nodeToRemove.data;
			}
			length--;
		}
		return result;
	}

	public boolean replace(int givenPosition, T newEntry) {
		boolean isSuccessful = true;
		if (!isEmpty() && (1 <= givenPosition) && (givenPosition <= length)) {
			Node desiredNode = getNodeAt(givenPosition);
			desiredNode.data = newEntry;
		} else
			isSuccessful = false;
		return isSuccessful;
	}

	public T getEntry(int givenPosition) {
		T result = null;
		if (!isEmpty() && (1 <= givenPosition) && (givenPosition <= length)) {
			result = getNodeAt(givenPosition).data;

		}
		return result;
	}

	public boolean contains(T anEntry) {
		boolean found = false;
		Node currentNode = firstNode;
		while (!found && (currentNode != null)) {
			if (anEntry.equals(currentNode.data)) {
				found = true;
			} else {
				currentNode = currentNode.next;
			}
		}
		return found;
	}

	private class Node {
		private T data;
		private Node next;

		private Node(T dataPortion) {
			data = dataPortion;
			next = null;
		}

		private Node(T dataPortion, Node nextNode) {
			data = dataPortion;
			next = nextNode;
		}
	}

	public Node reverse(Node head) {
		if (head == null)
			return null;
		Node p, q, t = null;
		p = head;
		q = p.next;
		if (q != null)
			t = q.next;
		// 把头结点设置成尾节点
		head.next = null;
		while (q != null) {
			q.next = p;
			p = q;
			q = t;
			if (t != null)
				t = t.next;
		}
		return p;

	}

	public void reverseKGroup(int k) {
		if (isEmpty()) {
			System.out.println("链表为空！");
		} else {

			Node p;
			Node firstNode1, nextfirstNode;// 反转后的子链表的头指针和下一段链表的头指针，供反转后连接母链表时使用
			Node headNode = firstNode;// 待翻转的子链表的头指针
			Node preTail = null;// 指向上一段链表的尾节点
			p = firstNode;

			int count = 0;

			while (p != null) {
				if (count == 0)
					headNode = p;
				count++;
				if (count == k) {
					count = 0;
					nextfirstNode = p.next;
					p.next = null;
					firstNode1 = reverse(headNode);
					headNode.next = nextfirstNode;// 连接上母链表,现在headNode指向的是尾节点
					if (preTail != null)
						preTail.next = firstNode1;
					if (preTail == null)
						firstNode = firstNode1;
					preTail = headNode;// 指向本次被翻转的链表的尾节点,作为下一次的上一段链表的尾节点
					p = preTail.next;
					continue;
				}
				p = p.next;
			}

		}
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		Huawei19<String> myList = new Huawei19<>();
		System.out.println("请输入：");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		int len = str.length();
		String[] str1 = new String[len];
		str1 = str.split(" ");
		for (int i = 0; i < str1.length; i++) {
			myList.add(str1[i]);
		}

		myList.display();
		System.out.println();
		
		myList.display();

		System.out.println();

		myList.reverseKGroup(2);
		myList.display();

	}

}


/*２３将 电话号码 one two 。。。nine zero
 翻译成1  2 。。9 0
 中间会有double
 例如输入：OneTwoThree
 输出：123
 输入：OneTwoDoubleTwo
 输出：1222
 输入：1Two2 输出：ERROR
 输入：DoubleDoubleTwo 输出：ERROR
 有空格，非法字符，两个Double相连，Double位于最后一个单词 都错误
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei23 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		String[] words = new String[] { "zero", "one", "two", "three", "four",
				"five", "six", "seven", "eight", "nine", "double" };
		int[] wordslen = new int[11];
		StringBuffer sb1 = new StringBuffer();
		String s1 = null;
		int d = 0;

		String tt = new String();
		String[] result = new String[100];
		String s = null;

		StringBuffer aa = new StringBuffer();
		for (int n = 0; n < 11; n++) {
			wordslen[n] = words[n].length();

		}

		System.out.println("请输入英文电话号码：");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		str = str.toLowerCase();
		int lenStr1 = str.length();
		str = str.replaceAll(" ", "");
		int lenStr2 = str.length();

		StringBuffer sb = new StringBuffer(str);
		int now = 0, r, n = 0;
		if ((lenStr1 != lenStr2) || !str.matches("[a-zA-Z]+"))
			System.out.println("error");
		else {
			while (now < lenStr2) {
				tt = sb.substring(now) + "        ";

				for (n = 0; n < 11; n++) {
					if (tt.substring(0, wordslen[n]).equals(words[n])) {

						s = aa.append(words[n]).append(",").toString();

						now = now + wordslen[n];

						break;
					}

				}

			}
			result = s.split(",");
			int m1=result.length;

			int f=0;
				for (int i = 0; i <m1; i++) {
					for (int j = 0; j < 11; j++) {
						if (result[i].equals(words[j]) && j < 10) {
							r = j;
							s1 = sb1.append(r).toString();

							if (d == 1) {
								s1 = sb1.append(r).toString();
								d = 0;
							}

							break;
						} else if (result[i].equals(words[j]) && j == 10) {
							d += 1;
							if(i==(m1-1))
							{
								f=1;
							}
							break;
						}
						
					}

				}
			
			if (d > 1 || f==1) {
				System.out.println("error");
			} else if(d<=1 && f==0) {
				System.out.println(s1);
			}

		}
	}
}

/*39将中文数字的拼音字符串转为最终的数字；每个字拼音的首字母大写，
 比如：JiuWanJiuQianJiuBaiJiuShiJiu表示九万九千九百九十九，即阿拉伯数字，。
 你当然记得每个数字的汉语拼音，但是还是提示你一下，
 Ling、Yi、Er、San、Si、Wu、Liu、Qi、Ba、Jiu、Shi、Bai、Qian、Wan。
 为简单起见，我们要处理的数字在万以内，不含负数，十、百、千、万等单位前面一定有数字，如YiShi表示。
 输入: 中文数字的拼音字符串 
 输出: 阿拉伯数字 
 样例输入: SanBaiLingSan
 样例输出: 303
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei39 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		String[] words = new String[] { "Shi", "Bai", "Qian", "Wan", "Ling",
				"Yi", "Er", "San", "Si", "Wu", "Liu", "Qi", "Ba", "Jiu" };
		int[] wordslen = new int[14];
		int n;
		for (n = 0; n < 14; n++) {

			wordslen[n] = words[n].length();

		}

		System.out.println("请输入拼音：");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		str = str.toLowerCase();
		int lenStr = str.length();

		StringBuffer sb = new StringBuffer(str);

		StringBuffer sb1 = new StringBuffer();
		String newString = new String();
		String s = new String();

		int now = 0;
		// while循环把我输入的字符串就找出来了
		while (now < lenStr) {
			newString = sb.substring(now) + "        ";

			for (n = 0; n < 14; n++) {
				if (newString.substring(0, wordslen[n]).equalsIgnoreCase(
						words[n])) {
					s = sb1.append(words[n]).append(",").toString();

					now = now + wordslen[n];

					break;
				}
			}
		}

		// System.out.print(s);

		String[] result = new String[100];
		result = s.split(",");
		int resultLen = result.length;
		int r = 0;
		int pos = 0;
		int num = 0;
		for (int i = 0; i < resultLen; i++) {
			for (int j = 0; j < 14; j++) {
				if (result[i].equals(words[j]) && j > 3 && j < 14) {
					
					r = j - 4;
					
				} else if (result[i].equals(words[j]) && j >= 0 && j <= 3) {

					if (words[j] == "Shi")
						pos = r * 10;
					if (words[j] == "Bai")
						pos = r * 100;
					if (words[j] == "Qian")
						pos = r * 1000;
					if (words[j] == "Wan")
						pos = r * 10000;

				}
				num = num + pos;
				pos = 0;

			}

		}
		num += r;
		System.out.println(num);

	}

}


/*24.将整数倒序输出，剔除重复数据
 输入一个整数，如12336544，或1750，然后从最后一位开始倒过来输出，最后如果是0，
 则不输出，输出的数字是不带重复数字的，所以上面的输出是456321和571。
 如果是负数，比如输入-175，输出-571。
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei24 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		System.out.println("请输入一个整数：");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();

		StringBuffer sb = new StringBuffer(str);
		int len = sb.length();
		if (sb.charAt(len - 1) =='0') {
			sb.deleteCharAt(len - 1);
		} 
			String sb1 = null;

			for (int i = 0; i < sb.length(); i++) {
				for (int j = i + 1; j < sb.length(); j++) {
					if (sb.charAt(i) == (sb.charAt(j))) {

						sb.deleteCharAt(j);
						j--;
					}
				}
			}

			if (sb.charAt(0) == '-') {

				sb1 = sb.substring(1);

				StringBuffer sb2 = new StringBuffer(sb1);
				// System.out.println();
				System.out.print("-" + sb2.reverse());

			} else {
				System.out.println(sb.reverse());
			}

		}
	
}

/*２５．编程的时候，if条件里面的“(”、“)”括号经常出现不匹配的情况导致编译不过，
 * 请编写程序检测输入一行if语句中的圆括号是否匹配正确。
 * 同时输出语句中出现的左括号和右括号数量，
 * 如if((a==1)&&(b==1))是正确的，
 * 而if((a==1))&&(b==1))是错误的。
 * 注意if语句的最外面至少有一对括号。提示：用堆栈来做。
 输入：if((a==1)&&(b==1))
 输出：RIGTH 3 3
 输入：if((a==1))&&(b==1))
 输出：WRONG 3 4
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei25 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("请属于检测的if语句:");
		String str = br.readLine();
		int len = str.length();
		char[] str1 = str.toCharArray();

		int[] a = new int[800];
		int flag = 1, k = 0, left = 0, right = 0;

		for (int i = 0; i < len; i++) {
			if (str1[i] == '(') {
				left++;
				a[k] = 1;
				k++;
			} else if (str1[i] == ')') {
				right++;
				if (a[k - 1] == 1 && k > 0) {
					a[k - 1] = 0;
					k--;

				}
				else
					flag=0;
			}
			if((i==2 && str1[i]!='(')||(i==len-1 && str1[i]!=')'))
				flag=0;

		}
		if(a[0]==0 && flag!=0)
			System.out.println("RIGHT!");
		else
			System.out.println("WRONG!");
		System.out.println("Left: "+ left);
		System.out.println("Right: "+ right);

	}

}

/*6.一组人（n个），围成一圈，从某人开始数到第三个的人出列，再接着从下一个人开始数，最终输出最终出列的人
（约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）
围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，
数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。）
*/
public class Huawei06 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		// 总共有M个人
				int n = 9;
				// 数到N的人出列
				int m = 3;
				// 开始报数的位置
				int k = 1;
				// 初始数组长度，以后出圈一个长度减1
				int len = n;
				int[] array = new int[n];
				// 数组赋值
				for (int i = 0; i < n; i++) {
					array[i] = i + 1;
				}

				int i = 0; // 数组下标
				int j = 1; // 当前要报的数

				while (len > 0) {
					if (array[i % n] > 0) {
						if (j % m == 0) {// 找到出圈的人了，输出
							System.out.print(array[i % n] + " ");
							array[i % n] = -1;
							j = 1;
							i++;
							len--;
						} else {
							i++;
							j++;
						}
					} else {
						// 遇到已经出圈的数字，直接跳过了
						i++;
					}
				}

	}
}

/*26. 约瑟夫问题
输入一个由随机数组成的数列（数列中每个数均是大于0的整数，长度已知），和初始计数值m。从数列首位置开始计数，计数到m后，
将数列该位置数值替换计数值m，并将数列该位置数值出列，然后从下一位置从新开始计数，直到数列所有数值出列为止。
如果计数到达数列尾段，则返回数列首位置继续计数。请编程实现上述计数过程，同时输出数值出列的顺序
比如：输入的随机数列为：3,1,2,4，初始计数值m=7，从数列首位置开始计数（数值3所在位置）
第一轮计数出列数字为2，计数值更新m=2，出列后数列为3,1,4，从数值4所在位置从新开始计数
第二轮计数出列数字为3，计数值更新m=3，出列后数列为1,4，从数值1所在位置开始计数
第三轮计数出列数字为1，计数值更新m=1，出列后数列为4，从数值4所在位置开始计数
最后一轮计数出列数字为4，计数过程完成。
输出数值出列顺序为：2,3,1,4。
要求实现函数：
void array_iterate(int len, int input_array[], int m, int output_array[])
【输入】 int len：输入数列的长度；
int intput_array[]：输入的初始数列
int m：初始计数值
【输出】 int output_array[]：输出的数值出列顺序
【返回】 无
示例:
输入：int input_array[] = {3,1,2,4}，int len = 4， m=7
输出：output_array[] = {2,3,1,4}
解题思路：
每次出列一个数值，需要对m、input_array、output_array、输出位置outPos、起始位置startPos进行更新；
对于输出位置outPos的计算是关键！通过分析可知，outPos=(startPos+m-1)%num
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei26 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("请随机输入一个整形数列:");
		String str = br.readLine();
		System.out.println("请输入一个整数:");
		String str1 = br.readLine();
		
		String[] s1 = str.split(",");
		int len = s1.length;
		int[] array = new int[len];
		
		int i=0,j=1;
		for(int k=0;k<len;k++)
		{
			array[k] = Integer.parseInt(s1[k]);
			
		}
		System.out.println();
		int m = Integer.parseInt(str1);
		int n = len;
		while (len > 0) {
			if (array[i % n] > 0) {
				if (j % m == 0) {// 找到出圈的人了，输出
					System.out.print(array[i % n] + " ");
					m = array[i % n];
					array[i % n] = -1;
					j = 1;
					i++;
					len--;
				} else {
					i++;
					j++;
				}
			} else {
				// 遇到已经出圈的数字，直接跳过了
				i++;
			}
		}
		

	}

}



/*31. 按字母序输出定长排列组合。输入“ABC”，定长为2，则输出
 AB AC BC
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei31 {
	public static void perm(char[] buf, int start, int end) {

		if (start == end) {// 当只要求对数组中一个字母进行全排列时，只要就按该数组输出即可

			for (int i = 0; i <= end; i++) {

				System.out.print(buf[i]);

			}

			System.out.println();

		} else {// 多个字母全排列

			for (int i = start; i <= end; i++) {

				char temp = buf[start];// 交换数组第一个元素与后续的元素

				buf[start] = buf[i];

				buf[i] = temp;

				perm(buf, start + 1, end);// 后续元素递归全排列

				temp = buf[start];// 将交换后的数组还原

				buf[start] = buf[i];

				buf[i] = temp;

			}

		}

	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		System.out.println("请输入字符串：");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		int len = str.length();
		int m;
		String[] str1 = str.split(" ");

		char[] chars = str1[0].toCharArray();
		m = Integer.parseInt(str1[1]);
		
		perm(chars, 0, m);

	}

}


/*33：输入若干整数，输出其中能被这些整数中其他元素整除的那些元素
 描述
 输入一组大于0小于1000的整数，且均不相同，逗号隔开，输出其中能被这些整数中其他元素整除的那些元素。
 输入输出格式要求
 输入要求同上述描述，输出要求整数顺序按照输入时的顺序输出。
 样例
 输入：2,4,6,8,10,12,3,9 
 输出：4,6,8,10,12,9
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei33 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("请输入一组整数，以，隔开:");
		String str = br.readLine();
		int len = str.length();

		String[] str1 = new String[len];
		str1 = str.split(",");
		int len1 = str1.length;

		int[] str2 = new int[len1];
		int[] str3 = new int[len1];

		StringBuffer sb = new StringBuffer();
		int i, j;
		for (i = 0; i < len1; i++) {
			str2[i] = Integer.parseInt(str1[i]);
			str3[i] = str2[i];
		}
				
		int count = 0;
		for (i = 0; i < len1; i++) {
			for (j = 0; j < len1; j++) {
				
				if ((str2[i] % str3[j] == 0)) {

					count++;
				}
			}
			if(count >= 2)
			{
				sb.append(str3[i]).append(",").toString();
				count=0;
			}
		}
		int len4=sb.length();
		sb.deleteCharAt(len4-1);
		System.out.print(sb.toString());
	}
}

/* 37. 给定一个数组input[] ，如果数组长度n为奇数，则将数组中最大的元素放到 output[] 数组最中间的位置，
 * 如果数组长度n为偶数，则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上，
 * 然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。 
 例如：input[] = {3, 6, 1, 9, 7}   output[] = {3, 7, 9, 6, 1}; 
 input[] = {3, 6, 1, 9, 7, 8}    output[] = {1, 6, 8, 9, 7, 3}
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Huawei37 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();
		String[] str1 = str.split(",");
		int len = str1.length;
		int[] array = new int[len];

		int[] output = new int[len];
		int i, j, m, n = 1, temp;
		for (i = 0; i < len; i++) {
			array[i] = Integer.parseInt(str1[i]);
		}

		for (i = 0; i < len; i++) {
			for (j = i; j < len; j++) {
				if (array[i] < array[j]) {
					temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}

		m = len / 2;
		output[m] = array[0];
		if (len % 2 != 0) {
			for (i = 1; i <= m; i++) {

				output[m - i] = array[n++];
				output[m + i] = array[n++];

			}
		} else if (len % 2 == 0){
			for (i = 1; i < m; i++) {

				output[m - i] = array[n++];
				output[m + i] = array[n++];

			}
			output[0] = array[n];
		}
		for (i = 0; i < len; i++) {
			System.out.print(output[i] + " ");

		}

	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


/*36.比较一个数组的元素 是否为回文数组 */
public class Huawei36 {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Please enter the string:");
		String str = br.readLine();

		char[] chars = str.toCharArray();
		int len = chars.length;
		int i, j = 0;
		for (i = 0; i < len / 2; i++) {
			if (chars[i] != chars[len - 1 - i]) {
				System.out.println("No");
				j = 1;
				break;
			}
		}
		if (j == 0)
			System.out.println("Yes");
	}

}

/*输入一行字符串，将其中的数字与字母分离，并将数字放到字母后面*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Main {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String stdin = br.readLine();
		int len = stdin.length();
		
		String[] s1 = stdin.split("[a-zA-Z]+");
		int i;
		int len_s1 = s1.length;
		StringBuffer sb = new StringBuffer();
		StringBuffer sb1 = new StringBuffer();
		
		for(i=0;i<len_s1;i++)
		{
			if(!s1.equals(""))
			{
				sb.append(s1[i]).toString();
			}
		}
		
		String[] s2 = stdin.split("[0-9]+");
		int len_s2 = s2.length;
		
		for(i=0;i<len_s2;i++)
		{
			sb1.append(s2[i]).toString();
		}
		
		String stdout = sb1.toString() + sb.toString();
		
		System.out.println(stdout);

	}

}

/*输入字符串，找到第一个与通配符相符的子串，
比如 abcdefabcdeg，a？c？？f
输出abcdef 
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test11 {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String stdin = br.readLine();
		String[] s1 = stdin.split(",");
		int len = s1.length;
		int i, j, r = 0;
		String src = s1[0];
		String pat = s1[1];

		// pat = pat.replace("??", "*");
		int len_pat = pat.length();

		int len_src = src.length();
		boolean isFound = true;
		StringBuffer sb = new StringBuffer(src);
		for (i = 0; i < src.length() - pat.length() + 1; i++) {

			for (j = 0; j < pat.length(); j++) {

				if (pat.charAt(j) != '?' && src.charAt(i + j) != pat.charAt(j)) {

					isFound = false;

					break;

				}

				isFound = true;

			}

			if (j == pat.length() && isFound) {
				r = i;
				break;
			}

		}

		String stdout = sb.substring(r, r + len_pat);
		System.out.println(stdout);

	}

}