Rubyでゴルフをするための一般的なヒントは何ですか？

私は、Rubyに特有のゴルフ問題全般のコーディングに適用できるアイデアを探しています。（たとえば、「コメントの削除」は答えになりません。）

回答ごとに1つのヒントを投稿してください。

• 126番号100のように書くことができる?dと?~1.8で。
• 同様の注意として、1.9で1文字の文字列が必要な場合、？xは "x"よりも短くなります。
• 改行を追加せずに文字列を印刷する必要がある場合$><<"string"は、より短いですprint"string"。
• 複数行の入力を読み取る必要がある場合$<.map{|l|...}は、よりも短くなりwhile l=gets;...;endます。また$<.read、一度にすべてを読むために使用できます。
• あなたを想定している場合は、ファイルから読み込むための、$<およびgetsファイル名がである場合、ファイルの代わりに、標準入力から読み込みますARGV。したがって、再実装catするための最もゴルフらしい方法は次のようになります$><<$<.read。

スプラット演算子を使用して、配列の末尾と先頭を取得します。

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の新しい->演算子でラムダを作成します。（->演算子は「stabby lambda」または「dash rocket」です。）これにより、関数ごとに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)です。ラムダ呼び出しはc[n]です。それぞれの変更c nにc[n]は1文字かかるためc n、5回以上使用できる場合はメソッドを保持します。

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と三項演算子 ?:。ブランチに2つ以上のステートメントがある場合は、括弧で囲みます。

# 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。ここには、他の多くの有用な情報とともに、それらの良いリストがあります。

文字列補間を使用している場合（MartinBüttnerの投稿を参照してください）、オブジェクトの前にシギル（$、@）がある場合、中括弧は必要ありません。以下のような魔法の変数のために有用な$_、$&、$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で動作する4つのメソッドがあります$_。

• chop
• chomp
• sub
• gsub

Ruby 1.9では、これらの4つのメソッドは、スクリプトが-nまたはを使用する場合にのみ存在します-p。

変数を頻繁に印刷したい場合は、 trace_var(:var_name){|a|p a}

文字列補間を使用してください！

1. を置き換えるにはto_s。文字列にしたいものを括弧で囲む必要がある場合to_s、文字列補間よりも2バイト長くなります。

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

2. 連結を置き換える。他の2つの文字列に囲まれたものを連結すると、補間により1バイト節約できます。

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

   また、（複数の補間を使用する代わりに）補間内で連結を移動するだけで、中間のもの自体が連結される場合にも機能します。

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

避けlengthでif a.length<n

length6バイトで、コードゴルフでは少しコストがかかります。多くの場合、代わりに、指定されたポイントで配列に何かがあるかどうかを確認できます。最後のインデックスをnil超えて取得すると、falsey値を取得します。

変更できます：

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（おかげで、histocrat！）
• !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,=c2文字を保存しますが、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"

科学的表記法を使用して、1つまたは2つの文字を削ることができます。

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!

また、これはで動作することができます!し、~（単項のようなものオペレータ+または単項-それらのメソッドであるため動作しない-@と+@省電力、()しかし追加.@）

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

||代わりにor、&&代わりに使用しますand。

1文字の横に、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、配列もループし、1文字短くなります。

私はちょうど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バイト）に短縮できます。この1バイトだけが必要な場合は、これをさらに短くすることができます。?（2バイト）に。

同様に、次のように改行を短くすることができます。

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

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

あなたは使用することができます?\nし、?\tより短い1バイトであるだけでなく"\n""\t"。 andなります。難読化のために、スペースもありますか？

引数を変更する必要がある場合でも、引数を渡す代わりに定数を使用します。インタープリターは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

複数の値を使用すると、スプラット演算子さえ必要ありません（それについて修正してくれたhistocratに感謝します）：

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

チャレンジで複数行を出力する必要がある場合、たとえば配列の各行を印刷するために結果をループする必要はありません。このputsメソッドは配列を平坦化し、各要素を別々の行に出力します。

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

スプラット演算子を組み合わせると、#pさらに短くすることができます。

p *a

スプラット演算子（技術的には*@メソッドだと思います）は、配列でない列挙型も配列にキャストします。

> 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
      ^^^^^

Rubyの代わりにGorubyを使用します。これはRubyの短縮バージョンのようなものです。rvmでインストールできます

rvm install goruby

Gorubyあなたはルビーを書くことになるとあなたのコードのほとんどを書くことができますが、内蔵の追加の略語を持っているもののために利用可能な最短の省略形を見つけるために、あなたはヘルパーメソッドを使用することができます。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、putsそれ自体をで短縮することができますs。の代わりに

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

あなたは今書くことができます

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

アルファベットを大文字で印刷します（これは非常に良い例ではありません）。このブログ投稿では、さらに読みたい場合は、より多くのものと内部の動作について説明しています。

PS：hメソッドをお見逃しなく;;）

これの代わりに配列を結合するには

[...].join

これを行う

[...]*''

これにより2バイト節約されます。セパレータを使用して結合するには

[...]*?,

添え字番号！

昨日これを発見しました。-番目の位置にのビットをn[i]返します。例：ni

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