Plus d’articles de la série d’interviews 2023 sur la page d’accueil
1. Questions + réponses du test informatique Huawei OD
Description du sujet:
Étant donné un algorithme de résumé pour une chaîne, veuillez afficher la valeur de résumé de la chaîne donnée.
1. Supprimez les symboles autres que des lettres de la chaîne
2. Si des caractères consécutifs apparaissent (non sensibles à la casse), afficher : le caractère (petit) + le nombre d'occurrences consécutives
3. S'il s'agit d'un caractère non consécutif (non sensible à la casse), alors afficher : le caractère (minuscule) le nombre de fois que le caractère apparaît dans la chaîne après la lettre 4. Trier la chaîne exprimée de la manière ci-dessus : les lettres et Les nombres qui suivent sont triés par groupe, avec le plus grand nombre en premier, et les nombres avec le même numéro sont triés par ordre alphabétique, avec la plus petite lettre en premier.
Entrez la description :
Chaîne de lignes, longueur [1 200]
Description de la sortie :
chaîne récapitulative
Exemple 1
entrer:
aabbcc
Sortir:
a2b2c2
Exemple 2
entrer:
bAaAcBb
Sortir:
a3b2b2c0
illustrer:
Le premier b est une lettre non consécutive. Après cette lettre, elle apparaît 2 fois dans la chaîne (les deux derniers Bb), donc b2 est affiché, a apparaît 3 fois de suite et a3 est affiché.
c n'est pas consécutif. Il n'y a pas de c dans la chaîne après cette lettre. c0Bb est affiché 2 fois de suite et b2 est affiché.
Triez b2a3c0b2 et enfin affichez a3b2b2c0
Idées de résolution de problèmes (non optimales) :
1. Utilisez des expressions régulières pour obtenir toutes les lettres
2. Utiliser le parcours à double pointeur
2.1 Utilisez des bits d'indicateur pour déterminer si les lettres sont des lettres consécutives ou séparées
2.2 Les lettres continues sont le nombre actuel cumulé + 1, et les lettres non consécutives sont le nombre de lettres suivantes.
2.3 Une fois les lettres consécutives interrompues, attribuez la valeur du pointeur droit au pointeur gauche et ignorez l'indice des lettres consécutives.
2.4 Après chaque parcours, la valeur du pointeur droit est réaffectée
2.5 Le stockage est une valeur de lettre minuscule, et l'objet de stockage ici est
3. Trier
3.1 Comparez d'abord la grandeur, puis comparez l'ordre des lettres si elles sont égales.
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String value = sc.nextLine();
StringBuffer sb = new StringBuffer();
int index = 0;
for (int i = 1; i <= value.length();i++){
//1、去除字符串中非字母的符号
Pattern pattern = Pattern.compile("[a-zA-Z]+");
Matcher matcher = pattern.matcher((value.substring(index,i)));
if (matcher.find()){
sb.append(matcher.group());
}
index++;
}
List<Info> end = save(sb);
sort(end);
}
public static List<Info> save(StringBuffer sb){
//双指针
int left = 0;
int right = 1;
int count = 0;
Boolean flag = false;
List<Info> infoList = new ArrayList<>();
while (left != sb.length() && right != sb.length()) {
//当前值
String now = sb.substring(left, left + 1);
//最后一个字符
if (left + 1 == sb.length()) {
Info info = new Info(0, now.toLowerCase(Locale.ROOT));
infoList.add(info);
break;
}
String after = sb.substring(right, right + 1);
if (now.equalsIgnoreCase(after)) {
count++;
if (right - left <= 1) {
flag = true;//是否连续标志
}
if (right + 1 == sb.length()) {
if (flag) { //连续值+1
count++;
}
Info info = new Info(count, now.toLowerCase(Locale.ROOT));
infoList.add(info);
//移动右指针
right = left + 1;
left++; //移动左指针
count = 0;
}
right++;//连续值下标
} else {
// 2、如果出现连续字符 (不区分大小写) ，则输出: 该字符 (小) + 连续出现的次数
if (flag) {//连续 中断时保存是数据
left = right;//跳过连续值
count++;
Info info = new Info(count, now.toLowerCase(Locale.ROOT));
infoList.add(info);
count = 0;
if (right + 1 == sb.length()) { //重新赋值右指针
right = left + 1;
}
// 3、如果是非连续的字符(不区分大小写) ，则输出: 该字符(小写) 该字母之后字符串中出现的该字符的次数
} else if (!flag) { //非连续
if (right + 1 == sb.length()) {
Info info = new Info(count, now.toLowerCase(Locale.ROOT));
infoList.add(info);
count = 0;
right = left + 1;
left++;
}
}
right++;//跳过连续值
if (right == sb.length()) {
right = left;
}
flag = false;
}
}
return infoList;
}
/**
* 4、对按照以上方式表示后的字符串进行排序: 字母和紧随的数字作为一组进行排序，数字大的在前，数字相同的则按字母进行排序，字母小的在前。
* @param infoList
*/
public static void sort(List<Info> infoList){
Collections.sort(infoList,new SoutSummary());
infoList.forEach(data -> System.out.print(data.getS() + data.getCount()));
}
static class SoutSummary implements Comparator<Info>{
@Override
public int compare(Info o1, Info o2) {
//先比较次数的大小
if (o1.getCount() > o2.getCount()){
return -1;
}else if (o1.getCount() < o2.getCount()){
return 1;
//如果次数相等
}else {
return o2.getS().compareTo(o2.getS());
}
}
}
static class Info{
int count;
String s;
public Info(int count, String s){
this.count = count;
this.s = s;
}
public Info() {
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public String getS() {
return s;
}
public void setS(String s) {
this.s = s;
}
}