编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

0分，0分，0分，100分

做题要坚持不懈

说说我的经验，直接用字符串做，但是要考虑大数-小数大数退位了的情况，大数仍然保留0，这样就不会啥比标准答案长了，然后可能输入的数是循环的第一个，这时输出会跑到最后一个，用个IF调整就行了，希望大家都AC, 别来这个

├ 测试数据 02：答案错误...程序输出比正确答案长

├ 测试数据 03：答案错误...程序输出比正确答案长

├ 测试数据 04：答案错误...程序输出比正确答案长

├ 测试数据 05：答案错误...程序输出比正确答案长

├ 测试数据 06：答案错误...程序输出比正确答案长

├ 测试数据 07：答案错误...程序输出比正确答案长

├ 测试数据 08：答案错误...程序输出比正确答案长

├ 测试数据 09：答案错误...

longint一分也没捞到，int64立刻90，加上输入的第一个数就AC了……

var t:array[1..1000] of string;

a,b:string;

g,h:longint;

a1,b1:int64;

ch:boolean;

procedure qsort(l,r:longint);

var i,j:longint;

x,y:char;

begin

i:=l;

j:=r;

x:=a[(i+j) div 2];

repeat

while a[i]x do j:=j-1;

if ij;

if i

晕了，注意用INT64，WA了N次，才发现

program ss;

var i,j,k,i2,n,l1,l2,r,l:longint;

a,c,d:array[1..10000]of longint;

b:array[1..10000]of boolean;

begin

readln(n);

for l:=1 to 10000 do

begin

fillchar(c,sizeof(c),0);i:=0;l1:=0;l2:=0;

repeat

inc(i);

c[i]:=n mod 10;

n:=n div 10;

until n=0;

n:=i;

for j:=1 to n-1 do

for i:=1 to n-j do

if c[i]n;

n:=l2-l1;

for i:=1 to r do

if n=a[i] then

begin

for j:=i to r-1 do

write(a[j],' ');

write(a[r]);

writeln;halt;

end;

inc(r);a[r]:=n;

end;

end.

第一次一次通过，纪念一下(*^__^*) 嘻嘻……

program p1024;

var

i,j,k,m,n,t,x:longint;

a,b:array[1..256]of integer;

c:array[1..100,1..256]of integer;

s:string;

f:boolean;

procedure jian;

var

i,j,k:integer;

begin

for i:=m downto 1 do

begin

if a[i]

比如说数字是98760，它要减的一个数是06789，而不是60789

自作主张啊～～～我让提交次数上10201次

凌晨2：42，纪念一下：

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

囧了……为什么输出比实际答案长？

procedure main;

type

arr1=array[1..11]of integer;

var

i,j:integer;

a,b:arr1;

c:array[1..10000]of longint;

s:string;

l,p,k:integer;

procedure sort;

var

i,j,t:integer;

begin

for i:=1 to l-1 do

for j:=i+1 to l do

if a[i]>a[j] then

begin

t:=a[i];

a[i]:=a[j];

a[j]:=t;

end;

for i:=1 to l do

b[i]:=a[l+1-i];

end;

procedure jian;

var

j:integer;

begin

for j:=1 to l do

begin

if a[j]

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

原来保存结果的数组头一个应该保存输入数据本身，而且得用　double　代码如下：

#include

#include

#include

#define N 10000

int map_min(const void *a, const void *b)

{

return *(char *)a - *(char *)b;

}

int map_max(const void *a, const void *b)

{

return *(char *)b - *(char *)a;

}

int main(void)

{

　　　　int i, j, k, t;

　　　　double res[N];

　　　　char tmp_a[30], tmp_b[30];

　　　　double n;

　　　　double a, b;

　　　　while ((scanf("%lf", &n)) == 1) {

　　　　res[0]=n;

　　　　for (t = 1;;) {

　　　　sprintf(tmp_a,"%.0f",n);

　　　　　　　strcpy(tmp_b,tmp_a);

　　　　qsort(tmp_a, strlen(tmp_a), sizeof(tmp_a[0]), map_max);

　　　　qsort(tmp_b, strlen(tmp_b),sizeof(tmp_b[0]), map_min);

　　　　for (a = b = 0, j = 0; j < strlen(tmp_a); ++j) {

　　　　　　　　a = (a * 10 + tmp_a[j]-'0');

　　　　　　　b = (b * 10 + tmp_b[j]-'0');

　　　　}

　　　　res[t++] = n = a - b;

　　　　for (i = 0; i < t-1; ++i) {

　　　　if (n == res[i]) {

　　　 k=i;

　　　　n = -1;

　　　　}

　　　　}

　　　　if (n < 0) {

　　　　 break;

　　　　}

　　　　}

　　　　for (i = k; i < t-1; ++i) {

　　　　 printf("%.0lf ", res[i]);

　　　　}

　　　　puts("");

　　　　}

　　　　return 0;

}

鄙人真是汗啊！！！

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

必须用int64!

longint 10分

测试数据好阴啊！！！！！！

最后一组中的循环节的第一个居然是输入数据！！！！！！

但还是勉勉强强过了......

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

Program P1024;

var

i,j:longint;

a,b,l:int64;

s:string;

r:array[0..10000]of qword;

procedure swap(x,y:integer);

var

t:char;

begin

t:=s[x];

s[x]:=s[y];

s[y]:=t;

end;

function correct:boolean;

var

i,j:longint;

begin

for i:=1 to r[0]-1 do if r[i]=r[r[0]] then

begin

for j:=i to r[0]-1 do write(r[j],' ');

writeln;

exit(true);

end;

exit(false);

end;

begin

assign(input,'P1024.in');

assign(output,'P1024.out');

reset(input);

rewrite(output);

repeat

readln(s);

l:=length(s);

r[0]:=1;

val(s,r[1]);

repeat

for i:=l downto 1 do for j:=1 to i do if s[i]>s[j] then swap(i,j);

val(s,a);

for i:=l downto 1 do for j:=1 to i do if s[i]

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

longint过不了,换double立即AC

害我WA了3次……

100题纪念

#include "stdio.h"

#include "string.h"

double number,circle[1000];

double pow1(int n)

{

if(n==0) return 1;

else return pow1(n-1)*10;

}

double zhuanhuan(double num)

{

int i,j;

int t;

double max,min;

max=min=0;

char temp[150];

sprintf(temp,"%.0lf",num);

for(i=0;i

猫猫，很荣幸，我也60次AC了

60次AC,庆祝一下

简单模拟题,注意输入数据可能在循环的第一位, 第10组测试数据中出现.

我晕啊

居然用了qword才过……

program p1024;

var x:longint;

procedure make(x:longint);

var

a:array [0..65535] of longint;

b:array [1..100] of longint;

i,j,l,y,ok,big,small,flag,no:longint;

procedure change(var mm,nn:longint);

var t:longint;

begin

t:=mm;

mm:=nn;

nn:=t;

end;

begin

a[0]:=1234567;

ok:=x;

no:=0;

repeat

no:=no+1;

flag:=0;

y:=ok;

i:=0;

repeat

i:=i+1;

b[i]:=y mod 10;

y:=y div 10;

until y=0;

for j:=1 to i-1 do

for l:=j+1 to i do

if b[j]=3) then begin

for j:=1 to (no-1) do if ok=a[j] then break;

if (j=no-1) and (oka[no-1]) then begin flag:=0; a[no]:=ok; end else

begin

flag:=1;

for l:=j to (no-1) do write(a[l],' ');

end; end;

until flag=1;

end;

begin

repeat

readln(x);

make(x);

writeln;

until eof;

readln;

end.

var

w:string;

procedure quick1(var z:string;x,y:integer);

var

　　i,j:integer;b,d:char;

begin

　　i:=x;j:=y;

　　b:=z[(x+y)div 2];

　　while i