什么，这个帖子还不存在？

当然，GolfScript是由打高尔夫球，所以你可能会认为真的不需要特定的技巧。但是要充分利用GolfScript的功能，您需要学习一些非显而易见的技巧。这篇文章是收集这样有用的提示和技巧。

首先，这里是GolfScript官方参考页。您应该首先真正了解以下内容：

• 讲解
• 句法
• 内建
• 快速参考

特别是，我非常建议按此顺序阅读这些页面-快速参考没什么用，除非您已经相当熟悉内置函数，并且该教程包含了一些重要的细节，其他页面没有对此进行解释。 。

附言 为了启发和个人兴趣，以下是一些我想看到的不错的答案：

• 如何在GolfScript中进行有限音译？ {FROM?TO=}%作品如果你可以确保所有的输入中发现的FROM（或不介意他们都被映射到最后一个元素TO），但我已经看到了离开映射的值不变的方式已经更多或更少的klugey。

• 如何最好地将字符串转换为ASCII码数组并返回？这会产生副作用吗？将字符串中的字符转储到堆栈中的最佳方法是什么（就像~数组一样）？

有理/浮动/复杂

我读过很多遍了，以至于GolfScript只有整数，我才开始相信它。好吧，这不是真的。

2-1? # Raise 2 to the power of -1. Result: 0.5
4-1? # Raise 4 to the power of -1. Result: 0.25
+    # Add. Result: 0.75

输出是

3/4

使用标准的GolfScript解释器和

0.75

在Web GolfScript上。

类似的hack允许转换为Rational，Float甚至Complex：

{-2.?./*}:rational
{2.-1??./*}:float
{-2.-1??./*}:complex

取反数字

GolfScript缺少的一件事是内置的求反运算符。将堆栈上的数字转换为负数（例如-1*或）的显而易见的方法0\-需要三个字符。但是，有两种方法可以做到：

~)

这工作，因为GolfScript采用二进制补码算术，让〜X等于- X -1。

当然，该变体(~也适用；在它们之间进行选择通常是一个品味问题。

改组数组

在GolfScript中随机播放数组的最简单方法是通过随机排序键对其进行排序。如果您只需要粗略地改组一些值，则下面的代码将起作用：

{;9rand}$

请注意，即使是简短列表，也不会带来很好的随机播放。由于生日悖论，要获得合理统一的rand改组，必须将参数to 显着大于要改组的列表长度的平方。

因此9，用99多达10个元素的列表替换上述内容会给出较好的结果，但对于较长的列表则显示出明显的偏差。

以下代码使用9 ⁹ = 387,420,489个可能的值，适用于大约1000个左右的项目（并且可接受大约20,000个项目）：

{;9.?rand}$

对于非常长的列表，为⁹⁹ 99≈3.7×10 ^197的值再添加9 ：

{;99.?rand}$

测试：

这是使用上面显示的不同变体进行混洗的10个元素列表中的第一个元素的分布，对10,000个试验进行了采样：

• 的输出10,{;9rand}$0=显示出非常明显的偏差，0最终出现在第一个位置的可能性是1：

  0 16537 #######################################################
  1 5444  ##################
  2 7510  #########################
  3 8840  #############################
  4 9124  ##############################
  5 12875 ##########################################
  6 9534  ###############################
  7 8203  ###########################
  8 7300  ########################
  9 14633 ################################################
  

• 使用10,{;99rand}$0=，大部分偏差都消失了，但仍然有明显的数量：

  0 10441 ##################################
  1 9670  ################################
  2 9773  ################################
  3 9873  ################################
  4 10134 #################################
  5 10352 ##################################
  6 10076 #################################
  7 9757  ################################
  8 9653  ################################
  9 10271 ##################################
  

• 使用10,{;9.?rand}$0=，输出与真正的随机样本基本没有区别：

  0 9907  #################################
  1 9962  #################################
  2 10141 #################################
  3 10192 #################################
  4 9965  #################################
  5 9971  #################################
  6 9957  #################################
  7 9984  #################################
  8 9927  #################################
  9 9994  #################################
  

附言 为真的数字数组或字符串的坏改组，下面的代码有时可能是可接受的：

{rand}$

它通常会产生可笑的偏差，但是只要输入数组的所有元素（或字符串中的所有字符代码）都大于1，它就有非零的概率产生数组的任何排列，有时可能满足挑战要求写得不好。

要解决特定的子问题：

如何最好地将字符串转换为ASCII码数组并返回？这会产生副作用吗？将字符串中的字符转储到堆栈中的最佳方法是什么（就像〜对数组所做的那样）？

对于那些不了解问题的人，GolfScript的类型系统以整数，数组，字符串，块的顺序优先处理这些类型。这意味着应用于字符串的普通数组操作几乎总是为您提供字符串。例如

'ABC123'{)}%

将离开'BCD234'堆栈。

结果，将字符串转换为ASCII代码数组的最佳方法几乎肯定是将字符转储到堆栈中，然后将它们收集到一个数组中。

将字符串中的字符转储到堆栈中的最佳方法是什么？ {}/

将字符串转换为ASCII代码数组的最佳方法是什么？[{}/]（通常需要注意的是，如果堆栈上没有其他内容，则可以跳过[）

将ASCII码数组转换为字符串的最佳方法是什么？''+（请注意，这也会使数组变平，因此[65 [66 67] [[[49] 50] 51]]''+给出'ABC123'）

如果程序神秘地中断，请检查变量

我只是花了一些时间调试了一个看似正确的程序，该程序用作!了变量（理由是我不再使用它了）。不幸的是，我确实使用了if，事实证明if调用的实现!决定了要遵循的分支。

将栈顶项目包装成一个数组

有没有一种很好的方法可以转换... x成... [x]？

对于一般情况，最好的选择似乎是4个字符。但是，在某些特殊情况下，可以减少这种情况。

1个字符

]在特殊情况下工作，这x是堆栈上唯一的东西。

3个字符

[]+在特殊情况下x（整数）工作。

.,/在特殊情况下有效，它x是真实数组或字符串。例如"AB".,/给["AB"]; 3,.,/给[[0 1 2]]。然而，"".,/和[].,/两者都可以[]。

4个字符

[.;] 无条件工作。

在给定索引处修改数组的最佳方法是什么？– user1502040

这是个好问题。在GolfScript中没有直接的方法将值分配给数组元素，因此，您将不得不重新构建整个数组。

我知道在数组的x索引处插入一个新值的最短的一般方法i是在给定的索引处拆分该数组并追加x到前半部分，然后再将它们重新连接在一起：

• .i<[x]+\i>+（11个字符）-将值x插入到（从0开始）索引处的数组中i

为了替换在指数值i有x，我们只需要一个元素缩短阵列下半年：

• .i<[x]+\i)>+（12个字符） -在更换元件（从0开始）的索引i与该值x

或者，缩短前半部分将有效地执行相同的操作，但是使用基于1的索引，有时可能更可取：

• .i(<[x]+\i>+（12个字符）-将（基于1的索引）的元素替换i为值x

在上面的所有示例中，如果x为数字，则可以省略方括号以节省两个字符，因为+无论如何它将自动强制为数组：

• .i<x+\i>+（9个字符）-将数字x插入到（从0开始）索引处的数组中i
• .i<x+\i)>+（10个字符） -在更换元件（从0开始）的索引i与所述数x
• .i(<x+\i>+（10个字符） -在更换元件（从1开始）的索引i与所述数x

如果x输入数组或输入数组中的任何一个实际上是字符串，则也可以省略括号，在这种情况下，结果也将被强制转换为字符串（使用常规数组→字符串转换规则）。

附言 作为一种特殊情况，如果我们知道该数组具有介于i和之间的2个× i元素，则可以x在（基于0的）索引处i使用i/[x]*（6个字符）插入一个新元素。这实际上是将数组拆分为最多i元素的块，并x在每个块之间插入。请注意，在这种情况下，即使x是数字，也必须使用方括号。

点子 另一种方法是使用动态命名的变量。例如，

 'foo' 42 ':x'\+~

将值分配给'foo'变量x42，而

 42 'x'\+~

将检索它。

您可以通过省略x前缀并直接将其直接分配给数字文字来进一步优化这一点-这在GolfScript中是完全合法的，它允许您从分配代码中保存一个字符，并将检索代码缩短为公正`~（或根本没有）。索引是常数！）。当然，不利的一面是，分配给数字文字会覆盖代码中其他任何地方的文字值。但是，通常可以避免使用数字文字（或至少在重新分配它们之前限制于程序的开头），在这种情况下，这种技巧非常好。

最终输出操纵

默认情况下，当您的程序结束时，GolfScript解释器将输出堆栈中的所有内容以及最后的换行符，就像您的程序结束时一样：

]puts

该文档没有直接提及的是，解释器从字面上调用了内置函数puts以产生此输出，并且该内置函数的字面意义定义为：

{print n print}:puts;

因此，可以抑制或通过重新定义控制最终的输出puts，print 和/或n（或者 ，如果你感觉真的扭曲）。这里有些例子：

禁止最后的换行符：

'':n;

（当然，;如果您不介意堆栈上有多余的空字符串，则可以省略。）

完全禁止最终输出：

:puts

这将覆盖puts堆栈顶部的所有内容。如果碰巧是您不想执行的操作，则可以使用eg 0:puts;代替。请注意，这也会抑制p（定义为{`puts}:p;），但是print如果需要，您仍然可以将其用于输出。

我想问问最好的方法：最小，最大和绝对值。我所有的解决方案似乎占用了更多的字符。–克劳迪

最小/最大

要查找数组中的最小/最大值，只需对其进行排序并采用第一个/最后一个元素：

• $0= （3个字符）-一次装载中的最小元素
• $-1= （4个字符）-数组中的最大元素

如果您知道数组的长度，并且不超过10个元素，则可以通过替换-1最后一个元素的索引来找到三个字符的最大值。

如果堆栈中有值，则可以先将它们收集到数组中。为此，一个偶尔有用的技巧是[\]将堆栈的前两个元素收集到一个数组中，而[@]将前三个元素收集起来。因此，我们得到：

• [\]$0= （6个字符）-堆栈上至少两个值
• [@]$0= （6个字符）-堆栈上至少三个值
• [\]$1= （6个字符）-堆栈上最多两个值
• [@]$2= （6个字符）-堆栈上最多三个值

也可以使用相同的技巧来找到三个值的中位数，这有时会很有用：

• [@]$1= （6个字符）-堆栈上三个值的中位数

这是找到两个值的最小值/最大值而又将原始值保留在堆栈上的另一个可能有用的技巧：

• .2$>$ （5个字符）-在堆栈中查找至少两个值，同时保持原始值不变
• .2$<$ （5个字符）-在堆栈中查找最多两个值，同时保持原始值不变

它的工作方式是以.2$相反的顺序克隆堆栈中的前两个元素（即a b→ a b b a），</ >比较副本并返回0或1，然后标量$然后根据比较结果复制两个输入值中的任意一个。

如果堆栈上有两个非负整数，则可以使用,\,&,（5个字符）查找其最小值，使用,\,|,（5个字符）查找其最大值。此技巧将在范围内分别使用设置交集和并集。如果可以,单独应用于每个参数而不必交换它们，则可以保存另一个字符。由于此方法会为每个参数计算一个范围，因此对于较大的数字而言效率不高，但对于较小的输入可能非常有用。

在堆栈上查找最少两个非负整数的更短方法是,<,（3个字符）。,，此技巧无法找到最大值。

绝对值

GolfScript 内置的绝对值运算符为abs（3个字符）。虽然这比我想要的多两个字符，但总体上很难击败。

在某些情况下（例如，按绝对值排序），您可能会发现数字的平方可以替代其绝对值；这可以用两个字符计算，即2?或.*。因此，我们得到：

• {.*}$0= （7个字符）-数组中按绝对值最小的元素
• {.*}$-1= （8个字符）-数组中按绝对值表示的最大元素

类似地，您无需测试数字的绝对值是否小于3 abs 3<（6个字符，包括空格），而是可以测试其平方是否小于9 .*9<（4个字符，无需空格）。

从阵列中删除重复项

集合运算符|（联合），&（交集）和^（对称差）会将多个数组元素折叠为一个。因此，从数组中删除重复元素的最简单方法是使其与自己的并集或交集：

.|

要么：

.&

这些运算符会将字符串视为字符数组，因此它们也可以用于从字符串中删除重复的字符。

音译受限

解决特定的子问题：给定字符串，执行a的最佳方法是tr什么？例如tr/ABC/abc/

如果字符串中的所有字符都将受到影响，则这很简单：（{'ABC'?'abc'=}%开销：9个字符）。

但是，如果某些字符没有音译并'ABC'?给出，则会中断-1。

如果音译是非循环的，则可以使用字符串拆分和连接来一次替换一次：（'AaBbCc'1/2/{~@@/\*}/开销：15个字符）。这可能是可取的，但是有一种替代方法目前更好，并且适用于循环音译。

当前，最短的一般解决方案的开销为14个字符：

• 一种方法涉及转义字符：，其中表示原义的空字节。（当然，此方法并不完全通用：它无法将任何其他字符映射到一个空字节中。）{.'ABC'?'abc0'=\or}%0

• 或者，{.'ABC'?'abc'@),+=}%具有相同的开销，但仅使用可打印的ASCII字符。这@),+是一种复杂的方法（但显然是最短的方法），以确保替换字符串始终以输入字符结尾。

将字符串转换为char数组

您可以1/在其后输入： 。

示例： "String"1/推送以堆叠数组['S''t''r''i''n''g']。

当您要在字符串中移动字符时，这很方便。

分配给数字文字

通常，无需编写1:x然后使用/更新变量x，您可以直接使用和更新1：

1:^;{^.p.+:^;}5*
{1.p.+:1;}5*       (4 bytes shorter)

当然，这也适用于其他起始值，但是如果该值出现在代码中的其他位置，则会中断。

标点符号作为变量名

如果您有使用变量，它也常常明智地使用标点符号，是不是已经在你的代码-大量的程序也离不开谁&，|，^，或?。例如，通过这种方式，您可以编写&n而不是x n先推送变量，然后再推送换行符。

过滤数组

过滤数组的最通用方法是使用{ },，它为数组的每个元素评估代码块，并选择其结果值为true的那些元素（即，其行为类似于grepPerl）。

但是，使用数组减法运算符-通常会更短。此运算符采用两个数组，并从第一个数组中删除第二个数组中出现的每个元素。它不会更改第一个数组中元素的顺序，也不会折叠重复项。一个有用的技巧是应用两次减法运算以产生非折叠数组相交运算符：

• a b -：b从数组中删除在数组中找到的所有元素a
• a. b --：去除任何要素不阵列发现b从阵列a

特别是，它可以用于计算元素在数组中出现的次数：

• a.[c]--,：计算元素c在数组中出现的次数a

通常，此方法不是最佳方法，原因是：

• a[c]/,(：计算元素c在数组中出现的次数a
• a{c=},,：计算元素c在数组中出现的次数a

短一个字符（如果可以将计数减一，则a[c]/,可以节省一个字符）。但是，在特殊情况下，c是一个数字并且a是一个普通数组（不是字符串），c由于-操作符会将其参数强制转换为相同类型，因此可以省略方括号。

• a.c--,：计算该数字c在数组中出现的次数（不是字符串！）a

（如果a是字符串，并且c是介于0到9之间的数字，a.c--则将计算数字 c在中出现的次数a。）

可以使用类似的技巧来查找数组中最常见的元素：

:a{a\[.]-,}$0=

同样，如果输入是数字数组，[.]则可以省略整个序列。las，如果没有，这不适用于字符串[.]。

从STDIN读取

GolfScript可以从stdin中读取：

"#{STDIN.read}"

这将继续从STDIN读取，直到达到EOF。或者：

"#{STDIN.gets}"

要么

"#{STDIN.readline}"

其他可用的东西：

getbyte
getc
gets([sep])
gets(limit)
gets(sep, limit)
inspect # perhaps useful for an underhanded contest
isatty
read([length])
readbyte
readchar
readline([sep])
readline(limit)
readline(sep, limit)
readlines([sep])
readlines(limit)
readlines(sep, limit)
readpartial(maxlen [, outbuf])

对于这些参数中的每一个，它们只能使用一次（对于参数的每次更改也只能使用一次，也可以在带有空括号的情况下再次使用）；之后，您将获得的是原始值，而不是新值。

解码十六进制输入

GolfScript没有十六进制整数文字，因此，a，您不能仅使用解析十六进制输入~。相反，如果您的代码必须接受十六进制输入，则需要手动对其进行解析。

应用于字符串的此8个字符的循环会将小写的十六进制数字转换为其等效的数字：

{39%9-}%

如果您必须（也）接受大写的十六进制数字，最简单（也可能是最短的）的解决方案是首先使用32|来对它们进行小写，总共11个字符：

{32|39%9-}%

请注意，从技术上讲，输出仍将是字符串（由ASCII字符0到15组成），但是大多数GolfScript数组函数也将接受字符串。如果您绝对需要一个数组，则可以始终使用[{39%9-}/]（[如果堆栈为空，则第一个是可选的）。

要将上面代码的输出转换为整数，您可以简单地使用16base（6个字符）。如果您想要一个字节数组，我找到的最短的解决方案就是用2/{16base}%（11个字符）解码每对十六进制数字。综上所述，我发现将十六进制字符串转换为字节数组的最短代码是8 + 11 = 19个字符：

{39%9-}%2/{16base}%

请注意，这段代码的输出是确实是一个数组，而不是一个字符串。如果需要，可以通过将其串联来对它进行字符串化，例如，用""+或，如果您不介意在末尾添加多余的换行符，则使用n+。

定义新的内置运算符

标准的GolfScript解释器具有很少使用的功能，该功能允许在双引号字符串文字中插入Ruby代码。

之所以不常用此功能的原因之一是，尴尬的是，内插的代码在编译时执行，并且输出由GolfScript解释器缓存，因此，即使在内部，相同的字符串文字也始终会产生相同的值。字符串评估。

但是，此功能最有利的一件事是定义以Ruby代码实现的新的GolfScript运算符。例如，以下是定义新的二进制加法运算符的方法，该运算符的工作方式与标准内置+运算符相同：

"#{var'add','gpush a+b'.cc2}";

将定义放在代码中的位置并不重要；解析包含Ruby代码的双引号字符串后，就会定义新的运算符。在add上述工程定义的操作完全相同，如内置的+运营商，并可以以完全相同的方式来使用：

1 2 add          # evaluates to 3
"foo" "bar" add  # evaluates to "foobar"

当然，定义一个新的加法运算符是毫无用处的，除非您做了一些愚蠢的事情，例如擦除内置+运算符。但是您可以使用相同的技巧来定义新的运算符，这些运算符可以执行Golfscript无法（轻松）完成的本机操作，例如，统一对数组​​进行改组：

"#{var'shuf','gpush a.factory(a.val.shuffle)'.cc1}";

10,shuf          # evaluates to 0,1,2,...,9 in random order

或打印整个堆栈的内容：

"#{var'debug','puts Garray.new($stack).ginspect'.cc}";

4,) ["foo" debug  # prints ["" [0 1 2] 3 "foo"], leaving the stack untouched

或交互式输入：

"#{var'gets','gpush Gstring.new(STDIN.gets)'.cc}";

]; { "> " print gets ~ ]p 1 } do   # simple GolfScript REPL

甚至是网络访问：

"#{
  require 'net/http'
  require 'uri'
  var'get','gpush Gstring.new(Net::HTTP.get_response(URI.parse(a.to_s)).body)'.cc1
}";

"http://example.com" get

当然，后者的实现有些高尔夫球手（也可能更危险！）的实现为：

"#{var'get','gpush Gstring.new(`curl -s #{a}`)'.cc1}";

尽管它本身并不特别具有高尔夫球性，但是它使您可以将GolfScript的功能扩展到内置命令所提供的范围之外。

它是如何工作的？

当然，有关如何以这种方式定义新的GolfScript运算符的权威参考是解释器的源代码。也就是说，这里有一些快速提示：

• 要定义一个name运行Ruby代码的新运算符code，请使用：

  var'name','code'.cc

• 在代码内部，可用于gpop从堆栈中读取值，然后gpush将其压回。您还可以直接通过array访问堆栈$stack。例如，要将两者a同时b推入堆栈，要比做高尔夫球手$stack<<a<<b要好gpush a;gpush b。

  • 所述的位置[阵列启动标记被存储在所述$lb阵列。gpop如果堆栈缩小到其位置以下，该函数会注意将这些标记向下调整，但$stack直接操作数组则不会。

• 将.cc字符串中的Ruby代码编译为GolfScript运算符的字符串方法只是一个方便的包装Gblock.new()。它也有变种.cc1，.cc2并且.cc3使操作者自动弹出1，2或3个参数从堆栈中，并将其分配给变量a，b和c。还有一种.order类似的方法.cc2，除了它会根据类型priority将参数自动排序。

• 在GolfScript堆栈上的所有值（也应该！）类型的对象Gint，Garray，Gstring或Gblock。底层本地整数或数组（如果需要）可以通过.val方法访问。

  • 但是，请注意Gstring.val返回Gints 的数组！要将a Gstring转换为本地Ruby字符串，请调用.to_s它（或在自动执行此操作的上下文中使用它，例如字符串插值）。调用.to_gs任何GS值都会将其转换为Gstring，因此任何GS值都可以使用进行字符串化.to_gs.to_s。

• 该gpush函数不会自动将本地Ruby数字，字符串或数组自动包装到相应的GS类型中，因此，您通常必须自己通过显式调用eg来做到这一点Gstring.new()。如果将GS值类型之一以外的任何其他内容推入堆栈，则以后尝试对其进行操作的任何代码都可能崩溃。

• GS值类型还具有.factory调用该类型的构造函数的方法，该方法可能非常有用，例如，在处理它们的内容后重新包装数组/字符串。所有类型都有一个.coerce执行类型强制的方法：a.coerce(b)返回一对包含a并b强制为相同类型的对。