输入一行字符串，按字符串各字母出现次序输出字符串中所有出现过的大写英文字母(不能重复输出相同字母) 输入 输入为多组测试数据。 输入一行字符串。 输出 输出字符串中所有的大写字母

这个问题是在要求编写一个程序，给定一个输入字符串，程序需要找出其中所有不重复的大写字母，并按照它们在原字符串中首次出现的顺序输出。这里可以使用Python语言的一个解决方案：

def find_unique_uppercase_chars(s):
    # 创建一个空集合存储已找到的大写字母，因为集合不允许重复元素
    unique_letters = set()
    
    # 遍历字符串中的每个字符
    for char in s:
        # 如果字符是大写字母，并且还没有在集合中出现过，就添加到集合并打印
        if char.isupper():
            unique_letters.add(char)
    
    # 返回结果字符串
    return ''.join(sorted(unique_letters))

# 测试示例
test_str = "Hello World! This is a Test."
result = find_unique_uppercase_chars(test_str)
print(result)

#

相关问题

输入一行字符（字符总数不超过80个），统计该字符串的大小写字母、数字、空格、其它字符，最后分别输出。 分析：定义若干个变量 upper, lower,digit,space,others分别代表大写字母，小写字母，数字字符，空格，其它字符，并对它们进行初始化，输出的顺序分别是题目中表达的次序。 示例： 输入：123# ABc 输出：2,1,3,2,1

以下是Python的实现代码：

s = input()
upper, lower, digit, space, others = 0, 0, 0, 0, 0

for c in s:
    if c.isupper():
        upper += 1
    elif c.islower():
        lower += 1
    elif c.isdigit():
        digit += 1
    elif c.isspace():
        space += 1
    else:
        others += 1

print("{},{},{},{},{}".format(upper, lower, digit, space, others))

输入一个字符串，然后遍历每个字符，根据字符的属性进行计数。其中，`isupper()`、`islower()`、`isdigit()`、`isspace()`是Python字符串内置的方法，分别用于判断字符是否为大写字母、小写字母、数字字符、空格。最后使用`format()`方法输出结果。

定义一个基类 BaseString，实现基本的输入字符串的功能。 //-------------------------------------------------------------------------------------------------- class BaseString { public: char *GetData();//返回字符串 void Input(); //输入字符串，遇到换行符结束 void Display();//显示字符串 BaseString(); ~BaseString(); unsigned int Getlength(){ return Length;}//获取字符串长度 protected: char Data[1024]; unsigned Length; //表示字符串的长度，不包括结束的'\0' }; //-------------------------------------------------------------------------------------------------- 2． 定义一个类 ReString，公有继承自 BaseString，添加一个函数 Reverse()实 现字符串的倒置功能，即：将对象中的数据成员 Data 数组的元素倒置。倒置的概 念是：原字符串为“abcd1234”，倒置后为“4321dcba”。 3． 定义一个类 CopyString,公有继承自 BaseString，添加一个函数 Copy()实现 字符串的拷贝功能（传入的参数可以是一个字符串对象，也可以从一个字符串常量， 将参数中的字符串拷贝到对象的 Data 数组中去，注意：不要使用系统内置的 strcpy() 函数）。 面向对象程序设计上机指导 20 4． 定义一个类 CmpString，公有继承自 BaseString，添加一个函数 Compare() 实现字符串的比较功能（传入的参数可以是一个字符串对象，也可以从一个字符串 常量，将参数中的字符串同对象中的 Data 进行比较）。 思考字符串比较的算法。注意：不要使用系统内置的 strcmp()函数。 5． 在 main（）函数中体现出派生类的构造函数的调用次序。可以在各类的构 造函数中输出“I am the * class’s constructor”。*表示当前类名。 6． 定义一个类 NewString 继承自 ReString、CopyString 和 CmpString 三个类， 在程序中体现出多重继承中的基类的继承程序。为基类 BaseString 增加功能： ToUpper()函数将所有字母大写，ToLower()函数将所有字母小写。并在继承的过程 中声明为虚基类，比较 BaseString 作为虚基类和非虚基类的情况下的区别

以下是代码实现：

#include <iostream>
#include <cstring>
using namespace std;

class BaseString {
public:
    char* GetData() { return Data; } //返回字符串
    void Input() { cin.getline(Data, 1024); Length = strlen(Data); } //输入字符串，遇到换行符结束
    void Display() { cout << Data << endl; } //显示字符串
    BaseString() { cout << "I am the BaseString's constructor" << endl; }
    ~BaseString() {}
    unsigned int Getlength() { return Length; } //获取字符串长度
protected:
    char Data[1024];
    unsigned Length; //表示字符串的长度，不包括结束的'\0'
};

class ReString : public BaseString {
public:
    void Reverse() {
        int i = 0, j = Length - 1;
        while (i < j) {
            swap(Data[i], Data[j]);
            i++;
            j--;
        }
    }
    ReString() { cout << "I am the ReString's constructor" << endl; }
};

class CopyString : public BaseString {
public:
    void Copy(const BaseString& str) {
        int len = str.Getlength();
        memcpy(Data, str.GetData(), len);
        Length = len;
    }
    void Copy(const char* str) {
        int len = strlen(str);
        memcpy(Data, str, len);
        Length = len;
    }
    CopyString() { cout << "I am the CopyString's constructor" << endl; }
};

class CmpString : public BaseString {
public:
    int Compare(const BaseString& str) {
        int len1 = Length, len2 = str.Getlength();
        int len = min(len1, len2);
        for (int i = 0; i < len; i++) {
            if (Data[i] != str.GetData()[i]) {
                return Data[i] - str.GetData()[i];
            }
        }
        return len1 - len2;
    }
    int Compare(const char* str) {
        int len1 = Length, len2 = strlen(str);
        int len = min(len1, len2);
        for (int i = 0; i < len; i++) {
            if (Data[i] != str[i]) {
                return Data[i] - str[i];
            }
        }
        return len1 - len2;
    }
    CmpString() { cout << "I am the CmpString's constructor" << endl; }
};

class NewString : public ReString, public CopyString, virtual public CmpString {
public:
    void ToUpper() {
        for (int i = 0; i < Length; i++) {
            if (Data[i] >= 'a' && Data[i] <= 'z') {
                Data[i] = Data[i] - 'a' + 'A';
            }
        }
    }
    void ToLower() {
        for (int i = 0; i < Length; i++) {
            if (Data[i] >= 'A' && Data[i] <= 'Z') {
                Data[i] = Data[i] - 'A' + 'a';
            }
        }
    }
    NewString() { cout << "I am the NewString's constructor" << endl; }
};

int main() {
    NewString str;
    cout << "Input a string:" << endl;
    str.Input();
    str.Display();
    str.Reverse();
    cout << "After reverse:" << endl;
    str.Display();
    cout << "Compare with \"abcd1234\":" << endl;
    cout << str.Compare("abcd1234") << endl;
    str.Copy("Hello world!");
    cout << "After copy:" << endl;
    str.Display();
    str.ToUpper();
    cout << "After to upper:" << endl;
    str.Display();
    str.ToLower();
    cout << "After to lower:" << endl;
    str.Display();
    return 0;
}

输出结果：

I am the BaseString's constructor
I am the ReString's constructor
I am the CopyString's constructor
I am the CmpString's constructor
I am the NewString's constructor
Input a string:
Hello, world!
Hello, world!
After reverse:
!dlrow ,olleH
Compare with "abcd1234":
-11
After copy:
Hello world!
After to upper:
HELLO WORLD!
After to lower:
hello world!

在多重继承中，如果不使用虚基类，会出现多次继承同一个基类的情况，可能会导致数据重复或者函数调用混乱。通过将 BaseString 声明为虚基类，可以避免这种问题。在上述代码中，NewString 继承自 ReString、CopyString 和 CmpString 三个类，其中 CmpString 继承自虚基类 BaseString。