编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

二分+压位=一次秒杀。

首先，对于一盏灯i，它的每一个约数时刻时i都会改变状态。由于一开始是全关着的，所以约数个数为奇数的i最后会是开着的，这样的数只有平方数。

下面问题就变成了求trunc(sqrt(n))，由于n是高精度数，所以我们可以二分穷举答案。

var

i,n:longint;

begin

readln(n);

for i:= 1 to 46341 do

if i*i>=n then begin

n:=i;

break;

end;

writeln(n-1);

end.

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

编译通过...

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

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

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

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

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

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

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

　├ 标准行输出

　├ 错误行输出

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

　├ 标准行输出

　├ 错误行输出

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

　├ 标准行输出

　├ 错误行输出

├ 测试数据 10：运行时错误...| 错误号: 106 | 无效数字格式

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

Unaccepted 有效得分：60 有效耗时：0ms

高精度练手题……

var x:array[1..10000]of integer;

a,b,i,j,n,m:longint;

begin

read(n);

for i:=1 to n do

x[i]:=-1;

for i:=1 to n do

for j:=i to n do

if j mod i=0 then x[j]:=-x[j];

for i:=1 to n do

{if x[i]=1 then inc(a);

write(a);}

if x[i]=-1 then write(0)

else write(x[i]);

readln;

readln;

end.

编译通过...

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

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

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

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

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

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

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

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

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

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

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

Accepted 有效得分：100 有效耗

贴代码是不好的习惯

虽然我是牛顿迭代

话说数据太弱！

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

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

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

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

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

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

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

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

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

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

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

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

program djy;

var

a,b,c:array[0..300] of longint;

n:longint;

procedure init;

var

i:longint;

s:string;

begin

readln(s);

n:=length(s);

for i:=1 to n do

c[300-(n-i)]:=ord(s[i])-48;

end;

procedure main;

var

i,j,k,p,q:longint;

flag:boolean;

begin

for i:=300-n div 2 to 300 do

begin

for j:=9 downto 0 do

begin

a[i]:=j;

fillchar(b,sizeof(b),0);

for p:=200 to 300 do

for q:=200 to 300 do

b[p+q-300]:=b[p+q-300]+a[p]*a[q];

for k:=300 downto 1 do

begin

b[k-1]:=b[k-1]+b[k] div 10;

b[k]:=b[k] mod 10;

end;

flag:=true;

for k:=0 to 300 do

if b[k]c[k] then break;

if b[k]>c[k] then flag:=false;

if flag=true then break;

end;

end;

end;

procedure print;

var

i,j:longint;

begin

for i:=0 to 300 do

if a[i]0 then break;

for j:=i to 300 do

write(a[j]);

end;

begin

init;

main;

print;

end.

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

鄙视哈子董吉大牛。。。

二分的速度明显不如搜。。。。

37行搞定。。。

楼下的..

没那么简单啊..

N

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

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

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

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

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

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

├ 测试数据 07：答案错误...　├ 标准行输出

　├ 错误行输出

├ 测试数据 08：运行时错误...| 错误号: 106 | 无效数字格式

├ 测试数据 09：答案错误...　├ 标准行输出

　├ 错误行输出

├ 测试数据 10：运行时错误...| 错误号: 106 | 无效数字格式

program p1447;

var i:longint;

n,m:int64;

begin

readln(n);

for i:=1 to maxlongint do

if i*i>n then

begin

writeln(i-1);

exit;

end;

end.

怎么回事？

公式是对的，但是数据范围怎么处理？

谁能教下，谢谢！

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

...

破评测机..交了3遍128错误...同样的程序过会交..AC..

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

同意逐位枚举，编程复杂度超低，而且全部0ms通过

直接枚举平方根!

Flag 　　Accepted

题号 　　P1447

类型(?) 　　数论 / 数值

通过 　　200人

提交 　　668次

通过率 　　30%

难度 　　1

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

哈，第200个

编译通过...

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

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

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

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

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

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

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

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

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

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

一次AC就是爽

var

h,t,mid,n,a:array[0..1000]of longint;

i,j,k,p:longint;

s:string;

flag,f:boolean;

procedure init;

begin

readln(s);

while length(s)>=4 do

begin

inc(n[0]);

val(copy(s,length(s)-3,4),n[n[0]]);

delete(s,length(s)-3,4);

end;

if length(s)0 then

begin

inc(n[0]);

val(copy(s,length(s)-3,4),n[n[0]]);

end;

end;

function main:integer;

begin

fillchar(a,sizeof(a),0);

for i:=1 to mid[0] do

for j:=1 to mid[0] do

inc(a,mid[i]*mid[j]);

for i:=1 to 2*mid[0]-1 do

if a[i]>=10000 then

begin

inc(a,a[i] div 10000);

a[i]:=a[i] mod 10000;

end;

a[0]:=2*mid[0]-1;

if a[a[0]+1]0 then inc(a[0]);

main:=0;

if a[0]>n[0] then main:=1 else if a[0]n[i] then exit(1) else if a[i]=1000 then write(h[p]) else

if h[p]>=100 then write('0',h[p]) else

if h[p]>=10 then write('00',h[p])else

write('000',h[p]);

halt;

end;

function judge:boolean;

begin

a:=h;inc(a[1]);

i:=1;

while a[i]=10000 do

begin

a[i]:=0;

inc(a);

inc(i);

end;

if a[a[0]+1]0 then inc(a[0]);

if a[0]t[0] then exit(false) else

for i:=a[0] downto 1 do

if a[i]t[i] then exit(false);

exit(true);

end;

begin

init;

h[1]:=0;h[0]:=1;t:=n;

flag:=true;

while flag do

begin

fillchar(mid,sizeof(mid),0);

mid[0]:=t[0];

for i:=1 to t[0] do

mid[i]:=h[i]+t[i];

for i:=1 to mid[0]-1 do

if mid[i]>=10000 then

begin

inc(mid,mid[i] div 10000);

mid[i]:=mid[i] mod 10000;

end;

for i:=t[0] downto 2 do

begin

if odd(mid[i]) then inc(mid,10000);

mid[i]:=mid[i] shr 1;

end;

mid[1]:=mid[1] shr 1;

if mid[mid[0]]=0 then dec(mid[0]);

k:=main;

if k=0 then begin h:=mid;;print;end else

if k=1 then t:=mid else h:=mid;

if judge then print;

//h+1=t then print h;

end;

end.

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

——————————————————————————————————————————————————————————

不算非常ws……比某个恶心的随机tle题好多了……

有没有谁使牛顿迭代法做的？　有的贴个程序上来看看啊！

编译通过...

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

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

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

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

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

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

├ 测试数据 07：运行时错误...| 错误号: 106 | 无效数字格式

├ 测试数据 08：运行时错误...| 错误号: 106 | 无效数字格式

├ 测试数据 09：运行时错误...| 错误号: 106 | 无效数字格式

├ 测试数据 10：运行时错误...| 错误号: 106 | 无效数字格式

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

Unaccepted 有效得分：60 有效耗时：0ms

两行的code

q:qword;

readln(q);

writeln(trunc(sqrt(q)));

赚，考试的时候写个高精有点浪费时间了

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

哈哈