「.new」を含む日記 RSS

はてなキーワード: .newとは

2011-10-25

はてなブックマーク/見たくないリンク

0taku\.livedoor\.biz

2chblog\.jp

2chcopipe\.blog122\.fc2\.com

2chcopipe\.com

2chfootball\.net

2chmokomokocat\.blog72\.fc2\.com

2r\.ldblog\.jp

akb48matome\.com

alfalfalfa\.com

androidken\.blog119\.fc2\.com

ankeet\.ch

aresoku\.blog42\.fc2\.com

arukugamu\.blog70\.fc2\.com

asuui\.blog137\.fc2\.com

ayacnews2nd\.com

barukanlog\.blog31\.fc2\.com

bipblog\.com

blog\.esuteru\.com

blog\.livedoor\.jp\/batten821

blog\.livedoor\.jp\/booq

blog\.livedoor\.jp\/ch2ch2ch2

blog\.livedoor\.jp\/chihhylove

blog\.livedoor\.jp\/coleblog

blog\.livedoor\.jp\/darkm

blog\.livedoor\.jp\/domesaka

blog\.livedoor\.jp\/domesaka

blog\.livedoor\.jp\/domesoccer

blog\.livedoor\.jp\/dqnplus

blog\.livedoor\.jp\/football_news001

blog\.livedoor\.jp\/funs

blog\.livedoor\.jp\/gatun02

blog\.livedoor\.jp\/goldennews

blog\.livedoor\.jp\/googleyoutube

blog\.livedoor\.jp\/gundam2ch

blog\.livedoor\.jp\/gurum22

blog\.livedoor\.jp\/guusoku

blog\.livedoor\.jp\/himasoku123

blog\.livedoor\.jp\/hisabisaniwarota

blog\.livedoor\.jp\/ikuzi2p

blog\.livedoor\.jp\/insidears

blog\.livedoor\.jp\/iphonech

blog\.livedoor\.jp\/jyoshi2ch

blog\.livedoor\.jp\/jyoushiki43

blog\.livedoor\.jp\/kaibu222

blog\.livedoor\.jp\/karukan123

blog\.livedoor\.jp\/kashikou

blog\.livedoor\.jp\/kekkongo

blog\.livedoor\.jp\/kinisoku

blog\.livedoor\.jp\/lunasoku

blog\.livedoor\.jp\/matometatta

blog\.livedoor\.jp\/minnanohimatubushi

blog\.livedoor\.jp\/myonkui

blog\.livedoor\.jp\/negigasuki

blog\.livedoor\.jp\/nekokan2011

blog\.livedoor\.jp\/news23vip

blog\.livedoor\.jp\/newskorea

blog\.livedoor\.jp\/nicovip2ch

blog\.livedoor\.jp\/nonvip

blog\.livedoor\.jp\/notaffiliate

blog\.livedoor\.jp\/nwknews

blog\.livedoor\.jp\/omoidesokuhou

blog\.livedoor\.jp\/pachineet

blog\.livedoor\.jp\/peperon999

blog\.livedoor\.jp\/ringotomomin

blog\.livedoor\.jp\/roadtoreality

blog\.livedoor\.jp\/samplems\-bakufu

blog\.livedoor\.jp\/sangokuken

blog\.livedoor\.jp\/satohoblog

blog\.livedoor\.jp\/soccerkusoyarou

blog\.livedoor\.jp\/uresujibest10

blog\.livedoor\.jp\/video_news

blog\.livedoor\.jp\/worldfusigi

blog\.livedoor\.jp\/yohoo123matome

brow2ing\.doorblog\.jp

burusoku\-vip\.com

caffemocha8\.blog\.fc2\.com

ch\-neru\.doorblog\.jp

channelz\.blog118\.fc2\.com

chaos2ch\.com

chitekizaisan\.blog28\.fc2\.com

d\.hatena\.ne\.jp\/nunnnunn

dariusnews\.blog11\.fc2\.com

digital\-thread\.com

eegg\.dip\.jp

eroytuma\.blog\.fc2\.com

exawarosu\.net

gasoku\.livedoor\.biz

getnews\.jp

ggsoku\.com

ghardknow\.blog105\.fc2\.com

gogotorimaru\.blog19\.fc2\.com

hamusoku\.com

himarin\.net

hogehogesokuhou\.ldblog\.jp

horahorazoon\.blog134\.fc2\.com

houani\.blog118\.fc2\.com

insyoku\.livedoor\.biz

itaishinja\.com

jin115\.com

kabumatome\.doorblog\.jp

kanasoku\.blog82\.fc2\.com

katuru2ch\.blog12\.fc2\.com

kimsoku\.com

kiri550\.blog94\.fc2\.com

koenews\.blog9\.fc2\.com

komopes\.blog54\.fc2\.com

kuma2ch\.ldblog\.jp

kuromacyo\.livedoor\.biz

lamsect\.blog112\.fc2\.com

lifehack2ch\.livedoor\.biz

majikichi\.com

mamesoku\.com

matacoco\.com

matomate\.blog133\.fc2\.com

matomattaare\.blog\.fc2\.com

matomech\.com

matomeru\.me

matometanews\.com

mazikanon\.blog102\.fc2\.com

michaelsan\.livedoor\.biz

minisoku\.blog97\.fc2\.com

moebutanews\.blog59\.fc2\.com

moepons\.blog\.fc2\.com

msy738\.blog75\.fc2\.com

mudainodqnment\.ldblog\.jp

music2chnews\.blog123\.fc2\.com

nakasoku\.blog18\.fc2\.com

nanpinshimasuta\.blog\.fc2\.com

nantuka\.blog119\.fc2\.com

neetetsu\.com

nekomemo22\.blog99\.fc2\.com

netaatoz\.jp

netouyonews\.net

news\.2chblog\.jp

news020\.blog13\.fc2\.com

news4vip\.livedoor\.biz

news4wide\.livedoor\.biz

newsawards\.ldblog\.jp

now2chblog\.blog55\.fc2\.com

nw2\.blog112\.fc2\.com

omasoku\.blog90\.fc2\.com

onsoku\.info

otajyuu\.blog40\.fc2\.com

otanews\.livedoor\.biz

oyoguyaruo\.blog72\.fc2\.com

pirori2ch\.com

rakusyasa\.blog41\.fc2\.com

runxz\.blog4\.fc2\.com

ryusoku\.com

seiyuusokuhou\.blog106\.fc2\.com

sierblog\.com

siki420\.blog45\.fc2\.com

simapan\.org

snudge\.blog38\.fc2\.com

sorega801\.blog133\.fc2\.com

spon\.me

subcultureblog\.blog114\.fc2\.com

suiseisekisuisui\.blog107\.fc2\.com

tamasoku\.blog35\.fc2\.com

tenkomo\.blog46\.fc2\.com

tokati\.livedoor\.biz

tokuteisuta\.blog24\.fc2\.com

tundaowata\.info

u1sokuhou\.ldblog\.jp

umashika\-news\.jp

underworld2ch\.blog29\.fc2\.com

vip0nanzo\.blog109\.fc2\.com

vippers\.jp

vipsister23\.com

vipvipnews\.com

watch2ch\.2chblog\.jp

white0wine\.blog10\.fc2\.com

workingnews\.blog117\.fc2\.com

www\.news30over\.com

www\.scienceplus2ch\.com

www\.syu\-ta\.com

www\.tokuteishimasuta\.com

xxlarmesxx\.blog134\.fc2\.com

yakiusoku\.blog\.fc2\.com

yaraon\.blog109\.fc2\.com

yarareyaku\.com

yutori2ch\.blog67\.fc2\.com

zeark969\.blog38\.fc2\.com

2010-07-27

[]みんくちゃんねるから画像を抜き出すワンライナー

<< を半角にして使ってね

ruby -ropen-uri -rnokogiri -e "Nokogiri::HTML(open 'http://minkch.com/archives/51382882.html').search('img').inject([]){|b,r| b << r[:src] if /^http:\/\/.+\.jpg/ =~ r[:src]; b}.map{|url| Thread.new(url){|u| File.open(u.match(/.+\/(.+\.jpg)$/)[1],'w'){|f| f << open(u).read }}}.each{|e| e.join}"

2010-04-22

Redmine 0.9.3をTomcat 6で実行する方法

結構苦労したので健忘録として。。

環境は以下のとおり

JDK, Tomcat, JRubyインストール済み

MySQLインストール
yum install mysql-server
MySQLの起動
/etc/init.d/mysqld start
MySQLの設定

rootパスワードなどを設定する

mysql_secure_installation
Rubyモジュールインストール

RubyGemsモジュールインストールする

jruby -S gem install rails
jruby -S gem install warbler
jruby -S gem install activerecord-jdbc-adapter
jruby -S gem install activerecord-jdbcmysql-adapter
jruby -S gem install jdbc-mysql
MySQLRedmineデータベースを作成
mysql -u root -p
mysql> create database redmine character set utf8;
mysql> grant all privileges on redmine.* to 'redmine'@'localhost' identified by 'redmine';
mysql> exit

(ここでは、パスワードredmineしているが自由に)

RedmineDB設定

(任意の場所にRedmine解凍して、解凍先のディレクトリに移動した後)

cp config/database.yml.example config/database.yml
vi config/database.yml

database.yml

production:
  adapter: jdbcmysql
  database: redmine
  host: localhost
  username: redmine
  password: redmine
  encoding: utf8

#development:
#
#
#test:
#
#

後のwarbleでのエラーを防ぐため、developmentとtestコメントアウト

DBへのデータ投入
jruby -S rake generate_session_store
jruby -S rake db:migrate RAILS_ENV=production
jruby -S rake load_default_data RAILS_ENV=production
起動確認

script/serverで起動し、http://localhost:3000 にアクセスして正常に動作するか確認する

jruby script/server -e production
production.rbの修正

Tomcatで動かしたときにログ出力するための設定をする

vi config/environments/production.rb
config.logger = Logger.new(config.log_path)
config.logger.level = Logger::INFO
warblerの設定

warble.rbを生成

jruby -S warble config

warble.rbを修正

vi config/warble.rb
  config.dirs = %w(app config lib log vendor tmp extra files lang)
  config.gems = ["jdbc-mysql", "activerecord-jdbcmysql-adapter", "activerecord-jdbc-adapter"]
  config.gems["rails"] = "2.3.5"
  config.gems["rack"] = "1.0.1"
  config.webxml.rails.env = "production"

warファイルを作成

jruby -S warble

できたwarファイルTomcatに配置して、Tomcatを起動する

mv redmine-0.9.3.war /usr/local/tomcat/webapps/redmine.war
/usr/local/tomcat/bin/startup.sh

warblerのバグ(?)でwarに入らないファイルコピーして入れる

cp vendor/gems/rubytree-0.5.2/.specification /usr/local/tomcat/webapps/redmine/WEB-INF/vendor/gems/rubytree-0.5.2

http://localhost:8080/redmine/ にアクセスしてインストールできたか確認して完了!

2010-03-25

Re:日本の農機メーカーってガラパゴス進化代名詞なんですがね・・・

http://d.hatena.ne.jp/pal-9999/20100324/p1

こんな記事がはてBで話題になってて、読んでみたら、中身がsuckで頭に来たので、つらつらと書いていきますけどね。

で、救いようがないと思ったのが、この部分。

この人は、日本農業が、どこに強みをもっているか、まるで知らない事が、この一文で丸出し。日本農業技術は、狭い土地で多収穫可能になるような形で発展してきた。そのため、作物の品種改良や育成技術改良には非常に熱心で、単位面積あたりの収量という点では、小麦にしろ米にしろ欧米とは比較にならないくらい高い。

国際連合食糧農業機関(FAO)

FAOSTAT(http://faostat.fao.org/)より

米(t/ha)@2008
 1.Egypt		9.7309
 2.Australia		9.5000
 3.El Salvador		7.9373
 4.Uruguay		7.9025
 5.USA			7.6716
 6.Turkey		7.5716
 7.Korea		7.3942
 8.Peru			7.3567
 9.Morocco		6.9562
10.Spain		6.9209
11.Argentina		6.8277
12.Greece		6.7354
13.China		6.5558
14.Japan		6.4875

十分健闘していると思うが、それでも欧米より高いと思うのは間違い。アメリカよりも低いです。


小麦(t/ha)@2008
 1.Ireland		9.0629
 2.Netherlands		8.7297
 3.Belgium		8.3595
 4.United Kingdom	8.2813
 5.New Zealand		8.1120
 6.Germany		8.0873
 7.Denmark		7.8638
 8.France		7.1009
 9.Luxembourg		6.6616
10.Egypt		6.5009
:			
:			
31.Japan		4.1037
:			
:			
49.USA			3.0177

Europe全体 		4.0270

小麦に関しては、1haあたりの収量で、アメリカの12倍、EUの3倍に上る。

↑に関しては何を見たのか分かりませんが、そんなに差があるわけありません。EUには小麦食って生活している農業大国が沢山あります。世界市場という戦場で農業をもってして戦っている国々の収量が、兼業農家の収量に劣っているわけも無く。


普通に考えてみてください。アメリカの麦畑と日本の麦畑。同じ一区画に12倍も実っていたら、アメリカがしょっぼーいか、日本の麦が重みで折れるかどっちかです。ありえません。


ただ、はてブの方々が言うことにも賛成しませんが。日本農業自然環境特化型ではなく、保護政策の庇護による社会環境特化型。しかも大規模農家が極端に少なく、兼業農家ばかりで高齢化も進んでいる日本で、農業が衰退していくのは確実。となると日本の農機具メーカー海外に出るか、農機具メーカーをやめるか。携帯ガラパゴスとは違い、先は暗いガラパゴスです。

2010-03-15

外国人参政権国民生活を壊す/山田 宏(杉並区長)

ttp://zasshi.news.yahoo.co.jp/article?a=20100212-00000001-voice-pol

 まず、私自身が経験したことをお話ししたいと思う。2005年杉並区扶桑社歴史教科書を採択したときのことである。



 いずれの国であれ、自国の国民の子弟の教育内容は、その国の国民責任をもって決めるのが当然である。どの教科書を選ぶかも国民重要テーマで、小中学校の場合、それは市町村教育委員会の権限になっている。その権限に基づいて、杉並区教育委員会扶桑社歴史教科書を採択するのではないかとマスコミで報じられるや、全国の民団在日大韓民国民団)から抗議の手紙が殺到した。全国各地の民団の各支部から続々と舞い込んできたのである。どの歴史教科書を採択するかは民団が強く関心をもってきたテーマであり、彼らの主張する歴史認識に反する教科書を採択しないよう強く求めてきたのだ。



 そればかりではなく、杉並区議会でこの教科書採択のことが質問に上ると、民団関係者と思しき人びとが大挙して傍聴に訪れて傍聴席に陣取り、大きな声で野次を続けた。議会の傍聴席でそのような行為は禁じられており、議長も注意をするのだが、どんなに注意されようとも意に介さない。さらに、区長室の前にも多人数で押し掛け、シュプレヒコールを繰り返したのであった。



 もし、外国人参政権が付与されていたらどうなっただろうか。外国人区長区議会議員に対する選挙権をもつようになり、そのうえであのような激しい抗議活動が行なわれたとすれば、与野党を問わず、彼らの顔色を窺おうとする議員が出てきただろう。また、たとえばルール違反の抗議活動を排除しようとした場合、これまでならば、「日本人責任をもつべ教育の内容について、このような干渉をするのは失礼ではないですか」と主張することもできたが、外国人参政権が認められていれば「同じ有権者なのに、われわれを日本人差別するのか」という話にもなりかねない。

2009-10-15

http://anond.hatelabo.jp/20091015141743

ttp://www.news.janjan.jp/living/0606/0605315277/1.php

しょせんjanjan、信用するかどうかは任せる。

とはいえコンビニFC店長なんぞていのいい奴隷に過ぎない、というのはほぼ定説化しているし、裁判もそこかしこで起きている。

親が死ぬのをみすみす見ているのが趣味なら放置

そうでなければ、安美容室の店員にでもなったほうがまだマシだろう。

2009-10-12

[][]twitterのfollowingを整理するためのスクリプト

非常に頭が悪いやり方ですが、一応動くので置いておきます

必要なもの

動かし方

  1. 以下のソースのうち、meの部分を自分idに変えて保存。
  2. 実行
# -*- coding: utf-8 -*-
require 'uri'
require 'open-uri'
require 'rubygems'
require 'twitter'
require 'json'

LAST_YEAR = Time.now - 12*31*60*60*24
USERNAME = 'hogehoge'
PASSWORD = '********'

def following_me? other
  base = URI.parse('http://twitter.com/friendships/exists.json')
  base.query = "user_a=#{other}&user_b=#{USERNAME}"

  times = 0
  begin
    sleep 60
    open(base).read == 'true'
  rescue
    if times < 2
      times += 1
      retry
    else
      true
    end
  end
end

def posted? hash
  begin
    sleep 60
    last_post = @client.timeline_for(:user, :id=&gt;hash[:user], :count=&gt;1).first.created_at
  rescue Twitter::RESTError # protected ~A~K~A following ~A~L 0 ~A | ~P~H~A~Y~T~_~A~W~A~_~_
    p "#{$!}"
    p "passing  #{hash[:user]}"
    return true # ~D~P~F~_~P~F~J~\~A~Q~B~K
  rescue # twitter~A~L~P~A~A~B~K~Y~B対~V
    p "#{$!}"
    sleep 180
    retry
  end
  p "last_post was  #{last_post}"
  last_post &gt; hash[:from]
end

@client = Twitter::Client.new(:login =&gt; USERNAME, :password =&gt; PASSWORD)
(1..20).each do |pg|
  @client.my(:friends, :page=&gt;pg).each do |friend|
    p "checking #{friend.screen_name}"
    unless ((following_me? friend.screen_name) &amp;amp;&amp;amp; posted?({:from=&gt;LAST_YEAR, :user=&gt;friend.screen_name}))
      p "removing #{friend.screen_name}"
      sleep 60
      @client.friend(:remove, friend)
    end
  end
end

2009-03-24

http://anond.hatelabo.jp/20090324005857

img_passがimg_pathの間違いなんじゃないか、と思う以外は別にそんなに分かりにくいと思わないけどなぁ。

俺も同じようにすると思う。

Thumbnail, thumbnail, thumbnailsが紛らわしいと思うなら、

thumb_array = array.new();
while(img_path = gets())
  thumb = Thumbnail.new(img_path)
  thumb_array.add(thumb)
end

とすればよろし。

名付け方

ギークではないし、どちらかといえば下手なのですが。

http://anond.hatelabo.jp/20090324005857



  1. インスタンス名をどうするか
  2. 生成したインスタンスを格納する配列名前をどうするか
    • その集合を現す名前があるはず。

例えば、サムネイルを作る makeThumbnails という関数なら、

result = array.new()
while(src = gets())
    result.add(Thumbnail.new(src))
end
return result

かもしれないし、例えばサムネイルを一覧表示時のアイコンに使うなら、index_iconsとか、gif化してアニメーションするならframesとかつけるかも。

ちなみに、perlなら $frame = shift @frame だ。

whileの内側だけで使う一時変数なら名前は短く一文字とか、他にも処理があるならtmbとか、thumbとかにするかも。

インスタンス名とか配列名のつけ方

プログラムの初歩的な質問なんですが、

たとえばサムネイルを一覧表示するプログラムを作ってるとして、

次の場合、インスタンス名とか配列名とか、どうやったらうまくつけられるんでしょうか?



1.処理:各サムネイルは、Thumbnailクラスインスタンスとして生成

  このときインスタンス名をどうするか

  >生成されるインスタンスサムネイルなんだから、thumbnailじゃないの?



2.そうやって生成したインスタンス配列に格納することにする。

  このとき、配列名前をどうするか

  >サムネイルの集合だからthumbnailsじゃないの?



できたプログラム(処理:サムネイルインスタンスを作って配列に格納する)


(前略)
thumbnails = array.new();
while(img_pass = gets())
  thumbnail = Thumbnail.new(img_pass)
  thumbnails.add(thumbnail)
end
(後略)

という感じで後から見るとわけわかんなくなるんだけど、

この場合どう命名したらわかりやすかったのでしょうか。

ギークの皆さん助けて!

2009-02-13

ファッション偏差値

68:Emporio ARMANI、BARACUTA、santandrea、John Smedley、DSQUARED2

67:HUGO BOSS、LANVIN COLLECTION、PRADAsport

66:D&G、Y's For Men、COMME des Garcons Homme、COMME des Garcons SHIRT、JUNYA WATANABE MAN、Y-3、

  Z Zegna、Mackintosh、Stephan Schneider、Versace SPORT、Paul&Joe

65:ck Calvin Klein Premium、Paul Smith Collection、Vivienne Westwood MAN、MIHARA YASUHIRO

64:McQ、RAF by RAF SIMONS、Ralph Lauren、UNDER COVER、Kiminori Morishita、Rykiel Homme、Grenfell、Blauer

63:HELMUT LANG、Belstaff、Pringle、J.LINDEBERG

62:MARGARET HOWELL、CNC、ato、Kent &amp; Curwen、Brooks Brothers、Number(n)ine

61:ARMANI JEANS、N.Hoolywood、HYSTERIC GLAMOUR、ATTACHMENT、DIESEL、GREEN、LEMAIRE

60:A.P.C、Paul Smith、The Scotch House、Paul Stuart、Allegri、ck Calvin Klein

  GOMME HOMME、JULIUS、Roen、The Viridi-anne

  • 街行く洒落者御用達--------------------------------

58:PS Paul Smith、KATHARINE HAMNETT LONDON、agnes b、DKNY、JOHN LAWRENCE SULLIVAN

  Artisan、CABANE de ZUCCa、Ben Sherman

57:kiryuyrik、SATORUTANAKA、REATS TAILOR ZAZOUS、NONNATIVE、PUBLIC IMAGE、SHELLAC、WHEREABOUTS、wjk

56:JOSEPH HOMME、BLACKBARRETT by NEIL BARRETT、Armani EXCHANGE、LANVIN en Bleu、The DUFFER of St.GEORGE

  Lounge Lizard、LACOSTE、COMME CA COLLECTION、MICHEL KLEIN HOMME、DESIGNWORKS Mens

  5351 pour les hommes、Tomorrow LandUnited Arrows White Label、United Arrows District

55:TAKEO KIKUCHI、FRED PERRY、J.PRESS、NEWYORKER、TRANS CONTINENTS、MONSIEUR NICOLE

  LAD MUSICIAN、FACTOTUM、EDIFICE、Aramis、Or Glory

54:theory、55DSL、JOSEPH ABBOUD、五大陸、23区 HOMME、kolor、PARANOIDI、Lithium homme、pledge

  • 脱・脱オタ-----------------------------

53:BURBERRY BLACK LABEL、COMME CA DU MODE、MENS BIGI、ABA HOUSEUNTITLED MEN

  TOMMY HILFIGERBANANA REPUBLIC、Mr.olive、Avoid、Rude Gallery、Davit MEURSAULT

  United Arrows、nano universe、乱痴気、Adam et Rope Homme

52:JUN MEN、Arnold Palmer、NICOLE CLUB FOR MEN、Abercrombie Fitch、SCHLUSSEL、SABI SABI DELUXE

51:B&amp;Y United Arrows、BEAMS、SHIPS、American Rag Cie、Journal Standard、R.NEWBOLD、HAMNETT、ATELIER SAB MEN

  Mens Melrose、MK Homme、BOYCOTT、INTERMEZZO、TORNADO MART、MORGAN HOMME、CUSTOM CULTURE

50:TK、INED HOMME、Hiromichi Nakano、abx、FCUK、SHIPS Jet Blue、Urban Research

48:Levis、SIMPLE LIFE、SUPREME、whos whoSTUSSY、And A Homme

  ----------------------------丸井行く僕ってお洒落^^---------------------------

47:Chaopanic、United Arrows Green Label RelaxingUNIVERSAL LANGUAGE、RUPERT

46:MK+、CHAPS、CROCODILE、Playboy、HARE、ZARAUnited COLORS of BENNETON

44:TAKA:Q、Male&amp;Co、Wilks Bashford、Eddie Bauer、Lowbox、Zerosail、Rage Blue

Buona Gionata、Kent in Tradition

42:PPFM、semantic design、Global Work、On Board

  • 自分で服買い始めました-------------------------------------

40:COMME CA ISM、無印良品、Mac-House、GAPUNIQLO

38:Right-On、しまむら、PIKO、g.u.、PLUS ONE

36:Jeans Mate, LAFORM, pbi

34:306

2008-10-19

YourFileHostの動画をなんとかする

YourFileHostのCAPTCHA画像をなんとかするの続きの続き。

まぁ、なんというか、一応できたので張ってみる。微妙な出来栄えだけど。

decaptcha.rbと同じディレクトリに置いて適当に動かしてみてください。

どっかにいいRSSがないかなぁ。。。

しかし、CAPTCHA画像を相手にしてた時の方が楽しかったなぁ。。。

あと、添削とかいろいろ歓迎です。

追記

なぜか&が&amp;に置き換えられてるみたいなので、適当に&に読み替えてください。

download.rb

#!/usr/local/bin/ruby
$LOAD_PATH << File::dirname(File::expand_path($0))
require 'rubygems'
require 'rss'
require 'mechanize'
require 'decaptcha'
# require 'ruby-debug'
# require 'pp'

DESTDIR = 'files'
TMPDIR = '/tmp'

class Downloader
  COOKIE_URI = 'http://www.yourfilehost.com/media.php?cat=video&amp;file=%s'
  DOWNLOAD_URI =
    'http://www.yourfilehost.com/downloadlink.php?cat=video&amp;file=%s&amp;adult=1'
  VERBOSE = false
  DEBUG = false
  
  def self.fetch(file, destdir)
    puts "Fetching file: #{file}"

    destfile = destdir + '/' + file
    if test(?e, destfile) then
      puts '  - Already exists. skip'
      puts
      return nil
    end
  
    #
    # Initialize Mech
    #
    mech = WWW::Mechanize.new
    mech.user_agent_alias = 'Windows IE 6'
    mech.max_history = 3
    mech.open_timeout = 15
    mech.read_timeout = 3
  
    #
    # get cookie
    #
    uri = COOKIE_URI % file
    page = mech.get(uri)
  
    #
    # Challenge against CAPTCHA
    #
    uri = DOWNLOAD_URI % file
    page = mech.get(uri)
  
    for i in 0...3
      captcha_path = (page/'img[@height="38"]').attr(:src)
      captcha_uri = 'http://www.yourfilehost.com/%s' % captcha_path
      gif = mech.get_file(captcha_uri)
      open("#{TMPDIR}/captcha.gif", 'w') {|fd| fd.write(gif) }
      mech.back
  
      code = DeCAPTCHA.decode("#{TMPDIR}/captcha.gif")
      File.unlink("#{TMPDIR}/captcha.gif")
      if code.nil? then
        puts '  - CAPTCHA decode failed. retry' if VERBOSE
        next
      end
  
      form = mech.page.forms.first
      form.verify = code
      page = mech.submit(form)
  
      break unless page.links.empty?
    end
  
    if page.links.empty? then
      puts '  - Failed 3 times.  Try another one.'
      puts
      return nil
    end
  
    #
    # download
    #
    puts "  - Downloading: #{page.links.first.href}" if DEBUG
    retry_count = 0
    video = nil
    begin
      video = page.links.first.click
    rescue Timeout::Error => evar
      retry_count += 1
      if retry_count < 5 then
        puts "  * Timedout, retry" if VERBOSE
        retry
      end
      raise evar
    end

    unless video.instance_of?(WWW::Mechanize::File) then
      if DEBUG then
        puts "  - Something wrong while downloading. skip."
        puts
      end
      return nil
    end
    video.save(destfile)

    return destfile
  end
end



#
# main
#
[DESTDIR, TMPDIR].each do |dir|
  if !test(?d, dir) or !test(?w, dir) then
    puts "#{dir}: Directory not exists or cannot write."
    exit
  end
end

files = []


# collect URIs from RSS
RSS_URI = [
  ['http://www.yourfilehost.com/make-rss.php?range=day&amp;af=off',
    lambda {|rss| rss.items.map {|x| x.link }},
  ],
]
RSS_URI.each do |uri, preprocessor|
  rss = RSS::Parser.parse(uri)
  uris = preprocessor.call(rss) #=> Array of URI of YourFileHost

  uris.map {|x| /file=([^&amp;]*)/.match(x).to_a[1] }.each do |file|
    # next if file !~ /\.wmv/  # uncomment it if you need only wmv
    files << file
  end
end
files.uniq!


# download
files.each do |file|
  begin
    Downloader.fetch(file, DESTDIR)
  rescue SystemCallError, Timeout::Error => evar
    puts "  - error (#{evar.to_s}). skip."
    puts
  end
end
__END__

2008-10-18

real street angels から mechanize を使って動画を取ってきてEmacsで見てみるよ

せっかく書いたから匿名でのせてみるよ

使い方は

  • 動画を取ってきたいよ
    • config.yamlユーザとかを設定するよ
    • ids.txt に取ってきたいIDを書くよ
    • sangels.bat を実行するよ
  • Emacs動画を見たいよ
    • sangels.el を load するよ
    • M-x sangels だよ

必要なものを gem で取ってくるにはこうすればいいよ

  • gem install -r log4r
  • gem install -r -v 0.6 hpricot
  • gem install -r mechanize

長すぎてelispが消えたから続きがあるよ

sangels.bat - 起動用バッチファイル

@echo off
setlocal
set WD=%~dp0
cd /d %WD%

ruby get_movies.rb
ruby get_images.rb
ruby create_m3u.rb

ruby

config.yaml - 設定ファイル
user: ユーザID
password: パスワード
ids_file: ids.txt
done_file: ids_done.txt
movies_dir: movies

log4r_config:
  pre_config:
    global: INFO
  loggers:
    - name: app
      type: Log4r::Logger
      level: INFO
      outputters:
        - STDOUT
        - FILE
  outputters:
    - name: STDOUT
      type: Log4r::StdoutOutputter
      formatter:
        type: Log4r::PatternFormatter
        pattern: "%d [%l] %C - %M"
        date_pattern: "%H:%M:%S"
    - name: FILE
      type: Log4r::FileOutputter 
      filename: "#{LOGDIR}/sangels.log"
      formatter:
        type: Log4r::PatternFormatter
        pattern: "%d [%l] %C - %M"
        date_pattern: "%Y-%m-%d %H:%M:%S"
get_movies.rb
require 'fileutils'
require 'logger'
require 'mechanize'

BASEDIR = File.dirname($0)
require "#{BASEDIR}/util"
require "#{BASEDIR}/sangels"

$config = load_config(BASEDIR)
prepare_logger(BASEDIR)
$log = new_logger("get_movies")
WWW::Mechanize.log = new_logger("mechanize")
WGet.log = $log

class IDFile
  def initialize(file)
    @file = file
    unless File.exist?(@file)
      Fileutils.touch(@file)
    end
  end

  def ids(contains_comment = nil)
    File.open(@file) {|io|
      io.to_a.map {|x|
        x.chomp
      }.select {|x|
        if x.empty?
          nil
        elsif contains_comment
          true
        else
          not /^\s*\#/ =~ x
        end
      }
    }
  end

  def add(id)
    ids = ids(true)
    unless ids.any? {|x| x == id}
      write(ids + [id])
    end
  end

  def delete(id)
    ids = ids(true)
    if ids.any? {|x| x == id}
      write(ids - [id])
    end
  end

  def write(ids)
    File.open(@file, "w") {|io|
      ids.each {|x| io.puts x}
    }
  end
end


$log.info("BEGIN #{$0} ================")
exit_code = 0
begin
  ids_file = IDFile.new($config.ids_file)
  done_file = IDFile.new($config.done_file)
  movies_dir = $config.movies_dir
  wget = WGet.new

  sangels = SAngels.new
  sangels.login($config.user, $config.password)
  ids_file.ids.each {|id|
    begin
      movies = sangels.movies(id)
    rescue SAngels::Movies::InvalidMoviesError
      $log.warn("invalid movie id: #{id}")
      next
    end
    dir = File.expand_path(id, movies_dir)
    movies.each {|link|
      wget.retrieve(link.href, dir)
    }
    expected = movies.movie_links.map{|x| File.basename(x.href)}
    actual = Dir.glob("#{dir}/*").map {|x| File.basename(x)}
    if (expected - actual).empty?
      done_file.add(id)
      ids_file.delete(id)
    end
  }
rescue => e
  $log.error(e)
  exit_code = 1
end

$log.info("END #{$0} (#{exit_code}) ================")
exit exit_code
get_images.rb
require 'fileutils'
require 'logger'
require 'mechanize'
require 'ostruct'

BASEDIR = File.dirname($0)
require "#{BASEDIR}/util"
require "#{BASEDIR}/sangels"

$config = load_config(BASEDIR)
prepare_logger(BASEDIR)
$log = new_logger("get_images")
WWW::Mechanize.log = new_logger("mechanize")
WGet.log = $log

$log.info("BEGIN #{$0} ================")
exit_code = 0
begin
  movies_dir = $config.movies_dir
  sangels = SAngels.new
  sangels.login($config.user, $config.password)
  thumbnails = sangels.thumbnails

  Dir.glob("#{movies_dir}/*").each {|dir|
    next unless File.directory? dir
    id = File.basename(dir)

    url = thumbnails.url(id)
    unless url
      $log.warn("#{id} is not found")
      next
    end
    path = File.expand_path("00_thumbnail#{File.extname(url)}", dir)
    next if File.exist? path

    $log.info("retrieving #{url}")
    thumbnail = thumbnails.get_file(id)
    File.open(path, "wb") {|io| io.write(thumbnail)}
  }
rescue => e
  $log.error(e)
  exit_code = 1
end

$log.info("END #{$0} (#{exit_code}) ================")
exit exit_code
create_m3u.rb
BASEDIR = File.dirname($0)
require "#{BASEDIR}/util"

$config = load_config(BASEDIR)
movies_dir = $config.movies_dir
Dir.glob("#{movies_dir}/*") {|dir|
  next unless File.directory? dir
  name = File.basename(dir)
  files = Dir.glob("#{dir}/*.wmv").sort

  File.open("#{movies_dir}/#{name}.m3u", "w") {|io|
    files.each {|file|
      io.puts "#{name}/#{File.basename(file)}"
    }
  }

  File.open("#{dir}/00_movies.m3u", "w") {|io|
    files.each {|file|
      io.puts "#{File.basename(file)}"
    }
  }
}
sangels.rb
require 'mechanize'
require 'hpricot'

BASEDIR = File.dirname($0)
require "#{BASEDIR}/util"

class SAngels
  HOST = "real2.s-angels.com"
  LOGIN_URL = "http://#{HOST}/member/"
  INFO_URL = "http://#{HOST}/teigaku/item.php"
  THUMBNAILS_URL = "http://#{HOST}/teigaku/"
  THUMBNAIL_URL = "http://#{HOST}/images/default/thumb/"

  def initialize()
    @agent = WWW::Mechanize.new
  end

  def login(user, password)
    login_form = @agent.get(LOGIN_URL).forms.find {|form|
      form.fields.any? {|field| field.name == "frmLoginid"}
    }
    login_form.frmLoginid = user
    login_form.frmPw = password
    @agent.submit(login_form)
  end

  def movies(id, no_validate = nil)
    Movies.new(@agent, id, !no_validate)
  end

  def thumbnails
    Thumbnails.new(@agent)
  end

  class Thumbnails
    def initialize(agent)
      @agent = agent
      doc = Hpricot(@agent.get_file(THUMBNAILS_URL))
      elems = doc.search("div[@class=realthum]/a")
      @links = Hash(
        elems.map {|elem|
          href = elem["href"]
          id = $1 if /ID=(.+)/ =~ href
          url = elem.search("img")[0]["src"]
          [id, url]
        })
    end

    def get_file(id)
      @agent.get_file(url(id))
    end

    def url(id)
      @links[id]
    end

    def exist?(id)
      url(id)
    end
  end

  class Movies
    class InvalidMoviesError < StandardError
    end

    def initialize(agent, id, no_validate)
      @agent = agent
      @id = id
      if !no_validate &amp;&amp; !valid?
        raise InvalidMoviesError
      end
    end

    def info_page_url
      "#{INFO_URL}?ID=#{@id}"
    end

    def info_page
      @agent.get(info_page_url)
    end

    def movies_page
      @agent.click(info_page.links.find {|link| /P=10/ =~ link.href})
    end

    def movie_links
      movies_page.links.select {|link|
        /wmv$/ =~ link.href
      }.sort {|a, b|
        File.basename(a.href) <=> File.basename(b.href)
      }
    end

    def valid?
      info_page.uri.to_s == info_page_url
    end

    def each(&amp;block)
      orig_links = movie_links
      orig_links.each {|orig_link|
        link = movie_links.find {|l| File.basename(l.href) == File.basename(orig_link.href)}
        block.call(link)
      }
    end
  end
end
util.rb
require 'log4r'
require 'log4r/yamlconfigurator'
require 'singleton'
require 'fileutils'
require 'ostruct'

def Hash(a)
  Hash[*a.flatten]
end

def load_config(basedir)
  OpenStruct.new(File.open("#{basedir}/config.yaml") {|io| YAML.load(io)})
end

def new_logger(name)
  Log4r::Logger.new("app::#{name}")
end

def prepare_logger(basedir, logdir = nil)
  logdir ||= basedir
  Log4r::YamlConfigurator["LOGDIR"] = logdir
  Log4r::YamlConfigurator.load_yaml_file("#{basedir}/config.yaml")
end

class NullObject
  include Singleton
  def method_missing(message, *arg)
    NullObject.singleton
  end
end

class WGet
  class << self
    attr_accessor :log
    def initialize
      super
      @log = NullObject.singleton
    end
  end
  
  def log
    self.class.log
  end

  def retrieve(url, dir)
    FileUtils.mkdir_p(dir)
    file = File.expand_path(File.basename(url), dir)
    if File.exist?(file)
      log.info("already retrieved #{url}")
      return true
    end

    tmp = "#{file}.part"
    log.info("retrieving #{url}")
    ret = system("wget", "-c", "-O", tmp, url)
    if ret
      log.info("retrieving succeeded #{url}")
      File.rename(tmp, file)
    else
      if $? == 0x020000 # Ctrl-C
        exit($?)
      else
        log.error("retrieving failure #{url} (#{$?})")
      end
    end
    return ret
  end
end

2008-10-17

http://anond.hatelabo.jp/20081006220009

YourFileHostのCAPTCHA画像をなんとかするの続き。

その後、適当にいじったら、手元環境で1枚あたり25秒くらい→だいたい2.5秒くらいで判別できるようになった。このくらいなら使えるかな。

速度向上に一番効いたのは、Token#importで画像を比較しているところの修正。他は細かい手直し。

使い方は前のやつと変わってません。

あと、テストに100枚くらいCAPTCHA画像食わせてみたけど、とりあえず全部正しく判定できた。

動作確認用のスクリプト (run.rb)

カレントディレクトリ以下にある*.gifCAPTCHA画像ファイル適当に判別するスクリプト。動作確認用にどうぞ。

後述のdecaptcha.rbと同じディレクトリ適当に置いてchmod +xしてね。

#!/usr/local/bin/ruby
$LOAD_PATH << File::dirname(File::expand_path($0))
require 'decaptcha'

STDOUT.sync = true

Dir.glob('*.gif').sort.each do |file|
  correct = File::basename(file, '.*')
  puts "Processing file: #{file}"
  start_time = Time.now
  ret = DeCAPTCHA.decode(file)
  elapsed = Time.now - start_time

  puts "  Result: #{ret} (=> #{(correct == ret) ? "Ok" : "Fail"})"
  puts "  Elapsed time: #{elapsed}"
  puts
end

コード (decaptcha.rb)

#!/usr/local/bin/ruby
require 'rubygems'
require 'gd2'
require 'pp'

#
#= CAPTCHA画像解析モジュール
# CAPTCHA画像ファイルを食わすとあら不思議Stringが出てくるよ。
# YourFileHostのやつに対応。
#
#== Usage
# decoded_str = DeCAPTCHA.decode("some_captcha_image.gif")  #=> String
# 失敗したらnilが返る。
#
module DeCAPTCHA
  DEBUG = false

  #=== CAPTCHA画像デコード
  # file::    画像ファイル名のパス
  # method::  未指定でよい。男は細かい事を気にするな。
  # returns:: CAPTCHA画像解析結果(String) or nil (デコード失敗時)
  def self.decode(file, method = DeCAPTCHA::Site::YourFileHost)
    return method.new(file).decode
  end



  #= CAPTCHA画像デコードクラス
  # このクラスサブクラスはimport, tokenize, stream_parseメソッドの
  # 実装を含む必要がある。
  class Site
    def initialize(file = nil)
      @pix = nil
      self.import(file) unless file.nil?
    end
    def decode
      return stream_parse(tokenize())
    end
  end

  #= YourFileHostのCAPTCHA画像を解析するクラス
  class Site::YourFileHost < Site
    def import(file)
      @pix = PixelMatrix.new.import(file)
      return self
    end

    # importしたイメージ(PixelMatrix)から、文字と思わしきパターンを
    # 抽出して上下マージンを切り取ってArrayにして返す。
    # returns:: Array of PixelMatrix
    def tokenize
      ret = []
      state = :initial
      for x in 0...@pix.width
        case state
        when :initial
          if !@pix.vline_blank?(x) then
            state = :tokenize
            pixel = PixelMatrix.new(0, 0, true)
            ret << pixel
            redo
          end
        when :tokenize
          if @pix.vline_blank?(x) then
            state = :initial
            next
          end
          x0 = pixel.width
          for y in 0...@pix.height
            pixel[x0, y] = @pix[x, y]
          end
        else
          raise 'NOTREACHED'
        end
      end

      ret.map! {|token| Token.new.import(token.cutoff_vmargin!) }
    end


    # PixelMatrixのArrayを受け取り、数字を判別。
    # tokens:: Array of PixelMatrix
    # returns:: String (判別結果)
    def stream_parse(tokens)
      rs = tokens.map {|x| x.guess.to_s }.join('')
      if rs.length != 4 then
        rs = nil
        if DEBUG then
          puts '- guess failed. dumping guess result of each token:'
          tokens.each_index do |i|
            print "##{i}:#{tokens[i].guess} "
            pp tokens[i].candidate
          end
          puts
        end
      end
      return rs
    end

    class Token
      @@digits = nil
      attr_accessor :candidate

      def initialize
        if @@digits.nil? then
          # 文字画像サンプルを作っておく
          @@digits = DIGITS_ASSOC.map {|digit|
            PixelMatrix.new(0, 0, true).import_array(digit) }
        end

        @candidate = Hash.new
      end

      # PixelMatrixを受け取り、文字画像サンプルと比較して
      # 一致率を計算しておく。
      # pixel:: PixelMatrix
      # returns:: self
      def import(pixel)
        @@digits.each_index do |i|
          digit = @@digits[i]

          if (digit.width - pixel.width).abs   > 4 or
             (digit.height - pixel.height).abs > 4 then
            @candidate[i] = -1  # サイズが違いすぎな場合、一致させない
            next
          end

          correct_bits = 0
          enlarged_width  = [digit.width,  pixel.width ].max
          enlarged_height = [digit.height, pixel.height].max
          for y in 0...enlarged_height
            dy = (y.to_f / digit.height * enlarged_height).to_i
            py = (y.to_f / pixel.height * enlarged_height).to_i
            for x in 0...enlarged_width
              dx = (x.to_f / digit.width * enlarged_width).to_i
              px = (x.to_f / pixel.width * enlarged_width).to_i
              correct_bits += 1 if digit[dx, dy] == pixel[px, py]
            end
          end

          @candidate[i] = correct_bits * 100 /
                          (enlarged_width * enlarged_height)
        end

        return self
      end

      # importのときの比較結果をもとに文字を推測
      # returns:: Fixnum or nil(失敗時)
      def guess
        digit, ratio = @candidate.sort {|a, b| a.last <=> b.last}.last
        digit = nil if ratio < 0 or ratio < 65
        return digit
      end
    end
  end


  #= 画素マトリックスクラス
  # 画像ファイルを食わせると、各ピクセル(画素)を2値(black(1) or white(0))に
  # 変換して、内部で保持する。
  # 以後、Matrixクラスのような感じで個々の画素アクセスできる。
  class PixelMatrix
    BLACK = 1
    WHITE = 0

    attr_accessor :width
    attr_accessor :height

    # width::  幅
    # height:: 高さ
    # is_flexible:: 自動的に伸張するか
    def initialize(width = 0, height = 0, is_flexible = false)
      @matrix = Hash.new {|hash, key| hash[key] = Hash.new(WHITE)}
      @width, @height, @flexible = width, height, is_flexible
    end

    # file:: 画像ファイル名のパス
    # brightness_threshold:: 画素を黒とみなす閾値 (0 - 255, default: 0x40)
    # returns:: self (DeCAPTCHA::PixelMatrix)
    def import(file, brightness_threshold = 0x40)
      gd = GD2::Image.import(file)
      @width, @height = gd.width, gd.height

      self.each_with_axis do |x, y|
        color = gd[x, y]
        greyscale = (color.red + color.green + color.blue) / 3
        self[x, y] = (greyscale > brightness_threshold) ?
          WHITE :
          BLACK
      end
      return self
    end

    def import_array(array)
      array.each_with_index do |str, y|
        str.split('').each_with_index do |c, x|
          self[x, y] = c.to_i
        end
      end
      return self
    end

    # PixelMatrixを画像ファイルとしてexport
    # file:: 新たに作る画像ファイル名のパス
    def export(file)
      gd = GD2::Image::IndexedColor.new(@width, @height)
      gd.palette << GD2::Color::WHITE
      gd.palette << GD2::Color::BLACK
      self.each_with_axis do |x, y|
        gd[x, y] = {
          WHITE => GD2::Color::WHITE,
          BLACK => GD2::Color::BLACK,
        }[self[x, y]]
      end
      gd.export(file)
      return self
    end

    # 指定された位置の画素を返す。
    # returns:: PixelMatrix::BLACK(1) or WHITE(0)
    def [](x, y)
      if !@flexible and !in_range?(x, y) then
        raise RangeError
      end
      return WHITE if !@matrix.has_key?(y)  # XXX: for optimize
      return @matrix[y][x]
    end

    # 画素に値を設定。
    # returns:: PixelMatrix::BLACK(1) or WHITE(0)
    def []=(x, y, val)
      unless in_range?(x, y) then
        raise RangeError unless @flexible
        @width  = (x >= @width)  ? x + 1 : @width
        @height = (y >= @height) ? y + 1 : @height
      end

      @matrix[y][x] = val
    end

    def in_range?(x, y)
      ((0...@width) === x and (0...@height) === y)
    end

    # 指定された軸をもとに画素を走査し、Arrayに変換。
    # 例えば、to_a(:vertical, 10) とすると、x == 10 な列を取り出して
    # Arrayにして返す。
    #
    # axis:: 軸を指定 (:vertical または :horizontal)
    # pos:: 位置を指定。_axis_で指定した軸と直交する軸における位置を指定。
    def to_a(axis, pos)
      {:vertical => lambda {
        (0...@height).map {|y| self[pos, y]}
       },
       :horizontal => lambda {
        (0...@width).map  {|x| self[x, pos]}
       },
      }[axis].call
    end

    # returns:: Array
    def hline(y)
      self.to_a(:horizontal, y)
    end

    # returns:: Array
    def vline(x)
      self.to_a(:vertical, x)
    end

    # X軸方向に画素を走査。
    # y:: どの位置で走査するか
    # returns:: 指定された軸の上にドットが存在: false, 無い: true
    def hline_blank?(y)
      return true if @matrix.has_key?(y) == false # XXX: for optimize
      for x in 0...@width
        return false if self[x, y] == BLACK
      end
      return true
    end

    # Y軸方向に画素を走査。
    # x:: どの位置で走査するか
    # returns:: 指定された軸の上にドットが存在: false, 無い: true
    def vline_blank?(x)
      for y in 0...@height
        return false if self[x, y] == BLACK
      end
      return true
    end

    # 上下のマージン削除した新しいPixelMatrixを返す。
    # returns:: PixelMatrix
    def cutoff_vmargin
      pixel = PixelMatrix.new(0, 0, true)
      head = 0
      tail = self.height - 1

      head.upto(tail) do |y|
        if !self.hline_blank?(y) then
          head = y
          break
        end
      end
      tail.downto(head) do |y|
        if !self.hline_blank?(y) then
          tail = y
          break
        end
      end

      head.upto(tail) do |y|
        0.upto(self.width - 1) do |x|
          pixel[x, y - head] = self[x, y]
        end
      end

      return pixel
    end
    
    # 自身の上下のマージン削除する。cutoff_vmarginの破壊版。
    # 速度稼ぎのために直接@matrixを触ったり、すこしずるをしている。
    # 効率は、ほんの少しだけ速くなったような誤差の範囲のような感じ。
    # returns:: self (PixelMatrix)
    def cutoff_vmargin!
      head = 0
      tail = self.height - 1

      head.upto(tail) do |y|
        if !self.hline_blank?(y) then
          head = y
          break
        end
      end
      tail.downto(head) do |y|
        if !self.hline_blank?(y) then
          tail = y
          break
        end
        @matrix.delete(y) if @matrix.has_key?(y)  # XXX
      end

      if head > 0 then
        head.upto(tail) do |y|
          next if !@matrix.has_key?(y)            # XXX
          @matrix[y - head] = @matrix.delete(y)   # XXX
        end
      end
      self.height = tail - head + 1

      return self
    end
    
    def each_with_axis
      for x in 0...@width
        for y in 0...@height
          yield(x, y)
        end
      end
    end
  end
end

class DeCAPTCHA::Site::YourFileHost::Token
DIGITS_ASSOC = [
  # 0
  ["00000000011111110000000000",
   "00000001111111111110000000",
   "00000011111000001111000000",
   "00001111111100010011110000",
   "00011111100000110000111000",
   "00111111000000100001111000",
   "00111111110001000001111100",
   "01111111000010000011111110",
   "01111100000110000111111110",
   "01111111000100000111111110",
   "11111100001000001111111111",
   "11100000001000011111111111",
   "11111000010000011111111111",
   "11111000110000111111111111",
   "10000000100001111111111111",
   "01100001000001111111111110",
   "01100010000011111111111110",
   "01100010000111111111111110",
   "00111100000111111111111100",
   "00011100001111111111111000",
   "00001100011111111111111000",
   "00001111111111111111100000",
   "00000011111111111111000000",
   "00000000111111111100000000"],
  # 1
  ["00001",
   "00111",
   "11111",
   "11111",
   "10001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001",
   "00001"],
  # 2
  ["0000011111111110000000",
   "0001111111111111000000",
   "0011110000000010000000",
   "0110000000000100000000",
   "1100000000001100011110",
   "1000000000001000001111",
   "1000000000010000000111",
   "1000000000110001111111",
   "1000000000100001111111",
   "1000000001000000011111",
   "0100000011000001111111",
   "0011000010000111111110",
   "0011000110000001111110",
   "0000001100000111111100",
   "0000001000011111110000",
   "0000011000000111100000",
   "0000110000000000000000",
   "0000111111111111111111",
   "0001111111111111111110",
   "0011111111111111111100",
   "0011111111111111111100",
   "0111111111111111111000",
   "0111111111111111110000"],
  # 3
  ["000000011111111110000000",
   "000001111111111111100000",
   "000011100000011111111000",
   "000111000000111111111000",
   "000110000001111111111100",
   "000100000001111111111100",
   "000100000011111111111100",
   "000110000111111111111000",
   "000010000111111111111000",
   "000000001111111111100000",
   "000000011111111111000000",
   "000000011111111110000000",
   "000000000000001100000000",
   "000000000000011100011100",
   "000000000000111000111110",
   "000000000000110000001110",
   "000000000001110001111111",
   "110000000011100011111111",
   "111000000111000000111110",
   "011100000110001111111100",
   "001111001110000111111000",
   "000011111100000011100000",
   "000000011000111000000000"],
  # 4
  ["0000000000011",
   "0000000000011",
   "0000000000111",
   "0000000001111",
   "0000000001111",
   "0000000011111",
   "0000000111111",
   "0000000110111",
   "0000001100111",
   "0000011100111",
   "0000011000111",
   "0000110000111",
   "0001110000111",
   "0001100000111",
   "0011000000111",
   "0111000000111",
   "0111111111111",
   "1111111111111",
   "0000000000111",
   "0000000000111",
   "0000000000111",
   "0000000000111",
   "0000000000111"],
  # 5
  ["000000001111111111111110",
   "000000011111111111111100",
   "000000111111111111111100",
   "000000111111111111111000",
   "000001111111111111110000",
   "000011100000000000000000",
   "000011011111111110000000",
   "000111111111111111000000",
   "001111100000000111000000",
   "001110000000000110001100",
   "000000000000000100011110",
   "000000000000001100000110",
   "000000000000011000011111",
   "000000000000011001111111",
   "000000000000110000011111",
   "000000000001100000111111",
   "110000000001100111111110",
   "011000000011000001111110",
   "011100000110000011111100",
   "001111000110011111111000",
   "000111111100001111110000",
   "000001111100000011000000",
   "000000001000011000000000"],
  # 6
  ["000000000000000110000000",
   "000000010001111111111000",
   "000001110000011100111100",
   "000011100000011000001000",
   "000111000011111000000000",
   "001111000001110000000000",
   "001110000000111100000000",
   "011110001111111111100000",
   "011100000111000011110000",
   "011000000010000001111000",
   "011000011110000011111100",
   "010000111100000111111110",
   "100000001000000111111110",
   "100001111000001111111111",
   "000011110000011111111111",
   "000000100000011111111111",
   "000011100000111111111111",
   "001111000001111111111110",
   "000010000001111111111110",
   "001110000011111111111100",
   "000111000111111111111000",
   "000011111111111111110000",
   "000000111111111111000000",
   "000000000111111000000000"],
  # 7
  ["0011111111111110001111",
   "0011111111111100000011",
   "0111111111111000000110",
   "1111111111111000111100",
   "1111111111110000001100",
   "0000000000000000011000",
   "0000000000000011111000",
   "0000000011000000110000",
   "0000001110000011100000",
   "0000011110001111100000",
   "0000111100000011000000",
   "0001111000000110000000",
   "0001111000111110000000",
   "0011110000001100000000",
   "0011110000001000000000",
   "0011100011111000000000",
   "0011000001110000000000",
   "0001000000110000000000",
   "0000000111100000000000",
   "0000000111000000000000",
   "0000000011000000000000",
   "0000001110000000000000",
   "0000001100000000000000"],
  # 8
  ["0000000111111111110000000",
   "0000011111111111111100000",
   "0000001111100000011110000",
   "0000000001110000000111000",
   "0011000011111000000011100",
   "0011100001111100000011100",
   "0011110000001110000011100",
   "0001111000011111000111000",
   "0000111100000111101110000",
   "0000011110000001111100000",
   "0000001111000011111110000",
   "0000111111110000011111000",
   "0011110011111000001111100",
   "0111100001111100011111100",
   "0111000000111110000111110",
   "1111000000011111000000111",
   "1111000000001111100011111",
   "1111000000000011111000010",
   "0111100000000001111100000",
   "0011110000000000111110000",
   "0001111110000001111110000",
   "0000011111111111111000000",
   "0000000011111110000000000"],
  # 9
  ["000000111111111110000000",
   "000001111111111111100000",
   "000111111111111001111000",
   "001111111111110000010000",
   "011111111111110000010000",
   "011111111111100000100000",
   "011111111111000001100000",
   "111111111110000001000111",
   "111111111110000010000001",
   "111111111100000110000111",
   "011111111000000100011111",
   "011111111000001000001111",
   "001111110000011000011111",
   "001111100000010001111110",
   "000111110000100000011110",
   "000001111111100000111110",
   "000000011111000111111100",
   "000000000010000001111100",
   "000000000110000001111000",
   "000100001100011111110000",
   "000111001100001111100000",
   "000011111000001111000000",
   "000000010000110000000000"],
]
end
__END__

2008-10-06

YourFileHostのCAPTCHA画像をなんとかする

破ろうぜ!CAPTCHA画像♪(うっうーん)

そんなわけで、みんな大好きなYourFileHostだけども、最近みてみたら、なんかCAPTCHA認証がついているわけじゃないですか。

でもこれってさーCAPTCHAといっても見るからに危ういというか、見れば見るほど簡単に破れてしまいそうな気がして、どうにもむずがゆいアンニュイな気分になってしまうわけです。

そんで、このたび適当にいじってみたところ、それなりに推測できるコードが書けたので、ここに張ってみますね。

やってることは単純で、こんな感じ

  1. CAPTCHA画像ファイルをよみこむ
  2. ピクセルごとにグレイスケールにして、それで2値にする
  3. この時点でじゃまな背景が消えて、文字の形がわかってしまうわけです
  4. 縦軸に点がないところで切って、文字ごとにばらばらにする
  5. 文字画像のサンプルと比較して、一致率が高いものを採用

使い方は、こんな感じで

require 'decaptcha.rb'
captcha_string = DeCAPTCHA.decode(filename)
if !captcha_string.nil? then
  # 判別成功時の処理
else
  # 判別失敗時の処理。失敗することもあるのでよしなに。
end

あ、Ruby/GD2入れといてね。sudo gem install gd2とかで入ります。多分。

判別率はそこそこ良い感じになったんだけども、富豪プログラミングがたたってか、いかんせん遅いです。

手元だと1枚判別するのに20秒くらいかかることもある。

そんなわけで誰かチューニングしてくれるとうれしい。

追記

実行速度を上げた改良版はこっちにうpしました。以下のコードは参考程度に。

コード (decaptcha.rb)

#!/usr/local/bin/ruby
require 'rubygems'
require 'gd2'
require 'pp'

#
#= CAPTCHA画像解析モジュール
# CAPTCHA画像ファイルを食わすとあら不思議Stringが出てくるよ。
# YourFileHostのやつに対応。
#
#== Usage
# decoded_str = DeCAPTCHA.decode("some_captcha_image.gif")  #=> String
# 失敗したらnilが返る。
#
module DeCAPTCHA
  DEBUG = false

  #=== CAPTCHA画像デコード
  # file::    画像ファイル名のパス
  # method::  未指定でよい。男は細かい事を気にするな。
  # returns:: CAPTCHA画像解析結果(String) or nil (デコード失敗時)
  def self.decode(file, method = DeCAPTCHA::Site::YourFileHost)
    return method.new(file).decode
  end



  #= CAPTCHA画像デコードクラス
  # このクラスサブクラスはimport, tokenize, stream_parseメソッドの
  # 実装を含む必要がある。
  class Site
    def initialize(file = nil)
      @pix = nil
      self.import(file) unless file.nil?
    end
    def decode
      return stream_parse(tokenize())
    end
  end

  #= YourFileHostのCAPTCHA画像を解析するクラス
  class Site::YourFileHost < Site
    def import(file)
      @pix = PixelMatrix.new.import(file)
      return self
    end

    # importしたイメージ(PixelMatrix)から、文字と思わしきパターンを
    # 抽出して上下マージンを切り取ってArrayにして返す。
    # returns:: Array of PixelMatrix
    def tokenize
      getter, tokenizer = lambda {|queue|
        [ lambda { return queue },
          lambda {|x, pixel|
            if pixel.nil? then
              x, pixel = tokenizer.call(x, PixelMatrix.new(0, 0, true))
              queue << pixel
              return x
            end
  
            if !@pix.in_range?(x, 0) or @pix.vline_blank?(x) then
              return [x, pixel]
            end
            x0 = pixel.width
            @pix.vline(x).inject(0) do |y, color|
              pixel[x0, y] = color
              y + 1
            end
            return tokenizer.call(x + 1, pixel)
          }
        ]
      }.call([])

      x = 0
      while (x < @pix.width)
        x = @pix.vline_blank?(x) ?
          x + 1 :
          tokenizer.call(x, nil)
      end

      getter.call.map do |token|
        # Token.new.import(token.cutoff_vmargin.shrink)
        Token.new.import(token.cutoff_vmargin)
      end
    end

    # PixelMatrixのArrayを受け取り、数字を判別。
    # tokens:: Array of PixelMatrix
    # returns:: String (判別結果)
    def stream_parse(tokens)
      r = []
      tokens.inject(nil) do |prev, cur|
        r << cur.guess
      end

      rs = r.map {|x| x.to_s}.join('')
      if rs.length != 4 then
        if DEBUG then
          puts '- guess failed. dumping guess result of each token:'
          tokens.each_index do |i|
            print "##{i}: "
            pp tokens[i].candidate
          end
          puts
        end
        return nil
      end
      return rs
    end

    class Token
      @@digits = nil
      attr_accessor :candidate

      def initialize
        if @@digits.nil? then
          # 文字画像サンプルを作っておく
          @@digits = DIGITS_ASSOC.map {|assoc|
            PixelMatrix.new(0, 0, true).import_assoc(assoc) }
        end

        @candidate = Hash.new
      end

      # PixelMatrixを受け取り、文字画像サンプルと比較して
      # 一致率を計算しておく。
      # pixel:: PixelMatrix
      # returns:: self
      def import(pixel)
        gcd = lambda {|a, b|
          a, b = [b, a] if a < b
          return a if b == 0
          r = a % b
          return gcd.call(b, r)
        }
        lcm = lambda {|a, b| a * b / gcd.call(a, b) }
        mul_to_lcm = lambda {|a, b|
          g = gcd.call(a, b)
          [b / g, a / g]
        }

        0.upto(@@digits.size - 1) do |i|
          if (@@digits[i].width - pixel.width).abs   > 4 or
             (@@digits[i].height - pixel.height).abs > 4 then
            @candidate[i] = -1  # 比較対象とサイズが違いすぎ
            next
          end

          mul_ax, mul_bx = mul_to_lcm.call(@@digits[i].width,  pixel.width)
          mul_ay, mul_by = mul_to_lcm.call(@@digits[i].height, pixel.height)
          enlarged_width  = @@digits[i].width  * mul_ax
          enlarged_height = @@digits[i].height * mul_ay

          # 文字画像サンプルと比較対象画像のサイズをあわせる
          # 幅・高さをそれぞれ適当整数倍して、最小公倍数に合わせて比較
          # (めんどうだから)
          correct_bits = 0
          (0...enlarged_width).each do |x|
            (0...enlarged_height).each do |y|
              if @@digits[i][x/mul_ax, y/mul_ay] ==
                 pixel[x/mul_bx, y/mul_by] then
                correct_bits += 1
              end
            end
          end
          
          @candidate[i] = correct_bits * 100 /
                          (enlarged_width * enlarged_height)
        end

        return self
      end

      # importのときの比較結果をもとに文字を推測
      # returns:: Fixnum or nil(失敗時)
      def guess
        digit, ratio = @candidate.sort {|a, b| a.last <=> b.last}.last
        digit = nil if ratio < 0 or ratio < 80
        return digit
      end
    end
  end


  #= 画素マトリックスクラス
  # 画像ファイルを食わせると、各ピクセル(画素)を2値(black(1) or white(0))に
  # 変換して、内部で保持する。
  # 以後、Matrixクラスのような感じで個々の画素アクセスできる。
  class PixelMatrix
    BLACK = 1
    WHITE = 0

    attr_accessor :width
    attr_accessor :height

    # width::  幅
    # height:: 高さ
    # is_flexible:: 自動的に伸張するか
    def initialize(width = 0, height = 0, is_flexible = false)
      @matrix = Hash.new {|hash, key| hash[key] = Hash.new(WHITE)}
      @width, @height, @flexible = width, height, is_flexible
    end

    # file:: 画像ファイル名のパス
    # brightness_threshold:: 画素を黒とみなす閾値 (0 - 255, default: 0x40)
    # returns:: self (DeCAPTCHA::PixelMatrix)
    def import(file, brightness_threshold = 0x40)
      gd = GD2::Image.import(file)
      @width, @height = gd.width, gd.height

      self.each_with_axis do |x, y|
        color = gd[x, y]
        greyscale = (color.red + color.green + color.blue) / 3
        self[x, y] = (greyscale > brightness_threshold) ?
          WHITE :
          BLACK
      end
      return self
    end

    # reverse function of to_assoc
    def import_assoc(assoc)
      assoc.inject(0) do |y, columns|
        columns.inject(0) do |x, color|
          self[x, y] = color
          x + 1
        end
        y + 1
      end
      return self
    end

    # PixelMatrixを画像ファイルとしてexport
    # file:: 新たに作る画像ファイル名のパス
    def export(file)
      gd = GD2::Image::IndexedColor.new(@width, @height)
      gd.palette << GD2::Color::WHITE
      gd.palette << GD2::Color::BLACK
      self.each_with_axis do |x, y|
        gd[x, y] = {
          WHITE => GD2::Color::WHITE,
          BLACK => GD2::Color::BLACK,
        }[self[x, y]]
      end
      gd.export(file)
      return self
    end

    def to_assoc
      (0...@height).map do |y|
        (0...@width).map do |x|
          self[x, y]
        end
      end
    end

    # 指定された位置の画素を返す。
    # returns:: PixelMatrix::BLACK(1) or WHITE(0)
    def [](x, y)
      if !@flexible and !in_range?(x, y) then
        raise RangeError
      end
      return @matrix[y][x]
    end

    # 画素に値を設定。
    # returns:: PixelMatrix::BLACK(1) or WHITE(0)
    def []=(x, y, val)
      unless in_range?(x, y) then
        raise RangeError unless @flexible
        @width  = (x >= @width)  ? x + 1 : @width
        @height = (y >= @height) ? y + 1 : @height
      end

      @matrix[y][x] = val
    end

    def in_range?(x, y)
      ((0...@width) === x and (0...@height) === y)
    end

    # 指定された軸をもとに画素を走査し、Arrayに変換。
    # 例えば、to_a(:vertical, 10) とすると、x == 10 な列を取り出して
    # Arrayにして返す。
    #
    # axis:: 軸を指定 (:vertical または :horizontal)
    # pos:: 位置を指定。_axis_で指定した軸と直交する軸における位置を指定。
    def to_a(axis, pos)
      {:vertical => lambda {
        (0...@height).map {|y| self[pos, y]}
       },
       :horizontal => lambda {
        (0...@width).map  {|x| self[x, pos]}
       },
      }[axis].call
    end

    # returns:: Array
    def hline(y)
      self.to_a(:horizontal, y)
    end

    # returns:: Array
    def vline(x)
      self.to_a(:vertical, x)
    end

    # X軸方向に画素を走査。
    # y:: どの位置で走査するか
    # returns:: 指定された軸の上にドットが存在: false, 無い: true
    def hline_blank?(y)
      hline(y).find {|color| color == BLACK }.nil? ?
        true : false
    end

    # Y軸方向に画素を走査。
    # x:: どの位置で走査するか
    # returns:: 指定された軸の上にドットが存在: false, 無い: true
    def vline_blank?(x)
      vline(x).find {|color| color == BLACK }.nil? ?
        true : false
    end

    # 上下のマージン削除した新しいPixelMatrixを返す。
    # returns:: PixelMatrix
    def cutoff_vmargin
      pixel = PixelMatrix.new(0, 0, true)
      head = 0.upto(self.height - 1) do |y|
        break(y) if !self.hline_blank?(y)
      end
      tail = (self.height - 1).downto(0) do |y|
        break(y) if !self.hline_blank?(y)
      end

      head.upto(tail) do |y|
        y0 = pixel.height
        self.hline(y).inject(0) do |x, color|
          pixel[x, y0] = color
          x + 1
        end
      end

      return pixel
    end
    
    def each_with_axis
      (0...@width).each {|x|
        (0...@height).each {|y|
          yield(x, y)}}
    end
  end
end

class DeCAPTCHA::Site::YourFileHost::Token
DIGITS_ASSOC = [
# 0
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
 [0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
 [0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
],
# 1
[[0, 0, 0, 0, 1],
 [0, 0, 1, 1, 1],
 [1, 1, 1, 1, 1],
 [1, 1, 1, 1, 1],
 [1, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1],
 [0, 0, 0, 0, 1]],
# 2
[[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
 [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0],
 [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1],
 [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
 [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
 [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
 [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
 [0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
 [0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]],
# 3
[[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
 [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
 [1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
# 4
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1],
 [0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1],
 [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1],
 [0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1],
 [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1],
 [0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1],
 [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1],
 [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1],
 [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1]],
# 5
[[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],
 [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0],
 [0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
# 6
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0],
 [0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
 [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
# 7
[[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1],
 [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1],
 [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0],
 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0],
 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
# 8
[[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
 [0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
 [0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
 [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
 [0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0],
 [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1],
 [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1],
 [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0],
 [0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
# 9
[[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
 [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
 [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
 [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0],
 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1],
 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1],
 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1],
 [0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1],
 [0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1],
 [0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1],
 [0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0],
 [0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0],
 [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0],
 [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0],
 [0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
 [0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
]
end


__END__
Dir.glob('*.gif').each do |file|
  puts "Processing file: #{file}"
  p DeCAPTCHA.decode(file)
end

__END__

2008-07-09

Vimperatorで;bでリンクを新しいバックグラウンドのタブに開くようにする。

8/18追記

vimperator2.0preから;bが実装されたので、本記事は意味をなさなくなりました。




Windows+Firefox3で確認。


hints.jsのprocessHints()に

            case "b": liberator.buffer.followLink(elem, liberator.NEW_BACKGROUND_TAB); break;

を追加。7/4のバージョンだと336行目だった。


hints.jsのreturn部のshowメソッドの最初の行にbも含める。

            if (mode == liberator.modes.EXTENDED_HINT &amp;&amp; !/^[;?asoOtTvVwWyYb]$/.test(minor))

638行目だった。


buffer.jsのreturn部のfollowLinkメソッドを

                case liberator.NEW_TAB:
                    newTab = true;
                    break;
                case liberator.NEW_BACKGROUND_TAB:
                    newWindow = true;
                    newTab = true;
                    break;

のように変更。

これでCtrl+Shift+クリックが可能に。


Macだと新しいバックグラウンドのタブに開くキーバインドが違うからうまくいかないかも。


@see http://www.y-adagio.com/public/standards/tr_dom2_events/events.html のinitMouseEventメソッドの引数の説明。

2008-01-28

とんでもなく効率の良い、エロ画像収集マシンを作り上げてしまった

まあ、Picasaウエブアルバムを使うということなのだが。落ち着いて聞いてくれ。俺はMacなのでWinでできるかどうか知らん。

1.Picasaの利用開始する(GmailiGoogleを使っていれば簡単)

2.Picasa Web Albums Uploaderをダウンロードインストールする

3.シャンバラなどにいっていつものようにエロ画像ダウンロード


4.Picasa Web Albums Uploaderを起動

5. +ボタンを押す。Photos modified:をToday, Photos in:をComputerを選ぶ

6.左のサムネイル今日の成果が列挙されるのですべて選択

7.New Albumを選び Unlisted Albumを選ぶ(じゃないと公開したことになりとっつかまる)

8.アップロードMacダウンロードフォルダ空っぽにしておく


9.落ち着いたらPicasaウエブアルバムを見ながら、キャプションだとかタグだとかを付ける

10.Enjyo!ってやつだ


だれか、オートメータを作ってくれ。

2007-10-20

http://anond.hatelabo.jp/20071019153453

よもや、レスがついてるとは思わなかった。

興味を持ってもらえてサンクスです。

entry = diary.entry('20070712231804')

エントリー指定してたからなんなんだろうと思って。

editもできるってことなのかな?

書き込んだあとの編集機能はいまんとこなし。

上記は指定したidエントリを引っ張ってくる。

# get entry from id
entry = diary.entry('20070712231804')

# puts entry title
puts entry.title

# puts entry content
puts entry.content

で、そもそもRubyに詳しくない自分からするとちゃんとした使い方がそれでもわからない。

バカでごめんねなんだけど、どうやって使えばいいの?

たとえば、エントリタイトル一覧(1ページ目だけだけど)を出力するなら

diary = Masuda::Diary.new

diary.entries do |entry|
  puts entry.title
end

こんな感じかな。

新しいエントリを登録するなら

diary = Masuda::Diary.new

diary.login('my_id', 'my_pass')
diary.post('koko wa title ne', <<EOS)
koko ni kizi no honbun wo kaku
EOS

とか。


ずらーっと増田らしきものを読み込む。

そりゃそうだわなと思いながら文字化けの山。

文字化けなのは、たぶん増田エントリ(UTF-8)をそのまんま取得しているせいだと思う。

なんでスクリプトを実行するときにフィルタを通すとか

~$ ruby hoge.rb | nkf -Ws

出力するときにSJISに変換するとか。

require 'rubygems'
require 'masuda'
require 'kconv'

diary = Masuda::Diary.new
diary.entries.each do |entry|
  puts entry.title.tosjis
  puts entry.content.tosjis
end

あと

session[:diary] = diary.raw

diary = Masuda::Diary.restore(session[:diary])

の...って何でしょうか??

Masuda::Diary#rawインスタンスシリアライズするメソッド。

ログイン済みのインスタンスシリアライズしてセッションにつっこんどいて、次のリクエストでも使いまわすとか。


わかりづらい文章で申し訳ない。

2007-10-18

http://anond.hatelabo.jp/20071018141259

これは何をするための?

単にRubyから増田を読み書きするためのライブラリだけど、分かりづらかったかな。。。


バックアップとってくれるのかな?

自分のエントリバックアップするんだったら

diary = Masuda::Diary.new

diary.login('my_id', 'my_pass')
diary.my_entries.each do |entry|
  open("#{entry.id}.txt", 'w') do |f|
    f << entry.content
  end
end

とか。

Ruby Masuda Library

http://rubyforge.org/projects/masuda/

作った。

インストール
gem install masuda
使い方
require 'rubygems'
require 'masuda'

diary = Masuda::Diary.new
diary.entries.each {|entry| puts entry.content }
entry = diary.entry('20070712231804')
puts <<EOS
  #{entry.title}
  #{entry.content}
EOS
entry.trackbacks.each {|trackback| puts trackback.snippet }

diary.login('my_id', 'my_pass')
diary.my_entries.each {|entry| puts entry.content }
diary.post('Ruby is ...', <<EOS)
A dynamic, open source
programming language with a
...
EOS

session[:diary] = diary.raw
...
diary = Masuda::Diary.restore(session[:diary])

2007-10-14

速学Ruby railsを使うための最小限の知識

前置き

本講座ではほかの言語は触ったことがあるが、Ruby未経験者を対象にRailsを触るための最小限のrubyの知識を身につけるためのものである。

と、堅苦しく書いたけど仕事で急いでrailsを触れうようになるための最低限の情報だけをまとめてみたよ。

これを読んだだけではRubyプログラムを書けるようにはならないと思うけど、Railsを使った開発だといきなり何もできないってことはなくなるはずだよ。

肩の力を抜いて読んでほしいな。

基本のお話

変数宣言

Rubyでは特別に変数の宣言は必要ないんだ。

いきなり今まで宣言していない名前を使ってもおこらえないよ。

answer_to_life_the_universe_and_everything = 42 
# answer_to_life_the_universe_and_everything ????~A~S??~S????~H~]??~A????~Y??| ??~A~Y??~K??~B

なんて書いても問題ないんだ。

静的言語をやってきた人には型の宣言がないことに違和感を感じる人もいるかもしれないけど、Rubyでは型はあんまり気にしないんだ。


int x = HogeHoge.new

みたいな書き方では

変数xを用意してそこにHogeHoge.newを代入する。といった説明を受けたと思う。

でもRubyではちょっと違う考え方をするんだ。

x = Foo.new

だとFoo.new変数を用意して、それを名前に"束縛"するって説明することが多いよ。

ベルが貼られた箱を用意してそこに何かを入れるか、何かが入った箱を用意してそれにラベルを張るかの違いだね。後者のほうがちょっとだけ柔軟なんだ。

そして、柔らかいほうがRuby流って気がするよ。


でもそんなRubyでもちょっとだけ名前に関するルールがある。

大文字からはじまる名前はクラス

小文字からはじまる名前が局所変数

@からはじまるのがインスタンス変数

@@からはじまるのがクラス変数

ってルールだよ。

Railsだったらとりあえず@からから始まる名前にしておけばたいていは問題ないんじゃないのかな。


分岐分岐

JavaC言語ではif文なんかをよく使うよね。Rubyでもほとんど一緒だよ。

 if something_condition
  do_some_thing
elsif other_condition
  do_another_thing
else
  do_something_if_you_wont
end

もちろんelsifやelseが必要なければ省略することができるよ。

ほかにもRubyには便利な分岐の書き方があるよ。

so_some_thing if some_condition

みたいに後置でも書けるんだ。

どっちでも好きなほうを使えばいいと思うよ

関数宣言

関数宣言のとてもシンプルなんだ。

def func_name ( some_val_names )
  do_some_thing
end

といった感じでdef..endでくくるだけで簡単に関数を宣言できるよ

そして関数戻り値は最後に評価した値が自動的に戻り値になるんだ。

def baz 
  10
end

これは常に10を返す関数の例だよ。


Hash,Array

プログラムをしていて非常によく使うデータの型といえば配列(Array)や連想配列(Hash)だよね。

Rubyではそれらを簡潔に使うために専用の文法を用意している。

それが[]と{}だ。

arr = [1,2,3,"A","B","CDE"]         #??~M很~W宣訾@
has = {1 => "A",2 => "B", 3 => "C"} #??~O??~C????~CťΣ訾@
puts arr[3]
puts has[2]
A
B

とすれば簡単に配列ハッシュが宣言できるよ。

アクセス方法もほかの言語と大きく変わらないのが分かるよね。

2007-07-24

GoogleEarthで遊ぼう

Ruby,Windows COM APIの知識がそれなりにあることを前提としています。あしからず

あと、用語の使い方は結構いい加減です。訂正ヨロ。

まずは、GoogleEarthをインストールしよう。http://earth.google.co.jp/ から無料ダウンロードできます。

次に、COM APIの登録。コマンドプロンプトで、GoogleEarthをインストールしたフォルダ(通常は、c:\Program Files\Google\Google Earth)に移動して次のコマンドを実行します(>は入力する必要はありません)。

>googleearth.exe /RegService

これを実行することによりCOM APIを介して外部から操作することが可能になります。

次にRubyの実行環境を整えます。が、説明が面倒なので省きます。ActiveScriptRubyでぐぐれ!

さて、ここから実際にGoogleEarthを動かしてみます。こういうときはirbが便利ですね。ActiveScriptRubyが正しくセットアップされていれば、デスクトップRuby Consoleというショートカットができているはずです。これを起動すると、Rubyパスが通った状態でコマンドプロンプトが起動するはずです。そこでirb(Enter)と入力してみましょう。

irb(main):001:0>

というふうに表示されればOKです。

どんどんいきましょう。irbで、

>require 'win32ole'

入力してください(>は入力しません。プロンプトがでているという意味お約束です)。これで、COM APIRuby上で取り扱うことが出来るようになります。

次に、

>ge = WIN32OLE.new('GoogleEarth.ApplicationGE')

入力しましょう。変数geがGoogleEarthのCOM APIインタフェースインスタンスになります。geのメソッドを呼び出すことによりGoogleEarthを操作します。GoogleEarthを起動していない場合、ここで起動されます。

では、いよいよGoogleEarthを動かします。GoogleEarthでは、視点情報をCameraと呼称しています。カメラを移動させるために、カメラ情報へのインタフェースを生成します。

>cam = WIN32OLE.new('GoogleEarth.CameraInfoGE')

この、camプロパティを設定することによりカメラ情報を設定することが出来ます。

>cam.FocusPointLatitude = 35.0
=>35.0
>cam.FocusPointLongitude = 135.0
=>135.0

実際に入力するのは、1行目と3行目です。Latitude:緯度、Longitude:経度です。緯度は赤道を中心として+90(北方向)から-90(南方向)の値をとります。経度は+180(東方向)から-180(西方向)の値をとります。日本の場合、どちらも+になります。

実際に視点を移動させるには、先ほどのgeのメソッドを呼び出します。

>ge.SetCamera(cam,1)

GoogleEarthでの表示が切り替われば成功です。場所は日本どこかです。岡山のあたりでしょうか。

(つづく?)

2007-07-11

めいろさくせーぷろぐらむつくってみたー

http://anond.hatelabo.jp/20070711013155

人待ちの間暇だったから作ってみたよー。

さっくり作ったから無駄が多い気がするけど、とりあえず動いた。

全体が埋まったかどうかの判定をしないでひたすらまわしまくってるし、なんか綺麗な形じゃないけど、とりあえず投稿しちゃうよ!

これ綺麗な形にするの結構難しいんじゃないかな。面白いね。

class Maze
	class Box
		WALL = 0
		LOAD = 1
		def initialize(state = LOAD)
			@state = state
		end
		def is_wall?
			return true if @state == WALL
			false
		end
		def is_load?
			return true if @state == LOAD
			false
		end
		def set_wall
			@state = WALL
		end
		def set_load
			@state = LOAD
		end
	end
	TOP = 10
	RIGHT = 11
	BOTTOM = 12
	LEFT = 13
	def initialize(height = 100, width = 60)
		@height = height
		@width  = width
		@data = Array.new
		self.fillbox
		@counter = 1000
		@root = Array.new
	end
	def choose_random
		return rand(@width-3)+1, rand(@height-3)+1
	end
	def choose_direct
		t = rand(4)+10
		return t
	end
	def move(x, y, t)
		new_x = x
		new_y = y
		case t
		when TOP
			new_y -= 1
		when RIGHT
			new_x += 1
		when BOTTOM
			new_y += 1
		when LEFT
			new_x -= 1
		end
		return new_x, new_y
	end
	def make_load?(x, y)
		return false if x < 0 or y < 0 or x > @width-1 or y > @height-1
		return false if @data[x][y].is_load?
		true
	end
	def dead_end?(x, y, t)
		case t
		when TOP
			if make_load?(x-1, y) and \
				 make_load?(x-1, y-1) and\
				 make_load?(x, y-1) and\
				 make_load?(x+1, y-1) and\
				 make_load?(x+1, y) then
				 return false
			end
		when RIGHT
			if make_load?(x, y-1) and \
				 make_load?(x+1, y-1) and\
				 make_load?(x+1, y) and\
				 make_load?(x+1, y+1) and\
				 make_load?(x, y+1) then
				 return false
			end
		when BOTTOM
			if make_load?(x-1, y) and \
				 make_load?(x-1, y+1) and\
				 make_load?(x, y+1) and\
				 make_load?(x+1, y+1) and\
				 make_load?(x+1, y) then
				 return false
			end
		when LEFT
			if make_load?(x, y+1) and \
				 make_load?(x-1, y+1) and\
				 make_load?(x-1, y) and\
				 make_load?(x-1, y-1) and\
				 make_load?(x, y-1) then
				 return false
			end
		end
		true
	end
	def check_all?(stack)
		for i in TOP..LEFT do
			return false if !stack.include?(i)
		end
		true
	end
	def extend(x, y)
		@data[x][y].set_load
		check_stack = Array.new
		loop do
			t = choose_direct
			check_stack << t
			new_x, new_y = move(x, y, t)
			if enable_new_point?(new_x, new_y)
				if !dead_end?(new_x, new_y, t) then
					@root << ["ex", new_x, new_y, t]
					extend(new_x, new_y)
					break
				end
			end
			break if check_all?(check_stack)
		end
	end
	def enable_new_point?(x, y)
		return false if x<=0 or y <= 0 or x > @width-1 or y > @height-1
		return false if @data[x][y].is_load?
		true
	end
	def _make
		x = y = 0
		loop do
			x, y = choose_random
			break if @data[x][y].is_load?
		end
		@root << [x,y]
		extend(x, y)
	end
	def make_goal
		x = @width - 2
		y = @height - 1
		for i in 1..@width-3
			if @data[x-i][y-1].is_load? then
				@data[x-i][y].set_load
				break
			end
		end
	end
	def make_start
		for i in 1..@width-3
			if @data[i][1].is_load? then
				@data[i][0].set_load
				break
			end
		end
	end
	def make
		self.fill_all
		x, y = choose_random
		@root << [x,y]
		@data[x][y].set_load
		extend(x,y)
		while(!is_fill?) do
			_make
		end
		make_goal
		make_start
		self
	end
	def is_fill?
		@counter -= 1
		return true if @counter < 0
		false
	end
	def fillbox
		for i in 0...@width do
			@data[i] = Array.new
			for j in 0...@height do
				@data[i][j] = Box.new
			end
		end
	end
	def fill_all
		for i in 0...@width do
			for j in 0...@height do
				@data[i][j].set_wall
			end
		end
	end
	def output
		for i in 0...@height do
			for j in 0...@width do
				if @data[j][i].is_wall? then
					print "#" 
				else
					print " "
				end
			end
			print "\n"
		end
	end
end

Maze.new(30, 30).make.output

## output

# ############################
#  ##    # #     ##    #     #
##    ##   ## ## #  ##   ### #
### #  ###  #  #   #### ###  #
#   # ## ## ## ### #  #  #  ##
### #  #  #  #   #### ## # ###
##  ## ## ## ###   #  ## #   #
#  ### #  #   #### # ##  ## ##
# ## #   ####    #    # ###  #
#  # ###  # #### # ## # #   ##
##     ## #      #  ### ######
######  ### #######   ###    #
#    ##   ###   # # #   ## # #
# #######  #  # # # ###  ### #
#   # # ##   ##   #   ##   # #
### #    ######## ########   #
#   # ## ##     #    #     ###
# ### ##  ## ##   ##   ##### #
#      ##  # #  #  ###  #    #
# ######## # #####   ## # # ##
#       ## #  #  #####  # #  #
####### #  ## # ## #   ## ## #
##    ### ###   ##   ####### #
#  ##  ##   ## ##  ###    ## #
# ####  ###  # #  ## # ##    #
#  # ##   ## # # ###    ######
## #  # #  # # #   ## #    ###
#    ## ## #   # #  # # ##  ##
# # ##  ##   # # ##   #  ##  #
########################### ##

2007-05-08

みんなアタマやわいね

想定していた回答はこんなの

def setr(a,k,str)
	a[k-1] = str if a[k-1]==nil && k<=100
end

res = Array.new(100)
(1..100).each{|i|
	setr(res,i   ,i.to_s)
	setr(res,i*3 ,"Fizz")
	setr(res,i*5 ,"Buzz")
	setr(res,i*15,"FizzBuzz")
}

print res.join("\n")

http://anond.hatelabo.jp/20070508173455 が気に入ったのでこなたあげます っ(=ω=.)

2007-02-26

Javaのあまり知られてない仕様

例えば、

new SampleA().new SampleB().new SampleC();

とか、

SampleA.this.toString();

とかってあまり知られて無いような気がするけど、どうなんだろうか。

- 転職ならen
- 派遣ならen
 
1ページ中1ページ目を表示(合計:25件)