Question

因此，如果元素在数组中，则打印元素的索引;如果元素不在数组中，则打印-1。我必须使用循环来做到这一点。请帮助！

def element_index(element, my_array)
  while my_array.map.include? element do
    puts my_array.index(element)
    break
  end

  until my_array.include? element do
    puts -1
    break
  end
end

p element_index("c", ["a","b","c"])

Answer 1

如果可以使用Array#index，那么

def element_index(elem, collection)
  collection.index(elem) || -1
end

或者，如果您不应该使用Array#index，或者您想在任意集合上执行此操作，那么

def element_index(elem, collection)
  collection.each_with_index.reduce(-1) do |default, (curr, index)| 
    curr == elem ? (return index) : default
  end
end

顺便说一下，当我想迭代一个集合（数组，映射，集合，......）来计算一个值时，我总是转向Enumerable#reduce。

Answer 2

这是一种简单的方法，但可能不符合“使用循环”的标准：

def element_index(x, arr)
  arr.index(x) || -1
end

element_index("c", ["a","b","c"]) #=> 2
element_index("d", ["a","b","c"]) #=> -1

明确使用循环：

def element_index(x, arr)
  arr.each_index.find { |i| arr[i] == x } || -1
end

正如评论中指出的那样，我们可以改写

arr.each_index.find(->{-1}) { |i| arr[i] == x }

element_index("c", ["a","b","c"]) #=>  2
element_index("d", ["a","b","c"]) #=> -1

Answer 3

我知道这是一项任务，但我首先会将其视为真实的代码，因为它教你一些不那么优秀的Ruby。

Ruby有一个方法，Array#index。它返回第一个匹配元素的索引（可以有多个）或nil。

p ["a","b","c"].index("c")  # 2
p ["a","b","c"].index("d")  # nil

返回-1是不可取的。 nil是一个更安全的“这个东西不存在”的值，因为它永远不是一个有效的值，总是假的（Ruby中的-1和0都是真的），并且除了它自己之外不会比较等于任何东西。返回-1表示这个练习的任何人都将其转换为另一种语言，如C。

如果必须，可以使用简单的包装器。

def element_index(element, array)
    idx = array.index(element)
    if idx == nil
        return -1
    else
        return idx
    end
end

我必须使用循环。

好的，这是家庭作业。让我们重写Array#index。

基本思想是遍历每个元素，直到找到匹配的元素。使用Array#each迭代遍历数组的每个元素，但是您需要使用Array#each_index完成每个索引。然后可以使用array[idx]获取该元素。

def index(array, want)
    # Run the block for each index of the array.
    # idx will be assigned the index: 0, 1, 2, ...
    array.each_index { |idx|
        # If it's the element we want, return the index immediately.
        # No need to spend more time searching.
        if array[idx] == want
            return idx
        end
    }

    # Otherwise return -1.
    # nil is better, but the assignment wants -1. 
    return -1
end

# It's better to put the thing you're working on first,
# and the thing you're looking for second.
# Its like verb( subject, object ) or subject.verb(object) if this were a method.
p index(["a","b","c"], "c")
p index(["a","b","c"], "d")

习惯使用list.each { |thing| ... }，这就是你在Ruby中循环的方式，以及many other similar methods。在Ruby中几乎没有调用while和for循环。相反，你要求对象循环并告诉它如何处理每件事。它非常强大。

Answer 4

我必须使用循环。

你的方法很有创意。您已使用if循环重新创建while语句：

while expression do
  # ...
  break
end

相当于：

if expression
  # ...
end

expression类似于array.include? element。

我怎么能这样做呢？

要反转（布尔）表达式，您只需添加!：

if !expression
  # ...
end

适用于您的while - 黑客：

while !expression do
  # ...
  break
end

整个方法看起来像这样：

def element_index(element, my_array)
  while my_array.include? element do
    puts my_array.index(element)
    break
  end

  while !my_array.include? element do
    puts -1
    break
  end
end

element_index("c", ["a","b","c"])
# prints 2
element_index("d", ["a","b","c"])
# prints -1

正如我在开始时所说的那样，这种方法非常具有创造性＆＃34;。您可能应该使用循环找到索引（请参阅Schwern's answer），而不是调用内置index。

我怎么能做相反的事呢。包括？

4 个答案: