Řazení ve sloupcích a základy Ruby

22.11.2017 01:47 | Přečteno: 1768× | Linux | poslední úprava: 22.11.2017 01:46

Program načítá jednotlivé řádky z textového souboru, jehož název je na příkazové řádce jako argument, a poté je vypíše seřazené ve sloupcích, jako to dělá například příkaz ls. Pokud bychom měli na každém řádku klíčová slova z jazyku Golang, výpis by vypadal takto:

break       defer       goto        range       var         
case        else        if          return                  
chan        fallthrough import      select                  
const       for         interface   struct                  
continue    func        map         switch                  
default     go          package     type

Zde již samotný program:

TIOCGWINSZ = 0x5413


def get_size
  buf = [0, 0, 0, 0].pack("S4") 

  if STDOUT.ioctl(TIOCGWINSZ, buf) >= 0
    row, col, x, y = buf.unpack("S4")  
  else
    row = 20
    col = 70
  end    
  [row, col]
end


words = []
maxlen = 1

row, col = get_size

ARGF.each do |line|
  if line !~ /^\s+$/
    line.strip!
    if (s = line.size) > maxlen
      maxlen = s  
    end
    words << line
  end
end

words.sort!
maxlen += 1					#mezera

col = col / maxlen
row = (words.size + col) / col
fmt = "%%-%ds" % maxlen

(col*row).times do |i|						
  target = (i % col) * row + (i / col)		#svisle razeni  
  str = sprintf(fmt, (target < words.size) ? 
			words[target] : "")  
  print str
  puts if (i + 1) % col == 0 
end

Následuje několik poznámek.

V Ruby proměnné definované mimo metody nejsou v metodách viditelné. K vytvoření globální proměnné se používá prefix $ ($global). Funkce pack a unpack převádějí hodnoty na proud bajtů, potažmo proud bajtů na jednotlivé hodnoty, stejné funkce nalezneme i v Perlu a Pythonu.

a = [1,2,3,4,5,6,7,8,9,10]
b = a.pack('i10')		# b je proud deseti 4 bajtových cisel
c =  b.unpack('i*')
c == b 				# vraci true

Různé způsoby vytvoření pole

a = [3, 2, 1]
b = []         			# nové, prázdné pole
empty = Array.new		# nové, prázdné pole
nils = Array.new(3)             # nils je [nil, nil, nil]
zeros = Array.new(4, 0)         # zeros je [0, 0, 0, 0]
count = Array.new(3) {|i| i+1 } # count je [1, 2, 3] 

[[1,2],[3,4],[5]]		# pole poli

[1, 2, 3].length		# 3
[].size				# 0, synonymum pro length

Změna prvků v poli

a = [1, 2, 3]
a[0] = 0		# [0, 2, 3]
a[-1] = 4		# [0, 2, 4]
a[3] = 6		# [0, 2, 4, 6]
a[5] = 8		# [0, 2, 4, 6, nil, 8]
a << 10 		# [0, 2, 4, 6, nil, 8, 10]
a << 12 << 14		# [0, 2, 4, 6, nil, 8, 10, 12, 14]
a = [1, 2, 3]		# [1, 2, 3]
a + a			# [1, 2, 3, 1, 2, 3]
a.concat([4, 5])	# [1, 2, 3, 4, 5] a se meni, zadny vykricnik

a = ['a', 'b', 'c']
a.insert(1, 1, 2)	# a je ['a',1,2,'b','c']

Odstranění prvku

a = [1,2,3,4,5,6]
a.delete_at(4)          # vraci 5, a je a = [1,2,3,4,6]
a.delete_at(-1)         # vraci 6, a je [1,2,3,4]

Odstranění podle hodnoty

a.delete(4)		        # 4, a je [1,2,3]
a[1] = 1		
a.delete(1)		        # 1, a je [3]
a = [1,2,3]
a.delete_if {|x| x%2==1 }	# odstrani liche prvky, a je [2]
a.reject! {|x| x%2==0 }		# jako delete_if, a je []

Bloky

Proměnné definované v bloku mají platnost pouze v tom bloku. Bloky mohou být ohraničené buď složenými závorkami, anebo klíčovými slovy do a end, do a end se zpravidla používá u víceřadkových bloků.

5.times  {|i| print i }                    # tiskne "01234"  
0.upto(5) {|i| print i }                   # tiskne "012345"

a = [3, 2, 1]
a.each {|elm| print elm }      	           # tiskne "321"
b = a.map {|x| x*x }         	           # b je [9, 4, 1]
c = a.select {|x| x%2==0 }    	           # c je [2], jen sude
sum = a.inject {|s,x| s+x }                # sum je 6, soucet prvku
a.each_with_index{|e,i| print e,i}         # tiskne 302112

(5..7).each_with_index {|x,i| print x,i }  # tiskne "506172"

Iterace řetězce

s = "¥1000"
s.each_char {|x| print "#{x} " } 	# tiskne "¥ 1 0 0 0"

"hello".each_byte.to_a			# vraci [104, 101, 108, 108, 111]

s = "A\nB"
s.each_line {|l| print l.chomp}		# tiskne "AB"

Blok v bloku

1.upto(10) do |i|
  1.upto(10) do |i|
    print "#{i} "
  end
  print " ==> Row #{i}\n"
end

1 2 3 4 5 6 7 8 9 10  ==> Row 1
1 2 3 4 5 6 7 8 9 10  ==> Row 2
1 2 3 4 5 6 7 8 9 10  ==> Row 3
1 2 3 4 5 6 7 8 9 10  ==> Row 4
1 2 3 4 5 6 7 8 9 10  ==> Row 5
1 2 3 4 5 6 7 8 9 10  ==> Row 6
1 2 3 4 5 6 7 8 9 10  ==> Row 7
1 2 3 4 5 6 7 8 9 10  ==> Row 8
1 2 3 4 5 6 7 8 9 10  ==> Row 9
1 2 3 4 5 6 7 8 9 10  ==> Row 10

Ve starší verzi Ruby 1.8 by byl vnější index překryt a číslo řádku by zůstávalo na deseti. Kvůli lepší kompatibilitě existuje v Ruby 1.9 přepínač -w, který varuje, pokud má parametr bloku stejný název jako již existující proměnná.

#!/usr/bin/ruby -w

Soubory

File.open(filename) do |f|	     # otevre soubor
  f.each {|line| print line }	     # tiskne vsechny radky
end				     # zavre soubor

File.open(filename) do |f|
  f.each_with_index do |line,number|
    print "#{number}: #{line}"
  end
end

V Ruby samozřejmě existují i běžné cykly jako while, until nebo for/in.

while line = gets.chomp do      # do lze vynechat, pokud nasleduje \n 
  case line
  when /^\s*#/			# komentar
    next
  when /^quit$/i
    break
  else
    puts line.reverse
  end
end

Řetězce jsou v Ruby změnitelné (mutable).

"Ruby" + " rocks!" 		# "Ruby rocks!"
"Ruby! " * 3			# "Ruby! Ruby! Ruby! "
"%d %s" % [3, "rubies"]		# "3 Rubies"

greeting = "Hello"
greeting << " " << "World"
puts greeting   		# tiskne "Hello World"


s = "hello"
s.length			# vraci 5, pocet znaku v 1.9, bajtu v 1.8
s.size				# synonymum pro length
s.concat(" world")              # synonymum pro <<
				# meni se s a vraci nove s
s.empty?			# vraci false

s = "hello\n"			
s.chomp!			# vraci "hello", odstranen \n, meni se s 
s.chomp				# vraci "hello", nic se neodstranuje
s.chomp!			# vraci nil, nic se neodstranuje
s.chomp!("o")			# vraci "hell", meni se s

s = "hello\n"
s.chop!				# vraci "hello", odstranen \n, meni se s 				
s.chop				# vraci "hell", s se nemeni

s = "\t hello \n"
s.strip				# vraci "hello"
s.lstrip			# vraci "hello \n"
s.rstrip			# vraci "\t hello"

Metody strip, lstrip a rstrip mají i verze s vykřičníky, takže mění objekty volající tyto metody.

Metoda puts tiskne řetězec a na rozdíl od print jej ukončí \n, lze ji použit i bez argumentů, jen k odřádkování.

K rychlému otestování kódu můžete použít interaktivní interpreter irb.

Až budu umět Ruby lépe, tak sem dám třeba něco o objektech, asociativních polích a dalších operacích s řetězci a poli, protože tohle bylo jen několik výpisků z knihy The Ruby Programming Language.

Zdroj: The Ruby Programming Language a Perl Cookbook.        

Komentáře

[ttt]

Ještě ti chybí trochu lenosti :) Pomalé to bude tak jako tak, tak proč si např. nespočítat délku dalším cyklem, je to kratší a přehlednější.

Práce se soubory jde zkrátit na:

File.open(filename).each do |line|
  print line
end

Zápis blocku jde zkrátit pomocí '&':

[1,2,3].inject(&:+) # 6

S použitím pár dalších knihovních metod:

TIOCGWINSZ = 0x5413

def terminal_size
  buf = [0, 0, 0, 0].pack('S4')

  if STDOUT.ioctl(TIOCGWINSZ, buf) >= 0
    buf.unpack('S4')[0..2]
  else
    [20, 70]
  end
end

words = ARGF.readlines.map(&:strip).sort
width = words.map(&:length).max + 1

col = terminal_size[1] / width
row = words.size / col + 1
padding = row - words.size % row
words.fill('', words.size, padding)

puts words.each_slice(row).to_a.transpose
  .map { |ws| ws.map { |w| w.ljust(width) }.join }
  .join("\n")

[sad]

Pěkné. Díky za tipy.

[RM]

pěknej příklad :)

[ehm]

Máš ten kód celý na ruby.

[xsubway]

alespoň to není na JavaScript .-)

[s.b.]

A tohle nedostane tučňáka?