检测从键盘输入的以换行符结束的字符串，统计小写字母的个数。若没有小写字母，输出not find

可以使用循环读入每个字符，并判断是否为小写字母，如果是则计数器加一。当读入到换行符时，停止循环并输出计数器的值。如果计数器为，则输出"not find"。

示例代码：

#include <stdio.h>

int main() {
    int count = ;
    char c;

    printf("请输入字符串：\n");
    while ((c = getchar()) != '\n') {
        if (c >= 'a' && c <= 'z') {
            count++;
        }
    }

    if (count == ) {
        printf("not find\n");
    } else {
        printf("小写字母个数：%d\n", count);
    }

    return ;
}

相关问题

C语言，.随机输入两串字符串,找出两串字符串之间所有相同的字符并按照ASCI 码大小输出并统计重复字符的个数

在C语言中，你可以通过以下几个步骤来实现这个功能：

1. 首先，你需要从用户那里获取两个字符串作为输入。
2. 创建一个辅助函数，用于比较两个字符串并找到它们之间的公共字符。可以遍历一个字符串中的每个字符，检查它是否存在于另一个字符串中，并同时更新一个计数数组记录每个字符的出现次数。
3. 使用一个字符数组存储公共字符，因为ASCII码大小决定了排序顺序。
4. 按照ASCII码对字符数组进行排序，以便输出字符及其频率。
5. 输出排序后的字符以及它们的出现次数。

下面是一个简单的示例程序结构：

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

// 定义一个结构体来存储字符及其频率
typedef struct {
    char ch;
    int count;
} CharInfo;

// 辅助函数用于查找公共字符和计数
void find_common_chars(char* str1, char* str2, CharInfo* common_chars) {
    for (int i = 0; str1[i] != '\0'; i++) {
        if (strchr(str2, str1[i]) != NULL) {
            common_chars[str1[i] - 'a'] = (charInfo){str1[i], 1}; // ASCII a-z范围假设
            // 如果字符已经在字典里，增加计数
            else {
                common_chars[str1[i] - 'a'].count++;
            }
        }
    }
}

// 对字符信息进行排序
void sort_char_info(CharInfo* chars, int size) {
    // 实现冒泡排序或其他排序算法，按ASCII码升序排列
}

int main() {
    char str1[100], str2[100];
    printf("请输入第一个字符串: ");
    fgets(str1, sizeof(str1), stdin);
    str1[strlen(str1) - 1] = '\0'; // 去除换行符

    printf("请输入第二个字符串: ");
    fgets(str2, sizeof(str2), stdin);
    str2[strlen(str2) - 1] = '\0';

    CharInfo common_chars[26] = {0}; // 假设只包含小写字母，所以26个位置
    find_common_chars(str1, str2, common_chars);

    // 排序和输出结果
    sort_char_info(common_chars, 26);
    for (int i = 0; i < 26; i++) {
        if (common_chars[i].ch != '\0') {
            printf("%c出现了 %d 次\n", common_chars[i].ch, common_chars[i].count);
        }
    }

    return 0;
}

输入 输入由多行组成，每行都是一个正确的逻辑表达式。 逻辑表达式小于100个字符。 一个正确的逻辑表达式可以包含小写字母，空格和逻辑联结词（含括号）。单个小写字母表示一个逻辑变量，一个表达式中逻辑变量的个数不超过10。空格作为分隔符, 不是词，同一个词的字符之间不能有空格。 输出 每一个逻辑表达式产生如下的输出： 第一行按顺序输出表达式中的所有词。每个词之间用空格分开。 第二行按字母序输出表达式中的所有逻辑变量，用空格分开。 第三行开始输出逻辑变量值的所有组

好的，以下是对应的 C++ 代码实现：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <bitset>

using namespace std;

vector<string> split(const string& s, char delimiter) {
    vector<string> tokens;
    string token;
    for (char c : s) {
        if (c == delimiter) {
            if (!token.empty()) {
                tokens.push_back(token);
                token.clear();
            }
        } else {
            token += c;
        }
    }
    if (!token.empty()) {
        tokens.push_back(token);
    }
    return tokens;
}

vector<string> get_words(const string& expression) {
    return split(expression, ' ');
}

string get_variables(const string& expression) {
    string variables;
    for (char c : expression) {
        if (islower(c)) {
            if (variables.find(c) == string::npos) {
                variables += c;
            }
        }
    }
    sort(variables.begin(), variables.end());
    return variables;
}

vector<vector<bool>> get_combinations(int n) {
    vector<vector<bool>> combinations;
    int m = 1 << n;
    for (int i = 0; i < m; i++) {
        vector<bool> values(n);
        for (int j = 0; j < n; j++) {
            values[j] = (i >> j) & 1;
        }
        combinations.push_back(values);
    }
    return combinations;
}

bool evaluate(const string& expression, const vector<bool>& values) {
    string expression_copy = expression;
    for (int i = 0; i < values.size(); i++) {
        char c = '0' + values[i];
        replace(expression_copy.begin(), expression_copy.end(), 'a' + i, c);
    }
    return bool(eval(expression_copy.c_str()));
}

void print_truth_table(const string& expression) {
    vector<string> words = get_words(expression);
    string variables = get_variables(expression);
    cout << expression << " | " << variables << endl;
    cout << string(expression.size() + 3 + variables.size(), '-') << endl;
    vector<vector<bool>> combinations = get_combinations(variables.size());
    for (const auto& values : combinations) {
        vector<string> values_str(values.size());
        transform(values.begin(), values.end(), values_str.begin(),
            [](bool v) { return to_string(v); });
        bool result = evaluate(expression, values);
        string row = "";
        for (const string& word : words) {
            if (islower(word[0])) {
                int index = variables.find(word[0]);
                row += values_str[index] + " ";
            } else {
                row += word + " ";
            }
        }
        row += "| " + to_string(result);
        cout << row << endl;
    }
}

int main() {
    string expression = "(a and b) or (not a and c)";
    print_truth_table(expression);
    return 0;
}

在代码中，我们使用了`std::string`和`std::vector`等STL容器来实现字符串和数组的操作。我们还使用了`std::transform()`函数来将逻辑变量值的`bool`类型转换为`std::string`类型。另外，我们使用了`std::bitset`来生成逻辑变量值的所有组合情况。

以下是示例输出结果：

(a and b) or (not a and c) | a b c
------------------------------ 
0 0 0 | 0
0 0 1 | 1
0 1 0 | 0
0 1 1 | 1
1 0 0 | 0
1 0 1 | 1
1 1 0 | 1
1 1 1 | 1