HarmonyOS 应用开发者高级认证编程练习题

1、aaa...aa的和

有个整数a，大小在1到9之间。要算一个值s，它是由a、两个a组成的数、三个a组成的数……n个a组成的数，这样依次相加得到的，现在给你a和n的值，让你求s的值。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let numStr = inputArray[0].split(' ');
    let num = Number(numStr[0]);
    let count = Number(numStr[1]);
    
    let sum:number = 0;
    for(let i=1; i<=count; i++){
        let temp = 1;
        for(let j = 1;j<i;j++){
            temp *= 10;
        }
        sum += num*(count-i+1)*temp;
    }
    console.log(sum);
});

2、元素之和

给你一个数组，找出数组之中两个元素之和等于给定值的所有组合。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let numArray = inputArray[0].split(' ');
    let len = numArray.length;
    let num:number[] = new Array<number>(len);
    for(let i = 0;i <= len;i++){
        num[i] = Number(numArray[i]);
    }
    let str = "";
    let count = 0;
    for(let i = 0;i < len;i++){
        for(let j = i+1;j< len;j++){
            if(num[i] + num[j] == num[len-1]){
                if(count!=0){
                    str += " ";
                }
                str += num[i] + " " + num[j];
                count += 1;
            }
        }
    }
    if(count==0){
        console.log("NOEXIT");
    }else{
         console.log(str);
    }
    process.exit();
});

3、一比特字符

有两种特殊字符：
第一种字符可以用一比特 0 表示
第二种字符可以用两比特（10 或 11）表示
给你一个以 0 结尾的二进制数组 bits，将数组解析为比特字符，如果最后一个字符是一个一比特字符，则返回 TRUE 。
1 <= bits.length <= 1000

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let sumArray = inputArray[0].split(' ');
    
    let temp = 2;
    if(sumArray[sumArray.length] != '1'){
        for(let i = 0;i< sumArray.length;i++){
            if (temp == 1){
                temp = 2;
            }else if(sumArray[i] == '1'){
                temp = 1;
            }else if(sumArray[i] == '0'){
                temp = 0;
            }
        }
    }
    if (temp!=0){
        console.log("FALSE");
    }else{
        console.log("TRUE");
    }
    process.exit();
});

4、山脉数组

“山脉数组”：顾名思义，像山脉一样的数组，先严格递增后严格递减。现在给你一个整数数组，判断它是否为“山脉数组”。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let numArray = inputArray[0].split(' ');
    let flag = false;
    let isAdd = true;
    for(let i = 1;i<numArray.length;i++){
        if(isAdd){
            if(numArray[i]<numArray[i-1]){
                isAdd = false;
            }
        }else{
             if(numArray[i]>numArray[i-1]){
                isAdd = true;
                 break;
            }
        }
    }
    if(isAdd){
        console.log("FALSE");
    }else{
        console.log("TRUE");
    }
    process.exit();
});

5、计算数组特征值

给你一个长度为n的非负整数数组 nums 。如果存在一个数 x ，使得 nums 中恰好有 x 个元素 大于或者等于 x ，那么就称 nums 是一个特殊数组 ，而 x 是该数组的特征值 。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    
    let numArray = inputArray[0].trim().split(' ');
    let nums:number[] = new Array<number>(numArray.length);
    for(let i = 0;i <numArray.length;i++){
        nums[i] = Number(numArray[i]);
    }
    var sortNums = nums.sort();
    let flag = -1;
    for(let i = 0;i <sortNums.length;i++){
        if(sortNums[i]>=(sortNums.length - i)){
            if(i> 0 && sortNums[i - 1]>=(sortNums.length - i)){
                continue;
            }
            flag = sortNums.length - i;
            break;
        }
    }
    console.log(flag);
    process.exit();
});

6、找相同数对

输入为整数数组 data。如果两个下标 (i,j) 满足 data[i] == data[j] 且 i < j ，就认为是一组相同数对。请返回 data 数组包含的相同数对的数目。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    
    let numArray = inputArray[0].split(' ');
    let numMap = new Map();
    for(let i = 0;i< numArray.length;i++){
        let num = Number(numArray[i]);
        if (numMap.has(num)){
            numMap.set(num, numMap.get(num) + 1);
        }else{
            numMap.set(num, 1);
        }
    }
    let sum = 0;
    numMap.forEach((value, key) => { 
        if(value > 1){
            sum += value*(value-1)/2;
        }
    });
    console.log(sum);
    process.exit();
});

7、数组的距离

非严格递增的两个数组x[]和y[]，请你计算两个数组的距离（两个数组元素之间差的绝对值中最小的一个）。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let numArray1 = inputArray[0].split(' ');
    let numArray2 = inputArray[1].split(' ');
    
    let len = Math.abs(Number(numArray1[0]) - Number(numArray2[0]));
    let num1,num2;
    for(let i=0,j=0;i<numArray1.length&&j<numArray2.length;){
        num1 = Number(numArray1[i]);
        num2 = Number(numArray2[j]);
        len = Math.min(len,  Math.abs(num1 - num2));
        if(num1 < num2){
            i++;
        }else{
            j++;
        }
    }
    console.log(len);
    process.exit();
});

8、寻找更大元素

给你一个正整数 n ，请你找出符合条件的最小整数，其由重新排列 n 中存在的每位数字组成，并且其值大于 n 。如果不存在这样的正整数，则返回 -1 。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});

process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let numberArray = inputArray[0].split('');
    let num:number[] = new Array(numberArray.length);
    for(let i = 0;i<numberArray.length;i++){
        num[i] = Number(numberArray[i]);
    }
    
    let index = numberArray.length - 2;
    while(index>=0&&num[index]>=num[index+1]){
        index--;
    }
    if(index<0){
        console.log(-1);
    }else{
        let i = numberArray.length - 1;
        while(i>=1&&num[i]< num[index]){
            i--;
        }
        [num[i], num[index]] = [num[index], num[i]];
        
        let left = index + 1,right = numberArray.length - 1;
        while(left<right){
            [num[left], num[right]] = [num[right], num[left]];
            left++;
            right--;
        }
        console.log(num.join(''));
    }
    process.exit();
});

9、学生出勤记录

给你一个字符串 s 表示一个学生的出勤记录，其中的每个字符用来标记当天的出勤情况（缺勤、迟到、到场）。记录中只含下面三种字符：
'A'：Absent，缺勤
'L'：Late，迟到
'P'：Present，到场
如果学生能够 同时 满足下面两个条件，则可以获得出勤奖励：
1.按 总出勤 计，学生缺勤（'A'）严格 少于两天。
2.学生 不会 存在 3 天或 3 天以上的迟到（'L'）记录。
如果学生可以获得出勤奖励，返回 TRUE ；否则，返回 FALSE 。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let record = inputArray[0];
    let countA = 0;
    let countL = 0;
    let flag = false;
    for(let i = 0;i<record.length;i++){
        if(record[i]=='L'){
            countL += 1;
            if(countL == 3){
                flag = true;
                break;
            }
        }else{
             countL = 0;
            if(record[i] == 'A'){
                countA += 1;
                if(countA == 2){
                    flag = true;
                    break;
                }
            }
        }
    }
    if(flag){
        console.log('FALSE');
    }else{
        console.log('TRUE');
    }
    process.exit();
});

10、16进制转2进制

将输入的16进制数转换为2进制数并输出。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let numstr = inputArray[0].trim();
    let numMap: Map<string, string> = new Map([
      ['0', '0000'],
      ['1', '0001'],
      ['2', '0010'],
      ['3', '0011'],
      ['4', '0100'],
      ['5', '0101'],
      ['6', '0110'],
      ['7', '0111'],
      ['8', '1000'],
      ['9', '1001'],
      ['a', '1010'],
      ['b', '1011'],
      ['c', '1100'],
      ['d', '1101'],
      ['e', '1110'],
      ['f', '1111'],
    ]);
    let str='';
    for(let i = 2;i<numstr.length;i++){
        str += numMap.get(numstr[i]);
    }
    let strnum = '0b' + str.replace(/^0+/, '');
    console.log(strnum);
    process.exit();
});

11、最长递增数列

厂房有一批新箱子共n个(n<=500)，箱子按照一定的顺序摆放。用一个正整数ai(1<=ai<=10000) (1<=i<=n)来表示第i个箱子的高度。现在华华要按照从前往后的顺序选出m个箱子(可以选任意一个箱子作为第一个)，并且满足对任意的i < j 有 ai < aj. 那么m最大可以是多少呢？

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let sumArray = inputArray[0].split(' ');
    
    let dp = new Array(sumArray.length);
    let count = 0;
    let curNum;
    dp[0] = Number(sumArray[0]);
    for(let i = 1;i<sumArray.length;i++){
        curNum = Number(sumArray[i]);
        if(curNum>dp[count]){
            count++;
            dp[count] = curNum;
        }else{
            let left = 0,right = count,pos = 0;
            while(left <= right){
                let mid = (left + right)>>1;
                if(dp[mid]<curNum){
                    left = mid + 1;
                }else{
                    pos = mid;
                    right = mid - 1;
                }
            }
            dp[pos] = curNum;
        }
    }
    console.log(count+1);
    process.exit();
});

12、相反数

有N个非零且各不相同的整数。请你编一个程序求出它们中有多少对相反数（a 和-a为一对相反数）。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    
    let numArray = inputArray[0].split(' ');
    let numMap = new Map<number, number>();
    let count = 0;
    let num;
    for(let i = 0;i<numArray.length;i++){
        num = Number(numArray[i]);
        if(numMap.has(-num)){
            count++;
        }
        numMap.set(num, 1);
    }
    console.log(count);
    process.exit();
});

13、最多可做任务类型数

鸿蒙开发者有n个任务，其中第 i 个任务的类型为 taskType[i],由于时间限制，开发者只能完成 n / 2 （n 是一个偶数）个任务。
给定一个长度为 n 的正整数数组 taskType ，返回;开发者在只完成 n / 2 个任务的情况下，最多可以做多少种不同类型的任务。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let numArray = inputArray[0].split(' ');
    let numMap = new Map<number, number>();
    
    let num;
    for(let i = 0;i<numArray.length;i++){
        num = Number(numArray[i]);
        if(!numMap.has(num)){
            numMap.set(num,1);
        }
    }
    console.log(Math.min(numMap.size,numArray.length>>1));
    process.exit();
});

14、第几天

给一个日期（格式为年月日），判断这一天是这一年的第几天（提示：闰年和平年的二月天数不一样）。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let year = Number(inputArray[0].substr(0,4));
    let month = Number(inputArray[0].substr(5,2));
    let day = Number(inputArray[0].substr(8,2));
    let days:number[] = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    if(year%400 == 0 ||(year%4==0&&year%100!=0)){
        days[1] = days[1] + 1;
    }
    let count = 0;
    for(let i = 0;i<month-1;i++){
        count += days[i];
    }
    console.log(count + day);
    process.exit();
});

15、翻转字符串中的元音字母

给定一个字符串 s ，反转字符串中的所有元音字母(a,e,i,o,u)的顺序，并返回反转后的结果。即获取字符串中所有的元音字母，元音字母逆序后，再放回原字符串，保持辅音字母的顺序不变。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let strTemp = inputArray[0].split('');
    let len = strTemp.length;
    let left = 0,right = len-1;
    
    let map = new Map([
        ['a',1],
        ['e',1],
        ['i',1],
        ['o',1],
        ['u',1],
    ]);
    
    let temp;
    let leftFlag = false, rightFlag = false;
    while(left<right){
        if(!leftFlag){
            if(!map.has(strTemp[left])){
                left++;
            }else{
                leftFlag = true;
            }
        }
        if(!rightFlag){
            if(!map.has(strTemp[right])){
                right--;
            }else{
                rightFlag = true;
            }
        }
        if(leftFlag&&rightFlag){
            temp = strTemp[left];
            strTemp[left] = strTemp[right];
            strTemp[right] = temp;
            leftFlag = false;
            rightFlag = false;
            left++;
            right--;
        }
    }
    console.log(strTemp.join(''));
    process.exit();
});

16、交替位二进制数

给定一个正整数n检查它的二进制表示是否总是 0、1 交替出现：换句话说，就是二进制表示中相邻两位的数字永不相同。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let num = Number(inputArray[0]);
    
    let result = true;
    let flag = (num % 2 === 0);
    while(num!=0){
        num = num>>1;
        if(flag == (num % 2 === 0)){
            result = false;
            break;
        }else{
            flag = !flag;
        }
    }
    if(result){
        console.log("TRUE");
    }else{
        console.log("FALSE");
    }
    process.exit();
});

17、存在重复元素

给你一个长度为n的非负整数数组 nums 。如果任一值在数组中出现至少两次 ，返回 TRUE ；如果数组中每个元素互不相同，返回 FALSE 。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let numArray = inputArray[0].split(' ');
    let map = new Map<number,number>();
    let num,flag = false;
    for(let i = 0;i< numArray.length;i++){
        num = Number(numArray[i]);
        if(map.has(num)){
            flag = true;
        }else{
            map.set(num,1);
        }
    }
    if(flag){
        console.log("TRUE");
    }else{
        console.log("FALSE");
    }
    process.exit();
});

18、元音字母

你是一个英语爱好者，尤其是对元音字母敏感。现在给你一个字符串，你来判断其中元音字母（A/a、E/e、I/i、O/o、U/u）的出现次数，并分别输出每个字母出现的次数。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let map = new Map([
       ['a',0] ,
       ['e',1] ,
       ['i',2] ,
       ['o',3] ,
       ['u',4] ,
       ['A',0] ,
       ['E',1] ,
       ['I',2] ,
       ['O',3] ,
       ['U',4] ,
    ]);
    let result:number[] = [0,0,0,0,0];
    let num;
    for(let i=0;i<inputArray[0].length;i++){
        num = inputArray[0][i];
        if(map.has(num)){
            result[map.get(num)] = result[map.get(num)] + 1;
        }
    }
    console.log(result.join(' '));
    process.exit();
});

19、不区分大小写对字符串进行排序

不区分大小写对字符串进行排序(按AaBbCcDd...顺序排序，且大写字母在小写字母前)
如：BadbAbB不区分大小写排序是AaBBbbd

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let charArray = inputArray[0].split('');
    let sorrtedArray:string[] = charArray.sort((n1,n2)=> {
        let index1 = n1.toLowerCase().charCodeAt(0);
        let index2 = n2.toLowerCase().charCodeAt(0);
        
        if(index1 == index2){
            return n1.charCodeAt(0) - n2.charCodeAt(0);
        }else{
            return index1 - index2;
        }
    });
    console.log(charArray.join(''));
    process.exit();
});

20、完全数

完全数的意思是一个数等于它的所有真约数之和。现在给你一个整数，请你判断一下这个整数是否为完全数。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let num = Number(inputArray[0]);
    
    if(num == 6||num == 28||num == 496){
        console.log("TRUE");
    }else{
        console.log("FALSE");
    }
    process.exit();
});

21、字符排序

给定一个字符串，仅含英文字母和数字，请按如下规则对其进行排序：
排序后，原位置是数字的，排序后仍然是数字；原位置是字母的，排序后仍然是字母。
数字：按 0-9 升序。
英文字母：大写字母大于小写字母，小写字母按 a-z 升序，大写字母按 A-Z 升序。

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
    input += data;
});
process.stdin.on('end', () => {
    let inputArray = input.split('\n');
    let charArray = inputArray[0].split('');
    let charMap = new Map();
    for(let i = 0;i<charArray.length;i++){
        if(charMap.has(charArray[i])){
            charMap.set(charArray[i], charMap.get(charArray[i])+1);
        }else{
            charMap.set(charArray[i], 1);
        }
    }
    let indexlow = 'a';
    let indexnum = '0';
    let indexhigh = 'A';
    for(let i = 0;i<charArray.length;i++){
        if(!isNaN(Number(charArray[i]))){
            while(true){
                if(charMap.has(indexnum)){
                    let count = charMap.get(indexnum);
                    if(count == 1){
                        charMap.delete(indexnum);
                    }else{
                        charMap.set(indexnum, count - 1);
                    }
                    charArray[i] = indexnum;
                    break;
                }else{
                    indexnum = String.fromCharCode(indexnum.charCodeAt(0) + 1);
                }
            }
        }else{
            while(true){
                if(indexlow.charCodeAt(0) <= 'z'.charCodeAt(0)){
                    if(charMap.has(indexlow)){
                        let count = charMap.get(indexlow);
                        if(count == 1){
                            charMap.delete(indexlow);
                        }else{
                            charMap.set(indexlow, count - 1);
                        }
                        charArray[i] = indexlow;
                        break;
                    }else{
                        indexlow = String.fromCharCode(indexlow.charCodeAt(0) + 1);
                    }
                }else{
                    if(charMap.has(indexhigh)){
                        let count = charMap.get(indexhigh);
                        if(count == 1){
                            charMap.delete(indexhigh);
                        }else{
                            charMap.set(indexhigh, count - 1);
                        }
                        charArray[i] = indexhigh;
                        break;
                    }else{
                        indexhigh = String.fromCharCode(indexhigh.charCodeAt(0) + 1);
                    }
                }
                
            }
        }
    }
    console.log(charArray.join(''));
    process.exit();
});