Ruby String 2D tömb

Egyéb: Assembly, Ada...

Egy 2 dimenziós string tömb legegyszerűbb megvalósítására lennék kíváncsi Rubyban.
Kerestem rá megoldást neten, de annyiféle szart írnak össze róla, hogy egyszerűen kész.

Amit szeretnék megoldani, hogy számozással tudjak egy tömb adott elemére hivatkozni, mely egy szöveget tartalmaz.

Pl. a [2,1] valakinek a neve, a [2,2] ugyanannak a címe, a [2,3] ugyanannak a telefonszáma,
de a [3,1] más valakinek a neve, a [3,2] ennek a személynek a címe, és a [3,3] szintén eme 3. személynek a telefonszáma. És így tovább.

Egy ilyen tömbre lenne szükségem, és ezekre az elemekre szeretnék hivatkozni.

String adatott tenni bele, de nem előre dekraláltan, hanem utólag feltölteni.

Valaki tudna ebben egy picit segíteni nagyon egyszerű módon?

Köszönöm előre is!

( locsemege v | 2017. 01. 28., szo – 02:40 )

Előre szólok, rubyhoz hülye vagyok, de ha van egy dimenziós tömböd, akkor minden van. Assembly-ben hogyan csinálnád? Legyen egy n * m-es tömböd, ekkor így hivatkozhatsz egy egy dimenziós implementációban az a[y, x] elemre:

a[y * m + x]

ahol

0 <= y < n
és
0 <= x < m

tr '[:lower:]' '[:upper:]' <<<locsemege
LOCSEMEGE

( log69 | 2017. 01. 28., szo – 09:49 )

Ezt keresed talán (tömb a tömbben):

adat = [ ["Nagy József", "1105 Budapest, Kató u. 10", "+36 70 112 22 33"], ["Kis Miklós", "Pécs, Kőrös út 45.", "+36 30 441 22 33"], [...] ]

adat[1,1] => "Nagy József"
adat[2,1] => "Kis Miklós"
adat[2,2] => "Pécs, Kőrös út 45."

Hozzáadás:

adat.push( ["Németh Elemér", "", ""] )

( mn3monic v | 2017. 01. 28., szo – 10:50 )

Valami ilyesmi nem lenne jobb inkabb? 


#!/usr/bin/ruby

$adat = [
    {:nev => 'Nev 1', :cim => 'Cim 1', :tel => 'Tel 1'},
    {:nev => 'Nev 2', :cim => 'Cim 2', :tel => 'Tel 2'}
]

def print_adat(idx)
  print "Masodik:\n"
  print ' - nev: ' + $adat[idx][:nev] + "\n"
  print ' - cim: ' + $adat[idx][:cim] + "\n"
  print ' - tel: ' + $adat[idx][:tel] + "\n"
end

print_adat 1

$adat << {:nev => 'Nev 3', :cim => 'Cim 3', :tel => 'Tel 3'}

print_adat 2

$adat[0][:tel] = 'Custom tel number'

print_adat 0

Ha a hash-ek megfelelnek neki a tömb helyett, akkor még akár ilyen struktúra is érdekes lehet (hash a hash-ben):

adat = {"Nagy István" => {"cim" => "Pécs, Virág u. 8.", "tel" => "+36 20 11 22 333"}, "Kis Péter" => {"cim" => "Bp, Kossuth u. 111.", "tel" => "+36 30 55 44 333"}}

adat["Nagy István"]["tel"]
=> "+36 20 11 22 333"

adat["Kis Péter"]["cim"]
=> "Bp, Kossuth u. 111."

Egy gyors kérdésem lenne még. Adott a következő:

ADAT = [
{:nev => '',:cim => '',:tel => ''},
{:nev => '',:cim => '',:tel => ''},
{:nev => '',:cim => '',:tel => ''}
]

Tökéletesen működik, de ahhoz hogy az adott környezete működni tudjon, előre kell ilyen módon deklarálnom a tömböt üres elemekkel.

A kérdésem pedig a következő:

Melyik lenne a legegyszerűbb módszer (akár ciklus, akár másféle egyszerű dolog) amivel deklarálni tudnám ezeket az üres tömb elemeket, pl. ha 52 "sorra" lenne szükségem? És azt miként tudnám megvalósítani, a legegyszerűbb módon?

Köszönet a válaszokért!

Üdvözlettel,
Balázs

Ha jobban megnézed, akkor ott van a válasz a kérésedre, de itt egy újabb példa, hátha így átjön :) 


$adat = []

def print_all
  unless $adat.empty?
    print "Adatok szama: #{$adat.count}\n"
    $adat.each_with_index { |sor,idx|
      print "Adat (idx: #{idx}):\n"
      print " - nev: #{sor[:nev]}\n"
      print " - cim: #{sor[:cim]}\n"
      print " - tel: #{sor[:tel]}\n"
    }
  else
    print "Nincs adat\n"
  end
end

$adat << {:nev => 'Nev 1', :cim => 'Cim 1', :tel => 'Tel 1'}
$adat << {:nev => 'Nev 2', :cim => 'Cim 2', :tel => 'Tel 2'}
$adat << {:nev => 'Nev 3', :cim => 'Cim 3', :tel => 'Tel 3'}

# masodik sorban modositas
$adat[1][:tel] = 'Custom tel number'

print_all

Nem kell előre deklarálnod semmit. Csinálsz egy üres hash-t és majd azt teszel bele amit akarsz:

adat = {}

Ami megzavar téged szerintem az az, hogy nem tudod hogy bármilyen különböző struktúra lehet bármilyen elemben, ráadásul akármilyen mélyen egymásba ágyazva. Tehát Ruby is több más nyelvhez hasonlóan teljesen megengedő és a fejlesztő maximális kényelmét és hatékonyságát szolgálja. Lásd a következőt:

adat = ["hello", 55, 3.14]

adat += [[1,2,3,4], "ez egy teszt"]

Az eredmény => ["hello", 55, 3.14, [1, 2, 3, 4], "ez egy teszt"]

Ugyanez van hash esetében is:

adat = {}
adat["Besenyő István"] = {:cim => "Szeged, Károly út 51", :tel => "+36 ..."}
adat["Nagy Miklós"] = {:eletkor => 44, "kedvenc szín" => "zöld"}
adat[:teszt] = "Ez egy naaagy teszt.."
adat["akármi"] = rand(100)

Nagyon szépen köszönöm a példákat, és valóban kicsit számomra az a zavaró, hogy a Rubyt nem ismervén nem szoktam hozzá, hogy ennyire megengedő.

Viszont a helyzet, hogy egy már előre megírt komolyabb ruby forráskódba szeretnék változtatni pár sort, ami szerencsére egész jól összejött, azt az egy dolgot kivéve, hogy egyáltalán nem működik a program, ha nincs előre megadva, milyen, és mennyi elem van az adott tömbben. Így most a legegyszerűbb számomra hogy előre megadom ezeket az adatokat üres értékekkel, de elég otrombán nézne ki egy több száz elemű tömb esetében több száz ilyen {:nev => '',:cim => '',:tel => ''} sor.

Miként tudnám ezt megoldani?

Tökéletesen működik az a minimális változtatás amit eszközölni szerettem volna.

Ha lesz rá időm és kedvem is akkor fogok foglalkozni rubyval komolyabban, de most van más dolgom.

Amúgy jogosnak mondható amit írtál, de nem segít :)

( thottee | 2017. 01. 28., szo – 17:57 )

Köszönöm mindenkinek a segítséget!

Egy órát szoptam azon hogy ha nem raktam $ kezdést akkor nagybetűvel kellett írnom a tömb nevét, hogy működjön stringként az adott környezetben :D

De sikerült felhasználnom az itt leírt ötleteket, köszönöm mindenkinek még egyszer a segítséget.