華為機考試題（JAVA）
阿新 • • 發佈：2019-01-12
試題1:字元子串拆分
描述:
給定兩個字串a和b，定義a*b標識兩個字串的連結。
例如：a=”abc”,b=”def”,則a*b=”abcdef”。
如果將連線看成乘法，則按照普遍的方法，一個非負整數的冪表示為：
a的0次方：a^0=””
a的1次方：a^1=a
a的2次方：a^2=a*a
……
a的n+1次方：a^(n+1)=a*(a^n)。
輸入：
字串s，長度在1~100之間。
輸出：
每個字串s，輸出最大的n和對應的a，使其滿足s=a^n。
例如：
s=”abcd”,則n=1, a=”abcd”
s=”aaaa”,則n=4，a=”a”
s=”ababab”,則n=3，a=”ab”
題目類別: 字串,搜尋
難度: 中級
分數:
執行時間限制: 無限制
記憶體限制: 無限制
階段: 應聘考試
輸入:
字串s，長度在1~100之間。
輸出:
每個字串s，輸出最大的n和對應的a，使其滿足s=an。
例如：
s=”abcd”,則n=1, a=”abcd”
s=”aaaa”,則n=4，a=”a”
s=”ababab”,則n=3，a=”ab”
樣例輸入:
ababab
樣例輸出:
3 ab
import java.util.*;
public class TestSplit {
public static void main(String[] args) {
while (true) {
Scanner scn = new Scanner(System.in 試題2：奇數偶數位置分別排序
輸入若干（不超過1000個）非負整數數字，請先取出為奇數的數字按從大到小排序，
再取出偶數從小到大排序
輸入8 12 3 7 6 5 9
9 8 6 3
5 7 12
輸出9 5 8 7 6 12 3
import java.util.Scanner;
public class SortJO {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
while (scan.hasNext()) {
String str = scan.nextLine();
sort(str);
}
scan.close();
}
private static void sort(String str) {
//去掉空格，儲存數字
int str_length = str.length();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < str_length; i++) {
if (str.charAt(i) != ' ') {
sb.append(str.charAt(i));
}
}
char[] num = sb.toString().toCharArray();
int length = num.length;
int part_length = length / 2;//儲存一半數字，按照奇數偶數儲存
char[] odd;
char[] even;
//偶數個數字
if (length % 2 == 0) {
odd = new char[part_length];
even = new char[part_length];
} else {
//奇數個數字,多一個奇數
odd = new char[part_length + 1];
even = new char[part_length];
}
int index_odd = 0;
int index_even = 0;
for (int i = 0; i < length; i++) {
if (i % 2 == 0) {
odd[index_odd++] = num[i];
} else {
even[index_even++] = num[i];
}
}
ascendingSort(odd);//奇數位升序
descendingSort(even);//偶數位降序
for (int i = 0; i < index_even; i++) {
if (i == 0) {
System.out.print(odd[i] + " " + even[i]);
} else {
System.out.print(" " + odd[i] + " " + even[i]);
}
}
if (index_odd != index_even) {
System.out.println(" " + odd[index_odd - 1]);
}
}
private static void ascendingSort(char[] data) {
int length = data.length;
char temp = '*';
for (int i = 0; i < length - 1; i++) {
for (int j = i + 1; j < length; j++) {
if (data[i] > data[j]) {
temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
}
}
private static void descendingSort(char[] data) {
int length = data.length;
char temp = '*';
for (int i = 0; i < length - 1; i++) {
for (int j = i + 1; j < length; j++) {
if (data[i] < data[j]) {
temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
}
}
}試題3：查詢和排序
題目：輸入任意（使用者，成績）序列，可以獲得成績從高到低或從低到高的排列,相同成績
都按先錄入排列在前的規則處理。
例示：
jack 70
peter 96
Tom 70
smith 67
從高到低 成績
peter 96
jack 70
Tom 70
smith 67
從低到高
smith 67
Tom 70
jack 70
peter 96
輸入描述:
輸入多行，先輸入要排序的人的個數，然後分別輸入他們的名字和成績，以一個空格隔開
輸出描述:
按照指定方式輸出名字和成績，名字和成績之間以一個空格隔開
輸入例子:
3
0
fang 90
yang 50
ning 70
輸出例子:
fang 90
ning 70
yang 50
import java.util.*;
//儲存每個學生的基本資訊
public class Sort {
static class Info{
int index;//錄入序號
String name;//姓名
int score;//成績
//構造方法
public Info(int index , String name , int score){
this.index = index;
this.name = name;
this.score = score;
}
}
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
List<Info> list = new ArrayList<Info>();//每次輸入資料前都要清空
int stu_num = scan.nextInt();
int sort_way = scan.nextInt();
for(int i = 0 ; i < stu_num ; i++){
String name = scan.next();
int score = scan.nextInt();
list.add(new Info(i , name , score));
}
//sort_way=0降序排列
if(sort_way == 0){
//自定義比較器
Collections.sort(list , new Comparator<Info>() {
public int compare(Info o1, Info o2) {
if(o1.score != o2.score){
//後面減去前面，如果相減為負，表示降序
return o2.score - o1.score;
}else{
//分數相等，按照序號的優先順序儲存
//前面減去後面，如果相減為負，表示升序
return o1.index - o2.index;
}
}
});
}else{
//sort_way=1升序排列
Collections.sort(list , new Comparator<Info>(){
public int compare(Info o1, Info o2){
if(o1.score != o2.score){
return o1.score - o2.score;
}else{
return o1.index - o2.index;
}
}
});
}
//列印資訊
for(Info stu : list){
System.out.println(stu.name + " " + stu.score);
}
// list.clear();//清空列表
}
scan.close();
}
}試題4：兩個非常大的數字相乘（相加，相減）
該題目在java中可以使用BigInteger類中的方法來實現。否則的話可以使用如下方式來實現。
大數相乘：假設有A和B兩個大數，位數分別為a和b。根據我們平常手動計算乘法的方式可以看出，
最終的結果的位數c一定小於等於a+b，我們可以舉一個簡單的例子來說明，99*999=98901，
最終結果是五位（a+b）。下面我們根據98*765 = 74970來看看結果中的每一位是怎麼得來的，
最後一位0是A的最後一位8和B的最後一位5的乘機除10取餘得到的，結果的倒數第二位7是A的倒數
第二位9和B的最後一位5的乘積45與A的最後一位8和B的倒數第二位6的乘積48之和93然後加上上一
位的進位4得到97然後在除10取餘得到的7……依次進行下去就可以得到最終結果。
下面來總結一下規律：A中的第i位與B的第j位之積最終會存放到結果的第i+j位中（i和j都是從後往前數），
所以我們可以先進行結果中每一位的計算，完成所有計算後在進行進位的計算。為了將i和j從0開始計算，
我們先將字串A和B進行逆轉，然後在進行計算的時候就可以從0開始了。
*
*
大數相加:和相乘是類似的，不同的地方只是result結果集的長度，其值為較長字串的長度加一。
*
*
大數相減：大數相減和大數相加類似，只是需要判斷正負
*
*
在上述的各中計算過程中有幾點需要說明：大數相加的時候沒有判斷數字的正負，如果都是正數，
那麼就可以按照正數相加來計算，如果是一正一負可以轉換成大整數相減，兩個負數可以先儲存符號，然後相加。
import java.util.Scanner;
public class BigNum {
public static void main(String[] args) {
while (true) {
Scanner console = new Scanner(System.in);
System.out.println("請輸入兩個以空格分隔的數字字串，數字由0-9構成：");
String inputStr = console.nextLine();
String[] str = inputStr.split(" ");
String str1 = str[0];
String str2 = str[1];
String addOut = bigNumberAdd(str1,str2);
System.out.println("加法："+str1+"+"+str2+"="+addOut);
bigNumberSub(str1, str2);
bigNumberSimpleMulti(str1,str2);
}
}
public static String bigNumberSub(String f, String s) {
System.out.print("減法:" + f + "-" + s + "=");
// 將字串翻轉並轉換成字元陣列
char[] a = new StringBuffer(f).reverse().toString().toCharArray();
char[] b = new StringBuffer(s).reverse().toString().toCharArray();
int lenA = a.length;
int lenB = b.length;
// 找到最大長度
int len = lenA > lenB ? lenA : lenB;
int[] result = new int[len];
// 表示結果的正負
char sign = '+';
// 判斷最終結果的正負
if (lenA < lenB) {
sign = '-';
} else if (lenA == lenB) {
int i = lenA - 1;
while (i > 0 && a[i] == b[i]) {
i--;
}
if (a[i] < b[i]) {
sign = '-';
}
}
// 計算結果集，如果最終結果為正，那麼就a-b否則的話就b-a
for (int i = 0; i < len; i++) {
int aint = i < lenA ? (a[i] - '0') : 0;
int bint = i < lenB ? (b[i] - '0') : 0;
if (sign == '+') {
result[i] = aint - bint;
} else {
result[i] = bint - aint;
}
}
// 如果結果集合中的某一位小於零，那麼就向前一位借一，然後將本位加上10。其實就相當於借位做減法
for (int i = 0; i < result.length - 1; i++) {
if (result[i] < 0) {
result[i + 1] -= 1;
result[i] += 10;
}
}
StringBuffer sb = new StringBuffer();
// 如果最終結果為負值，就將負號放在最前面，正號則不需要
if (sign == '-') {
sb.append('-');
}
// 判斷是否有前置0
boolean flag = true;
for (int i = len - 1; i >= 0; i--) {
if (result[i] == 0 && flag) {
continue;
} else {
flag = false;
}
sb.append(result[i]);
}
// 如果最終結果集合中沒有值，就說明是兩值相等，最終返回0
if (sb.toString().equals("")) {
sb.append("0");
}
// 返回值
System.out.println(sb.toString());
return sb.toString();
}
public static String bigNumberAdd(String f, String s) {
//翻轉兩個字串，並轉換成陣列
char[] a = new StringBuffer(f).reverse().toString().toCharArray();
char[] b = new StringBuffer(s).reverse().toString().toCharArray();
int lenA = a.length;
int lenB = b.length;
//計算兩個長字串中的較長字串的長度
int len = lenA > lenB ? lenA : lenB;
int[] result = new int[len + 1];
for (int i = 0; i < len + 1; i++) {
//如果當前的i超過了其中的一個，就用0代替，和另一個字元陣列中的數字相加
int aint = i < lenA ? (a[i] - '0') : 0;
int bint = i < lenB ? (b[i] - '0') : 0;
result[i] = aint + bint;
}
//處理結果集合，如果大於10的就向前一位進位，本身進行除10取餘
for (int i = 0; i < result.length; i++) {
if (result[i] >= 10) {
result[i + 1] += result[i] / 10;
result[i] %= 10;
}
}
StringBuffer sb = new StringBuffer();
//該欄位用於標識是否有前置0，如果有就不要儲存
boolean flag = true;
for (int i = len; i >= 0; i--) {
if (result[i] == 0 && flag) {
continue;
} else {
flag = false;
}
sb.append(result[i]);
}
return sb.toString();
}
public static void bigNumberSimpleMulti(String f, String s) {
System.out.print("乘法：" + f + "*" + s + "=");
// 獲取首字元，判斷是否是符號位
char signA = f.charAt(0);
char signB = s.charAt(0);
char sign = '+';
if (signA == '+' || signA == '-') {
sign = signA;
f = f.substring(1);
}
if (signB == '+' || signB == '-') {
if (sign == signB) {
sign = '+';
} else {
sign = '-';
}
s = s.substring(1);
}
// 將大數翻轉並轉換成字元陣列
char[] a = new StringBuffer(f).reverse().toString().toCharArray();
char[] b = new StringBuffer(s).reverse().toString().toCharArray();
int lenA = a.length;
int lenB = b.length;
// 計算最終的最大長度
int len = lenA + lenB;
int[] result = new int[len];
// 計算結果集合
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < b.length; j++) {
result[i + j] += (int) (a[i] - '0') * (int) (b[j] - '0');
}
}
// 處理結果集合，如果是大於10的就向前一位進位，本身進行除10取餘
for (int i = 0; i < result.length; i++) {
if (result[i] > 10) {
result[i + 1] += result[i] / 10;
result[i] %= 10;
}
}
StringBuffer sb = new StringBuffer();
// 該欄位用於標識是否有前置0，如果是0就不需要列印或者儲存下來
boolean flag = true;
for (int i = len - 1; i >= 0; i--) {
if (result[i] == 0 && flag) {
continue;
} else {
flag = false;
}
sb.append(result[i]);
}
if (!sb.toString().equals("")) {
if (sign == '-') {
sb.insert(0, sign);
}
} else {
sb.append(0);
}
// 返回最終結果
System.out.println(sb.toString());
}
}試題5：字串分解
輸入m個字串 和一個整數n, 把字串M化成以N為單位的段，不足的位數用0補齊。
如
輸入
2
8
abc
abcdefgdhkfk
輸出
abc00000
abcdefgd
hkfk0000
public class DecompressExport {
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
int m = cin.nextInt();
int n = cin.nextInt();
List<String> lists = new ArrayList<>();
for (int i = 0; i < m; i++) {
lists.add(i, cin.next());
}
for (String list : lists) {
export(list, n);
}
}
private static void export(String input, int n) {
int len = input.length();
int polish = len % n;
if(polish!=0){
for (int i = 0; i < n - polish; i++) {
input = input + "0";
}
}
int loop = input.length() / n;
for (int i = 0; i < loop; i++) {
System.out.println(input.substring(i*n, (i +1)* n));
}
System.out.println("\r\n");
}
}試題：括號合法性檢測
程式設計的時候，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;
import java.util.Stack;
/**
* 使用棧實現字串的括號匹配檢查。
*/
public class JudgeSymbolReg {
public static void main(String[] args) throws IOException {
while (true) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
System.out.println(match(str));
}
}
/**
* 進行匹配的演算法。
*
* @param str 待檢查的字串。
* @return boolean
*/
public static boolean match(String str) {
Stack stack = new Stack(); // 定義一個存放括號的棧。
char[] ca = str.toCharArray(); // 將字串轉為字元陣列以便對其遍歷。
stack.push((Character) ca[0]); // 首先將第一個字元壓入棧中。
/*
* 從第二個字元開始，依次與棧中字元匹配。
* 成功則將棧頂元素彈出。
* 失敗則將字元陣列中的當前字元壓入棧中。
*/
for (int index = 1; index < ca.length; ++index) {
if(stack.empty()){
return false;//右括號先於左括號，則wrong
}
Character c1 = (Character) stack.peek();
Character c2 = ca[index];
if ((c1.equals('(') && c2.equals(')'))
|| (c1.equals('[') && c2.equals(']'))) {
stack.pop();
} else {
stack.push(c2);
}
}
return stack.empty();
}
}試題：過濾非首次出現字元
通過鍵盤輸入一串小寫字母(a~z)組成的字串。請編寫一個字串過濾程式，若字串中出現多個相同的字元，將非首次出現的字元過濾掉。
比如字串“abacacde”過濾結果為“abcde”。
要求實現函式：
void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);
【輸入】 pInputStr： 輸入字串
lInputLen： 輸入字串長度
【輸出】 pOutputStr： 輸出字串，空間已經開闢好，與輸入字串等長；
import java.util.Scanner;
public class FilterRep {
public static void main(String[] args){
while (true){
Scanner scanner = new Scanner(System.in);
String a = scanner.next();
String output = filterRep(a);
System.out.println(output);
}
}
public static String filterRep(String a){
StringBuilder input = new StringBuilder(a);
for(int i = 0; i<input.length()-1;i++){
for(int j = i+1 ;j<input.length();j++){
if(input.charAt(i) == input.charAt(j)){
input.deleteCharAt(j);
j--;
}
}
}
return input.toString();
}
}試題：字串匹配
有字串”?^_^“，”?”與”“中間字元為主要匹配字元，”?”代表一個字元，而”*”可以當做0或任意數量字元。
對目標字串進行匹配，並輸出字串匹配成功的第一個字元的下標，字串的第一個字元下標為0。（我一開始沒注意到”？
“可以有N多個，白浪費功夫做一個”？”的匹配了）。
例子：
輸入：?^_^*
abc^_^abc
輸出：2
import java.util.Scanner;
public class TestMatch {
public Integer firstMatchReg() {
Scanner cin = new Scanner(System.in);
System.out.println("請先輸入規則；回車換行後輸入匹配字串");
String match = cin.next();
String input = cin.next();
String matchReg = match.substring(match.indexOf("?")+1,match.indexOf("*"));
int index = input.indexOf(matchReg);
if(index==0){
index= input.indexOf(matchReg,1);
}
return index > 0 ? index - 1 : -1;
}
public static void main(String[] args) {
TestMatch testMatch = new TestMatch();
int output = testMatch.firstMatchReg();
System.out.println(output);
}
}試題：地鐵換乘
描述：已知2條地鐵線路，其中A為環線，B為東西向線路，線路都是雙向的。經過的站點名分別如下，兩條線交叉的換乘點用T1、T2表示。
編寫程式，任意輸入兩個站點名稱，輸出乘坐地鐵最少需要經過的車站數量（含輸入的起點和終點，換乘站點只計算一次）。
地鐵線A（環線）經過車站：A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18
地鐵線B（直線）經過車站：B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15
輸入：輸入兩個不同的站名
輸出：輸出最少經過的站數,含輸入的起點和終點，換乘站點只計算一次
輸入樣例：A1 A3
輸出樣例：3
(注意：按照題示，A1 A3結果為3，所以A1 A1結果就應該為1，依此。)
Floyd演算法的基本思想如下：從任意節點A到任意節點B的最短路徑不外乎2種可能：
1、是直接從A到B，
2、是從A經過若干個節點X到B。
所以，我們假設dis(AB)為節點A到節點B的最短路徑的距離，對於每一個節點X，我們檢查dis(AX) + dis(XB) < dis(AB)是否成立，
如果成立，證明從A到X再到B的路徑比A直接到B的路徑短，我們便設定dis(AB)= dis(AX) +dis(XB)，這樣一來，
當我們遍歷完所有節點X，dis(AB)中記錄的便是A到B的最短路徑的距離。
import java.util.Scanner;
public class Station {
static String strA = "A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18";
static String strB = "B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15";
static String[] SA = strA.split(" ");
static String[] SB = strB.split(" ");
static int LENSA = SA.length;
static int LENSB = SB.length;
static int indexT1SA = getIndexofSA("T1"); //"T1"車站在A線路上的陣列下標
static int indexT1SB = getIndexofSB("T1"); //"T1"車站在B線路上的陣列下標
static int indexT2SA = getIndexofSA("T2"); //"T2"車站在A線路上的陣列下標
static int indexT2SB = getIndexofSB("T2"); //"T2"車站在B線路上的陣列下標
public static void main(String[] args) {
int step = 0;
System.out.println("請輸入\"始發站\"（空格）\"終到站\"(例如：A1 B4（回車結束）)：");
Scanner sc = new Scanner(System.in);
String[] strArray = sc.nextLine().split(" ");
String x = strArray[0].toUpperCase();
String y = strArray[1].toUpperCase();
System.out.println("go:"+x);
System.out.println("to:"+y);
sc.close();
step = getMinStep(x, y) + 1;
System.out.println("經過的最少車站數："+step);
}
private static int getMinStep(String x, String y) {
if(('A' != x.charAt(0))&&('A' != y.charAt(0)))
{
//在地鐵B線路上
return min(stepBtoB(x, y), stepT1orT2(x, y));
}
else if(('B' != x.charAt(0))&&('B' != y.charAt(0)))
{
//在地鐵A線路上
return min(stepAtoA(x, y), stepT1orT2(x, y));
}
else
{
//A到B，或者B到A
return stepT1orT2(x, y);
}
}
//從T1或者T2站換乘，s1到s2的最短距離
private static int stepT1orT2(String s1, String s2) {
int lenXtoT1 = steptoT1(s1);
int lenXtoT2 = steptoT2(s1);
int lenYtoT1 = steptoT1(s2);
int lenYtoT2 = steptoT2(s2);
int lineT1 = lenXtoT1 + lenYtoT1;
int lineT2 = lenXtoT2 + lenYtoT2;
return min(lineT1, lineT2);
}
//到T1的最短距離
private static int steptoT1(String s) {
if("T1".equals(s))
{
return 0;
}
else if("T2".equals(s))
{
return min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2"));
}
else if('A' == s.charAt(0)) //s是A線路上的車站
{
//找到s站在SA的下標
int indexSSA = getIndexofSA(s);
//不換乘，s到T1最短路程
int line1 = min(mod(indexSSA, indexT1SA), LENSA-mod(indexSSA, indexT1SA));
//不換乘，s到T2最短路程
int line2 = min(mod(indexSSA, indexT2SA), LENSA-mod(indexSSA, indexT2SA));
return min(line1, line2+min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2")));
}
else if('B' == s.charAt(0)) //s是B線路上的車站
{
//找到s站在SB的下標
int indexSSB = getIndexofSB(s);
//不換乘，s到T1最短路程
int line1 = mod(indexSSB, indexT1SB);
//不換乘，s到T2最短路程
int line2 = mod(indexSSB, indexT2SB);
return min(line1, line2+min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2")));
}
else
{
System.out.println("車站名有誤，請檢查！");
return -1;
}
}
//s到T2的最短距離
private static int steptoT2(String s) {
if("T2".equals(s))
{
return 0;
}
else if("T1".equals(s))
{
return min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2"));
}
else if('A' == s.charAt(0)) //s是A線路上的車站
{
//找到s站在SA的下標
int indexSSA = getIndexofSA(s);
//不換乘，s到T1最短路程
int line1 = min(mod(indexSSA, indexT1SA), LENSA-mod(indexSSA, indexT1SA));
//不換乘，s到T2最短路程
int line2 = min(mod(indexSSA, indexT2SA), LENSA-mod(indexSSA, indexT2SA));
return min(line2, line1+min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2")));
}
else if('B' == s.charAt(0)) //s是B線路上的車站
{
//找到s站在SB的下標
int indexSSB = getIndexofSB(s);
//不換乘，s到T1最短路程
int line1 = mod(indexSSB, indexT1SB);
//不換乘，s到T2最短路程
int line2 = mod(indexSSB, indexT2SB);
return min(line2, line1+min(stepAtoA("T1", "T2"), stepBtoB("T1", "T2")));
}
else
{
System.out.println("車站名有誤，請檢查！");
return -1;
}
}
//A到A，不換乘
private static int stepAtoA(String s1, String s2) {
if(('B' == s1.charAt(0))||('B' == s2.charAt(0)))
{
System.out.println("輸入不是A線路上的站點，請檢查！");
return -1;
}
//找到s1站，在A線路上的陣列下標
int indexS1SA = getIndexofSA(s1);
//找到s2站，在A線路上的陣列下標
int indexS2SA = getIndexofSA(s2);
//不換乘，s1到s2的最短距離
return min(mod(indexS1SA, indexS2SA), LENSA-mod(indexS1SA, indexS2SA));
}
//B到B，不換乘
private static int stepBtoB(String s1, String s2) {
if(('A' == s1.charAt(0))||('A' == s2.charAt(0)))
{
System.out.println("輸入不是B線路上的站點，請檢查！");
return -1;
}
//找到s1站，在B線路上的陣列下標
int indexS1SB = getIndexofSB(s1);
//找到s2站，在B線路上的陣列下標
int indexS2SB = getIndexofSB(s2);
//不換乘，s1到s2的最短距離
return mod(indexS1SB, indexS2SB);
}
private static int min(int a, int b)
{
return a<b?a:b;
}
private static int getIndexofSA(String str)
{
for(int index = 0; index < LENSA; index++)
{
if(str.equals(SA[index]))
{
return index;
}
}
return -1;
}
private static int getIndexofSB(String str)
{
for(int index = 0; index < LENSB; index++)
{
if(str.equals(SB[index]))
{
return index;
}
}
return -1;
}
private static int mod(int a, int b)
{
if(a < b)
{
return b-a;
}
else
{
return a-b;
}
}
}試題：程式設計去掉字串中數字之後的重複字元
描述:
給定一個字串，該字串只包含數字和字母，其中包含有連續相同的數字和字母，要求一個數字(該數字不包括在內)之後如果有兩個或者以上重複的數字或者字母，則去掉一個重複的，其餘的保持原樣，非數字之後的重複字元保持原樣輸出。
題目類別: 字串,棧,查詢
難度: 中級
分數:
執行時間限制: 無限制
記憶體限制: 無限制
階段: 應聘考試
輸入:
字串，只包含數字和字母，長度在1-100.
輸出:
數字之後如果有重複的數字或者字母，則去掉一個重複的，其餘的保持原樣，非數字之後的重複字元保持原樣輸出。
樣例輸入:
33333zzhhhhaaa44455pppin
樣例輸出:
3333zhhhhaaa445ppin
import java.util.*;
public class SplitRep {
public static Character chaStatic;//用於存放倒數第二個元素
public static void main(String[] args) {
while (true) {
Scanner scanner = new Scanner(System.in);
String input = scanner.next();
String output = splitRep(input);
System.out.println(output);
}
}
private static String splitRep(String input) {
Stack<Character> tmpStack = new Stack<Character>(); // 定義一個存放輸入的棧
char[] ca = input.toCharArray(); // 將字串轉為字元陣列以便對其遍歷。
//========長度小於等於2則直接輸出==========//
if (ca.length <= 2) {
return input;
}
//把資料都放入臨時棧中
for (int i = ca.length - 1; i >= 0; i--) {
tmpStack.push(ca[i]);
}
Stack<Character> finalStack = new Stack<Character>();//用於儲存輸出資料的棧
boolean isNumLast = false;
boolean isNum;
int sameCount = 1;
int lastNum = 20;
Character curChar = (Character) tmpStack.peek();
if (curChar > '0' && curChar < '9') {
isNumLast = true;
lastNum = curChar;
}
Character nextChar;
finalStack.push(curChar);//推入第一個元素
while (!tmpStack.empty()) {//棧不為空，則有元素，繼續執行。以下邏輯略複雜，可以轉化為陣列處理。
curChar = (Character) tmpStack.pop();
if (tmpStack.empty()) { //元素結束，判斷上一字元是數字，並且最後一個字元和前一字元相等，則移除一位