【Perl,Python,PHP】LL ﾊﾞﾄﾙﾛﾜｲﾔﾙ 27【JS,Ruby】

最強のLL＝軽量プログラム言語は、どれよ？

エントリーは、Perl、PHP、Python、Ruby、JavaScript・・・
さあ、死ぬまで語りやがれ！！！

■LLとは？
軽量プログラミング言語（Lightweight Language,LL）とは、取り回しに優れ、
コードの作成や修正が容易と見なされるプログラミング言語のことを指す。

ここでいう「軽さ」はプログラマの負担の軽重を指し、
実行速度に優れているという意味ではない。

現在の水準では
・インタプリタ
・動的型
・正規表現
・クロージャ
などを利用できるものがLLと呼ばれることが多い。
ただし、他人の同意を得られるとは限りません。

長いコードはここで
ttp://play.island.ac/codepaste/

【Perl,Python,PHP】LL ﾊﾞﾄﾙﾛﾜｲﾔﾙ 26【JS,Ruby】
http://toro.2ch.net/test/read.cgi/tech/1346967719/

このスレッドは天才チンパンジー「アイちゃん」が
言語訓練のために立てたものです。

アイと研究員とのやり取りに利用するスレッドなので、
関係者以外は書きこまないで下さい。

京都大学霊長類研究所

関数型言語 >>>>>>>>>>>>>>>> LL

Lispマクロのような手軽な強力さも、Haskellのような静的型検査も無い

((((((((((((((((関数型言語)))))))))))))))) LL

>>1のいう現在の水準ならLuaも入りそうなもんだが

スレタイ文字数制限あるからなあ
ところでttp://play.island.ac/codepaste/ってなんぞ

ecma scriptの1人勝ち。そろそろ、このスレは終了すべき

2chでは盛り上がっているJSだが、なぜか世界的には不発。
http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

だってまともな言語で書いて
JSにコンパイルする方がマシだもん

　　　　　　　／/
　　　　　／　 /　　　ﾊﾞｶｯ
　　　　 //⌒)∩＿＿∩
　　　　/.|　.| ノ　　　　　ヽ
　　　 /　|　| 　●　　　● | 　　　　
　　　/ 　|　彡　　( _●_)　ミ 馬鹿には無理
　　 /　　|　ヽ　　|∪|　　/＿
　　/／　│　　　ヽノ　　＼／
　　"￣￣￣￣￣￣￣（..ノ

web屋達の中ではマイブームなんだろ
そっとしておけ

>>8
それ見るとRubyも不発か・・・

redmonkの調査ではjsが1位とってたよ
多分、tiobeは中堅どこのソフトウェアハウス
零細web屋はjsが増えていく。
零細web屋が中堅どこの仕事を奪っていく。
零細web屋が中心になって世界が動いていく。

>>13
> 零細web屋が中心になって世界が動いていく。

零細web屋の妄想ワロスwww

シリコンバレーのスタートアップなんて零細ウェブ屋と同義語だろ

>>13
Tiobeは単に検索数の集計で、長い間特に操作を加えている様子はない。
Javascriptが下降しているのは「話題性」は乏しいという意味。
流行っているかとか使われているかというようなことはあまり読み取れない。

ttp://redmonk.com/sogrady/2012/09/12/language-rankings-9-12/

>>17
すみません質問です。
この表の縦、横罫の中に現れる(by # of projets) (by # of Tags)は
それぞれどういう意味ですか。

flat of projects|Tags だから、
プロジェクト数（タグ数）を順序でならした結果でしょう。

(;´Д｀)♭

hirata-create.cocolog-nifty.com
hirata-create.toypark.in

Lua IN
Ruby OUTでいいじゃん

スクリプト言語ばかりニョキニョキ出てきても仕方ない。
はっきり言って、大量に亡びるべき。

このスレにいたキチガイだろ今スレ乱立してるの
本物の障害者だったか

スレのアボーン登録がフルブックになりそう

颯爽とObjectScriptが登場

颯爽（さっそう）

どれが優れてるかじゃなく、「１つだけ残すならどれ？」ってのはおもしろいかもしれない

それブラウザ専用言語を別枠にしとかないとJSになっちまうぞ

ひとつだけ消滅するならどれ？ってのも

なくなっても困らないもの
それが Ruby

https://github.com/norinori2222/boyfriend_require
最近のgithubでは、第８層でjp語を使った子プロセス作りまで行うらしいな

>>30
javascript
これでソフトウェアの進化を食い止められる

rubyとjsの共通点わかる？モルモン繋がりだよw

JS…扱いやすい言語、小学生でも取得できる。ブラウザで必要、サーバーサイドのnodejsやクライアントサイドのHTML5APIなどで活躍の場多し
PHP…JSに毛が生えたような言語でサーバーサイドのWeb開発に特化。HTMLと親和性が高い。ちょっとしたWebアプリ作るならほぼこれ
Python…Google推しでWebだけでなく幅広く使われている。可読性に優れている。Linuxの周辺ツールもこれで書かれているものも多い。ライブラリー豊富。小さなプログラムを大きく育てるのにも向いている
perl…古くからWebのCGIやUNIXのシェルスクリプトで使われているきた。CGIとして未だ現役。オワコン化しているがライブラリーやドキュメントの充実さは魅力的
ruby…日本発、楽しく効率よくコーディングできるのを目標。開発者のオ○二ー的要素も大きいがRoRという便利なものがある。下火ではあるが生産性がウケてところどころで使われている

web開発でのrubyに生産性なんてないよ。馬鹿じゃねーの
それよか、jsをしっかり使える方が重要だよ。自称jsを使える人間なんて現場における凶器だから

未だに昔の通りのWebオモチャ言語としての認識しかない人も居るからなあJS

jsってバイナリファイル扱える？
unicodeって本当に便利か？

まず小学生にも扱いやすいならPHPだよ、深いことをやろうとすると他の言語よりも大変になるけど
これはこれで一つのLLの有り様だと思う
JSは改良版が乱立してるように、とにかく改善の余地の塊でウンコ言語

JSの改良版乱立って言うが、そんなに乱立してたっけ

改良版っていうか...
https://github.com/jashkenas/coffee-script/wiki/List-of-languages-that-compile-to-JS

29 デフォルトの名無しさん [sage] 2012/10/10(水) 18:11:39.35 ID: Be:
    http://www.infoq.com/jp/news/2012/10/Ruby-on-Rails-Node-js-LinkedIn

    LinkedIn は先日，パフォーマンスとスケーラビリティを理由として，
    同社のモバイル用バックエンドインフラを Ruby on Rails から Node.js にリプレースした。
    これに対して元 LinkedIn のチームメンバが，何が問題であったのか，自身の意見を表明している。

30 デフォルトの名無しさん [sage] 2012/10/10(水) 18:15:24.99 ID: Be:
    ・優れたパフォーマンス – いくつかのシナリオにおいて，Node.js は Rails の20倍以上高速だった。
    ・サーバ30台の処理をわずか３台で実行できるため，10倍以上のトラフィックを処理する余地が生まれる。
    ・フロントエンドの JavaScript 技術者をバックエンドコード開発に従事させることが可能になる。
    　この結果，２つあった開発チームが１つに統合された。

OO言語が乱立しても改善の余地があると言わないのはなんで？
C++が難解でもOOが難しいことにはならないし
Rubyが遅くてもOOが遅いとはいえない
OOは無敵すぎる

お前が馬鹿でも人間が馬鹿ということにはならないから

>>42
Infoq記事の続き....

　問題をいくつか指摘した後に Lan 氏は，最終的に "v8 がとんでもなく早い" ことを認めながらも，
　"次世代の技術として node.js の使用が必須である，とは言い切れません。" と付け加えた。
　"モバイルサーバで実行しなければならなかった処理に関して言えば，Ruby on Rails より
　適切であったことは事実です。しかしパフォーマンスの万能薬ではないのです。
　下位レベルのサーバとフルスタックの Web フレームワークの比較なのです。"

最後の結論に注目：

　 下位レベルのサーバ(Node.js)とフルスタックの Web フレームワーク(Rails)の比較なのです

すべてのWebサービスが Rails から Node.js へ移行するのではなく、軽量なサービスに限定すれば
(LinkedIn社の場合は「プロキシよりちょっと重い程度」) Node.js を検討する価値がある、
という程度の話ではないかと思われ

railsがなければrubyに用なし

軽量サービスはサーバーサイドJS
重いのはクライアントサイドJS

そもそもなぜRubyを使ったｗ

それが古のオタクたちの夢だったからだ。だが、crubyは死んだ。
OSSという才能が集まるフリークラスでは淘汰された。
現存するのは、企業が提供するタダ乗り文化だ。

rubyの犠牲はキリストの犠牲と似ている。
誰かrubyとキリストによる贖いの比較ってタイトルで論文でも書け
バザール文化はcからnode.jsに移った。

前にjsが流行っこないって言った連中は、上司にヤレと言われても断れよw

普通にJSにコンパイルして使ってるよ

てか、博多のruby開発拠点ってさ、第五世代コンピューティングばりの失敗だよねwwwww
これからrubyやrailsで商売しようとしてたマヌケたちって、どうなっちゃうんだろうwwwww
日本は、計算機の市場でまた負けたのだよ。計算機、OSときて、そして言語まできたwwwwww

けれど、ソーシャルゲーム市場で勝つショボさwwwwwww

サーバサイドで処理系の出来の良さだけ考慮して
言語そのものは何でも良いなら
node.jsなんてオモチャ使わずにErlang使うわ、という話

http://kuenishi.hatenadiary.jp/entry/20101013/1286973687

uyとかいうゴミってまだ生きてるの

たまにレス番飛ぶから生きてると思われる

>>55
日付がちょっと先なのが気になった

次の記事はもう予想が付くだろ?
どーせ、node.js vs eralng vs golang だよ
もうひとつが、dart vs typescript
この関係を持ち出すと、結局、node.jsしか選びようがないわけ
こうして、古きよき時代のLL文化はテクノロジーの進化と共に幕を閉じた
さようなら、Larry。さようなら、guide。さようなら、matz。

だから、ソフトウェアはcで書けって!

>>60
cはプラグイン言語だろうね

>>59
上の記事なかなかおもしろいよ

この自信満々の煽り方は古きよきオタクとは正反対のリア充だよね

まさか。LLブームのおかげでFOSSに興味もってしまったニートだよwwww
釣られている現職のPGなんて居たら、向いてないから転職した方が良いwwwww

perl、rubyとかpython弄ってたのに、卒業したと同時にブーム終わってんのwwwwww
冗談抜きでc++以外さわっちゃダメだよね。本当に時間の無駄だったwwwwwwwwww
今学生に戻れるならc++かjsのどっちかしか触んないwwwwwwww
今ならc++と競技コーディングの方が就職に有利なのかなwwwwwwww
記事書いた連中供死ねよwwwwwwwwwwwwwwwww

http://whatcanidoformozilla.org/

Rubyの仕事がないｗ

ニートの予想だとね、jsで競技コーディングがトレンドだよー
topcoderだかでは、jsだけなかった気がしたけどね
学部１年はアリ本とヤドカリ本、買おうね！
学部２年は現実を見つめて公務員試験を受けよう！

Mozillaはもう経年劣化が激しすぎるからJava/JSから離れてRuby組み込むべき

rustなんてrubyのようなものだろ
rubyをtypescriptにしたような感じ

いまさらあんなものに肩入れする奴がいるとも思えない
汎用的なスクリプト言語でPython, Rubyにとってかわる勢いのある言語はないのか

>>65
> perl、rubyとかpython弄ってたのに、卒業したと同時にブーム終わってんのwwwwww

perl, ruby, python なんて役割が被ってて
弄るにしても一つで十分なのは自明なのに
全部弄ってたなんて人として最低限の知性すら足りてない
馬鹿はどんな言語触っても無駄

だから、今はもうスクリプトの選択はjsしかないってwwwww
そのスーパーセットのtypescriptが一番に勢いが付くよwwwww
他は触るだけ時間の無駄だよ。無駄wwwwwwwwwwwwwwwwwwwwwww

馬鹿は生きてるだけで資源の無駄

>>71
最初はまだ、rubyブームなんて着てなかったんだよwwwwwww
perlを弄りだしたところでrailsが流行りだしてんのwwwwwwwwww
python触りだした頃に、schemeブーム、haskellブーム...
記事書いた奴ら死ねよwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

そして今度はjsブームに踊らされるわけですね、分かります

汎用的なってわざわざ書いたのにこれだ

>>73
現存する馬鹿はPHPやjs以外でコード書く奴らだよwwww
直にPHPも馬鹿扱い。生残るのはjsだけだよwwww
rubyとかpythonとか、本当に使えるとこないからwwwwwwwwwwww
perlなんて、恐ろしい零細ぐらいしか使わないよwwwwwwwww
結局、皆が仕事を探すに当たってweb系ならPHPかjsの募集が多い。
いまどき、perlで書かれたCGIなんて弄りたいヤツ居ないだろ?wwwwww
rubyやpythonの募集なんて限りなく少ない。
他のものイジルよりnode.jsを弄った方が痛み少ないって風に、皆が考えるわけ
これが求職者の立場から見たnode.jsバブルwwwwwwwwwww
rubyやpythonなんて弄ってみろよ？零細企業から逃げ出せないぜ？

直にjsはないわ

生でjsだよ。生で。
rubyからのトランスレータ使わせて下さいなんて会社に言うの？
馬鹿じゃね？って却下されるよwwwwwwwwwwwwwwwwwwwwwww

なんで却下されるの？自分の意見が通らないほど下っ端だから？

あ、もしかして派遣ですか？wwwww

せいぜい、gdbやtrac弄るのにpython止まりだよー。
rubyだけ、使う必要性が他言語と比較して狭すぎる。

>>80
ニートですけどなにかwwwwwwwwwwwwwwwwwwwwww
普通、大きな会社だと自分の意見なんて通らないじゃないのか？wwwwwwwww
この言語でーーーーーーーなんてぇーーーー、すぅっげぇーーーー零細ないめぇーーーーーーじwwwwwwwwwwwwwwwww

ニートはコテハン付けてよ

嫌だぉーーーーーーーーーーーーーーｗｗｗｗｗｗ
コテとかuyのアホだけがやってりゃいいだろwwwwwwwwwwwwwwwwwwwwww
node.js推してるレスなんて、ほとんど俺だよwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

てかさ、c++でグループウェア作ってるとことか大丈夫なのかねwwwwwww
あれって、次のofficeとかsocket.io、jsライブラリ、
html5で似たようなことする製品作れそうじゃんwwwww
c++で書くなんて石から削りだしてるように見えるのよねwwwwwww
methor frameworkなんて流行りだした日には、大量のjava屋さんたちにハローワークで会うかしら？wwwwwwww
ざぁｗｗｗｗｗまぁｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗ

jsだけリアルタイムシステム書けないけど、
そういった機能要求よこされる中堅どころぉなんてぇーーーー、
しぃんそぉつぅでさいよぉーされた奴らだけが必死こいて、
やってりゃいいぉねぇえええええｗｗｗｗｗｗｗｗ
そーいった現場って、クビきられた後で、次の職場でノウハゥ生かせられるのかしらん？wwwwwwwwwwwww

このスレは既知外ホイホイですか？

最近、発症したよぉぉぉぉぉぉｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗ
ｗつけるぅとぉおおおおおおんｗｗｗｗ、すぅっげぇい楽しいねぇええええええええええええｗｗｗｗｗｗｗ
ｗｗｗｗｈｙみたいにぃいいい、node.jsのにゅうぅーもんマンガでもかいたらぁぁああああ、
しぃごぉとぉおおおお大尾、みいいぃいいつうかぁっるうかなあああああああああｗｗｗｗｗｗｗ

まずは失踪から始めよう。成果が出るまで続けるのが大事

c/c++の求人さがしてぇええ、おうぼぉするのぉってぇええええええｗｗｗｗｗ、
すぅげぇええええええぇリスク高いよねぇえええええええええええええええｗｗｗ
作れってぇえええええ、いわれぇっるうううもののおののがあぁぁっぁ、
レベェルたかかああああああああいいいいいイッメーーーーーーージ
がぞぅしょりだの、せいぎょだの、シィんそちゅのがぁしたヴぁかにぃー、
てとりナにとりぃーーー教えてもらえるぅのかなぁあああんん？
ロマンスグレイなぁじょーーしにさーーーーーー。ふふぅん、こんばんはかえさないよぉーーーなんてぇｗｗｗｗｗ
祖ぉーーレナらぁーーーまぁだーーーいーけーどさーーーーー、
ひっこしたあとで、ほうちされて、おい込まれたりしたらぁあああああ、
すぅううごおおぃいいリィスゥーーーーーーーーーーーーーーーークwwwwwwww

けど差、けど差、けどぉさぁぁあア嗚呼嗚呼あああんああああんあああぁあああぁwwww
じゃヴぁってぇーーーーーーーーー、なぁあああああんんかあああぁあああぁあああ
しちょおおおおっせえええええええええええええぇえええが嗚呼ああああみいいえてえるよねえええええええｗｗｗｗｗｗｗｗ
M　V　C　!　M　V　C　!ってぇえええええいううぅぅぅけえれっどおおぉぉおおおおおおおｗｗｗｗｗｗｗｗｗ
かぃたこおおぉおぉおどのおおおわりぃいいいにいいいいいいいいいいい、
やれることおおおおすくうないいじゃんんんんんｗｗｗｗｗｗｗｗｗｗｗｗ
しょーじきーネットワーーーークまわりぃいいのおおおぉおおライブラリぐらいしか、
つかわれなくなりそうだよねぇええええええええええええええええええ。
すぅぷぅりんぐ?なにそれ、おいしいいいぃいいのおおおおおおおおお？ｗｗｗｗｗｗｗ
ウェブフレームゥワークってぇええええええ、らんりちゅしぃーすぅーぎぃーwwwwwwwww
ぷぅろぉじぇくとぅ毎にぃ、えらぶぅだけえええええええええええのおぉおぉおぉおぉおおお、
メリットなんてぇええええ、あんのかよぉぉぉぉっぉぉぉぉおぉお
C#はぁ、entityイッタクだけぉどぉぉぉおおお、M$のお庭でぇあそぶぅのう、
なんんかああああああ、せいしゅうぉぉおおおおお、ぜんひてーーいするきぃぶぅんｗ
でさ、でさ、でさ、出た答えがぁｗｗｗｗｗｗｗ、ザッカーバーグゥか、ジョブズのまぁねごとしたいヴァカを期待してぇえ、
node.jsとぉぉおおお、メェテェオゥッ！html5でぇええ、てくぅのろじーが
入れ替わるのぉおおおおおきぃたぃするしかないぃんだよねぇええええへへへへへｗｗｗｗ

よぉのぉなかあぁあああのおおさあああああ、ぎょおーむけーなんてぇー、
じゅよおおううよおおぉおお斧おおほとおおんどおななんてええぇえええ、
GUIと文字列とデータベース、統計でぇえええええええええええ、
すんじゃうよねねねねねねねねえんええんねええええええええええええwwww
desa,desa,desa、GUIと文字列とデータベース弄るゥぅぅのにぃいいいさあぁあああ、
じゃヴぁあああぐらいぃいいい、メンドウなぁあああげんんごおおってえええ、
ほぉかにないよねええええええええええｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗ
しょおきぃぼぉなぁああああんけんはぁああああああああああ、
じゃヴぁすくぅりぃぷとぅがあぁああああおいしくぅううういただきぃましたぁああああｗｗｗ

>>86
> jsだけリアルタイムシステム書けないけど、

リアルタイムシステムに必要なものって何のこと？
それがjsだけ欠けているというのが本当か調べたいんだけど、
まあ後半の文章見る限り、レスは期待できないなｗ

ま、レスがなければ根拠なしということで忘れよう。

るぅびぃはぁああーーあああああああーああああああああさぁああああああああ、
ほんとぅにぃーーーーー、くぅーーるぅううーなあああぁあああぁあぁ、
げんごぉおぉおおおだったぁけれえええええどおおおぉおおさああっぁああああん、
どぅみぃてぇもぉおおお、はっかぁーれんちゅーがぁあああああああーーーーー、
このぉむぅううぅぅうぅぅ、てぇつぅがぁくスタァイルじゃないんだよねぇえええ
うにぃくすぅのぉおおでんとぅてぇきぃな記号はぁあああ、うけついでるけどさぁ、
やぁあああぱああぁああっりいいぃいい、てぇえええつうぅうがぁくぅスタァイルとはぁ、
違ってええええええええぇええみえええっるうんだょねえええええええええええええええ。
スゥクゥリプトゥのレベルでぇ、ほんとぅにぃ、クラスなぁんてーーひつようだったのかしらん？
ハッシュでぇえええええええええじゅうううぶうぅうんんだったよねえええええええええええマヂで

>>93
RTOSみたいなああああああああ、GCのぉおタァアアイミングゥまでぇええええ、
要求されぇるようなぁああああああああああぁあああ、じゃヴぁあああすくりぷとぅのおおお、
処理系何てぇええええええええええあるぅうのぉおおお？
とうしょーのしすてむとかーぁあああああ、javaらしいいじゃあああああああんんんん。
ニートゥに聞くなよヴぁーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーか
おれぇがききてぇえええええぐらいだよおおおおお、たこ、くず、はげ、ごみぃぃいぃいい

>>93
おまえぇ、にいぃいいとぉおおだよねぇええええええ？
げんえきぃのえすいーとかだったらぁああああああああ、
しんだほうぅがあああいいいよおおおおおおお。
てか、しね。しね。市ね。視ね。視ね。しね。しね。しね。しね。しね

なにが、ま、レスがなければ根拠なしだとwwwwwwwwwwwwwwwwwwww
バーーーかあああああああ、くうっぅぅうずううううううう、あほふぉおおぉおおお
じじじじいいいしんんにいいいいいいまああああきこまれてぃえええええええ、しね

>>94
いや、だからそれ、JavaScript以外ならあるの？
少なくともスクリプト言語は全滅だし、
その他だって言語の機能じゃないでしょｗ

>>97
ア嗚呼あったあああありいぃいいまえええええだろおぉおおヴぁあああーあーかああ
でもなきゃぁあああーーーーー、Real-Time-yo!にぃいいいいいい、
わざわぁあああああああああ、じゃヴぁああああのぉおおおおかそぉおおましいいんつぅくるぅYO!
ふーつーはーーーーーーー、real time ! なんてぇえええええええ、c/c++の分野だろぉおおおおおがぁああああああん
ゆううういいいいつぅうううううう、食ううぅううみいいっこおおみいいいよおおとおおではぁあああああああ、
mrubyがぁああああああああ、にたYOなことおおおおぉおおおやろおおおとしてえええよおお
ひょっとおおするううとおおおおぉおおお、pythonのおおおおおじっそおおおううううにはぁああああ、
RTな要求をぉ大尾見達すうものおおおお大尾がああるうかもしれええあんないいけっどおおおおおおお、
風雨通宇うーは嗚呼嗚呼嗚呼あ、エンプラ用途ではぁあああつかわねーーーだろおおおおぉおおおおおおお。

http://ll.jus.or.jp/2012/slide/Language/mruby.pdf
組み込みを意識したmrubyを作ってみた
まつもとゆきひろ

ハードリアルタイムはムリ

なぁああああにいいがあああああああ、
>少なくともスクリプト言語は全滅だし、
da-yo!カス、クズ、ゴミ虫ィィ良い良い良い良い良い良いイ！
ふつううううにいぃいいかんんがええええれりゃああああああああああああああ、
すうううくううう売り良いぃいいっぷううつうぅうううのぉおおおお、
やるうううよおうううなぁああああああああああ、機能要求じゃねーーーーYO！

>>99
まぢいでええええ？まぁあああそおおおだよおねえええええええええええ
cへのぉおおおおトランスレーターーーにいぃいいスレヴァいいいのにいいぃいいいいNE！

http://www.forest.impress.co.jp/docs/news/20121010_565069.html
そのほか、「Firefox 15」での採用が見送られた“インクリメンタル
ガーベジコレクション（Incremental GC）”がJavaScriptエンジンに搭載された。
従来のガベージコレクション（不要になったメモリを開放する処理）に比べて
プログラムの停止時間が短縮されるため、ゲームなどリアルタイムな処理が
求められるコンテンツがより快適に楽しめるようになるだろう。

http://www.2ality.com/2011/11/v8-incremental-gc.html
Today we are announcing the release of Chrome’s new incremental
garbage collector (GC) which dramatically improves interactive
performance of web apps and HTML5 games.

ゲーーーーームのおおぉおおおおリアルタイムゥなあああよおおおぉおおきゅうううとおぉおおお、
金融なんかでのおぉおおおお、奇異の大おうううよううううきゅううううをおおおおおおお
おおおぉおおおぉおおおなんなんじいいいいいいい、じいげええんんでええええええええええええ
考える宇宇宇ナッツーーーーーーーーーーーーーーにおおおおおおおおおお
レントゲンをおおぉおおおお、いっめーーーーーーーじ、しろぉおおおおおお
ちょおおおどおおおおお、GCはしったりいいしたらああああああいやすぎるだろおおおおおがああああああああああああああ

mrubyのGCって
インクリメンタルGCだろ？
リアルタイムって何を言ってるんだか。

うん。インクリメンタルGCならソフトリアルタイムといっていいよ。
JavaScriptもそうだけど。

じゃヴぁとRTじゃヴぁのぉおおおおおおおおおおおお、GCってぇええええええええええええ
ナああああああああああにいいいいがああつかああわれえてええぇんんのおお？

GCがあああああはしいるううううう、FXだとかぁあ、株価のおおおおおほげとかぁああああああ、
つううううううかいいいたいいいいかあああああああああああああああああああああああっぁあ？
じゃヴぁすくりぷとでかかれたあああしんしつさいどぅそぉおちとぉかぁ、雄プレイなんてぇ、
JOE式でえええかんがえってえええええ、イイヤァーーだろぉおおおおぉお

webバブルが.comバブルの再来に見える。うふふ

なんだこのスレ・・・
鬼のようにレス番飛んでんな
キティでもわいてるのか？

>>109
#=> true

mozillaの気合が入ってるけど、これって確かgoogleから資金提供してもらってんだよね
運営資金足りないとかで、数年以内に結果出せって言われてた気がする。
もはやビジネスで負けた連中の呪いだよね！だから、大好き。

nokiaと組んだM$って、何処かOSSと関わって没落した企業の再生工場に見える

フリーソフトで損失を出す能力ってすごいよね
100%外れる占い師みたいなやつだな

馬鹿だな。100%外れたら、言われたことと反対のことすればいいだろ。本当に馬鹿だな

はっきりいっておくが、このスレに居るヤツは負け組み候補の受難を背負っている！

たぶん、w3cだとか各種言語のメーリングリストだのコミュニティだのを見た方が出世できるぞ。良い子の諸君たち！

コミュニティのメーリングリストが整備され、
実名で行動した方が有意義である文化において２chはオワコン化してしまった。
いいや、最初からこんな場所を読んではいけなかったのだ。

学歴なんて大して重要視されないが英語の読み書きが出来ないコミュ障は死んだ方が良い世界

これからさ、web開発での工数と価格が暴落して面白いことになりそうだよね
これまでシステムがあったらってな零細企業にも低価格で気楽に導入されるんだよ
頭使わない精神論者や教養のない連中が、どんどん淘汰されていくんだ。見物だね

ふう

今まで、こんなに技術から離れてたことがあっただろうか
なんか本当にもう、どうでもいいなこのジャンル
冷静に第三者視点でみると
IT技術なんて全然世界の中心ではなく
ひとつの「マイナー」ジャンルでしかない

「マイナー」だよ「マイナー」
狭すぎだろ･･･そしてマイナーな割に難易度が高い事は事実でもある
可愛そうだ
いつの時代も、社会や国の負荷がモロにかかる職種ってあるよな

こんな時代にPGやってる奴って･･･。

>>117
PerlとかのUNIX系のソフトウェアのメーリングリストは2chなんかが存在する以前から十分に普及してたぞ

ECMAScript 6 の draft で
class と module については一応見当たるのですが
静的型付けについてはどこに書かれているのか分かりません
"Static Semantics" とか関係ありますか？
http://wiki.ecmascript.org/doku.php?id=harmony:specification_drafts
http://wiki.ecmascript.org/lib/exe/fetch.php?id=harmony%3Aspecification_drafts&cache=cache&media=harmony:working_draft_ecma-262_edition_6_9-27-12-nomarkup.pdf

ここは質問スレじゃない

読みやすい教科書がまだない間はインターネット良いよね
で教科書が完成したら解散
無事に終わってよかっただろ

教科書の情報なんてすぐに陳腐かするだろ
ある程度の設計できるようになったら、断片的な知識から全体を構成できるからな

組込み・制御・ゲームって給料ヨサゲだけど才能ない人たちは死にそうだよね
web系・業務系はまったく才能がなくても、上手くやれば簡単に金巻き上げれそう
おまいら、どっちがオヌヌメなの？

>>120
何れホワイトカラーの事務職なんてのは、jsと統計周りの知識が必須になるよ
多分、ウェブバブル崩壊後には散り散りになったweb系技術者たちが
地方のあちこちのダメな中小企業で社内システムやらM$Officeのマクロを弄り出すよ
或いは、web系の企業の方が地方のダメな中小企業の業務を持っていってしまうか
どちらにせよ、地獄絵図だよ！

>>123
TypeScriptが話題になってたからこのスレが良いかなと思って
結局次期JavaScriptに静的型付けが入るのかどうか気になったんだよ

静的型付けをそのまま含めたら、ほとんどaction scriptだよね

TypeScript part1
http://toro.2ch.net/test/read.cgi/tech/1349187527/

JavaScriptコードはすでにTypeScripttコードです
http://toro.2ch.net/test/read.cgi/tech/1349488930/

>>127
統計が必須になる層はJSなんて弄りません

>>126
ゲーム関連のお給料がいいなんて話は聞いたことがないけど…
モシモシのことならあれはwebサービスだからね
>>131
統計が必須になるような層の人は実際コンピュータには無知な人が多いような…

a

>>130
おいおい、このスレでJavaScriptのことを話題にしてもいいだろ

html最強

動的言語は罪深い

オープンソースなのに情報が少ないから結局クローズドソース
動的だから変更のたびに　チェックと確認が必要　
ローカル開発→開発サーバー→ステージング→本番　順番に確認作業が必要
仕様変更のたびにこれを毎回やる
実行しないとバグがわからないから　クラス・関数がどこかで参照されているか明らかにする必要がある
ドキュメントが大量に必要　しかも仕様変更のたびにドキュメントの変更も必要　
この場合ドキュメントにもバグが混入する　大規模開発だと必ずこんがらがる
FWはバージョンアップのたびに別物に生まれ変わり　互換性がなく　今までのソースは動かない　
動作しているものから不具合を探さないといけない　また学習しないといけない
新しいＦＷがしょっちゅう出てきて　それがデフォルトスタンダードのようにはてぶなどで宣伝工作される


実行しないとバグがわからない動的言語は過去のライブラリを使うのをためらう
結局過去の資産を生かせない　関数の名前の変更のたびに
ソース検索が必要で手間がかかる　これが静的言語だったらエラー吐くから　
確認作業はローカル開発内で収まることが多い　動的は作れば作るほどシステムが負債化していく　
作った後はまた新しいものを作った方が早いという結論になることが多い
どうしようもない動的言語を流行らそうとするはてぶをはじめ技法やCodeZine、アシアルは本当に罪深い

結局これは短期記録力がある人間の驕りなんだよね。（東大とかアシアルとか）
彼らは自分たちの記憶能力を生かしたいがために
ガラクタ言語をチョイスしてそれをスタンダードのような流れにしたいと思っている
このガラクタ言語を使うことで短記録のある自分たちが有利であることを知っていて　
他を蹴落としたいと潜在的に思っている。はてぶとかで工作してくる
静的言語を使えば（主にＣ＃）こんな苦労なんて全然ないのに　
それでは自分たちが存在意義が問われるからあえて使わないようにしている
いい加減こんなガラクタ言語やっていても無限に苦労することなる

動的言語はやめとけ無限に苦労することになる　書けば書くほど大変になる
記録力のあるやつだけやつしか現場に残らない　記録に止めないといけないことが
多すぎる　VisualStudioやC#だったらバグ、リファレンスエラーが教えてくれる　
リファクターで容易に関数名を変更ができる
動的言語に比べてはるかに短い時間で安全確実にプログラムを完成させることができる

見えない地雷で身動きのとりづらい言語だからMVCで思考を統一するしかなかった　
だから現場は北朝鮮みたいな思考統制が進み　ロボット人間だけが残る　
組織は硬直し　ルールーこそ人の上に立つ存在だと考える頭のおかしいロボット人間がでてくる
そこは自由な思想・行動も否定され　愚かなルールを誰が破るか密告することを楽しみとする　潰しあいの世界が出来上がる

いつの時代も、社会や国の負荷がモロにかかる職種ってあるよな

御題

"3 19 + -2 /" という文字列入力に対し-11を返すような
逆ポーランド電卓関数を書け

・四則演算をサポートすること（さらに、演算セットは入れ替え可能なこと）
・不正な入力に対しては例外・nullなどを返すこと

11 3 19 + -2 / +
のときはどう動けばいい？

0を返す

なんか書き方が教科書的すぎて
言語間の優劣とかの話にはしづらい気がするが
Ruby1.8系

require 'strscan'

def lex(str)
s = StringScanner.new(str)
tokens = []
until s.eos?
if s.scan(/-?\d+/)
tokens << [:num, s.matched.to_i]
elsif s.scan(Regexp.union("+", "-", "*", "/"))
tokens << [:op, s.matched]
elsif s.scan(/\s+/)
# do nothing
else
raise "illegal input"
end
end
tokens
end

def evaluate(tokens)
stack = []
until tokens.empty?
t = tokens.shift
case t[0]
when :num
stack.push(t[1])
when :op
command = t[1]
op1 = stack[-2]
op2 = stack[-1]
stack = stack[0 .. -3] << eval(op1.to_s + " " + command + " " + op2.to_s)
else
raise "internal error(must not happen)"
end
end
stack[0]
end


def calc(str)
tokens = lex(str)
result = evaluate(tokens)
puts result
end

calc("3 19 + -2 /")

d = {}
def add(a):
    a[-2] = a[-2] + a[-1]
    a.pop()
d["+"] = add
def div(a):
    a[-2] = a[-2] / a[-1]
    a.pop()
d["/"] = div
a = []
for s in input('?').split():
    if s in d:
        d[s](a)
    else:
        a.append(float(s))
print(a)

御題は全部自分で作るから良いよな
自分で作った物が一番記憶しやすいし
仕様を変える時期もコントロールできるし責任の擦り合いもない

全部自分で作ることが悪いみたいに宣伝されるのが不可解だ

条件後出しでも怒られないし
勝手に仕様変えるのも
自分に都合の良い解釈するのも
全部自由
まるで森口

>>140は特に動的言語向けの御題じゃないな
別に動的型もevalも使う必要無いし

ただし>>137-138のような低能には無理。静的動的関係なく

デフォルトスタンダード君がにも来たか

C#のコードまだ〜？

PHPってもともと「PHP」などの雑誌ビジネス書人文社会科学書を発刊していた出版社
ちょっと目を逸らしたらWeb用CGI言語がメインでけっこう大きな勢力になっていたので驚いた

Perlっていいなまえですね！　おそらくPerl言語のPerlだけ一致するだろう。
PHP, Ruby, Pythonは、Googleで検索したら余計なものも一致する

ム板終わったな。キチガイは死んでろ

ネタ
http://news.tv-asahi.co.jp/ann/news/web/html/221013022.html

グロ注意

>>153
まずおまえがきえろ

>>140
Rubyによるもう一つの実装
http://play.island.ac/codepaste/code?id=24

>>140
何から何まで横着してみた@PowerShell

function calc ([string]$s) {
do {
$a = -Split $s
$b = iex ("{0}{1}({2})" -f $a[0],$a[2],$a[1])
$s = (@($b) + $a[3..$a.Count]) -join " "
} until ( [double]::TryParse($s, [ref]$null) )
return $s
}

calc "3 19 + -2 /"

入力によっては例外出し続ける

Haskell
なんとか1レスに収まった


import Control.Monad
import Control.Applicative

calcRPN fs s = do
  [result] <- foldM f [] $ words s
  return result
  where
    f = foldr (\f g xs s -> f xs s <|> g xs s) push fs
    push xs s = (:xs) <$> case reads s of {[(x, "")] -> Just x; _ -> Nothing}


infixMaybe op a (y:x:xs) b | a == b = Just $ x `op` y : xs
                           | otherwise = Nothing
infixMaybe _ _ _ _ = Nothing

add = infixMaybe (+) "+"
sub = infixMaybe (-) "-"
mul = infixMaybe (*) "*"
fdiv = infixMaybe (/) "/"

main = print $ calcRPN [add, sub, mul, fdiv] "3 19 + -2 /"

実装方針が色々あって面白いな
golfみたいに短さ優先で書いたり、小さな言語処理系みたいに書いたり

ときどき実装方針にまでケチつける出題者いるけど
そういうのは多様性が無くなってツマラン

型チェックをザルのように通り抜けForthに落ちていく様子をご覧下さい

クラウド（笑）の次はnode.jsやら、JavaScript関係のバズワードで攻めるようだね
ひとつ言ってやるけど、
世界規模の自然災害や、戦争でも起こらない限り、
今までやってた常識がある日突然に覆る事は無い
常識が覆るペースは非常に遅い
なのでその「常識」を覆している最中に、
もっと良い物が出てくる可能性がITにおいては多々ある
どこに始まってもいないJSに未来を見れるのだろうか

>>162
どんな入力値をいれたら鼻から悪魔が出たの？

>>163
クラウドにスマホ、html5といったイノベーションが起こったよ
これで、これまでの常識が変わったと思わないなんて、よっぽど狭い世界で生きてんだろうな

>>137
わざわざドキュメント書くアホなんて、大手で大卒雇ってるアホ連中だろwwww

どこを見たってjsだけだよw
railsホスティングサービスやruby2.0なんて出だしでこけた感しかない

ドキュメント残さないヤツは糞だろ
一人で仕事してるようなヤツじゃなければ普通書く
キッチリ書くかザックリ書くかは規模による

コードに書かれたコメントを見ることはあってもドキュメントを見ることなんてないな
わざわざexcelにドキュメント残すって、コードとドキュメントに整合性とれないだろｗ

ザックリしたドキュメントってのは
「こうあるべきだよな」
っていうのを書くのであって
コーディングの内容書くわけじゃないんだぞ
整合性取れないって…

クラウドといえばAmazon Elastic MapReduceにRuby, Perl, PythonはあるがJSは無いよ

herokuがやってるからイラナイよ
それよか、railsのホスティングサービスw

azureでも動くな。amazonからは負け犬臭がする

herokuでmapreduceって何の話だよ。自分でHadoopセットアップすんの？
azureでのmapreduceはF#しか使えない上にamazonより面倒くせぇ

Debian "Wheezy" で自分の"クラウド"を展開
ttp://www.debian.org/News/2012/20120425

>>140
"1 2 3"的なバグッた式でも正常終了して値を返す
腐ったプログラム書いてる奴ばっかだな。
こういうのも静的チェックで捕まえられると良いんだが。

>>176
もし100万行書いた後でそうなら腐ったと言ってもいいよね
しかし数十行ではどうだろう
怠惰かもしれないが腐敗ではないと思う

最終状態のスタックトップを答えとする仕様もありえるから、
明らかに不正とも言い切れない

型チェックは減点法のようなものなので短いコードが大量に減点されることはない
がんばって書いた量に比例してチェックが厳しくなる

typescript最強ですね。わかります。

>>140
Squeak Smalltalk で。かなり手抜きだけど。

((Scanner new scanTokens: '3 19 + -2 /')
   inject: OrderedCollection new into: [:stack :elem |
      (elem isKindOf: Number)
         ifTrue: [stack add: elem]
         ifFalse: [stack add: ((stack atLast: 2) perform: elem with: (stack removeLast: 2) last)].
      stack]) last "=> -11 "

素晴らしいね

そこにスタックに積んだ数字を全て足す"sum"や
exp(x)を返す"exp"を後から追加できると
ポイント高いよ

こういうこと？

((Scanner new scanTokens: '5 4 - exp 3 -2 1 sum')
   inject: OrderedCollection new into: [:stack :elem |
      stack add: (true caseOf: {
         [elem isKindOf: Number] -> [elem].
         [(Number selectors includes: elem) and: [elem numArgs isZero]]
            -> [stack removeLast perform: elem].
         [(Collection selectors includes: elem) and: [elem numArgs isZero]]
            -> [(stack removeFirst: stack size) perform: elem]}
         otherwise: [(stack atLast: 2) perform: elem with: (stack removeLast: 2) last]).
      stack]) last "=> 4.718281828459045 "

i も受け付けるけど数値でなく関数扱いなのはご愛敬。リファクタってちょっとすっきり。

((Scanner new scanTokens: '5 4 - i exp 3 2 - cos - 1 sin i - 2 3 4 sum sqrt')
   inject: OrderedCollection new into: [:stack :elem |
      stack add: (true caseOf: {
         [elem isKindOf: Number] -> [elem].
         [(Number selectors includes: elem) and: [elem numArgs isZero]]
            -> [elem value: stack removeLast].
         [(Collection selectors includes: elem) and: [elem numArgs isZero]]
            -> [elem value: (stack removeLast: stack size)]}
         otherwise: [(stack removeLast: 2) reduce: elem]).
      stack]) last "=> 3.0 + 0 i "

>>159に>>182を追加

extension (x:xs) "sum" = Just $ [sum (x:xs)]
extension (x:xs) "exp" = Just $ exp x : xs
extension _ _ = Nothing


> calcRPN [add, sub, mul, fdiv, extension] "5 4 - exp 3 -2 1 sum"
Just 4.718281828459045


http://ideone.com/5fqag

TypeScript、凄くいいね。もうこれで決まりだわ。

静的型付け言語は書き直しがダルいから
最初から拡張性あるように組む必要があって、
動的型付け言語は状況に応じてバンバンコード書き変えて、
行き当たりばったり上等！って感じ

上のSmalltalkとHaskellのコードに良く現れてる

C++の拡張をあきらめたからJavaがあるのだぞ

>>181,185
いいぞ、もっとやれ。昔に見た流れだ。
それで沢山の大学生たちを地獄に落としてやれ

タイプスクリプトまだテクニカルプレビューだぞ？

短く書こうとするとどんどん言語関係なくなるなー
function calc ($s) {
$a = -split $s
for ($($i=2; $s=$a[0]); $i -le $a.count; $i+=2)
{ $s = "($s)$($a[$i])($($a[($i-1)]))"}
iex $s
}

calc '3 19 + -2 /'
>> -11

5000行ぐらいの長い関数があるのですが、
その内の一部を選択して、コマンド打つだけで
正確に関数に抜き出してくれるツールはありませんか？

LL言語用のものならなんでもいいです。
正確ってことが重要なので、それにより動作が
変わってはだめです。

>>192
自分で作るが良い

5000行の関数書くようなクズを助けたがるプログラマなんているわけがねぇ

>>191

>>140には「演算セットは入れ替え可能なこと」ってあるから
'/'の振舞いをdivからquoに変更して、
数は整数以外はエラーになるよう変えてみたら？

その修正にどの程度書き換えが必要かで
言語の特徴も見えてくるんじゃない？

>>157のRuby実装をアップデートしてみた
　http://play.island.ac/codepaste/code?id=25

ninjaの元ネタってニューロマンサーかな？

>>195
> 数は整数以外はエラーになるよう変えてみたら？

LLは(動的型言語は)こういう制限かける方向は苦手。
間違った入力する奴が悪いってスタンスだから。

Squeak Smalltalk を、前のよりまじめに仕様に従ったかんじで整えてみた。

| RPNcalc |
RPNcalc := [:str |
   | tokens mathOps stackOps stack detectSymFrom |
   tokens := Scanner new scanTokens: str.
   mathOps := {#(+). #(-). #(/ quo:). #(*). #(exp)}.
   stackOps := {#(sum). {#prod. [:xs | xs reduce: #*]}}.
   stack := OrderedCollection new.
   detectSymFrom := [:sym :ops | ops detect: [:pair | pair first = sym] ifNone: []].
   tokens do: [:tok |
      | result |
      tok isInteger ifTrue: [result := tok].
      (detectSymFrom value: tok value: mathOps) ifNotNilDo: [:pair |
         result := pair first numArgs caseOf: {
            [0] -> [pair last value: stack removeLast].
            [1] -> [(stack removeLast: 2) reduce: pair last]}].
      (detectSymFrom value: tok value: stackOps) ifNotNilDo: [:pair |
      result := pair last value: (stack removeLast: stack size)].
      result ifNotNil: [stack add: result] ifNil: [self error]].
   stack last
].

RPNcalc value: '3 19 + -2 /'. "=> -11 "
RPNcalc value: '11 3 19 + -2 / +'. "=> 0 "
RPNcalc value: '1 2 + 3 4 5 sum'. "=> 15 "
RPNcalc value: '5 4 - exp'. "=> 2.718281828459045 "
"RPNcalc value: '1 2.0 +'. => Error "
RPNcalc value: '12 5 /'. "=> 2 "
RPNcalc value: '2 3 4 prod'. "=> 24 "

スマホやブラウザをjs+html5で弄れる時代のsmalltalkerって、
ガンダムエンジンをこさえているテム・レイ的な哀愁が背中に漂ってるよね。
父さん、こんな古いものを…

jsに言われちゃな

>>165 >>167
つかそれ以前に、これだけ使われに使われまくってるjavascriptを
逆説的でもなく本気で「始まってない」と評してるあたり、
この人間の意見は聞く価値もがない

昔始まり、やがて時代遅れとなり、隠居しようとしたら
老人ホームから連れてきてサイボーグ化された

始まるっていうのは、ようするにスタートのことだよ。
マラソンで折り返し地点にいるのにスタートするとは言わない。

始まるというのは、使われてない状態からスタートしたばかり時のこと。

故に、普及しているものは、始まっていない。

今のLLで書けば>>199はもっと短く書けるの？　誰か翻訳して！

jsだと8割くらいになる

特定の分野なら短く書ける言語を
DSLという。

短くかけると評判のpythonではどうなるかね？

>>208
js厨乙

特定の問題を解決するのに短くかけたからといって
違う問題でも短く書けるとは限らないんだよな。

とりあずRubyに直訳（一部意訳）したので添削・スリム化は頼む

class Object; def integer?; false end end
def scan_tokens(str)
str.split(" ").map{|s| case s; when /^-?\d+$/; s.to_i; when /^-?\d+\.\d+$/; s.to_f else s.to_sym end}
end

def rpn_calc(str)
tokens = scan_tokens(str)
math_ops = [[:+], [:-], [:/], [:*], [:exp, Math.method(:exp)]]
stack_ops = [[:sum, ->xs{xs.inject(:+)}], [:prod, ->xs{xs.inject(:*)}]]
stack = []
detect_sym_from = ->(sym, ops){ops.detect{|pair| pair.first == sym}}
tokens.each{|tok|
result = tok if tok.integer?
if pair = detect_sym_from[tok, math_ops]
result = case pair.last
when Method, Proc; pair.last[stack.pop]
when Symbol; stack.slice!(-2,2).inject(pair.last)
end
end
if pair = detect_sym_from[tok, stack_ops]
result = pair.last[stack.slice!(-stack.size, stack.size)]
end
result ? stack << result : raise
}
stack.last
end

p rpn_calc('3 19 + -2 /') #=> -11 "

smalltalkとRubyがあまり変わらない件
直訳だからそうなるのか

>>159のfdivを置き換え

ndiv = infixMaybe div "/"


> calcRPN [add, sub, mul, ndiv] "1 2.0 +"
Nothing
> calcRPN [add, sub, mul, ndiv] "12 5 /"
Just 2


ghcでコンパイルするときは-XNoMonomorphismRestrictionがいるかも

ここまでC#もJavaScriptも無し

その手の言語の中ではSmalltalk良いよね

ラピッドラピッド五月蠅いjs厨が
今必死で超級ラピッド開発してるから
正座して待ってろ

+　　　+
　 ∧＿∧ 　+
　（0ﾟ・∀・）　　　ﾜｸﾜｸﾃｶﾃｶ
　（0ﾟ∪ ∪ +
　と＿_）__）　+

0 + '' + [] + {} + function(){return 0;};

こんだけ型の違う値を足しても実行時エラーすら出ないJSで
ラピッド開発とかマゾなの？

# Python 3.x 入力は整数のみ、無入力は 0
import operator, sys
ops = {'+': operator.add,
   '-': operator.sub,
   '*': operator.mul,
   '/': operator.floordiv,}
def rpm(line):
  stack = []
  for elm in line.split():
    if elm in ops:
      try:
        y, x = stack.pop(), stack.pop()
      except IndexError:
        raise ValueError
      try:
        stack.append(ops[elm](x, y))
      except ZeroDivisionError:
        raise ZeroDivisionError
    else:
      try:
        stack.append(int(elm))
      except:
        raise SyntaxError
  if len(stack) == 0:
    return 0
  elif len(stack) == 1:
    return stack[0]
  else:
    raise ValueError

print(rpm('3 19 + -2 /')) #=> -11

ごめん、sysのimportは必要ないや

>>219
一度例外を捕まえてから
同じ例外をraiseするのは
何か意味があるの？

もしかして
どんな厳しいチェックをしてもここで assert y!=0 を保証するのは不可能という意味なのか

整数用と実数用でコード共有できてるHaskellさんは偉い
さすが関数記述用DLSやで

ダイビングロングシュート？

>>224
デビルライトソードじゃね？

http://www.disney.co.jp/records/DLS/

ﾖｶﾞﾌｧｲｱ

それにしても皆ほんとまじめに書くな、お兄さんびっくりだ

>>196を更にアップデート
http://play.island.ac/codepaste/code?id=26

主な変更点:
・計算結果(スタックの先頭値)を変数へ保存/参照できるようになりました
　ワード(演算子)は ! で、構文は「<expr> <symbol> "!"」です
　　001> x
　　**** ERROR **** Illegal input: 'x'　　# 変数 x はまだ定義されていない
　　001> 1 2 + :x !　　# 式 1 2 + の計算結果を変数 x へ保存
　　==>
　　002> x　　# 変数 x を参照
　　==> 3　　# (今度はエラーとならず、) x の値がスタックに積まれる
　　003>
・空白等を含む文字列リテラル "..." および記号リテラル :sym をサポート
・スタックの表示書式を切り替えるワード debug と nodebug を追加

>>228
>>229以外はそんなに真面目でも無いと思う

こいつらホントに遅いな。
js版は音声認識に対応して
今は駅前でテスターを募集している

JSプログラマはコードは書けないが妄想は書ける

>>231
俺のjsは尻文字の入出力を実装した
ケツ同士でのやりとりが出来る

>>233
俺のjsはハイブリットにした。
3と19の間に「次」と言う事で
319と区別できる

>>206はたかが20行程度のコードを書くのに
一体何時間かかるの？>>199の8割で書けるんでしょ？

>>235
ラピッド開発は早けりゃ良いってもんじゃない

やっぱり動的型ではSmalltalk, 静的型ではHaskellが現時点で最強だな

古いほうが勝つわな
家柄的な意味で

コードは実力、言語は人気

LLって存在意義ねーなー

Haskellはともかく、Smalltalkには負けたくない

この手のお題でSmalltalkに勝つのは難しいと思うぞ

よく似た粒度のお題200個くらい解かせて平均したら短さダントツだった
http://cast-a-spell.at.webry.info/201001/article_7.html

>>240
意義があってもなくても使わなければゼロオーバーヘッドだから許される
と言い出したやつが今の世界をつくったと思う

200題てどんだけ暇人だよ

Smalltalkって>>184>>199のように各行みっしり詰まったコードになりがち
単純に行数少ないからコード量少ないとは言えない感じ

(defun rpn (string)
  (loop with operators = '(("*" . *)
                           ("+" . +)
                           ("-" . -)
                           ("/" . /))
     with place
     for start = 0 then (1+ end)
     for end = (or (position #\ string :start start)
                   (length string))
     for operator = (cdr (assoc (subseq string start end) operators :test #'equal))
     do (push (if operator
                  (apply operator (reverse (list (pop place) (pop place))))
                  (parse-integer string :start start :end end))
              place)
     until (= end (length string))
     finally (if (= (length place) 1)
                 (return (pop place))
                 (error "~S is not a valid argument to RPN." string))))

(rpn "3 19 + -2 /")

sum等の2項演算子じゃない演算に対応してなく、
整数実数両対応でもないコードを
いまさら上げる心意気に感動した

お前それsigned/unsigned両対応でも同じ事言えんの？

>>247
いいじゃん。いろいろ出てきたほうが楽しいから
もっとも、こんなんで Common Lisp は短く書けるドヤ！とか主張しだしたら叩くけど

>>246をSqueak Smalltalkに超訳してみたｗ

| rpn |
rpn := [:string |
   | stream operators place |
   stream := string subStrings readStream.
   operators := {#* -> #*. #+ -> #+. #- -> #-. #/ -> #//} as: Dictionary.
   place := OrderedCollection new.
   [stream atEnd] whileFalse: [
      | next |
      place add: (operators at: (next := stream next)
         ifPresent: [:op | (place removeLast: 2) reduce: op]
         ifAbsent: [next asInteger])].
   place size = 1
      ifTrue: [place removeLast]
      ifFalse: [self error: string, ' is not a valid argument to RPN']].

rpn value: '3 19 + -2 /'. "=> -11 "

Lispの真価は、10個以上の異なる問題を、どの問題でも使っていいような
共通ルーチンの作成を許して解かせるようなソースコードで
発揮されると聞いたことがある。
ただし、確認してみたことはない

>>250からのRuby

class Enumerator; def end?; (peek; false) rescue true end end

def rpn(string)
stream = string.split(" ").each
operators = {"*"=>:*, "+"=>:+, "-"=>:-, "/"=>:/}
operators.default_proc = ->(_,k){ k.to_i }
place = []
until stream.end?
tok = operators[stream.next]
place << (tok.kind_of?(Symbol) ? place.slice!(-2,2).inject(tok) : tok)
end
if place.size == 1
place.shift
else
raise "#{string} is not a valid argument to RPN"
end
end

p rpn('3 19 + -2 /') #=> -11

>>211 >>252
インデントすらつけないで2chにソース投稿してる奴は死ねよ
何年2chやってんだ？
ソースに＆んｂｓｐ；付与するスクリプトくらいさっさと作れカス

>>248
いわゆるC言語のunsigned intに対応


import Foreign.C.Types


> calcRPN [add, sub, mul, ndiv] "1 2 -" :: Maybe CUInt
Just 4294967295


http://ideone.com/zcxWmv

gawk
http://ideone.com/kwrjvK

(defun rpn (string)
(loop with operators = '((* * 2)
(+ + 2)
(- - 2)
(/ / 2)
(sin sin 1)
(cos cos 1)
(sqrt sqrt 1)
(exp exp 1)
(sum + all))
with place
for start = 0 then (1+ end)
for end = (or (position #\ string :start start)
(length string))
for atom = (read-from-string string t nil :start start :end end)
for (nil operator number-of-operands) = (assoc atom operators)
when (eq number-of-operands 'all)
do (setf number-of-operands (length place))
do (print atom)
do (push (cond (operator
(prog1 (apply operator
(nreverse (subseq place
0 number-of-operands)))
(setf place (subseq place number-of-operands))))
((numberp atom) atom)
(t (error "~S is not a valid argument to RPN." atom)))
place)
until (= end (length string))
finally (if (= (length place) 1)
(return (pop place))
(error "~S is not a valid argument to RPN." string))))

253 ：uy：2012/10/22(月) 05:56:21.86
>>211 >>252
インデントすらつけないで2chにソース投稿してる奴は死ねよ
何年2chやってんだ？
ソースに＆んｂｓｐ；付与するスクリプトくらいさっさと作れカス

他LLからSmalltalkに移行 => エディタやDVCSなど全環境を捨ててSmalltalk独自環境へ引っ越し

結論: そこまでのメリットがSmalltalkに無い

最強の環境を選べなかったやつらは死滅するという設定なので
環境は捨てるものではなく滅ぼされるもの

滅びた環境なんてまず無いｗ

Smalltalkには別に移行する必要なんかはないんだよ
ちょっとそこで過ごしてみさえすれば
精神と時の部屋みたいなもんで
たとえごく短時間でもちゃんと鍛錬しさえすれば
出てくるときには戦闘力が上がっている

>>256
なんでSETFなの？

http://www.geocities.jp/m_hiroi/xyzzy_lisp/abclisp01.html
データをセットするには setf または setq という関数を使います。
Common Lisp では setf を使うことが推奨されていますが、
M.Hiroi は古い人間なので setq を好んで使っています。
皆さんは setf を使ってくださいね。

>>261
そういう「使ったらレベルアップする」系の話は
関数型言語では良く聞くけど、Smalltalkでも成り立つの？

そりゃ何でも新しい言語の習得中は、何かしらの「レベルアップ感」はある

丸暗記系ではレベルアップ感がないという人もいる

まあSmalltalkなんざぁ、言語としては最もシンプルな部類のもんなんだから、
レベルアップとかそうしゃっちょこばらずにほんの５分でも触ってみたらいいと思うんだよね
http://amber-lang.net/learn.html

そりゃXEROX直系由来の環境とかライブラリとかやっかいなのも色々あるかもしれんけど、
とりあえずは一番大事な「メッセージング」っていう唯一のドグマに納得できてからでも遅くないというか

興味無いことがレベルアップしても仕方ないんだよね
むしろ邪魔

君らって言葉が幼稚だよね

XエXロX

同じ意味の言葉が二つあって少なくとも一方は幼稚だとしたらどうしますか
1. 一つしかなければ幼稚にならないから一つにする
2. 気がすむまで新しい言葉を作る

3.幼稚の定義を振り返る

大切なのは幼稚より中身

7点

>>267
5分も触ったらメッセージングなんて
わざわざ構文でサポートする程のモンじゃないって
分かってしまうよね
それを言語のコアに据えるSmalltalkが時代遅れの骨董品ってこともね

Schemeは時々[]を使うようだが、物凄くどうでもいい用途に使ってるよな
なぜlambdaを[]にしないのか理解できない

まあHaskell使っとけってことだ

>>275
あれってメッセージングなの？たんなる動的呼び出しだろ

動的呼び出しごときで「ドグマ」とか言い出しちゃうSmalltalkerって...

呼び出しで括弧を書かないためにセレクタを書いてるんだろ
セレクタも括弧も両方書く言語はLispと同じかそれ以上に酷い
Haskellの方がまし

Lispに酷いって括弧の量のこと？
あんなもんただの慣れだぞ
慣れるとむしろ優先度とか余計なこと考えなくていいから読みやすい

まあLisp時代に戻れば多言語とか余計なこと考えなくてよいよね

>>278
メッセージングは方便だよ。
本質はできるだけ多くの事（呼び出しも含め）を動的（遅延結合）にすること。
それを貫くことで、ソフトウエアを停止させずに、長く、必要なら部分を変化・置き換えつつ
運用し続けることが可能だって示すところがSmalltalkで示したかったこと…ってアラン・ケイも総括している。
http://squab.no-ip.com/collab/uploads/61/IsSoftwareEngineeringAnOxymoron.pdf

そんなことあらんけー

ここから濃厚なプログレスレ

セレクタとメソッドの関に一枚噛ませたって感じだわな。

箱庭に閉じこもってOS含む外の環境が無いふりをするなら
動き続けることは難しく無いわな

MessageNotUnderstood: UndefendedObject>>275
我々はか弱い。 だからあまりいじめるな

なんで、スマホやタブレットPCが普及したのにダイナブックじゃないんですかー。
やぁだぁーーーーーーー

そんなに普及したいか？
自転車でいうとママチャリだぞ

T型フォードくらいには言ってくれ

http://web.archive.org/web/20090208073444/http://itpro.nikkeibp.co.jp/a/it/alacarte/interview0703/alan_9.shtml
私の少年期を過ごした農場には、T型フォードが数台あった。1920年代のしろものだ。
それも本物の自動車にも関わらず、たった数百個の部品でできていた。
だから12歳の子供でも、週末に友達と一緒に、自動車全体を分解し、
それを元通りに組み立て直すことも可能だった。ところが現代において、
そんなことはありえない。自動車には数百万個もの半導体が組み込まれている。
トランスミッションのシステムも極めて複雑化している。
ちょっと改造してみようと思っても、自動車の原理全体を学ぶことは容易ではない。

これは世の中の進歩にとって重大な問題だと考えている。子供たちが、
大人の世界から隔離されかねない。こうしたテクノロジーへの関心が急速に
冷めているのも理解できる。

Inventing Fundamental New Computing Technologies
http://www.viewpointsresearch.org/html/work/ifnct.htm

STEPS プロジェクトご紹介その２
http://d.hatena.ne.jp/propella/20111022/p1

関心を持つ必要がないものを隔離すればその労力が他の適切な分野に供給されるはずだ
ということで隔離してるんだけど
壁を作って隔離してみたら、壁自体に興味を持ってトンネルを掘る子供が増えたりして

骨董品の話しはもういいからさー
コード出してくれよ。コードを

問題

"3 19 [ + -2 / ] $" という文字列に対し
配列 ['3', '19', ['+', '-2', '/'], '$'] を返すような関数を書け
入れ子の深さは制限しないこと

宿題は自分でやれ

s = "3 19 [ + -2 / ] $"
s.split.inject([[]]){|m, t|
  case t
  when "["; m << []
  when "]"; m[-2] << m.pop
  else m.last << t
  end
  m
}.first #=> ["3", "19", ["+", "-2", "/"], "$"]

もう全部evalひとつでいいんじゃないかな

$str = "3 19 [ + -2 / ] $" -replace "\s", "','" -replace "'\[',", "(" -replace ",'\]'", ")"
iex "'$str'"

import Control.Applicative ((<$>), (*>), (<*))
import Text.Parsec
import Text.Parsec.String

data Tree a = Leaf a | Node [Tree a] deriving (Eq, Ord, Show, Read)

tree, node, leaf :: Parser (Tree String)
tree = (char '[' *> node <* char ']') <|> leaf
node = Node <$> sepBy (spaces *> tree <* spaces) spaces
leaf = Leaf <$> many1 (noneOf " []")

main = parseTest (node <* eof) "3 19 [ + -2 / ] $"

>>229を、またまたアップデート
　http://play.island.ac/codepaste/code?id=27

主な変更点:
・データ型として配列をサポートし、その操作ワードもいくつか追加しました
　　[1 2 3] ary-length ==> 3　# 配列の長さ
　　[[:a :b] [:c :d]] ary-concat ==> [:a :b :c :d]　# 配列の連結
・ワードの塊を無名手続きであるブロックで表現できるようになりました
　　[1 2 3] { 10 * } ary-map ==> [10 20 30]　# 配列上の写像
・ブロックをワード ! (>>196)を使って記号と束縛することで、手続きを定義できます
　　{ :x ! :y ! x y x y > cond } :max !　# 手続き max を定義
　　1 3 max ==> 3　# (他の組み込みワードと同様に)ユーザ定義ワード max もコールできる
　ただし、手続きは再帰的に定義できないので、計算体系としては不完全です

なお、規模が1Kstepを超えて全体の把握がしづらくなってきたので、文書化してみました
　http://www.h6.dion.ne.jp/~machan/tmdoc/example/RPN.book/html/

| string modified |
string := '3 19 [ + -2 / ] $'.
modified := {'''[''' -> '('. ''']''' -> ')'}
   inject: string subStrings asString
   into: [:str :assoc | str copyReplaceAll: assoc key with: assoc value].
(Scanner new scanTokens: modified) first   "=> #('3' '19' #('+' '-2' '/') '$') "

括弧の数が合わないのにエラーも出さず
しれっと終了するプログラムには苦笑を禁じ得ない

>>295
gawk
http://ideone.com/XxvD6l

gawkにも完敗のRubyとSmalltalk

この程度なら無理にロジック考えんでも引数を配列リテラルに組み直してevalで十分だと思うんだけど
皆頑張るねぇ

適当に変換してevalが悪いとは全然思わないが
例えば "3 19 [ + -2 / ] $ (4)" が
['3', '19', ['+', '-2', '/'], '$', [ '4' ]]
を返したりするのはアウト

>>302
構文解析はコンパイル時だから、実行時よりも気が楽だな
旅の恥はかき捨て

言語の記述力比較が目的だとすれば、ある程度似せたアルゴリズムにする必要があるんじゃないの？

>>306
空白だけ弄るようにすればなんも問題ないよ
引用符で空白を囲んでる場合は別対応、とかなら他の解含めて書き直しだけどね

[や]の前後に空白開けてるのがダセェ
eval方式なら不要

そんなことを言ったら空白必須、改行推奨のbegin end方式はどうなるのか
{}も改行が多いし

Rubyの>>297をSqueak Smalltalkで

| string |
string := '3 19 [ + -2 / ] $'.
(string subStrings inject: (OrderedCollection with: OrderedCollection new) into: [:vec :ss |
   ss caseOf: {
      ['['] -> [vec add: OrderedCollection new].
      [']'] -> [(vec atLast: 2) add: vec removeLast asArray]}
      otherwise: [vec last add: ss].
   vec]
) first asArray   "=> #('3' '19' #('+' '-2' '/') '$') "

# Python + pyparsing
from pyparsing import *

INT = Combine(Optional(Word("+-")) + Word("123456789"))
ATOM = INT | Word("+-/", max=1) | "$"
LIST = Forward()
VALUE = ATOM | LIST
LIST << Suppress("[") + Group(ZeroOrMore(VALUE)) + Suppress("]")
INPUT = OneOrMore(VALUE)

print INPUT.parseString("3 19 [ + -2 / ] $")
#=> ['3', '19', ['+', '-2', '/'], '$']


Rubyのtreetopやparsletで書いたのも見てみたいとリクエストしてみる

# python
def nest(s):
    a,x,xs = s.split(),0,[]
    while x < len(a):
        if a[x] == '[': xs.append(x)
        if a[x] == ']':
            a[xs[-1]:x+1] = (a[xs[-1]+1:x],)
            x = xs.pop()
        x += 1
    return a
print(nest('3 19 [ + -2 / ] $'))

>>297をperlで
use 5.016;
use warnings;
use Data::Dump qw(dumpf);

sub parser {
    my @r = ([]);
    foreach(split /\s+/, shift) {
        given($_) {
            when('['){ push @r, [] }
            when(']'){ push @{$r[-2]}, pop(@r) }
            default{ push @{$r[-1]}, $_ }
        }
    }
    dumpf($r[0], sub{ $_[0]->is_scalar ? {dump => "'${$_[1]}'"} : {} });
}

parser('3 19 [ + -2 / ] $');

perl Parse::RecDescent使用
use 5.016;
use warnings;
use Parse::RecDescent;

my $parser = Parse::RecDescent->new(<<'EOF') or die;
list: '[' item items ']' { $return = join('', @item[1..$#item]) }
items: item(s?) { $return = join('', map{ ", $_" } @{$item[1]}) }
item: id | list
id: /-?(?:0|[1-9][0-9]*)|[-+\/*\$]/ { $return = "'$item[1]'" }
EOF

sub parser { $parser->list("[ $_[0] ]") || "error" }

say parser('3 19 [ + -2 / ] $');

メジャーな言語にはパーサライブラリがあるから
この御題じゃ差が付かないな

パーサライブラリ使ってる回答の間で差というか違いは出てるよ
>>299,313は内部DSLだけど>>316はflex風の外部DSLだし

外部DSLは、GPL等のライセンスの問題を回避しやすい

Perl自体には内部DSLを作れるだけの表現能力がある気がする

もっと動的型や遅延結合を活用できる御題じゃないと
LLである必要がないね

>>320
能力というと持ち主がいるみたいだけど
その力がその人の内部にあるか外部にあるか考えてもあまり良いことはない
もし必要がない能力だったら持ってる人は損した気分になるかもしれない
重要なのは内か外かではなく使いたい時にいつでも使えるかどうか

使いたいときにいつでも使えるなんて条件だと、
posix準拠なsh,awk,sedかjs、或いはcぐらいしか選択肢がない

jsが載ったwebブラウザが走る環境なら
大抵の言語は動くと思うが

rubyは真っ先に外れるな

つーかrubyはもう滅んでくんないかな

饅頭こわいからもう滅んでって言うと饅頭を無償でもらえるんだよね
無償こわいよ無償

>>324
想定する環境だと、この辺がネック
linuxやunixでの古典ツールの動作の微妙な違い
客先常駐時にrubyやpythonの処理系を用意できるか
新しい組込み機器の処理系がcコンパイラしか用意されない

jsで動くRuby/Python作ればいいんじゃね？

js自体は、ほとんど何処の環境にでもある。が、js処理系に互換性あるのか？

ダーティに弄れるjsで、規約やツールレベルでOOPや大規模開発すれば良いんじゃないかな

>>328
最近のUnix系だとPerlは入っているだろう。
CPANがないと楽できないけれど。

そりゃjs以外選択肢が無い環境でコード書いてるならjs選ぶしかないけどさ
色々選べる環境で仕事してる奴らも世の中に沢山いるわけよ

Mac OSX はRubyもPythonもPHPも最初から入ってるよ
Node.jsは入ってないけど

http://wireframe.cc/
この手のものって、どの言語で作られてんの？

いい歳こいたperl mongerやruby gangは、そろそろニュービーたちを騙すのを辞めた方が良いと思う

自分の意志ではどうにもならないことが多いだろうけど
だからといって、いい歳こいた誰かの思惑通りに動いているわけでもない
人間以外の要因で色々決まってしまうことが多い

>>332
とは言えsh+sed+awkくらいの用途なら標準ライブラリだけで割と何とかならね？

>>337
政治的な層と経済的な層ですね。わかります。

>>339
人に騙されたくないなら人文系の層から離れてください

死ねゴミ共がw
死ねゴミ共がw
死ねゴミ共がw
死ねゴミ共がw

>>340
陸那比転職記事でソシャゲ屋へのって随分と適当なこと書いてねぇ？
求職中のニートでも、内容に何処か違和感覚えるレベルの記事。
俺、技術的な詳細について全く分からないけれど、
あの記事の内容は技術的な詳細なんて全く分かってない転職者に向けて、
技術的な詳細の分かってない記者が転職市場の活性化の為だけに書いたものだと思うの

RubyはRails含めて互換性低すぎて、保守性めちゃくちゃ悪いよな。昔作られたサイトの修正とか、新規に作り直した方がよっぽど楽。

Python2「メジャーアップデートしたい・・・」
修造　 「ちょっとまって、今・・・何て言った？　おいPython2！今何ていった！？『メジャーアップデートしたい！？』」
修造　 「メジャーアップデートとか言ってる間はずっとダメなんだよ！」
修造　 「使えよ！もっと2.7使えよ！」
Python2「もうマイナーアップデートない・・・」
修造　 「無い事無い、無いなんて事は無い！どこかにあるはず、探そうよ！」
Python2「・・・2.8・・・2.9・・・」
修造　 「ほらあるじゃない！　ほらみろ！あるじゃないか！」
Python2「上げるぞ・・・」
修造　 「そうだ上げろ！」
Python2「上げるぞ！！！！」
修造　 「もっと！」
Python2「マイナーバージョン上げるぞ！！！！！！！！！」
Guiod　 「はい終了した！！もうPython2のメンテナンス終了したよ！！！！」

Guiodまで読んだ

うん、普通に誤字ったすまん

頑張れなかったperl6

Perl6は熱意がぜんっぜん気持ち伝わってこなかったからな

>>344
マイナーアップデートはないけど、メンテナンスは継続してる
2.7は2015まで保守される予定

うん、そこは現実どうこうより台詞を短くまとめてｇｄｇｄにならないよう努めた
もとからｇｄｇｄとかそういうつっこみは受け付けない

kwatchの人がまたtwitterで喧嘩売りまくってるんだけど、この人どうにかならないの？
http://twitter.com/makotokuwata
なんで無駄に好戦的なんだろう
いい歳こいてトゲのある言葉まき散らして、コミュニティの空気悪くして、ほんと迷惑

祭にして叩けば?

>>351
「Perlしかできない」って言われて怒っちゃったyappoさん2chで反撃なんて最高にダサイですね

http://detail.chiebukuro.yahoo.co.jp/qa/question_detail/q1296730132

PHPとPerl(CGI)の使い方について教えて下さい
↑のURLは知恵袋で質問したものです
知恵コイン500枚でお得だよ￥＾−＾￥
　　　　 ＿＿
　　　／　 _, ,_ヽ　 ┏┓
　　 / (●) ..(●　 ┏┛
　　 |　　　(p_q)i　　・
　　 |　　 ,-|=‐| i.　
　　　> 　　|　 |く
　＿/　,／|⌒)|､,ヽ＿
　　 ヽ､_／|~ヽ､|__）　 ＼
　　　 ＿ノ＿__ノ
　　 （　　　　　　　＿
　 　　ヽ__　　　　/◎/
　　　　　　）　　/ロ/
　 　　　　（___ノ￣

俺様以外のバカの集まるスレw
死ねゴミ共がw

Python はじまったな

窓の杜 - 【NEWS】Microsoft、「Python Tools for Visual Studio」v1.5を正式公開
http://www.forest.impress.co.jp/docs/news/20121105_570958.html
http://www.forest.impress.co.jp/img/wf/docs/570/958/image3.jpg
http://www.forest.impress.co.jp/img/wf/docs/570/958/image2.jpg

>>351-353
思春期特有の精神性でないとプログラマなんて続けられないだろうし、
声が大きい人のおかげで発言しやすくなるだろから放っておけば？
しかし、2chの名無しならともかくtwitterアカウントで発言なんて頭沸いてる

http://developers.slashdot.jp/story/12/07/29/0728218/

【お題】
昇順、重複無し、整数要素の配列が与えられたとき、
連番部分を括り出す処理をどう書く？　括り出し部分の表現は自由。

例： [1, 3, 4, 5, 7, 9, 10, 11, 13] #=> [1, 3..5, 7, 9..11, 13]

Perlのいい加減さがいいよね、Cをやってると考えられないような事を平気で出来るからね。

>>359
Python

reduce(lambda x, y: x[0][-1].append(y) or (x[0],y) if x[1] == y - 1 else x[0].append([y]) or (x[0],y), [1,3,4,5,7,9,10,11,13], ([], None))[0]

-> [[1], [3, 4, 5], [7], [9, 10, 11], [13]]

Rubyだが奇をてらわない感じで
パターンマッチのある言語だともっと整理できるかも

def group(acc = [], ary)
　return acc if ary.empty?
　return group([ary[0]], ary[1 .. -1]) if acc.empty?
　if acc[-1] + 1 == ary[0]
　　group(acc << ary[0], ary[1 .. -1])
　else
　　[acc] + group(ary)
　end
end

group [1, 3, 4, 5, 7, 9, 10, 11, 13]

Rubyで
a = [1, 3, 4, 5, 7, 9, 10, 11, 13]
a.each_cons(2).each_with_object([[a.first]]){|(a,b),h| b-a == 1 ? h.last << b : h << [b]}
# => [[1], [3, 4, 5], [7], [9, 10, 11], [13]]

LLじゃないけどScala
val a = List(1, 3, 4, 5, 7, 9, 10, 11, 13)
var r = ListBuffer[ListBuffer[Int]]()
a.indices.foreach(i => if (i > 0 && a(i) -1 == a(i -1)) r.last + a(i) else r + ListBuffer(a(i)))

ト部のこれってなんか小難しいことやってるわりにバグってて意図不明
https://twitter.com/shyouhei/statuses/265919547314425857

a=[1,2,3,5,6,7]; b=a.each_cons(2).group_by{|(x, y)|x!=y-1}[true].map{|i|i[0]}; a.group_by{|i|b.find_index{|j|j<=i}}
#=> {nil=>[1, 2], 0=>[3, 5, 6, 7]}

Squeak Smalltalk で変化球。（「行儀が悪い方法」ともいう）

Object compile: 'key'. "前準備"

| result |
result := #(-1 1 2 3 5 6 7 9 11 13 14 15 17) inject: OrderedCollection new into: [:coln :each |
&nbsp;&nbsp;&nbsp;(coln notEmpty and: [coln last value + 1 = each])
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ifTrue: [each := coln removeLast key -> each]. coln, {each}].
result asArray "=> {-1 . 1->3 . 5->7 . 9 . 11 . 13->15 . 17} "

Perl

use List::Util qw(reduce);

my @list = (1, 3, 4, 5, 7, 9, 10, 11, 13);

my @r = (
map{ @{$_} == 1 ? @{$_} : $_ }
@{ reduce(sub{
@{$a} && $b == $a->[-1][-1] + 1 ?
[@{$a}[0..($#{$a} - 1)], [@{$a->[-1]}, $b]] :
[@{$a}, [$b]]
}, [], @list) }
);

rubyで

class Integer; def begin; self end; def end; self end end
a = [-1, 1, 2, 3, 5, 6, 7, 9, 11, 13, 14, 15, 17]
a.inject([]){ |r,e| e=r.pop.begin..e if !r.empty? and r.last.end+1==e; r<<e }
#=> [-1, 1..3, 5..7, 9, 11, 13..15, 17]

http://playbuildy.com/world?id=50736d9452572c7481000000#x=45616&y=0&z=-264112&s=32

>>361と同様に、(再帰の代わりに)「畳み込み」を用いた関数型プログラミング作法をRubyで

[1, 3, 4, 5, 7, 9, 10, 11, 13].inject([]) { |acc, x|
　　if acc.empty?
　　　　[[x]]
　　else
　　　　if acc.last.last.succ == x
　　　　　　acc[0 .. -2] + [acc.last + [x]]
　　　　else
　　　　　　acc + [[x]]
　　　　end
　　end
}

# => [[1], [3, 4, 5], [7], [9, 10, 11], [13]]

ユーザー数で堅牢性が上がっていくようなハックなものから、
ユーザー居なくなること見えてるのに、この先どうなるんだろ

堅牢性が必要なのはC言語まで
C以降の高級言語は何度もリセットしてやり直している
この先もそれをくりかえすだけ

Haskell

f&nbsp;x&nbsp;((y:ys):yss)&nbsp;|&nbsp;x+1==y&nbsp;=&nbsp;(x:y:ys):yss
f&nbsp;x&nbsp;yss&nbsp;=&nbsp;[x]:yss
main&nbsp;=&nbsp;print&nbsp;$&nbsp;foldr&nbsp;f&nbsp;[]&nbsp;[1,3,4,5,7,9,10,11,13]

ごめん。空白が...

f x ((y:ys):yss) | x+1==y = (x:y:ys):yss
f x yss = [x]:yss
main = print $ foldr f [] [1,3,4,5,7,9,10,11,13]

>>359 perl
my @a = (1,3,4,5,7,9,10,11,13);
my @b = ($a[0]);
for my $i (grep {$a[$_+1] != $a[$_]+1} (0..@a-2)) {
  splice(@b, -1, 1, [$b[-1],$a[$i]], $a[$i+1]);
}
$b[-1] = [$b[-1],$a[-1]];
printf("%d %d\n", @$_) for (@b);

>>359 Python
from itertools import groupby,count
[list(g) for k,g in groupby([1,3,4,5,7,9,10,11,13], lambda n,c=count():n-next(c))]

Mathematica

lst = {1, 3, 4, 5, 7, 9, 10, 11, 13};

Range[First[lst], Last[lst]] //
　ReplacePart[#, Map[# -> "}, {" &, Complement[#, lst]]] & //
　ToString[{#}] & //
　StringReplace[#, {", }" -> "}", "{, " -> "{"}] & //
　ToExpression //
　Select[#, # != {} &] &

{{1}, {3, 4, 5}, {7}, {9, 10, 11}, {13}}

お前らなら、括り出した連番部分を(始点,終点)のタプルとかで表現できるはずだ！

×[[1], [3, 4, 5], [7], [9, 10, 11], [13]]
○[1, (3, 5), 7, (9, 11), 13]

>>378
ﾉｼ

Mathematica

lst = {1, 3, 4, 5, 7, 9, 10, 11, 13};

Range[First[lst], Last[lst]] //
　ReplacePart[#, Map[# -> "}, {" &, Complement[#, lst]]] & //
　ToString[{#}] & //
　StringReplace[#, {", }" -> "}", "{, " -> "{"}] & //
　ToExpression //
　Select[#, # != {} &] & //
　Map[Which[Length[#] == 1, First[#], True, {First[#], Last[#]}] &, #] &

{1, {3, 5}, 7, {9, 11}, 13}

>>372
誰が、いつ地雷を踏むか分からないだろ
まずまず安心して使えそうなのってPHPとjavascriptまでじゃね？

>>380
サーバの中ではlibuvってのを使えばいいんだろ？

&gt; まずまず安心して使えそうなのってPHPとjavascriptまでじゃね？

ここ笑うところ？

>>378

g x (ys:yss) | x+1==head ys = [x,last ys]:yss
g x yss = [x]:yss
main = print $ foldr g [] [1,3,4,5,7,9,10,11,13]

>>378
>>370を改造してみた
コードが少し長くなったので、以下を参照
　http://play.island.ac/codepaste/code?id=28

>>376
その発想は無かったわ
スマートだしPythonらしくていいな

>>376 シンプルで感動した。Squeak Smalltalkでも書いてみた。
重複無しなので count イテレーターの代わりに indexOf: が使えるはず。

| ary |
ary:= #(1 3 4 5 7 9 10 11 13).
(ary groupBy: [:elem | elem - (ary indexOf: elem)] having: #notNil) values

ついでに Ruby でも

ary = [1, 3, 4, 5, 7, 9, 10, 11, 13]
ary.group_by{ |e| e-ary.index(e) }.values

>>378 Perl
use List::Util qw(reduce);

my @list = (1, 3, 4, 5, 7, 9, 10, 11, 13);

sub tail { ref $_[0] ? tail($_[0]->[-1]) : $_[0] }
sub head { ref $_[0] ? head($_[0]->[0]) : $_[0] }
sub rest { @{$_[0]}[0..($#{$_[0]} - 1)] }

my $r = reduce{ @{$a} && $b == tail($a) + 1 ? [rest($a), [head($a->[-1]), $b]] : [@{$a}, $b] } [], @list;

>>386
シンプルで美しいコードだと思うけど、以下の点が気になったので改変(改悪?)してみる
(1) 式ではないから、他のコードと繋げることが(=チェーンが)できない
　　--> Rubyらしくない
(2) 各要素に対してindex(e)の反復が入るから、入力リスト長に対して処理時間が指数的
　　--> 効率がよくない

p [
　　1, 3, 4, 5, 7, 9, 10, 11, 13
].each_with_index.group_by { |e, i|
　　e - i
}.map { |_, xs|
　　xs.map { |x, _| x }
}

# => [[1], [3, 4, 5], [7], [9, 10, 11], [13]]

>>378
型混在リストは、出来てもやらない派だけど
御題優先って事で妥協して文字列で…

ideone.com/4hINft

>>388
レシーバを使いまわすにはObject#tapが使えたりする
美しくは無いけど無理やりメソッドチェーンさせられる
tap内でbreakすると返り値をすりかえられることを利用する
p [1, 3, 4, 5, 7, 9, 10, 11, 13] \
.tap{|a| break a.group_by{ |e| e-a.index(e) }}.values

Pythonと違い仮引数のデフォルト値は呼出しごとに評価されるので
カウンターをスマートに渡せない
p [1,3,4,5,7,9,10,11,13] \
.tap{|a| c = a.size.times; break a.group_by{|n| n - c.next}}.values

と思ったが、別にEnumeratorを使う必要は無かった
p [1,3,4,5,7,9,10,11,13] \
.group_by.with_index{|n,c| n - c.next}.values

>>390
c の next は無用かと。これが>>376のruby的な最終到達点？

[1,3,4,5,7,9,10,11,13].group_by.with_index{ |n,c| n-c }.values

-- haskell
f xs = zip xs (tail xs ++ [head xs])
g xs = zip (last xs : init xs) xs
main=print$map(\((_,x),(y,_))->(x,y))$g$filter(\(x,y)->x+1/=y)$f[1,3,4,5,7,9,10,11,13]
-- [(1,1),(3,5),(7,7),(9,11),(13,13)]

ruby 1.9 におけるハッシュ飽和攻撃による DoS 脆弱性 (CVE-2012-5371) 　
http://www.ruby-lang.org/ja/news/2012/11/09/ruby19-hashdos-cve-2012-5371

>>391
ブロック変数を本来から一つ増やせばインデックスとれるって仕様にすれば
[1,3,4,5,7,9,10,11,13].group_by{|n,i|n-i}.values
で済むのにeach_indexとかむやみに増設しちゃうmatzってセンス無いよね

>>359
R
(function(x=c(1,3,4,5,7,9,10,11,13))split(x,cumsum(c(0,diff(x) > 1))))()

>>394
同じ機能のメソッドが二個も三個もあるのが常で
似た機能ならもっと沢山あるのが普通の Ruby では
似た機能だから、これで代用できるから、でそれらを纏めちゃうのは違うんでない

今回のお題の条件で行くなら別に配列のインデックスを取得する必要ないんでは
PowerShellだとglobalが邪魔っ気だった

1,3,4,5,7,9,10,11,13 | group { $_-$global:i++ }

>>394
ダックタイピングの弱点じゃないかなね？
Arrayとはまったく関係無いクラスがgroup_byを実装してる可能性があるから、
むやみにメソッドの仕様を拡張できない

>>398
group_by は Enumerable のメソッドなんだが…(´・ω・`)

>>399
Enumerableが提供するメソッドをEnumerableをインクルードしないで実装してもよいよね？
ダックタイピングなんだから

pythonのgroupbyはクラスを使ってないから、クラスの弱点やな

>>400
実装するのは勝手だが、ダックに使っても問題ないように実装するよね？
ダックタイピングなんだから

>>402
預言者じゃないんだから、オリジナルのメソッドの仕様変更に対応できるわけはないだろｗ

>>394
お前みたいに、新しい名前を増設したらセンス無いと思ってるやつが
名前が同じで仕様だけが変わる紛らわしいものを作ってるのかな

一つ余計なブロック変数が現状nilを返すのをインデックスを返すようにする程度の
仕様変更で動かなくなるコードがまったく思いつかないんだが…(´・ω・`)

>>394
こんなのもあるからダメじゃね？
[[1],[2,3],[5,6,nil]].map{|x,y,z|[x,y,z]}
=> [[1, nil, nil], [2, 3, nil], [5, 6, nil]]

>>394
(3..6).each.to_a
が[3,4,5,6]じゃなくて
[[3,0],[4,1],[5,2],[6,3]]になったりする
さらに
(3..6).each(&->x{p x}) や (3..6).each(&:display)
がエラーをだすようになる

with_indexが長いから短く
ってならわかるんだけど

>>378
Common Lispで
(nreverse (reduce (lambda (x y)
(if (and x
(= (funcall (if (atom (car x)) #'car #'cdar) x) (1- y)))
`((,(funcall (if (atom (car x)) #'car #'caar) x) . ,y) ,@(cdr x))
`(,y ,@x)))
'(1 3 4 5 7 9 10 11 13)
:initial-value nil))

>>407
それはto_aや->x{p x}や:display.to_procのアリティで判断できるだろう。
逆にアリティ2のブロックやメソッドなら渡してやればいいだけの話。

>>406
その仕様はあきらめてもらわんと困る。括弧くくるので代替してくれ。
[[1],[2,3],[5,6,nil]].map{|(x,y,z),i|[x,y,z,i]} #=>[[1,nil,nil,0],[2,3,nil,1],[5,6,nil,2]]

>>409
お前がやろうとしてるのは、Enumerableの仕様変更じゃなくて、
rubyのメソッド呼び出しの基本的仕様の変更
影響範囲がでかすぎる

だいたい引数展開ルールは同じにしといて
メソッドはアリティ守ってブロックは自由とかこのレベルでもう破綻してる

シンプルな実装且つ柔軟に組み合わせて使えるからこそ強力なのに

シンプルな実装は、いちいち人に相談しなくても組み合わせられるから強力なのだ

>>391 いいね!

group_by は Hash を返すようだけど、公式以外の実装でも問題なし？
公式マニュアルでキー生成順と確認したけど、他の実装が気になる点。一応 jruby は正常動作確認した。

細かい点だけど with_index なので、引数も合わせた方が良いかもしれない。 |n,i|

その前に {|n,c| n-c } で &:- …は使えなかったけど、
何か (map - '(1 2 3) '(4 5 6)) #=> (-3 -3 -3) 的な代替手段はないかな？

>>376や>>391は駄目だろ
何やってるのか分からない
パズルが得意なやつじゃないと
そもそもGroupbyの動作を知ってるやつが少ない
俺にはとても奇麗だとは思えん

>>415
それはキミが手続き脳だからだろ。
それとも「連番」を「インデクスとの差が一定」と
捉えられないバカなのか。

ぶっちゃけその台詞は>>376が言っても説得力ないけどなー

>>376以外が、だった

ライブラリ読み込んでる時点でダメだろ。

ルールがよくわからんのでアウトなんだろうなあと思いつつ>>376をパクらせていただいて

#!/usr/bin/perl
use strict;
use warnings;
my @a = (1,3,4,5,7,9,10,11);

my %b;
for(0..@a-1){push @{$b{$a[$_]-$_}}, $a[$_];}

use Data::Dumper;
print Data::Dumper->Dump([\%b],['*b']);
__DATA__

最後にmap{$b{$_}}sort {$a<=>$b}keys %bでもかまさなきゃだめかな
……それ以前の問題かもしれないけど

>>414
> その前に {|n,c| n-c } で &:- …は使えなかった

使えるよ。これで本当の最終形か。

[1,3,4,5,7,9,10,11,13].group_by.with_index(&:-).values
#=> [[1], [3, 4, 5], [7], [9, 10, 11], [13]]

> (&:-)
なかなかかわいい

なんというか短いだけで簡潔さがないな

短いけど読むのに時間がかかるという
リーダブルコード的にはダメなコードばかりなので
読むのに時間がかからないコードを書いた。
無駄なことをしていない分速度もこっちが早いと思う。

my @list = (1, 3, 4, 5, 7, 9, 10, 11, 13);

while(my $i = shift @a) {
　if($i+2 == $a[1]) { #値が2つ先まで連続していれば
　　print "$i..";
　　do {$i = shift @a} while($i+1 == $a[0]) #連続している間は省略する
　}
　print $i;
　print ", " if @a;
}

1,2,4 というのを 1..2,4 とするか 1,2,4 とするか迷ったが後者にしてみた。
前者が良ければ最初のifの数値2箇所をそれぞれ1つ減らせばいい。

もし0のことも考慮したいのなら

while(defined(my $i = shift @a)) {

こうしてくれ。

あ、しなくても大丈夫だったｗ

>>416
>>376のコード読めばああなるほどと分かるんだけど
真っ先に数列の性質に着目してコード化して見せた>>376はやっぱりすごいよ
>>376と、コードを見て初めて気づく人と、コードを見ても分からない人の間には
それぞれ超えられない壁がある

でも、groupbyという便利関数を使ってるだけだからなぁ。
あの関数が使えるって思いついただけだと思う。

>>424
あまつさえデフォで遅くて読みにくいことで定評あるPerlで
『リーダブルコード』で駄目な例に出てきそうなコメントバリバリのコードひっさげて
「リーダブルコード的にはダメなコードばかり」「速度もこっちが早い」とかどんなギャグかと

>>428
くやしいのう　くやしいのう

>>429
読めよw

リーダブルコードより

8章 巨大な式を分割する

短く書こうとして逆に分かりにくくなっていたことについての1文。

どうして1行で書こうとしたのだろう？　そのときは「オレは頭がいい」と思っていたのだ。
ロジックを簡潔なコードに落とし込むことに一種の喜びを感じていた。
この気持ちはみんなにも理解してもらえると思う。まるでパズルを解いているような感じだ。
仕事は楽しくやりたいからね。問題は、これがコードのスピードバンプになっていたことだ。
(P.102)
※スピードバンプ:ここではコードを読む速度を遅くさせるものという意味

同じ事を書いているにもかかわらず>>421と>>376を比較すると、
>>376は>>376の着想にPythonの表現力がついてこれてないもどかしさがあるな

>>431
うんうん。頭がいいと思っていたって話だねｗ

着想とか言ってる時点でダメだな。
頭が良ければわかる？ わからない奴はついてこなくていい？
なんだろそれは、読むのが困難だって言ってるようなもんだ。

>>376は可読性も問題無いと思う
でも、>>378のような仕様変更があると
全書き換えになる所が弱点
洗練されすぎてて仕様変更に弱い

>>376程度の工夫で読めなくなる人は
プログラム業界からお引き取りしてもらったほうが
「お互い」幸せに思えるが

【御題】
1から10までの数を二組の集合x,yに分けたとき
・sum(x) > sum(y)
・product(x) < product(y)
を満たすx,yを全て出力せよ（出力の表現は自由）

>>434
そりゃgroupbyを使えばだろ？

例えば数列中から連続している区間を取り出すhogehogeって関数があったとしたら
（hogehoge ・・・ 数値が連続していればその区間の開始と終わりを、そうでなければ単一の値をクロージャに渡す）

print join(', ', hogehoge { @_ > 1 ? "$_[0]..$_[1]" : $_[0] } @a)

これぐらい可読性よく書けるよ。

>>421
使えたーありがとう

>>378 対応は、こんな感じかな
.map{|_,e| e.length > 1 ? "#{e.first}..#{e.last}" : e.first.to_s }.join(", ")

>>435
えと、みんながその発想を褒めてる時点で
それが答えなんですが・・・。

>>439
普通に「読める」コードだけど自分では思いつかなかったから褒めてるんだろ
読めるコードでも自分で普通に思いついて書かないようなコードはダメだってか？
どんなファッショだよ

だめな理由はgroupby使ってるからじゃね？

ためしにgroupbyのコードを
書いてみてよ。

>>436

Mathematica

Table[
　x = IntegerDigits[i, 2] // PadLeft[#, 10] & // # * Range[1, 10] & //
　　　Map[Which[# == 0, {}, True, #] &, #] & // Flatten;

　y = Complement[Range[1, 10], x];

　tf = And[Apply[Plus, x] > Apply[Plus, y],
　　　 Apply[Times, x] < Apply[Times, y]];

　If[tf, {{x, y}}, {}], {i, 1, 2^10}] // Flatten[#, 1] &


{{{4,5,9,10},{1,2,3,6,7,8}},{{3,7,9,10},{1,2,4,5,6,8}},
　{{3,7,8,10},{1,2,4,5,6,9}},{{3,6,9,10},{1,2,4,5,7,8}},
　{{2,8,9,10},{1,3,4,5,6,7}},{{2,7,9,10},{1,3,4,5,6,8}},
　{{1,8,9,10},{2,3,4,5,6,7}},{{1,5,6,7,9},{2,3,4,8,10}},
　{{1,4,6,8,9},{2,3,5,7,10}},{{1,4,6,7,10},{2,3,5,8,9}},
　{{1,4,5,9,10},{2,3,6,7,8}},{{1,4,5,8,10},{2,3,6,7,9}},
　{{1,3,7,9,10},{2,4,5,6,8}},{{1,3,7,8,10},{2,4,5,6,9}},
　{{1,3,7,8,9},{2,4,5,6,10}},{{1,3,6,9,10},{2,4,5,7,8}},
　{{1,3,6,8,10},{2,4,5,7,9}},{{1,3,5,9,10},{2,4,6,7,8}},
　{{1,2,8,9,10},{3,4,5,6,7}},{{1,2,7,9,10},{3,4,5,6,8}},
　{{1,2,7,8,10},{3,4,5,6,9}},{{1,2,6,9,10},{3,4,5,7,8}}}

>>441
fold等よりよほど用途が限定されていて、関数の名前だけでグループ分けすると
いうことがすぐにわかるgroupbyがダメとか、意味が分からなすぎる

可読性でゴネてるやつは、
(x + 1) & ~1
のようなCのコードの意味が分からないからといって
if (x % 2 == 1) ++x
のように書き直して簡潔さを犠牲にして分岐命令を増やすようなタイプだろうか？
本当に業界を去って頂いた方がお互いのためかもな

>>441
Haskellだけど

groupby _ [] = []
groupby f (x:xs) = (x:ys) : groupby f zs
  where (ys,zs) = span ((==f x).f) xs

言語の良し悪しってのは実は言語そのものではなく
ライブラリがどれだけ充実しているかにあるというのは
知ってはならない真実なんだろうなぁ。

groupbyがいいとなれば
どんな言語でもgroupby相当の物を
持ってくるなりして使えば
同じように書けそうな気がするね。

>>436
Haskell

import Data.List
main = print [(x,y) | let s = [1..10], x <- subsequences s, let y = s \\ x, sum x > sum y, product x < product y]

>>443
え？ こういう問題ってライブラリは使わないで
基礎的な命令だけで解くことが目的の
アルゴリズムの問題なんじゃないの？

言語の標準（？）ライブラリ自慢になってちゃ
面白く無いと思うけど。

ID出るといいんだけどねー

出したいなら代わりにトリップ出せばいいと思うよｗ

>>443
上の式は実行効率の良さはともかく簡潔だとは思わんな・・・
下の文より分かりづらい

>>450
俺だけ出しても仕方あるまいよ。君頭いいね

>>448
「基礎的な命令」を正確に定義して

>>453
関数、メソッドではないもの。

>>454
全てがメッセージパッシングなオブジェクト指向言語はどうしたら

つーか制限かけるとつまんねーんだよ
何でもありだから言語固有のコードが出て来て面白いんだろが

>>455
ifもループも配列も
全部、関数やメソッドなのかい？
なら参加権なしってことだ。

いつまでもバナナはおやつに含まれますか論争してんじゃねぇよ・・・

>>456
いや、今回の場合ただの関数があるかないか自慢になってるから。

よし、こうしよう。他の言語にも
同等の関数はあるという前提で
いろんな言語で実装してみるというのはどうだ？

groupbyみたいな単純な関数(>>444)を使っただけで
ライブラリ自慢になってるとか馬鹿らしいよ

じゃあgroupbyのなかで使ってる
spanを実装しなよｗ

ひどい自演を見た

>>461
span f xs = (takeWhile f xs, dropWhile f xs)

>>461
from webbrowser import *
open_new_tab("http://www.youtube.com/watch?v=anwy2MPT5RE&t=1m00s")

groupbyを使わないで同じことをやると、あまり面白くない

a = [1,3,4,5,7,9,10,11,13]
b = [a[i]-i for i in range(len(a))]
print([[a[i] for i in range(len(a))if b[i]==j]for j in range(min(b),max(b)+1)])

>>434
それは言語次第だと思うけど、どっちにしろ全書き換えってこたないと思う

PowerShellだと>>397にの後ろにパイプ式を追加するだけで済んだよ
>> $s = 1,3,4,5,7,9,10,11,13 | group { $_-$global:i++ } |
% { if ( $_.count -gt 2 ) { "($($_.group -join ','))" } else { $_.group } }
>> $s -join ','
1,(3,4,5),7,(9,10,11),13

そもそも>>376はPythonではなく
書いた376が賞賛されてることに気付いた方がいい
だからライブラリ自慢なんて的外れ

入れ子リストという構造自体はごく汎用的だから、出力形式を変えたければ単に
その後形式を変換すればいいだけ
一般論として形式AからBに変換するコードを足すと、最初からBを出力するつもりの
コードよりは長くなるかもしれないが、どういう形式を選んでもそういうことは有り得る

>>434はどういう根拠で>>376が仕様変更に弱いと思ったんだろう

>>378はリストを作る段階から(始点,終点)形式で作れって意味かと思い込んでた
すまぬ、すまぬ...

>>376じゃないけど、もちろんPythonでも>>376に1行足せばいいだけ

# >>376の「嫌いな」形式に変換する
xs = [1, 3, 4, 5, 7, 9, 10, 11, 13]
groups = [list(g) for k, g in groupby(xs, lambda n, c=count(): n - next(c))]
converted = [group[0] if len(group) == 1 else tuple(group) for group in groups]

>>436
Squeak Smalltalk で

| in out |
in := 1 to: 10.
out := OrderedCollection new.
(1 to: in size // 2) do: [:m |
　in combinations: m atATimeDo: [:x |
　　| y |
　　y := in copyWithoutAll: x.
　　(x sum > y sum and: [(x reduce: #*) < (y reduce: #*)]) ifTrue: [out add: x copy]]].
^out

>>470
こうじゃないの？

converted = [group[0] if len(group) == 1 else (group[0],group[-1]) for group in groups]

>>472
ああ、全部出力しちゃいけないのか…
題意をよく読んでなかった、ごめん

あ、ほんとだ、俺も間違えてた

groupbyはもういいから、次のお題>>436をどう書く？

俺の頭じゃ例がないとxとyの状態がよく分からんわ・・・
xが10個とも持ってる場合とかも含めた総当りをかっこよく書いてちょってことでいいんかね

>>376の良さは、1,3,4,5,5,7,9,10,11,13という並びがあった場合、
[[1, 5], [3, 4, 5, 7], [9, 10, 11], [13]]
ではなく、
[[1], [3, 4, 5], [5], [7], [9, 10, 11], [13]]
が返ってくるところ。

>>476
正解。

そう、当たり。

>>477
お題で重複はないって条件にあるんでー

>>477
重複があったらダメなコードのが少なくね？

>>477
それって、どっちかっていうとPythonのgroupbyの仕様バグくさいけどな。

引数にジェネレータが取れる仕様だからじゃないの
無限列かもしれないんだから

無限列ならなおさら出てきたところまではまとめて欲しいと思うが…
そもそも仕様に「SQLのと違う」って断わり書き入れるくらいなら、名前変えろよと
Python作り手の考えることはいっけん理屈が通っているようでけっきょく抜けとる

戻り値もジェネレータだからねぇ

>>427
そういう、「思いついた俺すげえ。」「分かる俺すげえ」みたいなのは
自己満足にはいいけど、現実世界ではある程度は万人に分かることが重要じゃないかな

>>481-484
雲行きが怪しくなってきたなあ
結局、groupby自体、どういう仕様なのかはっきりしないものであって
人によって解釈が異なるってことか
ますます可読性に難があることがあらわになってきたね

groupbyのような単純な関数で文句を言うな、可読性に問題はない
とか言ってた連中大恥じゃないかw

>>485
さすがに>>376程度も理解できんのは業界から去って欲しくね？

初めてgroupbyという名前を聞いた人が
その機能を考えて全員一致するなら
わかりやすい関数だって見とめてやるよ

>>487
ちなみに未だになんでnextが必要なのかわからない
俺は去ることになりそうだ
pythonを知ってるから内包表記は理解できたが、
まずその段階でさる人が多そうだ
99%は去ることになると思う

結局、こういうややこしいパズルみたいなのはバグを作り込むんだよね
「分かる俺すげええええ」して、異を唱える他の人を「どうせ分からないんだろう」とバカにして
悦に入っていたやつも、ほとんどは>>477まで想定して言ってたわけじゃないんだろうなw

>>489
count()の戻り値はジェネレータだから

>>488
全部の言語で仕様が一致する必要があるの？
mapですら違うよ？

全部の言語で一致する必要はないけどこの場合の問題は
SQLの方のgroupbyを想像する人の方が多数派であると予想されること

>>486
一番恥ずかしいのは「groupby書いてみろよ（書けないだろ？ww）」的な事書いて
速攻でレスされた441だと思います

SQLは無限列を扱う訳じゃないからねぇ

無限列ならなおさら出来たところでまとめて欲しいけどねぇ

googleコーディング規約で「内包表記はシンプルな場合のみ利用しましょう。
複数のfor式、フィルター式はやめましょう。」的なのがあったけど、
groupby以前にまずこれに違反してるな
内包表記とgroupbyとlambda組み合わせちゃってるから

>>495
思いつきで言ってるでしょ
戻り値も無限列の可能性がある（だから戻り値もジェネレータ）なのに、
どうやってまとめるの？

googlerですら「複雑な文はやめましょう。ちなみに複数のfor使っただけで内包表記は複雑です」
とはっきり言ってるんだよね。
もちろん376みたいなのはNGでしょ。
やっぱり、虚勢を張りたい気持ちは分かるが、謙虚にならねばならない。
Googlerのように。

>>497
普通に出来そうだけど
何で出来ないのか理解できない

そもそも、理解できたとしてもそういう内部の事情を考慮しないと分からない時点で
分かりにくい

馬鹿には無理

残念ながらこの業界の90％はバカなのです。
まあ趣味レベルの仕事であなた一人で仕事を完結させるならいいですが。

さすがにgooglerを馬鹿とは言いたくないけどねぇ

使うのを控えるのと理解できないのとでは全然違う

>>489
>>491が言ってるようにcount()を含めたitertoolsの関数はジェネレータを返す
next()はジェネレータの次の値を取り出す、ただそれだけの関数
JavaのIteratorインタフェースのnext()メソッドとやってることは等価だし
C++のSTLを知ってればiteratorやstd::advance()のようなものを
知っているはず

99%は言い過ぎ、バカが自分だけじゃないと主張して安心したいだけにしか見えない

数行のコードを誉めたり貶したりする何百行ものコメントを読まされる人は大変だろ
このスレで最も複雑なのはgroupbyでも内包表記でもない
日本語とかコミュ能は規約で色々禁止した方が生産性上がるんじゃねぇの

Pythonのgroupbyが理屈優先でユースケース想定不足な謎仕様になっていることと
本来のSQL的なgroupby程度すら直感的に理解できないリテラシー不足が大勢いることを
一緒くたにして議論してはいけない

>>484
前後するけど、戻り値もそのキー値の値もジェネレーターなのは
どんなユースケースを想定しているのだろうか？
単純な例で、count()を偶奇でgroupbyする場合だとまったく意味をなさないように思うのだが。

>>507
そういう場合は入力をソートする

＞groupby() の操作は Unix の uniq フィルターと似ています。 key 関数の値が変わるたびに
＞休止または新しいグループを生成します (このために通常同じ key 関数でソートしておく必要があるのです)。
＞この動作は SQL の入力順に関係なく共通の要素を集約する GROUP BY とは違ます。

>>508
count()はソート済みでは？
そもそも聞きたいのは「どうしたらできるか？」ではなく
返値やキーの値がジェネレーターだと「どんなシチュで何が便利なのか？」であって

たとえばキーの種類が増えていくとき、返値がジェネレーターだと便利だよね　これは分かる。
でも、既に存在するキーにグループ分けされるはずの要素が新たに現われたとき、
既存のキーの値（ジェネレーター）に追加されるわけではないんだよね。
今の仕様だと、既存のとは別に同じキーのキーと値のペアが作られるだけ
これではほとんど旨味がないと思うんだけど

>>509
groupbyに渡す key関数で ソート

>>509
要素の順序が重要なとき

ランレングス圧縮から

名前,日時,発言 の会話ログ・データが時系列にあって
名前が連続してる時は名前表示をひとつに纏めたいとか、雑多な作業にまで色々と使える

PythonのgroupbyからSQLのgroup by相当は簡単に作れる、ソートしてもしなくても作れる
SQLのgroup byからPythonのgroupby相当は作れない

ていうか、世の中の90%のダメプログラマは
>>424の方が良いコードだと感じるの？マジで？
括り出しのロジックと端末への出力の分離すらできてない
最低のコードだと思うんだけど

お ま ま ご と

>>424
@a が未定義
要素に0が含まれてるとその時点でループ終了

>>513
便利メソッドがないという前提で
お前書いてみて。

>>515
> 要素に0が含まれてるとその時点でループ終了
次２つのレスぐらい読めないの？

>>513
>>424はPerlの文法知らないからチンプンカンプンだわw
個人的に駄目プログラマでも分かりやすいと思ったのはこの辺だな
>>363-364 >>374

>>513
端末？を見下すやつってなんなの？アップル信者なの？

>>424は新しいリストを得るのではなく印字してるだけに見えるね

今のところ364が一番分かりやすいな
やっぱり変数に型がないと駄目だね

>>519
ターミナル軽視はWindows一辺倒の人に多いかと

ループ終えたあとには元のリスト@list（@aのtypoか）は空リストになるのか
これは>>513に分があるような

424のコードは良く分からないが、コメントは分かりやすいw

印字に文句言ってる奴が多いから、perlを知らない俺が妄想でperlの仕様を
補間してちゃっちゃと改良してやったよ。
間違ってるけどこんな感じで出来るだろ。本質的じゃないことに文句言い過ぎなんだよ

my @list = (1, 3, 4, 5, 7, 9, 10, 11, 13);
my @result = ();
while(my $i = shift @a) {
　@result << $i;
　if($i+2 == $a[1]) { #値が2つ先まで連続していれば
　　do {$i = shift @a} while($i+1 == $a[0]) #連続している間は省略する
　　$(@result[-1]) << $i;
　}
}

動くといいね

結果を変数に入れて副作用を使ってリストを作っていくコードが
分かりやすいな
過度に関数型チックで簡潔にしようとしているのは、処理の流れが複雑なリッチな関数
に頼ることで処理がブラックボックス化し、結果に対する変化が見えない
ことで分かりにくくなっている気がする

>>504
そもそもcount()がジェネレータを返すというのを知らなければ
いくらjavaやSTLに詳しかろうが分からんだろ

#値が2つ先まで連続していれば
#連続している間は省略する

というソースコードよりも

#連続している間は省略する
#値が2回以上省略されれば

というソースコードの方が分かりやすいのでは？

こんな感じじゃないかな。構造は1回以上の繰り返し。
my @list = (1, 3, 4, 5, 7, 9, 10, 11, 13);
my @r;

while(defined(my $i = shift @list)){
if (defined $list[0] and $i + 1 == $list[0]){ # 連続していれば
my $s = $i;
do {
$i = shift @list;
} while(defined $list[0] and $i + 1 == $list[0]); # 間を飛ばす
push @r, [$s, $i];
next;
}
push @r, $i;
}

あいうえお.かきくけこさしすせそたちつてと....
と五十音表を作りたいのですが
utf8で一気に作る方法ありませんか？
教えてください

お題に書かれた順番で考えたほうが分かりやすい人と
連番との差でグループ化できると考えたら分かりやすい人がいるというだけだろ。
my @list = (1, 3, 4, 5, 7, 9, 10, 11, 13);
my %result = ();
for(my $i=0;$i<$#list+1;++$i){push(@{$result{$list[$i]-$i}},$list[$i]);}

>>527
それは分かりやすさのベクトルが違うと思うよ
「玄関で右曲がって交差点で左曲がって500ｍ直進した右手の建物に入る」って言った方が分かりやすいのか
「自宅から国会議事堂に行く」って言ったほうが分かりやすいのか、そういう違いだと思う

my @aiueo = (
"あ", "い", "う", "え", "お",
"か", "き", "く", "け", "こ",
"さ", "し", "す", "せ", "そ",
"た", "ち", "つ", "て", "と",
"な", "に", "ぬ", "ね", "の",
"は", "ひ", "ふ", "へ", "ほ",
"ま", "み", "む", "め", "も",
"ら", "り", "る", "れ", "ろ",
"わ", "ゐ", "ゑ", "を", "ん",
"や", "ゆ", "よ");

これ以外で教えてください

・あいうえお...を1つずつ取り出して0から47まで代入
・qw(あ い う え お ...)
・$aiueo[0]="あ"; ....
#動作確認はしてない

>>528
それはどんな言語のどんな関数についても言えることだろう……

>>519
>>513は別に端末を見下しているんじゃなくて、データを返すコードではなく
端末に値を出力するだけのコードは汎用性が皆無であることを問題視してるんだろ

>>527
それってシェルで言うと、
grep $PATTERN file
ですむことを
while read line; do
&nbsp; &nbsp; if expr line : $PATTERN; then
&nbsp; &nbsp; &nbsp; &nbsp; print line
&nbsp; &nbsp; fi
done < file
と書いた方が分かりやすいと言ってるようなもんだよな

うわ、&はエスケープされるようになったの？
while read line; do
if expr line : $PATTERN; then
print line
fi
done

>>376はラムダ式の呼び出しのたびにc=count()が実行されて
毎回next(c)で0が返りそうにしか見えないんだけど
どういうカラクリなんだよ？

あんまりPython知らないからあれだけど
これで業界去らなくちゃいけないのは厳しいわｗ

そこはPythonを知らないなら仕方がないね
Pythonのデフォルト引数は一度だけ（関数の定義時）にしか評価されない

Pythonの仮引数のデフォルト値は一回しか評価されない
何回コールしても、その同じオブジェクトが入ってる

def foo(i,a=[]): a.append(i); return a

print(foo(1)) # [1]
print(foo(2)) # [1,2]
print(foo(3)) # [1,2,3]
print(foo(4)) # [1,2,3,4]

説明ありがとう
しかし分かりづらい仕様だな

これ関数型的に考えるなら先にzipして
[(0,1),(1,3),(2,4),...]
てリストを作ってgroupByに渡すべきなんじゃないだろうか？
Pythonだとそれも面倒なのかな？

中途半端に手続きが入ってる感じが余計分かりづらくしている気がする

一つ前の要素と現在の要素をkey関数で評価し、
真の間の要素を同じグループに纏める関数を手続きで書いた。

ideone.com/K2qrKO

sequence = [1,4,5,6,7,9,10,11,13]
is_next_num = lambda prev,current: prev+1 == current

print(list(group_while(sequence, is_next_num)))

group by も、実装方法は幾つか種類があるようだけど、
実態は、よくある処理の汎用的な部分を抽出し、再利用しやすくしたものなので、
紐解いてみればそんなに難しくないよ。ハッシュを使った実装だとこんな感じ
(テストはしてない。注意インデント全角です)

sub group_by(&@) {
　my ($keyfunc,@sequence) = @_;
　my %groups = ();
　foreach (@sequnce) {
my $key = &$keyfunc($_);
　　push(@{$groups{$key}}, $_);
　}
　return %groups;
}

# 用例
sub uniq(@){ my %d = group_by {$_[0]} @_; keys %d }

関数型・手続き云々ではなく、こういったユーティリティ関数の組み合わせで組んだコードの利点は
式単位での部品の再利用性。同様の処理を書くのに差分のみのコーディングで済むので、
バグが入り込む余地が比較的少なく、生産性・保守性も優れてる所にあります。=>プログラマの負担軽減に繋がる

お、おう

>>546
ただ、最適化されたコードではないから
遅くなるんだよね。

二回もループして一旦別配列を作ったりするから。

このスレでの経緯から見ると、生産性や保守性に優れていて
バグの軽減につながるというのは眉唾
何をやっているのか理解に苦しむ人が続出し、pythonジェネレータや
groupbyの分かりにくさや曖昧さを露呈した
pythonやrubyでのgroupbyに慣れた人が
sql型のgroupbyを持つ言語でバグを作り込みそうだ

華麗にスルー

それに、プログラミングコンテストで好成績を収めているのは
C++で手続き型丸出しの書き方の人が多いという現実がある
関数的な書き方が生産性が高いというのは幻想だと思う

>>537
そこまで出来ればあとはアレンジだけだと思うがなあ
入力を即値→標準入力から読ませるに変えるのもLLは1〜2行で済んだりするし

書き捨てコードとして貼られたら何も思わなかったけど
見本を見せてやると言わんばかりに貼られたコードだからねぇ

ああいうコードにダメさを感じないPGって
MVCとかも本当には理解してなさそう

>>527>>551
>>363-364 >>374 あたりは読み易いという意見もあるけど？

>>543
zipは関数型では良いけどオブジェクト指向では微妙だよな
二つのコレクションのどっちがレシーバになるべきか迷う

>>553
でも結局>>525や>>530と同じようなコードなんだし
本質から離れた揚げ足取りで横やりを入れてる感じは否めない

>>555
Ruby使いだけど
その点ではPythonみたいな関数タイプもいいなと思う
zip(列挙型1,列挙型2),...

Rubyだと
列挙型1.zip(列挙型2,...)
結果の要素数がレシーバーに合わされるっていうのがわかりやすいともいえるけど

Pythonのような
全部のなかで要素数が最小のや、最大のにあわせたzipも欲しいところ

>>556
ロジックがIOと分離されてないとこにケチ付けられてるのに
ロジックが同じだから大差無い？馬鹿すぎて目眩がする

肝心のロジックも冗長なだけのゴミ

殺伐としたスレにcoffeescriptが

a = [1, 3, 4, 5, 7, 9, 10, 11, 13]
r = []
for i in [0...a.length]
　if i > 0 && a[i - 1] + 1 == a[i] then r[r.length - 1].push a[i] else r.push [a[i]]

現実のプログラムでロジックとIO分離すんの結構面倒で難しいよね
トイプログラムでなければ進捗表示とかロギングとか色々要求が出てくるし

後はGUIだとユーザによる中断／キャンセルとかな

旅人と上着を分離・・・ah

進捗表示とかの処理をロジックと分離するのにも
ジェネレータや遅延リストが役立つよ

>>533
後者はもっと違う気がする
喩えるなら、「A君が自宅から国会議事堂に行くときのように、B君の自宅からホワイトハウスに行くんだよ。わかった？」
って言ってる感じ

>>560
どうもr[r.length - 1]が冗長だよな
indexを使わざるを得ないのも不格好だ
俺的最強言語ならこうなるな

for a in [1, 3, 4, 5, 7, 9, 10, 11, 13]
　if a.to(-1) == a - 1 then r.last += a else r += [a]

こんな言語いかにもありそうなんだがな
ここまで簡潔なのはなぜか無い

aに入ってるのは数字なのに、なんでa.to(-1)でリストの一つ前の数字を差せるんだよ
そんな気持ち悪い言語あってたまるか

俺的最強言語（笑）ではa = 1のときどうなるの？

>>567-568
想像力のない奴らめ
aはこのスレで流行のジェネレータで、単にaと書くのはa.valueの
省略形じゃ
わかったか愚民どもめ

ジェネレータ知らんのに無理すんなwww

知ってるけど？
PostgreSQLでいう、シーケンスみたいなもんだろ。
呼び出すごとに値を返す。

for a in g: <= この場合gがジェネレータで、aはジェネレータに生成された値

> aはこのスレで流行のジェネレータで、単にaと書くのはa.valueの
> 省略形じゃ

馬鹿すぎるwwwwwwwwwww

ぼくがかんがえたさいきょうのジェネレータ
相手は死ぬ
そういう年頃があってもいいじゃない

>>572
お前、Pythonごときと俺の最強言語が一緒だと思うなよ？

【お題】
1. 円周率を小数点以下1000桁まで求めるコードを組み
2. その結果を用いて、小数点以下に列ぶ数字の出現数順に並べて出力せよ

1は書き下ろしはもちろん、ライブラリを使っても1000桁のコピペでも構わないがコードとして示すこと。
参考：http://mail2.nara-edu.ac.jp/~asait/c_program/sample0/pi.htm
2の出力結果も示すこと。出現数が多い順に並んでいて出現数が分かれば形式は自由
できれば、１レス以内に収まる簡潔なコードが望ましいが、適宜コード貼り付けサイトも活用されたし

print(sortByShutugensu(getEnshuritsu(1000)))

できた

>>575 Rubyで
require 'bigdecimal/math'

pi1000 = BigMath.PI(1000).*(10**999).to_i.to_s
histogram = pi1000.chars.each_with_object(Hash.new{|h,k| h[k] = 0}){|s,h| h[s] += 1}
p histogram.sort_by{|(a,b)| [-b,a]}

結果
[["1", 116], ["9", 105], ["2", 103], ["3", 103], ["8", 101], ["5", 97], ["7", 95], ["6", 94], ["0", 93],["4", 93]]

全部で一行のメソッドチェーンにするのもアレなんで分割した

>>575
意外と簡単な処理で数万桁くらいまでなら求められるんですね。びっくり。
Squeak Smalltalk で。

| atan pi1000 |

atan := [:m :d |
　| x y m2 i limit |
　x := y := (1 asScaledDecimal: d) / m.
　m2 := m * m.
　i := 0.
　limit := (10 raisedTo: d negated) asScaledDecimal: d.
　[ | z |
　　z := (y := y / m2) / (2 * (i := i + 1) + 1).
　　x := i even ifTrue: [x + z] ifFalse: [x - z].
　　z < limit
　] whileFalse.
　x
].

pi1000 := (atan value: 5 value: 1000) * 4 - (atan value: 239 value: 1000) * 4.
((pi1000 asString allButFirst: '3.' size) first: 1000) asBag sortedCounts

"=> {116->$1 . 106->$9 . 103->$2 . 102->$3 . 101->$8 . 97->$5 . 95->$7 . 94->$6 . 93->$0 . 93->$4} "


ついでに10000桁も算出＆カウントしてみた。

=> {1046->$5 . 1026->$1 . 1021->$2 . 1021->$6 . 1014->$9 . 1012->$4 . 974->$3 . 970->$7 . 968->$0 . 948->$8}

意外と >>577 と >>578 の結果が違うんですね。びっくり。

頭の３．を含むか含まないかの違いだろう
”小数点以下に列ぶ数字の...”って云っているので、含めない方が正解か？

3 の出現数だけならそれで説明付くが
9 の出現数が違うのはなぜだろう

1001桁目か1000桁目か999桁目が9なんだろ

これはひどい

ざこば

In[1]:= DigitCount[N[Pi, 1001], 10, Range[0, 9]]
Out[1]= {93, 116, 103, 103, 93, 97, 94, 95, 101, 106}

Mathematicaで3.を含んで小数点以下1000桁

WolframAlpha でもできた。簡単のため出現頻度は 1, 2, 3, ... ,9, 0 の順で固定。

http://www.wolframalpha.com/input/?i=DigitCount[N[Pi%2C1001]]
[116, 103, 103, 93, 97, 94, 95, 101, 106, 93]

http://www.wolframalpha.com/input/?i=DigitCount[N[Pi%2C10001]]
[1026, 1021, 975, 1012, 1046, 1021, 970, 948, 1014, 968]

>>575 Haskell

import Data.List
import Data.Ord

arctan :: Rational -> [Rational]
arctan m = [s*(m^n)/toRational n | (n,s) <- zip [1,3..] $ cycle [1,-1]]

main = print . sortBy (comparing (negate.snd)) .
  map (\s -> (head s, length s)) . group . sort . show . fst .
  properFraction $ (4 * (4 * x - y) - 3) * n
  where
  n = 10^1000
  x = sum $ takeWhile ((1/(16*n) <).abs) $ arctan (1/5)
  y = sum $ takeWhile ((1/(4*n) <).abs) $ arctan (1/239)


-- 結果
[('1',116),('9',106),('2',103),('3',102),('8',101),('5',97),('7',95),('6',94),('0',93),('4',93)]

うぉ、はずかしっ、3は含まないのか
require 'bigdecimal/math'
pi1000 = BigMath.PI(1000).-(3).*(10**1000).to_i.to_s
histogram = pi1000.chars.each_with_object(Hash.new{|h,k| h[k] = 0}){|s,h| h[s] += 1}
p histogram.sort_by{|(a,b)| [-b,a]}

結果
[["1", 116], ["9", 106], ["2", 103], ["3", 102], ["8", 101], ["5", 97], ["7", 95], ["6", 94], ["0", 93],["4", 93]]

自前で計算させると
require 'bigdecimal'
def atan_i(m, limit=1000)
x = y = BigDecimal(1).div(BigDecimal(m),limit)
m2=BigDecimal(m)**2
i = 0
loop do
z = (y = y.div(m2,limit)).div((2*(i += 1) + 1),limit)
x = i.even? ? x+z : x-z
return x if z.round(limit).zero?
end
end
pi = (atan_i(5)*4-atan_i(239))*4
pi1000 = ((pi-3)*10**1000).to_i.to_s
histogram = pi1000.chars.each_with_object(Hash.new{|h,k| h[k] = 0}){|s,h| h[s] += 1}
p histogram.sort_by{|(a,b)| [-b,a]}

XMPP::Conn: ReceivedID: nope...
XMPP::Conn: WaitForID: haven't gotten it yet... let's wait for more packets
XMPP::Conn: Process: timeout(1)
XML::Stream: Read: buff(<stream:error><host-unknown xmlns='urn:ietf:params:xml:ns:xmpp-streams'/></stream:error>)


これは何が原因だと思いますか？
教えてください
<stream:error><host-unknown xmlns='urn:ietf:params:xml:ns:xmpp-streams'/></stream:error>

>>575
Common Lisp

(labels ((pi (x)
(labels ((my-atan (y)
(loop for i upto x
for j = (1+ (* i 2))
sum (/ (if (evenp i) 1 -1) j (expt (/ y) j)))))
(* (- (* (my-atan 1/5) 4) (my-atan 1/239)) 4))))
(loop with l = (loop for i upto 9 collect `(,i . 0))
for (q r) = (multiple-value-list (floor (* (- (pi 1000) 3) 10)))
then (multiple-value-list (floor (* r 10)))
repeat 1000
do (incf (cdr (assoc q l)))
finally (return (sort l #'> :key #'cdr))))

これ答えたほうがいいよ
http://detail.chiebukuro.yahoo.co.jp/qa/question_detail/q1497248299

>>575
JavaとC#で一番簡潔なコードは
1000桁コピペだった件
やっぱりLLの足下にも及ばなかったよ……

標準ライブラリにBigMath.PIがあるかないかの違いで
威張られても・・・

JavaドカタにはBigMath.PIが無かったら手も足も出ないわな
LLの方が言語だけじゃなくプログラマの質も高い

>プログラマの質も高い

言語に下駄履かせてもらってるんだけど

高い下駄を履きこなせるのも能力のうち

いや、簡単に使えるんだから
低い下駄だろｗ

馬鹿には無理

過去の資産や政治的理由を除いて、純粋に言語の機能だけでみればC#
そして、政治的理由とトレンドを考えてsharpkitで遊ぼうとしたけどもインストーラーが動かない

>>594
冗談抜きでLLとか言ってる人たちがcのプリミティブな配列で多倍長整数やhashを実装するところが想像できない
だいたい、javaより重要なものがない

>>551
c/c++プログラマと〜使い()では、手段と目的が違うからな

>>599
多倍長とか言って10のマイナス1000乗の精度が求められる世界だからね
冗談抜きでは想像できないね

花形IT企業勤務のレッドコーダーから見たらJava土方だの
LLだの低レベルな罵り合いは微笑ましい

>>599
凄いレベルの馬鹿発見

ブロックを渡せないオブジェクト指向って馬鹿だよな
ブロックがないなら継承してオーバーライドしてコンストラクタ呼べばいいじゃないって
歴史に残る馬鹿だな

>>575

@Mathematica

x = Pi // N[#, 1000 + 1] & // ToString //
StringReplace[#, "3." -> ""] & // Characters // ToExpression ;

Table[{i, Count[x, i]}, {i, 0, 9}] // Sort[#, #1[[2]] > #2[[2]] &] &

{{1, 116}, {9, 106}, {2, 103}, {3, 102}, {8, 101}, {5,
97}, {7, 95}, {6, 94}, {4, 93}, {0, 93}}

連投ｽﾏｿ。

x (ﾟ�听)ｲﾗﾈ

@Mathematica

Pi // N[#, 1000 + 1] & // ToString //
　StringReplace[#, "3." -> ""] & // Characters // ToExpression //
　Table[{i, Count[#, i]}, {i, 0, 9}] & // Sort[#, #1[[2]] > #2[[2]] &] &

{{1, 116}, {9, 106}, {2, 103}, {3, 102}, {8, 101}, {5, 97}, {7, 95}, {6, 94}, {4, 93}, {0, 93}}

>>604
× ブロックを渡せないなら指向ではない。
○ ブロックを渡すことでできる「何か」がブロック以外で出来ればオブジェクト指向。

>>607
ブロックで出来る程度の事を継承でやるのは冗長で、
コード間に無駄な密結合を発生させ、可読性と保守性を落とす
馬鹿馬鹿しい行為だと>>604は指摘してるだけで、
オブジェクト指向じゃないとは書いてないよ

冗長ってようするにタイピング数が多いってだけだろ？
そんなに困るのか？

タイピング数が多い以外の問題を
具体的に言うことができたら>>608のいうことを
少しは信じてやってみいいぞｗ

タイプ数それなりに重要じゃね？
例えばイテレータとかも「こんだけ冗長ならもうforループに直書きでよくね？」になるんだよなあ

こんだけ冗長ってどれだけ？
共通部分は除いてどこが冗長化書いてみてよ。

タイプ数、数えてあげるからさ。

for(int i=0;i<a.size();i++)total+=a.get(i);
for(Iterator<Integer>i=a.iterator();i.hasNext();)total+=i.next();

Java辺りには結構いると思うぞ
「イテレータの何が便利なのか分からない、冗長かつ読みにくくなっただけじゃん」
って思ってる人間。

LLのイテレータは大概、どう考えても書きやすく読みやすくなるから
自然と使うようになると思う。「良いものを自然と使いたくなる」ってのは案外重要だと思うんだ。

データ列の生成と、データの処理と、繰り返し終了の判定
これらの直交する処理を分離しておくと再利用性が高くなるね

つうかJavaでも
for(Integer i:a) total+=i;
って書けるんだが・・・

Java相手だからって馬鹿にしすぎ
流石にイテレータでループくらいは短く書けるよ、結構昔(Java5)から

昔の知識で止まったまま批判してることとかよくあるね。XPの頃のままでWindowsを批判するMacユーザーとか。

>>613
予想通り、批判が的はずれでワロタｗ

>>613
a.get(i)はaとiが分離しているから変数が2個いる
Iteratorクラスを作れば変数を1個減らせる (クラスは1個増える)

あくまで減らすのが目的だから
良いクラスを増やせば良いことがあるみたいな言い方はおかしい

冗長さが実用上ハンデになるか否か議論したくても
まとまったソースコードも無いんじゃ水掛け論だよ

せめて、スレに出て来た御題のどれか一つでも解いてくれたら……

Java8からクロージャも書けるようになるから、ブロックがどうのこうのって議論もあれだな
今でもScalaとかあるけど

クロージャじゃなくてSAMタイプの構文糖だけど、言いたい事は分かる

ソートアルゴリズムと比較関数をStrategyとして受け取って、
ソート後に出力するというStrategyパターンの例（Java）


import java.util.*;

interface SortStrategy<T> {
void sort(List<T> l, Comparator<T> comp);
}

class CollectionsSortStrategy<T> implements SortStrategy<T> {
public void sort(List<T> l, Comparator<T> comp) { Collections.sort(l, comp); }
}

class Context<T> {
private SortStrategy<T> sort;
private Comparator<T> comp;
public Context(SortStrategy<T> sort, Comparator<T> comp) { this.sort = sort; this.comp = comp; }
public void execute(List<T> l) { this.sort.sort(l, this.comp); System.out.println(l.toString()); }
}

class StrategyExample {
public static void main(String[] args) {
Context<Integer> context = new Context<Integer>(new CollectionsSortStrategy<Integer>(),
new Comparator<Integer>() { public int compare(Integer v1, Integer v2) { return v1 - v2; }});
context.execute(Arrays.asList(new Integer[] {3,1,2,4}));
}
}

>>623
えと、共通部分は省略してください。
ライブラリの実装までわざわざ書きますか？
importも不要です。そんなのエディタが勝手に処理するじゃないですか。

guavaを使ったソートの例 (Java)
http://www.zecun.org/?m=201203

Ordering<Foo> ordering = Ordering.natural().nullsFirst().onResultOf(new Function<Foo, String>() {
　public String apply(Foo foo) {
　　return foo.sortedBy;
　}
});

つまりJava使いは自分でライブラリは実装しないと

そりゃドカタと言われますわ

http://d.hatena.ne.jp/mtoyoshi/20100725/1280040233

List<Integer> list = Ints.asList(1,2,3,4,5);
List<Integer> evenList = (List<Integer>)Collections2.filter(list, new Predicate<Integer>() {
　　@Override
　　public boolean apply(Integer input) {
　　　　return input % 2 == 0;
　　}
});

List<Integer> list = Ints.asList(1,2,3,4,5);
List<Integer> negativeList = Lists.transform(list, new Function<Integer, Integer>() { // -1,-2,-3,-4,-5
　　@Override
　　public Integer apply(Integer input) {
　　　　return -1 * input;
　　}
});

>>625
あ、車輪の再発明だから
ライブラリがあるものを書くなって意味か
お前が馬鹿だったｗ

ソートはどうでもいいけど、ストラテジパターンはよく使う
これが冗長だとキツい

このスレのお題をjavaで書くとこうなる
一件ジェネリックスが面倒だけど、エディタが補間してくれるので
そうでもない
　int[] a = {1, 3, 4, 5, 7, 9, 10, 11, 13};
　List<List<Integer>> r = new ArrayList<List<Integer>>();
　for (int i = 0; i < a.length; i++) {
　　if (i == 0 || a[i - 1] != a[i] - 1) {
　　　r.add(new ArrayList<Integer>());
　　}
　　r.get(r.size() - 1).add(a[i]);
　}

Java7ならこう書けるはず。new ArrayList<>();

結局型安全という付加価値をつけた分
コードが長くなってるだけで、冗長ではないんだよ

型安全のメリットを失ってまで短くするのは
本末転倒ってもんだ。

>>629
> ストラテジパターンはよく使う

よく使うってのは、ストラテジパターンを使ったライブラリの
利用者側か？それともライブラリ側か？

もしライブラリ側ならそれは設計がまずいとしか思えない。
ジェネリクス使わないで型ごとに作ってたりな。

ライブラリの利用者側なら、大してコード多くないだろ。
コードの大半はエディタが未実装のメソッドのテンプレートを生成してくれるし。

>>627
この冗長なコードをリンク付きでLLスレに貼るとか
鬼畜かお前は

ん？で？

>634
冗長なレスだなｗ
馬鹿には、「で？」だけでいいだろｗ

プログラミング言語Jochoって言語作りたくなってきた

まじめな話をすると、ちゃんとインデント付けて
キーワードハイライトもあると、>>623ですら結構スラスラ読める
型のところは色が付くから、型を読む必要が無いときは読み飛ばせる

>>627をRubyで書くとどうなるの？

そんな話はしていない。sortもcompareも
ライブラリがあるのだからそれを利用しろと。

そしてmainとかimportは何度も書くものじゃないんだから
実際に書く必要があるコードだけを書いてくれということ。

rubyのコードと”文字数”で比較してみようぜ。

「文字数」ならcのゴルフコードが結構いい線行くと思うけど、
LL好きにとっては、cがいい言語で、ゴルフコードが素晴らしい書き方なの？

>>636
っCOBOL

型を書く必要があるから「文字数」で不利ってわかってて言ってるんだろうな
そんなものは重要じゃないと言ってるのにいくら言っても分からない

型安全というメリットが追加されてるんだから
こんなもんでしょ。

運用系みたいに1000行も行かないような
小さなスクリプト書くなら、型安全なくてもいいけど

それを大きく超える。一人で全部把握できないようなものは
型安全ないとやっていけないよ。
型安全がないとコード修正の影響範囲がつかめない。

>>631
いや、それでも少し冗長ではあるよ
Scalaなら>>630が>>364になるんだし
ただ、それが問題になるほどのことなのかは
議論の余地あり

>>364って改行を無理やり減らしただけじゃねーかｗ
そんなトリックに騙されると思って？

val a = List(1, 3, 4, 5, 7, 9, 10, 11, 13)
var r = ListBuffer[ListBuffer[Int]]()
a.indices.foreach(i =>
　if (i > 0 && a(i) -1 == a(i -1))
　　r.last + a(i)
　else
　　r + ListBuffer(a(i))
)

>>646
だから、それでもこっちの方が簡潔なんだが

>>638
元のコードを留めた程度に書くなら
even_list = list.select{| input | n % 2 == 0 }
negative_list = list.map{| input | -n }
かなあ、実際は偶数判定をするメソッドが既にあるのでもっと簡潔だが

間違えた n は input に脳内変換してくれ

>>647
簡潔じゃないとは言ってないよ
空白改行除いて、Javaでは181文字だったのが143文字まで減っている。
38文字タイピング文字数を減らせている。

>>627はJavaだと普通に
　List<Integer> list = Arrays.asList(1,2,3,4,5);
　List<Integer> r = new ArrayList<Integer>();
　for (Integer e:list) {
　　if (e % 2 == 0) r.add(e);
　}
　r = new ArrayList<Integer>();
　for (Integer e:list) {
　　r.add(-e);
　}
って書くけど、これじゃ駄目なの？
無理矢理なんちゃらパターンやら小難しいこと考える必要あるんか？

>>650
そうだね。だから少し冗長だね。と言ってるんだけど
何を反論したいの？
同じ意見じゃん

>>648
> 実際は偶数判定をするメソッドが既にあるので

Javaにもそれがあったら（なければ作ればいいだけだけどｗ）

List<Integer> list = Ints.asList(1,2,3,4,5);
List<Integer> evenList = (List<Integer>)Collections2.filter(list, new Predicate<Integer>() {
　　@Override
　　public boolean apply(Integer input) {
　　　　return input % 2 == 0;
　　}
});

このコードはここまで短くなりそう。

List<Integer> list = Ints.asList(1,2,3,4,5);
List<Integer> evenList = (List<Integer>)Collections2.filter(list, MyUtil.Filter);

>>651

>>653みたいによくあるアルゴリズムを
関数化することでコードを短く出来る。

>>654
わかりにくいだけじゃん
651でも十分簡潔で分かりやすいコードなんだが
無理矢理短くしてもメリットあまりないと思うけど

あとバグの可能性が減る。
結局のところ　return input % 2 == 0;　の
比較行しか見なくて済むから、
このコードは実質たったのこれだけとかんがえられる。

たかがこの程度でバグの可能性が減るってのは本当かどうか怪しいな
この例は元のコードが簡潔だから良い例じゃない
しかし、ちょっと前にも、ジェネレータやらgroupbyでバグの可能性が増えてたから
LLで関数型スタイルが良いんだというのは結局思い込みじゃないの

>>655
そりゃ今回は条件の内容がわかりやすいからだろｗ

もし複雑な条件でも、その条件だけを入れ替え可能になっている。
使うときはすごく簡単になるぞ。

>>658
仮に複雑な条件でも、どちらの書き方でもif文が複雑になるでしょ
外側のforで回す構造は簡潔かつ分かりやすいままじゃん
そんなメリットだとは到底思えないけど

>>659
if文を分離できるって所が重要なんだよ。

コードの内容は同じでも、それを使う部分が凄くシンプルになる。
そしてif文の中身が交換可能になってる。
同じインターフェースを持っているものに入れ替え可能という追加機能がある。

※filterの中身は外部から与えられる。
List<Integer> evenList = (List<Integer>)Collections2.filter(list, filter);

どちらもコードは同じようにシンプルなら
追加機能がある法が良い。

>>660
何が重要なのかさっぱり分からない
簡潔なfor文書けば良いだけなのに
そんなにfor文繰り返すのが嫌なのか？

Interfaceつかうコードにメリットが見いだせないのか、
お題が単純だからロジックを分離するほどでもないって意味なのかどっちなんだろう。

filterやmapごときなら、単純なfor文で代用できるので分離に躍起になるほどではない。
ソートのようなもっと複雑な制御ロジックなら、ロジックを分離する意味が
大きいかもしれないが、そう頻繁にあることではないし、その場合にはInterfaceを使えるわけだし
java8ではそれも簡単になるだろう

大体、そんなにLLが優れているなら、GCJなどの大会でLLが席巻していないとおかしいだろう
現実はC++が最も実績を残しているし、Javaもそれに次いで多い

問題に応じて複数の言語を用意しておくものじゃないの
というか、ああいう競技だと問題が大きくて
制限時間に収まらないとかがあるから

GCJってGNUのJavaのやつしか知らんが
大会ってそもそも「何分で実装出来るか」じゃなく
「制限時間内でどれだけ効率の良いプログラムに出来るか」
を競うのが主流じゃないのん？LLにとっては不利な条件でしょ

LLに不利なことがあるなんて・・・・

世の中不利なことばかりです

JavaとかC#はIDEの補完が効くから実際のタイピング数は少なくて済むよね。

>>666
残念ながらそういう条件じゃない
GCJの場合はLLでも完全に間に合うように作ってある
過去にはPythonで一位になった人もいた
スピードが大事で、まさに「何分で実装できるか」のような
大会
そういう大会で上位陣にはC++やJavaが多い

>>646
Haskellだと>>630が>>374になるよ
Scalaよりさらに短い

>>670
http://www.go-hero.net/jam/12/languages/6

実際のところ、LL使いは殆ど参加してない

あと実行速度も超重要だから、特にLarge > GCJ

>>672
それはLLがこの大会で有利な言語じゃないからみんな使わないだけ
>>673
Largeでも十分LLで間に合うよ

> それはLLがこの大会で有利な言語じゃないからみんな使わないだけ

速度的に不利だからね

てか、>>672のグラフは決勝に残った人がLLを全く使ってないということを示してるだけじゃん。
LL使いは決勝までに全員敗退したんでしょw

速度的に不利だからね

>>675
だから速度は全く関係ない。正しいアルゴリズムならLLで間に合うように作ってある。
しかも、間に合うか間に合わないかの二択で点数決まるから、全く不利にならない。

C++なら正しくなくても力技で解けるけどね

ちなみに2011年はPythonが優勝した(まあ決勝の他の人は全部非LLだったけど)
LLでも間に合うように作ってあるからそういうことも可能
LLの速度は全然不利ではない

>>679
そんなことになるのは予選やRound1くらい
決勝近くなってくると、問題はちゃんと洗練されるから
そんなことにはならない

C++勢はSmallを力技で解いてポイント稼ぎ

>615
C++も最近出来るようになったね

>>682
例えばどの問題？
LLでも力技で間に合うように作ってあるんだが。
pypyに代表されるように、JITコンパイラで最近のLLは結構速いしな

LL使いって、関数がお膳立てされている世界で生きてるから
そんなのが通用しない、自分で問題を解くような世界では
生きられないんだよｗ

C++は安全性を重視しない点はLLに似ているよね
間違いを事前に防止できなくても後で直せばいい
現に、Java7がだめでもJava8で改善すればいいって開き直る奴が最強だからな

Haskell知らないんだけど、>>374ってLispっぽいcarcdr式の
パターンマッチしか使えんの？foldrで逆からになっててわかりにくい
こういう風にリストの末尾でパターンマッチしたいんだけど

f ys:y x | y ==x-1 = ys:(y:x)
f ys x = ys:[x]
main = print $ foldl f [] [1,3,4,5,7,9,10,11,13]

右畳み込みと左畳み込みで分かり易さが違うとは、これいかに

a + (b + (c + d))
(a + b) + c) + d

だって、普通先頭から末尾に向かって処理していくでしょ

>>687
リストでは無理
遅延評価のおかげで無限列でも動くし、foldrに慣れてください、としか

>>689
先頭から順番に処理してますよ > foldr

>>690
意味が分からん
>>687でも無限列で動くでしょ

>>691
どういう意味？
ysは後ろの数字からリストに入ってきて大きくなっていくでしょ

ああ、意味が分かった
遅延評価してるって言いたいだけか
でも、それは687に対するメリットではないし、基本的に演算の左辺と右辺の優先順位が右辺になってる
ことに変わりはないよね

>>692
無限列の末尾なんて取れないでしょ
lastを取ろうとした所で無限ループ

>>694
パターンマッチング適用時点では、常に無限でないリストが入ってくるから
そうはならない

>>695
> パターンマッチング適用時点では、常に無限でないリストが入ってくるから

リストが無限列かどうかを判定するのは無理だし、
可能だとしても無限列が入ってきたら
マッチするパターンが存在しなくて>>687は動かない

>>696
少なくとも687に関して言うなら、ｆの引数として絶対に無限列は入ってこないよ
作成途中の非無限列しか入ってこない

>>697
ああ、そうでした
完全にこちらの間違いでした

え？w
2chでそんなに素直に謝る人初めて会ったw
君は凄い人だねw

いやいや、実は>>374は無限列で動かないので
最初の前提から間違っていたw
恥ずかしいww


言いたかった事は、下のような関数定義で
上は無限列でもOKだけど、下はダメだよ的な事が言いたかった...

map f = foldr (\x xs -> f x : xs) []
map f = foldl (\xs x -> xs ++ [f x]) []

>>700
ちょっとわからないのは、
(1) >>374も>>687も動かないのはなぜか
(2) 両方動かないのならやっぱり、末尾のパターンマッチが駄目な理由にはふさわしくないのでは？
(3) mapで上はいいのに、下は駄目な理由は？(Haskellがそういう実装になってるのはどういう理由なのか。止むに止まれぬ理屈なのかどうか)

foldl'

>>680
そもそもweb系言語で計算量について考えるような問題領域なんてあるの？

>>701
(1)正直よく分からない。動きそうなんだけど、どこかで評価が止まらない...

(2)末尾だけパターンマッチできればOK？それとも先頭と末尾の両方をパターンマッチできる必要有り？

(3)説明が難しいんだけど、例えば>>700で map f [1..4] って式は、

上： f 1 : (f 2 : (f 3 : (f 4 : [])))
下：((([] ++ [f 1]) ++ [f 2]) ++ [f 3]) ++ [f 4]

って感じになる。head $ map f [1..4] ってすると、どちらも f 1 を返すけど
上の式は遅延評価により (f 2 : (f 3 : (f 4 : []))) はまだ評価されない
一方、下のほうは ++ を内側まで評価しないと f 1 まで行き着かない

c++やjavaで何かしら問題を解く上で計算量について考える場面に出くわすことがあったとしても、
スクリプト言語でどーこーするような領域で計算量について深刻に考える方がどこかおかしい。

さすがにO(1)とO(n)とO(n log(n))とO(n^2)の違いくらいは意識するでしょ

その昔、perlのsortやhashの内部実装についての書籍でオライリーが儲けていたよね

Rubyのhashは1.8までメモリリークしてたよ

pythonがwebで主流になれなかった理由がインデントのせいってことに1ペリカ

pythonには標準のGUIのライブラリが必ず入ってるからじゃないの？

想像だけど、htmlやxmlに組み込んだ際に、インデントでワケワカメになるからだと思ふ
てか、python標準のGUIライブラリってドレになるの？tk?gtk?wx?
rails製のmetasploitがCGIによるインターフェースってあたり、
クロスプラットフォームなGUIほど混沌とした世界もないんじゃないかな

標準って意味ではtk
ttkもサポートされて見た目は改善されたが、もうtkってイメージだけでね...

tkって、枯れてて、さっさと仕事片付けろってな用途にはピッタリじゃね？

事実上wx辺りがメインになるかねえ

wxはandroidからiOSまでと公式が風呂敷を広げたもののコミッタ、メンテナが集まらなかった不遇の子
そのうち、wxhtml5とか出来てそう。

>>621
ようやくクロージャ入るんだ、ありがたい。
ラムダは7から入ってるんだっけ？

クロージャが入ると匿名クラスで書かなくて良くなるから
3行ぐらい行数が減らせるんだっけ。
まあその3行はエディタが自動生成してくれる部分なんだが。

クロージャーとラムダの違いって何？
概念とか言葉で説明するんじゃなくて
具体的な違いが知りたい。

　　　＿＼.ｰ､ヽ } Ｖレ〃ﾚ７／ﾉ　　__
　　　＞ ｀ヽ　ヽ)　　　　　 ´∠ｒ " ／_
　＿,..ゝ　　　　　　　　　　　 　　　_∠
　＞　　　　　　,.....---....､　　　　∠、
⌒＞　　　　／:::::::::::::::::::::＼　　 ＿_.>
　　｀＞､　./:｢ﾄL｢¨Ｍ¨'ヽ､::::!／
　　　　￣7Y´､＿_,　 ､＿, Ｙ′
　　　　　ノ∧ ＜・｣ , L･＞ !}_＿
　　ｒ‐v'´:::::ヾ:､ 　 ｒ−､　 ./::::::::::|｀L、
..／!　i:::::::::::::::/ヽ　￣ _ イ:::::::::::::! ｌ　ヽ
　　i　l:::::::::::::::l ＿ ￣　　 〉::::::::::::! ｌ　　ヽ
これがクロウじゃ

そしてこれがラムだ
　　　　　　　　　　　　　　＿＿ ,､__
　　　　　　　　　　,, -,,' ´￣" ｀ ''ｰ｀､ ｀ヽ.　　　　　　　　　
　　　__＿ ,,.. -' "／　{　｀　-一-ヾ　ヽ.　 ヽ 　　　☆
　／　　　　　 ▽　/ ∧　ヽ､,　_,,　　}}_} ・　 ii　／
/　　　　　　　 {　 {ゝ{__｀ｰ-Ｙ´f｡Vﾊ'V } * ・ ii
!　〃　　　　　 i　 ﾊ ´{ ヽ　　 ､ソ　 } く　 ☆ ii 　 　　　　　　　　
ヾ{{　　　　☆　｀ヾ､_｀ヽ'^' ヽ　　　" ! ! i ﾟ　:　iｉ 　　　　　　　　　
　 ヽ{{　　*　.　　　　　 ﾊ　　く）　／.l､! !　 ;　.ii　　　　　　　　　 　
　　　ヾ､.　　　　　　　 {　｀　ｰj‐'　　{ﾑﾉ_　　 ﾉ 　 　 　　　　　　　
　　　　　ヾ　　　　　　 , '´ ￣ｰ‐‐-　'　　 ｀ く　　　　　　　　　　　
　　 　 　 　｀ ｰ---─,'　　 　　　　　 ､　　　､}　　　　　　　　 　 　 　
　　　　　　　　　　　 ,'　　 ,〈　, -ｰ‐-､i∠⌒ヽ　　　　　　　　　　　
　　　　　　　　　　　,'　　∧＜=ﾆ二‐ノヽ､二ｿ　　　　　　　　　　　
　　　　　　　　　　 /　 ./　}　 ｀"''' "; 　｀7Ｔ´　　　　　

Java8に入るのは紆余曲折を経た上、クロージャではなくラムダだとか
ブロック云々程度ならラムダで十分ではあるが

クロージャーはスコープが広すぎるっていう問題があるんだよね。

クロージャの中からその外のスコープの変数が丸見えになっちゃう。
もちろん書き込みの可能。

便利なこともあるのだけれど、クロージャーの中は
その中でスコープは閉じていて欲しい。
関数と同じで引数と戻り値があるのだから十分なはず。

そう考えるとラムダのほうが優れてるかな。

ごめん、何言ってんのか分かんない

クロージャの内側からの可視性は
（たぶんほとんどの言語で）その外側の関数内までなので
そこまで広いとは言えないと思うが

問題になるとしたらエクステントの方で、無限エクステントになってしまう
寿命が確定できないのはある意味めんどくさい
とはいえ、普通はGCに管理を任せるから問題にはならないけど

ごめん、エクステントって何？

Scalaがあるので、SAMタイプの構文糖（ラムダより劣ってる）なんてどうでもいい

>>718
関数() {
変数aを宣言;
関数内関数() {
// ここから変数aにはアクセスできなかったり、制限付きだったりする
}
}

関数() {
変数aを宣言;
クロージャ {
// ここから変数aに自在にアクセスできる
}
}

クロージャ = >>726の下のような性質を持った関数
ラムダ = 無名関数
なんじゃないの？
ラムダかクロージャーかっていう表現は少しおかしい気がする

イギリスのRubyカンファレンスBritrubyが人種・性別差別問題で開催中止に
http://developer.cybozu.co.jp/akky/2012/11/britruby-cancelled/

>>727
クロージャか非クロージャか…だね本来の区別は
元がラムダ(=無名関数)があってもクロージャがない環境の話だからじゃないかな

て

【お題】
整数が入っている入れ子のリストから、
入れ子構造は保ったまま奇数のみを取り出す関数を書け
入れ子の深さは制限せず、空リストは取り除く事

例： [1, [2, 3], 4, [[5, [6]], 7]] #=> [1, [3], [[5], 7]]

>>731
Common Lisp

(defun f (l)
(labels ((g (m)
(cond ((listp m) (delete nil (mapcar #'g m)))
((oddp m) m))))
(g l)))

(f '(1 (2 3) 4 ((5 (6)) 7))) ; => (1 (3) ((5) 7))

>>731
Squeak Smalltalk

| collectOdd |
collectOdd := nil. "for compiler"
collectOdd := [:arr |
　 arr inject: #() into: [:acc :elm |
　　 true caseOf: {
　　　 [elm isArray] -> [acc, {(collectOdd value: elm) copyWithout: #()}].
　　　 [elm odd] -> [acc, {elm}]}
　　　 otherwise: [acc]]].

collectOdd value: #(1 (2 3) 4 ((5 (6)) 7)) "=> #(1 (3) ((5) 7)) "

>>731
@Mathematica

f[lst_] := Module[{dropEven, rmEmpty},

　dropEven[lstx_] := Which[
　　lstx == {}, {},
　　ListQ[First[lstx]], Prepend[f[Rest[lstx]], f[First[lstx]]],
　　OddQ[First[lstx]], Prepend[f[Rest[lstx]], First[lstx]],
　　True, f[Rest[lstx]]];

　rmEmpty[lstx_] := Module[{lst1, lst0},

　　lst0 = {};
　　lst1 = lstx;

　　While[lst0 != lst1, lst0 = lst1;
　　　lst1 = lst1 // ToString //
　　　　StringReplace[#, {", {}" -> "", "{}" -> ""}] & // ToExpression];

　　lst1];

　lst // dropEven // rmEmpty];


In := f[{1, {2, 3}, 4, {{5, {6}}, 7}}]

Out = {1, {3}, {{5}, 7}}

訂正：

dropEven 内の f は dropEven の間違いｽﾏｿ。正しくは↓

dropEven[lstx_] :=
　Which[lstx == {}, {}, ListQ[First[lstx]],
　Prepend[dropEven[Rest[lstx]], dropEven[First[lstx]]],
　OddQ[First[lstx]], Prepend[dropEven[Rest[lstx]], First[lstx]],
　True, dropEven[Rest[lstx]]];

>>728
rubyのコミュニティ自体に、宗教やジェンダー、学歴、雇用制度といった山ほどの社会問題が見つかるが
そこに更に人種問題が加わったわけだ。きっと神の思し召しだな。つまり、新しい時代へのイノベーションだ

>>732-735
おまいらって、この手の問題、何分ぐらいで解いてるの？

>>731
Squeak Smalltalk >>733とは別解

| oddNums |
oddNums := nil.
oddNums := [:elem |
　 true caseOf: {
　　 [elem isArray] -> [(elem gather: oddNums) ifNotEmpty: [:arr | {arr}]].
　　 [elem odd] -> [{elem}]}
　　 otherwise: [{}]].

#(1 (2 3) 4 ((5 (6)) 7)) gather: oddNums "=> #(1 (3) ((5) 7)) "

>>731
Scheme

(define (f l)
　(fold-right (lambda (x y)
　　　　　　　　(let ((z (cond ((list? x) (f x))
　　　　　　　　　　　　　　　 ((odd? x) x)
　　　　　　　　　　　　　　　 (else '()))))
　　　　　　　　　(if (null? z) y (cons z y))))
　　　　　　　'()
　　　　　　　l))

(f '(1 (2 3) 4 ((5 (6)) 7))); => (1 (3) ((5) 7))

>>731
Perl
use List::Util qw(reduce);

sub odd_list {
    reduce{
        sub{
            $_[0]->($_[1]) ? [@{$a}, $_[1]] : $a
        }->(
            ref $b ? (sub{ @{$_[0]} }, odd_list($b)) : (sub{ $_[0] % 2 }, $b)
        )
    } [], @{$_[0]}
}
my $r = odd_list([1, [2, 3], 4, [[5, [6]], 7]]);

>>731
Haskell

{-# LANGUAGE MonadComprehensions #-}
import Data.Maybe

data T a = L a | N [T a]

f (L x) = [L x | odd x]
f (N xs) = [N ys | let ys = mapMaybe f xs, not$null ys]

t = f $ N [L 1, N [L 2, L 3], L 4, N [ N [L 5, N [L 6]], L 7]]

おなにーすれ

御題が出るとJavaドカタの書き込みが止まるスレ

そもそもLLスレだしw

>>737
自分は1時間くらい。

>>731 Rubyで
def select_odd(a)
a.map do |x|
case x
when Numeric
next x.odd? ? x : nil
when Array
select_odd(x)
else
x # or raise "type error :#{x.inspect}"
end
end.reject{|x| x == nil or x == []}
end

p select_odd [1, [2, 3], 4, [[5, [6]], 7]]
# => [1, [3], [[5], 7]]

>>731 Rubyで手抜き

p eval( [1, [2, 3], 4, [[5, [6]], 7]].inspect.gsub(/\d*[02468][,\s]*/,'').gsub(/(?<!^)(\[(?:\g<0>+|[,\s]*)\][,\s]*)/,''))
# => [1, [3], [[5], 7]]

ネストした空の角カッコ対を削除する正規表現にいまいち自信が無い

ｐｈｐで苦労している。

この言語は、ＳＵＢＭＩＴ　でデータを受け取るのに、

SUBMITで　入力データを受け取り操作に関する命令文を　
<　input　type="text" >

のあとに書かなくてはならない。５行づつの一覧表入出力を作っているので

更新した後、その更新行のところに再表示させるために
リダイレクトしてページ再表示したいんだけど
java ｃ＃　vb.netだとredirect　命令で簡単にできるけど

phpのheader命令は、 ｈｔｍｌの入出力のあとに
書くと動作しない。

かといって　
<　input　type="text" >の前だとsubmit でデータが受取れてない。
なんかいい方法ないの？リダイレクトの方法。

日本で頑張れやー

解読に苦労している。

httpの仕組み理解すればわかると思うよ>>748

>>748
ページを更新してもフォームの値を保存するってこと？
普通Cookieとか外部ファイルでやらない？

馬鹿には無理

つかえる　げんご
つかえない　げんご
そんなの　じょうしの　きぶん

はいはいドカタドカタ

>>748

なんとかできました。
submitでとにかく無理やり、form action でクエリつけて
そのクエリから飛ばすようにしました。

print "<form method='POST' action='compsql.php?count10=".$startcount10."&ppk=1' > " ;

if (isset($_GET["ppk"]) ){
if ($_GET["ppk"]==1 ){


header("Location:compsql.php?count10=".$startcount10."&ppk=10") ;

}
}


多分、多分岐の場合は、他のプログラムphpにとばして、そこで分岐させるみたいな方法でしょうね。
C# VB.NET JAVA では同じプログラムファイルで簡単にできることが
headerの限定された、能力で、めんどい。
これって欠陥だよね。header がhtml内容に影響されるって。

ソース頻繁に上がるようになったのはいいけど何の話してんの？

俺からみて何の話しているか分からないってことは
多分中身のないレスで新着５０は埋め尽くされている

頭に欠陥のある人ですねわかります

おっと、檻の中から一匹がこちらに向かえって吠えてきた

土台になりたがる奴がいないと社会は周らない
その檻の中で順位付けをし、争い続けるが良い

>>731 Prolog

'整数が入っている入れ子のリストから、入れ子構造は保ったまま奇数のみを取り出す'([]
,[]).
'整数が入っている入れ子のリストから、入れ子構造は保ったまま奇数のみを取り出す'(L1
,L2) :-
　　　　'入れ子構造は保ったまま奇数のみを取り出す'(L1,L2,R1,R2),
　　　　'整数が入っている入れ子のリストから、入れ子構造は保ったまま奇数のみを取り
出す'(R1,R2).

'入れ子構造は保ったまま奇数のみを取り出す'([List1|R1],[List2|R2],R1,R2) :-
　　　　list(List1),
　　　　'整数が入っている入れ子のリストから、入れ子構造は保ったまま奇数のみを取り
出す'(List1,List2),!.
'入れ子構造は保ったまま奇数のみを取り出す'([A|R1],[B|R2],R1,R2) :-
　　　　1 is A mod 2,!.
'入れ子構造は保ったまま奇数のみを取り出す'([_|R1],R2,R1,R2).

取り\n出す になっている所は、改行してはいけなかった。コピペのミス。

>>731 Prolog 他にミスがあったから書き直し。'整数が入っている入れ子のリストから、入れ子構造は保ったまま奇数のみを取り出す'([],[]).

'整数が入っている入れ子のリストから、入れ子構造は保ったまま奇数のみを取り出す'(L1
,L2) :-
　　　　'入れ子構造は保ったまま奇数のみを取り出す'(L1,L2,R1,R2),
　　　　'整数が入っている入れ子のリストから、入れ子構造は保ったまま奇数のみを取り出す'(R1,R2).

'入れ子構造は保ったまま奇数のみを取り出す'([List1|R1],[List2|R2],R1,R2) :-
　　　　list(List1),
　　'整数が入っている入れ子のリストから、入れ子構造は保ったまま奇数のみを取り出す'(List1,List2),!.
'入れ子構造は保ったまま奇数のみを取り出す'([N|R1],[N|R2],R1,R2) :-
　　　　1 is N mod 2,!.
'入れ子構造は保ったまま奇数のみを取り出す'([_|R1],R2,R1,R2).

また失敗したけれど、もう直しません。すみません。

ナイストライ
Prologの面白さや、やりたいことなんかが良く分かるね

>>764
空リストは取り除く事という部分の手当を忘れていた。

>>731
Javaで動的型付け

Object selectOdd(Object x) {
  if (x instanceof Integer) {
  return (Integer)x % 2 == 1 ? x : null;
  } else if (x instanceof List) {
  List lst = new ArrayList();
  for (Object y : (List)x) {
  Object z = selectOdd(y);
  if (z != null) {
  lst.add(z);
  }
  }
  return lst.isEmpty() ? null : lst;
  } else {
  return null;
  }
}


http://ideone.com/7ZJtm5

>>764
% 文字数が多くなり制限に掛かるかも知れないから、後半の述語だけ。
% 前半の述語は述語名に但し書きを付加。空リストを排除するためリスト構造を示す表現を変えた。

'入れ子構造は保ったまま奇数のみを取り出す。ただし空リストは取り除く事。'([[A|B]|R1],[[C|D]|R2],R1,R2) :-
　　　　'整数が入っている入れ子のリストから、入れ子構造は保ったまま奇数のみを取り出す。ただし空リストは取り除く事。'([A|B],[C|D]),!.
'入れ子構造は保ったまま奇数のみを取り出す。ただし空リストは取り除く事。'([N|R1],[N|R2],R1,R2) :-
　　　　integer(N),
　　　　1 is A mod 2,!.
'入れ子構造は保ったまま奇数のみを取り出す。ただし空リストは取り除く事。'([_|R1],R2,R1,R2).

>>766
結局Javaが一番分かりやすい件

【お題】
1) 1〜100からランダムに抽出した整数10個を要素に持つ配列を作成し、
2) その平均値と、
3) 各要素の平均値からの差の二乗値の平均の平方根（標準偏差）を算出して、
4) 1)〜3)の結果を出力するコードをどう書く？

言語のベーサルな表現実装力が見てみたいので、
可能であれば import や require 等の
機能追加をしない素の状態でのチャレンジが望ましい。

出力例：
[77, 62, 26, 17, 88, 40, 14, 11, 4, 49]
38.8
27.85964823898536

正直、デフォでこれら機能を有する統計処理のLL達のアピールを期待したお題だけれど
ループ等でしか書けそうもない普通のLL勢もひねりを加えるなどして面白くして欲しい。

つまんねーお題いらね
次

デフォルトの名前空間にインポートされてる機能の有無で
優劣付けようなんて馬鹿じゃないの？

>>769
Excel

=INT(RAND()*100)
=INT(RAND()*100)
=INT(RAND()*100)
=INT(RAND()*100)
=INT(RAND()*100)
=INT(RAND()*100)
=INT(RAND()*100)
=INT(RAND()*100)
=INT(RAND()*100)
=AVERAGE(A1:A9)
=STDEVP(A1:A9)

だってさー
ただの平均だよ平均
どんなバカでも頭の中で一瞬でJavaの全ソースコードが書けるお題なんだぜ？
何がアピールだよw

>>769
R

data = sample(1:100, 10)
data; mean(data); sd(data)

【お題】
コラッツ予想とは、「任意の0でない自然数nをとり、
・nが偶数の場合、nを2で割る
・nが奇数の場合、nに3をかけて1を足す
という操作を繰り返すと、有限回で1に到達する」という主張である。

nからスタートして1に到達するまでのステップをsとしたとき、
n = 1 .. 100000についてsを計算し、最長のsを出力せよ。

ただし、それぞれのnに対するsの計算は並列（スレッド、プロセス問わない）で行う事。

>任意の0でない自然数nをとり

そもそも自然数って0含まないだろ。

>777

>>776
文科省乙とでも言えばいいのだろうか
自然数に0を含める流儀は数論や計算機科学など中心に
結構あるからどっちかはっきりさせる意味でも一応断ったんだろ

とでもマジレスすればいいのだろうか
それともここはギャグで返すべきだったのだろうか

>>775
http://toro.2ch.net/test/read.cgi/tech/1200989025/190-192
http://www.e-mise2.ne.jp/

>>775
Scala

def collatz(n: Int): Int =
if (n == 1) 1
else if (n % 2 == 1) 1 + collatz(3 * n + 1)
else 1 + collatz(n / 2)

var max = 0
(1 to 100000).par foreach (i => max = math.max(max, collatz(i)))
print(max)

n==1のときは0で計算するんじゃないのか

>>781
すみません
def collatz(n: Int): Int =
if (n == 1) 0
else if (n % 2 == 1) 1 + collatz(3 * n + 1)
else 1 + collatz(n / 2)

var max = 0
(1 to 100000).par foreach (i => max = math.max(max, collatz(i)))
// print(max) => 350

>>775
Haskell


import Control.Parallel.Strategies

collatz 1 = 0
collatz n = 1 + collatz (if even n then n`div`2 else 3*n+1)

main = print $ maximum $ parMap rseq collatz [1..100000]

scala2
(for (i <- (1 to 100000).par) yield collatz(i)) max

>>783のScala版
def collatz(n: Int): Int =
if (n == 1) 0
else 1 + collatz(if (n % 2 == 0) n / 2 else 3 * n + 1)

(for (i <- (1 to 100000).par) yield collatz(i)) max

まーたparがあるかないかの勝負か
rubyはどうなん？

>>775
@Mathematica

maxStepCollatz[n_] := Module[{collatz},

　collatz[m_, s_] := Which[
　　m == 1, s,
　　EvenQ[m], collatz[m/2, s + 1],
　　True, collatz[m*3 + 1, s + 1]];

　Range[1, n] // Map[collatz[#, 0] &, #] & // Max];

In := maxStepCollatz[100000]

Out = 350

mathematicaわかりにくいなー
この言語は関数が結果を返せない上に、&やら//やらの意味不明の記号に
ModuleやらWhichやらのへんてこキーワードマスターしないと
使えないのか

馬鹿には無理

>>775
結果をキャッシュすると早く計算できるだろうな。
並列化とどう組み合わせるかが面白そうですね。

Haskell的にはControl.Parallel.Strategiesってどうなの？
純粋関数型だから評価順に意味がなかったんじゃなかったのか？

>>790
別に面白くはないんじゃね
配列にキャッシュ化するだけでしょ

>>790
Scalaメモ化バージョン
val mem = Array.fill(100000)(-1)
mem(1) = 0
def collatz(n: Int): Int = {
if (n < mem.size && mem(n) > -1) return mem(n)
val ret = 1 + collatz(if (n % 2 == 1) 3 * n + 1 else n / 2)
if (n < mem.size) mem(n) = ret
ret
}

(for (i <- (1 to 100000).par) yield collatz(i)) max
// 350

>>792
その程度のことが簡単には出来ない言語もあるのよ
Haskellとかねw

>>731
書き込みできず乗り遅れてしまったのだけど、折角なので

Ruby
def f(a)
a.map{ |x| f(x) rescue x.odd? ? x : [] }.select{ |x| x.size > 0 }
end
f [1, [2, 3], 4, [[5, [6]], 7]] #=> [1, [3], [[5], 7]]

>>792
小さい方から計算したほうが早そうなんだが、並列化で順番とか簡単にかける？

f(x) rescue x.odd? ? x : [] ←　言語制作者のオナニー機能

>>796
それを指定したら並列化の意味がないだろ
それに今回の場合、大きな数字から初めても最後には小さい数字に行き着くのだから、
小さい方から計算した方が速いってのもあんまり正しくなさそう

>>797
例外と三項演算子くらいC++とかでもあるだろ
x.odd? が嫌いなら x%2>0 にでもすればいい

>>798
小さい数字に行き着くのだから、小さい方から計算したほうが、
キャッシュにヒットしやすくなるようなきがするのだが。

Squeak Smalltalkで

>>769

| data average sd |
data := Array streamContents: [:ss | 10 timesRepeat: [ss nextPut: 100 atRandom]].
data := (1 to: 100) asArray shuffled first: 10. "重複を許さない場合"
average := data average.
sd := ((data - average) raisedTo: 2) average sqrt.
^{data. average asFloat. sd}


>>775

| queue memo mutex collatz range |
memo := Dictionary new.
mutex := Monitor new.
collatz := nil.
collatz := [:n |
　mutex critical: [memo at: n ifAbsentPut: [
　　true caseOf: {
　　　[n = 1] -> [0].
　　　[n even] -> [1 + (collatz value: n/2)]}
　　　otherwise: [1 + (collatz value: n*3+1)]]]].

queue := SharedQueue2 new.
range := 1 to: 100000.
range do: [:m | [queue nextPut: (collatz value: m)] fork].
range size timesRepeat: [queue next].
^(memo keyAtValue: memo max) -> memo max

単純にループまわすのに比べて、メモ化でどれくらい速くなるか気になるな。
メモ化変数の同期コストと比べてどうなんだろう？

あとCPU使用率と実行時間も
どれくらい並列化の恩恵があったのか

>>800
それは違うな
大きな数字でも小さな数字に行き着くのだから、結局一回目でキャッシュが作られるわけで

>>804
全部キャッシュすればそうだね

>>775
Perl

use threads;
use threads::shared;
use Thread::Queue;
use List::Util qw(max);

my %memo : shared = (1 => 0);

sub collatz {
    my ($n) = @_;
    return $memo{$n} // ($memo{$n} = 1 + collatz($n % 2 ? $n * 3 + 1 : $n / 2));
}

my $q = Thread::Queue->new;

sub f {
    while(defined(my $n = $q->dequeue)){
        collatz($n);
    }
}

my $thr_num = 4;
my @thr = map{ threads->new(\&f) } (1..$thr_num);
$q->enqueue(1..100000, (undef) x $thr_num);
$_->join foreach(@thr);

my $s = max values %memo;

# 色々�_。

それってRace Conditionは解決できてるのかい？

>>775
;;; Common Lisp メモ化
(defvar *max* 100000)

(defvar *memo*)

(defun memo (vlist s)
(dolist (v vlist)
(when (<= v *max*)
(setf (svref *memo* (- v 1)) s))))

(defun getmemo (n)
(when (<= n 100000)
(svref *memo* (- n 1))))

(defun collatz/memo (n s &optional (called (list)))
(cond ((getmemo n) (memo called (getmemo n))
(getmemo n))
((<= n 1) (memo called s)
s)
((evenp n) (collatz/memo (/ n 2) (1+ s) (cons n called)))
(t (collatz/memo (1+ (* 3 n)) (1+ s) (cons n called)))))

メモ化なしの
(defun collatz (n s)
(cond ((<= n 1) s)
((evenp n) (collatz (/ n 2) (1+ s)))
(t (collatz (1+ (* 3 n)) (1+ s)))))

を使った場合と、 >>808 を、
(setf *memo* (make-array 100000 :initial-element nil))
してから、1から100000まで昇順に適用した場合と降順で適用した場合でを比べてみた。
（CLISP、共にコンパイル済み。i5-2450M 2.5 GHz）
降順のほうが絶対速くなるだろー、と思ったけどあんま変わんねえ。

normal
Real time: 2.478142 sec.
Run time: 2.465 sec.
Space: 68472 Bytes

memo
Real time: 0.17101 sec.
Run time: 0.156 sec.
Space: 2302568 Bytes
GC: 2, GC time: 0.032 sec.

memo reverse
Real time: 0.17201 sec.
Run time: 0.172 sec.
Space: 2302568 Bytes
GC: 2, GC time: 0.032 sec.

>>806修正。
sub collatz {
    my ($n) = @_;
    lock(%memo);
    return $memo{$n} //= 1 + collatz($n % 2 ? $n * 3 + 1 : $n / 2);
}

# 何か間違えてる気もする。

メモ化は相当速くなってるな

>>775
並列化せずにメモ化だけした。C言語。
http://ideone.com/q8YIz2


100000じゃ速すぎて測定不能なので100000000までやった結果(Core i5 1.6GHz)。

> time ./collatz
949
./collatz  5.37s user 0.21s system 99% cpu 5.609 total

Scala Core2Duo 2.2GHz
速すぎるので100回繰り返した

def time(max: Int, f: => Unit) = {
val start = System.currentTimeMillis
for (i <- 1 to max) f
(System.currentTimeMillis - start) / 1000.0
}

println("メモ化並列 " + time(100, (for (i <- (1 to 100000).par) yield collatz2(i)).max))
println("メモ化直列 " + time(100, (for (i <- 1 to 100000) yield collatz2(i)).max))
println("並列 " + time(100, (for (i <- (1 to 100000).par) yield collatz(i)).max))
println("直列 " + time(100, (for (i <- 1 to 100000) yield collatz(i)).max))

メモ化並列 0.901
メモ化直列 0.584
並列 4.035
直列 6.461

よーわからんけど、100回繰り返しって
2回目移行はメモ化完了してね？

まあ実際には誤差みたいなもんでないの

>>812のコードで1〜100000を100回繰り返してみた。

メモ使い回し: 0.04s user 0.00s system 94% cpu 0.042 total
メモを毎回クリア: 0.31s user 0.00s system 99% cpu 0.319 total
メモをクリアする処理だけ: 0.01s user 0.00s system 81% cpu 0.013 total

クリアで結構遅くなってるな
メモ化はCやScalaみたいな言語だと計算が速すぎて効果はない？

>>816
すまんな。計測時間が10秒未満のデータは
信用しないことにしてるのだよ。

>>817
2回目以降はより速くなるんだから効果はあるでしょ

Scalaに合わせて100回にしたけど、流石に回数が少なすぎた。
というわけで、10000回繰り返しの結果。

メモ使い回し: 3.22s user 0.01s system 99% cpu 3.241 total
メモを毎回クリア: 28.46s user 0.04s system 99% cpu 28.570 total
メモをクリアする処理だけ: 0.68s user 0.00s system 99% cpu 0.692 total

普通に時間が100倍になってるだけだな
やっぱり遅くなってる
毎回クリアしたメモ化でメモ化無しより速くなってるの？

Scala C2D 2.2G メモクリア1000回
10秒未満だけどスマソ
こちらはメモクリアでほとんどスピード変わらない

def time(max: Int, f: => Unit) = {
val start = System.currentTimeMillis
for (i <- 1 to max) {
var mem = Array.fill(MAX)(-1L)
mem(1) = 0
f
}
(System.currentTimeMillis - start) / 1000.0
}
メモ化直列 5.787
メモ化並列 7.389
直列 70.827
並列 42.061

メモ化はええええ

>>821
10000回は中々終わらなかったので、100回繰り返し(>>816と同条件)

メモ化無し: 4.17s user 0.01s system 99% cpu 4.194 total

メモ化という言葉を初めて知った高校二年生の冬

>>824
遅くね？Core2DuoのScalaと一緒ぐらい？
Cori5のCの方が数段速いはずだが

急にRubyとPythonが静かになりましたw

単純すぎる計算だとクロック数が前面に出てくる

見たいもの

RubyとPythonの並列化コード
Haskellのメモ化コード
CoffeeScript、Gruvy、TypeScript、Gooのコード

uyには無理

GoなのかBooなのかはたまたGooという言語があるのか

CarといえばGooっていうぐらいだし
LISPの亜種だろ

>>822
実行時間は比べるべくもなく遅いがRでも
メモ化直列<メモ化並列<並列<直列だな

-- Haskell メモ化

import Control.Applicative
import qualified Data.Vector.Unboxed as V
import Data.IORef

num = 100000
memo :: IO (IORef (V.Vector Int))
memo = newIORef $ V.replicate num (-1)

collatz 1 = return 0
collatz n = do
  v <- readIORef =<< memo
  let s = if n < V.length v then v V.! n else -1
  if s /= -1 then return s
             else (+1) <$> collatz (if even n then n`div`2 else 3*n+1)

main = print . maximum =<< mapM collatz [1..num]

高木boo

さすがのHaskellもメモ化ソースは長くなったな

Rubyは標準では並列実行の機能はない
Windows以外だとforkをつかった並列実行ライブラリがあるみたいだが
Windowsユーザーはどうすりゃいいんだろう
JRubyだとスレッドが並列に動くが

近い将来の間にスレッドを並列実行できるようになる可能性はないが
複数のVMを並列実行できるようにはするそうなので
実現すればWindowsを含めた汎用的な並列化ライブラリを作れそうだけど
いったいいつになることやら……

windowsはそのうち無くなるから大丈夫

>>775 Python

from multiprocessing import Pool

def collatz(n):
    if n == 1: return 0
    else: return 1 + collatz(n / 2 if n % 2 == 0 else 3 * n + 1)

print(max(Pool(4).map(collatz, range(1,100000))))

>>838
近いうちに解散と言いつつ４年

どっちみちRubyってRails以外じゃ使い道ないから、Windowsで動かなくても誰も困らないだろう。
Python製のWindowsアプリはだいぶ増えてきたな。

>>839
さすがの横綱相撲だね
今回はpythonが優勝かな

わざわざ「return」が必要なところ、スレッド数を指定しないといけないところなど
HaskellやScalaに劣る部分もある。
完勝とは言いがたい。

C拡張のCilkとかで書けば色々うまく行きそうだ

【お題】
２つの箱がある。片方の箱には黒玉１つ、白玉１つ。
もう片方の箱には黒玉が２つ入っている。
どちらかの箱から玉を１つ取り出す(箱の中身は見えない)。
取り出した玉が黒であるとき、その玉を取り出した箱に残っている玉が黒玉である確率を求めよ。

>>843
プロセス数は省略できるよ
returnは書き忘れると実行時にNoneが返って来てアレってなるけど

>>845
Haskell

白が0, 黒が1


import Data.List

boxes = [[0,1],[1,1]]
residue = concat [delete x b | b <- boxes, x <- b, x == 1]

main = print (sum residue, length residue)


答: 2/3

>>847
@Mathematica

env={{"A",{"Black","White"}},{"B",{"Black","Black"}}};

p[box_, color_, env_] := Module[{pBallBox, pBox, pBall},

　pBallBox[colorx_, boxx_] := Select[env, #[[1]] == boxx &] // #[[1, 2]] & //
　　Count[#, colorx]/Length[#] &;

　pBox[boxx_] := Select[env, #[[1]] == boxx &] // Length[#]/Length[env] &;

　pBall[colorx_] := Map[#[[2]] &, env] // Flatten //
　　Length[Select[#, # == colorx &]]/Length[#] &;

　pBallBox[color, box]*pBox[box]/pBall[color]];

In := p["B","Black",env]

Out = 2/3

>>843
from multiprocessing import Pool
cllatz = lambda n: 0 if n == 1 else 1 + collatz(n / 2 if n % 2 == 0 else 3 * n + 1)
print(max(Pool(4).map(collatz, range(1,100000))))

>>849
Pythonのmultiprocessingはlambda受け取れないよってツッコミ待ち？

>>845
Perl

use List::Util qw(sum reduce);
use constant { WHITE => 0, BLACK => 1 };

my @boxes = ([BLACK, WHITE], [BLACK, BLACK]);
my @r = map{ $_->[1] } grep{ $_->[0] } map{ [@{$_}], [reverse @{$_}] } @boxes;
my $p = sum(@r) / @r;

# Haskell凄味があるなあ

>>851
内包表記が使えれば似たような事はできるし
srfi-42は機能が多い分記述も冗長だけど

(use srfi-42)
(let* ((x '((#f #t) (#t #t)))
　　　 (p (list-ec (:list b x) (:range n 2) (if (list-ref b n))
　　　　　　　　　 (list-ref b (- 1 n)))))
　(/ (count values p) (length p)))

>>845
Python

r = []
for b in [[0,1],[1,1]]:
    for i,x in enumerate(b):
        if x == 1:
            r.extend(b[:i] + b[i+1:])
p = sum(r) / float(len(r))

え　1/2じゃないのか
直感も当てにならんな

>>845
Squeak Smalltalk

| restBalls |
restBalls := #((黒 白) (黒 黒)) gather: [:box |
&nbsp;&nbsp; box select: [:ball | ball = #黒] thenCollect: [:ball | box asBag remove: ball; anyOne]].
^(restBalls occurrencesOf: #黒) / restBalls size "=> (2/3) "

>>853
ぱっと見分かりにくいポイント
b in [[0,1],[1,1]]:← 一瞬、bに0とか1が入るのかと思った
in enumerate(b)　← まあ、index付きで数えるんだろうなとは思うけど、
0から始まるのか1から始まるのか迷って、ああ0からだったかなみたいな感じになる
b[:i] + b[i+1:]　← コロン知らないと意味がわからん。iやらi+1やらをを含むのか含まないのか迷う。
境界ではどうなってたかな、とか「ああ要素が二つしかないからこれで上手く行くのね」とかいろいろ考えないと分からん

なんか、「簡潔な言語」っていつもこんな調子じゃね？
本当に分かりやすいとは俺には思えない
cとかJavaの方が分かりやすい
マジで

・黒を取ったとき残りは黒２白１
だから残りが黒の確率は２／３である

・どっちかの箱を選ぶ確率は１／２ずつ同等
片方を選べば必ず残りは白で、もう片方なら必ず黒が出る
ゆえに残りが黒の確率は１／２である

>>856
CとかJavaで書いても、分かりやすいと言ってくれる人はいないぞ
分かりやすい (＝もっと難しくしてもOK) なんて言う奴はいない

>>856
俺なんてじっくり見ても、
>>851のコードにreverseが入ってる理由とか、
>>852のコードが何やってるのかなんて全然分からんぜ

その言語知らない奴から見たら、そんなもんじゃね？

発想ゲームとかパズルゲームやってる
感覚なんだろうなｗ

曲芸やるぐらいなら普通に書いたほうが良い。

P(残った玉が黒 | 取り出した玉が黒)
= P(取り出した玉が黒で残った玉が黒) / P(取り出した玉が黒)
= P(黒が二つ入った箱を選ぶ) / ((1/2)*(1/2) + (1/2)*1)
= (1/2) / (3/4)
= (2/3)

>>845
Java

enum Ball {WHITE, BLACK}
double probability() {
    Ball[][] boxes = {{Ball.WHITE, Ball.BLACK}, {Ball.BLACK, Ball.BLACK}};
    List<Ball> restBalls = new ArrayList<Ball>();
    for (Ball[] box : boxes) {
        for (Ball ball : box) {
            if (ball == Ball.BLACK) {
                List<Ball> r = new ArrayList<Ball>(Arrays.asList(box));
                r.remove(ball);
                restBalls.addAll(r);
            }
        }
    }
    double count = 0;
    for (Ball ball : restBalls) {
        if (ball == Ball.BLACK) {
            count++;
        }
    }
    return count / restBalls.size();
}