/home/wijet - Home

Quick tip #2: Memoizable

2009-04-22T14:05:00Z

Gdy jakaś metoda wykonuje kosztowne obliczenia, a jej wyniku używamy wielokrotnie, rozsądnym jest obliczenia wykonać raz, a wynik zapamietać, tzw. cachowanie za pomoca zmiennych instancji. W takim wypadku, najczęsciej używamy idiomu "||="

class Bar
  def foo
    @foo ||= lambda {
      # jakies kosztowne obliczenia
      ...
    }.call
  end
end

Od railsów 2.2 możemy korzystać z metody :memoize, należy dodać metody z modułu ActiveSupport::Memoizable jako metody klasy.

class Bar
  extend ActiveSupport::Memoizable

  def foo
    # jakies kosztowne obliczenia
    ...
  end

  memoize :foo
end

Spowoduje to że za pierwszym wywołaniem metody :foo, metoda ta faktycznie zostanie wywołana, a wartość przez nią zwrócona zapamiętana (dziala to tak jak cachowanie w zmiennej instancji, czyli tylko w obrebie danego obiektu).

Każde następne wywołanie metody :foo, na tym konkretnym obiekcie, spowoduje zwrócenie zapamiętanej wartośći.

Jeśli chcemy wymusić wywołanie metody (tzn. bez cachu), jako ostatni parametr należy podać wartość true.

Linki

Module ActiveSupport::Memoizable

Memo-what? - A Guide to Memoization

Railscasts: Memoization

What's New in Edge Rails: Easy Memoization

Quick tip #1: tap i returning

2009-04-11T19:15:00Z

Tym postem chcę rozpocząć serię którkich wpisów, o konkretnych metodach/konstrukcjach dostępnych w railsach, lub w samym Ruby, Za pomocą których możemy zrobić coś krócej, ładniej, bardziej ruby way.

Czasami pojawia się potrzeba wykonania na obiekcie pewnych operacji, a następnie zwrócenie go.

def foo(name)
  product = Product.find_or_initialize_by_name(name)
  # tu cos mieszamy z produktem
  ...
  # zapisujemy
  product.save
  product
end

jak widać na końcu musi być 'product' aby metoda zwracała product, inaczej :foo zwrociła by nam prawde lub fałsz, czyli wynik product.save

Możemy to bardzo elegancko, zastapić, poniższa konstrukcją

returning

def foo(name)
  returning Product.find_or_initialize_by_name(name) do |product|
    # tu cos mieszamy z produktem
    ...
    # zapisujemy
    product.save
  end
end

:returning przyjmuje obiekt, przekazuje go do bloku który otrzymuje, a następnie zwraca ten obiekt

tap

Za pomocą :tap możemy zrobić to samo, w troche inny sposob:

def foo(name)
  Product.find_or_initialize_by_name(name).tap do |product|
    # tu cos mieszamy z produktem
    ...
    # zapisujemy
    product.save
  end
end

Metoda :tap przyjmuje blok do którego przekazuje self (obiekt na którym została wywołana), a następnie po wykonaniu bloku zwraca self.

Obydwie metody sa dostepne w railsach. Warto wiedzieć że metoda :tap została włączona do Ruby w wersji 1.9.

Za pomocą metody :tap mozemy nawet wiecej poczarować, polecam przejrzenie poniższych linków:

Linki

Eavesdropping on Expressions

Tapping method chains with Ruby 1.9

Rails ActiveSupport returning Method

Mining ActiveSupport: Object#returning

Named scopes w ActiveRecord

2009-04-02T18:18:00Z

Od railsów 2.1 możemy korzystać z dobrodziejstw named_scopes, za pomocą których możemy definiować w łatwy sposób findery. Mowiąc prościej, możemy budować zapytania do bazy danych. Nie są to jednak zwykłe metody ktore wyszukują nam coś w bazie, zamiast prostego zbioru wyników, zwracany jest scope (zakres).

Aby rzucić więcej swiatła na sprawę, zacznijmy od przykładu:

class Product < ActiveRecord::Base
  named_scope :available, :conditions => "amount > 0"
  named_scope :featured, :conditions => {:featured => true}
end

Od railsów 2.x możemy korzystać z dobrodziejstw named_scopes, za pomocą których możemy definiować w łatwy sposób findery. Mowiąc prościej, możemy budować zapytania do bazy danych. Nie są to jednak zwykłe metody ktore wyszukują nam coś w bazie, zamiast prostego zbioru wyników, zwracany jest scope (zakres).

Aby rzucić więcej swiatła na sprawę, zacznijmy od przykładu:

class Product < ActiveRecord::Base
  named_scope :available, :conditions => "amount > 0"
  named_scope :featured, :conditions => {:featured => true}
end

Pierwszy argument to nazwa scopu, drugi to hash taki jak przyjmuje metoda :find, albo lambda która zwraca taki hash. Mozemy także wywołać named_scope z blokiem, ale o tym poźniej.

Product.available
# SELECT * FROM "products" WHERE (amount > 0)

Product.featured
# SELECT * FROM "products" WHERE ("products"."featured" = 't')

No tak, w sumie mozna by napisac "normalne" metody klasy, ktore zrobia to samo.

Wygladało by to tak:

def self.available
  all(:conditions => ["amount > 0"])
end

def self.featured
  all(:conditions => {:featured => true})
end

Dlaczego więc warto stosować named_scopes, zamiast "normalnych" metod ?

Ładniejszy, krótszy kod
Mozliwość łaczenia scopów

Łaczenie scopów

Tak, scopy mozemy łaczyć. Aby pobrać produkty, które są dostępne i promowane, napiszemy:


Product.available.featured
# SELECT * FROM "products" WHERE (("products"."featured" = 't') AND (amount > 0))

Jak widac, zostało wykonane jedno zapytanie, a warunki obu scopów zostały połączone.

Scopy które przyjmują argumenty

class Product < ActiveRecord::Base
  named_scope :limit, lambda { |limit| {:limit => limit} }
end

Wystarczy aby lambda zwracała hash opcji wyszukiwania, taki jak przekazujemy do metody :find.

Product.available.limit(20)

Anonimowy scope

Za pomocą metody scoped, moźemy tworzyć anonimowe scopy.

Product.scoped(:conditions => "name ~* 'tv'").limit(100)

Nie zaleca się jednak stosowania tego typu konstrukcji gdzie popadnie, gdyż możemy poprostu napisać scope nazwany w modelu, tam gdzie powinnismy trzymac nasze zapytania.

Są miejsca gdzie przydaje się anonimowy scope, tutaj jest przykład ciekawego wykorzystania Railscasts - Anonymous Scopes

Rozszerzenia dla named_scopes

Podobnie jak w przypadku associacji, możemy tworzyć rozszerzenia dla scopów. Dodajmy metode która zamówi wszystkie produkty, których brakuje.

named_scope :unavailable, :conditions => {:amount => 0} do
  def order
    each { |product| Order.create(:product => product) }
  end
end

Product.unavailable

Zwraca wszystkie produkty ktorych brakuje

natomiast

Product.unavailable.order

Tworzy zamowienia, dla kazdego z tych produktów.

Rails 2.3

W railsach 2.3 został wprowadzony scope dynamiczny i domyslny.

Dynamiczny scope

Możemy używac dynamicznych scopow, podobnie jak dynamiczynych finderow, czyli:

Product.scoped_by_amount_and_featured(100, true)

Domyślny scope

Nastepną bardzo użyteczna konstrukcją, jest możliwość zdefiniowania domyślnego scopu dla modelu. Bardzo często konkretna tabele sortujemy po konkretnej kolumnie/kolumnach.

class Product < ActiveRecord::Base
  default_scope :order => "name DESC"
end

Przydaje się też, gdy chcemy ukryc pewne rekordy, np. produkty które nie są aktualnie odstępne:

default_scope :conditions => "amount > 0"

Linki

Module ActiveRecord::NamedScope::ClassMethods

Railscasts named_scope

What's New in Edge Rails: Has Finder Functionality

What's New in Edge Rails: Default Scoping

What's New in Edge Rails: Dynamic Scope Methods

Daj się policzyć!

2007-12-14T14:23:00Z

Firma OpenLogic przeprowadza pierwszy na świecie spis programów open source. Jak wiadomo trudno jest policzyć wolne oprogramowanie, jest masa mirrorów, bardzo często oprogramowanie jest dostarczane razem z systemami operacyjnymi np linuksem, rozdawane na wszelakich konferencjach. Aby wdziąć udział w akcji należy ściągnąć program który przeskanuje nasz komputer w poszukiwaniu oprogramowania open source. Aplikacja wymaga interpretera Ruby przynajmniej w wersji 1.8.5. Pozostaje tylko czekać na pierwsze analizy wyników.

Dziwne zachowanie ||=

2007-11-04T13:26:00Z

Do tej pory myślałem o boo ||= "foo" jako naturalnym(lepszym) zamienniku dla instrukcji

boo = "foo" if boo.nil?

Czyli do zmiennej boo przypisujemy "foo" jeśli boo jest nil'em. Fakt ten jest opisany na wielu stronach, także w książce "Programowanie w Języku Ruby" czytamy:

words[key] ||= []

"...jeśli wpis w tablicy asocjacyjnej words dla klucza key nie istnieje(nil), wartością zwracaną przez || będzie drugi operand, > czyli nowa pusta tablica. Dlatego ten wiersz kodu przypisze tablice elementowi tablicy asocjacyjnej który nie ma jeszcze > wartości..."

I w takiej świadomości dość długo żyłem, dlatego metoda typu

def foo(options = {})
  options[:boo] ||= true
  options[:bar] ||= "r"
end

wydawała mi się całkowicie poprawna.

Niestety tak nie jest, przekazanie do metody :boo => false i tak powodowało ustawienie options[:boo] na true, z początku myślałem ze w nocy ktoś mi podmienił interpreter. Zajrzałem na strone (bardzo dobre źródło wiedzy o idiomach ruby) "Ruby: idmioms":http://www.rubygarden.org/ruby/page/show/RubyIdioms i moje wątpliwosci zostaly rozwiane

bq. You can also use the ||= operator to assign a value to a variable if it evaluates to false.

Do tej pory dałbym sobie rękę uciąć że ||= przypisuje wartość tylko gdy zmienna jest nil'em, i "...bym teraz k** ręki nie miał".

Łatwe pobieranie screencastow z Railscasts.com

2007-08-15T23:38:00Z

Na stronie Railscasts znajduje się masa screencastów o railsach, trochę irytowało mnie osobne ściąganie plików, sprawdzanie które już mam a których nie, wiec napisałem kawałek kodu. Skrypt pakujemy do katalogu w którym chcemy gromadzić filmiki, odpalamy, dostajemy listę dostępnych na stronie screencastow (pobrane są oznaczane na zielone, niepobrane na czerwono), następnie wpisujemy oddzielone spacjami numery screencastow do pobrania. Może komuś przypadkiem się przyda :)

#!/usr/bin/ruby
require 'open-uri'
require 'rss/2.0'
 
module RSS
  class Rss
    class Channel
      class Item
        def file_name
          @file_name ||= self.enclosure.url.split(/\//).last
        end
        def file_number
          file_name.split(/_/).first.to_i
        end
        def file_size
          self.enclosure.length.to_f / 1024 / 1024
        end
      end
    end
  end
end
 
rss_content = ""
open("http://feeds.feedburner.com/railscasts") do |f|
  rss_content = f.read
end
 
rss = RSS::Parser.parse(rss_content,false)
rss.items.reverse.each do |item|
  if File.exists?(item.file_name)
    printf "\e[32m%s (%.2f MB)\e[0m\n", item.title, item.file_size
  else
    printf "\e[31m%s (%.2f MB)\e[0m\n", item.title, item.file_size
  end
end
 
puts "Podaj numery screencastow do pobrania"
numbers = STDIN.gets
 
numbers.split(' ').each do |n|
  item = rss.items.detect{|i| i.file_number == n.to_i}
  unless item.nil? or File.exists?(item.file_name)
    system "wget -c #{item.enclosure.url}" 
  end
end

Symbole w Ruby

2007-08-07T00:20:00Z

W dobrze napisanym kodzie Ruby często możemy spotkać symbole, nic dziwnego – w wielu miejscach użycie symboli zamiast stringów wpływa pozytywnie na wydajności programu a także należy do dobrego stylu programowania. Na początku przygody z Rubim zrozumienie symboli może sprawić kłopot.

Symbol jest identyfikatorem który odpowiada łańcuchowi znaków, możemy go traktować jako “lżejszą” odmianę stringa. Symbole możemy definiować na kilka sposobów.

:foo
:'foo'
:"foo"
"foo".to_sym

Symbol posiada zarówno reprezentacje liczbową jak i znakową. Dla nas bardziej znacząca jest reprezentacja znakowa. Faktycznie symbole możemy traktować jako stringi, ale stringi niemodyfikowalne tzn. nie mogą występować po lewej stronie operatora przypisania. Wiec jeśli nie potrzebujemy modyfikować napisu ani używać metod z klasy String, możemy skorzystać z symboli. Kolejnym dobrym zastosowaniem jest użycie symboli w charakterze stałych np: jako przełącznik, tak jak poniżej.

def read_file(file_name,user_mode)
  case user_mode
    when :nobody
      #....
    when :user
      #....
    when :admin
     #....
  end
end
read_file("config.txt",:user)

Bardzo ważna właściwością symboli jest to, że podczas działania programu takie same symbole są zawsze odwołaniem do jednego obiektu w pamięci, który jest tworzony tylko raz. Przeanalizujmy wyniki działania poniższego skryptu, który wyświetla id utworzonych obiektów.

puts "foo".object_id
puts "foo".object_id
puts :foo.object_id
puts :foo.object_id

Wyniki:

Jak widać “foo” i “foo” to tak naprawdę dwa różne obiekty (zajmują różne miejsca w pamięci) natomiast w przypadku symboli :foo i :foo widzimy że id jest takie same, a wiec stosując symbole oszczędzamy pamięć. Dlatego świetnym zastosowaniem dla symboli jest użycie ich jako kluczy w haszu.

foo = {:boo => 12,:bar => "ble" }

	odwołanie

foo[:bar]

W tym przypadku zysk w postaci zaoszczędzonej pamięci będzie znikomy, ale warto zauważyć ze jeśli mielibyśmy np. tablice użytkowników typu

users = [{:login => "abc",:pass => "qaz",:email => :email => "abc@domain.pl"},
              {:login => "qwe",:pass => "rty",:email => :email => "eee@domain.pl"}
             ]

zawierająca 100 użytkowników i zamiast symboli używali stringów jako kluczy. Zamiast 3 obiektów (kluczy) mielibyśmy 300 obiektów, które zwykle nie są nam do niczego potrzebne i tylko pożerają pamięć.

Jak już pisałem symbole posiadają także reprezentacje liczbową którą możemy otrzymać wywołując metodę to_i.
Jest ona używana podczas porównywania symboli, tzn. porównywana jest reprezentacja liczbowe czyli liczby. Jeżeli dwa symbole maja taką sama reprezentacje liczbowa to znaczy że są to te same symbole. W przypadku stringów sytuacja wygląda inaczej porównując dwa stringi na pewny poziomie abstrakcji tak naprawdę dochodzi do porównywania znak po znaku, co jest bardziej czasochłonne niż porównywanie dwóch liczb.

Symbole są powszechnie używane do przekazywania nazw metod i zmiennych, np przy tworzeniu setterów i getterów. W klasie poniżej tworzony jest getter dla zmiennej @foo aby można było odczytać ją z poza obiektu.

class Boo
  attr_reader :foo
end

Metoda attr_reader zadziała tak samo jeśli przekażemy nazwę zmiennej jako string, wynika to z jednak z jej implementacji a nie z jakiejś “magi” symboli.
W następnym przykładzie używamy metody send z klasy Object, uruchamia ona metodę przekazaną jej jako symbol.

obj.send(:foo)

W obu przykładach ponownie pojawia się pytanie, po co symbole? Gdybyśmy przekazali nazwy atrybutów, metod jako stringi wszystko by działało, w tych przypadkach użycie symboli (oprócz tego że jest bardziej optymalne) jest bardziej naturalne. Nie obchodzi nas tak naprawdę nazwa jako sekwencja znaków,nie interesuje nas treść tylko to co ona symbolizuje(identyfikuje).

Postawy YAML’a, czyli łatwe serializowanie i deserializowanie obiektów

2007-07-11T00:14:00Z

YAML jest prostym językiem służącym do opisu danych. Obiekty są przedstawiane za pomocą czystego tekstu, łatwego do czytania i edycji. YAML pozwala na składowanie zarówno pojedynczych obiektów jak i różnych zbiorów obiektów. Istnieje wiele implementacje YAML’a m.in. dla php, python, ruby, pozwala to na przenoszenie danych pomiędzy aplikacjami napisanymi w rożnych językach. Dzięki formatowi plików YAML nadaje się przede wszystkim do przechowywania konfiguracji, logów a także tworzenia prostych raportów.

Obsługa YAML’a jest banalnie prosta i w zasadzie ogranicza się do wczytania lub zapisania danych.
Zapisujemy zawartość zmiennej config do pliku.

require 'yaml'
config = {
 :max_users=>200,
 :db=>
    {:host=>"localhost",
      :user_name=>"shop",
      :db_name=>"shop",
      :password=>"shop123"
    },
 :timeout=>10
}
 
File.open("config.yaml","w") { |file| YAML.dump(config,file) }

Dane można konwertować to formatu YAML również za pomocą metody to_yaml, która po załadowaniu biblioteki yaml jest dodawana do obiektów w programie.
Plik config.yaml:

---
:max_users: 200
:db:
    :host: localhost
    :user_name: shop
    :db_name: shop
    :password: shop123
:timeout: 10

Jak widać format pliku jest bardzo czytelny i łatwy do edycji. Wczytywanie danych z pliku również jest proste.

require 'yaml'
config = YAML.load_file("config.yaml")

Warto wspomnieć że za pomocą YAML’a możemy zachować dane z dowolnego obiektu, a gdy zajdzie taka potrzeba zainicjować obiekt tymi danymi.

Kawałek przykładu:

require 'yaml'
class Student
  def initialize(id,name,last_name)
    @id, @name, @last_name = id, name,last_name
    @marks = {}
  end
  def add_mark(subject,mark)
    @marks[subject] = mark
  end
end
 
o1 = Student.new(32124,"Tomek","Kowalski")
o1.add_mark("Matematyka",3)
o1.add_mark("Fizyka",4)
o1.add_mark("Biologia",5)
#zachowujemy zawartość obiektu
File.open("student.yaml","w") { |file| file.write(o1.to_yaml) }
#tworzymy nowy obiekt inicjalizując go zachowanymi danymi
o2 = YAML.load_file("student.yaml")

Własne gemy - jak instalować gemy bez łaski root’a

2007-06-27T20:24:00Z

Najlepszym sposobem używania bibliotek ruby są gemy, bardzo prosta instalacja aktualizacja, rubygems także rozwiązuje problem zależności miedzy bibliotekami. Standardowo tylko administrator może dokonywać operacji na gemach. Możemy tak skonfigurować rubygems by korzystać z tych zainstalowanych już w systemie, a także instalować własne.

Tworzymy katalog dla gemów, następnie sprawdzamy gdzie w systemie są instalowane gemy domyślnie.

gem environment

Spisujemy ścieżki pod GEM PATH. Tworzymy w katalogu domowym plik .gemrc do którego pakujemy te ścieżki plus ścieżkę w której chcemy instalować własne gemy, plik będzie wyglądać mniej więcej tak:

gempath:
 - /usr/lib/ruby/gems/1.8
 - /home/wijet/gems

Istotny jest format pliku, ponieważ jest interpretowany jako plik YAML.

Już możemy instalować własne gemy:

gem install rails -i /home/wijet/gems

Bardzo często wychodzą nowe wersje gemów, możemy hurtem przeprowadzać update gemów bez zawracania głowy adminowi.

gem update -i /home/wijet/gems

Markaby - pisz w Ruby, wyświetlaj html

2007-05-03T19:11:00Z

Pisząc mój serwer http w rubym, chciałem skorzystać z jakiegoś systemu szablonów, wybrałem ERB który jest chyba najprostszy i był najbliżej, bo w standardowej bibliotece języka. Pliki templatow ERB to wymieszany HTML z kodem ruby umieszczonym miedzy znacznikami, który następnie jest wykonywany. Taki format templatow jest średnio czytelny. Przeglądając kod micro frameworka Camping’a natknąłem się na "Markaby":http://code.whytheluckystiff.net/markaby/ (Markup as Ruby), czyli szablony w czystym ruby!.

Przyjrzałem się trochę możliwością Markaby i stwierdziłem to jest to czego potrzebuje, jak rozwiniecie nazwy wskazuje markaby pozwala nam pisać szablony w czystym ruby, po przetworzeniu otrzymujemy gotowy do wyświetlenia kod HTML. Jest doskonała alternatywa dla ERB i innych systemów szablonów opartych na znacznikach i jakiejś nowej składni, można go używać w railsach. Co więcej Markaby tworzy kod zgodny z XHTML 1.0 Strict lub Transitional, potrafi wyłapywać nasze niektóre pomyki, a także znaczniki które są niedozwolone w danym standardzie.

Markaby jest dostępne w postaci gemu i paczki tgz "http://rubyforge.org/projects/markaby":http://rubyforge.org/projects/markaby. Instalowanie czegokolwiek za pomocą rubygems jest banalnie proste wiec tak zrobimy:

gem install markaby -y

Cała praca z Markaby to tak naprawdę wywoływanie metod(tu małe kłamstwo) i przekazywanie im bloków kodu. Nazwy metod które wywołujemy to nazwy tagów HTML. Przejdźmy do przykładu by zobaczyć jak to wygląda.

require 'markaby'
output = Markaby::Builder.new(:indent=>1) do
  html do
    head { title "To jest jakis tytul" }
    body { "Jakis napis w ciele dokumentu" }
  end
end
puts output.to_s

<html>
  <head>
    <meta content="text/html; charset=utf-8" http-equiv="Content-Type"/>
    <title>To jest jakis tytul</title>
  </head>
  <body>
    Jakis napis w ciele dokumentu    
  </body>
</html>

Parametr :indent określa o ile spacji będzie wcinany każdy blok kodu wynikowego. Domyślnie ma on wartość zero, która powoduje ze otrzymamy kod html w jednej linii.

xhtml_strict do
    head { title "Strona numer 2" }
    body do
      h1 "Naglowek strony numer 2"
      div do
        p "Pierwszy akapit"
        strong "tu pogrubione"
        div { blockquote "a tu kawalek cytatu w div'e" }
      end
    end
  end
end

<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<h1>Naglowek strony numer 2</h1>
<div>
  <p>Pierwszy akapit</p>
  <strong>tu pogrubione</strong>
  <div>
    <blockquote>a tu kawalek cytatu w div'e</blockquote>
  </div>
</div>

Jak widać aby zagnieżdżając coś pomiędzy tagami html wystarczy przekazać to jako blok kodu. Jest bardzo intuicyjne, robimy to tak samo jak w przypadku zwykłego kodu html. Możemy także manipulować parametrami tagów, umieszczając odpowiedni parament w postaci symbolu po argumencie metody będącym zawartością tagu, jeśli ten argument jest podany.

a "Ruby!",:href=>"http://ruby-lang.org"
p "To bedzie na zielono",:style=>"color:green"
div :style=>"color:red;font-weight:bolder" do
  "Tu cos w div'ie"
end

<a href="http://ruby-lang.org">Ruby!</a>
<p style="color: green">To bedzie na zielono</p>
<div style="color: red; font-weight: bolder">Tu cos w div'ie</div>

Gdy używamy stylów css przydaje się aby elementy naszej strony należały do jakiejś klasy i/albo posiadały jakiś identyfikator, markaby łatwo pozwala je nadawać, spójrzmy na przykład.

div.spis! do
  ul do
    ["abc","123","a2c"].each do |var|
      li.wartosci var
    end
  end
end
p.zielony { "Tu powinno byc zielono" }

<div id="spis">
  <ul>
    <li class="wartosci">abc</li>
    <li class="wartosci">123</li>
    <li class="wartosci">a2c</li>
  </ul>
</div>
<p class="zielony">Tu powinno byc zielono</p>

Jak widać kod szablonu jest bardzo przejrzysty, łatwy do czytania i interpretacji (w końcu to ruby!).

Sortowanie prawie optymalne

2007-04-28T15:21:00Z

Temat sortowania aktualny ponieważ na zajęciach z algorytmów i struktur danych omawiamy właśnie sposoby sortowania. Dowiedziałem sie jakoś,czy ktoś mi powiedział, czy usłyszałem gdzieś o głupim sortowaniu, jako przykład chyba najbardziej nieefektywnego sposobu sortowania. Z ciekawości poszukałem i napisałem trochę kodu.

Znalazłem trochę informacji w sieci, pierwszy sposób to Bogosort, algorytm bardzo prosty można przedstawić na przykładzie sortowania tali kart
tasujemy karty sprawdzamy czy są posortowane jeśli nie tasujemy jeszcze raz i tak aż do momentu kiedy talia będzie posortowana. Pesymistyczna złożoności obliczeniowa to O(n*n!), korzystamy z losowych permutacji zbioru co powoduje ze możemy nigdy nie otrzymać posortowanego zbioru. W najlepszym przypadku możemy otrzymać posortowany zbiór po jednym losowaniu permutacji zbioru.

Podobnym algorytmem sortowania do Bogosort jest Bozo sort, także opiera się na losowych permutacjach zbioru. Sprawdzamy czy zbiór jest posortowana jeśli nie wybieramy dwa losowe elementy zbioru i zamieniamy ze sobą i znowu sprawdzamy czy zbiór jest posortowany.
Oba algorytmy są wysoce nieefektywne, i raczej nie przydadzą sie w jakich kolwiek zastosowaniach. W wolnej chwili w ramach ćwiczenia rubiego napisałem kawałeczek kodu realizującego te dwa algorytmy.

class Array
  def bogosort!
    shake until is_sorted?
    self
  end
 
  def bozosort!
    until is_sorted?
      a = rand(size-1)
      b = rand(size-1)
      self[a], self[b] = self[b], self[a]
    end
    self
  end
 
  def is_sorted?
    for i in 0..size-2
      if self[i] > self[i+1]
        return false
      end
    end
    true
  end
 
  def shake
    for i in 0..size-1
      a = rand(size-1)
      self[i], self[a] = self[a], self[i]
    end
    self
  end
 
end

Dobierz sobie kolor

2007-04-05T14:58:00Z

Ostatnio przeglądając forum.php.pl przypadkowo znalazłem bardzo przydatna stronkę ColorBlender . Jestem totalny antytalenciem jeśli chodzi o grafikę i dobieranie kolorów, a tu mieszając suwakami mam 6 dobranych do siebie kolorów, pewnie nie jest to idealne dobranie barw, ale jest na pewno lepsze niż zdał bym się na własny gust.