首页 > 其他分享 >2023年10月第四周题解------输入与输出

2023年10月第四周题解------输入与输出

时间：2023-10-29 21:25:54浏览次数：40  
标签：count 10 下标 int 题解 char person 2023 include

 

问题 A: ly喜欢玩石头

 

解题思路

  1. 题目告诉我们(1<=a,b <=1e9),那么int类型就够了。因为这两个数相加最大为20亿
  2. 定义两个变量a和b
  3. 输入a和b的值
  4. 打印a加b的值
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

int main(int argc,char *argv[])
{
    int a;//第一堆石头 
    int b;//第二堆石头 
    
    scanf("%d%d", &a, &b);//输入第一堆和第二堆石头的个数 
    
    printf("%d\n", a + b);//打印合并之后石头的个数 
    
    return 0;
}

 

 

问题 B: Hello World！

 

解题思路

  1. 调用printf函数打印字符串
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

int main(int argc,char *argv[])
{
    printf("Hello,World!");
    
    return 0;
}

 

问题 D: 找最小

解题思路

  1. 假设下标0是最小的，在输入的同时比较新进来的数和最小的谁更小，如果新进来的数小，就更新最小的下标，不是就继续输入下一个数
  2. 将最小的数与最后一个数进行交换
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#define N 10
 
void swap(int *a, int *b);//交换a和b中的值 
 
int main(int argc,char *argv[])
{
    int a[N];//存放10个数 
    int min = 0;//假设0下标是最小的，存放最小的下标 
     
    for (int i = 0; i < N; i++)  {//输入10个数 
        scanf("%d", a + i);//输入 
        if (abs(a[min]) > abs(a[i])) {//如果a[i]比最小的数还要小 
            min = i;//更新最小的下标 
        }
    }
     
    if (min != N - 1) {//只要最小的不是最后一个，就把最小的数和最后一个数交换 
        swap(&a[min], &a[N - 1]);
    }
     
    for (int i = 0; i < N; i++)  {//打印交换后的数组 
        printf("%d ", a[i]);
    }
     
    return 0;
}
void swap(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

 

 

问题 E: 统计个数

解题思路

  1. 定义一个count数组用来统计不同分数段的学生
  2. 输入分数
  3. 如果是大于0的数，判断在那个分数段，然后让对应的计数数组加1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

int main(int argc,char *argv[])
{
    int score;//存放成绩 
    int count[3] = {0}; //初始化计数数组 
    //count[0]代表>=85分段的
    //count[1]代表>=60 && <= 84分段的
    //count[2]代表>=1 && <=59分段的
    
    scanf("%d", &score);//输入成绩 
    
    while(score > 0) {//成绩合法 
        if ( score >= 85) {//成绩大于等于85 
            count[0]++;
        }
        else if (score >= 60) {//成绩大于等于60且小于等于84 
            count[1]++;
        }
        else {//成绩大于等于1且小于等于59 
            count[2]++;
        }
        
        scanf("%d", &score);//再次输入成绩 
    }

    printf(">=85:%d\n", count[0]);//打印>=85分段的人数 
    printf("60-84:%d\n", count[1]);//打印60分到84分的人数 
    printf("<60:%d", count[2]);//打印1分到59分的人数 
    
    return 0;
}

问题 F: 最大与最小

解题思路

  1. 要开辟一个有n个float元素的数组
  2. 假设下标0是最小和最大的，因为数组只有一个数时，下标0位置的数就是最大的也是最小的
  3. 给float数组赋值，每赋一次值之后和最大数比较，如果新的数比最大数还要大，就把最大的下标更新
  4. 如果新的数比最小的数还要小，更新最小的下标
  5. 重复3.4步知道输入完毕
  6. 输入完之后min指向最小的数，max指向最大的数
  7. 打印保留两位小数的最大数和最下数
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

int main(int argc,char *argv[])
{
    int n;//浮点数的个数 
    
    scanf("%d", &n);//输入浮点数的个数 
    
    float *p = (float*)malloc(sizeof(float) * n);//开辟n个float的空间，相当于float p[n]; 
    
    int min = 0;//假设下标0是最小的，用来存放最小的下标 
    int max = 0;//假设下标0是最大的 ，用来存放最大的下标 
    
    for (int i = 0; i < n; i++)//读入n个float的数 
    {
        scanf("%f", p + i);//输入 
        if ( p[min] > p[i] )//如果p[i]比p[min]还小 
        {
            min = i;//那么最小的就是i 
        }
        else if ( p[max] < p[i] ) {//如果p[i]比p[max]还大 
            max = i;//那么最大的就是i 
        }
    }
    
    printf("%.2f %.2f", p[max], p[min]);//打印保留2位小数的最大和最下值 
    
    return 0;
}

问题 G: 偶数判断

解题思路

  1. 输入一个数
  2. 判断它是不是偶数
  3. 是偶数打印true
  4. 不是偶数打印false

 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

int main(int argc,char *argv[])
{
    int n;
    
    scanf("%d", &n);//输入一个数 
    
    if (n % 2 == 0)//如果是偶数 
    {
        printf("true\n");//打印true
    }
    else //奇数 
    {
        printf("false\n");//打印false 
    }
    
    return 0;
}

问题 H: C语言实验题——鸡兔同笼(JSU-ZJJ)

解题思路

  1. 假设鸡的数量为x只，兔子的数量为y。那么兔子的数量就为总头的数量减去鸡的数量
  2. x从0开始到总的数量开始遍历，y = 总的数量  - x
  3. 判断鸡的脚和兔子的脚相加等不等于总的脚数
  4. 等于就输出鸡的数量和兔子的数量
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

int main(int argc,char *argv[])
{
    int headCount;//存放头的数量 
    int feetCount;//存放腿的数量 
    
    scanf("%d%d", &headCount, &feetCount);//输入头的数量，输入腿的数量 
    
    for (int i = 0; i <= headCount; i++)//i表示有几只鸡，那么headCount - i就是兔子的数量 
    {
        if (i * 2 + (headCount - i) * 4 == feetCount) {//如果鸡的脚和兔子的脚加起来满足腿的总数代表找到了 
            printf("%d %d\n", i, headCount - i);//打印鸡的数量和兔子的数量 
        }
    }
    
    return 0;
}

问题 I: 憨憨发牌员

解题思路

  1. 设置一个结构体,因为一张牌有花色和大小
  2. 读入庄家位置
  3. 设置第一个拿到牌的人
  4. 按顺序拿牌，直到没有牌了
  5. 按照大小进行排序
  6. 输出结果
#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

// 扑克牌结构体
typedef struct {
    char suit; // 花色：C、D、S、H
    char rank; // 牌面等级：2~9、T、J、Q、K、A
}Card;
char s[13] = { '2','3','4','5','6','7','8','9','T','J','Q','K','A' };//用来比较牌面大小的辅助数组

void sort(Card* person);//给一个人手中的牌排序
void p(void);//打印分隔符+---+---+---+---+---+---+---+---+---+---+---+---+---+
void printCard(Card* person);//打印一个人手中的牌
void printRank(Card* person);//打印一个人手中牌的牌面
void printSuit(Card* person);//打印一个手中牌的花色
void swap(Card* person, int i, int j);//交换一个人手中第i张牌和第j张牌交换位置
int find_index(char target);//在辅助数组s中找到牌面所对应的下标

int main(int argc, char* argv[])
{
    char c = 0;//庄家的位置
    Card person[4][13] = { 0 };//0代表北，1代表东，2代表南，3代表西 
    Card cur = { 0 };//从牌中拿的牌
    int m = 0;//表示拿牌的人
    int count[4] = { 0 };//表示每个人手上有几张牌

    scanf("%c", &c);//读入庄家的位置
    getchar();//处理掉在缓存区的换行，避免读到换行


    if (c == 'N')//如果庄家位置是北
    {
        m = 1;//第一个拿牌位置是东
    }
    else if (c == 'E')//如果庄家位置是东
    {
        m = 2;//第一个拿牌位置是南
    }
    else if (c == 'S')//如果庄家位置是南
    {
        m = 3;//第一个拿牌位置是西
    }
    else {//如果庄家位置是西
        m = 0;//第一个拿牌位置是北
    }


    while (count[0] + count[1] + count[2] + count[3] <= 51)//如果牌没有被拿完
    {
        scanf("%c%c", &cur.suit, &cur.rank);//从牌堆中读入
        person[m][count[m]].suit = cur.suit;//赋给拿牌的人
        person[m][count[m]].rank = cur.rank;
        count[m]++;//手中牌数加1
        m++;//下一个拿牌的人
        m %= 4;//如果这个人的位置是西了，那么他的下一个就是北，因此要模4[0, 3];
    }

    for (int i = 0; i < 4; i++) {//给每个人手中的牌排序
        sort(person[i]);
    }

    printf("South player:\n");
    printCard(person[2]);//打印在南方位置人的牌
        printf("West player:\n");
        printCard(person[3]);//打印在西方位置人的牌
        printf("North player:\n");
        printCard(person[0]);//打印在北方位置人的牌
        printf("East player:\n");
        p();//打印分隔符
        printRank(person[1]);//打印在东方位置人手中牌的牌面
        printSuit(person[1]);//打印在东方位置人手中牌的花色
        printRank(person[1]);//打印在东方位置人手中牌的牌面
        printf("+---+---+---+---+---+---+---+---+---+---+---+---+---+");//打印分隔符

    return 0;
}
void p(void)
{
    printf("+---+---+---+---+---+---+---+---+---+---+---+---+---+\n");
}
void printCard(Card* person)
{
    p();
    printRank(person);
    printSuit(person);
    printRank(person);
    p();
}
void printRank(Card* person)
{
    putchar('|');
    for (int i = 0; i < 13; i++) {
        printf("%c %c|", person[i].rank, person[i].rank);
    }
    putchar('\n');
}
void printSuit(Card* person)
{
    putchar('|');
    for (int i = 0; i < 13; i++) {
        printf(" %c |", person[i].suit);
    }
    putchar('\n');
}
void sort(Card* person)
{
    //按花色排序，用的是冒泡
    for (int i = 0; i < 12; i++) {
        for (int j = 0; j < 12 - i; j++) {
            if (person[j].suit == 'H') {//如果前一张的牌花色是最大的花色就交换
                swap(person, j, j + 1);
            }
            else if (person[j].suit == 'S' && 
                (person[j + 1].suit == 'D' || person[j + 1].suit == 'C')) 
                {//如果前一张的牌花色是第二大的花色，
                //且后面的花色没有前一张牌花色大，那么交换
                swap(person, j, j + 1);
                }
            else if (person[j].suit == 'D' && person[j + 1].suit == 'C') {//如果前一张牌的花色是第三大的
                //且后面的花色是最小的花色，那么交换
                swap(person, j, j + 1);
            }
        }
    }
    //按牌面排序，用的是冒泡
    for (int i = 0; i < 12; i++) {
        for (int j = 0; j < 12 - i; j++) {
            if (person[j].suit == person[j + 1].suit) {//通过辅助数组的下标来比较大小，下标越大，那么牌面就越大
                if (find_index(person[j].rank) > find_index(person[j + 1].rank)) {
                    swap(person, j, j + 1);
                }
            }
        }
    }
}
void swap(Card* person, int i, int j)
{
    char t = person[j].suit;
    person[j].suit = person[i].suit;
    person[i].suit = t;
    t = person[j].rank;
    person[j].rank = person[i].rank;
    person[i].rank = t;
}
int find_index(char target)
{
    for (int i = 0; i < 13; i++) {
        if (s[i] == target) {
            return i;
        }
    }
}

 

问题 J: acm社团欢迎你

解题思路

  1. 调用printf函数打印字符串
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

int main(int argc,char *argv[])
{
    printf("acm社团欢迎你");
    
    return 0;
}

 

标签：count,10,下标,int,题解,char,person,2023,include
From： https://www.cnblogs.com/lwj1239/p/17794319.html

相关文章

  • #2023-2024-1 20231408《计算机基础与程序设计》第五周学习总结
    作业信息这个作业属于哪个课程<2023-2024-1-计算机基础与程序设计>这个作业要求在哪里<2023-2024-1计算机基础与程序设计第五周作业>这个作业的目标<学会《计算机科学概论》第6章，《C语言程序设计》第4章，pep/9虚拟机>作业正文https://www.cnblogs.com/jfxyh0610......
  • 2023-2024 20231310《计算机基础与程序设计》第五周学习总结
    作业信息这个作业属于哪个课程2022-2023-1-计算机基础与程序设计这个作业要求在哪里2023-2024-1计算机基础与程序设计第5周作业这个作业的目标《计算机科学概论》第6章和《C语言程序设计》第4章作业正文教材学习内容总结《计算机科学概论》第六章1.机器......
  • 10.29日记
    从下往上依次是：物理层，数据链路层，网络层，传输层，会话层，表示层，应用层。   物理层：二进制数据传输，物理链路和物理特性相关。   数据链路层：将数据封装成帧进行传输，准确传送至局域网内的物理主机上。   网络层：数据分组传输和路由选择，能准确的将数据传输到互联网的主机上。  ......
  • 2023-2024-1 20211211 第四章读书笔记
    第四章读书笔记一、知识点归纳（思维导图）二、收获总结并行线程的主要挑战有：线程同步、死锁、资源竞争、上下文切换开销等问题。线程级别的并行是指在多核处理器上同时执行多个线程，每个线程独立执行不同的任务。指令级别的并行是指在单个核心的处理器上同时执行多条指令。并发......
  • 每日总结10.29
    今日完成了算术题的输出并且成功以csv形式储存。  代码：importcom.opencsv.CSVWriter;importjava.io.FileWriter;importjava.io.IOException;importjava.util.Random;importjava.util.ArrayList;importjava.util.List;importjava.util.Scanner;publicclasssuanshu......
  • 2023-2024-1 20231326 《计算机基础与程序设计》第五周周总结
    2023-2024-120231326《计算机基础与程序设计》第五周周总结目录2023-2024-120231326《计算机基础与程序设计》第五周周总结作业信息作业信息这个作业属于哪个课程2022-2023-1-计算机基础与程序设计这个作业的要求2022-2023-1计算机基础与程序设计第五周作业这......
  • NewStarCTF 2023 公开赛道 WEEK4|MISC 部分WP
    R通大残1、题目信息R通大残，打了99，补！2、解题方法仔细分析题目，联想到隐写的R通道。首先解释一下：R是储存红色的通道，通道里常见有R（红）、G（绿）、B（蓝）三个通道，如果关闭了R通道图片就没有红色的部分，G、B同理。因此我们想到R大残应该是不显示红色了，猜测结果就在R通道里，所以使用Stegsolv......
  • 学期2023-2024-1 20231409 《计算机基础与程序设计》第五周学习总结
    学期2023-2024-120231409《计算机基础与程序设计》第五周学习总结作业信息这个作业属于哪个课程2023-2024-1-计算机基础与程序设计这个作业要求在哪里2023-2024-1计算机基础与程序设计第五周作业这个作业的目标自学教材：计算机科学概论第6章，C语言程序设计第4章并完......
  • CSP-S 2023 消消乐
    洛谷传送门考虑dp，设\(f_i\)为以\(i\)结尾的合法子串个数。如果我们能对每个\(i\)，求出来\(g_i\)表示最大的左端点\(l\)使得\([l,i]\)是合法串，那么\(f_i=f_{g_i-1}+1\)。若\(g_i\)不存在则\(f_i=0\)。答案为\(\sum\limits_{i=1}^nf_i\)。考虑求\(g_......
  • 2023-2024-1 20231419 《计算机基础与程序设计》第五周学习总结
    2023-2024-120231419《计算机基础与程序设计》第五周学习总结作业信息这个作业属于哪个课程https://edu.cnblogs.com/campus/besti/2023-2024-1-CFAP这个作业要求在哪里https://www.cnblogs.com/rocedu/p/9577842.html#WEEK05这个作业的目标预习《计算机科学概......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99