23

更新：取消了时间限制。您必须能够描述输出-请参阅新规则。

一个全字母短句是使用字母表中的每个字母至少一次，如句子：

敏捷的棕色狐狸跳过了懒狗。

一个完美的全字母短句使用每个字母一次。

考虑使用95个可打印的ASCII字符（十六进制代码20至7E）作为字母编写完美的pangram程序：

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

这样的程序必须完全包含95个字符，每个可打印的ASCII字符仅出现一次，但顺序不限。（因此有95！= 1.03×10 ^148个可能性。）

您的任务是编写此程序，以使打印到stdout的可打印ASCII字符数尽可能多（即，多产）。

您的分数是程序输出的可打印ASCII字符数（总数，而不是不同的数字：AABC分数4，而ABC分数3）。最高分获胜。

细节

输出可能包含任何字符（包括重复字符），但只有95个可打印ASCII字符的实例才计入您的分数。
- 您可以使用此JSFiddle来计算任何字符串中可打印ASCII字符的数量。
如果您的语言没有标准输出，请使用最合适的替代方法。
您的程序...
- 必须具有有限的运行时（时间限制已删除）
- 必须具有有限的输出
- 可能包含评论
- 必须编译并运行时没有（未捕获）错误
- 不得提示或要求输入
- 必须是时间不变的和确定性的
- 不得使用外部库
- 一定不需要网络连接
- 不得使用外部文件
  - （您可以使用程序文件本身，只要更改文件名不会改变程序的行为）
如果这项任务不可能完成，那是某种糟糕的语言。
如果输出太大而不能容纳在帖子中，则必须给出准确的输出或准确地描述它。您实际上不必运行程序。只要将在有限的时间量在计算机上运行的内存无界量它是有效的。

例

这个简单的Python 2程序是可能的解决方案：

print 9876543210#!"$%&'()*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghjklmoqsuvwxyz{|}~

它输出9876543210包含10个可打印ASCII字符，因此得分为10。

— 卡尔文的爱好
source

14

令人赞叹的是赞扬的出现，而pangram却给人带来极大的冲击，因为它们令人烦恼。

— Geobits

2

我也只是重新阅读了完全不相同的规则。我之前略过了一下，认为这显然是一个不完全的规则，因为替代方法会导致荒谬的构造，例如将字母印刷a六次，达到六千万次，甚至无法获得精确的上限。字符数。无论如何，我仍然为自己的95感到骄傲，即使它很小。你知道大小不是一切。

— COTO 2014年

您为什么认为在HQ9 +中无法完成此任务？

— 彼得·泰勒

我将尝试在FORTRAN中执行此操作（因此我可以利用大小写不敏感）。---然后抓它。我需要4次字母O：2次用于程序声明，2次用于循环声明。

— Nzall 2014年

1

@丹尼斯5号

— 卡尔文的爱好

12

GolfScript，超过2个↑↑↑（9871↑↑2）个字符

2 9871.?,{;0$[45)63]n+*~}/
#!"%&'(-:<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_`abcdefghijklmopqrstuvwxyz|

打印一个整数。利用无限的CPU寄存器大小（这决定了Ruby中的最大字符串长度），内存和运行时间。换行仅用于可读性。

代码

2             # Push 2.
9871.?        # Push b := 9871↑↑2 = 9871↑9871 = 9871**9871.
,{            # For each i from 0 to b - 1:
  ;0$         #   Discard i and duplicate the integer on the stack.
  [45)63]n+*  #   Replicate ".?\n" that many times.
  ~           #   Evaluate.
 }/           #

分数

定义b = 9871↑↑2（请参阅Knuth的向上箭头表示法）。

。？执行f：x↦x↑x。
内部块执行g：x↦f ^x（x）。

由于f（x）= x↑x = x↑↑2，因此f ²（x）=（x↑x）↑（x↑x）> x↑x↑x = x↑↑3，
f ³（x）= （（（x↑x）↑（x↑x））↑（（x↑x）↑（x↑x））>（x↑x↑x）↑（x↑x↑x）> x↑x↑x↑ x = x↑↑4等等，我们有
g（x）> x↑↑（x + 1）> x↑↑x。
外部块执行h：x↦g ^b（x）。

因为g（x）= x↑↑x = x↑↑↑2，所以g ²（x）=（x↑↑x）↑↑（x↑↑x）> x↑↑x↑↑x = x↑↑↑ 3，
g ³（x）=（（x↑↑x）↑↑（x↑↑x））↑↑（（x↑↑x）↑↑（x↑↑x））>（x↑↑x↑↑ x）↑（x↑↑x↑↑x）> x↑↑x↑↑x↑↑x = x↑↑↑4等，我们得到h（x）> x↑↑↑（b + 1）。
我们从堆栈上的整数2开始，因此代码计算出h（2）> 2↑↑↑（b + 1）。
分数是h（2）的小数位数，即log（h（2））+1> log（2↑↑↑（b + 1））> 2↑↑↑b。

因此，分数大于2↑↑↑（9871↑↑2）。

2↑↑↑ñ生长在一个荒谬的步伐ñ变得更大。2↑↑↑4：= 2↑↑2↑↑2↑↑2 = 2↑↑2↑↑4 = 2↑↑65536，它是65536份2的右缔合力量塔：

类似地，2↑↑↑5：= 2↑↑（2↑↑↑4） ，这是一个电力塔2↑↑↑4份2。

现在，分数不是2↑↑↑4或2↑↑↑5，而是大于2↑↑↑b，其中b> 2×10 ^{39 428}。这个数目很大...

— 丹尼斯
source

@DigitalTrauma-您应该检查我的;）

— Optimizer

@Dennis-大概多少钱？

— Optimizer

@Optimizer，你懂我；-)

— Digital Trauma

太棒了！这让我想起了格雷厄姆的电话号码。

— 重写

3

请注意，尽管从理论上讲这应该打印出非常多的零，但实际上它只会使解释器崩溃in `*': bignum too big to convert into `long' (RangeError)。

— Ilmari Karonen 2014年

22

Perl，70 * 18446744073709551615 * 10 ^ 987654320

say q{!"#%&'+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\]^_`bcdfghijklmnoprtuvwz|}x(1e987654320*~$[)

输出：

!"#%&'+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\]^_`bcdfghijklmnoprtuvwz|

重复18446744073709551615 * 10 ^ 987654320次。

$[默认情况下为0，因此~$[等效于18446744073709551615。

附带说明一下，我用尽了内存来尝试创建数字10^987654320。

旧答案（7703703696）：

say qw(!"#$%&'*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdefghijklmnoprtuvz{|}~10)x98765432

输出为：

!"#$%&'*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdefghijklmnoprtuvz{|}~10

重复98765432次。

注意：使用 perl -Mbignum -E

— es1024
source

真好！但我想知道是否可以使用递归...（如果必须使用自己的名称，则无法调用自己，因为它将重复名称中的字符...但函数名称不能以$ _结尾或Perl的另一个变量？）..或巧妙地使用$ 0调用（无需填充堆）

— Olivier Dulac 2014年

如果您有足够的内存，则可以perl -E'say qw{m}x(9876543210*ord$")'

— hmatt1 2014年

2

如果有帮助，则不再有时间或内存限制。

— 卡尔文的爱好2014年

2

不幸的是Perl使用**而不是^进行求幂。

— 2014年

11

Bash + coreutils，151,888,888,888,888,905（1.5 * 10 ^ 17）

seq 9E15;#\!%*+,-./2346780:=@ABCDFGHIJKLMNOPQRSTUVWXYZ]^_abcdfghijklmnoprtuvwxyz~"'$&()?<>`{}|[

输出整数1到9x10 ¹⁵，每行一个。需要很长的时间。

为什么9E15呢事实证明，GNU seq似乎在内部使用64位浮点数（双精度）。我们可以用这种类型表示的最大整数，在由于缺乏精度而导致递增停止停止之前为2 ⁵³或9007199254740992。我们可以用指数表示法最接近的整数是9E15或9000000000000000。

为了计算分数，我将所有具有给定数字位数的数字相加并加上9E15，因为每个数字之间都有换行符：

8000000000000001*16 + 900000000000000*15 + 90000000000000*14 + 9000000000000*13 + 900000000000*12 + 90000000000*11 + 9000000000*10 + 900000000*9 + 90000000*8 + 9000000*7 + 900000*6 + 90000*5 + 9000*4 + 900*3 + 90*2 + 9 + 9000000000000000

我可以将此输出传递od一个额外的数量级左右，但这会使分数计算变得更加困难。

规则变更前答案：

Bash + coreutils，18,926,221,380

seq 1592346780;#\!%*+,-./:=@ABCDEFGHIJKLMNOPQRSTUVWXYZ]^_abcdfghijklmnoprtuvwxyz~"'$&()?<>`{}|[

输出1到1592346780。在我的2012年中期的Macbook（与链接的基准相差不远）上，这大约需要9分45秒。

_{即使它可能毫无意义，我也忍不住要对其进行更多优化。}

输出：

$ time ./pangram.sh | wc
 1592346780 1592346780 18926221380

real    9m46.564s
user    11m7.419s
sys 0m10.974s
$

— 数字创伤
source

你为什么不干seq 9876543210;呢？

— durron597 2014年

@ durron597因为花费的时间太长-大概一个小时。它需要在10分钟内完成。

— Digital Trauma

但是可以肯定的是，该程序的唯一限制因素是I / O ...使用任何其他语言编写的任何其他程序都无法真正胜过这一点。

— durron597

@ durron597是的，我认为是正确的。虽然如果这个社区中的某人找到聪明的方法，我不会感到惊讶……

— Digital Trauma 2014年

1

@DigitalTrauma我实际上是在删除时间限制，以确保这不是倒数第二个答案（没有冒犯性，我就是不想比赛这么快结束：P），所以请随时使用9876543210。您可能需要阅读新的最后一条规则。

— 卡尔文的爱好

6

GolfScript，≈3 * 10 ^（2 * 10 ^ 7），即≈3x10 ^20000000

 87 9654321?,`0${;.p}/#!"%&'()*+-9:<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnoqrstuvwxyz|~

怎么运行的

87 9654321?                "Pushes 87^9654321 to stack";
           ,               "Pushes an array [0, 1, 2 ... (87^9654321) - 1] to stack";
            `              "Creates a string representation of the array like "[0 1 2...]";
             0$            "Copies the string";
               {;.p}/      "Print the string wrapped in quotes X times";
                     #...  "This is all comment";

这X是数组的字符串表示形式的字符计数（长度），[0, 1, 2..,(87^9654321) - 1]类似于[0 1 2 3 4 ... (87^9654321) - 1]

~~我试图在X这里计算以便找到我的分数。 (87^9654321) - 1大约10^(10^7.272415829713899)是18724742十进制数字。~~

X大致上也是3*10^(2*10^7)如此X*X。请注意，由于（甚至）wolframa的计算限制，这些值处于较低的一侧，我无法计算出sum (floor(log10(x)) + 1) for x = 1 to (87^9654321 - 1)哪个是的真实值X

— 优化器
source

从理论上讲，有几种方法可以使它变得更加安全，但可悲的是Ruby的BigNum确实有局限性，而且87 9654321?是公正的Infinity。

— 丹尼斯

哦! ？你知道最大吗？;）

— Optimizer

不完全是。似乎取决于计算机，因为整数必须适合RAM。有了无限的内存，我不知道限制在哪里。可能2**(2**64)-1适用于64位Ruby。

— 丹尼斯

我们拥有的RAM无限量

— 优化

是的，这就是为什么我要澄清。对于CJam，有一个固定的限制，并且当您耗尽内存时，解释器会崩溃。Ruby似乎与众不同。

— 丹尼斯

4

MATLAB，95

码

char(37-5:126)% !"#$&'*+,./0489;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bdefgijklmnopqstuvwxyz{|}~

输出量

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

输出包含所有指定的ASCII字符，每个字符一次，并且顺序正确。

— 首席技术官
source

1

观众注意：当规范要求最大化唯一字符时，将提交此答案。这不再是目标，但是可以保留该答案，因为它是有效的。

— 卡尔文的爱好2014年

2

Ruby，89岁

p %q{!"#$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnorstuvwxyz|~}

输出：

"!\"\#$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnorstuvwxyz|~"

包含所有ASCII字符除外，p，，%，q，{，和}。

— 门把手
source

1

观众注意：当规范要求最大化唯一字符时，将提交此答案。这不再是目标，但是可以保留该答案，因为它是有效的。

— 卡尔文的爱好2014年

2

GolfScript，93岁

{ !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|~}

输出：

{ !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|~}
}

包含除"和以外的所有ASCII字符'。

— 门把手
source

6

虽然您的程序不是完美的功能，是吗？它似乎没有包含"或'两种。

— Martin Ender 2014年

观众注意：当规范要求最大化唯一字符时，将提交此答案。这不再是目标，但如果此答案有效就可以保留。

— 卡尔文的爱好2014年

1

使其在新规则下有效很容易：只需将#其从当前位置移除，然后追加#"'到末尾即可。不过，分数将下降1。

— Ilmari Karonen 2014年

2

高尔夫球稿-27 * 2 ^{6543 ⁹⁸⁷⁰}

这是我第一次提交Golfscript！:)

12,`{.+}6543 9870?*#!"$%&'()-/:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz|~

说明：

12,                     - Creates an array of ascending numbers from 0 to 11
   `                    - Converts the array to a string
    {.+}                - Duplicates the string on the stack and concatenates the two
        6543 9870?      - Calculates 6543^9870 and pushes it to the stack
                  *     - Repeat the block 6543^9870 times
                   #... - The rest is a comment

输出是数字列表。考虑以下代码：

12,`{.+}1*

使用12,它会产生以下数组：

[0 1 2 3 4 5 6 7 8 9 10 11]

反引号将其转换为字符串，并将其传递给block {.+}。这将复制字符串，然后将两者连接起来，从而产生：

[0 1 2 3 4 5 6 7 8 9 10 11][0 1 2 3 4 5 6 7 8 9 10 11]

该1*指令告诉解释程序一次执行前一个块（2 ¹ = 2）。

因此，基于此：

 12,`{.+}n*

输出12,`2 ⁿ次输出。

— Beta衰变
source

与可打印ASCII有关的多产的完美Pangram程序

细节

例

GolfScript，超过2个↑↑↑（9871↑↑2）个字符

代码

分数

Perl，70 * 18446744073709551615 * 10 ^ 987654320

旧答案（7703703696）：

Bash + coreutils，151,888,888,888,888,905（1.5 * 10 ^ 17）

Bash + coreutils，18,926,221,380

输出：

GolfScript，≈3 * 10 ^（2 * 10 ^ 7），即≈3x10 20000000

MATLAB，95

Ruby，89岁

GolfScript，93岁

高尔夫球稿-27 * 2 6543 9870

GolfScript，≈3 * 10 ^（2 * 10 ^ 7），即≈3x10 ^20000000

高尔夫球稿-27 * 2 ^{6543 ⁹⁸⁷⁰}