week9 作业

最新推荐文章于 2022-11-19 01:45:38 发布
最新推荐文章于 2022-11-19 01:45:38 发布
阅读量100 收藏
点赞数
分类专栏： 程序设计思维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43761738/article/details/105800776
版权

文章目录

A-咕咕东的目录管理器

题目描述

咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零bug的操作系统 —— 这工程量太大了，所以他定了一个小目标，从实现一个目录管理器开始。前些日子，东东的电脑终于因为过度收到宇宙射线的影响而宕机，无法写代码。他的好友TT正忙着在B站看猫片，另一位好友瑞神正忙着打守望先锋。现在只有你能帮助东东！
初始时，咕咕东的硬盘是空的，命令行的当前目录为根目录 root。
目录管理器可以理解为要维护一棵有根树结构，每个目录的儿子必须保持字典序。

现在咕咕东可以在命令行下执行以下表格中描述的命令：
在这里插入图片描述

input
输入文件包含多组测试数据，第一行输入一个整数表示测试数据的组数 T （T <= 20）；
每组测试数据的第一行输入一个整数表示该组测试数据的命令总数 Q （Q <= 1e5）；
每组测试数据的 2 ~ Q+1 行为具体的操作 （MKDIR、RM 操作总数不超过 5000）；
面对数据范围你要思考的是他们代表的 “命令” 执行的最大可接受复杂度，只有这样你才能知道你需要设计的是怎样复杂度的系统。
output
每组测试数据的输出结果间需要输出一行空行。注意大小写敏感。
时空限制
Time limit 6000 ms
Memory limit 1048576 kB

样例

样例输入
1
22
MKDIR dira
CD dirb
CD dira
MKDIR a
MKDIR b
MKDIR c
CD ..
MKDIR dirb
CD dirb
MKDIR x
CD ..
MKDIR dirc
CD dirc
MKDIR y
CD ..
SZ
LS
TREE
RM dira
TREE
UNDO
TREE
样例输出
OK
ERR
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
OK
9
dira
dirb
dirc
root
dira
a
b
c
dirb
x
dirc
y
OK
root
dirb
x
dirc
y
OK
root
dira
a
b
c
dirb
x
dirc
y

思路分析

解决这个问题必然要维护一棵目录树，所以创建结构体Directory来存放当前目录名，子目录，上级目录，子树大小，当前节点的十个目录名，记录当前节点的子孙有无变动的bool变量。因为要求它的子目录是保持字典序的，所以要用map<string,目录>，每次可以用log级别的复杂度取到子目录。

另外在创建一个结构体存放当前命令的类型，并且考虑到，对于执行成功的操作要存起来以便撤销。

接下来就是细节的实现：

MKDIR：创建子目录并返回，失败返回空指针。

RM：删除子目录并返回，删除失败返回空指针。

CD：进入一个子目录，若是“…”时，返回上一级目录。

SZ：输出当前目录的大小Size

LS：当前Size为0时，目录为空，输出EMPTY；小于等于10的时候，全部输出；当当前子目录大于10个时，遍历输出前5个和输出后5个。

UNDO：撤销MKDIR,RM,CD三种操作，每次从保存执行成功命令的数组中取出一个命令。执行对应的相反的操作。

TREE：在后代节点数量大于10时，要开始前序遍历和后序遍历。并且对复杂度有要求！ 观察数据规模可以发现遍历很可能会超时，所以我们用到了（懒更新），节点数远少于TREE操作数，指不定还有重复询问，对于目录相同期间问过的相同问题，理应只有一次是计算过程。

AC代码

#include<iostream>
#include<cstdio>
#include<algorithm> 
#include<map>
#include<string>
#include<vector>
using namespace std;
char tmps[20];
struct Directory
{
 string name;//当前目录名
 map<string, Directory*> children;  
 Directory* parent;      //上级目录
 int Size;//子树大小
 vector<string>* tenDescendants;//保存当前节点的十个后代
 bool updated;       //记录当前节点的子孙有无变动，无变动则十个后代无需更新
 Directory(string theName, Directory* theParent) 
 {
  name =theName;
  parent = theParent;
  Size = 1;
  tenDescendants=new vector<string>; 
  updated=false; 
 } 
    Directory* getChild(string name) //取子目录并返回，不存在返回空指针
 {
  auto it=children.find(name);
  if (it==children.end()) 
      return nullptr;
  
  return it->second;
 }
 Directory* mkdir(string name) //创建子目录并返回，失败返回空指针
 {
  if (children.find(name) != children.end()) 
      return nullptr;   
  Directory* ch = new Directory(name, this);
  children[name] = ch;
  maintain(+1);
  return ch;
 } 
 Directory* rm(string name)  //删除子目录并返回,失败返回空指针
 {
  auto it = children.find(name);
  if (it == children.end()) 
      return nullptr;  
  maintain(-1 * it->second->Size);  
  children.erase(it);
  return it->second;
 }
 Directory* cd(string name) 
 {
  if (".." == name)   return this->parent;
  
  return getChild(name);
 }
 bool addChild(Directory* ch)//加入子目录并判断是否成功
 {
  if (children.find(ch->name) != children.end())
   return false;
   
  children[ch->name] = ch;
  maintain(+ch->Size);
  return true;
 }
 void sz() 
 {
  printf("%d\n", this->Size);
 }
 void ls() 
 {
  int sz=children.size();  
  if (sz==0) printf("EMPTY\n");
  else if(sz<=10)
  {
   for(auto& entry : children)
   {
    printf("%s\n", entry.first.c_str());
   } 
  } 
  else 
  {
   auto it=children.begin();
   for(int i=0;i<5;i++,it++)
   {
    printf("%s\n",it->first.c_str());
   } 
   printf("...\n");
   it=children.end();
   for(int i=0;i<5;i++) 
       it--;
       
   for(int i=0;i<5;i++,it++)
   {
    printf("%s\n", it->first.c_str());
   }
  }
 }
 void maintain(int delta) //向上维护子树大小
 {
  updated=true;
  Size=Size+delta;
  if(parent != nullptr)    parent->maintain(delta); 
 }
 void tree() 
 {
  if (Size == 1) printf("EMPTY\n");
  else if (Size <= 10) 
  {   
   if(this->updated) 
   {    
    tenDescendants->clear();    
    treeAll(tenDescendants);
    this->updated=false;
   }
   for(int i=0;i<Size;i++)   printf("%s\n", tenDescendants->at(i).c_str()); 
  }
  else 
  {   
   if(this->updated) 
   {
    tenDescendants->clear();
    treeFirstSome(5,tenDescendants);
    treeLastSome(5,tenDescendants);
    this->updated = false;
   }
   for(int i=0;i<5;i++)
   {
    printf("%s\n", tenDescendants->at(i).c_str()); 
   }
   printf("...\n");
   for (int i=9;i>=5;i--)
   {
    printf("%s\n", tenDescendants->at(i).c_str());
   }  
  }
 } 
private: 
 void treeAll(vector<string>* bar)  //更新全桶
 {  
  bar->push_back(name);
  for(auto &entry : children)
   entry.second->treeAll(bar); 
 }
 void treeFirstSome(int num, vector<string>* bar)//前序遍历并加入 前num个后代 
 {
  bar->push_back(name);
  if (--num == 0) return;
  int n=children.size();  
  auto it=children.begin();
  while(n--) 
  {
   int sts=it->second->Size;
   if (sts>=num) 
   {
    it->second->treeFirstSome(num, bar);
    return;
   }
   else 
   {
    it->second->treeFirstSome(sts, bar);
    num=num-sts;
   }
   it++;
  }
 }
 void treeLastSome(int num, vector<string>* bar)//后序遍历并加入 前num个后代  
 {
  int n=children.size();  
  auto it=children.end();
  while(n--) 
  {
   it--;
   int sts=it->second->Size;
   if (sts>=num) 
   {
    it->second->treeLastSome(num, bar);
    return;
   }
   else 
   {
    it->second->treeLastSome(sts, bar);
    num=num-sts;
   }
  }
  bar->push_back(name);
 }
};
struct Command
{
    const string CMDNAMES[7] = {"MKDIR","RM","CD","SZ","LS","TREE","UNDO"};
 int type;//命令的类型
 string arg;//命令的参数
 Directory* tmpDir;//记录刚刚操作的目录节点
 Command(string s) 
 {
  for(int i=0;i<7;i++)
  {
   if (CMDNAMES[i] == s) 
   {
    type = i;
    if(i<3)  //MKDIR、RM、CD的参数后续读入
    {
     scanf("%s",tmps);
     arg = tmps;
    }
    return;
   }
  } 
 } 
};
void solve()
{
 int n;
 scanf("%d",&n); 
 Directory *now = new Directory("root", nullptr);
 vector<Command*> cmdList;//新增加的数组  来存成功执行的命令以便UNDO 
 while (n--) 
 {
  scanf("%s",tmps);
  Command* cmd=new Command(tmps);
  switch (cmd->type)
  {
   case 0:{//MKDIR
    cmd->tmpDir=now->mkdir(cmd->arg);
    if(cmd->tmpDir==nullptr) printf("ERR\n");
    else 
    {
     printf("OK\n");
     cmdList.push_back(cmd);
    }
    break;
   }
   case 1:{//RM
    cmd->tmpDir = now->rm(cmd->arg);
    if (cmd->tmpDir == nullptr) printf("ERR\n");
    else 
    {
     printf("OK\n");
     cmdList.push_back(cmd);
    }
    break;
   }
   case 2:{//CD
    Directory * ch = now->cd(cmd->arg);
    if(ch==nullptr)  printf("ERR\n");
    else 
    {
     printf("OK\n");
     cmd->tmpDir=now;
     now=ch;
     cmdList.push_back(cmd);
    }
    break;
   }  
   case 3:{
    now->sz(); //SZ
    break;
   } 
   case 4:{
    now->ls(); //LS
    break;
   }
   case 5:{
    now->tree(); //TREE
    break;
   }
   case 6://UNDO
   {
    bool success=false;//记录undo执行是否成功
    while (!success && !cmdList.empty()) 
    {
     cmd=cmdList.back(); 
     cmdList.pop_back();
     switch(cmd->type)
     {
        //UNDO MKDIR 
      case 0:{
       success = now->rm(cmd->arg) != nullptr; 
       break;
      } 
      //UNDO RM
      case 1:{
       success = now->addChild(cmd->tmpDir); 
       break;
      }
      //UNDO CD
      case 2: {
       now = cmd->tmpDir; 
       success = true; 
       break;
      } 
     }
    }
    printf(success ? "OK\n" : "ERR\n");
   }  
  }
 }
 printf("\n");
}
int main()
{
 int T;
 scanf("%d",&T);
 while(T--) 
 {
  solve(); 
 }
 return 0; 
}

B-东东学打牌

题目描述

题面
最近，东东沉迷于打牌。所以他找到 HRZ、ZJM 等人和他一起打牌。由于人数众多，东东稍微修改了亿下游戏规则：

所有扑克牌只按数字来算大小，忽略花色。
每张扑克牌的大小由一个值表示。A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13。
每个玩家抽得 5 张扑克牌，组成一手牌！（每种扑克牌的张数是无限的，你不用担心，东东家里有无数副扑克牌）

理所当然地，一手牌是有不同类型，并且有大小之分的。
举个栗子，现在东东的 “一手牌”（记为 α），瑞神的 “一手牌”（记为 β），要么 α > β，要么 α < β，要么 α = β。
那么这两个 “一手牌”，如何进行比较大小呢？首先对于不同类型的一手牌，其值的大小即下面的标号；对于同类型的一手牌，根据组成这手牌的 5 张牌不同，其值不同。下面依次列举了这手牌的形成规则：

大牌：这手牌不符合下面任一个形成规则。如果 α 和 β 都是大牌，那么定义它们的大小为组成这手牌的 5 张牌的大小总和。
对子：5 张牌中有 2 张牌的值相等。如果 α 和 β 都是对子，比较这个 “对子” 的大小，如果 α 和 β 的 “对子” 大小相等，那么比较剩下 3 张牌的总和。
两对：5 张牌中有两个不同的对子。如果 α 和 β 都是两对，先比较双方较大的那个对子，如果相等，再比较双方较小的那个对子，如果还相等，只能比较 5 张牌中的最后那张牌组不成对子的牌。
三个：5 张牌中有 3 张牌的值相等。如果 α 和 β 都是 “三个”，比较这个 “三个” 的大小，如果 α 和 β 的 “三个” 大小相等，那么比较剩下 2 张牌的总和。
三带二：5 张牌中有 3 张牌的值相等，另外 2 张牌值也相等。如果 α 和 β 都是 “三带二”，先比较它们的 “三个” 的大小，如果相等，再比较 “对子” 的大小。
炸弹：5 张牌中有 4 张牌的值相等。如果 α 和 β 都是 “炸弹”，比较 “炸弹” 的大小，如果相等，比较剩下那张牌的大小。
顺子：5 张牌中形成 x, x+1, x+2, x+3, x+4。如果 α 和 β 都是 “顺子”，直接比较两个顺子的最大值。
龙顺：5 张牌分别为 10、J、Q、K、A。

作为一个称职的魔法师，东东得知了全场人手里 5 张牌的情况。他现在要输出一个排行榜。排行榜按照选手们的 “一手牌” 大小进行排序，如果两个选手的牌相等，那么人名字典序小的排在前面。
不料，此时一束宇宙射线扫过，为了躲避宇宙射线，东东慌乱中清空了他脑中的 Cache。请你告诉东东，全场人的排名。
input
输入包含多组数据。每组输入开头一个整数 n (1 <= n <= 1e5)，表明全场共多少人。
随后是 n 行，每行一个字符串 s1 和 s2 （1 <= |s1|,|s2| <= 10）， s1 是对应人的名字，s2 是他手里的牌情况。
output
对于每组测试数据，输出 n 行，即这次全场人的排名。

样例

样例输入
3
DongDong AAA109
ZJM 678910
Hrz 678910
样例输出
Hrz
ZJM
DongDong

思路分析

没什么好说的，就是要细心，因为几种情况代码都差不多，经常把一段复制到另一个地方后，忘记改一些细节的东西，WA了好几次

AC代码

#include<iostream>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
map<char,int> mp;
struct player
{
 string name;
 int card[5];
 int type,key1,key2,key3;
 player()
 {
  type=1;key1=0;key2=0;key3=0;
 }
 void clear()
 {
  type=1;key1=0;key2=0;key3=0;
 }
 bool operator < (const player& p) const 
 {
  if(type!=p.type) return type>p.type;
  if(key1!=p.key1) return key1>p.key1;
  if(key2!=p.key2) return key2>p.key2;
  if(key3!=p.key3) return key3>p.key3;
  return name<p.name;
 }
};
int n;
player p[100005];
bool judge1(int i)
{
 if(p[i].card[0]!=p[i].card[1]&&p[i].card[1]!=p[i].card[2]&&p[i].card[2]!=p[i].card[3]&&p[i].card[3]!=p[i].card[4])
 {
  p[i].key1=p[i].card[0]+p[i].card[1]+p[i].card[2]+p[i].card[3]+p[i].card[4];
  p[i].type=1;
  return true;
 }
 return false;
}
bool judge2(int i)
{
 if(p[i].card[0]==p[i].card[1])
 {
  p[i].key1=p[i].card[0];
  p[i].key2=p[i].card[2]+p[i].card[3]+p[i].card[4];
  p[i].type=2;
  return true;
 }
    if(p[i].card[1]==p[i].card[2])
 {
  p[i].key1=p[i].card[1];
  p[i].key2=p[i].card[0]+p[i].card[3]+p[i].card[4];
  p[i].type=2;
  return true;
 }
 if(p[i].card[2]==p[i].card[3])
 {
  p[i].key1=p[i].card[2];
  p[i].key2=p[i].card[0]+p[i].card[1]+p[i].card[4];
  p[i].type=2;
  return true;
 }
 if(p[i].card[3]==p[i].card[4])
 {
  p[i].key1=p[i].card[3];
  p[i].key2=p[i].card[2]+p[i].card[1]+p[i].card[0];
  p[i].type=2;
  return true;
 }
 return false;
}
bool judge3(int i)
{
 if(p[i].card[0]==p[i].card[1]&&p[i].card[2]==p[i].card[3])
 {
  p[i].key1=p[i].card[2];
  p[i].key2=p[i].card[0];
  p[i].key3=p[i].card[4];
  p[i].type=3;
  return true;
 }
 if(p[i].card[0]==p[i].card[1]&&p[i].card[3]==p[i].card[4])
 {
  p[i].key1=p[i].card[3];
  p[i].key2=p[i].card[0];
  p[i].key3=p[i].card[2];
  p[i].type=3;
  return true;
 }
 if(p[i].card[2]==p[i].card[1]&&p[i].card[3]==p[i].card[4])
 {
  p[i].key1=p[i].card[3];
  p[i].key2=p[i].card[1];
  p[i].key3=p[i].card[0];
  p[i].type=3;
  return true;
 }
 return false;
}
bool judge4(int i)
{ 
 if(p[i].card[0]==p[i].card[1]&&p[i].card[1]==p[i].card[2])
 {
  p[i].key1=p[i].card[0];
  p[i].key2=p[i].card[3]+p[i].card[4];
  p[i].type=4;
  return true;
 }
 if(p[i].card[3]==p[i].card[1]&&p[i].card[1]==p[i].card[2])
 {
  p[i].key1=p[i].card[1];
  p[i].key2=p[i].card[0]+p[i].card[4];
  p[i].type=4;
  return true;
 }
 if(p[i].card[3]==p[i].card[4]&&p[i].card[4]==p[i].card[2])
 {
  p[i].key1=p[i].card[2];
  p[i].key2=p[i].card[0]+p[i].card[1];
  p[i].type=4;
  return true;
 }
 return false;
}
bool judge5(int i)
{
 if(p[i].card[0]==p[i].card[1]&&p[i].card[1]==p[i].card[2]&&p[i].card[3]==p[i].card[4])
 {
  p[i].key1=p[i].card[0];
  p[i].key2=p[i].card[3]; 
  p[i].type=5;
  return true;
 }
 if(p[i].card[2]==p[i].card[3]&&p[i].card[3]==p[i].card[4]&&p[i].card[0]==p[i].card[1])
 {
  p[i].key1=p[i].card[2];
  p[i].key2=p[i].card[0]; 
  p[i].type=5;
  return true;
 }
 return false;
}
bool judge6(int i)
{
 if(p[i].card[0]==p[i].card[1]&&p[i].card[1]==p[i].card[2]&&p[i].card[2]==p[i].card[3])
 {
  p[i].key1=p[i].card[0];
  p[i].key2=p[i].card[4];
  p[i].type=6;
  return true;
 }
 if(p[i].card[4]==p[i].card[1]&&p[i].card[1]==p[i].card[2]&&p[i].card[2]==p[i].card[3])
 {
  p[i].key1=p[i].card[4];
  p[i].key2=p[i].card[0];
  p[i].type=6;
  return true;
 }
 return false;
}
bool judge7(int i)
{
 if(p[i].card[0]==(p[i].card[1]-1)&&p[i].card[1]==(p[i].card[2]-1)&&p[i].card[2]==(p[i].card[3]-1)&&p[i].card[3]==(p[i].card[4]-1))
 {
  p[i].key1=p[i].card[4];
  p[i].type=7;
  return true;
 }
 return false;
}
bool judge8(int i)
{
 if(p[i].card[0]==1&&p[i].card[1]==10&&p[i].card[2]==11&&p[i].card[3]==12&&p[i].card[4]==13)
 {
  p[i].type=8;
  return true;
 }
 return false;
}
int main()
{
 mp['A']=1;mp['J']=11;mp['Q']=12;mp['K']=13;
 while(cin>>n)
 {
  for(int i=0;i<n;i++)
     {
      p[i].clear();
     }
  string str;
     for(int i=0;i<n;i++)
       {
      cin>>p[i].name>>str;
      int flag=0;
      for(int j=0;j<5;j++)
      {
       if(str[flag]>'1'&&str[flag]<='9')
       {
        p[i].card[j]=str[flag]-'0';
       }
       else if(str[flag]=='1')
       {
        p[i].card[j]=10;
        flag++;
       }
       else
       {
        p[i].card[j]=mp[str[flag]];
       }
       flag++;
      }
      sort(p[i].card,p[i].card+5);
     } 
        for(int i=0;i<n;i++)
        {
      if(judge8(i)) continue;
      else if(judge7(i)) continue;
      else if(judge6(i)) continue;
      else if(judge5(i)) continue;
      else if(judge4(i)) continue;
      else if(judge3(i)) continue;
      else if(judge2(i)) continue;
      else 
      {
       judge1(i);
        } 
     }
     sort(p,p+n);
     for(int i=0;i<n;i++)
     {
      cout<<p[i].name<<endl;
     }
 } 
 return 0;
}

签到题

题目描述

DUQD 旁边的滨海公园有 x 条长凳。第 i 个长凳上坐着 a_i 个人。这时候又有 y 个人将来到公园，他们将选择坐在某些公园中的长凳上，那么当这 y 个人坐下后，记k = 所有椅子上的人数的最大值，那么k可能的最大值mx和最小值mn分别是多少。Input
第一行包含一个整数 x (1 <= x <= 100) 表示公园中长椅的数目
第二行包含一个整数 y (1 <= y <= 1000) 表示有 y 个人来到公园
接下来 x 个整数 a_i (1<=a_i<=100)，表示初始时公园长椅上坐着的人数

Output
输出 mn 和 mx

样例

Input Example3
7
1
6
1
Output Example
6 13

样例解释
最初三张椅子的人数分别为 1 6 1接下来来了7个人。
可能出现的情况为{1 6 8},{1,7,7},…{8,6,1}
相对应的k分别为8,7,…,8
其中，状态{1,13,1}的k = 13，为mx状态{4,6,5}和状态{5,6,4}的k = 6，为mn

思路分析

首先最多的情况肯定是所有人都坐在了原人数最多的椅子上，而最少的情况有可能等于原最多人数，如果在所有椅子的人数都等于原最多人数后，还有人没有坐下，则把剩下的人尽可能均分给所有椅子，此时的最大值则是最小的。

AC代码

#include<iostream>
#include<algorithm>
using namespace std; 
int main()
{
 int x,y;
 cin>>x>>y;
 int a[x];
 for(int i=0;i<x;i++)
 {
  cin>>a[i];
 }
 sort(a,a+x);
 int count=0,add=0;
 for(int i=0;i<x;i++)
 {
  count+=a[x-1]-a[i];
 }
 if(y>count)
 {
  count=y-count;
  while(count>0)
  {
   add++;
   count=count-x;
  }
 }
 cout<<a[x-1]+add<<" "<<a[x-1]+y<<endl;
 return 0;
}
rwyoi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
山东大学程序思维设计与实践week9
m0_73802120的博客
04-29 1134
【代码】山东大学程序思维设计与实践week9。
machine learning week9 作业答案
04-27
异常检测（Anomaly Detection），推荐系统（Recommender Systems）
WEEK9 JAVA作业
qq_40384004的博客
11-30 461
1:需求：递归删除带内容的目录 import java.io.File;   public class Homework1 { public static void main(String[] args) { File Folder = new File ("RNG6"); Delete(Folder); } private static void Delete(File
Java程序设计 北京大学 Week9互评作业
nonlinearthink的博客
05-16 1287
public class WordsFile { String path="F:/java/HelloWeb/src/EnglishWords/words.txt"; File file= new File(path); String str; public ArrayList<String> getfile() throws IOException { BufferedReader in=new BufferedReader(new Inp
week5作业题
qq_41213748的博客
01-03 228
实现注册、登录功能。 某用户先注册，注册信息包括用户名、密码、个人格言。 然后使用注册的信息登录，如果登录成功，则显示个人信息； 否则显示“登录失败”。 package login; import java.util.ArrayList; import java.util.Scanner; public class LoginDemo { public static void
ML WEEK1 作业
qq_43637099的博客
12-06 141
整理了一下第一周的作业 这题答错了, 呜呜
week4滴作业
zpfhhh的博客
11-19 767
week4滴作业
week2-day6作业
weixin_51426009的博客
05-29 100
Description 输入一个整型数，判断是否是对称数，如果是，输出yes，否则输出no，不用考虑这个整型数过大，int类型存不下，不用考虑负值； 例如 12321是对称数，输出yes，124421是对称数，输出yes，1231不是对称数，输出no Input 一个整型数 Output 输出是yes，或者no Sample Input 1 12321 Sample Output 1 yes Sample Input 2 1231 Sample Output ..
Week6作业
u013782717的专栏
04-08 356
/*zuo ye */ #include "stdio.h" main() { int i; scanf("%d",&i); if(i>-1&&i<10) printf("ok"); else printf("not ok"); }
week7晚作业
u013797365的专栏
04-08 462
#include "stdio.h" main() { int a[4][5]; int x,y; for(x=0;x<4;x++) { for(y=0;y<5;y++) { scanf("%d",&a[x][y]); } } for(y=0;y<5;y++) { for(x=0;x<4;x++) {
week4-day10作业
weixin_51426009的博客
05-30 167
week4-day10作业 Description 输入一个整型数，存入变量i，通过子函数change把主函数的变量i除2，然后打印i，例如如果输入的为10，打印出5，如果输入的为7，打印出3 Input 一个整型数 Output 对应整型数除2后的商 Sample Input 1 10 Sample Output 1 5 Sample Input 2 7 Sample Output 2 3 #include <stdio.h> void..
程序设计思维与实践 Week9 作业 B 东东学打牌
01-06
A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13。 每个玩家抽得 5 张扑克牌，组成一手牌！（每种扑克牌的张数是无限的，你不用担心，东东家里有无数副扑克牌） ...
Week3作业
02-09
Week3作业
作业week011
08-08
在软件开发领域，软件过程模型和软件体系结构设计原则是两个关键的概念，它们对软件项目的成功至关重要。下面将详细介绍这两个方面。 首先，我们来看软件过程模型。软件过程模型描述了软件开发的不同阶段及其顺序，...
Week2家庭作业
02-12
Week2家庭作业
Dijkstra算法的详细介绍
最新发布
06-28
dijkstra算法
Matlab通信原理-QPSK数字通信系统的仿真
06-28
信源为随机产生的0/1序列; 8倍过采样;画出发送序列时域波形和频谱。 进行根升余弦成型滤波，画出滤波后的时域波形及频谱图。 信道加入高斯白噪声:接收端匹配滤波，下采样后判决。画出接收端各处的时域波形和频谱。 改变信号和噪声功率的相对大小，观察并分析误码率的变化。画出误码率随信噪比变化的曲线。 详见：https://mp.weixin.qq.com/s/v91q-ruSoYmBVeqtis34tw
搜索引擎 PHP源码 免费开源
06-28
搜索引擎开源 易搜是一个性能极佳的搜索引擎，免费开源 易搜采用自主研发的 BiuSQL 数据库储存数据，不需要安装数据库，下载源码解压缩即可使用 项目文件结构 > ./css -文件夹-储存CSS渲染资源<br> ./help -文件夹-易搜的使用帮助和申明事件<br> ./img -文件夹-用来储存易搜图片文件<br> ./js -文件夹-储存JavaScript脚本资源<br> ./s -文件夹-易搜搜索功能核心算法<br> ./console -文件夹-易搜控制台<br> ./备份 -文件夹-易搜开发以及版本备份储存<br> ./index.php -文件-易搜首页初始化文件<br> ./verification.html -文件-易搜验证以及防攻击文件<br> ./项目结构 -文件-项目结构文件<br>
机器学习作业基于 Python 的历史照片EXIF元数据 GIS机器学习分析源码+项目说明.zip
06-28
机器学习作业基于 Python 的历史照片EXIF元数据 GIS机器学习分析源码+项目说明.zip 机器学习作业基于 Python 的历史照片EXIF元数据 GIS机器学习分析源码+项目说明.zip 机器学习作业基于 Python 的历史照片EXIF元数据 GIS机器学习分析源码+项目说明.zip 适用目标：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。
WEEK3|CRYPTO
10-20
WEEK3|CRYPTO是指加州大学伯克利分校开设的一门加密学课程，旨在介绍加密学的基本概念和技术，包括对称加密、公钥加密、哈希函数、数字签名等内容。该课程由加密学专家David Wagner教授主讲，通过在线视频、课程笔记...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

rwyoi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值