❶ 急！！！！c语言问题！！
//改了，可以用vc++6.0编译，问题不多，就是有些地方不注意。
#include<stdio.h>
#include<math.h>
#define C 30*3.1415926/180
#define A 2.8
#define D 7
#define H 4
#define P 90
#define Q 70
int hanshu1()
{
double xm;
int nm,t=1,n=0,m;
for(m=0;m<P/(D+1/2*H);m++)
{
xm=m*(D+1.0/2*H);
nm=(int)((Q-(Q*xm)/P)/A);
n+=nm;}
return n;
}
int hanshu2(double f)
{//改了c[4]={0}
double bm,k,b0,x,y,x3,y3,c[4]={0},r;
int nm,n=0,i,j,m;
k=tan(f);
b0=-k*P;
for(m=0;m<=(Q-b0)/((D+H/2)*sqrt(k*k+1));m++)
{
bm=b0+m*(D+H/2)*sqrt(k*k+1);
x=-(bm/k);
y=bm;
x3=(P*Q-bm*P)/(Q+k*P);
y3=(k*P*Q+bm*Q)/(k*P+Q);
if(x>0&&x<P&&y>0&&y<Q)
{
c[0]=bm*tan(C+f)/k;
c[1]=bm;
}
else if((x>P&&y>0&&y<Q)||(x<0&&y>0&&y<Q))
{
c[0]=bm;
c[1]=y3-x3*tan(C+f);
}
else if((x>0&&x<P&&y>Q)||(x>0&&x<P&&y<0))
{
c[0]=bm*tan(C+f)/k;
c[1]=y3-x3*tan(C+f);
}
if(m>0)
{
for(i=0;i<4;i++)
for(j=i+1;j<4;j++)
{if(c[j]>c[i])
{
r=c[i];
c[i]=c[j];
c[j]=r;
}
nm=(int)((c[0]-c[1])*cos(C+f)/A);
}
c[2]=c[0];
c[3]=c[1];
n+=nm;
}
return n;
}
}
int hanshu3(double f)
{
double bm,k,b0,x,y,x3,y3,c[4]={0},r;
int nm,n=0,i,j,m;
k=tan(f);
b0=0;
for(m=0;m<=(Q-b0)/((D+H/2)*sqrt(k*k+1));m++)
{
bm=b0+m*(D+H/2)*sqrt(k*k+1);
x=-(bm/k);
y=bm;
x3=(P*Q-bm*P)/(Q+k*P);
y3=(k*P*Q+bm*Q)/(k*P+Q);
if(x>0&&x<P&&y>0&&y<Q)
{
c[0]=bm*tan(C+f)/k;
c[1]=bm;
}
else if((x>P&&y>0&&y<Q)||(x<0&&y>0&&y<Q))
{
c[0]=bm;
c[1]=y3-x3*tan(C+f);
}
else if((x>0&&x<P&&y>Q)||(x>0&&x<P&&y<0))
{
c[0]=bm*tan(C+f)/k;
c[1]=y3-x3*tan(C+f);
}
if(m>0)
{
for(i=0;i<4;i++)
for(j=i+1;j<4;j++)
{
if(c[j]>c[i])
{
r=c[i];
c[i]=c[j];
c[j]=r;
}
nm=(int)((c[0]-c[1])*cos(C+f)/A);
}
c[2]=c[0];
c[3]=c[1];
n+=nm;
}
return n;
}
}
void main()
{
double f;
int na[1000],t=0,i,j,z;
na[0]=hanshu1();
for(f=0;f<90;f=f+1)
{
na[t]=hanshu2(f);
t++;
}
for(f=180;f>90;f=f-1)
{
na[t]=hanshu3(f);
t++;
}
for(i=0;i<t;i++)
for(j=i+1;j<t;j++)
{
if(na[i]<na[j])
{
z=na[i];
na[i]=na[j];
na[j]=z;
}
printf("%d",na[0]);
}
}
//有很多括号漏了
❷ 下面是BM算法的C语言源码，小弟看的不是太懂，求高手在重点位置加点标注既对每行代码解释一下，谢谢。。。
Dijkstra算法--c++源代码--by 伟伟猪 [转贴 2005-12-15 20:21:00 ] 发表者: 伟伟猪
/***********************************************
设G=(V,E)是一个每条边都有非负长度的有向图，有一个特异的顶点s称为缘。
单源最短路径问题，或者称为最短路径问题，是要确定从s到V中没一个其他
顶点的距离，这里从顶点s到x的距离定义为从s到x的最短路径问题。这个问题
可以用Dijkstra算法解决。下面我给我了c++下的源代码！ --by 伟伟猪
************************************************/
#include<iostream.h>
void main()
{
int infinity=100,j,i,n,k,t,**w,*s,*p,*d;
cout<<"input the value of n:";
cin>>n;
cout<<endl;
d=new int[n];
s=new int[n];
p=new int[n];
w=new int*[n];
for(i=0;i<n;i++)
for(i=0;i<n;i++)
for(j=0;j<n;j++)
cin>>w[i][j];
for(s[0]=1,i=1;i<n;i++)
{
s[i]=0;d[i]=w[0][i];
if(d[i]<infinity) p[i]=0;
else p[i]=-1;
}
for(i=1;i<n;i++)
{
t=infinity;k=1;
for(j=1;j<n;j++)
if((!s[j])&&(d[j]<t))
s[k]=1;//point k join the S
for (j=1;j<n;j++)
if((!s[j])&&(d[j]>d[k]+w[k][j]))
}
cout<<"从源点到其它顶点的最短距离依次如下：";
for(i=1;i<n;i++) cout<<d[i]<<" ";
}
/*********
顶点个数用n表示，这里给出的例子n=6
100 1 12 100 100 100
100 100 9 3 100 100
100 100 100 100 5 100
100 100 4 100 13 15
100 100 100 100 100 4
100 100 100 100 100 100
具体例子见 电子工业出版社 《算法设计技巧与分析》148页
************/
❸ 用C语言编写程序:输入体重和身高，输出体重指数BMI
例子如下：
知识扩展：
BMI指数（即身体质量指数，简称体质指数又称体重，英文为Body Mass Index，简称BMI），是用体重公斤数除以身高米数平方得出的数字，是目前国际上常用的衡量人体胖瘦程度以及是否健康的一个标准。主要用于统计用途，当我们需要比较及分析一个人的体重对于不同高度的人所带来的健康影响时，BMI值是一个中立而可靠的指标。
BMI值原来的设计是一个用于公众健康研究的统计工具。当我们需要知道肥胖是否对某一疾病的致病原因时，我们可以把病人的身高及体重换算成BMI值，再找出其数值及病发率是否有线性关联。不过，随着科技进步，现时BMI值只是一个参考值。要真正量度病人是否肥胖，还需要利用微电力量度病人的阻抗，以推断病者的脂肪厚度。因此，BMI的角色也慢慢改变，从医学上的用途，变为一般大众的纤体指标。
❹ 在c语言程序设计语句中,bm(pin)是啥意思
这个看起来像是针对硬件的编程，这是一段宏代码。相当于一个小程序。BM的意思需要联系这个程序用在什么地方来考虑。好像是调制的意思。
❺ 如何用c语言读取图片
#include
using namespace std;
#define Twoto1(i,j,w) i*w+j
void createimage(unsigned char *&img, int w, int h)
{img = new unsigned char[w*h];}
void delateimage(unsigned char*img)
{delete []img;}
void readimage(unsigned char*img, int w, int h, char *fname)
{
FILE *fp;
fopen_s(&fp,fname, "rb");
if (fp == NULL){ cout << "error" << endl; return; }
size_t result;
result=fread(img , sizeof(unsigned char), w*h, fp);
if (result != w*h)
{
cout << "Reading error" << endl;
return;
}
else
cout << "Reading Ok!" << endl;
fclose(fp);
}
void mobanjuanji(unsigned char image, unsigned char*image1, int w, int h, float moban[5][5])
{
for (int i = 0; i for (int j = 0; j if (iw - 3 || j>h - 3)
image1[Twoto1(i,j,w)] = 0;
else
{
float temp = 0;
for (int m = 0; m<5; m++)
for (int n = 0; n<5; n++)
{
temp += (image[Twoto1(i-2+m,j-2+n,w)] moban[m][n]);
}
if (temp>255) image1[Twoto1(i, j, w)] = 255;
else if (temp<0) image1[Twoto1(i, j, w)] = 0;
else image1[Twoto1(i, j, w)] = temp;
}
}
void saveimage(unsigned char *img, int w, int h, char *fname)
{
FILE *fp;
fopen_s(&fp, fname, "wb");
if (fp == NULL) { cout << "error" << endl; return; }
size_t result;
result = fwrite(img, sizeof(unsigned char), w*h, fp);
if (result != w*h)
{
cout << "Write error" << endl;
return;
}
else
cout << "Write Ok!" << endl;
fclose(fp);
}
void main()
{
unsigned char *img;
unsigned char *img1;
float moban[5][5] = { {0,0,0,0,0},{0, -1, 0, 1, 0 }, { 0, -2, 0, 2, 0 }, { 0, -1, 0, 1, 0 }, { 0,0,0,0,0 } };
//float moban[5][5] = { 0 };
int w = 512, h = 512;
createimage(img, w, h);
createimage(img1, w, h);
readimage(img, w, h, "E:ss.raw");
mobanjuanji(img, img1,w, h, moban);
saveimage(img, w, h, "E:ss_1.raw");
saveimage(img1, w, h, "E:ss_2.raw");
delateimage(img);
delateimage(img1);
}
(5)c语言bm扩展阅读
C语言实现一个图片的读出和写入
#include <stdlib.h>
#include <windows.h>
int file_size(char* filename)//获取文件名为filename的文件大小。
{
FILE *fp = fopen(filename, "rb");//打开文件。
int size;
if(fp == NULL) // 打开文件失败
return -1;
fseek(fp, 0, SEEK_END);//定位文件指针到文件尾。
size=ftell(fp);//获取文件指针偏移量，即文件大小。
fclose(fp);//关闭文件。
return size;
}
int main ()
{
int size=0;
size=file_size("qw");
printf("%d ",size);
FILE * pFile,*qw;
char *buffer=(char*)malloc(sizeof(char)*size);
qw =fopen("qw","r");
pFile = fopen ( "qwe" , "wb" );
printf("%d==
",pFile);
printf("%d ",size);
fread(buffer,1,size,qw);
fwrite (buffer , sizeof(byte), size , pFile );
fclose (pFile);
rename("qwe","Groot.jpg");
return 0;
}
❻ C语言中，fprintf（fp,"%s",BM）是什么意思
向fp指向的文件指针输出一个字符串，字符串的内容为存放在BM变量中的字符串。
❼ 求字符串匹配BM算法的代码，要c或者c++的。
BM算法的C语言实现：
// 函数：int* MakeSkip(char *, int)
// 目的：根据坏字符规则做预处理，建立一张坏字符表
// 参数：
// ptrn => 模式串P
// PLen => 模式串P长度
// 返回：
// int* - 坏字符表
int* MakeSkip(char *ptrn, int pLen)
{
int i;
//为建立坏字符表，申请256个int的空间
//PS:之所以要申请256个，是因为一个字符是8位，
// 所以字符可能有2的8次方即256种不同情况
int *skip = (int*)malloc(256*sizeof(int));
if(skip == NULL)
{
fprintf(stderr, "malloc failed!");
return 0;
}
//初始化坏字符表，256个单元全部初始化为pLen
for(i = 0; i < 256; i++)
{
*(skip+i) = pLen;
}
//给表中需要赋值的单元赋值，不在模式串中出现的字符就不用再赋值了
while(pLen != 0)
{
*(skip+(unsigned char)*ptrn++) = pLen--;
}
return skip;
}
// 函数：int* MakeShift(char *, int)
// 目的：根据好后缀规则做预处理，建立一张好后缀表
// 参数：
// ptrn => 模式串P
// PLen => 模式串P长度
// 返回：
// int* - 好后缀表
int* MakeShift(char* ptrn,int pLen)
{
//为好后缀表申请pLen个int的空间
int *shift = (int*)malloc(pLen*sizeof(int));
int *sptr = shift + pLen - 1;//方便给好后缀表进行赋值的指标
char *pptr = ptrn + pLen - 1;//记录好后缀表边界位置的指标
char c;
if(shift == NULL)
{
fprintf(stderr,"malloc failed!");
return 0;
}
c = *(ptrn + pLen - 1);//保存模式串中最后一个字符，因为要反复用到它
*sptr = 1;//以最后一个字符为边界时，确定移动1的距离
pptr--;//边界移动到倒数第二个字符（这句是我自己加上去的，因为我总觉得不加上去会有BUG，大家试试“abcdd”的情况，即末尾两位重复的情况）
while(sptr-- != shift)//该最外层循环完成给好后缀表中每一个单元进行赋值的工作
{
char *p1 = ptrn + pLen - 2, *p2,*p3;
//该do...while循环完成以当前pptr所指的字符为边界时，要移动的距离
do{
while(p1 >= ptrn && *p1-- != c);//该空循环，寻找与最后一个字符c匹配的字符所指向的位置
p2 = ptrn + pLen - 2;
p3 = p1;
while(p3 >= ptrn && *p3-- == *p2-- && p2 >= pptr);//该空循环，判断在边界内字符匹配到了什么位置
}while(p3 >= ptrn && p2 >= pptr);
*sptr = shift + pLen - sptr + p2 - p3;//保存好后缀表中，以pptr所在字符为边界时，要移动的位置
// PS:在这里我要声明一句，*sptr = （shift + pLen - sptr） + p2 - p3;
// 大家看被我用括号括起来的部分，如果只需要计算字符串移动的距离，那么括号中的那部分是不需要的。
// 因为在字符串自左向右做匹配的时候，指标是一直向左移的，这里*sptr保存的内容，实际是指标要移动
// 距离，而不是字符串移动的距离。我想SNORT是出于性能上的考虑，才这么做的。
pptr--;//边界继续向前移动
}
return shift;
}
// 函数：int* BMSearch(char *, int , char *, int, int *, int *)
// 目的：判断文本串T中是否包含模式串P
// 参数：
// buf => 文本串T
// blen => 文本串T长度
// ptrn => 模式串P
// PLen => 模式串P长度
// skip => 坏字符表
// shift => 好后缀表
// 返回：
// int - 1表示成功（文本串包含模式串），0表示失败（文本串不包含模式串）。
int BMSearch(char *buf, int blen, char *ptrn, int plen, int *skip, int *shift)
{
int b_idx = plen;
if (plen == 0)
return 1;
while (b_idx <= blen)//计算字符串是否匹配到了尽头
{
int p_idx = plen, skip_stride, shift_stride;
while (buf[--b_idx] == ptrn[--p_idx])//开始匹配
{
if (b_idx < 0)
return 0;
if (p_idx == 0)
{
return 1;
}
}
skip_stride = skip[(unsigned char)buf[b_idx]];//根据坏字符规则计算跳跃的距离
shift_stride = shift[p_idx];//根据好后缀规则计算跳跃的距离
b_idx += (skip_stride > shift_stride) ? skip_stride : shift_stride;//取大者
}
return 0;
}
❽ 用c语言定义结构体，存储学生学号和三门课成绩及平均分，初始化成绩如下
k=N[(int)s[0]-1].am+N[(int)s[0]-1].bm+N[(int)s[0]-1].cm;
改为
k=N[(int)(s[0]-'1')].am+N[(int)(s[0]-'1')].bm+N[(int)(s[0]-'1')].cm;
试试。
❾ c语言中 符号&= 是什么意思 如 USBCS &=~bmDISCON;
C语言中&=是一个赋值与位与复合运算符号，如USBCS&=bmDISCON和USBCS=USBCS&bmDISCON是等效的,它的意思是先将USBCS与bmDISCON进行位与运算后再把它赋给USBCS，例如：A=00001110，B=11110011经过A&=A后A就变成了 A=00000010。相关内容可以看C语言的基础知识 位运算
❿ 用C语言写一个类似于ATM机的程序，有开户(姓名，密码)，存款，取款，查询余额，转账的功能，
packagecom.efounder.pub.util;
importjava.util.ArrayList;
importjava.util.Vector;
/**
*字符串处理工具类
*@authorxiewan
*/
publicclassStringFunction{
(String[]stringArray,charsymbol){
StringBuffersb=newStringBuffer();
for(inti=0;i<stringArray.length;i++){
sb.append(stringArray[i]);
sb.append(symbol);
}
returnsb.toString();
}
publicstaticString[](Stringstring,Stringsymbol){
VectorstringVector=(string,symbol);
String[]stringArray=newString[stringVector.size()];
for(inti=0;i<stringVector.size();i++)
stringArray[i]=(String)(stringVector.elementAt(i));
returnstringArray;
}
publicstaticString[]NO(Stringstring,Stringsymbol){
VectorstringVector=NO(string,symbol);
String[]stringArray=newString[stringVector.size()];
for(inti=0;i<stringVector.size();i++)
stringArray[i]=(String)(stringVector.elementAt(i));
returnstringArray;
}
publicstaticVector(Stringstring,Stringsymbol){
VectorstringVector=newVector();
String[]array=string.split(symbol);
for(inti=0;i<array.length;i++){
stringVector.addElement(array[i]);
}
returnstringVector;
}
publicstaticVectorNO(Stringstring,Stringsymbol){
VectorstringVector=newVector();
String[]array=string.split(symbol);
for(inti=0;i<array.length;i++){
stringVector.addElement(array[i]);
}
returnstringVector;
}
(VectorstringVector,charsymbol){
StringBuffersb=newStringBuffer();
for(inti=0;i<stringVector.size();i++){
sb.append(stringVector.elementAt(i));
sb.append(symbol);
}
returnsb.toString();
}
publicstaticStringfillString(StringpsStr,charpsC,intpsLen){
if(psStr.length()>psLen){
returnpsStr.substring(0,psLen);
}else{
char[]vcTemp=newchar[psLen];
for(inti=0;i<psLen;i++){
vcTemp[i]=psC;
}
StringvsTemp=newString(vcTemp);
StringvsResult=psStr.concat(vsTemp);
returnvsResult.substring(0,psLen);
}
}
publicstaticStringformatValue(doublevalue,intsep,charch,intround){
return"";
}
publicstaticStringGB2Uni(Stringoriginal){
if(original!=null){
try{
returnnewString(original.getBytes("GBK"),"ISO8859_1");
}catch(Exceptione){
e.printStackTrace();
returnnull;
}
}else
returnnull;
}
publicstaticStringUni2GB(Stringoriginal){
if(original!=null){
try{
returnnewString(original.getBytes("ISO8859_1"),"GBK");
}catch(Exceptione){
e.printStackTrace();
returnnull;
}
}else
returnnull;
}
publicstaticStringgenerateID(Stringpre,intvalue,intnum){
charchs[]=newchar[num];
for(inti=0;i<num;i++){
chs[num-i-1]=(char)(48+value%10);
value=value/10;
}
returnpre.trim()+newString(chs);
}
publicstaticStringgetTempStr(){
returnString.valueOf(System.currentTimeMillis());
}
(StringpsStr,StringpsS){
intviPos=psStr.indexOf(psS);
returnviPos>=0;
}
(StringpsStr,StringpsS,StringpsD){
intviPos=psStr.indexOf(psS);
if(viPos<0)
returnpsStr;
intviLength=psS.length();
StringBuffervsValue=newStringBuffer();
while(viPos>=0){
vsValue.append(psStr.substring(0,viPos));
vsValue.append(psD);
psStr=psStr.substring(viPos+viLength);
viPos=psStr.indexOf(psS);
}
vsValue.append(psStr);
returnvsValue.toString();
}
publicstaticString[]splitStringByToken(StringvsStr,Stringsymbol){
StringvsString[]={"",""};
intviPos1;
viPos1=vsStr.indexOf(symbol);
if(viPos1<0){
vsString[0]=vsStr;
vsString[1]="";
returnvsString;
}
vsString[0]=vsStr.substring(0,viPos1);
vsString[1]=vsStr.substring(viPos1+symbol.length(),vsStr.length());
returnvsString;
}
(Stringstring,Stringsymbol){
VectorstringVector=newVector();
StringvsStr=string.trim();
StringvsTemp=null;
String[]st=null;
while((!vsStr.equals(""))&&isIncludeString(vsStr,symbol)){
st=splitStringByToken(vsStr,symbol);
vsTemp=st[0].trim();
if(!vsTemp.equals(""))
stringVector.addElement(vsTemp);
vsStr=st[1].trim();
}
if(!vsStr.equals(""))
stringVector.addElement(vsStr);
returnstringVector;
}
publicstaticStringgetTempStr(intlength){
Stringstr=String.valueOf(System.currentTimeMillis());
returnstr.substring(str.length()-length);
}
WithNull(Stringstring,Stringsymbol){
VectorstringVector=newVector();
StringvsStr=string.trim();
StringvsTemp=null;
String[]st=null;
while((!vsStr.equals(""))&&isIncludeString(vsStr,symbol)){
st=splitStringByToken(vsStr,symbol);
vsTemp=st[0].trim();
stringVector.addElement(vsTemp);
vsStr=st[1].trim();
}
if(!vsStr.equals(""))
stringVector.addElement(vsStr);
returnstringVector;
}
(StringBm,intJs,StringStruct){
inti,Len,Length;
Len=Bm.length();
Length=GetStructLength(Struct,Js);
if(Len>=Length){
Bm=Bm.substring(0,Length);
}
returnBm;
}
(StringBm,StringStruct){
inti,Len,Length;
Len=Bm.length();
Length=GetStructLength(Struct,0);
for(i=0;i<Length-Len;i++){
Bm+="0";
}
returnBm;
}
(Stringcode,Stringstruct){
intcodeLength=code.length();
intstructLength=struct.length();
inttempLength=0;
for(intjs=1;js<=structLength;js++){
tempLength=GetStructLength(struct,js);
if(codeLength==tempLength)
returnjs;
}
return0;
}
(StringStruct,intJS){
inti,Length=0;
Stringsub;
Integerii;
if(JS==0)
JS=Struct.trim().length();
for(i=0;i<JS;i++){
sub=Struct.substring(i,i+1).trim();
ii=Integer.decode("0x"+sub);
//Length+=Integer..parseInt(sub);
Length+=ii.intValue();
}
returnLength;
}
(StringBM,StringStruct,intSJS){
StringRes="";
intLen;
Len=GetStructLength(Struct,SJS);
if(BM.length()>=Len)
Res=BM.substring(0,Len);
returnRes;
}
(intnum,intleng){
returnFillTagFromBegin(String.valueOf(num),leng,"0");
}
(Stringnum,intleng,StringTag){
StringRes="",tempStr1="",tempStr2="";
tempStr1=String.valueOf(num);
for(inti=0;i<(leng-tempStr1.length());i++){
tempStr2+=Tag;
}
Res=tempStr2+tempStr1;
returnRes;
}
publicstaticStringClearBMZero(StringBM,StringBMStruct){
returnClearBMTag(BM,BMStruct,"0");
}
publicstaticStringClearBMTag(StringBM,StringBMStruct,StringTag){
intJSLen=BMStruct.length();
Stringbm="",ZERO,Tmp;
intLen;
for(inti=1;i<=JSLen;i++){
Tmp=BMStruct.substring(i-1,i);
Len=Integer.parseInt(Tmp);
ZERO=RepeatChar(Tag,Len);
if(!BM.startsWith(ZERO)){
bm+=BM.substring(0,Len);
BM=BM.substring(Len);
}else
break;
}
returnbm;
}
publicstaticStringRepeatChar(Stringc,intlen){
StringRes="";
for(inti=0;i<len;i++){
Res+=c;
}
returnRes;
}
/**
*key1=value1;key2=value2;key3=value3
*
*@paraminputStringString
*@paramhashMapMap
*/
(StringinputString,java.util.MaphashMap){
String[]keyValues=StringFunction.NO(inputString,";");
String[]keyValue;
Stringkey,value;
for(inti=0;i<keyValues.length;i++){
if(!"".equals(keyValues[i])){
keyValue=StringFunction.NO(keyValues[i],"=");
if(keyValue.length<2)
continue;
key=keyValue[0];
value="";
for(intk=1;k<keyValue.length;k++){
value+=keyValue[k];
}
hashMap.put(key,value);
}
}
}
/**
*
*@paramhashMap
*Map
*@returnString
*/
(java.util.MaphashMap){
Object[]keys=hashMap.keySet().toArray();
Stringkey,value,keyValue="";
for(inti=0;i<keys.length;i++){
key=(String)keys[i];
value=(String)hashMap.get(key);
keyValue+=key+"="+value+";";
}
if(keyValue.length()>0){
keyValue=keyValue.substring(0,keyValue.length()-1);
}
returnkeyValue;
}
/**
*
*@paramvalue
*String
*@parammark
*String
*@returnString[]
*/
publicstaticString[]split(Stringvalue,Stringmark){
intindex=value.indexOf(mark);
java.util.Listlist=newArrayList();
while(index>=0){
list.add(value.substring(0,index));
value=value.substring(index+mark.length());
index=value.indexOf(mark);
}
list.add(value);
String[]rtn=newString[list.size()];
System.array(list.toArray(),0,rtn,0,rtn.length);
returnrtn;
}
publicstaticvoidmain(String[]args){
Stringvalue="a;;;;";
String[]rtn=split(value,";;");
System.out.println(rtn);
}
}