Ruby 创建一系列字母的数组，从a开始，到Z结束，即（B到AC）

我正在使用RooGem，希望从基于标准A1语法的电子表格中提取数据

我在电子表格中有Z以外的列，所以Excel会处理整个AA、AB、AC列的位置

我想为W到AH列创建一个数组

Ruby似乎不喜欢上限超过Z，但不是从A开始

你知道如何

（“B”.“AC”）。到a

而不是

[]

这是irb的基本问题

("A".."Z").to_a
#=> ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
("B".."Z").to_a
#=> ["B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
("A".."AC").to_a
#=> ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "AB", "AC"]
("B".."AC").to_a
#=> []

这个怎么样

("A".."AC").to_a.drop(1)

您可以删除任意数量的

元素

，只需创建一个范围和一个数组

整数可能被替换为返回字母在字母表中位置的数据

直接使用

范围

类，感谢@sagarpandya82

class Range
  def from(column)
    to_a.drop(find_index(column).to_i)
  end
end

("A".."AC").from('F')
#=> ["F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "AB", "AC"]

用于构建空数组。当当前值等于第二个参数时，循环中断。要返回新构建的数组

o

，我们将

o

作为参数传递给

break

，默认情况下该参数返回

nil

def cols a, b
  loop.with_object([]) do |_, o|
    o << a
    break(o) if a == b
    a = a.next
  end
end  

cols('W','AH')
 #=> ["W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH"]

cols("A","Z")
 #=> ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
 #    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]

cols("B","Z")
 #=>  ["B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
 #     "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]

cols("A","AC")
 #=> ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
 #    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
 #    "AA", "AB", "AC"]

cols("B","AC")
 #=> ["B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
 #    "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA",
 #    "AB", "AC"]

def冷却液a、b
loop.with_对象（[]）do | o|
o[“W”、“X”、“Y”、“Z”、“AA”、“AB”、“AC”、“AD”、“AE”、“AF”、“AG”、“AH”]
科尔斯（“A”、“Z”）
#=>[“A”、“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“J”、“K”、“L”、“M”，
#“N”、“O”、“P”、“Q”、“R”、“S”、“T”、“U”、“V”、“W”、“X”、“Y”、“Z”]
科尔斯（“B”、“Z”）
#=>[“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“J”、“K”、“L”、“M”、“N”，
#“O”、“P”、“Q”、“R”、“S”、“T”、“U”、“V”、“W”、“X”、“Y”、“Z”]
科尔斯（“A”、“AC”）
#=>[“A”、“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“J”、“K”、“L”、“M”，
#“N”、“O”、“P”、“Q”、“R”、“S”、“T”、“U”、“V”、“W”、“X”、“Y”、“Z”，
#“AA”、“AB”、“AC”]
cols（“B”、“AC”）
#=>[“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“J”、“K”、“L”、“M”、“N”，
#“O”、“P”、“Q”、“R”、“S”、“T”、“U”、“V”、“W”、“X”、“Y”、“Z”、“AA”，
#“AB”、“AC”]

这一问题的数学答案是：

A=>AH=（A=>W）+（W=>AH）

所以W=>AH=（A=>AH）-（A=>W）

此问题的程序性答案是：

("A".."AH").to_a - ("A"..."W").to_a
#=> ["W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH"]

第二个范围中的

…

使其具有排他性，即没有“W”

更一般的答案是

r = "W".."AH"

("A"..r.end).to_a - ("A"...r.begin).to_a
#=> ["W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH"]

Ruby以Excel增加列名的方式增加字母：

'Z'.succ #=> "AA"

因此，如果您知道可以通过

succ

访问目标值，则可以使用一个简单的循环：

ary = ['W']
ary << ary.last.succ until ary.last == 'AH'

ary #=> ["W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH"]

这意味着名字越长，名字越短。相同长度的名称按字典顺序进行比较

这允许您生成所需的序列：

r = Column.new('W')..Column.new('AH')
r.map(&:name)
#=> ["W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH"]

---

抱歉，我想保持简短，因此使用数组范围语法。我可以接受一个替代方案，只要它短且易于维护。

（'B'..'Z'）。到_a+（'a'..'AC'）。到_a

太难看了？是的，我刚刚做了一个。我现在就用它，但我想我可能错过了一些明显有趣的东西。我本想妥善处理这件事，但也失败了。我已经提交了a。嗯，很好，你从B开始，很容易计算出要投多少个字母。但是如果它在中间的某个地方，可能会导致太多的思考。但它很短，我给你：）是的。整数可能被替换为返回字母在字母表中位置的数据。不管怎样，我都会给它多一点时间看看其他人有什么想法。我现在用这个，除非有更精简的东西出现，否则我会接受这个答案。谢谢，在此之前，我还在考虑更好的解决方案……）您可以删除数组修补程序中对

self

的所有引用。建议：使用

to a.drop（查找索引（列）.to i）

修补

范围

类。然后你可以从（'F'）等写

（“A”。“AC”）。这是一种有趣的方法。我已将您的
（string.ord-1）.chr
替换为独占范围。
class Column
  attr_reader :name

  def initialize(name)
    raise ArgumentError if name =~ /[^A-Z]/
    @name = name
  end

  def <=>(other)
    [name.length, name] <=> [other.name.length, other.name]
  end

  def succ
    Column.new(name.succ)
  end
end

[name.length, name] <=> [other.name.length, other.name]

r = Column.new('W')..Column.new('AH')
r.map(&:name)
#=> ["W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH"]