Writing powers of 10 as constants compactly

亡梦爱人 提交于 2019-11-29 07:20:12

I would say that this is impossible because what you want is to represent a function 10^(3i) where i is a positive integer as some function f(i), where f is a compositive function of your elementary go functions (+, -, /, *).

It was possible for 2^(10i) only because go introduced another elementary function integer exponentiation. So if 1 << y would allow y being float, you would be able to modify your code to use 1 << (log2(10) * 3 * i). This would worked because this is equivalent to solving 10^(3i) = 2^y. Taking log2 of both sides y = log2(10) * 3 * i.

But sadly enough bitwise shift is an integer operation.

You quoted it yourself:

The iota mechanism has its limits. For example, it's not possible to generate the more familiar powers of 1000 (KB, MB, and so son) because there is no exponentiation operator.

The authors don't want you to still find a way despite they not knowing any. The authors want you to create constant declarations for KB, MB etc. as compact as you can.

With Floating-point literals

Here's a compact way. This utilizes Floating-point literals with exponent part. Think of it: writing 1e3 is even shorter than writing 1000 (not to mention the rest...).

Also it compresses all identifiers into one constant specification, so we reduce the = signs to 1.

Here it is, just one line (67 characters without spaces):

const ( KB, MB, GB, TB, PB, EB, ZB, YB = 1e3, 1e6, 1e9, 1e12, 1e15, 1e18, 1e21, 1e24 )

Note that since we used floating-point literals, the constant identifiers (KB, MB...) denote floating-point constants, even though the literals' fractional parts are zero.

With integer literal, using KB as the multiplier

If we want untyped integer constants, we have to write 1000 for the KB. And to get the next one, we would automatically turn to multiply the previous identifier with 1000. But note that we can also multiply the next one with KB because it's exactly 1000 - but shorter by two characters :).

And so here are the untyped integer constant declarations (77 characters without spaces):

const (KB,MB,GB,TB,PB,EB,ZB,YB = 1000,KB*KB,MB*KB,GB*KB,TB*GB,PB*KB,EB*KB,ZB*KB)

(Sorry for removing spaces, but wanted it to fit in one line.)

With integer literal, using an extra x const as the multiplier

You can even gain 3 characters from the last solution if you also introduce a 1-char length const x which you use multiple times to do the multiplication instead of the *KB:

With an extra x const (74 characters without spaces):

const (x,KB,MB,GB,TB,PB,EB,ZB,YB = 1000,x,x*x,MB*x,GB*x,TB*GB,PB*x,EB*x,ZB*x)

With rune literal

We can even shorten it one more character if we specify the 1000 constant as a rune constant, with a rune whose code point is 1000, which is 'Ϩ' - which is 1 character less :)

With a rune literal 'Ϩ' const (73 characters without spaces):

const (x,KB,MB,GB,TB,PB,EB,ZB,YB = 'Ϩ',x,x*x,MB*x,GB*x,TB*GB,PB*x,EB*x,ZB*x)

Note that these will be rune constants, but just as all other numeric constants, they represent values of arbitrary precision and do not overflow.

标签
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!