【来挑战吧】用MSSQL计算2的10000次方

Question

好吧我们知道BIGINT的最大值是2^63-1，也就是9,223,372,036,854,775,807，那么2^64是多少呢？再往上呢？穷极无聊的我写了个计算2的N次方的语句，不过超过100后好像速度就慢下来了，用这个语句计算10000次方花了10分钟才出来数。放出300技术分，看看谁写的SQL语句能最快的算出2的10000次方。如果能写出瞬间计算出来的语句，立刻结帖
取巧的不算，比如把我帖的结果直接SELECT出来的
本活动最终解释权归本鸭所有

Answer 1

我的代码
SET NOCOUNT ON
GO
USE TEMPDB
GO
IF OBJECT_ID('TB') IS NOT NULL DROP TABLE TB
GO
CREATE TABLE TB(ID INT PRIMARY KEY,VAL BIGINT)
;WITH MU AS (
SELECT 1 AS ID,1 AS VAL
UNION ALL
SELECT ID+1,0 FROM MU WHERE ID<10000 --10000行预留，大致估计10000次方只需要1000行左右。
)
INSERT INTO TB
SELECT * FROM MU OPTION(MAXRECURSION 0)
DECLARE @I INT ,@COUNT INT,@RESULT VARCHAR(MAX)
SELECT @I=1,@RESULT='',@COUNT=10000 --@COUNT=10000就是计算2的10000次方
WHILE @I<=@COUNT
BEGIN
UPDATE T1 SET T1.VAL=(T1.VAL*2+CASE WHEN T2.VAL>=500000000000000000 THEN 1 ELSE 0 END)%1000000000000000000
FROM TB T1
LEFT JOIN TB T2 ON T1.ID=T2.ID+1
SET @I=@I+1
END
SELECT @RESULT=@RESULT+CONVERT(VARCHAR(20),VAL) FROM TB
WHERE VAL>0
ORDER BY ID DESC
SELECT @RESULT
SET NOCOUNT OFF

Answer 2

唉.    你帮我解决下这个问题啊. 老兄 .我现在有个 问题啊.
就是 三张表:
学生表
create table Student
(
Id varchar(64) primary key not null
constraint dfid default (newid()),   
Number varchar(12) unique not null, 学号
Name varchar(12) not null 名字
)
课程表
create table Course
(
Id varchar(64) primary key not null constraint cdfid default(newid()),
CouNumer varchar(12) not null, 课程号
Name varchar(24) not null, 科目
)
学生成绩表
create table Grade
(
Id varchar(64) primary key not null default(newid()),
StuNum varchar(12), 学号
CouNum varchar(24), 科目
Grade int check ( Grade > 0 and Grade <= 100)
)问题是:我想学生成绩表关联 学生表的学号 和 课程表的 课程号
每张表的 Id都是newid() 这样岂不是 关联不起了吗?外键不是 必须要主键来关联吗?
该怎么弄啊.

Answer 3

http://cake513.javaeye.com/blog/718520
自己翻翻去吧，现在看到学生表就哆嗦

Answer 4

小数点后面总是被自动截取，搞不定declare @i bigint
set @i=power(cast(2 as bigint),50)
select @i
--2的50次方=1125899906842624
declare @k decimal(38,30)
set @k=1.125899906842624
select power(@k,100)
/*141246.703213943690000000000000000000*/

Answer 5

楼主的程序有误,这一句:
SELECT @RESULT=@RESULT+CONVERT(VARCHAR(20),VAL) FROM TB
应改成:
SELECT @RESULT=@RESULT+right('0000000000000000000'+CONVERT(VARCHAR(20),VAL),18) FROM TB否则,前导零被去除了.

Answer 6

借用楼主的编程思想:
SET NOCOUNT ON
GO
USE TEMPDB
GO
IF OBJECT_ID('BASED') IS NOT NULL DROP TABLE BASED
IF OBJECT_ID('TB') IS NOT NULL DROP TABLE TB
GO
CREATE TABLE BASED(ID INT PRIMARY KEY,VAL BIGINT)
;WITH MU AS (
SELECT 1 AS ID
UNION ALL
SELECT ID+1 FROM MU WHERE ID<30
)
INSERT INTO BASED SELECT 0,1 union all
SELECT id,power(convert(bigint,2),id) FROM MU
--以上求出2^1~2^30
DECLARE @I INT ,@COUNT INT,@RESULT VARCHAR(MAX),@two30 bigint,@twoleft bigint
SELECT @I=1,@RESULT='',@COUNT=10000    --@COUNT=10000就是计算2的10000次方
select @two30=val from BASED where id=30
select @twoleft=val from BASED where id=@count % 30
--行数 @count/30+1,
print @two30
CREATE TABLE TB(ID INT PRIMARY KEY,VAL BIGINT)
;WITH MU AS (
SELECT 1 AS ID,1 AS VAL
UNION ALL
SELECT ID+1,0 FROM MU WHERE ID<@count/30+1    --总行数 @count/30+1
)
INSERT INTO TB
SELECT * FROM MU OPTION(MAXRECURSION 0)WHILE @I<=@COUNT/30
BEGIN
UPDATE T1 SET T1.VAL= (T1.VAL*@two30+CASE WHEN T2.VAL*@two30>1000000000 THEN T2.VAL*@two30/1000000000 ELSE 0 END)%1000000000
FROM TB T1
LEFT JOIN TB T2 ON T1.ID=T2.ID+1
SET @I=@I+1
END
UPDATE T1 SET T1.VAL= (T1.VAL*@twoleft+CASE WHEN T2.VAL*@twoleft>1000000000 THEN T2.VAL*@twoleft/1000000000 ELSE 0 END)%1000000000
FROM TB T1
LEFT JOIN TB T2 ON T1.ID=T2.ID+1
SELECT @RESULT=@RESULT+right('00000000'+CONVERT(VARCHAR(10),VAL),9) FROM TB
WHERE VAL>0 and id<=@count/30
ORDER BY ID DESC
SELECT @RESULT=CONVERT(VARCHAR(10),VAL)+@RESULT FROM TB
WHERE VAL>0 and id=@count/30+1SELECT @RESULT
SET NOCOUNT OFF

Answer 7

鸭子这么给力，我也写一个，不过代码风格不好，大家凑合着看，呵呵。。
declare 
@str nvarchar(max),
@strBack nvarchar(max),
@y smallint,
@strtemp char(1),
@f smallint,
@weishu smallint,
@neiLoop int,
@jinwei int;Set @y=1;
set @jinwei=0;
set @str='4';
set @neiLoop=1;
set @strBack='';while(@y<5000)--循环n次计算4的n次方
begin
set @jinwei=0;
set @neiLoop=1;
set @strBack='';
    set @weishu=len(@str);--首先获取当前数字的字符串位数
while(@neiLoop<@weishu+1)--一次从右边遍历每一位
begin 
set @strtemp=right(@str,1); --取最右边一位
set @f=cast(@strtemp as int)*4;--转换成数字乘以4
set @f=@f+@jinwei--和进位相加，得出当前位的值
if(@neiLoop=@weishu)--是最后一位
begin
set  @strBack=cast(@f as nvarchar(max))+@strBack;
end
else
begin
if(@f>=10)
begin
set @strBack=right(cast(@f as nvarchar(max)),1)+@strBack;
set @jinwei=left(@f,1);
set @str=left(@str,@weishu-@neiLoop);
end
else
begin
set @strBack=cast(@f as nvarchar(max))+@strBack;
set @jinwei=0;
set @str=left(@str,@weishu-@neiLoop);
end
end
      set @neiLoop=@neiLoop+1
end
set @str=@strBack;
set @y=@y+1;
end 
print @strBack
go
运行时间：第一次3分59秒  第二次3分22秒
机器配置：主频1.66GHz T5450酷睿2双核。
求鸭子鉴定结果

Answer 8

鸭子这么给力，我也写一个，不过代码风格不好，大家凑合着看，呵呵。。
declare 
@str nvarchar(max),
@strBack nvarchar(max),
@y smallint,
@strtemp char(1),
@f smallint,
@weishu smallint,
@neiLoop int,
@jinwei int;Set @y=1;
set @jinwei=0;
set @str='4';
set @neiLoop=1;
set @strBack='';while(@y<5000)--循环n次计算4的n次方
begin
set @jinwei=0;
set @neiLoop=1;
set @strBack='';
    set @weishu=len(@str);--首先获取当前数字的字符串位数
while(@neiLoop<@weishu+1)--一次从右边遍历每一位
begin 
set @strtemp=right(@str,1); --取最右边一位
set @f=cast(@strtemp as int)*4;--转换成数字乘以4
set @f=@f+@jinwei--和进位相加，得出当前位的值
if(@neiLoop=@weishu)--是最后一位
begin
set  @strBack=cast(@f as nvarchar(max))+@strBack;
end
else
begin
if(@f>=10)
begin
set @strBack=right(cast(@f as nvarchar(max)),1)+@strBack;
set @jinwei=left(@f,1);
set @str=left(@str,@weishu-@neiLoop);
end
else
begin
set @strBack=cast(@f as nvarchar(max))+@strBack;
set @jinwei=0;
set @str=left(@str,@weishu-@neiLoop);
end
end
      set @neiLoop=@neiLoop+1
end
set @str=@strBack;
set @y=@y+1;
end 
print @strBack
go
运行时间：第一次3分59秒  第二次3分22秒
机器配置：主频1.66GHz T5450酷睿2双核。
求鸭子鉴定结果

Answer 9

结果提示存在非法字符，我复制到word里看了下结果是3011位，也没超过10000个的字符限制，不知为何，哎。。

Answer 10

看到楼主题目后，我的第一反应就是采用#26的方法。可惜周末在家，没有SQL环境，让#26抢先了...

Answer 11

有错必纠!
下列程序 2 秒内完成:
SET NOCOUNT ON
GO
USE TEMPDB
GO
IF OBJECT_ID('BASED') IS NOT NULL DROP TABLE BASED
IF OBJECT_ID('TB') IS NOT NULL DROP TABLE TB
GO
CREATE TABLE BASED(ID INT PRIMARY KEY,VAL BIGINT)
INSERT INTO BASED SELECT 0,1 union all
SELECT id,power(convert(bigint,2),id) FROM(
select number as id from master..spt_values where type='p' and number>0 and number<31
)T
--以上求出2^1~2^30DECLARE @I INT ,@COUNT INT,@RESULT VARCHAR(MAX),@two30 bigint,@twoleft bigint
SELECT @I=1,@RESULT='',@COUNT=10000    --@COUNT=10000就是计算2的10000次方
select @two30=val from BASED where id=30
select @twoleft=val from BASED where id=@count % 30CREATE TABLE TB(ID INT PRIMARY KEY,VAL BIGINT)
INSERT INTO TB SELECT 1,1
INSERT INTO TB
SELECT number,0 FROM(
select number from master..spt_values where type='p' and number>1 and number<=@count/30+2
)T
--总行数 @count/30+1WHILE @I<=@COUNT/30
BEGIN
UPDATE T1 SET T1.VAL= (T1.VAL*@two30+(isnull(T2.VAL,0)*@two30+isnull(t3.val,0)*@two30/1000000000)/1000000000)%1000000000
FROM TB T1 LEFT JOIN TB T2 ON T1.ID=T2.ID+1 left join tb t3 on t2.id=t3.id+1
SET @I=@I+1
END
-- @count/30 次 @two30 相乘UPDATE T1 SET T1.VAL= (T1.VAL*@twoleft+(isnull(T2.VAL,0)*@twoleft+isnull(t3.val,0)*@twoleft/1000000000)/1000000000)%1000000000
FROM TB T1 LEFT JOIN TB T2 ON T1.ID=T2.ID+1 left join tb t3 on t2.id=t3.id+1
--乘以剩下的 2^(@count % 30)SELECT @RESULT=@RESULT+right('00000000'+CONVERT(VARCHAR(10),VAL),9) FROM TB
WHERE id<=@count/30
ORDER BY ID DESC
SELECT @RESULT=CONVERT(VARCHAR(10),VAL)+@RESULT FROM TB
WHERE VAL>0 and id=@count/30+2SELECT @RESULT
SET NOCOUNT OFF
/*
19950583848837421626835850838234
.....
*/

Answer 12

少连接一行...
再次更正:
SET NOCOUNT ON
GO
USE TEMPDB
GO
IF OBJECT_ID('BASED') IS NOT NULL DROP TABLE BASED
IF OBJECT_ID('TB') IS NOT NULL DROP TABLE TB
GO
CREATE TABLE BASED(ID INT PRIMARY KEY,VAL BIGINT)
INSERT INTO BASED SELECT 0,1 union all
SELECT id,power(convert(bigint,2),id) FROM(
select number as id from master..spt_values where type='p' and number>0 and number<31
)T
--以上求出2^1~2^30DECLARE @I INT ,@COUNT INT,@RESULT VARCHAR(MAX),@two30 bigint,@twoleft bigint
SELECT @I=1,@RESULT='',@COUNT=10000    --@COUNT=10000就是计算2的10000次方
select @two30=val from BASED where id=30
select @twoleft=val from BASED where id=@count % 30CREATE TABLE TB(ID INT PRIMARY KEY,VAL BIGINT)
INSERT INTO TB SELECT 1,1
INSERT INTO TB
SELECT number,0 FROM(
select number from master..spt_values where type='p' and number>1 and number<=@count/30+2
)T
--总行数 @count/30+1WHILE @I<=@COUNT/30
BEGIN
UPDATE T1 SET T1.VAL= (T1.VAL*@two30+(isnull(T2.VAL,0)*@two30+isnull(t3.val,0)*@two30/1000000000)/1000000000)%1000000000
FROM TB T1 LEFT JOIN TB T2 ON T1.ID=T2.ID+1 left join tb t3 on t2.id=t3.id+1
SET @I=@I+1
END
-- @count/30 次 @two30 相乘UPDATE T1 SET T1.VAL= (T1.VAL*@twoleft+(isnull(T2.VAL,0)*@twoleft+isnull(t3.val,0)*@twoleft/1000000000)/1000000000)%1000000000
FROM TB T1 LEFT JOIN TB T2 ON T1.ID=T2.ID+1 left join tb t3 on t2.id=t3.id+1
--乘以剩下的 2^(@count % 30)SELECT @RESULT=@RESULT+right('00000000'+CONVERT(VARCHAR(10),VAL),9) FROM TB
WHERE id<=@count/30+1
ORDER BY ID DESC
SELECT @RESULT=CONVERT(VARCHAR(10),VAL)+@RESULT FROM TB
WHERE VAL>0 and id=@count/30+2SELECT @RESULT
SET NOCOUNT OFF
/*
199506311688075838488374216268358508382349683188619245
.....
*/

Answer 13

两种完全不同的思路，蛮好26L和我本来的思路比较接近，我原来也是想用VARCHAR(MAX)存储结果，一位一位的计算的，但考虑到这是程序的思想，并没有很好的利用SQL的集合运算，就改用聚集索引表来代替CHAR数组了。不过感觉基数用4有点取巧，而且应该有更巧的余地，如果愿意的话可以把逻辑写的更复杂，基数用8，16什么的，循环数量也会成倍的减少。晴天大大就更直接了，每次运算都*2^30，最后一次补足10000，循环数量变为原来的1/30了，而且每次的运算都是由系统进行，比我们自己写的进位运算要快很多，肯定是顺间出来的。至于我那个就是随便写的，一个是每次都是整表更新，另一个是截取字符串的时候没正经考虑，表中的数据准确，但拼出来的结果不准，唯一的价值就是提供点思路，算是抛砖引玉了~~

Answer 14

关于这个问题，我们可以再延伸一下，比如我有一个表，里面有一列数字，现在要写一个自定义函数，得到数字的乘积，类似下面这样的：
SELECT ID,SUM(VAL) AS [求和],DBO.FUN_MU(VAL) AS [求积] FROM TB 
因为不知道有多少行，出来的很有可能是天文数字，那这个函数内肯定要有类似于26L那样的手工进位运算，这时候就无法取巧，只能硬算了。

Answer 15

如果用 decimal(38,0) 数据类型,则还可以减小循环次数.前面的处理是除以100000000去掉9位,如果用decimal的话,可以去掉18位.

Answer 16

用decimal(38,0),0秒:
SET NOCOUNT ON
GO
USE TEMPDB
GO
IF OBJECT_ID('BASED') IS NOT NULL DROP TABLE BASED
IF OBJECT_ID('TB') IS NOT NULL DROP TABLE TB
GO
CREATE TABLE BASED(ID INT PRIMARY KEY,VAL BIGINT)
INSERT INTO BASED SELECT 0,1 union all
SELECT id,power(convert(decimal(38,0),2),id) FROM(
select number as id from master..spt_values where type='p' and number>0 and number<57
)T
insert into BASED select number+57,power(convert(decimal(38,0),2),56)*power(2,number+1) from master..spt_values where type='p' and number<4
--以上求出2^1~2^60,因power函数在2^56以上时有舍去位,故分两步处理,以乘法代之
DECLARE @I INT ,@COUNT INT,@RESULT VARCHAR(MAX),@P60 decimal(38,0),@Pleft decimal(38,0)
SELECT @I=1,@RESULT='',@COUNT=10000    --@COUNT=10000就是计算2的10000次方
select @P60=val from BASED where id=60
select @Pleft=val from BASED where id=@count % 60CREATE TABLE TB(ID INT PRIMARY KEY,VAL decimal(38,0))
INSERT INTO TB SELECT 1,1
INSERT INTO TB
SELECT number,0 FROM(
select number from master..spt_values where type='p' and number>1 and number<=@count/60+2
)T
--设总行数为 @count/60+2WHILE @I<=@COUNT/60
BEGIN
UPDATE T1 SET T1.VAL= (T1.VAL*@P60+floor((isnull(T2.VAL,0)*@P60+floor(isnull(t3.val,0)*@P60/10000000000000000000))/10000000000000000000))%10000000000000000000
FROM TB T1 LEFT JOIN TB T2 ON T1.ID=T2.ID+1 left join tb t3 on t2.id=t3.id+1
SET @I=@I+1
END
-- @count/60 次 @P60 相乘UPDATE T1 SET T1.VAL= (T1.VAL*@Pleft+floor((isnull(T2.VAL,0)*@Pleft+floor(isnull(t3.val,0)*@Pleft/10000000000000000000))/10000000000000000000))%10000000000000000000
FROM TB T1 LEFT JOIN TB T2 ON T1.ID=T2.ID+1 left join tb t3 on t2.id=t3.id+1
--乘以剩下的 2^(@count % 60)SELECT @RESULT=@RESULT+right('000000000000'+CONVERT(VARCHAR(19),VAL),19) FROM TB
WHERE VAL>0
ORDER BY ID DESC
--SELECT @RESULT=CONVERT(VARCHAR(10),VAL)+@RESULT FROM TB
--WHERE  and id=@count/30+2SELECT right(@RESULT,LEN(@RESULT)-PATINDEX('%[1-9]%',@RESULT)+1)
SET NOCOUNT OFF
/*199506311688075838488374216268358508382349683188619245
.....
*/

Answer 17

另一种算法,动态处理列,不过运算时间要10秒,没完善:
declare @count int
set @count=10000
SET NOCOUNT ON
declare @sql varchar(8000),@p60 decimal(38,0)
--创建基表,获取2^0~2^60的值
CREATE TABLE BASED(ID INT PRIMARY KEY,VAL decimal(38,0))
INSERT INTO BASED SELECT 0,1 union all
SELECT id,power(convert(decimal(38,0),2),id) FROM(
select number as id from master..spt_values where type='p' and number>0 and number<57
)T
insert into BASED select number+57,power(convert(decimal(38,0),2),56)*power(2,number+1) from master..spt_values where type='p' and number<4
--以上求出2^1~2^60,因power函数在2^56以上时有舍去位,故分两步处理,以乘法代之
select @p60=val from based where id=60
--创建表
set @sql='create table tb(n1 decimal(38,0)'
select @sql=@sql+',n'+convert(varchar,number+2)+' decimal(38,0) default 0' from master..spt_values where type='p' and number<=@count/60
set @sql=@sql+')'
exec(@sql)
--第一列赋初值
if @count/60>0 
insert into tb(n1) values(@p60)
else
insert into tb(n1) select val from based where id=@count % 60
--计算
declare @i int,@R decimal(20,0),@flg decimal(20,0),@P decimal(20,0),@sql1 nvarchar(max)
set @i=1
set @R=convert(decimal(20,0),'10000000000000000000')
set @P=@P60
while @count>=120
begin
set @sql1='update tb set n1=n1*@P%@R,n2=(floor(n1*@P/@R)+n2*@P)%@R'
select @sql1=@sql1+',n'+convert(varchar,number+3)+'=(floor((floor(n'+convert(varchar,number+1)+'*@P/@R)+'
+'n'+convert(varchar,number+2)+'*@P)/@R)+n'+convert(varchar,number+3)+'*@P)%@R'
from master..spt_values where type='p' and number<@i --and number<64
set @sql1=@sql1+',@flg=(floor((floor(n'+convert(varchar,@i)+'*@P/@R)+n'+convert(varchar,@i+1)+'*@P)/@R)+n'+convert(varchar,@i+2)+'*@P)%@R'
exec SP_EXECUTESQL @sql1,N'@P decimal(20,0),@R decimal(20,0),@flg decimal(20,0) output',@P,@R,@flg output 
if @flg>0 select @i=@i+1
set @count=@count-60
end
--此处要加上与@Pleft有关的运算,也得用动态语句select * from tb
--连接未写
go
drop table based,tb
SET NOCOUNT OFF

Answer 18

--先建一个辅助表
create table num(id int primary key, v bigint)
--插入一些记录
declare @i int
set @i = 1
while @i <= 300
begin
insert num values(@i, 0)
set @i = @i + 1
end--下面开始计算
declare @i int
set @i = 1
update num set v = 2 where id = 1
while @i < 10000
begin
update a set a.v = a.v*2%100000000000000000+isnull(b.v,0)*2/100000000000000000 from num a left join num b on a.id = b.id + 1 where a.id <= @i/45 + 1
set @i = @i + 1
enddeclare @id int
select @id = max(id) from num where v > 0
select case id when @id then '' else replicate('0',17-len(v)) end+ltrim(v) from num where id <= @id order by id desc/*
--------------------------
19
95063116880758384
88374216268358508
38234968318861924
54852008949852943
88302219466319199
...
74304792596709376(178 行受影响)
*/本机计算15秒

Answer 19

每种语言有其适合的问题。SQL的优势是数据处理，而不是数值计算（GUI开发和网络编程则直接不可能）。print(2**10000)
# 1秒内完成结果开始：
19950631168807583848837421626835850838234968318861
92454852008949852943883022194663191996168403619459
78993311294232091242715564913494137811175937859320
96323957855730046793794526765246551266059895520550
08691819331154250860846061810468550907486608962488
80904898948380092539416332578506215683094739025569
12388065225096643874441046759871626985453222868538
16169431577562964076283688076073222853509164147618
39563814589694638994108409605362678210646214273333
94036525565649530603142680234969400335934316651459
29777327966577560617258203140799419817960737824568
37622800373028854872519008344645814546505579296014
14833921615734588139257095379769119277800826957735
67444412306201875783632550272832378927071037380286
63930314281332414016241956716905740614196543423246
38801248856147305207431992259611796250130992860241
70834080760593232016126849228849625584131284406153
67389514871142563151110897455142033138202029316409
57596464756010405845841566072044962867016515061920
63100418642227590867090057460641785695191145605506
82512504060075198422618980592371180544447880729063
95242548339221982707404473162376760846613033778706
03980341319713349365462270056316993745550824178097
28109832913144035718775247685098572769379264332215
99399876886660808368837838027643282775172273657572
74478411229438973381086160742325329197481312019760
41782819656974758981645312584341359598627841301281
85406283476649088690521047580882615823961985770122
40704433058307586903931960460340497315658320867210
59133009037528234155397453943977152574552905102123
10947321610753474825740775273986348298498340756937
95564663862187456949927901657210370136443313581721
43117913982229838458473344402709641828510050729277
48364550578634501100852987812389473928699540834346
15880704395911898581514577917714361969872813145948
37832020814749821718580113890712282509058268174362
20577475921417653715687725614904582904992461028630
08153558330813010198767585623434353895540917562340
08448875261626435686488335194637203772932400944562
46923254350400678027273837755376406726898636241037
49141096671855705075909810024678988017827192595338
12824219540283027594084489550146766683896979968862
41636313376393903373455801407636741877711055384225
73949911018646821969658165148513049422236994771476
30691554682176828762003627772577237813653316111968
11280792669481887201298643660768551639860534602297
87155751794738524636944692308789426594821700805112
03223654962881690357391213683383935917564187338505
10970271613915439590991598154654417336311656936031
12224993796999922678173235802311186264457529913575
81750081998392362846152498810889602322443621737716
18086357015468484058622329792853875623486556440536
96262201896357102881236156751254333830327002909766
86505685571575055167275188991941297113376901499161
81315171544007728650573189557450920330185304847113
81831540732405331903846208403642176370391155063978
90007428536721962809034779745333204683687958685802
37952218629120080742819551317948157624448298518461
50970488802727472157468813159475040973211508049819
04558034168269497871413160632106863915116817743047
92596709376
结果结束。

Answer 20

--鸭子快给分，就题目本身，哥。declare @xx varbinary(8000)
set @xx=0x100000000....000      --2500位

Answer 21

我也是这种观点，基数小的效率不如基数大的，是因为我们无法通过SQL控制底层迭代器，因此基础运算时间被延长，同一个运算，同一种算法，虽然结果一样，但大部分由系统进行和大部分由手工进行的效率相差灰常大，而时间复杂度的概念应该是建立在运算时间相同的基础上，所以在这里是不适用的。所以我觉得大基数分段的算法是最适合MSSQL的了

Answer 22

测试了下，6分钟。就是不晓得答案对不
用的是sqlserverdeclare @var varchar(3100)
decclare @v varchar(3100)
set @var = '2'
declare @i int
declare @l int
declare @jg int
delcrea @sws int
set @i = 1
while(@i<10000)
begin
    set @i=@i+1
    set @v = ''
    set @l = LEN(@var)
    set l1=0
    set @sws = 0
    while(@l1<@l)
    begin
        set @jg = CONVERT(int,substring(@var)-@l1)*2+@sws
        if(@jg<10)
        begin
            set @sws = 0
            set @v = CONVERT(varchar(2),@jg)+CONVERT(varchar(3100),@v)
        end
        else if(@jg>10)
        begin
            set @sws = @jg/10
            set @v = convert(varchar(2),(@jg%10))+convert(varchar(3100),@v)
        end
        else
        begin
            set @sws = 1
            set @v == '0' + convert(varchar(3100),@v)
        end
        set @l1 = @l1+1
    end
    if(@sws!=0)
        set @var = convert(varchar(2),@sws)+convert(varchar(3100),@v)
    else
        set @var = @v
end
print @var

Answer 23

貌似给新机测试CPU可以用。 哈哈（开玩笑，谁会去装SQL Server）

Answer 24

写成了function，就是循环太多之后效率比较慢
set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
go
create FUNCTION [dbo].[powerX](@loopnumber int,@loopcount int)
RETURNS varchar(max)
AS
BEGINdeclare @str varchar(max)
declare @loop int
declare @len int
declare @num int
declare @add int
declare @output varchar(max)
set @str=cast(@loopnumber as varchar(max))
set @loop=1while (@loop<@loopcount)
begin
set @output=''
    set @add=0
set @len=len(@str) while (@len!=0)
begin
set @num = cast(substring(@str,@len,1) as int)
set @num=@num*@loopnumber+@add
set @add=@num/10
set @output=cast(@num%10 as varchar(max))  +@output
set @len=@len-1
end
if(@add>=1)
begin
set @output = cast(@add as varchar(max))+@output
end
 set @loop=@loop+1
 set @str=@output
end
return @str
end

Answer 25

楼主既然说了 取巧的不算 ，那么，那些所谓几秒内就算出来，其实就只是利用2进制的特殊性算出来的，这个算不算取巧？真有本事，写一个A的B次方，然后再来比比。(A，B∈N)