ruby测验-使用while循环重新分配数组值

我从一个“简单的”ruby测试中得到了这个例子。如果数组的值等于（=）array1的值，我想将其重新赋值给array2的值。请看一下代码，这样就很明显：

array1 = Array.new
array1 = ('A'..'Z').to_a

array2 = Array.new
array2 = ('A'..'Z').to_a
array2 = array2.rotate(2)

puts "enter a word:"
word1 = gets.chomp
word1 = word1.upcase.split(//)

n = 0

word1.each do
  while n < 26
    if word1[n] == array1[n]
      word1[n] = array2[n]
    end
    n += 1
  end
end

puts word1   # This word should now be "encoded" and not easy to read.

array1=Array.new
数组1=（'A'..'Z'）。到_A
array2=Array.new
array2=（'A'..'Z'）。到_A
array2=array2.旋转（2）
输入“输入一个单词：”
word1=get.chomp
word1=word1.upcase.split（//）
n=0
每个人都做
而n<26
如果字1[n]==array1[n]
word1[n]=array2[n]
结束
n+=1
结束
结束
puts word 1#这个单词现在应该是“编码”的，不容易阅读。

我试过这个代码，它会随机地改变我输入的任何单词的1-2个字母（gets.chomp）

因此，我希望word1是一个数组，将每个元素（字母）与array1[0]进行比较，如果它等于，则将重新分配给array2[0]的值。如果word1[0]和array1[0]不相等，则“n”的值更改为+1，并再次运行该块

---

注意：对于这个问题，我不想有一个简单的公式，我想真正理解这里发生了什么，以及为什么我的每次迭代都不能像我预期的那样工作。所以，如果你能以“我的知识水平”回答这个问题，那就太棒了

我认为问题在于您使用相同的“计数器”

n

检查两个不同的数组，请尝试以下操作：

编辑 根据您的评论，由于您只需要如此混乱，以下是一种可能的方式：

array1 = ('A'..'Z').to_a
array2 = ('A'..'Z').to_a.shuffle

puts "enter a word:"
word1 = gets.chomp
word1 = word1.upcase.split(//)

n = 0

word1.each do
  word1[n] = array2[n]
  n +=1
end

puts word1

---

它将始终生成不同的输入，即使您使用同一个单词，因为

数组2中的
洗牌
我认为问题在于您使用相同的“计数器”
n
检查两个不同的数组，请尝试以下操作：

编辑
根据您的评论，由于您只需要如此混乱，以下是一种可能的方式：

array1 = ('A'..'Z').to_a
array2 = ('A'..'Z').to_a.shuffle

puts "enter a word:"
word1 = gets.chomp
word1 = word1.upcase.split(//)

n = 0

word1.each do
  word1[n] = array2[n]
  n +=1
end

puts word1

它将始终生成不同的输入，即使您使用同一个单词，因为
数组2中的
洗牌
首先，您忘记在连续单词之间重置计数器N。将N设置为零，然后开始迭代单词

因此，在概述中，您的algo的行为如下：

对于第一个单词，N在0..25上迭代

对于第二个单词，N以26开头，根本不迭代

对于第三个单词，N以26开头，不迭代

..
等等

因此，对于完全初学者，请执行以下操作：

array1 = Array.new
array1 = ('A'..'Z').to_a

array2 = Array.new
array2 = ('A'..'Z').to_a
array2 = array2.rotate(2)

puts "enter a word:"
word1 = gets.chomp
word1 = word1.upcase.split(//)     # <-- note that you REPLACE the input string
                                   # with an sequence of STRINGS produced by SPLIT

word1.each do                      # for each STRING in the SEQUENCE
  n = 0
  while n < 26                     # scan all 26 letters from ARRAY
    if word1[n] == array1[n]       # ... WTF
      word1[n] = array2[n]
    end
    n += 1
  end
end

因此，您从序列中读取第n个单词

.. 并将其与阵列1中的第n个字母进行比较

这真的是你想做的吗？完全不是

您很可能希望替换WORD中的每个字母以及由两个数组组成的字母对

因此，你想：


阅读单词1中的第n个字母
然后在数组1中的哪个索引处检查

然后从索引中读取替换字母
然后在WORD的第n个位置写下这封信：

letter = word[position]
letterindex = array1.index(letter)
substitution = array2[letterindex]
word[position] = subsitution



您也可以将其压缩为一行：

 -- loop
    -- loop2
      word[position] = array2[array1.index(word[position])]

但是，请注意，我现在说的是
位置
，而不是
N
。您使用了
N
作为范围0..25，这意味着数组中字母的索引

但是，为了检查单词的字母，您需要对单词的字母进行迭代。这个词有多长？当然，不是0..25

还要注意微妙的变化：
word
而不是
word1
。我说的是“单词”和“单词的字母”，而不是“单词”。最初，您还使用
N
读取序列中的第N个单词，让我们保留它。但当我们需要迭代word的leter时，需要一个不同的变量，'比如说
位置
：

n = 0

arrayOfWords.each do

    word = arrayOfWords[n]

    position = 0

    while position < word.length
        letter = word[position]
        letterindex = array1.index(letter)
        substitution = array2[letterindex]
        word[position] = subsitution
        position += 1
    end

    n += 1
end

请注意，我是如何将条形图中的“word”添加到每个调用的
中的。
以类似的方式，您实际上也可以去掉
位置，但这反过来会使代码更短，但更难阅读/理解。
首先，您忘了重置连续单词之间的计数器N。将N设置为零，然后开始迭代单词

因此，在概述中，您的algo的行为如下：

对于第一个单词，N在0..25上迭代

对于第二个单词，N以26开头，根本不迭代

对于第三个单词，N以26开头，不迭代

..
等等

因此，对于完全初学者，请执行以下操作：

array1 = Array.new
array1 = ('A'..'Z').to_a

array2 = Array.new
array2 = ('A'..'Z').to_a
array2 = array2.rotate(2)

puts "enter a word:"
word1 = gets.chomp
word1 = word1.upcase.split(//)     # <-- note that you REPLACE the input string
                                   # with an sequence of STRINGS produced by SPLIT

word1.each do                      # for each STRING in the SEQUENCE
  n = 0
  while n < 26                     # scan all 26 letters from ARRAY
    if word1[n] == array1[n]       # ... WTF
      word1[n] = array2[n]
    end
    n += 1
  end
end

因此，您从序列中读取第n个单词

.. 并将其与阵列1中的第n个字母进行比较

这真的是你想做的吗？完全不是

您很可能希望替换WORD中的每个字母以及由两个数组组成的字母对

因此，你想：


阅读单词1中的第n个字母
然后在数组1中的哪个索引处检查

然后从索引中读取替换字母
然后在WORD的第n个位置写下这封信：

letter = word[position]
letterindex = array1.index(letter)
substitution = array2[letterindex]
word[position] = subsitution



您也可以将其压缩为一行：

 -- loop
    -- loop2
      word[position] = array2[array1.index(word[position])]

但是，请注意，我现在说的是
位置
，而不是
N
。您使用了
N
作为范围0..25，这意味着数组中字母的索引

但是，为了检查单词的字母，您需要对单词的字母进行迭代。这个词有多长？当然，不是0..25

还要注意微妙的变化：
word
而不是
word1
。我说的是“单词”和“单词的字母”，而不是“单词”。最初，您还使用
N
读取序列中的第N个单词，让我们保留它。但当我们需要迭代word的leter时，需要一个不同的变量，'比如说
位置
：

n = 0

arrayOfWords.each do

    word = arrayOfWords[n]

    position = 0

    while position < word.length
        letter = word[position]
        letterindex = array1.index(letter)
        substitution = array2[letterindex]
        word[position] = subsitution
        position += 1
    end

    n += 1
end

请注意，我是如何将条形图中的“word”添加到每个调用的
中的。
类似地，你实际上也可以摆脱
的位置，但这反过来会使代码更短，但更难阅读/理解。
我终于设法回答了我的问题