精华内容
下载资源
问答
  • 输入一个整数n代表接下来输入整数个数,n,接着输入n整数整数用int表示即可。 输出描述 输出整数序列的和、最小值、最大值。用空格隔开,占一行 样例输入 2 1 2 样例输出 3 1 2 提交代码 自己编写的基础知识...
  • C语言如何实现 输入一个正整数n 代表接下来要输入的n行正整数,每行的个数未知 如输入3 2 5 7 6 2 3
  • 给定N个不同的整数,要求对这N整数按如下规则排序并输出 数据结构
  • 输入一个整数n代表接下来输入整数个数,0 < n <= 100,接着输入n整数整数用int表示即可。 输出描述 输出整数序列的和、最小值、最大值。用空格隔开,占一行 样例输入 2 1 2 样例输出 3 1 2 package ...

    输入描述
    输入一个整数n,代表接下来输入整数个数,0 < n <= 100,接着输入n个整数,整数用int表示即可。

    输出描述
    输出整数序列的和、最小值、最大值。用空格隔开,占一行

    样例输入
    2
    1 2
    样例输出
    3 1 2

    package qiumaxminsum;
    import java.util.Scanner;
    public class qiushu {
    	public static void main(String[] args) {
    		int i,j,sum=0,max=0,min=0,m;
               System.out.println("请输入一个N:");
               Scanner reader = new Scanner(System.in);
               m = reader.nextInt();
               int a[] = new int[m];
               for(i=0;i<m;i++){
            	   a[i] = reader.nextInt();
               }
               max = min = a[0];
               for(j=0;j<m;j++){
            	   sum = sum + a[j];
            	   if(max<a[j]) max = a[j];
            	   if(min>a[j]) min = a[j];
               }
               System.out.println(sum+" "+min+" "+max);
    	}
    }
    
    
    展开全文
  • <编程之美>数组分割问题题目概述:有一个没有排序,元素个数为2N的正整数数组。要求把它分割为元素个数为N的两个数组,并使两个子数组的和最接近。 假设数组A[1..2N]所有元素的和是SUM。模仿动态规划解0-1背包问题...

    解题参考原文如下(请带着批判的眼光去看,有些细节我认为是不对的,但是我没有改动)

    <编程之美>数组分割问题

    题目概述:有一个没有排序,元素个数为2N的正整数数组。要求把它分割为元素个数为N的两个数组,并使两个子数组的和最接近。
    假设数组A[1..2N]所有元素的和是SUM。模仿动态规划解0-1背包问题的策略,令S(k, i)表示前k个元素中任意i个元素的和的集合。显然:

    S(k, 1) = {A[i] | 1<= i <= k}
    S(k, k) = {A[1]+A[2]+…+A[k]}
    S(k, i) = S(k-1, i) U {A[k] + x | x属于S(k-1, i-1) }

    按照这个递推公式来计算,最后找出集合S(2N, N)中与SUM最接近的那个和,这便是答案。这个算法的时间复杂度是O(22N).
    因为这个过程中只关注和不大于SUM/2的那个子数组的和。所以集合中重复的和以及大于SUM/2的和都是没有意义的。把这些没有意义的和剔除掉,剩下的有意义的和的个数最多就是SUM/2个。所以,我们不需要记录S(2N,N)中都有哪些和,只需要从SUM/2到1遍历一次,逐个询问这个值是不是在S(2N,N)中出现,第一个出现的值就是答案。我们的程序不需要按照上述递推公式计算每个集合,只需要为每个集合设一个标志数组,标记SUM/2到1这个区间中的哪些值可以被计算出来。关键代码如下:

    for(i = 0; i < N+1; i++)  
        for(j = 0; j < sum/2+1; j++)  
            flag[i][j] = false;  
    flag[0][0] = true;  
    for(int k = 1; k <= 2*N; k++) {  
        for(i = k > N ? N : k; i >= 1; i--) {  
            //两层外循环是遍历集合S(k,i)  
            for(j = 0; j <= sum/2; j++) {  
                if(j >= A[k] && flag[i-1][j-A[k]])  
                    flag[i][j] = true;  
            }  
        }  
    }  
    for(i = sum/2; i >= 0; i--) {  
        if(flag[N][i]) {  
            cout << "minimum delta is " << abs(2*i - sum) << endl;  
            break;  
        }  
    } 

    正文

    如果上面的内容你看懂了,那么万事大吉。你可以关闭网页了。
    像我一样不够聪明的人,跟着我的思路往下看吧。

    解题思路:

    2N个整数,分成2组,使和之差最小。设2N个整数的和是NUM。
    关键点:让N个整数的和最接近NUM/2,那么显然另外N个整数的和也是最接近NUM/2,显然这种情况和之差是最小的。

    公式

    依然是上面的公式。
    令S(k, i)表示前k个元素中任意i个元素的和的集合。显然:
    注意公式中的数组序号是按照常规思路,从1开始的。

    S(k, 1) = {A[i] | 1<= i <= k}
    S(k, k) = {A[1]+A[2]+…+A[k]}
    S(k, i) = S(k-1, i) U {A[k] + x | x属于S(k-1, i-1) }

    看不懂?举个例子就好懂了。
    A[] = {1, 2, 3, 4, 5, 6, 7, 8};

    S(3, 1) = {123};
    // S(3, 3):在前三个数中任意选择三个数
    S(3, 3) = {1+2+3} = {6};
    // S(4, 3):在前四个数中任意选择三个数
    // 相比S(3, 3)多了哪几种情况呢
    /* 首先S(4, 3)集合肯定是包含S(3, 3)的,另外还多出来A[4]分别替换掉A[1]、A[2]、A[3]的情况,即{4+2+3,1+4+3,1+2+4} = {7, 8, 9}*/
    // 观察规律,{2+3,1+3,1+2}=S(3, 2)集合,于是得到上面的公式
    S(4, 3) = S(3, 3) U {4 + x | x属于S(3, 2) = {6, 7, 8, 9};

    算法设计

    源码来源
    针对源代码,继续解释。

    public class Main {
        // 题目:任意2n个整数,从其中选出n个整数,使得选出的n个整数和同剩下的n个整数之和的差最小。
        public static void main(String[] args) {
            int A[] = { 1, 2, 3, 5, 7, 8, 9 };
            // int A[] = { 1, 5, 7, 8, 9, 6, 3, 11, 20, 17 };
            func(A);
        }
    
        static void func(int A[]) {
            int i;
            int j;
            // 下面的变量声明地很直白,不解释
            int n2 = A.length;
            int n = n2 / 2;
            int sum = 0;
            // 计算数组总和
            for (i = 0; i < A.length; i++) {
                sum += A[i];
            }
    
            /*还记得编程之美中的话吗?
            我们的程序不需要按照上述递推公式计算每个集合,只需要为每个集合设一个标志数组,标记SUM/2到1这个区间中的哪些值可以被计算出来。
            flag[i][j]:任意i个整数之和是j,则flag[i][j]为true。换言之,flag[i][j]为true,那么一定能找到一组整数,使它们的和是j。
            下面的代码将对flag数组进行初始化*/
            boolean flag[][] = new boolean[A.length + 1][sum / 2 + 1];
            for (i = 0; i < A.length; i++)
                for (j = 0; j < sum / 2 + 1; j++)
                    flag[i][j] = false;
    
            flag[0][0] = true;
            // 重点来了
            for (int k = 0; k < n2; k++) {
                //i取k和n中的较小值,我们的目的是找出集合S(2N, N)中与SUM最接近的那个和,所以k>n时,取到n就足够了。k<n时,我们显然无法从3个数中任意选择4个数,所以取k值
                for (i = k > n ? n : k; i >= 1; i--) {
                    // 两层外循环是遍历集合S(k,i),遍历顺序S[1][1],S[2][2],S[2][1],S[3][3]……特殊的依赖关系导致必须这样设计算法
                    // 内层循环计算将A[k]加入到集合中能取到的可能的j值
                    for (j = 0; j <= sum / 2; j++) {//j是i个任意整数可能的和,从0遍历到sum / 2,判断能否得到
                        // 得到j值的条件,j是和,A[k]只是其中一个,肯定需要j >= A[k],否则,取flag[i - 1][j - A[k]]的值的时候会发生越界情况。flag[i - 1][j - A[k]] = true代表可以找到i - 1个数,使它们的和为j - A[k],所以此条件满足时意味着flag[i][j] = true
                        if (j >= A[k] && flag[i - 1][j - A[k]])
                            flag[i][j] = true;
                    }
                }
            }
            // 终于计算完了,现在找到最合适的结果就好了,要找到最接近SUM / 2的和,倒着找最好了
            for (j = sum / 2; j >= 0; j--) {
                if (flag[n][j]) {
                    System.out.println("sum is " + sum);
                    System.out.println("sum/2 is " + sum / 2);
                    System.out.println("j is " + j);
                    System.out.println("minimum delta is " + Math.abs(2 * j - sum));
                    break;
                }
            }
        }
    }

    运行结果:

    sum is 35
    sum/2 is 17
    j is 17
    minimum delta is 1
    
    展开全文
  • int i, n, sum, *p; printf("输入\n"); scanf_s("%d", &amp;n); if ((p = (int*)malloc(n * sizeof(int)))== NULL)//p指向新分配的空间 { printf("空间分配失败\n"); ..
    #include "stdio.h"
    #include "stdlib.h"
    int main()
    {
    	int i, n, sum, *p;
    	printf("输入\n");
    	scanf_s("%d", &n);
    	if ((p = (int*)malloc(n * sizeof(int)))== NULL)//p指向新分配的空间
    	{
    		printf("空间分配失败\n");
    		exit(1);
    	}
    	sum = 0;
    	printf("请输入%d个数:\n", n);
    	for (i = 0; i < n; i++)
    	{
    		scanf_s("%d", p + i);
    		sum+=*(p + i);
    	}
    	printf("sum=%d\n", sum);
    	free(p);//释放分配的空间
    	return 0;
    }
    
    
    展开全文
  • 输入: 第1行为n代表用户的个数 第2行为n个整数,第i个代表用户标号为i的用户对某类文章的喜好度 第3行为一个正整数q代表查询的组数 第4行到第(3+q)行,每行包含3个整数l,r,k代表一组查询,即标号为l&...

    输入描述:
    输入: 第1行为n代表用户的个数 第2行为n个整数,第i个代表用户标号为i的用户对某类文章的喜好度 第3行为一个正整数q代表查询的组数 第4行到第(3+q)行,每行包含3个整数l,r,k代表一组查询,即标号为l<=i<=r的用户中对这类文章喜好值为k的用户的个数。 数据范围n <= 300000,q<=300000 k是整型

    输出描述:
    输出:一共q行,每行一个整数代表喜好值为k的用户的个数

    输入例子1:
    5
    1 2 3 3 5
    3
    1 2 1
    2 4 5
    3 5 3

    输出例子1:
    1
    0
    2

    例子说明1:
    样例解释:
    有5个用户,喜好值为分别为1、2、3、3、5,
    第一组询问对于标号[1,2]的用户喜好值为1的用户的个数是1
    第二组询问对于标号[2,4]的用户喜好值为5的用户的个数是0
    第三组询问对于标号[3,5]的用户喜好值为3的用户的个数是2

    import java.util.Scanner;
    
    /**
     * 类名:main<br>
     * 功能:TODO<br>
     * 作者:王孟鑫<br>
     * 日期:2019/1/21 0021<br>
     * 版本:1.0.0<br>
     */
    public class main {
    
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            //定义用户数量
            System.out.println("请输入用户数:");
            int n = scanner.nextInt();
            System.out.println("请输入用户的喜好度:");
            //定义数组s将用户喜好度放入数组中
            int[] s = new int[n];
            for (int i = 0; i < s.length; i++) {
                s[i] = scanner.nextInt();
            }
            System.out.println("请输入查询的组数:");
            int q = scanner.nextInt();
            //定义二维数组m将查询内容输入进去
            int[][] m = new int[q][3];
            //定义数组h用于将最后的查询结果g存进数组,方便输出
            int[] h=new int[q];
            for (int j = 0; j < q; j++) {
                System.out.println("请输入第" + (j + 1) + "组数据:");
                //输入每一组的查询数据
                for (int x = 0; x < 3; x++) {
                    m[j][x] = scanner.nextInt();
                }
                int g = 0;
                //进行判断l<=i<=k中读者喜好度人数,这里的n是5
                for (int z = 0;z<n;z++) {
                    //l=(m[j][0]-1),k=(m[j][1]-1,z=i,(m[j][2])表示需要查询的喜好度
                    if ((m[j][0]-1) <= z && z <= (m[j][1]-1)) {
                        if (s[z] == (m[j][2])) {
                            g++;
                        }
                    }
                }
                h[j]=g;
            }
            System.out.println("人数:");
            for(int k=0;k<q;k++){
                //输出结果
                System.out.println(h[k]);
            }
        }
    }
    
    

    结果展示:
    在这里插入图片描述

    展开全文
  • n整数的和。 输入 输入第一行是一个整数T,表示有T组测试实例; 每组输入包括两行: 第一行一个数n表示接下来会有n整数; 第二行空格隔开的n个数。 输出 对于每组输入,在一行输出n个数的和(保证和不会超出...
  • 第一行输入一个数n代表行数 依次输入n整数 输出格式: 将n整数倒序输出 输入样例: 3 1 2 3 输出样例: 321 #include<iostream> using namespace std; int main() { int a;//输入的整数n,共有多少个整数 ...
  • 请编写一个函数,满足下列需求: 用户输入n,然后输入n整数到列表中,列表中的n整数需要使用冒泡法进行排序,并将排序后的结果输出。 print(sorted([int(input("请输入:")) for i in range(int(input("请输入个...
  • 找出最小的值:输入一个正整数 n, 再输入 n整数,输出最小 值。试编写相应程序。 分析 思考:之前我们都是在循环输入正整数,但是这里需要比较前后两个数的大小,怎么办? 我们需要在循环之外先输入一个数设置为...
  • 输入数据有若干行,第一行输入一个正整数k,表示k组输入测试数据,每组测试数据包含2行,第一行随机输入n(1≤n≤10000)个int非零数据的升序序列,第二行输入一个待插入数m。 输出 输出数据共k行,对应k组输入测试...
  • 第一行一个数n表示接下来会有n整数; 第二行空格隔开的n个数。 输出 对于每组输入,在一行输出n个数的和(保证和不会超出int类型的范围)! 样例输入 Copy 2 3 1 2 3 4 -1 0 -19 22 样例输出 Copy ...
  • import java.util.*; public class Compare { public static void main(String[] args) ... System.out.print("请输入整数个数:\n"); Scanner console = new Scanner(System.in); N = console.nextInt(); S...
  • 文章目录面试题43:从1到n整数中1出现的次数一、题目描述二、问题分析三、问题解答 面试题43:从1到n整数中1出现的次数 一、题目描述 输入一个整数n,求从1到nn整数的十进制表示中1出现的次数。 例如输入12,从1...
  • int n,i,j,q,t=0; scanf("%d",&n); if(n>64) { printf(“error”); } else { for(i=0;i<n;i++); scanf("%d",&a[i]); for(q=0;q<n-1;q++) for(j=q+1;j<n;j++) if(a[q]>...
  • 现在给你n整数区间,编程找出一个集合R,使得n个集合中的每个集合都有2个整数出现在R中,并且这个集合R包含的整数个数最少。 Input 第一行包含整数n(1 &lt;= n &lt;= 10000),表示整数区间的个数。接...
  • /*输入两个正整数m和n,输出m到n之间每个整数的自然对数。 输入 输入包括两个整数m和n(m<=n),之间用一个空格隔开。 输出 每行输出一个整数及其对数,整数占4列,对数占8列,右对齐,对数保留4位小数。 */ #...
  • 从键盘输入一个正整数 n,求 n!

    千次阅读 2021-02-03 18:32:20
    从键盘输入一个正整数 n,求 n! #include <stdio.h> int main () { int i = 2 , n; float fac = 1; printf("请输入一个正整数:\n"); scanf("%d", &n); if(n == 0 || n == 1) { printf("%d 的阶乘...
  • 可以申请一个大小为65536的数组A,数组的x下标代表数字x,A[x]代表x 在整数序列中出现的次数。扫描一遍整数序列就可以完成对该整数序列的排序,时间复杂度为O(n) 应为已知范围,申请大小为65536的数组,大小为常量,...
  • 牛客OJ:从1到n整数中1出现的次数 九度OJ:http://ac.jobdu.com/problem.php?pid=1373 GitHub代码: 032-从1到n整数中1出现的次数 CSDN题解:剑指Offer–032-从1到n整数中1出现的次数 牛客OJ 九度OJ ...
  • 输入在第一行中给出一个正整数n(1)。第二行输入n整数,用空格分开。 输出格式: 在一行中输出最大值及最大值的最小下标,中间用一个空格分开。 #include <stdio.h> #include <stdlib.h> int ...
  • 分析:对该你个整数进行排序,排序后进行取出前k个最小的数...题目:输入n整数,输出其中最小的k个。 例如输入1,2,3,4,5,6,7和8这8个数字,则最小的4个数字为1,2,3和4。 */ class mainK { private: int *p;
  • 题: 死亡魔法骑士不会魔法,就爱吃东西。...接下来一行有n整数a[i] (表示商家的美味值) 第三行一个整数q 表示死亡魔法骑士的q次询问 接下来q行每行一个整数m (1<=n,q,m<=100000,1<=a[i]<=100000
  • 整数n的倒数第k个数字

    千次阅读 2019-01-24 18:21:06
    整数n的倒数第k个数字 Time Limit: 1 Sec Memory Limit: 128 MB 64bit IO Format: %lld Description 编写程序输出正整数n中从右端开始的第k个数字的值(k从1开始)。 例如: n=264539,k=3,则输出5  n=7622...
  • 1. 将n划分成若干正整数之和的划分数。  2. 将n划分成k个正整数之和的划分数。  3. 将n划分成最大数不超过k的划分数。  4. 将n划分成若干奇正整数之和的划分数。  5. 将n划分成若干不同整数之和的划分数。1....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 349,522
精华内容 139,808
关键字:

n代表整数