11 solutions

  • 1
    @ 2024-9-5 4:24:02 
    #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
      @ 2024-10-27 19:45:53 
      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
        @ 2024-10-15 11:17:45 
        #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
          @ 2024-10-9 15:44:28 
          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
            @ 2024-9-23 21:11:25 
            #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
              @ 2024-9-8 16:42:08 
              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
                @ 2024-9-7 22:46:19

                解法：滑动窗口

                #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
                  @ 2024-9-2 3:15:20

                  双指针法: 先遍历一遍结果 加上普通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
                    @ 2024-8-30 12:38:10
                    • 方法：滑动窗口
                    • 思路：维持一个保存相同元素的窗口。对当前遍历到的元素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
                      @ 2024-8-29 1:13:08 
                      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
                        @ 2024-8-21 4:23:13

                        题面描述:

                        小明有根绳子，上面挂满了玻璃球，玻璃球的颜色有红、绿、蓝三种，分别用字符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秒内是可以接受的。因此，我们可以采用暴力方式逐个比较字符，也可以基于动态规划的思想来优化。

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

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

                        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;
}
                        • 1

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

                        Information

                        ID
                        74
                        Time
                        1000ms
                        Memory
                        256MiB
                        Difficulty
                        1
                        Tags
                        # Submissions
                        598
                        Accepted
                        228
                        Uploaded By
                        1. About
                        2. Contact Us
                        3. Privacy
                        4. Terms of Service
                        5. Copyright Complaint
                        6. Language
                        7. Legacy mode
                        8. Theme
                        2. 湘ICP备2023007293号
                        3. Worker 0, 42ms
                        4. Powered by Hydro v4.14.1 Community