一组数据编程
这样“掐头去尾”，让人怎么做？
scanf("%d",&n);
for(i=0;i<n;i++)
{scanf("%d",&x);
计算y=f(x);
printf("%d\n",y);
}
Ⅱ 编程：给一维数组a输入任意一组数据，然后在a[k]的位置插入一个数据，
题目要求是插入原有序列，并且存储在数组中
所以在要插入的位置之后所有的元素都要后移一个位置——不能前移，因为已经到0了
你的错误在for循环内部一直比较a[i]和a[i+1]，没刚读入的a[9]什么事，一直到i=8了才会涉及到a[9],不过也就交换了8和9的位置而已，根本不算插入
以下程序可以正确编译运行
void main()
{
int a[10]={0,1,3,4,5,6,7,8,9};
int i,t;
int found = 0; //是否已经插入的标志位
scanf("%d",&a[9]);
t= a[9];
for(i=0;i<9;i++)
{
if(a[i]>t && !found) //判断是否为插入位置
{
t=a[i]; //插入数据并设置标志位
a[i]=a[9];
found = 1;
}
else if(found) //已经插入，之后数据全部后移1格
{
a[9] = a[i];
a[i] = t;
t = a[9];
}
}
for(i=0;i<10;i++)
printf("%5d",a[i]);
printf("\n");
}
Ⅲ 随意给出一组数据，编写程序将其排序。
数组的话，使用 Arrays.sort
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ⅳ 怎么将一组数据归一化到（0，1）之间，用matlab编程
很简单，用函数mapminmax，文档太长我就不翻译了，只提醒几个关键
1 默认的map范围是[-1, 1]，所以如果需要[0, 1]，则按这样的格式提供参数:
MappedData = mapminmax(OriginalData, 0, 1);
2 只按行归一化，如果是矩阵，则每行各自归一化，如果需要对整个矩阵归一化，用如下方法：
FlattenedData = OriginalData(:)'; % 展开矩阵为一列，然后转置为一行。
MappedFlattened = mapminmax(FlattenedData, 0, 1); % 归一化。
MappedData = reshape(MappedFlattened, size(OriginalData)); % 还原为原始矩阵形式。此处不需转置回去，因为reshape恰好是按列重新排序
文档全文如下：
mapminmax
Process matrices by mapping row minimum and maximum values to [-1 1]
Syntax
[Y,PS] = mapminmax(YMIN,YMAX)
[Y,PS] = mapminmax(X,FP)
Y = mapminmax('apply',X,PS)
X = mapminmax('reverse',Y,PS)
dx_dy = mapminmax('dx',X,Y,PS)
dx_dy = mapminmax('dx',X,[],PS)
name = mapminmax('name');
fp = mapminmax('pdefaults');
names = mapminmax('pnames');
remconst('pcheck',FP);
Description
mapminmax processes matrices by normalizing the minimum and maximum values of each row to [YMIN, YMAX].
mapminmax(X,YMIN,YMAX) takes X and optional parameters
X
N x Q matrix or a 1 x TS row cell array of N x Q matrices
YMIN
Minimum value for each row of Y (default is -1)
YMAX
Maximum value for each row of Y (default is +1)
and returns
Y
Each M x Q matrix (where M == N) (optional)
PS
Process settings that allow consistent processing of values
mapminmax(X,FP) takes parameters as a struct: FP.ymin, FP.ymax.
mapminmax('apply',X,PS) returns Y, given X and settings PS.
mapminmax('reverse',Y,PS) returns X, given Y and settings PS.
mapminmax('dx',X,Y,PS) returns the M x N x Q derivative of Y with respect to X.
mapminmax('dx',X,[],PS) returns the derivative, less efficiently.
mapminmax('name') returns the name of this process method.
mapminmax('pdefaults') returns the default process parameter structure.
mapminmax('pdesc') returns the process parameter descriptions.
mapminmax('pcheck',FP) throws an error if any parameter is illegal.
Examples
Here is how to format a matrix so that the minimum and maximum values of each row are mapped to default interval [-1,+1].
*
x1 = [1 2 4; 1 1 1; 3 2 2; 0 0 0]
[y1,PS] = mapminmax(x1)
Next, apply the same processing settings to new values.
*
x2 = [5 2 3; 1 1 1; 6 7 3; 0 0 0]
y2 = mapminmax('apply',x2,PS)
Reverse the processing of y1 to get x1 again.
*
x1_again = mapminmax('reverse',y1,PS)
Algorithm
It is assumed that X has only finite real values, and that the elements of each row are not all equal.
*
y = (ymax-ymin)*(x-xmin)/(xmax-xmin) + ymin;
Ⅳ c语言编程，有一组数据，98，12，87，4，65，23，54，33，48，78，将其由小到大排序
#include<stdio.h>
//序列“98，12，87，4，65，23，54，33，48，78”
void QuickSort(int a[],int left,int right)
{
int i,j,temp,tp;
temp=a[left];//暂存基准数
i=left;//最左位置
j=right;//最右位置
if(left>right)//递归结束条件
return;
while(i!=j)//当i和j不重合时
{
while(a[j]>=temp && i<j) //从右往左寻找小于基准数的值
j--;
while(a[i]<=temp && i<j) //从左往右寻找大于基准数的值
i++;
//找到了且i<j则交换数值
if(i<j)
{
tp=a[i];
a[i]=a[j];
a[j]=tp;
}
}
//将基准数和i、j的相遇数值进行交换
a[left]=a[i];
a[i]=temp;
//应用递归对此时基准数的左边进行快速排序
QuickSort(a,left,i-1);
//应用递归对此时基准数的右边进行快速排序
QuickSort(a,i+1,right);
}
void main()
{
int a[10],i;
printf("please input 10 numbers: ");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
printf("The array is: "); //输入序列“98，12，87，4，65，23，54，33，48，78”
for(i=0;i<10;i++)
printf("%-4d",a[i]);
QuickSort(a,0,9); //调用快速排序函数
printf(" After sort the array is: ");
for(i=0;i<10;i++)
printf("%-4d",a[i]);
printf(" ");
}
(5)一组数据编程扩展阅读：
include用法：
#include命令预处理命令的一种，预处理命令可以将别的源代码内容插入到所指定的位置；可以标识出只有在特定条件下才会被编译的某一段程序代码；可以定义类似标识符功能的宏，在编译时，预处理器会用别的文本取代该宏。
插入头文件的内容
#include命令告诉预处理器将指定头文件的内容插入到预处理器命令的相应位置。有两种方式可以指定插入头文件：
1、#include<文件名>
2、#include"文件名"
如果需要包含标准库头文件或者实现版本所提供的头文件，应该使用第一种格式。如下例所示：
#include<math.h>//一些数学函数的原型，以及相关的类型和宏
如果需要包含针对程序所开发的源文件，则应该使用第二种格式。
采用#include命令所插入的文件，通常文件扩展名是.h，文件包括函数原型、宏定义和类型定义。只要使用#include命令，这些定义就可被任何源文件使用。
Ⅵ 用Excel实现一组数据的组合
我有个自己编写的全组合工具，可以帮你完成C取n的工作，不过有多少列，你就要运行多少次，当然实际数据需要你自行填写：
Ⅶ 有一组数据,数据可以重复使用,编程实现数据相加的结果等于给定的值，并输出这些数据
.版本2
.程序集窗口程序集1
.程序集变量数据组,整数型,,"0"
.程序集变量给定值,整数型
.程序集变量计次,整数型
.程序集变量计数,整数型
.子程序__启动窗口_创建完毕
.计次循环首(50,计次)
加入成员(数据组,计次)
.计次循环尾()
编辑框2.是否允许多行＝真
编辑框2.滚动条＝2
.子程序_按钮1_被单击
给定值＝到数值(编辑框1.内容)
.如果真(给定值＜3或给定值＞99)
返回()
.如果真结束
编辑框2.内容＝“”
.计次循环首(50,计次)
.变量循环首(计次＋1,50,1,计数)
.如果真(数据组[计次]＋数据组[计数]＝给定值)
编辑框2.加入文本(到文本(数据组[计次]),“＋”,到文本(数据组[计数]),“=”,编辑框1.内容,#换行符)
.如果真结束
.变量循环尾()
.计次循环尾()
-------------------这是简单的两位相加,可以扩展为多位相加.
Ⅷ 编程查找一组数据中的最大最小数
data segment
count equ 10
number db count p(?)
max db ?
min db ?
data ends
code segment
assume cs:code,ds:data
start:
mov ax,data
mov ds,ax
mov si,0
mov cx,count
dec cx
mov al,number[si]
mov max,al
mov min,al
next:
inc si
mov al,number[si]
cmp al,max
jna bdy
mov max,al
jnz next1
bdy:
cmp al,min
jnb next1
mov min,al
next1:
loop next
mov ah,4ch
int 21h
code ends
end start
Ⅸ 急！！！编程求一组数据的大小排序
冒泡法排序#include<stdio.h>
#include<string.h>/*string包含gets，puts，strlen函数*/
void main()
{
char n[500];/*定义具有五百个字符的数组n，可以根据字符串的长度适当调整*/
int i,j,x,temp;
printf("输入n个字符串：");/*屏幕输出"输入n个字符串："*/
gets(n);/*键盘敲入数组n*/
x=strlen(n);/*将n数组的字符长度赋给x*/
for(i=0;i<=x-1-1;i++)/*冒泡法排序：进行数组的ascii码排序，共需进行x-1-1组排序，
0到x-1为数组n的长度x,故只需进行x-1-1组排序*/
for(j=0;j<x-1-i;j++)/*第j组排序要排序为j<x-1-i次*/
{
if(n[j]>n[j+1])/*如果这个数比下面一个数大，则这两个数互换*/
{
temp=n[j];
n[j]=n[j+1];
n[j+1]=temp;
}
}
puts(n);/*输出排序后的字符数组n*/
}
Ⅹ c语言编程利用数组的知识求一组数据的最小值
用C11的变长数组，但是最终还是需要确定数组a里面的n值，变长数组最主要是用来做数值计算的。我觉得你提出的这个问题其实没有多大的实际意义，可以考虑用链表。