Comment déclarer un tableau à deux dimensions en Ruby

Je veux un deux dimensions de la matrice en Ruby, que je puisse y accéder, par exemple comme ceci:

if @array[x][y] == "1" then @array[x][y] = "0"

Le problème est: je ne connais pas les montants initiaux des dimensions du tableau et je serai le tableau (avec le << opérateur).

Comment dois-je le déclarer comme une variable d'instance, si je n'obtiens pas d'erreur de ce genre?

undefined method `[]' for nil:NilClass (NoMethodError)

QUESTION À JOUR LE:

@array = Array.new {Array.new}

travaille maintenant pour moi, si le commentaire de Matt ci-dessous est correct!

Je viens de trouver la raison pour laquelle j'ai reçu le message d'erreur était que je itéré le tableau comme ceci:

for i in 0..@array.length
    for j in 0..@array[0].length
        @array[i][j] ...

qui était évidemment faux et produit l'erreur. Il doit être comme ceci:

for i in 0..@array.length-1
        for j in 0..@array[0].length-1
            @array[i][j] ...
Ruby utilise le typage dynamique-de sorte que vous n'avez pas besoin de "déclarer" qu'une variable est un tableau à deux dimensions à l'avant. Ce que vous pouvez faire est de créer une variable et initialiser un tableau. Ensuite, commencer à mettre des tableaux à l'intérieur d'elle.
pour array = Array.nouveau {Array.nouveau} doivent être modifiés pour tableau = Array.nouveau(3) {Tableau.nouveau(2)},doivent avoir le chiffre à l'intérieur

OriginalL'auteur kadrian | 2012-02-04

  1. 7

    Une mise en œuvre simple pour un clairsemée tableau en 2 dimensions utilisant des tables de hachage, les

    class SparseArray
  attr_reader :hash

  def initialize
    @hash = {}
  end

  def [](key)
    hash[key] ||= {}
  end

  def rows
    hash.length   
  end

  alias_method :length, :rows
end

    Utilisation:

    sparse_array = SparseArray.new
sparse_array[1][2] = 3
sparse_array[1][2] #=> 3

p sparse_array.hash
#=> {1=>{2=>3}}

#
# dimensions
#
sparse_array.length    #=> 1
sparse_array.rows      #=> 1

sparse_array[0].length #=> 0
sparse_array[1].length #=> 1
    Vous pouvez éviter la rescue en fournissant un bloc de fetch: hash.fetch(key){ hash[key] = {} } sera beaucoup plus rapide. Aussi, hash[key] ||= {} plus court et le plus couramment utilisé.
    A noté :-). L'extraction et de sauvetage a été inutile.
    est-il possible d'avoir un .méthode de longueur pour chacune de ces dimensions?
    Oui, voir le code mis à jour. En plus, vous pouvez également mixin Énumérable module et de remplacer chaque #pour obtenir plus de fonctionnalités.

    OriginalL'auteur csherin

  2. 5

    Matt commentaire sur votre question est tout à fait correcte. Toutefois, en se fondant sur le fait que vous avez marqués cette "conways-jeu-de-vie", il semble que vous essayez d'initialiser un tableau à deux dimensions, puis de les utiliser dans les calculs pour le jeu. Si vous voulais le faire en Ruby, une façon de le faire serait:

    a = Array.new(my_x_size) { |i| Array.new(my_y_size) { |i| 0 }}

    qui permettra de créer une my_x_size * my_y_size tableau rempli avec des zéros.

    Ce que ce code n'est pour créer un nouveau Tableau de votre taille x, puis initialiser chaque élément de ce tableau à un autre Tableau de votre taille y, et initialiser chaque élément de chaque deuxième tableau avec des 0.

    OriginalL'auteur Marc Talbot

  3. 3

    Ruby Array ne vous donne pas cette fonctionnalité.

    Soit manuellement, vous faire:

    (@array[x] ||= [])[y] = 42

    Ou vous utilisez des hachages:

    @hash = Hash.new{|h, k| h[k] = []}
@hash[42][3] = 42
@hash # => {42 => [nil, nil, nil, 42]}
    J'ai couru avec votre idée d'utiliser des Hachages pour écrire SparseArray. Il est aussi un exemple de mise en œuvre à l'aide de Hachages dans le Rubis moyen du livre.

    OriginalL'auteur Marc-André Lafortune