返回目录

题目描述

给定一个字符串s，最多只能进行一次变换，返回变换后能得到的最小字符串（按照字典序进行比较）。

变换规则：交换字符串中任意两个不同位置的字符。

输入描述

一串小写字母组成的字符串s

输出描述

按照要求进行变换得到的最小字符串。

示例：

Python算法源码

# 对字符串进行排序
s = input()
sorted_str = ''.join(sorted(s))

# 如果排序后的字符串与原字符串相同，则说明已经是最小字符串，直接输出
if sorted_str == s:
    print(s)
else:
    # 遍历原字符串
    sb = list(s)
    for i in range(len(s)):
        # 如果当前字符与排序后的字符不相同，则进行交换
        if s[i] != sorted_str[i]:
            # 找到排序后的字符在原字符串中的位置
            swap_index = sb.index(sorted_str[i], i + 1)
            # 将原字符与排序后的字符交换
            sb[i], sb[swap_index] = sb[swap_index], sb[i]
            break

    # 输出最小字符串
    print(''.join(sb))

C算法源码

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

int main() {
    char s[100];
    scanf("%s", s);

    // 对字符串进行排序
    int len = strlen(s);
    for (int i = 0; i < len - 1; i++) {
        for (int j = i + 1; j < len; j++) {
            if (s[i] > s[j]) {
                char tmp = s[i];
                s[i] = s[j];
                s[j] = tmp;
            }
        }
    }

    char sorted_str[100];
    strcpy(sorted_str, s);

    // 如果排序后的字符串与原字符串相同，则说明已经是最小字符串，直接输出
    if (strcmp(sorted_str, s) == 0) {
        printf("%s\n", s);
        return 0;
    }

    // 遍历原字符串
    char sb[100];
    strcpy(sb, s);
    for (int i = 0; i < len; i++) {
        // 如果当前字符与排序后的字符不相同，则进行交换
        if (s[i] != sorted_str[i]) {
            // 找到排序后的字符在原字符串中的位置
            int swap_index = -1;
            for (int j = i + 1; j < len; j++) {
                if (sb[j] == sorted_str[i]) {
                    swap_index = j;
                    break;
                }
            }
            // 将原字符与排序后的字符交换
            char tmp = sb[i];
            sb[i] = sb[swap_index];
            sb[swap_index] = tmp;
            break;
        }
    }

    // 输出最小字符串
    printf("%s\n", sb);

    return 0;
}

Java算法源码

import java.util.Arrays;
import java.util.Scanner;

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

        // 对字符串进行排序
        char[] sortedStr = s.toCharArray();
        Arrays.sort(sortedStr);

        // 如果排序后的字符串与原字符串相同，则说明已经是最小字符串，直接输出
        if (Arrays.equals(sortedStr, s.toCharArray())) {
            System.out.println(s);
            return;
        }

        // 遍历原字符串
        char[] sb = s.toCharArray();
        for (int i = 0; i < s.length(); i++) {
            // 如果当前字符与排序后的字符不相同，则进行交换
            if (s.charAt(i) != sortedStr[i]) {
                // 找到排序后的字符在原字符串中的位置
                int swapIndex = -1;
                for (int j = i + 1; j < s.length(); j++) {
                    if (sb[j] == sortedStr[i]) {
                        swapIndex = j;
                        break;
                    }
                }
                // 将原字符与排序后的字符交换
                char tmp = sb[i];
                sb[i] = sb[swapIndex];
                sb[swapIndex] = tmp;
                break;
            }
        }

        // 输出最小字符串
        System.out.println(new String(sb));
    }
}