工作室课题

已于 2022-03-20 23:39:31 修改
阅读量1k 收藏
点赞数
文章标签： python c++
于 2022-03-20 23:26:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51468986/article/details/123623261
版权

练习

前10名

问题描述：
数据很多，但我们经常只取前几名，比如奥运只取前3名。现在我们有n个数据，请按从大到小的顺序，输出前10个名数据。
输入要求：
两行。
第一行一个整数n，表示要对多少个数据
第二行有n个整数，中间用空格分隔。表示n个数据。
输出要求：
一行，按从大到小排列的前10个数据，每个数据之间用一个空格隔开。
Sample Input 1
26
54 27 87 16 63 40 40 22 61 6 57 70 0 42 11 50 13 5 56 7 8 86 56 91 68 59
Sample Output 1
91 87 86 70 68 63 61 59 57 56
HINT:时间限制：1.0s 内存限制：256.0MB
10<=n<=200,各个整数不超出整型范围
代码python

n = int(input())
li = list(map(int, input().split()))//先转换成list，然后利用map函数进行输入，split()函数是以口号里的内容作为分隔符取字符串，不写着默认为空格
li.sort(reverse=True)
for i in range(0,10):
    print(li[i],end=" ")

身份证排序

问题描述：
安全局搜索到了一批(n个)身份证号码，希望按出生日期对它们进行从大到小排序，如果有相同日期，则按身份证号码大小进行排序。身份证号码为18位的数字组成，出生日期为第7到第14位
输入要求：
第一行一个整数n，表示有n个身份证号码
余下的n行，每行一个身份证号码。
输出要求:
按出生日期从大到小排序后的身份证号，每行一条
Sample Input 1
5
466272307503271156
215856472207097978
234804580401078365
404475727700034980
710351408803093165

Sample Output 1
404475727700034980
234804580401078365
215856472207097978
710351408803093165
466272307503271156

HINT:时间限制：1.0s 内存限制：256.0MB
n<=100000
代码python

def myg(b)://函数myg用来排序全部身份证号
    return int(b)
def myf(b)://函数myf用来排序生日
    return int(b[6:14])//截断的时候需要注意，左闭右开
n=int(input())
a=[input() for i in range(n)]//循环输入
a.sort(key=myg,reverse=True)
a.sort(key=myf,reverse=True)//sort中reverse = True降序，reverse = False 升序（默认）
for i in range(n):
    print(a[i],end="\n")

班级排名

问题描述：
达达在陶陶的影响下，也对学习慢慢的产生了兴趣。
他在每次考试之后，都会追着老师问，自己在班级的总名次是多少。考试一多，老师也不耐烦了，于是他给了达达所有人的成绩，让他自己去算出自己的排名。
可人太多了，达达也无法立即算出来，于是他想让你帮帮他。
输入要求
第一行为一个整数N，代表班级的学生总数。
接下来N行，每行一个字符串，代表一个学生的姓名，第一行总是DaDa。
接下来一行一个整数M，代表一共有M次考试。
每次考试有N行，每行有以一个空格分隔的一个正整数S和一个字符串P，代表名字为P的学生在这次考试中得了S分。
输出要求：
一共M行，每行一个整数，代表达达在班级里的排名，排名是这一次考试过后的所有考试总分排名，如果达达和别人并列，达达总是排在前面。
Sample Input 1
3
DaDa
A
B
2
49 DaDa
49 A
48 B
80 A
85 B
83 DaDa

Sample Output 1
1 2

HINT:时间限制：1.0s 内存限制：256.0MB
代码python

from operator import itemgetter

N = eval(input())//保证输入的为数字

Stu = {}//新建一个字典，用于存储学生姓名和分数
for i in range(N):
    Stu[input()] = 0

M = eval(input())

for i in range(M):
    for k,v in Stu.items()://键值都进入循环
        tmp = input().split()
        if tmp[1] not in Stu://不在，则直接赋值
            Stu[tmp[1]] = int(tmp[0])
        else:
            Stu[tmp[1]] += int(tmp[0])

    test = []

    for k, v in Stu.items():
        if k == 'DaDa':
            test.append([v, k, 1])
        else:
            test.append([v, k ,0])

    test.sort(key = itemgetter(0,2),reverse=True)
    for j in range(N):
        if 'DaDa' in test[j]:
            print(j+1)

冒泡排序

问题描述：
考虑冒泡排序的一种实现。
bubble-sort (A[], n)

round = 0
while A is not sorted

round := round + 1
for i := 1 to n - 1

if (A[i] > A[i + 1])

swap(A[i], A[i + 1])
求1 … n的排列中，有多少个排列使得A被扫描了K遍，亦即算法结束时round == K。
答案模20100713输出。

输入要求:
输入包含多组数据。每组数据为一行两个整数N，K。
输出要求：
对每组数据，输出一行一个整数表示答案
Sample Input 1
3
3 0
3 1
3 2
Sample Output 1
1
3
2

HINT:时间限制：1.0s 内存限制：256.0MB
T <= 10 ^ 5。
1 <= K < N < 10 ^ 6。
代码c++

#include <cstdio>
#include <iostream>
using namespace std;
const int mod = 20100713;
typedef long long ll;
const int N = 1e6+10;
ll f[N];
ll quick(ll a,ll n){
 ll ans = 1;
 while(n){
  if(n&1) ans = (ans*a)%mod;
  a = (a*a)%mod;
  n>>=1;
 }
 return ans;
} 

void init(){
 f[0] = f[1] = 1;
 for(int i = 2;i <= N-10;i++){
  f[i] = (f[i-1]*i)%mod;
 }
}
int main(){
 init();
 int t;scanf("%d",&t);
 ll n,k;
 while(t--){
  scanf("%lld%lld",&n,&k);
  ll ans = (f[k]*(quick(k+1,n-k)-quick(k,n-k)+mod)%mod)%mod;
  printf("%lld\n",ans);
 }
 return 0;
}

士兵排队

问题描述：
有Ｎ个士兵(1≤Ｎ≤26)，编号依次为Ａ,Ｂ,Ｃ,…，队列训练时，指挥官要把一些士兵从高到矮一次排成一行，但现在指挥官不能直接获得每个人的身高信息，只能获得“P1比P2高”这样的比较结果(P1、P2∈Ａ,Ｂ,Ｃ,…,Ｚ,记为 P1>P2)，如”Ａ>Ｂ”表示Ａ比Ｂ高。
请编一程序，根据所得到的比较结果求出一种符合条件的排队方案。
（注：比较结果中没有涉及的士兵不参加排队）
输入要求：
比较结果从文本文件中读入（文件由键盘输入），每个比较结果在文本文件中占一行。
输出要求：
若输入数据无解，打印“No Answer!”信息，否则从高到矮一次输出每一个士兵的编号，中间无分割符，并把结果写入文本文件中，文件由键盘输入：
Sample Input 1
A>B
B>D
F>B
F<A
Sample Output 1
AFBD

HINT:时间限制：1.0s 内存限制：256.0MB
代码c++

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<set>
using namespace std;
//为拓扑排序
bool A[26];
set<int> out[26]; 
set<int> IN[26];  
int main()
{
    char a,b,c;
    while(cin>>a>>b>>c)
    {
        out[a - 'A'].insert(c - 'A');
        IN[c -'A'].insert(a - 'A');
        A[a - 'A'] = true;
        A[c - 'A'] = true;
    }   
    queue<int> q;
    for(int i=0;i<26;i++)
        if(IN[i].size() == 0 && A[i])   //把所有入度为0的点都入队
            q.push(i);
    char AN[26];
    int k = 0;
    while(! q.empty())
    {
        int j = q.front();
        set<int>::iterator it;
        for(it = out[j].begin();it!=out[j].end();it++)
        {
            int to = *it;       
            IN[to].erase(j);   //删除该点和他连的边
            if(IN[to].size()==0)
                q.push(to);
        }
        out[j].clear();   
        AN[++k] = (char) j + 'A';
        q.pop();
    }

    int i;
    for(int i=0;i<26;i++)
    {
        if(IN[i].size() > 0)
        {
            puts("No Answer!");
             return 0;
        }
    }
    for(int i=1;i<=k;i++) printf("%c",AN[i]);
}

测试

输如输出练习

问题描述：
按格式读入一个3位的整数、一个实数、一个字符 。
并按格式输出 一个整数占8位左对齐、一个实数占8位右对齐、一个字符 ，并用|隔开。
Sample Input 1
123456.789|a
Sample Output 1
123|456.8|a
代码c++

#include<stdio.h>
#include<iostream>
using namespace std;
int main()
{
    char a,b,c,d,e;
    double g;
    scanf("%c%c%c%lf%c%c",&a,&b,&c,&g,&d,&e);
    printf("%-8d|%8.1lf|%c",(a-'0')*100+(b-'0')*10+(c-'0'),g,e);//-为左对齐
    return 0;
}

3000米预测

问题描述：
3000米长跑时，围观党们兴高采烈地预测着最后的排名。因为他们来自不同的班，对所有运动员不一定都了解，于是他们分别对自己了解的一些运动员的实力作出了评估，即对部分运动员做了相对排名的预测，并且告诉了可怜留守的班长。因为无聊，于是他们就组团去打Dota去了。比赛结束后他们向班长询问最后的排名，但班长不记得了，只记得他们中哪些人的预测是正确的，哪些人的预测是错误的。他们想知道比赛的排名可能是什么。
输入要求：
第一行两个整数n， m，n为运动员数量，m为围观党数量。运动员编号从0到n-1。
接下来m行，每行为一个围观党的相对排名预测。每行第一个数c表示他预测的人数，后面跟着c个0~n-1的不同的数，表示他预测的运动员相对排名，最后还有一个数，0表示这个预测是错误的，1表示是正确的。
输出要求：
第一行一个数k为有多少种排名的可能。
下面k行，每行一个0~n-1的排列，为某一个可能的排名，相邻的数间用空格隔开。所有排名按字典序依次输出。
Sample Input 1
3 2
2 0 1 1
2 1 2 0
Sample Output 1
2
0 2 1
2 0 1
Sample Input 2
3 2
2 0 1 1
2 2 1 0
Sample Output 2
1
0 1 2

HINT:时间限制：1.0s 内存限制：256.0MB
1<=n<=10, 2<=c<=n, 1<=m<=10，保证数据合法，且答案中排名可能数不超过20000。对于一个排名序列，一个预测是正确的，当且仅当预测的排名的相对顺序是排名序列的一个子序列。一个预测是错误的，当且仅当这个预测不正确。
代码c++

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<stdlib.h>
using namespace std;
int str[15][15];
int ctr[15];
bool use[15];
int graph[20001][15];
int Size;
int m,n;
int Judge()
{
    int f_1=1;
    int f_2=1;
    for(int i=0; i<m; i++)
    {
        if(str[i][str[i][0]+1]==1&&f_1)
        {
            int j=1;
            for(int x=0; j<=str[i][0]&&x<n; x++)
            {
                if(str[i][j]==ctr[x])
                    j++;
            }
            if(j<str[i][0]+1)
                f_1=0;
        }
        else
        {
            int j=1;
            for(int x=0; j<=str[i][0]&&x<n; x++)
            {
                if(str[i][j]==ctr[x])
                    j++;
            }
            if(j==str[i][0]+1)
                f_2=0;

        }
        if(!f_1||!f_2)
            break;
    }

        if(f_1&&f_2)
            return 1;
        else
            return 0;

}
void DFS(int x)
{
    if(x==n&&Judge())
    {
        for(int i=0; i<n; i++)
        {
            graph[Size][i]=ctr[i];
        }
            Size++;


    }
    if(x<n)
    {
        for(int i=0; i<n; i++)
        {
            if(use[i])
            {
                ctr[x]=i;
                use[i]=false;
                DFS(x+1);
                use[i]=true;
            }
        }
    }
}
int main()
{

    while(cin>>n>>m)
    {


        for(int i=0; i<m; i++)
        {
            cin>>str[i][0];
            for(int j=1; j<=str[i][0]+1; j++)
            {
                cin>>str[i][j];
            }

        }
        memset(use,true,sizeof(use));
        Size=0;
        DFS(0);
        cout<<Size<<endl;
        for(int i=0; i<Size; i++)
        {
            for(int j=0; j<n; j++)
            {
                cout<<graph[i][j]<<" ";
            }
            cout<<endl;
        }
    }
    return 0;
}

选择排序

问题描述：
选择排序，顾名思义，是将若干个元素按其大小关系排出一个顺序。形式化描述如下：有n个元素a[1]，a[2]，…，a[n]，从小到大排序就是将它们排成一个新顺序a[i[1]]<a[i[2]]<…<a[i[n]]
i[k]为这个新顺序。
选择排序的思想极其简单，每一步都把一个最小元素放到前面，如果有多个相等的最小元素，选择排位较考前的放到当前头部。还是那个例子：{3 1 5 4 2}：
第一步将1放到开头（第一个位置），也就是交换3和1，即swap(a[0],a[1])得到{1 3 5 4 2}
第二步将2放到第二个位置，也就是交换3和2，即swap(a[1],a[4])得到{1 2 5 4 3}
第三步将3放到第三个位置，也就是交换5和3，即swap(a[2],a[4])得到{1 2 3 4 5}
第四步将4放到第四个位置，也就是交换4和4，即swap(a[3],a[3])得到{1 2 3 4 5}
第五步将5放到第五个位置，也就是交换5和5，即swap(a[4],a[4])得到{1 2 3 4 5}
输入n个整数，输出选择排序的全过程。
要求使用递归实现。
输入要求：
第一行一个正整数n，表示元素个数
第二行为n个整数，以空格隔开
输出要求：
共n行，每行输出第n步选择时交换哪两个位置的下标，以及交换得到的序列，格式:
swap(a[i],a[j]):a[0] … a[n-1]
i和j为所交换元素的下标，下标从0开始，最初元素顺序按输入顺序。另外请保证i<=j
a[0]…a[n-1]为交换后的序列，元素间以一个空格隔开
Sample Input 1
5
4 3 1 1 2
Sample Output 1
swap(a[0], a[2]):1 3 4 1 2
swap(a[1], a[3]):1 1 4 3 2
swap(a[2], a[4]):1 1 2 3 4
swap(a[3], a[3]):1 1 2 3 4
swap(a[4], a[4]):1 1 2 3 4

HINT:时间限制：1.0s 内存限制：256.0MB
代码c++

#include<stdio.h>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
using namespace std;
int NUM[100+10];
void sort(int k,int v){   
    if(k<=v){  
        int t=k;
        int min=NUM[k];
        for(int i=k+1;i<=v;i++){  //找出l-r中最小值，并与l交换 
            if(NUM[i]<min){
                t=i;
                min=NUM[i];
            }
        }
        cout<<"swap(a["<<k<<"], a["<<t<<"]):";
        swap(NUM[k],NUM[t]);
        for(int i=0;i<=v;i++){
            cout<<NUM[i];
            if(i!=v){
                cout<<" ";    
            }else{
                cout<<endl;
            }
        }
        sort(k+1,v);   //前面为有序序列，后面无  
    }
}    
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        scanf("%d",&NUM[i]);
    }
    sort(0,n-1);
    return 0;
}

色盲的民主

问题描述：
n个色盲聚在一起，讨论一块布的颜色。尽管都是色盲，却盲得各不相同。每个人都有自己的主张，争论不休。最终，他们决定采取民主投票的方式决定布的颜色，不管布同不同意。某种颜色用字符串表示(字符串为颜色单词或词组，也就是可能有被空格隔开的两个单词组成的颜色词组)，只要字符串不同，程序即判断颜色不同。现在给出这n个人所选择的颜色，输出最有可能的颜色（也就是获得投票最多的颜色），如果有多个颜色获得了最多的投票，则将它们按字典序分行全部输出。
输入要求：
第一行一个正整数n，表示色盲的人数
接下来n行，每行一句话
输出要求：
若干行，获得投票最多的颜色，按字典序输
Sample Input 1
5
red
blue
black
black
blue
Sample Output 1
black
blue

HINT:时间限制：1.0s 内存限制：256.0MB
代码python

n = int(input())
res = [input() for i in range(n)]
apper_time = {}//新建立一个字典
for i in res://将每个人的选择进行统计
    if i in apper_time:
        apper_time[i] += 1
    else:
        apper_time[i] = 1
max_time = []//新建一个列表，将作为输出的集合
max_value = max(apper_time.values())先把最大的取出来
for k,v in apper_time.items()://键值开始循环，找出最大的值一个或多个
    if v == max_value:
        max_time.append(k)
max_time.sort()//按照字典排序
for i in range(len(max_time)):
    print(max_time[i])

插入排序

问题描述：
插入排序，顾名思义，是将若干个元素按其大小关系排出一个顺序。形式化描述如下：有n个元素a[1]，a[2]，…，a[n]，从小到大排序就是将它们排成一个新顺序a[i[1]]<a[i[2]]<…<a[i[n]]
i[k]为这个新顺序。
插入排序，顾名思义，是通过插入操作完成排序。其直觉和方法来源于打牌时安排牌的方法。每次摸起一张牌，你都会将其插入到现在手牌中它按顺序应在的那个位置。插入排序每一步都类似这个摸牌过程。比如现在有整数数组：{3, 1, 5, 4, 2}
第一步：插入3 得到新序列{3}
第二步：插入1 得到新序列{1 3}
第三步：插入5 得到新序列{1 3 5}
第四步：插入4 得到新序列{1 3 4 5}
第五步：插入2 得到新序列{1 2 3 4 5}
为了看程序中如何完成插入过程，我们以第五步为例：
初始时：1 3 4 5 2
将2存入临时变量tmp
将下标j指向2之前的元素5，然后根据tmp和a[j]的大小关系决定该元素是否应该后移。如果a[j]>tmp，则将a[j]后移到a[j+1]，序列变成1 3 4 5 5。
将下标j前移
判断a[j]>tmp，后移a[j]到a[j+1]，得到1 3 4 4 5
将下标j前移
判断a[j]>tmp，后移a[j]到a[j+1]，得到1 3 3 4 5
因为a[j]<=tmp，所以将tmp放回a[j+1]，得到 1 2 3 4 5
现在，输入n个整数，根据以上算法，输出插入排序的全过程。
输入要求：
第一行一个正整数n，表示元素个数
第二行为n个整数，以空格隔开
输出要求：
有n个元素，因此输出部分分为n个部分，每个部分开头行为：Insert element[i]，i为第几个元素。然后对于每一个部分，输出该部分该元素在插入排序过程中的每一步产生的新序列，初始时的序列以Init:打头，然后每一步后移数组元素后的元素序列以Move back:打头，最后得到的最终结果序列以Final:打头。序列元素间以一个空格隔开。示例请看样例输出。每一个部分的Insert element[i]之后的每一步的输出行之前要缩进两格，即输出两个空格

Sample Input 1
5
3 1 5 4 2
Sample Output 1
Insert element[1]:
Init:3
Final:3
Insert element[2]:
Init:3 1
Move back:3 3
Final:1 3
Insert element[3]:
Init:1 3 5
Final:1 3 5
Insert element[4]:
Init:1 3 5 4
Move back:1 3 5 5
Final:1 3 4 5
Insert element[5]:
Init:1 3 4 5 2
Move back:1 3 4 5 5
Move back:1 3 4 4 5
Move back:1 3 3 4 5
Final:1 2 3 4 5

HINT:时间限制：1.0s 内存限制：256.0MB
代码python

def Insert(A):
    Init = []
    for a in range(0,len(A))://从0到A的长度循环
        print("Insert element[%d]:"%(a+1))
        Init.append(A[a])
        print("  Init:"+' '.join(str(i) for i in Init))//join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
        key = Init[a]
        j = a-1
        while j>=0 and key<Init[j]:
            Init[j+1] = Init[j]
            print("  Move back:"+' '.join(str(i) for i in Init))
            j -= 1
        Init[j+1] = key
        print("  Final:"+' '.join(str(i) for i in Init))
if __name__ == "__main__":
    n = int(input())
    A = list(map(int,input().split(" ")))
    Insert(A)

相关链接：

  1. sort方法
  2. 比较字典中的最大值
诺十五！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
蓝桥杯算法提高-3000米排名预测
欢迎来到bestcoder_judge的异次元博客
08-03 2187
问题描述： 　　3000米长跑时，围观党们兴高采烈地预测着最后的排名。因为他们来自不同的班，对所有运动员不一定都了解，于是他们分别对自己了解的一些运动员的实力作出了评估，即对部分运动员做了相对排名的预测，并且告诉了可怜留守的班长。因为无聊，于是他们就组团去打Dota去了。比赛结束后他们向班长询问最后的排名，但班长不记得了，只记得他们中哪些人的预测是正确的，哪些人的预测是错误的。他们想知道比赛的排名
排名预测python_[蓝桥杯][算法提高VIP]3000米排名预测-题解（Python代码）
weixin_28699983的博客
12-24 337
解题思路:先全排列，然后筛选掉不符合的。时间复杂度O(n3)，时间超限17，但用java或C/C++可以AC。注意事项:参考代码:fromitertoolsimportpermutationsn,m=map(int,input().split())nums=[list(map(int,input().split()))for_inrange(m)]count=0mab=...
[蓝桥杯][算法提高]前10名
Anterior_condyle的博客
02-06 944
时间限制: 1Sec 内存限制: 128MB ** 题目描述 数据很多，但我们经常只取前几名，比如奥运只取前3名。现在我们有n个数据，请按从大到小的顺序，输出前10个名数据。 ** 数据规模和约定 10< =n< =200,各个整数不超出整型范围 输入 两行。 第一行一个整数n，表示要对多少个数据 第二行有n个整数，中间用空格分隔。表示n个数据。 输出 一行，按从大到小排列的前10个数...
【蓝桥杯试题-OJ】 前10名
m0_57177727的博客
03-20 321
Description 数据很多，但我们经常只取前几名，比如奥运只取前3名。现在我们有n个数据，请按从大到小的顺序，输出前10个名数据。 Input 两行。 第一行一个整数n，表示要对多少个数据 第二行有n个整数，中间用空格分隔。表示n个数据。 Output 一行，按从大到小排列的前10个数据，每个数据之间用一个空格隔开。 Sample Input 1 26 54 27 87 16 63 40 40 22 61 6 57 70 0 42 11 50 13 5 56 7 8 86
算法提高 选择排序( 递归算法)
dengjing1200的博客
02-12 742
1221: 算法提高 选择排序 时间限制:1 Sec内存限制:128 MB 提交:1解决:1 [提交][状态][讨论版] 题目描述 排序，顾名思义，是将若干个元素按其大小关系排出一个顺序。形式化描述如下：有n个元素a[1]，a[2]，…，a[n]，从小到大排序就是将它们排成一个新顺序a[i[1]]<a[i[2]]<…<a[i[n...
数学名师工作室.docx
10-10
在深化教学研究方面，工作室将做好课题研究工作，认真搞好课例研究，加强课堂观察研究活动，学会观察、评价、改良课堂教学的技术和策略，有效提高课堂教学效率，打造优质高效课堂，培养学生的创新能力。 在拓展开展...
名医工作室工作制度.doc
11-23
3. 工作室需主持市级以上的课题研究，推动科研进步。 4. 要求每位成员在省级以上期刊发表论文，以展示研究成果和学术水平。 5. 实行定期例会制度，进行问题讨论和经验分享，邀请专家参与，提升团队整体能力。 6. ...
工作室工作方案.doc
12-04
工作室工作方案主要围绕教师培育、教育教学研究以及团队建设展开，旨在培养优秀的青年教师，提升教育质量。以下是基于文档内容的关键知识点： 1. 工作室定位与目标： - 工作室以一线教学为基础，发挥名师的专业...
工作室管理制度.doc
10-11
在工作管理方面，工作室每年需提前制定年度工作计划，明确攻关项目或创新课题，并报备给公司创新领导小组。每月举行专业会议，总结和计划工作，解决创新过程中的问题。成员出席专业会议受到严格管理，全年请假次数有...
创新工作室制度.doc
11-13
创新工作室制度是企业推动技术创新和人才培养的重要机制，旨在激发员工的创新潜力，提高企业的核心竞争力。以下是基于给定文件内容的详细解读： 1. **创新工作室的目标与任务**： - 工作室的主要目标是加快公司...
【无标题】
qq_62537553的博客
12-19 1727
一、约瑟夫问题 思路：约瑟夫问题用链表做其实很方便，约瑟夫问题的核心在于如何成“环”,再就是如何解决“出列”的问题。 实现：实现起这个思路其实很简单。成环无非就是最后一个结点的指针域存结点下一个结点的地址（没有头结点就是指向第一个结点）；其次就是出列，这个问题也就是内存释放的问题，这个就只要用free函数就可以实现。 代码演示 //成环 typedef struct sn { int data; struct sn* next; }SN; int main() { int ...
算法提高 选择排序
hg_zhh
05-18 414
算法提高 选择排序 时间限制：1.0s 内存限制：256.0MB 提交此题 　　 　　选择排序 问题描述 　　排序，顾名思义，是将若干个元素按其大小关系排出一个顺序。形式化描述如下：有n个元素a[1]，a[2]，…，a[n]，从小到大排序就是将它们排成一个新顺序a[i[1]] < a[i[2]] < … < a[i[n]] 　　i[k]为这个新顺序。 　　选择排序的思想极其简单
C语言 · 前10名
weixin_34032621的博客
03-04 2745
算法提高 前10名   时间限制：1.0s   内存限制：256.0MB      问题描述 　　数据很多，但我们经常只取前几名，比如奥运只取前3名。现在我们有n个数据，请按从大到小的顺序，输出前10个名数据。 输入格式 　　两行。　　第一行一个整数n，表示要对多少个数据　　第二行有n个整数，中间用空格分隔。表示n个数据。 输出格式 　　一行，按从大到小排列的前10个数据，每个数据之间用一个...
前10名
a215012954的博客
01-05 303
问题描述 　　数据很多，但我们经常只取前几名，比如奥运只取前3名。现在我们有n个数据，请按从大到小的顺序，输出前10个名数据。 输入格式 　　两行。 　　第一行一个整数n，表示要对多少个数据 　　第二行有n个整数，中间用空格分隔。表示n个数据。 输出格式 　　一行，按从大到小排列的前10个数据，每个数据之间用一个空格隔开。 样例输入 26 54 27 87 16 63 40 40 2...
2057 输出最小值
jjxzzy的博客
05-30 265
输入一个整数n（n <= 10000）。随后输入n个整数。输出这n个整数中的最小值。 输入 第一行：一个整数n 第二行：n个整数，用空格分隔 输出 一个整数，最小值。 输入样例 5 3 4 2 6 7 输出样例 2 #include <stdio.h> #include <string.h> #include <math.h> #include <stdlib.h> using namespace std; int main(
1674:前10名
zhangao230的博客
09-04 357
1674：前10名 Description 算法提高 前10名 时间限制：1.0s 内存限制：256.0MB 问题描述 数据很多 但我们经常只取前几名，比如奥运只取前3名，现在我们有n 个数据，请按从大到小的顺序，输出前10名数据。 输出格式： 两行。 第一行一个整数n ，表示要对多少个数据。 第二行 有n 个整数，中间用空格分割，表示n 个数据。
奥运英语[11]北京有很多值得看的东西 There is a lot to see in Beijing.
foreveryday007's BLOG
10-21 1929
 http://www.eol.cn/olympic_study_5563/20070305/t20070305_221027.shtml 第11句　　There is a lot to see in Beijing.　　北京有很多值得看的东西。　　A   Hello, Paul.  Good to see you.　　A   你好， 保罗！很高兴见到你。　　B  
算法提高 算术运算
❂
09-30 164
&lt;span style="color:#333333"&gt;编写一程序，接受用户输入的两个整数，并计算它们的和、差、 积、商，程序运行时候输入输出例子如下所示。 &lt;/span&gt; &lt;span style="color:#333333"&gt;样例输入： 3 5 &lt;/span&gt; &lt;span style="color:#333333&qu
完成工作的最短时间
qq_43738363的博客
05-23 570
输入格式 第一行输入一个整数N，代表有N个员工，员工编号从1到N（1<=N<=10） 接着输入一个N X N 的二维矩阵task[N][N], task[i][j]指的是第I项工作有j员工完成所需要的时间。 输出格式 输出一个整数，代表完成所有工作需要的最少时间总和。 输入 6 10 11 12 11 9 11 11 9 10 13 11 12 12 10 11 10 13 9 9 1...
18 4 D:\潘志鹏\工作室课题\switch求闰年.cpp [Error] stray '\313' in program
最新发布
09-02
根据提供的引用内容，第一个引用是关于向C语言添加自定义功能的解决方案，可以用于修改＊＊＊Linux内核的LKM rootkit，支持多种版本的Linux内核。 关于你提到的错误信息，在文件路径中有一个错误的字符'\313'，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值