ruby 挑战 : experienced developers opinions

Question

我正在处理一些 面向新开发人员 的 ruby​​ 问题，但我希望有经验的开发人员对此提出意见。很抱歉发了这么长的帖子，非常感谢您抽出宝贵的时间和意见。

问题问题

Write a function, nearest_larger(arr, i) which takes an array and an index. The function should return another index, j: this should satisfy:

• (a) arr[i] < arr[j], AND
• (b) there is no j2 closer to i than j where arr[i] < arr[j].

In case of ties (see example below), choose the earliest (left-most) of the two indices. If no number in arr is larger than arr[i], return nil.

Difficulty: 2/5

Rspec 测试

describe "#nearest_larger" do
  it "handles a simple case to the right" do
    nearest_larger([2,3,4,8], 2).should == 3
  end

  it "handles a simple case to the left" do
    nearest_larger([2,8,4,3], 2).should == 1
  end

  it "treats any two larger numbers like a tie" do
    nearest_larger([2,6,4,8], 2).should == 1
  end

  it "should choose the left case in a tie" do
    nearest_larger([2,6,4,6], 2).should == 1
  end

  it "handles a case with an answer > 1 distance to the left" do
    nearest_larger([8,2,4,3], 2).should == 0
  end

  it "handles a case with an answer > 1 distance to the right" do
    nearest_larger([2,4,3,8], 1).should == 3
  end

  it "should return nil if no larger number is found" do
    nearest_larger( [2, 6, 4, 8], 3).should == nil
  end
end

解决方案

def nearest_larger arr, idx
diff = 1
  loop do
    l = idx - diff
    r = idx + diff
    return l    if (l >= 0) && (arr[l] > arr[idx])
    return r    if (r < arr.length) && (arr[r] > arr[idx])
    return nil  if (l < 0) && (r >= arr.length)
    diff += 1
  end
end

反馈

1. 您将如何着手解决这个问题？ (你的流程是什么？)
2. 您认为问题清晰易懂吗？
3. 解决这个问题需要多长时间？ (10 分钟、20 分钟、...？)
4. 是否同意难度级别？ (请记住，这是面向新开发人员的)
5. 如果愿意:请发布您自己的解决方案，展示您解决此问题的风格。

我决定发布这个问题，因为我知道新开发人员很容易陷入一个问题而不知道先写什么。我希望您的回答能让您深入了解您将如何解决您认为是挑战的问题。

Answer 1

我没有经验丰富的开发人员，甚至没有经验，但无论如何我都会告诉你我的想法。

1 您将如何着手解决这个问题？ (你的流程是什么？)

我会希望分解成碎片，但肯定每个人都会这样做。例如，此处数组中的值仅用于提取较大元素的索引，因此我认为第一个问题是提取索引，第二个问题是单独处理索引。我将通过减去 i 进一步简化后者从每个索引使得 j并与 k 进行比较像这样:if j.abs < k.abs ... , 而不是 if (j-i).abs < (k-i).abs... .在选择不同的方法时，我倾向于寻找最容易理解的方法(“读起来最好”)。

2.在您看来，问题是否清晰易懂？

是的。

3.你需要多长时间才能解决这个问题？

我拒绝回答，因为这肯定会连累我。

4.你同意这个难度吗？

看来是对的。这将是 rubeque.com 上的“初学者”问题。

5.如果愿意:请发布您自己的解决方案，展示您解决此问题的风格。

当然可以。

def nearest_larger(arr, i)
  ret = nearest_to_zero( arr.each_with_index
                            .select { |e,j| e > arr[i] }
                            .map    { |_,j| j-i        } )
  ret ? ret + i : nil
end

我看了两种写法nearest_to_zero() .第一种是简短、直接和清晰，但效率低下，使用 sort! :

def nearest_to_zero(a)
  a.sort! { |j,k| (j.abs == k.abs) ? j <=> k : j.abs <=> k.abs }
  a.any? ? a.first : nil
end

效率更高，但没那么漂亮:

def nearest_to_zero(a)
  neg, pos = a.partition { |e| e < 0 }    
  case
  when neg.empty?
    pos.empty? ? nil : pos.first
  when pos.empty?
    neg.last
  else
    pos.last.abs < neg.last.abs ? pos.first : neg.last
  end 
end

对于 arr = [2,5,4,8,10], i = 2 ，以下步骤由 nearest_larger() 执行:

a   = arr.each_with_index.select { |e,j| e > arr[i] } # => [[5,1],[8,3],[10,4]] 
b   = a.map { |_,j| j-i }                             # => [-1,1,2] 
ret = nearest_to_zero(b)                              # => -1 
ret ? ret + i : nil                                   # => 1 

在第一个nearest_to_zero() ，如果两个指数具有相等的绝对值(意味着它们在转换前同样接近 i)，则平局进入具有较低 vlaue 的指数；否则为绝对值较小的索引。

在第二个nearest_to_zero() :

neg, pos = [-1,1,2].partition {|e| e < 0} #  => [[-1],[1,2]]

其余的应该是不言自明的。

我读过 rspec，但以前没有用过。是时候这样做了。我的代码通过了。