您可以为Ruby打高尔夫球提供哪些一般技巧？

我正在寻找可用于编码一般针对Ruby的高尔夫问题的想法。（例如，“删除评论”将不是答案。）

请为每个答案发布一个提示。

• 100至126可被写为数字?d到?~ 1.8。
• 同样，如果您需要1.9中的单字符字符串，则x小于“ x”。
• 如果您需要打印字符串而不附加换行符，$><<"string"则比print"string"。
• 如果您需要阅读多行输入，$<.map{|l|...}则比短while l=gets;...;end。你也可以用$<.read它一次阅读所有内容。
• 如果您应该从文件中读取文件，$<并且gets文件名位于中，则将从文件中读取文件而不是stdin文件ARGV。因此，要重新实现golfiest方式cat是：$><<$<.read。

使用splat运算符可获取数组的尾部和头部：

head, *tail = [1,2,3]
head => 1
tail => [2,3]

这也可以用另一种方式工作：

*head, tail = [1,2,3]
head => [1,2]
tail => 3

将*方法与数组上的字符串一起使用以连接元素：

[1,2,3]*?,
=> "1,2,3"

• 使用abort终止程序和打印字符串STDERR -短于puts后跟exit
• 如果您阅读带有的行gets，则可以使用~/$/来查找其长度（如果存在，则不算结尾的换行符）
• 使用[]检查一个字符串包含另一个：'foo'['f'] #=> 'f'
• 使用tr代替进行gsub按字符替换：'01011'.tr('01','AB') #=> 'ABABB'
• 如果您需要删除结尾的换行符，请使用chop代替chomp

结束你的end。

尝试end从您的代码中删除。

不要def...end用来定义函数。在Ruby 1.9中使用new->运算符创建一个lambda。（->运算符是“ stabby lambda”（即“破折号火箭”）。）每个函数可节省5个字符。

# 28 characters
def c n
/(\d)\1/=~n.to_s
end

# 23 characters, saves 5
c=->n{/(\d)\1/=~n.to_s}

方法调用是c n或c(n)。Lambda电话是c[n]。将每个字符更改c n为c[n]1个字符，因此，如果可以使用c n5次以上，请保留该方法。

所有采用do...end块的方法都可以采用{...}块代替。这样可以节省3到5个字符。如果的优先级{...}太高，请使用括号对其进行修复。

# 48 characters
(?a..?m).zip (1..5).cycle do|a|puts a.join','end

# WRONG: passes block to cycle, not zip
(?a..?m).zip (1..5).cycle{|a|puts a.join','}

# 45 characters, saves 3
(?a..?m).zip((1..5).cycle){|a|puts a.join','}

更换if...else...end用三元运算符 ?:。如果分支有两个或多个语句，则将它们括在括号中。

# 67 characters
if a<b
puts'statement 1'
puts'statement 2'else
puts'statement 3'end

# 62 characters, saves 5
a<b ?(puts'statement 1'
puts'statement 2'):(puts'statement 3')

您可能没有while或until循环，但如果有或循环，则以修饰符形式编写它们。

(a+=1
b-=1)while a<b

除w0lf

使用数组时，.compact可以替换-[nil]为保存2个字符。

与上面的组合->您可以使其更短-[p]以节省另外2个字符。

使用短预定义变量只要有可能，例如$*代替ARGV。有他们的好名单在这里，有很多其他有用的信息。

当您使用字符串插值（如你应该公关马丁布特内尔的帖子），你不需要花括号，如果你的对象有一个印记（$，@在它的前面）。此功能用于对神奇的变量$_，$&，$1等：

puts "this program has read #$. lines of input"

因此，如果您需要打印的变量多于其他情况，则可以节省一些字节。

a=42; puts "here is a: #{a}"; puts "here is a again: #{a}"
$b=43; puts "here is b: #$b"; puts "here is b again: #$b"

如果您需要查找某个特定元素e是否在范围内r，则可以使用

r===e

而不是更长的时间：

r.cover?(e) # only works if `r.exclude_end?` is false

要么

r.member?(e)

要么

r.include?(e)

$_ 是最后读取的行。

• print -如果没有参数给出打印内容 $_
• ~/regexp/ - 短缺 $_=~/regexp/

在Ruby 1.8，你有四种方法Kernel，其操作上$_：

• chop
• chomp
• sub
• gsub

在Ruby 1.9中，仅当您的脚本使用-n或时，这四种方法才存在。-p。

如果您想经常打印一些变量，请使用 trace_var(:var_name){|a|p a}

使用字符串插值！

1. 更换to_s。如果您想在任何要变成字符串的地方加上括号，to_s则比字符串插值要长两个字节：

   (n+10**i).to_s
   "#{n+10**i}"
   

2. 替换串联。如果将其他两个字符串包围的内容串联起来，则插值可以为您节省一个字节：

   "foo"+c+"bar"
   "foo#{c}bar"
   

   如果中间的东西本身是串联的，那么也可以使用，如果您只是将串联在插值内移动（而不是使用多个插值）：

   "foo"+c+d+e+"bar"
   "foo#{c+d+e}bar"
   

避免 length在if a.length<n

length是6个字节，在代码高尔夫中有点昂贵。在许多情况下，您可以检查数组在给定点是否有任何东西。如果您超过最后一个索引，您将获得nil假值。

因此，您可以更改：

if a.length<5 至 if !a[4] -5个字节

要么

if a.length>5 至 if a[5] -6个字节

要么

if a.length<n 至 if !a[n-1] -3个字节

要么

if a.length>n 至 if a[n] -6个字节

注意：仅适用于所有真实值的数组。在阵列中nil或false阵列中可能会引起问题。

不要使用true和false关键字。

采用：

• !p为true（谢谢，历史学家！）
• !0为false。如果您需要的只是一个伪造的值，那么您可以简单地使用p（返回nil）。

保存一些字符。

使用生成数组a=i,*a以相反的顺序获取它们。您甚至不需要初始化a，并且如果这样做则不必是数组。

如果您需要从ARGV，get或类似的方法中获取一个数字以进行多次操作，则无需调用to_i它，只需使用?1.upto x{do something x times} x是字符串即可。

所以用?1.upto(a){}代替x.to_i.times{}您节省2个字符。

您也可以像p 1 while 1或p 1 if 1那样重写p 1while 1或p 1if 1

该示例不是很有用，但可以用于其他用途。

另外，如果您需要将数组的第一个元素分配给变量，a,=c则会保存两个字符，而不是a=c[0]

Ruby 2.3和2.4的新功能

最好与新的语言功能保持同步，这将有助于您的高尔夫比赛。最新的红宝石有一些很棒的。

Ruby 2.3

安全导航操作员： &.

当您调用一个可能返回的方法nil但想要链接其他方法调用（如果没有返回）时，则会浪费字节来处理这种nil情况：

arr = ["zero", "one", "two"]
x = arr[5].size
# => NoMethodError: undefined method `size' for nil:NilClass

x = arr[5].size rescue 0
# => 0

如果返回nil并返回nil整个表达式，则“安全导航运算符”将停止方法调用链：

x = arr[5]&.size || 0
# => 0

Array#dig 和 Hash#dig

深度访问嵌套元素，并使用一个简短的名字：

o = { foo: [{ bar: ["baz", "qux"] }] }
o.dig(:foo, 0, :bar, 1) # => "qux"

返回nil是否达到死胡同：

o.dig(:foo, 99, :bar, 1) # => nil

Enumerable#grep_v

的反函数Enumerable#grep返回与给定参数不匹配的所有元素（与相比===）。像一样grep，如果给出了块，则返回其结果。

(1..10).grep_v 2..5 # => [1, 6, 7, 8, 9, 10]
(1..10).grep_v(2..5){|v|v*2} # => [2, 12, 14, 16, 18, 20]

Hash#to_proc

返回一个Proc，它产生给定键的值，这可能非常方便：

h = { N: 0, E: 1, S: 2, W: 3 }
%i[N N E S E S W].map(&h)
# => [0, 0, 1, 2, 1, 2, 3]

红宝石2.4

Ruby 2.4尚未发布，但很快就会发布，并且具有一些很棒的小功能。（发布后，我将通过一些指向文档的链接来更新此帖子。）我在这篇很棒的博客文章中了解了其中的大多数内容。

Enumerable#sum

没有了arr.reduce(:+)。您现在可以做arr.sum。它带有一个可选的初始值参数，对于数字元素（[].sum == 0），默认值为0 。对于其他类型，您需要提供初始值。它还接受一个块，该块将在添加之前应用于每个元素：

[[1, 10], [2, 20], [3, 30]].sum {|a,b| a + b }
# => 66

Integer#digits

这将按从小到大的重要性顺序返回数字的数组：

123.digits # => [3, 2, 1]

与之相比123.to_s.chars.map(&:to_i).reverse，这非常不错。

另外，它需要一个可选的基数参数：

a = 0x7b.digits(16) # => [11, 7]
a.map{|d|"%x"%d} # => ["b", "7"]

Comparable#clamp

它在锡上说了什么：

v = 15
v.clamp(10, 20) # => 15
v.clamp(0, 10) # => 10
v.clamp(20, 30) # => 20

由于它在Comparable中，因此您可以将其与任何包含Comparable的类一起使用，例如：

?~.clamp(?A, ?Z) # => "Z"

String#unpack1

节省了2个字节.unpack(...)[0]：

"👻💩".unpack(?U)    # => [128123]
"👻💩".unpack(?U)[0] # => 128123
"👻💩".unpack1(?U)   # => 128123

精密论据Numeric#ceil，floor和truncate

Math::E.ceil(1) # => 2.8
Math::E.floor(1) # => 2.7
(-Math::E).truncate(1) # => -2.7

有条件的多重分配

这会在Ruby的早期版本中引发错误，但在2.4中是允许的。

(a,b=1,2) ? "yes" : "no" # => "yes"
(a,b=nil) ? "yes" : "no" # => "no"

科学记数法通常可用于去除一两个字符：

x=1000
#versus
x=1e3

使用运算符方法代替括号

假设您要表达a*(b+c)。由于优先级，a*b+c将无法工作（显然）。Ruby将运算符作为方法的很酷的方法来了！您可以使用a.*b+c设置*低于的优先级+。

a*(b+c) # too long
a*b+c   # wrong
a.*b+c  # 1 byte saved!

这也可以与!and ~运算符一起使用（一元+或一元之类的东西-不起作用，因为它们的方法是-@and +@，保存()但添加.@）

(~x).to_s # too long
~x.to_s   # error
x.~.to_s  # 1 byte saved!

使用||替代or和&&替代and。

除了一个字符外，and您还可以在运算符周围保留空格（也许还有括号）。

p true and false ? 'yes' :'no'   #-> true (wrong result)
p (true and false) ? 'yes' :'no' #-> 'no'
p true&&false ? 'yes' :'no'      #-> 'no', saved 5 characters


p true or false ? 'yes' :'no'   #-> true (wrong result)
p (true or false) ? 'yes' :'no' #-> 'yes'
p true||false ? 'yes' :'no'      #-> 'yes', saved 4 characters

如果在数组上循环，则通常使用each。但是map也会在数组上循环，它要短一个字符。

我只是尝试了TDD代码高尔夫球挑战，即编写最短的代码以使规范通过。规格有点像

describe PigLatin do
  describe '.translate' do
    it 'translates "cat" to "atcay"' do
      expect(PigLatin.translate('cat')).to eq('atcay')
    end
    # And similar examples for .translate
  end
end

出于代码高尔夫球的考虑，无需创建模块或类。

代替

module PigLatin def self.translate s;'some code'end;end

一个可以做

def(PigLatin=p).translate s;'some code'end

节省13个字符！

内核#p是一种有趣的方法。

使用p var代替puts var。这非常适合整数和浮点数，但不适用于所有类型。它在字符串周围打印引号，这可能不是您想要的。

与单个参数一起使用，p在打印后返回参数。

与多个参数一起使用，p以数组形式返回参数。

使用p（不带参数）代替nil。

不要使用#each。您可以使用#map遍历所有元素。所以代替

ARGV.each{|x|puts x}

您可以用更少的字节做同样的事情。

ARGV.map{|x|puts x}

当然，在这种情况下puts $*甚至会更短。

对于有理数和复数，有一些文字：

puts 3/11r == Rational(3,11)
puts 3.3r == Rational(66,20)
puts 1-1.i == Complex(1,-1)

=> true
true
true

您可以在字符串中使用大多数字节。 "\x01"（6个字节）可以缩短为""（3个字节）。如果只需要这个字节，则可以进一步缩短为?（2个字节）。

同样，您可以将换行符缩短得像这样：

(0..10).to_a.join'
'

 => "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10"

您也可以使用?\n和?\t，它比"\n"和短一个字节"\t"。对于混淆，还存在一个空格。

即使您需要更改常量，也请使用常量而不是传递参数。口译员将警告stderr，但谁在乎。如果需要定义更多彼此相关的变量，可以像这样链接它们：

A=C+B=7+C=9

=> A=17, B=16, C=9

这比C=9;B=16;A=17或短C=0;B=C+7;A=C+B。

如果需要无限循环，请使用loop{...}。长度未知的循环可能比其他循环更短：

loop{break if'
'==f(gets)}

while'
'!=f(gets);end

更多gsub / regexp技巧。使用特殊的'\1'转义字符而不是块：

"golf=great short=awesome".gsub(/(\w+)=(\w+)/,'(\1~>\2)')

"golf=great short=awesome".gsub(/(\w+)=(\w+)/){"(#{$1}~>#{$2})")

以及特殊变量$1等，如果您需要执行操作。请记住，它们不仅在块内定义：

"A code-golf challenge." =~ /(\w+)-(\w+)/
p [$1,$2,$`,$']

=> ["code", "golf", "A ", " challenge."] 

删除空格，换行符和括号。您可以忽略很多红宝石。如有疑问，请始终尝试是否不使用它，并记住这可能会破坏一些编辑器语法突出显示...

x+=1if$*<<A==????::??==??

使用splat运算符的另一种方法：如果要分配单个数组文字，*则左侧的a 短于右侧的方括号：

a=[0]
*a=0

使用多个值，您甚至不需要splat运算符（感谢histocrat对此进行了纠正）：

a=[1,2]
a=1,2

当一个挑战，需要你输出多行，你不必循环通过你的结果，以便打印的每一行如数组。该puts方法将展平数组并将每个元素打印在单独的行上。

> a = %w(testing one two three)
> puts a
testing
one
two
three

将splat运算符与#p您结合可以使它更短：

p *a

splat运算符（*@我认为是技术上的方法）也将非数组可枚举类型转换为数组：

> p a.lazy.map{|x|x*2}
#<Enumerator::Lazy: #<Enumerator::Lazy: [1, 2, 3]>:map>

与

> p *a.lazy.map{|x|x*2}
2
4
6

删除数组的重复元素时节省一些字节

a.uniq # before
a|[]   # after
    ^^

如果将[]在变量中使用空数组，则可以保存更多字节：

a.uniq;b=[] # before
a|b=[]      # after
      ^^^^^

使用Goruby代替Ruby，后者类似于Ruby的缩写版本。您可以通过rvm安装它

rvm install goruby

Goruby允许您像编写Ruby一样编写大多数代码，但是内置了其他缩写。要找出某事物的最短缩写，可以使用helper方法shortest_abbreviation，例如：

shortest_abbreviation :puts
#=> "pts"

Array.new.shortest_abbreviation :map
#=> "m"

String.new.shortest_abbreviation :capitalize
#=> "cp"

Array.new.shortest_abbreviation :join
#=> "j"

别名本身也可以缩写say为也非常方便。所以代替putss

puts [*?a..?z].map(&:capitalize).join

你现在可以写

s [*?a..?z].m(&:cp).j

用大写字母打印字母表（这不是一个很好的例子）。此博客文章如果您有兴趣进一步阅读介绍了更多内容和一些内部工作原理。

PS：不要错过h方法；-)

要加入一个数组，而不是这个

[...].join

做这个

[...]*''

节省2个字节。要与分隔符一起使用

[...]*?,

下标数字！

我昨天才发现这个。在第- 个位置n[i]返回n的位i。例：

irb(main):001:0> n = 0b11010010
=> 210
irb(main):002:0> n[0]
=> 0
irb(main):003:0> n[1]
=> 1
irb(main):004:0> n[2]
=> 0
irb(main):005:0> n[3]
=> 0
irb(main):006:0> n[4]
=> 1
irb(main):007:0> n[5]
=> 0

您可能可以保存2个字符并使用

[*(...)]

代替

(...).to_a

例如，假设我们有一个想要作为数组的范围：

(1..2000).to_a

像这样做：

[*1..2000]  #  Parentheses around the (ran..ge) is not needed!

现在，您可以将范围作为数组。

<<招

a.push x

可以缩短为：

a<<x

-4个字节

Array#assoc/rassoc

如果您有一个数组数组，并且想要查找以特定值开头的子数组，请不要使用Enumerable#find，请使用Array#assoc：

a = [[0,"foo"],[0,"bar"],[1,"baz"],[0,"qux"]]
a.find{|x,|x==1} # => [1,"baz"]
a.assoc(1) # => [1,"baz"]

Enumerable#any?在某些情况下，这也是很好的替代方法。

Array#rassoc 做同样的事情，但是检查子数组的最后一个元素：

a = [[123,"good"],[456,"good"]]
a.any?{|*,x|x=="bad"} # => false
a.rassoc("bad") # => nil