将10的幂作为常量紧凑地书写 [英] Writing powers of 10 as constants compactly

问题描述

我正在阅读最近发布的 Go编程语言，迄今为止一直是一种喜悦（Brian Kernighan是其中之一作者，我不会期望任何卓越成就）。

我在第3章中遇到了以下练习：

练习3.13
为KB，MB写入 const 声明YB，您可以紧凑。

（注意：在此上下文中，KB，MB等，表示权力为1000）

在前面加入 iota 作为有用的常量生成器机制。特别是，前面的段落展示了一个很好且紧凑的方法来定义1024的幂作为常量：

pre $ const $ $ $ $ b _ = 1 <<（10 * iota）
KiB
MiB
GiB
TiB
PiB
EiB
ZiB






$ b

作者进一步提到了10的权力：

iota 机制有其限制。例如，由于不存在指数运算符，因此不可能生成1000（KB，MB等等）更熟悉的权力。

我在这个练习中苦苦挣扎，因为它看起来像预期的解决方案比纯粹用手写出1000的权力更复杂一点（尤其是因为它出现在 iota 被引入）。我觉得有一些聪明的方式来做到这一点，使用 iota 以微妙的方式结合其他东西。

我想过要找到一种有系统的方法来从1024的每个幂中减去超额的数量以获得1000的幂，但它使我无处可去。然后，我看着二进制表示，试图推断出 iota 可能有用的一般模式，但我再一次没有任何结果。

我真的不知道如何在没有幂运算符的情况下从单个递增值（ iota ）产生1000的幂。

有什么想法？

解决方案

我会说这是不可能的，因为你想要的是表示一个函数 10 ^（3i）其中 i 是一个正整数，因为某些函数 f（i），其中 f 是您的基本go函数（+， - ，/，*）的集成函数。

仅仅因为引入了另一个基本函数整数指数，所以 2 ^（10i）是可能的。所以如果 1 << y 将允许y浮动，您将能够修改您的代码以使用 1<< （log2（10）* 3 * i）。这会奏效，因为这相当于解决 10 ^（3i）= 2 ^ y 。以双方的log2 y = log2（10）* 3 * i 。

但是遗憾的是，按位移是一个整数运算。

I'm reading the recently released The Go Programming Language, and it's been a joy so far (with Brian Kernighan being one of the authors, I wouldn't expect anything other than excellence anyway).

I've came across the following exercise on chapter 3:

Exercise 3.13 Write const declarations for KB, MB, up through YB as compactly as you can.

(NOTE: in this context, KB, MB, etc, denote powers of 1000)

This is preceded by a section where iota is introduced as a useful constants generator mechanism; in particular, the previous paragraph shows a nice and compact way to define the powers of 1024 as constants:

const (
    _ = 1 << (10 * iota)
    KiB
    MiB
    GiB
    TiB
    PiB
    EiB
    ZiB
    YiB
)

The authors further mention this regarding powers of 10:

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.

I'm struggling with this exercise because it looks like the expected solution is something a little more elaborate than simply spelling out the powers of 1000 by hand (especially since it appears after iota is introduced). I feel like there is some clever way to do this that uses iota in a subtle way combined with something else.

I thought about finding a systematic way to subtract the "excess" amount out of each of the powers of 1024 to get the powers of 1000, but it led me to nowhere. Then I looked at the binary representations to try and infer a general pattern where iota could be useful, but again, I got nothing.

I really can't see how one would generate powers of 1000 out of a single incrementing value (iota) without an exponentiation operator.

Any ideas?

解决方案

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.

这篇关于将10的幂作为常量紧凑地书写的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！