当前位置：首页 > article >正文

字符串重新排列

article 2025/3/1 7:46:39

字符串重新排列

真题目录: 点击去查看

E 卷 100分题型

题目描述

给定一个字符串s，s包括以空格分隔的若干个单词，请对s进行如下处理后输出：

单词内部调整：对每个单词字母重新按字典序排序
单词间顺序调整：
1. 统计每个单词出现的次数，并按次数降序排列
2. 次数相同，按单词长度升序排列
3. 次数和单词长度均相同，按字典升序排列

请输出处理后的字符串，每个单词以一个空格分隔。

输入描述

一行字符串，每个字符取值范围：[a-zA-z0-9]以及空格，字符串长度范围：[1，1000]

输出描述

输出处理后的字符串，每个单词以一个空格分隔。

用例1

输入

This is an apple

输出

an is This aelpp

说明

无

用例2

输入

My sister is in the house not in the yard

输出

in in eht eht My is not adry ehosu eirsst

说明

无

题解

c++

#include<iostream>
#include <cstdio>
#include<vector>
#include<string>
#include <utility> 
#include <sstream>
#include<algorithm>
#include<map>
using namespace std;

// 通用 split 函数
vector<string> split(const string& str, const string& delimiter) {
    vector<string> result;
    size_t start = 0;
    size_t end = str.find(delimiter);
    while (end != string::npos) {
        result.push_back(str.substr(start, end - start));
        start = end + delimiter.length();
        end = str.find(delimiter, start);
    }
    // 添加最后一个部分
    result.push_back(str.substr(start));
    return result;
}
// 统计单词出现数量
map<string, int> countMp;
// 单词内部转换策略
map<string, string> mp;

// 自定义排序
bool cmp(string s1, string s2) {
   if (countMp[mp[s1]] == countMp[mp[s2]]) {
       if (s1.size() == s2.size()) {
          return mp[s1] < mp[s2];
       }
       return s1.size() < s2.size();
   }
   return countMp[mp[s1]] > countMp[mp[s2]];
}

int main() {
    string s;
    getline(cin, s);
    vector<string> ans = split(s, " ");
    // 进行转换
    for (int i = 0; i < ans.size(); i++) {
        string first = ans[i];
        string firstBack = string(first);
        sort(firstBack.begin(), firstBack.end());
        mp[ans[i]] = firstBack;
        countMp[firstBack] ++;
    }

    
    sort(ans.begin(), ans.end(), cmp);
    for (int i = 0; i < ans.size(); i++) {
        cout << mp[ans[i]] << " ";
    }

}

JAVA

import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;
import java.util.StringJoiner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    String[] arr = sc.nextLine().split(" ");
    System.out.println(getResult(arr));
  }

  public static String getResult(String[] arr) {
    arr = Arrays.stream(arr).map(
                str -> {
                  char[] cArr = str.toCharArray();
                  Arrays.sort(cArr);
                  return new String(cArr);
                })
            .toArray(String[]::new);

    HashMap<String, Integer> count = new HashMap<>();
    for (String s : arr) {
      count.put(s, count.getOrDefault(s, 0) + 1);
    }

    Arrays.sort(
        arr,
        (a, b) ->
            !count.get(a).equals(count.get(b))
                ? count.get(b) - count.get(a)
                : a.length() != b.length() ? a.length() - b.length() : a.compareTo(b));

    StringJoiner sj = new StringJoiner(" ", "", "");
    for (String s : arr) {
      sj.add(s);
    }
    return sj.toString();
  }
}

Python

# 输入获取
arr = input().split()


# 算法入口
def getResult(arr):
    for i in range(len(arr)):
        arr[i] = "".join(sorted(arr[i]))

    count = {}
    for c in arr:
        if count.get(c) is None:
            count[c] = 0
        count[c] += 1

    # arr.sort(key=lambda x: (-count[x], len(x), [ord(char) for char in x]))
    arr.sort(key=lambda x: (-count[x], len(x), x))

    # return " ".join(map(str, arr))
    return " ".join(arr)


# 算法调用
print(getResult(arr))

JavaScript

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.on("line", (line) => {
  const arr = line.split(" ");
  console.log(getResult(arr));
});

function getResult(arr) {
  arr = arr.map((str) => [...str].sort().join(""));

  const count = arr.reduce((p, c) => {
    p[c] ? p[c]++ : (p[c] = 1);
    return p;
  }, {});

  arr.sort((a, b) =>
    count[a] !== count[b]
      ? count[b] - count[a]
      : a.length !== b.length
      ? a.length - b.length
      : a > b
      ? 1
      : -1
  );

  return arr.join(" ");
}

Go

package main

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



// 定义全局变量
var countMap = make(map[string]int) // 统计单词出现数量
var transformMap = make(map[string]string) // 单词内部转换策略

// 自定义排序
func customSort(words []string) func(i, j int) bool {
	return func(i, j int) bool {
		transI, transJ := transformMap[words[i]], transformMap[words[j]]
		if countMap[transI] == countMap[transJ] {
			if len(words[i]) == len(words[j]) {
				return transI < transJ
			}
			return len(words[i]) < len(words[j])
		}
		return countMap[transI] > countMap[transJ]
	}
}

func main() {
	// 读取输入
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	input := scanner.Text()

	// 分割字符串
	words := strings.Split(input, " ")

	// 构建转换映射和统计计数
	for _, word := range words {
		transformed := strings.Split(word, "")
		sort.Strings(transformed)
		transformedWord := strings.Join(transformed, "")
		transformMap[word] = transformedWord
		countMap[transformedWord]++
	}

	// 排序
	sort.Slice(words, customSort(words))

	// 输出结果
	for _, word := range words {
		fmt.Printf("%s ", transformMap[word])
	}
}