首页 > 试题广场 >

名字的漂亮度

[编程题]名字的漂亮度
  • 热度指数:140320 时间限制:C/C++ 1秒,其他语言2秒 空间限制:C/C++ 32M,其他语言64M
  • 算法知识视频讲解

给出一个字符串,该字符串仅由小写字母组成,定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。
每个字母都有一个“漂亮度”,范围在1到26之间。没有任何两个不同字母拥有相同的“漂亮度”。字母忽略大小写。

给出多个字符串,计算每个字符串最大可能的“漂亮度”。

本题含有多组数据。

数据范围:输入的名字长度满足



输入描述:

第一行一个整数N,接下来N行每行一个字符串



输出描述:

每个字符串可能的最大漂亮程度

示例1

输入

2
zhangsan
lisi

输出

192
101

说明

对于样例lisi,让i的漂亮度为26,l的漂亮度为25,s的漂亮度为24,lisi的漂亮度为25+26+24+26=101.   
//朋友们这就是一个大根堆的问题啊,统计字母个数存在大根堆,然后ans += top*(26-i);
#include<iostream>
#include<string>
#include<queue>
using namespace std;

string nameBeauty[1001];
int aphaCout(string& rhs);
int main(){
	int _N;
	while(cin>>_N){
		for(int i=0;i<_N;i++){
			cin>>nameBeauty[i];
		}
        for(int i=0;i<_N;i++){
            cout<<aphaCout(nameBeauty[i])<<endl;
        }
	}
    return 0;
}
int aphaCout(string& rhs){
	priority_queue<int> mypq;
	int aph[26] = {0};
	int ans = 0;
	for(int i=0;i<rhs.size();i++){
		++aph[rhs[i]-'a'];
	}
	for(int i=0;i<26;i++){
		if(aph[i] != 0 ){
			mypq.push(aph[i]);
		}
	}
	int _size = mypq.size();
	for(int i=0;i<_size;i++){
		ans += (26-i) * mypq.top();
		mypq.pop();
	}
	return ans;
}

发表于 2017-06-26 16:40:11 回复(0)
# str转换成list
def str2list(s):
    l=[v for v in s]
    return l

def beautiful_degree(s):
    l=str2list(s)#['l','i','s','i']
    ans=0
    dic={}
    for i in l:
        if i in dic:
            dic[i]+=1
        else:
            dic[i]=1
    # dic={'l':1,'i':2,'s':1}
    lst=sorted(dic.items(), key=lambda x: x[1], reverse=True)  # 按字典的value排序(倒序)
    # lst=[(i,2),(s,1),(l,1)]
    abc = [k for k in range(26, 0, -1)]#[26,25,24....]
    for j in range(len(lst)):
        ans += lst[j][1]*abc[j]
    return ans


while True:
    try:
        n=int(input())# 多少个名字
        li=[]
        for i in range(n):
            name=input()
            li.append(name)
        #li=['zhangsan','lisi']
        for j in range(len(li)):
            print(beautiful_degree(li[j]))
    except:
        break
很多人题意看不明白,其实就是出现次数最多的字母漂亮度是26,第二多的是25...以此类推。最后累计加和,这样整个单词的漂亮度最高,附代码。
发表于 2020-02-17 15:50:49 回复(10)
#include <bits/stdc++.h>
using namespace std;
int count(string str){
    int result = 0;
    map<char,int> helper;
    for(auto ch:str) ++helper[ch];
    vector<pair<char,int> > vec(helper.begin(),helper.end());
    stable_sort(vec.begin(), vec.end(),
               [](const pair<char,int>& p1, const pair<char,int>& p2)
                {return p1.second > p2.second;});
    for(int i=0;i < vec.size();i++)
        result += (26-i)*vec[i].second;
    return result;
}
int main(){
    int n;string name;
    while(cin >> n)
        for(int i=0;i < n;++i){
            cin >> name;
            cout << count(name) << endl;
        }
    return 0;
}

发表于 2020-06-22 22:18:58 回复(1)
while True:
    try:
        times = int(input().strip())
        for i in range(times):
            name = input().strip()
            char_dict = {}
            for key in name:
                if key in char_dict.keys():
                    char_dict[key] += 1
                else:
                    char_dict[key] = 1
            value_list = []
            for key in char_dict.keys():
                value_list.append(char_dict[key])
            beauty_value = 26
            total_value = 0
            for num in sorted(value_list, reverse=True):
                total_value += beauty_value * num
                beauty_value -= 1
            print(total_value)

    except:
        break
找出每个字母,形成列表,按照出现的次数非升序排列。然后最大的给26权重,次之的给25权重,以此类推,直至遍历完列表,得出总漂亮值。
发表于 2019-11-14 20:56:56 回复(0)
#include <iostream>
#include <algorithm>
#include <map>
#include <vector>
#include <string>
using namespace std;

bool isBigger(const pair<int, int> &lhs, const pair<int, int> &rhs) {
	return lhs.second > rhs.second;
}


int main()
{
	int test;
	while (cin >> test)
	{
		while (test--)
		{
			string st;
			cin >> st;
			int i, k = 26, res = 0;
			map<int, int> m;
			for (i = 0; i < st.length(); ++i)
			{
				if (st[i] >= 'a' && st[i] <= 'z')
					m[st[i] - 'a']++;
				else
					m[st[i] - 'A']++;
			}
			vector<pair<int, int> > pvec(m.begin(), m.end());
			sort(pvec.begin(), pvec.end(), isBigger);
			//int size = pvec.size();
			for (i = 0; i <= pvec.size() - 1; i++)
				res += pvec[i].second * k--;
			cout << res << endl;
		}
	}
	return 0;
}

编辑于 2019-09-16 15:29:18 回复(0)
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;

void Beauty(string str) 
{
	int alpha[26] = {0};
	
	for (int i = 0; i < str.length(); i++) 
	{
		if (str[i] >= 'a' && str[i] <= 'z')
		{
			alpha[str[i] - 97] ++;
		}
		else if (str[i] >= 'A' && str[i] <= 'Z')
		{
			alpha[str[i] - 65] ++;
		}
	}
	sort(alpha, alpha+26);
	int sum = 0;
	for (int i = 26; i > 0; i--) 
	{
		sum += alpha[i-1] * i;
	}
	cout << sum << endl;
}

int main()
{
	int num;
	while (cin >> num)
	{
		while (num--)
		{
			string tmp;
			cin >> tmp;
			Beauty(tmp);
		}
	}
	return 0;
}


发表于 2019-09-10 20:14:39 回复(0)
//#include "stdafx.h"
#include<iostream>
#include<string>
#include<map>
#include<algorithm>
#include<vector>
using namespace std;
struct Map
{
   char key;
   int value;
};
bool compare(Map a,Map b)
{
  return a.value>b.value;
};
int main()
{
   string str;
   int score=0;
   int n;
   cin>>n;
   for(int i=0;i<n;i++)
   {
 cin>>str;
 score=0;
 map<char,int>moban;
 map<char,int>::iterator iter;
  for(int i=0;i<str.size();i++)
  {
 moban[str[i]]++;
  }
       
  vector<Map>result;
  for(iter=moban.begin();iter!=moban.end();iter++)
  {
 Map aa;
       aa.key=iter->first;
 aa.value=iter->second;
 result.push_back(aa);
  }
  sort(result.begin(),result.end(),compare);
  int ii=26;
  for(int k=0;k<result.size();k++)
  {
  score+=result[k].value*ii;
      ii--;
  }
  cout<<score<<endl;
   }
   return 0;
}


发表于 2016-06-25 11:18:19 回复(1)
def pls(s): # 定义计算漂亮度的函数
    counts = [] # 保存每个字母出现的次数
    scores = 0 # 漂亮度的总分
    for i in set(s):
        counts.append(s.count(i)) # 计算每个字母出现的次数
    counts.sort(reverse=True) # 将字母出现的次数倒序排列
    for i in range(len(counts)):
        scores += counts[i] * (26-i) # 按照字母出现的次数由高到低计算其分数并且加到总分,如出现次数最多的就乘以26,第二多的乘以25,以此类推,算出来的漂亮度就是最高的
    return scores # 返回总漂亮度

while True:
    try:
        n = int(input())
        ls = []
        for i in range(n):
            d = input().lower()
            ls.append(d) # 保存我们输入的字符串
        for i in ls:
            print(pls(i)) # 每个字符串都调一遍漂亮度函数,得到对应的漂亮度
    except:
        break
发表于 2022-08-21 17:21:00 回复(0)
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	for scanner.Scan() {
		input := scanner.Text()
		if input == "" {
			return
		}

		charMap := map[byte]int{}

		for i := 0; i < len(input); i++ {
			charMap[input[i]]++
		}

		beautyList := []int{}

		for _, v := range charMap {
			beautyList = append(beautyList, v)
		}

		sort.Ints(beautyList)

		power := 26
		res := 0
		for i := len(beautyList) - 1; i >= 0; i-- {
			res += beautyList[i] * power
			power--
		}
		fmt.Println(res)
	}

}

发表于 2022-06-08 16:51:22 回复(0)
/****** 利用数组下标 排序+去重 ******/
#include <stdio.h>
#include <string.h>
char s[1001];
int main(void)
{
    int num;
    scanf("%d", &num);
    for (int i = 0; i < num; i++) {
        int sum_num = 0;
        int s_temp[150] = {0};
        scanf("%s", s);
        int s_len = strlen(s);
        for (int j = 0; j < s_len; j++) {
            s_temp[s[j]]++; // 使用下标去重复,并计算相同字母个数
        }
        int x = 1001; // 权重由大到小筛查
        int qz_num = 26; // 初始化最大权重
        while (--x) {
            for (int k = 'A'; k <= 'z'; k++) {
                if (s_temp[k] == x) { // 查到当前为止最大权重的字母
                    sum_num += qz_num * x; // 计算总重
                    qz_num--; // 权重递减
                }
            }
        }
        printf("%d\n", sum_num);
    }
    return 0;
}

发表于 2022-04-23 20:48:14 回复(0)
什么垃圾题,题意都描述不清楚,还要自己根据示例去蒙???
发表于 2022-02-24 11:46:02 回复(0)
题都看不懂,怎么做。。。
发表于 2021-12-14 16:45:40 回复(0)
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            for (int i=0; i<n; i++) {
                String str = scanner.next();
                // map集合统计字符
                Map<Character, Integer> map = new TreeMap<>();
                char c;
                for (int j=0; j<str.length(); j++) {
                    c = str.charAt(j);
                    if (!map.containsKey(c)) {
                        map.put(c, 1);
                    } else {
                        map.put(c, map.get(c) + 1);
                    }
                }
                // 提取数据为数组,并排序
                int[] nums = new int[map.size()];
                int index = 0;
                for (Map.Entry<Character, Integer> entry : map.entrySet()) {
                    nums[index] = entry.getValue();
                    index ++;
                }
                Arrays.sort(nums);
                // 计算最大的漂亮度
                int beautiful = 26;
                int sum = 0;
                for (int k=nums.length-1 ; k >= 0; k--) {
                    sum += beautiful * nums[k];
                    beautiful --;
                }
                System.out.println(sum);
            }
        }
    }
}

发表于 2021-11-04 15:33:51 回复(1)
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        in.nextLine();//跳到第二行
        for(int i=0;i<n;i++){
            System.out.println(getScore(in.nextLine()));
        }
    }
    public static int getScore(String name){
        int score = 0;
        char[] cha = name.toCharArray();
        int[] count = new int[26];
        for(int i=0;i<cha.length;i++){
            count[Character.toLowerCase(cha[i]) - 'a']++;//统计每个字母出现的次数,忽略大小写
        }
        Arrays.sort(count);//升序排列
        for(int i=1;i<=26;i++){//计算漂亮度
            score += i * count[i-1];
        }
        return score;
    }
}

发表于 2021-10-05 09:44:14 回复(1)
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int beauty=0;
        while(sc.hasNext()){
            int n = sc.nextInt();
            for(int i=0; i<n; i++){
                beauty = getBeauty(sc.next());
                System.out.println(beauty);
            }
        }
    }
    
    private static int getBeauty(String name){
        if(name==null || name.length()==0) return 0;
        
        //统计单词
        int[] arr = new int[26];
        name = name.toUpperCase();
        for(int i=0; i<name.length(); i++){
            arr[name.charAt(i)-'A']++;
        }
        //排序统计
        Arrays.sort(arr);
        int beauty=0, temp=26;
        for(int i=arr.length-1; i>=0; i--){
            if(arr[i]==0) break;
            beauty += arr[i]*temp;
            temp--;
        }
        return beauty;
    }
}

发表于 2021-08-06 20:33:10 回复(0)
利用hashmap和优先级队列
 public static void main(String[] args){
       Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int num = in.nextInt();
            in.nextLine();
            for(int i = 0;i < num;i++){
                String str = in.nextLine();
                HashMap<Character,Integer> map = new HashMap<>();
                for(int m = 0;m < str.length();m++){
                    char c = str.charAt(m);
                    if(map.containsKey(c)){
                        map.put(c,map.get(c) + 1);
                    }else{
                        map.put(c,1);
                    }
                }
                PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
                for(Character key : map.keySet()){
                    priorityQueue.offer(map.get(key));
                }
                int sum = 0;
                while(!priorityQueue.isEmpty()){
                    sum += priorityQueue.poll() * (26 - priorityQueue.size());
                }
                System.out.println(sum);
            }
        }
    }


编辑于 2021-04-14 21:33:55 回复(0)
每个字母的漂亮度其实是不确定的,我们先对名字的字符进行计数,然后利用贪心算法,将数量最多的字母漂亮度定义为26,次多的字母漂亮度定义为25,......,这样就能够使得漂亮度最大。
from collections import defaultdict

while True:
    try:
        n = int(input())
        for i in range(n):
            name = input().strip()
            counter = defaultdict(lambda: 0)
            for c in name:
                counter[c] += 1
            sorted_tuple = sorted(counter.items(), key=lambda x: -x[1])    # 按字符的计数降序排列
            max_beautiful, char_beautiful = 0, 26
            for _, cnt in sorted_tuple:
                max_beautiful += cnt * char_beautiful
                char_beautiful -= 1
            print(max_beautiful)
    except:
        break

发表于 2021-04-01 15:03:22 回复(0)
//无力吐槽了,写完自己都能通过,就是一直报段错误,各种原因都找了,本来我一般把输入字符串的数组定义成1000长度,我心说名字也超不过1000长度吧,谁家名字这么长,然后最后还真就是这个原因,数组定义小了,一怒之下换成char name[1000000]  行吧 100万长度的名字 通过了 笑cry

//思路 首先找出每个字母所占的个数,插入排序从大到小  按照数组下标++ *(26--)

#include<stdio.h>
#include<string.h>

int calculateBeauty(char *p)
{
    int hash[26]={0};
    int len = strlen(p);
    int i,j,temp,beauty=0;
    //先将所有字母个数统计出来
    for(i=0;i<len;i++)
    {
        //大小写忽略
        if(*(p+i) >= 'a' && *(p+i) <= 'z')
        {
            hash[*(p+i) - 'a'] ++;
        }
        else if(*(p+i) >= 'A' && *(p+i) <= 'Z')
        {
            hash[*(p+i) - 'A'] ++;
        }
    }
    //冒泡排序法
    for(i=0;i<25;i++)
    {
        for(j=i+1;j<26;j++)
        {
            if(hash[i] < hash[j])
            {
                temp = hash[i];
                hash[i] = hash[j];
                hash[j] = temp;
            }
        }
    }
    //
    for(i=0,j=26;i<26;i++)
    {
        if(hash[i])
        {
            beauty += hash[i]*j;
            j--;
        }
    }
    return beauty;
}

int main(void)
{
    int i,n;
    char name[100000];
    memset(name,0,sizeof(name));
    while(scanf("%d",&n) != EOF)
    {
        for(i=0;i<n;i++)
        {
            scanf("%s",name);
            printf("%d\n",calculateBeauty(name));
            memset(name,0,sizeof(name));
        }
    }
    return 0;
    
}
发表于 2021-01-28 22:18:33 回复(0)
大佬们帮忙看一下为啥OJ过不了,本地结果都对。OJ输出是空    本地输出正确数据
#include <iostream>
#include <string>

using namespace std;

int main()
{
    string str;
    int N;
    cin>>N;
    while(N--)
    {
        cin>>str;
        int arr[26] = {0};
        int res = 0;
        int count = 0;
        for(int i =0;i<str.size();i++)
        {
            if(str[i]>='a'&&str[i]<='z')
            {
              arr[str[i]-'a']+= 1;  
            }
            else if (str[i]>='A'&&str[i]<='Z')
            {
              arr[str[i]-'A']+= 1;
            }
        }
        //冒泡排序
        for(int j = 0;j< 26;j++)
        {
            for(int k = j+1;k<26;k++)
            {
                int tmp = 0;
                if(arr[j]<arr[k])
                {
                    tmp = arr[j];
                    arr[j] = arr[k];
                    arr[k] = tmp;
                }
            }
        }
        
        for(int n = 0;n<26;n++)
        {
            if(arr[n] != 0)
            {
                res+= arr[n]*(26-count);
                count++;
            }
        }
        cout<<res<<endl;
    }
    return 0;
}

发表于 2021-01-12 22:22:44 回复(1)
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            int num = scanner.nextInt();
            for (int i = 0; i < num; i++){
                int value = 26;
                int totalBeauty = 0;
                List<String> list = Arrays.asList(scanner.next().split(""));
                Map<String, Integer> alpFreq = new HashMap<>();
                for (int j = 0; j < list.size(); j++){
                    if (alpFreq.containsKey(list.get(j).toLowerCase())){
                        alpFreq.put(list.get(j).toLowerCase(),alpFreq.get(list.get(j).toLowerCase())+1);
                    }else{
                        alpFreq.put(list.get(j).toLowerCase(),1);
                    }
                }
                List<Map.Entry<String, Integer>> sortedList = new ArrayList<>(alpFreq.entrySet());
                Collections.sort(sortedList, new Comparator<Map.Entry<String, Integer>>(){
                    public int compare(Map.Entry<String, Integer> entry1, Map.Entry<String, Integer> entry2){
                        return entry2.getValue() - entry1.getValue();
                    }
                });
                Iterator<Map.Entry<String, Integer>> iter = sortedList.iterator();
                while (iter.hasNext()){
                    totalBeauty += alpFreq.get(iter.next().getKey())*value;
                    value -= 1;
                }
                System.out.println(totalBeauty);
            }
        }
    }
}


编辑于 2021-01-05 14:15:15 回复(0)