2024.01.24-秋招-第一题-计算积分

1

ichbinbobobo LV 7 @ 7 months ago

#include <string>
#include <iostream>
using namespace std;
int main()
{
    string line;
    getline(cin, line);
    int count = 0;
    for(size_t i=0; i<line.size();++i)
    {
        if(line[i]=='r')
        count+=1;
        else if(line[i]=='g')
        count+=2;
        else if(line[i]=='b')
        count+=3;
        
        if(i>0)
        {
            for(size_t j=i-1; j>=0;--j)
            {
                if(line[i]==line[j])
                count++;
                else
                break;
            }
        }
    }

    cout << count <<endl;
    return 0;
}

0

老友人来人往 LV 7 @ 6 months ago

data = input()
string = [0]*len(data)
i = 0 
for color in data:
    if color == 'r':
        string[i] = 1
    if color == 'g':
        string[i] = 2
    if color == 'b':
        string[i] = 3
    i+=1
count = []
count_ball = 1
now_ball = string[0]
sorce = 0
for j in range(1,len(data)):
    if string[j] == now_ball:
        count_ball+=1
    else:
        sorce += now_ball*count_ball+int((count_ball*(count_ball-1))/2)
        now_ball = string[j]
        count_ball = 1
sorce += now_ball*count_ball+int((count_ball*(count_ball-1))/2)
print(sorce)
# data = input()        #暴力解法
# color = {'r':1,'g':2,'b':3}
# sorce = 0
# ans =0
# for i in range(len(data)):
#     for j in range(i-1,-1,-1):
#         if data[i]==data[j]:
#             ans+=1
#         else:
#             break
#     sorce+=color[data[i]]
# print(sorce+ans)

0

lzjstranger@icloud.com LV 3 @ 6 months ago

#include<iostream>

using namespace std;

int main() {
    string s;
    getline(cin, s);
    int sum = 0, cnt = 0;
    char temp = '\0';
    for (int i = 0; i < s.size(); i++) {
        if (s[i] == 'r') {
            sum = sum + 1;
        } else if (s[i] == 'g') {
            sum = sum + 2;
        } else {
            sum = sum + 3;
        }
        if (s[i] == temp) {
            cnt++;
            sum = sum + cnt;
        } else {
            cnt = 0;
        }
        temp = s[i];
    }
    cout << sum << endl;
    return 0;
}

0

Kaf_sta LV 4 @ 6 months ago

def bonus(rope, i):
    score = 0
    while rope[i] == rope[i-1]:
        score += 1
        i -= 1
    return score


rope = list(input().strip())
rope = [0, 0] + rope
n = len(rope)
score = 0
for i in range(2, n):
    if rope[i] == 'r':
        score += 1
        score += bonus(rope, i)
    elif rope[i] == 'g':
        score += 2
        score += bonus(rope, i)
    elif rope[i] == 'b':
        score += 3
        score += bonus(rope, i)
print(score)

0

SKJKC LV 3 @ 7 months ago

#include<bits/stdc++.h>
using namespace std;

int main() {
    string str;
    unordered_map<char, int> u_map{
        {'r', 1},
        {'g', 2},
        {'b', 3}
    };
    while(cin>> str) {
        int n = str.size();
        vector<int> dp(n,0);

        for(int i = 1; i < n; i++) {
            if(str[i] == str[i-1]) {
                dp[i] = dp[i-1] + 1;
            }
        }
        
        int res = 0;
        for(int i = 0; i < n ;i++) {
            res += u_map[str[i]] + dp[i];
        }
        cout<<res;
    }
    return 0;
}

0

XiangChao LV 3 @ 7 months ago

s = input().strip()
bonus = ['a', 0]
res = 0
for item in s:
    if item == "r":
        res += 1
        if bonus[0] != "r":
            bonus[0] = "r"
            bonus[1] = 1
        else:
            res += bonus[1]
            bonus[1] += 1
    elif item == "g":
        res += 2
        if bonus[0] != "g":
            bonus[0] = "g"
            bonus[1] = 1
        else:
            res += bonus[1]
            bonus[1] += 1
    else:
        res += 3
        if bonus[0] != "b":
            bonus[0] = "b"
            bonus[1] = 1
        else:
            res += bonus[1]
            bonus[1] += 1

print(res)

0

Pau LV 2 @ 7 months ago

解法：滑动窗口

#include <iostream>
#include <string>
#include <unordered_map>

using namespace std;

int main()
{
    string s;
    cin >> s;
    
    unordered_map<char,int> hash = {{'r', 1}, {'g', 2}, {'b', 3}}; // 存放颜色对应的分数
    // 滑动窗口法
    int score = 0;
    for(int left = 0, right = 0; right < s.size(); right++)
    {
        char ch = s[right]; // 当前字符
        score += hash[ch];
        if(right > 0 && ch == s[right - 1]) // 扫描字符遇到与前一个字符一样, 移动right继续向后找
        {
            score += right - left;
            continue;
        }
        else left = right; // 扫描字符遇到与前一个字符不一样, 更新left到right位置
    }
    cout << score << endl;
    return 0;
}

0

riesling LV 6 @ 7 months ago

双指针法: 先遍历一遍结果加上普通rgb的res 接着再次遍历一遍使用双指针 fast slow 如果fast和slow相同则计算len = fast-slow 加入到res中; 如果不相同将fast位置赋值到slow上进行

#include<bits/stdc++.h>
using namespace std;

int getRewards(string str) {
    int fast = 0, slow = 0;
    long long res = 0;
    int len = str.size();
    for (int i = 0; i < len; i++) {
        if (str[i] == 'r') {
            res += 1;
        }
        else if (str[i] == 'g') {
            res += 2;
        } else if (str[i] == 'b') {
            res += 3;
        }
    }
    while (fast < len) {
        if (str[slow] == str[fast]) {
            int min_len = fast - slow;
            res += min_len;
        } else {
            slow = fast;
        }
        fast++;
    }
    return res;
}

int main() {
    string str;
    cin >> str;
    if (str.size() == 0) return 0;
    int res = 0;
    res = getRewards(str);
    cout << res << endl;
    return 0;
}

0

陈超峰 LV 1 @ 8 months ago

方法：滑动窗口
思路：维持一个保存相同元素的窗口。对当前遍历到的元素arr[right]，如果该元素与前一个元素相同，则该元素加入窗口，并计算增加的值。如果该元素与前一个元素不同，则重置窗口，窗口左端点left=right。
实现：left指向窗口左端点，right指向窗口右端点。每次处理arr[right]，决定是否加入窗口，或重置窗口。三种颜色值放入哈希表，注意初始化的方法。

import java.util.*;

public class Main {
    static Map<Character, Integer> map = new HashMap<>(){{
        put('r', 1);
        put('g', 2);
        put('b', 3);
    }};//写法
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            char[] arr = in.next().toCharArray();
            int res = 0;//得分
            //滑动窗口
            for(int left = 0, right = 0; right < arr.length; right++) {
                char ch = arr[right];//当前颜色
                res += map.get(ch);
                if((right == 0) || (right > 0 && arr[right] == arr[right - 1])) {
                    res += right - left;//正好是下标差额
                    continue;
                } else {
                    left = right;//收缩左边界
                }
            }
            System.out.println(res);
        }
        in.close();
    }
}

0

kingxue LV 6 @ 8 months ago

text = list(input())
trans = {"r":1,"g":2,"b":3}
bonus = [0] *len(text)

text = [trans[i] for i in text]

for i in range(len(text)-1):
    if text[i] == text[i+1]:
        bonus[i+1] = bonus[i]+1

print(sum(text)+sum(bonus))

0

TaZi SU @ 8 months ago

题面描述:

小明有根绳子，上面挂满了玻璃球，玻璃球的颜色有红、绿、蓝三种，分别用字符r、g、b表示，红色球的得分为1分，绿色球为2分，蓝色球为3分。此外，若某个球的颜色与前面的球相同，则会额外获得奖励分，具体来说，与前面1个球相同奖励1分，与前面2个球都相同奖励2分，以此类推。给定一串由这些字符组成的字符串，任务是计算这串玻璃球的总得分。

思路：模拟遍历

由于string的长度只有1e4，可以直接暴力做，n^2也只有1e8，小常数1s内可以跑完。直接往前遍历有几个字符和它相同即可。

或者基于简单dp的方式，每个位置保存它前面与它相等且串联的字符数量，每个字符只需要看其是否与上一个字符相等即可，相等则加1，否则置为0。

题解

本题要求计算一串由红、绿、蓝玻璃球组成的字符串的总得分。每种颜色的玻璃球对应不同的基础分数，其中红色球为1分，绿色球为2分，蓝色球为3分。此外，当一个球的颜色与前面的球相同时，会获得额外的奖励分数。具体来说，如果一个球与前面的第n个球颜色相同，将获得n-1分的奖励。

由于字符串的最大长度为10,000，暴力算法的复杂度为O(n^2)，在最坏情况下的操作次数为1亿，这在1秒内是可以接受的。因此，我们可以采用暴力方式逐个比较字符，也可以基于动态规划的思想来优化。

以下是基于暴力法的实现思路：

遍历字符串中的每一个字符。
对于每个字符，向前遍历其之前的字符，判断是否与当前字符相同。
若相同，则根据相同的数量增加得分；若不相同，则停止继续向前查找。
每个字符的基础得分加到总得分中。
输出最终得分。

JavaScript

// 读取输入字符串
let s = readline(); 

// 初始化总得分
let ans = 0;

// 定义每种颜色玻璃球的基础得分
let score = { "r": 1, "g": 2, "b": 3 };

// 遍历字符串中的每一个字符
for (let i = 0; i < s.length; i++) {
    // 内层循环向前查找与当前字符相同的字符
    for (let j = i - 1; j >= 0; j--) {
        // 如果当前字符与前面的字符相同
        if (s[i] == s[j]) {
            ans += 1; // 增加相同字符的奖励分
        } else {
            break; // 如果不相同，则停止查找
        }
    }
    // 加上当前字符的基础得分
    ans += score[s[i]];
}

// 输出最终得分
print(ans);

Java

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 创建一个Scanner对象，用于读取输入
        Scanner scanner = new Scanner(System.in);
        
        // 读取输入字符串
        String s = scanner.next();

        // 初始化总得分
        int ans = 0;

        // 定义每种颜色玻璃球的基础得分
        Map<Character, Integer> score = new HashMap<>();
        score.put('r', 1); // 红色球得分1
        score.put('g', 2); // 绿色球得分2
        score.put('b', 3); // 蓝色球得分3

        // 遍历字符串中的每一个字符
        for (int i = 0; i < s.length(); i++) {
            // 内层循环向前查找与当前字符相同的字符
            for (int j = i - 1; j >= 0; j--) {
                // 如果当前字符与前面的字符相同
                if (s.charAt(i) == s.charAt(j)) {
                    ans += 1; // 增加相同字符的奖励分
                } else {
                    break; // 如果不相同，则停止查找
                }
            }
            // 加上当前字符的基础得分
            ans += score.get(s.charAt(i));
        }

        // 输出最终得分
        System.out.println(ans);
    }
}

Python

# 读取输入字符串
s = input()  

# 初始化总得分
ans = 0  

# 定义每种颜色玻璃球的基础得分
score = {"r": 1, "g": 2, "b": 3}  

# 遍历字符串中的每一个字符
for i in range(len(s)):
    # 内层循环向前查找与当前字符相同的字符
    for j in range(i - 1, -1, -1):
        # 如果当前字符与前面的字符相同
        if s[i] == s[j]:
            ans += 1  # 增加相同字符的奖励分
        else:
            break  # 如果不相同，则停止查找
    
    # 加上当前字符的基础得分
    ans += score[s[i]]  

# 输出最终得分
print(ans)

C++

#include <iostream>
#include <string>
#include <map>

using namespace std;

int main() {
    // 读取输入字符串
    string s;
    cin >> s;

    // 初始化总得分
    int ans = 0;

    // 定义每种颜色玻璃球的基础得分
    map<char, int> score = { {'r', 1}, {'g', 2}, {'b', 3} };

    // 遍历字符串中的每一个字符
    for (int i = 0; i < s.length(); i++) {
        // 初始化当前字符与前面相同的数量
        int sameCount = 0;
        
        // 向前遍历，判断当前字符与前面的字符是否相同
        for (int j = i - 1; j >= 0; j--) {
            if (s[i] == s[j]) {
                sameCount++; // 相同的字符数量增加
            } else {
                break; // 遇到不同的字符，停止查找
            }
        }

        // 将相同字符的数量加入总得分（相同数量会产生额外的得分）
        ans += sameCount; // 奖励分数
        ans += score[s[i]]; // 当前字符的基础得分
    }

    // 输出最终得分
    cout << ans << endl;

    return 0;
}

11 solutions

解法：滑动窗口

题面描述:

思路：模拟遍历

题解

JavaScript

Java

Python

C++

Information

Status

Development

Support