提示用户输入任意一个 int 类型范围的正整数，统计其中每个数字出现次数并打印。(提 示:巧用index(下标))如:输入:1324352 输出:1出现1次，2出现2次，3出现2次，4出现1次，5出现1次

你可以使用Python编写一个简单的程序来完成这个任务。下面是一个示例：

def count_digits():
    # 获取用户输入的字符串
    user_input = input("请输入一个只包含正整数的字符串: ")

    # 创建一个空字典来存储每个数字及其出现次数
    digit_counts = {}

    # 遍历输入的每一个字符，如果它是数字，就更新计数
    for char in user_input:
        if char.isdigit():  # 检查字符是否是数字
            num = int(char)  # 转换为整数
            if num in digit_counts:
                digit_counts[num] += 1
            else:
                digit_counts[num] = 1

    # 打印每个数字及其出现次数
    for digit, count in digit_counts.items():
        print(f"{digit}出现{count}次")

# 调用函数
count_digits()

当你运行此程序并输入像 "1324352" 这样的字符串时，它会按照提示计算并打印出每个数字及其出现的次数。

相关问题

java提示用户输入任意一个 int 类型范围的正整数，统计其中每个数字出现次数并打印。(提 示:巧用index(下标))如:输入:1324352 输出:1出现1次，2出现2次，3出现2次，4出现1次，5出现1次

在Java中，你可以使用`Scanner`类获取用户的输入，并创建一个HashMap来存储每个数字及其出现次数。遍历输入字符串，通过`indexOf`方法找到每个字符的位置，然后更新HashMap中的计数。下面是一个简单的例子：

import java.util.HashMap;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数序列：");
        
        String input = scanner.nextLine(); // 获取用户输入
        HashMap<Character, Integer> countMap = new HashMap<>();
        
        for (int i = 0; i < input.length(); i++) { // 遍历输入的每一个字符
            char digit = input.charAt(i); // 获取当前数字
            if (countMap.containsKey(digit)) { // 如果已存在于map中，则加一
                countMap.put(digit, countMap.get(digit) + 1);
            } else { // 否则添加到map中，初始值为1
                countMap.put(digit, 1);
            }
        }

        System.out.println("每个数字出现次数：");
        for (Map.Entry<Character, Integer> entry : countMap.entrySet()) {
            System.out.format("%c 出现了 %d 次", entry.getKey(), entry.getValue());
        }
    }
}

请编写程序，将 n 个整数顺次插入一个初始为空的单链表的表头。随后对任意给定的位序 i，删除链表中第 i 个结点。注意：i 代表位序，从 1 开始。删除结束后，输出链表长度，并顺序输出链表中的每个结点的数值。 输入格式： 输入首先在第一行给出正整数 n（≤10 4 ）；随后一行给出 n 个 int 范围内的整数，数字间以空格分隔；最后一行给出删除位序 i，为 int 范围内的整数。 输出格式： 如果删除的位置不合法，则不能删除，在一行中输出句子 错误：删除位置不合法。。无论是否删除成功，都按照题面描述的要求，在一行中输出链表信息，格式为： 表长: x1 x2 ... xn 注意数字间有 1 个空格分隔，行首尾无多余空格。 输入样例 1： 5 1 2 3 4 5 3 输出样例 1：

<<
为了实现这个功能，我们需要使用单链表的数据结构，并且要确保我们能够正确地进行节点的插入和删除操作。我们将从以下几个方面来介绍这个问题的解决方案：

1. **定义链表节点**：创建一个包含数据成员 `data` 和指针成员 `next` 的结构体。
2. **初始化链表**：创建一个指向头部的指针，并将其初始化为 `nullptr` 表示初始状态为空链表。
3. **插入元素到表头**：每次新添加的元素都将作为新的头部节点并更新链表头指针。
4. **处理输入与输出**：
- 首先读取 n 以及接下来的 n 个整数，依次将它们插入至列表开头；
- 接着尝试根据用户指定的位置执行删除操作 (检查位置有效性)；
- 最后打印出当前链表的内容及其长度。

下面是完整的 C++ 实现代码:

#include <iostream>
using namespace std;

// 定义链表节点结构体
struct ListNode {
    int data;
    ListNode* next;
};

class SinglyLinkedList {
public:
    // 构造函数, 初始化空链表
    SinglyLinkedList() : head(nullptr), size(0) {}

    ~SinglyLinkedList();                    // 析构函数

    void insertAtHead(int value);           // 在表头插入新值
    bool removeAtIndex(int index);          // 移除索引处的项
    void printListInfo() const;             // 打印链表信息
    
private:
    ListNode *head;                         // 指向第一个节点的指针
    int size;                               // 记录链表大小
};

void SinglyLinkedList::insertAtHead(int value){
    // 创建一个新的节点
    ListNode* newNode = new ListNode{value, nullptr};
    
    if (!this->head){                       // 如果是第一次插入（即原本是空链表）
        this->head = newNode;
    } else {                                // 否则将新节点设置为首部节点并将旧首部连接在其后面
        newNode->next = this->head;
        this->head = newNode;
    }
    ++size;                                 // 更新链表尺寸计数器
}

bool SinglyLinkedList::removeAtIndex(int index){
    if(index <= 0 || index > size)
        return false;                       // 删除失败:无效参数

    --size;                                 // 提前减少链表尺寸计算器，因为成功移除了项目
                                            // 下面逻辑保证至少有一个元素存在时才继续操作
    if (index == 1 && this->head != nullptr){// 特殊情况——当我们要移除的是首个也是唯一的一个节点
        delete this->head;
        this->head = nullptr;
        return true;
    }

    ListNode *prevNode = nullptr,
            *currentNode = this->head;

    for(int currentIndex=1 ; currentNode!=nullptr && currentIndex<index ; ++currentIndex){
        prevNode=currentNode;
        currentNode=currentNode->next;
    }

    if(currentNode==nullptr)// 若到达了末尾但还没找到目标节点说明删除失败
       return false;

    prevNode->next=currentNode->next;// 修改先前节点指向下一个节点绕过待删节点形成断开后的链接关系
    delete currentNode;              // 清理内存释放掉已经不再使用的原节点空间避免泄漏风险
    return true;                     // 成功完成任务返回真标记此次调用有效果非空闲
}

void SinglyLinkedList::printListInfo()const{
    cout << "表长:" ;
    if(head == nullptr){
         cout << endl;
         return;
     }
     
    ListNode* current = this->head;
    while(current != nullptr){
        cout << ' ' << current->data;
        current = current -> next;
    }
    cout << '\n';
}
  
SinglyLinkedList::~SinglyLinkedList(){
    ListNode *temp;
    while(this->head != nullptr){
        temp = this->head;
        this->head = this->head->next;
        delete temp;
    }
} 

int main()
{
    int numElements, targetIndex;
    cin >> numElements;

    SinglyLinkedList list;

    for (int i = 0; i < numElements; ++i) {
        int element;
        cin >> element;
        list.insertAtHead(element);
    }

    cin >> targetIndex;

    if(!list.removeAtIndex(targetIndex))
      cout<<"错误：删除位置不合法。\n";

    list.printListInfo();

    return 0;
}

该段落解释了如何构建所需的单向链表及其实现细节，并提供了具体的C++代码实例以满足题目要求的功能需求。