【Perl,Python,PHP】LL バトルロワイヤル 27【JS,Ruby】
1 :
デフォルトの名無しさん :
2012/10/07(日) 02:47:23.61 最強の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も入りそうなもんだが
ecma scriptの1人勝ち。そろそろ、このスレは終了すべき
だってまともな言語で書いて JSにコンパイルする方がマシだもん
// / / バカッ //⌒)∩__∩ /.| .| ノ ヽ / | | ● ● | / | 彡 ( _●_) ミ 馬鹿には無理 / | ヽ |∪| /_ // │ ヽノ \/ " ̄ ̄ ̄ ̄ ̄ ̄ ̄(..ノ
web屋達の中ではマイブームなんだろ そっとしておけ
redmonkの調査ではjsが1位とってたよ 多分、tiobeは中堅どこのソフトウェアハウス 零細web屋はjsが増えていく。 零細web屋が中堅どこの仕事を奪っていく。 零細web屋が中心になって世界が動いていく。
>>13 > 零細web屋が中心になって世界が動いていく。
零細web屋の妄想ワロスwww
シリコンバレーのスタートアップなんて零細ウェブ屋と同義語だろ
>>13 Tiobeは単に検索数の集計で、長い間特に操作を加えている様子はない。
Javascriptが下降しているのは「話題性」は乏しいという意味。
流行っているかとか使われているかというようなことはあまり読み取れない。
>>17 すみません質問です。
この表の縦、横罫の中に現れる(by # of projets) (by # of Tags)は
それぞれどういう意味ですか。
flat of projects|Tags だから、 プロジェクト数(タグ数)を順序でならした結果でしょう。
(;´Д`)♭
hirata-create.cocolog-nifty.com hirata-create.toypark.in
22 :
デフォルトの名無しさん :2012/10/09(火) 05:12:30.13
Lua IN Ruby OUTでいいじゃん
スクリプト言語ばかりニョキニョキ出てきても仕方ない。 はっきり言って、大量に亡びるべき。
このスレにいたキチガイだろ今スレ乱立してるの 本物の障害者だったか
スレのアボーン登録がフルブックになりそう
颯爽とObjectScriptが登場
颯爽(さっそう)
どれが優れてるかじゃなく、「1つだけ残すならどれ?」ってのはおもしろいかもしれない
それブラウザ専用言語を別枠にしとかないとJSになっちまうぞ
ひとつだけ消滅するならどれ?ってのも
なくなっても困らないもの それが Ruby
32 :
デフォルトの名無しさん :2012/10/09(火) 16:33:57.57
>>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の改良版乱立って言うが、そんなに乱立してたっけ
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台の処理をわずか3台で実行できるため,10倍以上のトラフィックを処理する余地が生まれる。
・フロントエンドの JavaScript 技術者をバックエンドコード開発に従事させることが可能になる。
この結果,2つあった開発チームが1つに統合された。
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 を検討する価値がある、
という程度の話ではないかと思われ
46 :
デフォルトの名無しさん :2012/10/10(水) 20:42:53.03
railsがなければrubyに用なし
軽量サービスはサーバーサイドJS 重いのはクライアントサイドJS
そもそもなぜRubyを使ったw
それが古のオタクたちの夢だったからだ。だが、crubyは死んだ。 OSSという才能が集まるフリークラスでは淘汰された。 現存するのは、企業が提供するタダ乗り文化だ。
rubyの犠牲はキリストの犠牲と似ている。 誰かrubyとキリストによる贖いの比較ってタイトルで論文でも書け バザール文化はcからnode.jsに移った。
前にjsが流行っこないって言った連中は、上司にヤレと言われても断れよw
普通にJSにコンパイルして使ってるよ
てか、博多のruby開発拠点ってさ、第五世代コンピューティングばりの失敗だよねwwwww これからrubyやrailsで商売しようとしてたマヌケたちって、どうなっちゃうんだろうwwwww 日本は、計算機の市場でまた負けたのだよ。計算機、OSときて、そして言語まできたwwwwww
けれど、ソーシャルゲーム市場で勝つショボさwwwwwww
uyとかいうゴミってまだ生きてるの
たまにレス番飛ぶから生きてると思われる
次の記事はもう予想が付くだろ? どーせ、node.js vs eralng vs golang だよ もうひとつが、dart vs typescript この関係を持ち出すと、結局、node.jsしか選びようがないわけ こうして、古きよき時代のLL文化はテクノロジーの進化と共に幕を閉じた さようなら、Larry。さようなら、guide。さようなら、matz。
だから、ソフトウェアはcで書けって!
61 :
デフォルトの名無しさん :2012/10/10(水) 22:57:07.38
この自信満々の煽り方は古きよきオタクとは正反対のリア充だよね
まさか。LLブームのおかげでFOSSに興味もってしまったニートだよwwww 釣られている現職のPGなんて居たら、向いてないから転職した方が良いwwwww
perl、rubyとかpython弄ってたのに、卒業したと同時にブーム終わってんのwwwwww 冗談抜きでc++以外さわっちゃダメだよね。本当に時間の無駄だったwwwwwwwwww 今学生に戻れるならc++かjsのどっちかしか触んないwwwwwwww 今ならc++と競技コーディングの方が就職に有利なのかなwwwwwwww 記事書いた連中供死ねよwwwwwwwwwwwwwwwww
ニートの予想だとね、jsで競技コーディングがトレンドだよー topcoderだかでは、jsだけなかった気がしたけどね 学部1年はアリ本とヤドカリ本、買おうね! 学部2年は現実を見つめて公務員試験を受けよう!
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
ニートはコテハン付けてよ
嫌だぉーーーーーーーーーーーーーーwwwwww コテとかuyのアホだけがやってりゃいいだろwwwwwwwwwwwwwwwwwwwwww node.js推してるレスなんて、ほとんど俺だよwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
てかさ、c++でグループウェア作ってるとことか大丈夫なのかねwwwwwww あれって、次のofficeとかsocket.io、jsライブラリ、 html5で似たようなことする製品作れそうじゃんwwwww c++で書くなんて石から削りだしてるように見えるのよねwwwwwww methor frameworkなんて流行りだした日には、大量のjava屋さんたちにハローワークで会うかしら?wwwwwwww ざぁwwwwwまぁwwwwwwwwwwwwwwwwwwwwwwwwwww
jsだけリアルタイムシステム書けないけど、 そういった機能要求よこされる中堅どころぉなんてぇーーーー、 しぃんそぉつぅでさいよぉーされた奴らだけが必死こいて、 やってりゃいいぉねぇえええええwwwwwwww そーいった現場って、クビきられた後で、次の職場でノウハゥ生かせられるのかしらん?wwwwwwwwwwwww
このスレは既知外ホイホイですか?
最近、発症したよぉぉぉぉぉぉwwwwwwwwwwwwwwwwww wつけるぅとぉおおおおおおんwwww、すぅっげぇい楽しいねぇええええええええええええwwwwwww wwwwhyみたいにぃいいい、node.jsのにゅうぅーもんマンガでもかいたらぁぁああああ、 しぃごぉとぉおおおお大尾、みいいぃいいつうかぁっるうかなあああああああああwwwwwww
まずは失踪から始めよう。成果が出るまで続けるのが大事
c/c++の求人さがしてぇええ、おうぼぉするのぉってぇええええええwwwww、 すぅげぇええええええぇリスク高いよねぇえええええええええええええええwww 作れってぇえええええ、いわれぇっるうううもののおののがあぁぁっぁ、 レベェルたかかああああああああいいいいいイッメーーーーーーージ がぞぅしょりだの、せいぎょだの、シィんそちゅのがぁしたヴぁかにぃー、 てとりナにとりぃーーー教えてもらえるぅのかなぁあああんん? ロマンスグレイなぁじょーーしにさーーーーーー。ふふぅん、こんばんはかえさないよぉーーーなんてぇwwwww 祖ぉーーレナらぁーーーまぁだーーーいーけーどさーーーーー、 ひっこしたあとで、ほうちされて、おい込まれたりしたらぁあああああ、 すぅううごおおぃいいリィスゥーーーーーーーーーーーーーーーークwwwwwwww
けど差、けど差、けどぉさぁぁあア嗚呼嗚呼あああんああああんあああぁあああぁwwww じゃヴぁってぇーーーーーーーーー、なぁあああああんんかあああぁあああぁあああ しちょおおおおっせえええええええええええええぇえええが嗚呼ああああみいいえてえるよねえええええええwwwwwwww M V C ! M V C !ってぇえええええいううぅぅぅけえれっどおおぉぉおおおおおおおwwwwwwwww かぃたこおおぉおぉおどのおおおわりぃいいいにいいいいいいいいいいい、 やれることおおおおすくうないいじゃんんんんんwwwwwwwwwwww しょーじきーネットワーーーークまわりぃいいのおおおぉおおライブラリぐらいしか、 つかわれなくなりそうだよねぇええええええええええええええええええ。 すぅぷぅりんぐ?なにそれ、おいしいいいぃいいのおおおおおおおおお?wwwwwww ウェブフレームゥワークってぇええええええ、らんりちゅしぃーすぅーぎぃーwwwwwwwww ぷぅろぉじぇくとぅ毎にぃ、えらぶぅだけえええええええええええのおぉおぉおぉおぉおおお、 メリットなんてぇええええ、あんのかよぉぉぉぉっぉぉぉぉおぉお C#はぁ、entityイッタクだけぉどぉぉぉおおお、M$のお庭でぇあそぶぅのう、 なんんかああああああ、せいしゅうぉぉおおおおお、ぜんひてーーいするきぃぶぅんw でさ、でさ、でさ、出た答えがぁwwwwwww、ザッカーバーグゥか、ジョブズのまぁねごとしたいヴァカを期待してぇえ、 node.jsとぉぉおおお、メェテェオゥッ!html5でぇええ、てくぅのろじーが 入れ替わるのぉおおおおおきぃたぃするしかないぃんだよねぇええええへへへへへwwww
よぉのぉなかあぁあああのおおさあああああ、ぎょおーむけーなんてぇー、 じゅよおおううよおおぉおお斧おおほとおおんどおななんてええぇえええ、 GUIと文字列とデータベース、統計でぇえええええええええええ、 すんじゃうよねねねねねねねねえんええんねええええええええええええwwww desa,desa,desa、GUIと文字列とデータベース弄るゥぅぅのにぃいいいさあぁあああ、 じゃヴぁあああぐらいぃいいい、メンドウなぁあああげんんごおおってえええ、 ほぉかにないよねええええええええええwwwwwwwwwwwwwwwww しょおきぃぼぉなぁああああんけんはぁああああああああああ、 じゃヴぁすくぅりぃぷとぅがあぁああああおいしくぅううういただきぃましたぁああああwww
>>86 > jsだけリアルタイムシステム書けないけど、
リアルタイムシステムに必要なものって何のこと?
それがjsだけ欠けているというのが本当か調べたいんだけど、
まあ後半の文章見る限り、レスは期待できないなw
ま、レスがなければ根拠なしということで忘れよう。
るぅびぃはぁああーーあああああああーああああああああさぁああああああああ、
ほんとぅにぃーーーーー、くぅーーるぅううーなあああぁあああぁあぁ、
げんごぉおぉおおおだったぁけれえええええどおおおぉおおさああっぁああああん、
どぅみぃてぇもぉおおお、はっかぁーれんちゅーがぁあああああああーーーーー、
このぉむぅううぅぅうぅぅ、てぇつぅがぁくスタァイルじゃないんだよねぇえええ
うにぃくすぅのぉおおでんとぅてぇきぃな記号はぁあああ、うけついでるけどさぁ、
やぁあああぱああぁああっりいいぃいい、てぇえええつうぅうがぁくぅスタァイルとはぁ、
違ってええええええええぇええみえええっるうんだょねえええええええええええええええ。
スゥクゥリプトゥのレベルでぇ、ほんとぅにぃ、クラスなぁんてーーひつようだったのかしらん?
ハッシュでぇえええええええええじゅうううぶうぅうんんだったよねえええええええええええマヂで
>>93 RTOSみたいなああああああああ、GCのぉおタァアアイミングゥまでぇええええ、
要求されぇるようなぁああああああああああぁあああ、じゃヴぁあああすくりぷとぅのおおお、
処理系何てぇええええええええええあるぅうのぉおおお?
とうしょーのしすてむとかーぁあああああ、javaらしいいじゃあああああああんんんん。
ニートゥに聞くなよヴぁーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーか
おれぇがききてぇえええええぐらいだよおおおおお、たこ、くず、はげ、ごみぃぃいぃいい
>>93 おまえぇ、にいぃいいとぉおおだよねぇええええええ?
げんえきぃのえすいーとかだったらぁああああああああ、
しんだほうぅがあああいいいよおおおおおおお。
てか、しね。しね。市ね。視ね。視ね。しね。しね。しね。しね。しね
なにが、ま、レスがなければ根拠なしだとwwwwwwwwwwwwwwwwwwww バーーーかあああああああ、くうっぅぅうずううううううう、あほふぉおおぉおおお じじじじいいいしんんにいいいいいいまああああきこまれてぃえええええええ、しね
>>94 いや、だからそれ、JavaScript以外ならあるの?
少なくともスクリプト言語は全滅だし、
その他だって言語の機能じゃないでしょw
>>97 ア嗚呼あったあああありいぃいいまえええええだろおぉおおヴぁあああーあーかああ
でもなきゃぁあああーーーーー、Real-Time-yo!にぃいいいいいい、
わざわぁあああああああああ、じゃヴぁああああのぉおおおおかそぉおおましいいんつぅくるぅYO!
ふーつーはーーーーーーー、real time ! なんてぇえええええええ、c/c++の分野だろぉおおおおおがぁああああああん
ゆううういいいいつぅうううううう、食ううぅううみいいっこおおみいいいよおおとおおではぁあああああああ、
mrubyがぁああああああああ、にたYOなことおおおおぉおおおやろおおおとしてえええよおお
ひょっとおおするううとおおおおぉおおお、pythonのおおおおおじっそおおおううううにはぁああああ、
RTな要求をぉ大尾見達すうものおおおお大尾がああるうかもしれええあんないいけっどおおおおおおお、
風雨通宇うーは嗚呼嗚呼嗚呼あ、エンプラ用途ではぁあああつかわねーーーだろおおおおぉおおおおおおお。
なぁああああにいいがあああああああ、
>少なくともスクリプト言語は全滅だし、
da-yo!カス、クズ、ゴミ虫ィィ良い良い良い良い良い良いイ!
ふつううううにいぃいいかんんがええええれりゃああああああああああああああ、
すうううくううう売り良いぃいいっぷううつうぅうううのぉおおおお、
やるうううよおうううなぁああああああああああ、機能要求じゃねーーーーYO!
>>99 まぢいでええええ?まぁあああそおおおだよおねえええええええええええ
cへのぉおおおおトランスレーターーーにいぃいいスレヴァいいいのにいいぃいいいいNE!
ゲーーーーームのおおぉおおおおリアルタイムゥなあああよおおおぉおおきゅうううとおぉおおお、 金融なんかでのおぉおおおお、奇異の大おうううよううううきゅううううをおおおおおおお おおおぉおおおぉおおおなんなんじいいいいいいい、じいげええんんでええええええええええええ 考える宇宇宇ナッツーーーーーーーーーーーーーーにおおおおおおおおおお レントゲンをおおぉおおおお、いっめーーーーーーーじ、しろぉおおおおおお ちょおおおどおおおおお、GCはしったりいいしたらああああああいやすぎるだろおおおおおがああああああああああああああ
mrubyのGCって インクリメンタルGCだろ? リアルタイムって何を言ってるんだか。
うん。インクリメンタルGCならソフトリアルタイムといっていいよ。 JavaScriptもそうだけど。
じゃヴぁとRTじゃヴぁのぉおおおおおおおおおおおお、GCってぇええええええええええええ ナああああああああああにいいいいがああつかああわれえてええぇんんのおお?
GCがあああああはしいるううううう、FXだとかぁあ、株価のおおおおおほげとかぁああああああ、 つううううううかいいいたいいいいかあああああああああああああああああああああああっぁあ? じゃヴぁすくりぷとでかかれたあああしんしつさいどぅそぉおちとぉかぁ、雄プレイなんてぇ、 JOE式でえええかんがえってえええええ、イイヤァーーだろぉおおおおぉお
webバブルが.comバブルの再来に見える。うふふ
なんだこのスレ・・・ 鬼のようにレス番飛んでんな キティでもわいてるのか?
mozillaの気合が入ってるけど、これって確かgoogleから資金提供してもらってんだよね 運営資金足りないとかで、数年以内に結果出せって言われてた気がする。 もはやビジネスで負けた連中の呪いだよね!だから、大好き。
nokiaと組んだM$って、何処かOSSと関わって没落した企業の再生工場に見える
フリーソフトで損失を出す能力ってすごいよね 100%外れる占い師みたいなやつだな
馬鹿だな。100%外れたら、言われたことと反対のことすればいいだろ。本当に馬鹿だな
はっきりいっておくが、このスレに居るヤツは負け組み候補の受難を背負っている!
たぶん、w3cだとか各種言語のメーリングリストだのコミュニティだのを見た方が出世できるぞ。良い子の諸君たち!
コミュニティのメーリングリストが整備され、 実名で行動した方が有意義である文化において2chはオワコン化してしまった。 いいや、最初からこんな場所を読んではいけなかったのだ。
学歴なんて大して重要視されないが英語の読み書きが出来ないコミュ障は死んだ方が良い世界
これからさ、web開発での工数と価格が暴落して面白いことになりそうだよね これまでシステムがあったらってな零細企業にも低価格で気楽に導入されるんだよ 頭使わない精神論者や教養のない連中が、どんどん淘汰されていくんだ。見物だね
120 :
uy :2012/10/14(日) 03:57:12.19
ふう 今まで、こんなに技術から離れてたことがあっただろうか なんか本当にもう、どうでもいいなこのジャンル 冷静に第三者視点でみると IT技術なんて全然世界の中心ではなく ひとつの「マイナー」ジャンルでしかない 「マイナー」だよ「マイナー」 狭すぎだろ・・・そしてマイナーな割に難易度が高い事は事実でもある 可愛そうだ いつの時代も、社会や国の負荷がモロにかかる職種ってあるよな こんな時代にPGやってる奴って・・・。
>>117 PerlとかのUNIX系のソフトウェアのメーリングリストは2chなんかが存在する以前から十分に普及してたぞ
ここは質問スレじゃない
読みやすい教科書がまだない間はインターネット良いよね で教科書が完成したら解散 無事に終わってよかっただろ
教科書の情報なんてすぐに陳腐かするだろ ある程度の設計できるようになったら、断片的な知識から全体を構成できるからな
組込み・制御・ゲームって給料ヨサゲだけど才能ない人たちは死にそうだよね web系・業務系はまったく才能がなくても、上手くやれば簡単に金巻き上げれそう おまいら、どっちがオヌヌメなの?
>>120 何れホワイトカラーの事務職なんてのは、jsと統計周りの知識が必須になるよ
多分、ウェブバブル崩壊後には散り散りになったweb系技術者たちが
地方のあちこちのダメな中小企業で社内システムやらM$Officeのマクロを弄り出すよ
或いは、web系の企業の方が地方のダメな中小企業の業務を持っていってしまうか
どちらにせよ、地獄絵図だよ!
>>123 TypeScriptが話題になってたからこのスレが良いかなと思って
結局次期JavaScriptに静的型付けが入るのかどうか気になったんだよ
静的型付けをそのまま含めたら、ほとんどaction scriptだよね
>>127 統計が必須になる層はJSなんて弄りません
>>126 ゲーム関連のお給料がいいなんて話は聞いたことがないけど…
モシモシのことならあれはwebサービスだからね
>>131 統計が必須になるような層の人は実際コンピュータには無知な人が多いような…
a
>>130 おいおい、このスレでJavaScriptのことを話題にしてもいいだろ
html最強
動的言語は罪深い
オープンソースなのに情報が少ないから結局クローズドソース 動的だから変更のたびに チェックと確認が必要 ローカル開発→開発サーバー→ステージング→本番 順番に確認作業が必要 仕様変更のたびにこれを毎回やる 実行しないとバグがわからないから クラス・関数がどこかで参照されているか明らかにする必要がある ドキュメントが大量に必要 しかも仕様変更のたびにドキュメントの変更も必要 この場合ドキュメントにもバグが混入する 大規模開発だと必ずこんがらがる FWはバージョンアップのたびに別物に生まれ変わり 互換性がなく 今までのソースは動かない 動作しているものから不具合を探さないといけない また学習しないといけない 新しいFWがしょっちゅう出てきて それがデフォルトスタンダードのようにはてぶなどで宣伝工作される 実行しないとバグがわからない動的言語は過去のライブラリを使うのをためらう 結局過去の資産を生かせない 関数の名前の変更のたびに ソース検索が必要で手間がかかる これが静的言語だったらエラー吐くから 確認作業はローカル開発内で収まることが多い 動的は作れば作るほどシステムが負債化していく 作った後はまた新しいものを作った方が早いという結論になることが多い どうしようもない動的言語を流行らそうとするはてぶをはじめ技法やCodeZine、アシアルは本当に罪深い
結局これは短期記録力がある人間の驕りなんだよね。(東大とかアシアルとか) 彼らは自分たちの記憶能力を生かしたいがために ガラクタ言語をチョイスしてそれをスタンダードのような流れにしたいと思っている このガラクタ言語を使うことで短記録のある自分たちが有利であることを知っていて 他を蹴落としたいと潜在的に思っている。はてぶとかで工作してくる 静的言語を使えば(主にC#)こんな苦労なんて全然ないのに それでは自分たちが存在意義が問われるからあえて使わないようにしている いい加減こんなガラクタ言語やっていても無限に苦労することなる 動的言語はやめとけ無限に苦労することになる 書けば書くほど大変になる 記録力のあるやつだけやつしか現場に残らない 記録に止めないといけないことが 多すぎる VisualStudioやC#だったらバグ、リファレンスエラーが教えてくれる リファクターで容易に関数名を変更ができる 動的言語に比べてはるかに短い時間で安全確実にプログラムを完成させることができる 見えない地雷で身動きのとりづらい言語だからMVCで思考を統一するしかなかった だから現場は北朝鮮みたいな思考統制が進み ロボット人間だけが残る 組織は硬直し ルールーこそ人の上に立つ存在だと考える頭のおかしいロボット人間がでてくる そこは自由な思想・行動も否定され 愚かなルールを誰が破るか密告することを楽しみとする 潰しあいの世界が出来上がる
139 :
デフォルトの名無しさん :2012/10/15(月) 02:22:32.32
いつの時代も、社会や国の負荷がモロにかかる職種ってあるよな
御題 "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 のような低能には無理。静的動的関係なく
149 :
デフォルトの名無しさん :2012/10/15(月) 11:21:15.91
デフォルトスタンダード君がにも来たか
C#のコードまだ〜?
PHPってもともと「PHP」などの雑誌ビジネス書人文社会科学書を発刊していた出版社 ちょっと目を逸らしたらWeb用CGI言語がメインでけっこう大きな勢力になっていたので驚いた
Perlっていいなまえですね! おそらくPerl言語のPerlだけ一致するだろう。 PHP, Ruby, Pythonは、Googleで検索したら余計なものも一致する
ム板終わったな。キチガイは死んでろ
グロ注意
>>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に落ちていく様子をご覧下さい
163 :
uy :2012/10/16(火) 10:35:53.46
クラウド(笑)の次はnode.jsやら、JavaScript関係のバズワードで攻めるようだね ひとつ言ってやるけど、 世界規模の自然災害や、戦争でも起こらない限り、 今までやってた常識がある日突然に覆る事は無い 常識が覆るペースは非常に遅い なのでその「常識」を覆している最中に、 もっと良い物が出てくる可能性がITにおいては多々ある どこに始まってもいないJSに未来を見れるのだろうか
>>162 どんな入力値をいれたら鼻から悪魔が出たの?
>>163 クラウドにスマホ、html5といったイノベーションが起こったよ
これで、これまでの常識が変わったと思わないなんて、よっぽど狭い世界で生きてんだろうな
>>137 わざわざドキュメント書くアホなんて、大手で大卒雇ってるアホ連中だろwwww
どこを見たってjsだけだよw railsホスティングサービスやruby2.0なんて出だしでこけた感しかない
ドキュメント残さないヤツは糞だろ 一人で仕事してるようなヤツじゃなければ普通書く キッチリ書くかザックリ書くかは規模による
コードに書かれたコメントを見ることはあってもドキュメントを見ることなんてないな わざわざexcelにドキュメント残すって、コードとドキュメントに整合性とれないだろw
ザックリしたドキュメントってのは 「こうあるべきだよな」 っていうのを書くのであって コーディングの内容書くわけじゃないんだぞ 整合性取れないって…
クラウドといえばAmazon Elastic MapReduceにRuby, Perl, PythonはあるがJSは無いよ
herokuがやってるからイラナイよ それよか、railsのホスティングサービスw
azureでも動くな。amazonからは負け犬臭がする
herokuでmapreduceって何の話だよ。自分でHadoopセットアップすんの? azureでのmapreduceはF#しか使えない上にamazonより面倒くせぇ
175 :
デフォルトの名無しさん :2012/10/17(水) 10:31:51.98
>>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
いいぞ、もっとやれ。昔に見た流れだ。
それで沢山の大学生たちを地獄に落としてやれ
190 :
デフォルトの名無しさん :2012/10/19(金) 00:27:21.76
タイプスクリプトまだテクニカルプレビューだぞ?
短く書こうとするとどんどん言語関係なくなるなー 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言語用のものならなんでもいいです。 正確ってことが重要なので、それにより動作が 変わってはだめです。
193 :
デフォルトの名無しさん :2012/10/19(金) 01:00:59.77
5000行の関数書くようなクズを助けたがるプログラマなんているわけがねぇ
>>191 >>140 には「演算セットは入れ替え可能なこと」ってあるから
'/'の振舞いをdivからquoに変更して、
数は整数以外はエラーになるよう変えてみたら?
その修正にどの程度書き換えが必要かで
言語の特徴も見えてくるんじゃない?
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ではどうなるかね?
特定の問題を解決するのに短くかけたからといって 違う問題でも短く書けるとは限らないんだよな。
とりあず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やで
ダイビングロングシュート?
ヨガファイア
それにしても皆ほんとまじめに書くな、お兄さんびっくりだ
>>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 を追加
こいつらホントに遅いな。 js版は音声認識に対応して 今は駅前でテスターを募集している
JSプログラマはコードは書けないが妄想は書ける
>>231 俺のjsは尻文字の入出力を実装した
ケツ同士でのやりとりが出来る
>>233 俺のjsはハイブリットにした。
3と19の間に「次」と言う事で
319と区別できる
>>206 はたかが20行程度のコードを書くのに
一体何時間かかるの?
>>199 の8割で書けるんでしょ?
>>235 ラピッド開発は早けりゃ良いってもんじゃない
やっぱり動的型ではSmalltalk, 静的型ではHaskellが現時点で最強だな
古いほうが勝つわな 家柄的な意味で
コードは実力、言語は人気
LLって存在意義ねーなー
Haskellはともかく、Smalltalkには負けたくない
>>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に超訳してみたw
| 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
253 :
uy :2012/10/22(月) 05:56:21.86
>>211 >>252 インデントすらつけないで2chにソース投稿してる奴は死ねよ
何年2chやってんだ?
ソースに&んbsp;付与するスクリプトくらいさっさと作れカス
>>248 いわゆるC言語のunsigned intに対応
import Foreign.C.Types
> calcRPN [add, sub, mul, ndiv] "1 2 -" :: Maybe CUInt
Just 4294967295
http://ideone.com/zcxWmv
(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))))
257 :
デフォルトの名無しさん :2012/10/23(火) 06:28:01.16
253 :uy:2012/10/22(月) 05:56:21.86
>>211 >>252 インデントすらつけないで2chにソース投稿してる奴は死ねよ
何年2chやってんだ?
ソースに&んbsp;付与するスクリプトくらいさっさと作れカス
他LLからSmalltalkに移行 => エディタやDVCSなど全環境を捨ててSmalltalk独自環境へ引っ越し 結論: そこまでのメリットがSmalltalkに無い
最強の環境を選べなかったやつらは死滅するという設定なので 環境は捨てるものではなく滅ぼされるもの
滅びた環境なんてまず無いw
Smalltalkには別に移行する必要なんかはないんだよ ちょっとそこで過ごしてみさえすれば 精神と時の部屋みたいなもんで たとえごく短時間でもちゃんと鍛錬しさえすれば 出てくるときには戦闘力が上がっている
>>261 そういう「使ったらレベルアップする」系の話は
関数型言語では良く聞くけど、Smalltalkでも成り立つの?
そりゃ何でも新しい言語の習得中は、何かしらの「レベルアップ感」はある
丸暗記系ではレベルアップ感がないという人もいる
まあSmalltalkなんざぁ、言語としては最もシンプルな部類のもんなんだから、
レベルアップとかそうしゃっちょこばらずにほんの5分でも触ってみたらいいと思うんだよね
http://amber-lang.net/learn.html そりゃXEROX直系由来の環境とかライブラリとかやっかいなのも色々あるかもしれんけど、
とりあえずは一番大事な「メッセージング」っていう唯一のドグマに納得できてからでも遅くないというか
興味無いことがレベルアップしても仕方ないんだよね むしろ邪魔
269 :
uy :2012/10/25(木) 12:29:40.30
君らって言葉が幼稚だよね
270 :
デフォルトの名無しさん :2012/10/25(木) 12:31:09.27
XエXロX
同じ意味の言葉が二つあって少なくとも一方は幼稚だとしたらどうしますか 1. 一つしかなければ幼稚にならないから一つにする 2. 気がすむまで新しい言葉を作る
3.幼稚の定義を振り返る
大切なのは幼稚より中身
274 :
デフォルトの名無しさん :2012/10/25(木) 22:34:15.94
7点
>>267 5分も触ったらメッセージングなんて
わざわざ構文でサポートする程のモンじゃないって
分かってしまうよね
それを言語のコアに据えるSmalltalkが時代遅れの骨董品ってこともね
Schemeは時々[]を使うようだが、物凄くどうでもいい用途に使ってるよな なぜlambdaを[]にしないのか理解できない
まあHaskell使っとけってことだ
>>275 あれってメッセージングなの?たんなる動的呼び出しだろ
動的呼び出しごときで「ドグマ」とか言い出しちゃうSmalltalkerって...
呼び出しで括弧を書かないためにセレクタを書いてるんだろ セレクタも括弧も両方書く言語はLispと同じかそれ以上に酷い Haskellの方がまし
Lispに酷いって括弧の量のこと? あんなもんただの慣れだぞ 慣れるとむしろ優先度とか余計なこと考えなくていいから読みやすい
まあLisp時代に戻れば多言語とか余計なこと考えなくてよいよね
284 :
デフォルトの名無しさん :2012/10/26(金) 11:22:33.52
そんなことあらんけー
ここから濃厚なプログレスレ
セレクタとメソッドの関に一枚噛ませたって感じだわな。
箱庭に閉じこもってOS含む外の環境が無いふりをするなら 動き続けることは難しく無いわな
MessageNotUnderstood: UndefendedObject
>>275 我々はか弱い。 だからあまりいじめるな
なんで、スマホやタブレットPCが普及したのにダイナブックじゃないんですかー。 やぁだぁーーーーーーー
そんなに普及したいか? 自転車でいうとママチャリだぞ
関心を持つ必要がないものを隔離すればその労力が他の適切な分野に供給されるはずだ ということで隔離してるんだけど 壁を作って隔離してみたら、壁自体に興味を持ってトンネルを掘る子供が増えたりして
骨董品の話しはもういいからさー コード出してくれよ。コードを
問題 "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 / ] $"
| 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' '/') '$') "
括弧の数が合わないのにエラーも出さず しれっと終了するプログラムには苦笑を禁じ得ない
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は入ってないけど
いい歳こいたperl mongerやruby gangは、そろそろニュービーたちを騙すのを辞めた方が良いと思う
自分の意志ではどうにもならないことが多いだろうけど だからといって、いい歳こいた誰かの思惑通りに動いているわけでもない 人間以外の要因で色々決まってしまうことが多い
>>332 とは言えsh+sed+awkくらいの用途なら標準ライブラリだけで割と何とかならね?
>>337 政治的な層と経済的な層ですね。わかります。
>>339 人に騙されたくないなら人文系の層から離れてください
341 :
デフォルトの名無しさん :2012/11/03(土) 11:41:30.74
死ねゴミ共が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まで保守される予定
うん、そこは現実どうこうより台詞を短くまとめてgdgdにならないよう努めた もとからgdgdとかそういうつっこみは受け付けない
352 :
デフォルトの名無しさん :2012/11/05(月) 02:37:58.22
祭にして叩けば?
>>351 「Perlしかできない」って言われて怒っちゃったyappoさん2chで反撃なんて最高にダサイですね
354 :
デフォルトの名無しさん :2012/11/05(月) 07:50:47.05
355 :
デフォルトの名無しさん :2012/11/05(月) 13:28:55.18
俺様以外のバカの集まるスレw 死ねゴミ共がw
>>351-353 思春期特有の精神性でないとプログラマなんて続けられないだろうし、
声が大きい人のおかげで発言しやすくなるだろから放っておけば?
しかし、2chの名無しならともかくtwitterアカウントで発言なんて頭沸いてる
358 :
デフォルトの名無しさん :2012/11/08(木) 21:07:33.72
【お題】 昇順、重複無し、整数要素の配列が与えられたとき、 連番部分を括り出す処理をどう書く? 括り出し部分の表現は自由。 例: [1, 3, 4, 5, 7, 9, 10, 11, 13] #=> [1, 3..5, 7, 9..11, 13]
360 :
デフォルトの名無しさん :2012/11/08(木) 23:06:57.73
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 | (coln notEmpty and: [coln last value + 1 = each]) 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]
>>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 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]
374 :
373 :2012/11/09(金) 14:40:35.32
ごめん。空白が... 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]
379 :
377 :2012/11/09(金) 18:48:05.63
>>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ってのを使えばいいんだろ?
> まずまず安心して使えそうなのって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]
>>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]]
389 :
376 :2012/11/10(土) 04:00:41.29
>>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)]
>>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 預言者じゃないんだから、オリジナルのメソッドの仕様変更に対応できるわけはないだろw
>>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 をパクらせていただいて
#!/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)) { こうしてくれ。
あ、しなくても大丈夫だったw
>>416 >>376 のコード読めばああなるほどと分かるんだけど
真っ先に数列の性質に着目してコード化して見せた
>>376 はやっぱりすごいよ
>>376 と、コードを見て初めて気づく人と、コードを見ても分からない人の間には
それぞれ超えられない壁がある
でも、groupbyという便利関数を使ってるだけだからなぁ。 あの関数が使えるって思いついただけだと思う。
>>424 あまつさえデフォで遅くて読みにくいことで定評あるPerlで
『リーダブルコード』で駄目な例に出てきそうなコメントバリバリのコードひっさげて
「リーダブルコード的にはダメなコードばかり」「速度もこっちが早い」とかどんなギャグかと
>>428 くやしいのう くやしいのう
>>429 読めよw
リーダブルコードより
8章 巨大な式を分割する
短く書こうとして逆に分かりにくくなっていたことについての1文。
どうして1行で書こうとしたのだろう? そのときは「オレは頭がいい」と思っていたのだ。
ロジックを簡潔なコードに落とし込むことに一種の喜びを感じていた。
この気持ちはみんなにも理解してもらえると思う。まるでパズルを解いているような感じだ。
仕事は楽しくやりたいからね。問題は、これがコードのスピードバンプになっていたことだ。
(P.102)
※スピードバンプ:ここではコードを読む速度を遅くさせるものという意味
>>431 うんうん。頭がいいと思っていたって話だねw
着想とか言ってる時点でダメだな。 頭が良ければわかる? わからない奴はついてこなくていい? なんだろそれは、読むのが困難だって言ってるようなもんだ。
>>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出るといいんだけどねー
出したいなら代わりにトリップ出せばいいと思うよw
>>443 上の式は実行効率の良さはともかく簡潔だとは思わんな・・・
下の文より分かりづらい
>>450 俺だけ出しても仕方あるまいよ。君頭いいね
>>454 全てがメッセージパッシングなオブジェクト指向言語はどうしたら
つーか制限かけるとつまんねーんだよ 何でもありだから言語固有のコードが出て来て面白いんだろが
>>455 ifもループも配列も
全部、関数やメソッドなのかい?
なら参加権なしってことだ。
いつまでもバナナはおやつに含まれますか論争してんじゃねぇよ・・・
>>456 いや、今回の場合ただの関数があるかないか自慢になってるから。
よし、こうしよう。他の言語にも
同等の関数はあるという前提で
いろんな言語で実装してみるというのはどうだ?
groupbyみたいな単純な関数(
>>444 )を使っただけで
ライブラリ自慢になってるとか馬鹿らしいよ
じゃあgroupbyのなかで使ってる spanを実装しなよw
ひどい自演を見た
>>461 span f xs = (takeWhile f xs, dropWhile f xs)
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 が仕様変更に弱いと思ったんだろう
469 :
434 :2012/11/11(日) 22:46:21.44
>>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
472 :
434 :2012/11/11(日) 22:57:10.43
>>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]]
が返ってくるところ。
>>477 重複があったらダメなコードのが少なくね?
>>477 それって、どっちかっていうとPythonのgroupbyの仕様バグくさいけどな。
引数にジェネレータが取れる仕様だからじゃないの 無限列かもしれないんだから
無限列ならなおさら出てきたところまではまとめて欲しいと思うが… そもそも仕様に「SQLのと違う」って断わり書き入れるくらいなら、名前変えろよと Python作り手の考えることはいっけん理屈が通っているようでけっきょく抜けとる
戻り値もジェネレータだからねぇ
>>427 そういう、「思いついた俺すげえ。」「分かる俺すげえ」みたいなのは
自己満足にはいいけど、現実世界ではある程度は万人に分かることが重要じゃないかな
>>481-484 雲行きが怪しくなってきたなあ
結局、groupby自体、どういう仕様なのかはっきりしないものであって
人によって解釈が異なるってことか
ますます可読性に難があることがあらわになってきたね
groupbyのような単純な関数で文句を言うな、可読性に問題はない
とか言ってた連中大恥じゃないかw
初めて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が含まれてるとその時点でループ終了
次2つのレスぐらい読めないの?
>>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 それは分かりやすさのベクトルが違うと思うよ
「玄関で右曲がって交差点で左曲がって500m直進した右手の建物に入る」って言った方が分かりやすいのか
「自宅から国会議事堂に行く」って言ったほうが分かりやすいのか、そういう違いだと思う
my @aiueo = ( "あ", "い", "う", "え", "お", "か", "き", "く", "け", "こ", "さ", "し", "す", "せ", "そ", "た", "ち", "つ", "て", "と", "な", "に", "ぬ", "ね", "の", "は", "ひ", "ふ", "へ", "ほ", "ま", "み", "む", "め", "も", "ら", "り", "る", "れ", "ろ", "わ", "ゐ", "ゑ", "を", "ん", "や", "ゆ", "よ"); これ以外で教えてください
535 :
デフォルトの名無しさん :2012/11/13(火) 00:43:43.80
・あいうえお...を1つずつ取り出して0から47まで代入 ・qw(あ い う え お ...) ・$aiueo[0]="あ"; .... #動作確認はしてない
>>528 それはどんな言語のどんな関数についても言えることだろう……
>>519 >>513 は別に端末を見下しているんじゃなくて、データを返すコードではなく
端末に値を出力するだけのコードは汎用性が皆無であることを問題視してるんだろ
>>527 それってシェルで言うと、
grep $PATTERN file
ですむことを
while read line; do
if expr line : $PATTERN; then
print line
fi
done < file
と書いた方が分かりやすいと言ってるようなもんだよな
うわ、&はエスケープされるようになったの? while read line; do if expr line : $PATTERN; then print line fi done
>>376 はラムダ式の呼び出しのたびにc=count()が実行されて
毎回next(c)で0が返りそうにしか見えないんだけど
どういうカラクリなんだよ?
あんまりPython知らないからあれだけど
これで業界去らなくちゃいけないのは厳しいわw
そこは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とかも本当には理解してなさそう
>>543 zipは関数型では良いけどオブジェクト指向では微妙だよな
二つのコレクションのどっちがレシーバになるべきか迷う
>>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ごときと俺の最強言語が一緒だと思うなよ?
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}
579 :
デフォルトの名無しさん :2012/11/14(水) 11:41:07.64
頭の3.を含むか含まないかの違いだろう ”小数点以下に列ぶ数字の...”って云っているので、含めない方が正解か?
3 の出現数だけならそれで説明付くが 9 の出現数が違うのはなぜだろう
1001桁目か1000桁目か999桁目が9なんだろ
583 :
デフォルトの名無しさん :2012/11/14(水) 13:04:29.08
これはひどい
ざこば
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))))
>>575 JavaとC#で一番簡潔なコードは
1000桁コピペだった件
やっぱりLLの足下にも及ばなかったよ……
標準ライブラリにBigMath.PIがあるかないかの違いで 威張られても・・・
JavaドカタにはBigMath.PIが無かったら手も足も出ないわな LLの方が言語だけじゃなくプログラマの質も高い
>プログラマの質も高い 言語に下駄履かせてもらってるんだけど
高い下駄を履きこなせるのも能力のうち
いや、簡単に使えるんだから 低い下駄だろw
馬鹿には無理
過去の資産や政治的理由を除いて、純粋に言語の機能だけでみればC#
そして、政治的理由とトレンドを考えてsharpkitで遊ぼうとしたけどもインストーラーが動かない
>>594 冗談抜きでLLとか言ってる人たちがcのプリミティブな配列で多倍長整数やhashを実装するところが想像できない
だいたい、javaより重要なものがない
>>551 c/c++プログラマと〜使い()では、手段と目的が違うからな
>>599 多倍長とか言って10のマイナス1000乗の精度が求められる世界だからね
冗談抜きでは想像できないね
花形IT企業勤務のレッドコーダーから見たらJava土方だの LLだの低レベルな罵り合いは微笑ましい
ブロックを渡せないオブジェクト指向って馬鹿だよな ブロックがないなら継承してオーバーライドしてコンストラクタ呼べばいいじゃないって 歴史に残る馬鹿だな
>>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}}
606 :
605 :2012/11/17(土) 12:14:26.68
連投スマソ。 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 のいうことを
少しは信じてやってみいいぞw
タイプ数それなりに重要じゃね? 例えばイテレータとかも「こんだけ冗長ならもう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 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 あ、車輪の再発明だから
ライブラリがあるものを書くなって意味か
お前が馬鹿だったw
ソートはどうでもいいけど、ストラテジパターンはよく使う これが冗長だとキツい
このスレのお題を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 冗長なレスだなw 馬鹿には、「で?」だけでいいだろw
プログラミング言語Jochoって言語作りたくなってきた
まじめな話をすると、ちゃんとインデント付けて
キーワードハイライトもあると、
>>623 ですら結構スラスラ読める
型のところは色が付くから、型を読む必要が無いときは読み飛ばせる
そんな話はしていない。sortもcompareも ライブラリがあるのだからそれを利用しろと。 そしてmainとかimportは何度も書くものじゃないんだから 実際に書く必要があるコードだけを書いてくれということ。
rubyのコードと”文字数”で比較してみようぜ。
「文字数」ならcのゴルフコードが結構いい線行くと思うけど、 LL好きにとっては、cがいい言語で、ゴルフコードが素晴らしい書き方なの?
型を書く必要があるから「文字数」で不利ってわかってて言ってるんだろうな そんなものは重要じゃないと言ってるのにいくら言っても分からない
型安全というメリットが追加されてるんだから こんなもんでしょ。 運用系みたいに1000行も行かないような 小さなスクリプト書くなら、型安全なくてもいいけど それを大きく超える。一人で全部把握できないようなものは 型安全ないとやっていけないよ。 型安全がないとコード修正の影響範囲がつかめない。
>>631 いや、それでも少し冗長ではあるよ
Scalaなら
>>630 が
>>364 になるんだし
ただ、それが問題になるほどのことなのかは
議論の余地あり
>>364 って改行を無理やり減らしただけじゃねーかw
そんなトリックに騙されると思って?
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にもそれがあったら(なければ作ればいいだけだけどw)
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);
>>654 わかりにくいだけじゃん
651でも十分簡潔で分かりやすいコードなんだが
無理矢理短くしてもメリットあまりないと思うけど
あとバグの可能性が減る。 結局のところ return input % 2 == 0; の 比較行しか見なくて済むから、 このコードは実質たったのこれだけとかんがえられる。
たかがこの程度でバグの可能性が減るってのは本当かどうか怪しいな この例は元のコードが簡潔だから良い例じゃない しかし、ちょっと前にも、ジェネレータやらgroupbyでバグの可能性が増えてたから LLで関数型スタイルが良いんだというのは結局思い込みじゃないの
>>655 そりゃ今回は条件の内容がわかりやすいからだろw
もし複雑な条件でも、その条件だけを入れ替え可能になっている。
使うときはすごく簡単になるぞ。
>>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が多い
あと実行速度も超重要だから、特に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使いって、関数がお膳立てされている世界で生きてるから そんなのが通用しない、自分で問題を解くような世界では 生きられないんだよw
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に関して言うなら、fの引数として絶対に無限列は入ってこないよ
作成途中の非無限列しか入ってこない
>>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とか出来てそう。
716 :
デフォルトの名無しさん :2012/11/18(日) 21:05:23.00
>>621 ようやくクロージャ入るんだ、ありがたい。
ラムダは7から入ってるんだっけ?
クロージャが入ると匿名クラスで書かなくて良くなるから 3行ぐらい行数が減らせるんだっけ。 まあその3行はエディタが自動生成してくれる部分なんだが。
クロージャーとラムダの違いって何? 概念とか言葉で説明するんじゃなくて 具体的な違いが知りたい。
_\.ー、ヽ } Vレ〃レ7/ノ __ > `ヽ ヽ) ´∠r " /_ _,..ゝ _∠ > ,.....---....、 ∠、 ⌒> /:::::::::::::::::::::\ __.> `>、 ./:「トL「¨M¨'ヽ、::::!/  ̄7Y´、__, 、_, Y′ ノ∧ <・」 , L・> !}__ r‐v'´:::::ヾ:、 r−、 ./::::::::::|`L、 ../! i:::::::::::::::/ヽ  ̄ _ イ:::::::::::::! l ヽ i l:::::::::::::::l _  ̄ 〉::::::::::::! l ヽ これがクロウじゃ そしてこれがラムだ __ ,、__ ,, -,,' ´ ̄" ` ''ー`、 `ヽ. ___ ,,.. -' "/ { ` -一-ヾ ヽ. ヽ ☆ / ▽ / ∧ ヽ、, _,, }}_} ・ ii / / { {ゝ{__`ー-Y´f。Vハ'V } * ・ ii ! 〃 i ハ ´{ ヽ 、ソ } く ☆ ii ヾ{{ ☆ `ヾ、_`ヽ'^' ヽ " ! ! i ゚ : ii ヽ{{ * . ハ く) /.l、! ! ; .ii ヾ、. { ` ーj‐' {ムノ_ ノ ヾ , '´  ̄ー‐‐- ' ` く ` ー---─,' 、 、} ,' ,〈 , -ー‐-、i∠⌒ヽ ,' ∧<=ニ二‐ノヽ、二ソ / ./ } `"''' "; `7T´
Java8に入るのは紆余曲折を経た上、クロージャではなくラムダだとか ブロック云々程度ならラムダで十分ではあるが
クロージャーはスコープが広すぎるっていう問題があるんだよね。 クロージャの中からその外のスコープの変数が丸見えになっちゃう。 もちろん書き込みの可能。 便利なこともあるのだけれど、クロージャーの中は その中でスコープは閉じていて欲しい。 関数と同じで引数と戻り値があるのだから十分なはず。 そう考えるとラムダのほうが優れてるかな。
ごめん、何言ってんのか分かんない
クロージャの内側からの可視性は (たぶんほとんどの言語で)その外側の関数内までなので そこまで広いとは言えないと思うが 問題になるとしたらエクステントの方で、無限エクステントになってしまう 寿命が確定できないのはある意味めんどくさい とはいえ、普通はGCに管理を任せるから問題にはならないけど
ごめん、エクステントって何?
Scalaがあるので、SAMタイプの構文糖(ラムダより劣ってる)なんてどうでもいい
>>718 関数() {
変数aを宣言;
関数内関数() {
// ここから変数aにはアクセスできなかったり、制限付きだったりする
}
}
関数() {
変数aを宣言;
クロージャ {
// ここから変数aに自在にアクセスできる
}
}
クロージャ =
>>726 の下のような性質を持った関数
ラムダ = 無名関数
なんじゃないの?
ラムダかクロージャーかっていう表現は少しおかしい気がする
728 :
デフォルトの名無しさん :2012/11/19(月) 15:05:45.20
>>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}}
735 :
734 :2012/11/19(月) 21:58:16.86
訂正: 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のコミュニティ自体に、宗教やジェンダー、学歴、雇用制度といった山ほどの社会問題が見つかるが
そこに更に人種問題が加わったわけだ。きっと神の思し召しだな。つまり、新しい時代へのイノベーションだ
>>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
745 :
734 :2012/11/20(火) 12:55:42.92
>>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]]
ネストした空の角カッコ対を削除する正規表現にいまいち自信が無い
748 :
質問です。 :2012/11/21(水) 01:31:02.12
phpで苦労している。 この言語は、SUBMIT でデータを受け取るのに、 SUBMITで 入力データを受け取り操作に関する命令文を < input type="text" > のあとに書かなくてはならない。5行づつの一覧表入出力を作っているので 更新した後、その更新行のところに再表示させるために リダイレクトしてページ再表示したいんだけど java c# vb.netだとredirect 命令で簡単にできるけど phpのheader命令は、 htmlの入出力のあとに 書くと動作しない。 かといって < input type="text" >の前だとsubmit でデータが受取れてない。 なんかいい方法ないの?リダイレクトの方法。
日本で頑張れやー
解読に苦労している。
751 :
デフォルトの名無しさん :2012/11/21(水) 08:21:19.10
httpの仕組み理解すればわかると思うよ
>>748
>>748 ページを更新してもフォームの値を保存するってこと?
普通Cookieとか外部ファイルでやらない?
馬鹿には無理
つかえる げんご つかえない げんご そんなの じょうしの きぶん
はいはいドカタドカタ
756 :
デフォルトの名無しさん :2012/11/23(金) 04:18:48.51
>>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内容に影響されるって。
757 :
uy :2012/11/23(金) 05:01:02.17
ソース頻繁に上がるようになったのはいいけど何の話してんの? 俺からみて何の話しているか分からないってことは 多分中身のないレスで新着50は埋め尽くされている
頭に欠陥のある人ですねわかります
759 :
uy :2012/11/23(金) 05:32:58.77
おっと、檻の中から一匹がこちらに向かえって吠えてきた 土台になりたがる奴がいないと社会は周らない その檻の中で順位付けをし、争い続けるが良い
>>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).
761 :
760 :2012/11/23(金) 05:49:39.79
取り\n出す になっている所は、改行してはいけなかった。コピペのミス。
762 :
760 :2012/11/23(金) 06:05:35.96
>>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).
763 :
760 :2012/11/23(金) 06:06:40.50
また失敗したけれど、もう直しません。すみません。
ナイストライ Prologの面白さや、やりたいことなんかが良く分かるね
765 :
762 :2012/11/23(金) 09:39:07.97
>>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
767 :
762 :2012/11/23(金) 10:03:13.59
>>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).
【お題】 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 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やらのへんてこキーワードマスターしないと 使えないのか
789 :
デフォルトの名無しさん :2012/11/23(金) 12:26:39.37
馬鹿には無理
>>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 それは違うな
大きな数字でも小さな数字に行き着くのだから、結局一回目でキャッシュが作られるわけで
>>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回目以降はより速くなるんだから効果はあるでしょ
820 :
816 :2012/11/23(金) 20:56:57.70
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のコード
830 :
デフォルトの名無しさん :2012/11/23(金) 22:26:46.10
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]
835 :
デフォルトの名無しさん :2012/11/23(金) 23:27:43.70
高木boo
さすがのHaskellもメモ化ソースは長くなったな
Rubyは標準では並列実行の機能はない Windows以外だとforkをつかった並列実行ライブラリがあるみたいだが Windowsユーザーはどうすりゃいいんだろう JRubyだとスレッドが並列に動くが 近い将来の間にスレッドを並列実行できるようになる可能性はないが 複数のVMを並列実行できるようにはするそうなので 実現すればWindowsを含めた汎用的な並列化ライブラリを作れそうだけど いったいいつになることやら……
838 :
デフォルトの名無しさん :2012/11/24(土) 01:08:24.46
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))))
どっちみちRubyってRails以外じゃ使い道ないから、Windowsで動かなくても誰も困らないだろう。 Python製のWindowsアプリはだいぶ増えてきたな。
>>839 さすがの横綱相撲だね
今回はpythonが優勝かな
わざわざ「return」が必要なところ、スレッド数を指定しないといけないところなど HaskellやScalaに劣る部分もある。 完勝とは言いがたい。
C拡張のCilkとかで書けば色々うまく行きそうだ
【お題】 2つの箱がある。片方の箱には黒玉1つ、白玉1つ。 もう片方の箱には黒玉が2つ入っている。 どちらかの箱から玉を1つ取り出す(箱の中身は見えない)。 取り出した玉が黒であるとき、その玉を取り出した箱に残っている玉が黒玉である確率を求めよ。
>>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 |
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の方が分かりやすい
マジで
・黒を取ったとき残りは黒2白1 だから残りが黒の確率は2/3である ・どっちかの箱を選ぶ確率は1/2ずつ同等 片方を選べば必ず残りは白で、もう片方なら必ず黒が出る ゆえに残りが黒の確率は1/2である
>>856 CとかJavaで書いても、分かりやすいと言ってくれる人はいないぞ
分かりやすい (=もっと難しくしてもOK) なんて言う奴はいない
>>856 俺なんてじっくり見ても、
>>851 のコードにreverseが入ってる理由とか、
>>852 のコードが何やってるのかなんて全然分からんぜ
その言語知らない奴から見たら、そんなもんじゃね?
発想ゲームとかパズルゲームやってる 感覚なんだろうなw 曲芸やるぐらいなら普通に書いたほうが良い。
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();
}
Java enum Ball { WHITE, BLACK } static double probability() { Ball[][] boxes = { { Ball.WHITE, Ball.BLACK }, { Ball.BLACK, Ball.BLACK } }; int count = 0; int total = 0; for (Ball[] box : boxes) { for (int i = 0; i < box.length; i++) { if (box[i] == Ball.BLACK) { total++; if (box[1 - i] == Ball.BLACK) { count++; } } } } return count / (double) total; }
>>845 の問題の
「取り出した玉が黒であるとき、その玉を取り出した箱に
残っている玉が黒玉である確率を求めよ」
という文章を
「取り出した玉が黒であるとき、その玉を取り出した箱から
もう一度玉を取り出したとき黒玉である確率を求めよ。」
に変更すると、二つの箱に任意個の白黒玉を入れた場合を考える事ができる。
片方の箱に{白, 白, 黒}、もう一方に{黒, 黒, 黒, 白}が入ってる場合の確率を求めよ。
>>864 Scheme(Gauche)
(use util.combinations)
(define (probability boxes)
(define (black-ref? perm ref)
(eq? (ref perm) 'black))
(define (prob-calc prob ref)
(let1 len (length prob)
(fold (^(x y) (+ (/ (ref x) len) y)) 0 prob)))
(let* ((plist (map permutations boxes))
(prob (map (^x (cons (/ (count (cut black-ref? <> first)
x)
(length x))
(/ (count (^y (and (black-ref? y first)
(black-ref? y second)))
x)
(length x))))
plist)))
(/ (prob-calc prob cdr) (prob-calc prob car))))
(probability '((white white black) (black black black white))); => 6/13
861をそのまま書いただけ
>>864-865 問題の定義が曖昧
・まず、箱をどちらか片方選び(それぞれ1/2)、その上で選ぶ
・それぞれのボールを等確率で選ぶ
のか不明
おそらく、問題文のような行為から推測すると、
箱の中身が見えなくて、ボールの数も分からないと推測され
前者が正しいように思える
しかし、これはきっちり定義されていないから推測でしかない
そしてこの場合、865は誤り
>>864 @Mathematica
>>848 より
env = {{"A", {"White", "White", "Black"}}, {"B", {"Black", "Black", "Black", "White"}}};
In := pBoxBall["B", "Black", env]
Out = 21/32
(* 「取り出した玉が黒であるとき、その箱が B(後者)である確率を求めよ。」に読み替えてみた。 *)
>>864 Java
import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
enum Ball { WHITE, BLACK }
static double probability() {
Ball[][] boxes = { { Ball.WHITE, Ball.WHITE, Ball.BLACK }, { Ball.BLACK, Ball.BLACK, Ball.BLACK, Ball.WHITE } };
DescriptiveStatistics stats = new DescriptiveStatistics();
for (Ball[] box : boxes) {
DescriptiveStatistics probs = new DescriptiveStatistics();
for (Ball ball: box) {
if (ball == Ball.BLACK) {
probs.addValue((Collections.frequency(Arrays.asList(box), Ball.BLACK) - 1) / (box.length - 1.0));
}
}
stats.addValue(probs.getMean());
}
return stats.getMean();
}
// 0.3333333333333333
>>864 Java改
enum Ball { WHITE, BLACK }
static double probability() {
Ball[][] boxes = { { Ball.WHITE, Ball.WHITE, Ball.BLACK }, { Ball.BLACK, Ball.BLACK, Ball.BLACK, Ball.WHITE } };
DescriptiveStatistics stats = new DescriptiveStatistics();
for (Ball[] box : boxes) {
int blackCount = Collections.frequency(Arrays.asList(box), Ball.BLACK);
if (blackCount > 0)
stats.addValue((blackCount - 1.0) / (box.length - 1));
}
return stats.getMean();
}
>>864 >>870 は間違ってた・・・連投すみません
enum Ball { WHITE, BLACK }
static double probability() {
Ball[][] boxes = { { Ball.WHITE, Ball.WHITE, Ball.BLACK }, { Ball.BLACK, Ball.BLACK, Ball.BLACK, Ball.WHITE } };
int total = 0;
double weightProb = 0;
for (Ball[] box : boxes) {
int blackCount = Collections.frequency(Arrays.asList(box), Ball.BLACK);
if (blackCount > 0) {
total += blackCount;
weightProb += blackCount * (blackCount - 1.0) / (box.length - 1);
}
}
return weightProb/ total;
}
// 0.5
言語比較というよりも数学の問題になってないか?
>>864 Haskell
import Data.List
import Data.Ratio ((%))
boxes = [[0,0,1],[1,1,1,0]]
p f = sum [(length $ filter f xs) % (length xs * length boxes) | b <- boxes, let xs = permutations b]
p1 = p $ \(x:xs) -> x == 1 -- 取り出した玉が黒
p2 = p $ \(x:y:xs) -> x == 1 && y == 1 -- 取り出した玉が二回連続で黒
main = print $ p2 / p1
答: 6/13
数学の問題としてとくと、まず、Aの黒が選ばれる確率が1/2×1/3=1/6、その後、黒が選ばれる確率は0 次に、Bの黒が選ばれる確率が1/2×3/4=3/8、その後、黒が選ばれる確率は2/3 よって求める確率は 3/8×2/3÷(3/8+1/6)=1/4÷13/24=6/13
>>874 解説ありがとう Java誤り修正バージョン
enum Ball { WHITE, BLACK }
static double probability() {
Ball[][] boxes = { { Ball.WHITE, Ball.WHITE, Ball.BLACK }, { Ball.BLACK, Ball.BLACK, Ball.BLACK, Ball.WHITE } };
double total = 0;
double weightProb = 0;
for (Ball[] box : boxes) {
int blackCount = Collections.frequency(Arrays.asList(box), Ball.BLACK);
if (blackCount > 0) {
double weight = (double)blackCount / box.length;
total += weight;
weightProb += weight * (blackCount - 1.0) / (box.length - 1);
}
}
return weightProb/ total;
}
//0.46153846153846156
>>873 はpermutations全部列挙してない?
メモリ大量に使うことになりはしない?
黒→黒 勝ち 黒→白 負け 白→黒 引き分け 白→白 引き分け 引き分けを除いた勝率を求めればいい 引き分けの確率が小さければ、条件がない確率との乖離も小さい
モンティホール問題っぽい設問だなぁ
問題の読解力は自信なし、pythonでlistとsetを使ってみた ideone.com/odZ1ib
>>873 ,874
「黒が選ばれたとき」の確率じゃないの?
そう。だから、最初に白が選ばれる場合は考慮する必要がない
>>866 も誤解している
>>864 Squeak Smalltalk
| 箱 全取り出し順 一個目が黒の確率 二個目も黒の確率 |
箱 := {#(白 白 黒) asBag. #(黒 黒 黒 白) asBag}.
"箱 := {#(白 黒) asBag. #(黒 黒) asBag}."
全取り出し順 := 箱 collect: [:各箱 |
各箱 gather: [:一個目 | (各箱 copy remove: 一個目; yourself) collect: [:二個目 | {一個目. 二個目}]]].
一個目が黒の確率 := (箱 collect: [:各箱 | (各箱 occurrencesOf: #黒) / 各箱 size]) sum / 箱 size.
二個目も黒の確率 := (全取り出し順 collect: [:各箱毎 | (各箱毎 count: [:ペア | ペア = #(黒 黒)]) / 各箱毎 size]) sum / 箱 size.
^二個目も黒の確率 / 一個目が黒の確率 "=> (6/13) "
>>876 確率の式を知らなくても答えが納得できるかなって思ったけど、
余計なお世話だったかも
式を直接解くと
x2 = sum [ (m*(m-1)) % (n*(n-1)) | b <- boxes, let (m, n) = (sum b, length b)]
x1 = sum [ sum b % length b | b <- boxes]
main = print $ x2 / x1
>>882 まあ、「へーなるほどなあ」みたいな感じはあったので面白かった
でも、なんだろうなあ、Haskellは$とか%とかletとか
慣れてないと読みづらい変な感覚はやっぱりある
読んでもわからないのが多いので念のため質問。 箱に黒一個しか入ってない場合の備えはどれもできているの?
コードも出さない、読んでも分からないのが多い奴が 「どれもできているの?」とかどんだけ上からだよ
なんで質問が上から目線に見えるんだよw オマエちょっとおかしいぞww
というより、この場合、問題がそもそも対応できていないぞ。 だって、「もう一度取り出す」が出来ないわけだから。 オリジナルは二個固定だから大丈夫だが、改変版は可変にするとしか言って無い。
888 :
864 :2012/11/26(月) 00:26:29.07
取り出す玉が無いときの扱いは未定義なので、確率も未定義。 黒玉が一つも存在しない場合も確率は未定義。 確率が未定義の場合はエラーを返すのが望ましいが、 未定義なので勝手に計算した確率を返すのでも可とする。
>>884 お題の {白, 白, 黒} のところを {黒} にして、ざっとしらべてみた。
>>865 Scheme => ERROR: bad object: (black)
>>873 Haskell => Non-exhaustive patterns in lambda
>>875 Java => NaN
>>880 Smalltalk => ZeroDivide
つうわけで、何でも良いということだ 備えをしなくてはならないと思い込んでる884が間違い
コード書けなくて他人のコードも殆ど読めない奴には ここ最近の流れはつまらないだろうとは思う
バカは有識者の真似をしたがるからな 数学、関数型言語、パズルとかホザけば バカはそれを真似してやりはじめる
オマエが楽しければいいじゃん、いいからどんどんやれよ
おどるあほうに みるあほう おなじあほなら おどらにゃそんそん
マニュアルから目当ての関数を探す事が プログラミングだと思っているドカタにとっては ループとifと四則演算を使っただけでパズル扱い
ウェブ開発とかだと、プログラミングにアルゴリズムとかほぼ不要だからね。
大学生の頃にcでカリカリと毎日素振りのようにsortやhash書いてたよ! 本当に無駄な時間だった。結局、プログラミングってAPIを繋げることだったんだよ
車輪の再発明
単なる再実装を車輪の再発明とか言っちゃう奴けっこういるよね
まあデジタルハリウッドの低学歴だし
当初は学習目的でも当人が無駄だと分かった時点で車輪の再発明だろ?
902 :
デフォルトの名無しさん :2012/11/28(水) 02:02:55.97
ウェブ開発とかだと、プログラミングにアルゴリズムとかほぼ必須だからね。
マニュアル読んでAPIをつなげてりゃいい時もあれば、 高速化やら何やらのために頭をひねるときもあるのに 十把一絡げにしちゃう男の人って……
>>900 デジハリが低学歴? 卒業生には筑駒出身者もいるんだぞ。
図星の低学歴が暴れてますね
>>903 新卒でないとダメって、実際、すごくアホな風潮だよね
金出して入らないと学べないようなことなんてあるの?
もう何回も議論されたはずだが、ScalaってLLじゃないだろ LLの定義にもなってしまうが
0 ~ 64 の 65 個の数字を 以下のような個数毎に改行して表示する場合 各言語ではどのように書きますか? 便宜上それぞれの数字の型は int としてください 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
>>908 Haskell
f xs (n:ns) = case splitAt n xs of ([],_) -> []; (ys,zs) -> ys : f zs ns
main = mapM_ print $ f [0..64] $ cycle [5,4,4]
DDTでもやってんのか
DDTでもやってんのか
>>908 Python
import math
def layout(elems, nelems, nrows):
L = [int(math.ceil(float(x) * nelems / nrows)) for x in range(0, nrows + 1)]
return [elems[span[0]:span[1]] for span in zip(L, L[1:])]
print layout(range(65), 65, 15)
>>908 (format t "~{~5@{~2d ~}~%~2@{~4@{~2d ~}~%~}~}"
(loop for i upto 64 collect i))
>>908 Squeak Smalltalk
| stream cycle |
stream := (0 to: 64) readStream.
cycle := [| i | i := 0. [#(4 4 5) atWrap: (i := i + 1)]] value.
Transcript open.
[stream atEnd] whileFalse: [
Transcript cr.
(stream next: cycle value) asStringOn: Transcript delimiter: ' '].
Transcript endEntry
>>908 @Mathematica
layoutNumbers[lst_] := Module[{pickList},
pickList[lstx_] := {Take[lstx, 5], Take[lstx, {6, 9}], Take[lstx, {10, 13}]};
lst // Partition[#, 13, 13] & // Map[pickList, #] & // Flatten[#, 1] & // Grid];
In := layoutNumbers[Range[0, 64]]
Out = (省略)
>>907 HaskellやSmalltalkもLLじゃないと思う
>>908 python
for i in xrange(65):
print i, (['']*4+['\n']+['']*3+['\n']+['']*3+['\n'])[i % 13],
レイアウト変だね for i in xrange(65): print '%2d%s' % (i, (['']*4+['\n']+['']*3+['\n']+['']*3+['\n'])[i % 13]),
>>908 Perl
use feature qw(say);
my @cycle = (5, 4, 4);
my @list = (0..64);
my ($i, $m) = (0, 0);
while($m < @list){
my $n = $m + $cycle[$i++ % @cycle];
say "@list[$m..$n - 1]";
$m = $n;
}
リストのリストを作ってから出力するタイプと いきなり出力するタイプがあるね
>>908 Scheme
>>913 にCLだけど格好良く解かれてるのであえて黒板らしく
(define (f n)
(define newline?
(let ((lis (circular-list #f #f #f #f #t #f #f #f #t #f #f #f #t)))
(lambda () (let ((ret (car lis)))
(set! lis (cdr lis))
ret))))
(let loop ((cnt 0) (rev-str-list '()))
(if (>= n cnt)
(loop (+ cnt 1) (cons (if (newline?)
"\n"
" ")
(cons (format #f "~2d" cnt) rev-str-list)))
(apply string-append (reverse rev-str-list)))))
(display (f 64))
>>908 Perl
use 5.01;for(2..16){$_/=.23;say join' ',$_-8..$_-4.6}
明らかにダメな方向に進んでしまった
>>908 PowerShellでものっそいべた書きかつ副作用万歳
$i=0; $a=0..64; do { "$($a[$i..($i+=4)])`n$($a[(++$i)..($i+=3)])`n$($a[(++$i)..($i+=3)])" } while( $i++ -lt $a[-1] )
副作用全開で書いた方が簡単なような気がしていたが 別にそんなことはなかったぜ
>>924 まあ書くのは簡単だったよ、べた書きだから
正規表現全開で書けばすっきりな気がしていたが
別にそんなことなかったぜ
[Regex]::Matches("$(0..64) ", "((\d+\s){5})((\d+\s){4})((\d+\s){4})") | % { $_.Groups[1,3,5].Value }
>>908 gawk 拡張性の無い方向で
BEGIN {
d = 0
for(i = 0; i < 65; i++) {
d = (d + 3) % 13
ORS = d < 3 ? "\n" : " "
print i
}
}
>>926 確かに拡張性はないけど、ようそんな法則性見つけるねぇ・・・
node.jsに落ち着くだろう悲しい未来しか視えない 最近はGUI周りでのjavascriptパインドの対応状況も、かなり良いよね gtkやwxWidgetsって生残るのかしら
LLは釣りでした
Ruby その1 numbers = (0..64).to_a [5,4,4].cycle do |n| puts numbers.shift(n).join(' ') break if numbers.empty? end その2 numbers = (0..64).each [5,4,4].cycle{|n| puts n.times.map{numbers.next}.join(' ')} rescue "StopIteration"
>>908 Python
for x in range(65):print x,"\n"if 3*x%13>9 else"",
import s for x in xrange(32768): for y in xrange(32768): for z in xrange(32768): d = 'c:/test/%030d/%030d/%030d' % (z, y, x) os.makedirs(d) f = os.path.join(d, '%030d_%030d_%030d.txt' % (x, y, z)) p = open(f, 'wb') p.write(f) p.close() print f
脱ファイルシステムか スマホのステマか
935 :
デフォルトの名無しさん :2012/12/03(月) 13:43:42.44
動的なサイトを作りたいんだけど、javascript Python PHP のどれを最初に学んだほうがいい?? いずれは全部勉強するつもりなんだけど。
oppai
作りたいサイトに似たサンプルチュートリアルのあるものからはじめて改造していくのが早いと思う ブログとか掲示板とかならPHPだし、UIとかajaxならJavaScript、検索エンジンとか自然言語処理ならPythonがサンプル豊富なイメージ というのは、行き詰まるのが一番こわいから あとデータベース設計は正規化とか関連性とかがわかる程度には理解しといた方がいいも思う 思ってるサイトができるといいな
938 :
デフォルトの名無しさん :2012/12/03(月) 14:32:04.74
馬鹿には無理
英語が読めないのにPython使うクズ多いね Perl使えばいいのに
オブジェクト指向の言語として、どれをえらぶかなら、Perlは、不利だろう
941 :
デフォルトの名無しさん :2012/12/03(月) 15:43:51.74
perl:古い、可読性が… ruby:マイナー python:可読性OK、流行ってる、日本語情報もOK
pythonって2と3があるらしいけど どっちがいいの?
943 :
デフォルトの名無しさん :2012/12/03(月) 15:56:46.62
新しい方に決まってるじゃん pythonとして徐々に3にシフトしていく方針みたいだし すぐに2から3に乗り換えられないから互換性のため2が残してあるのであって
Pythonの布教うぜえ
Ruby厨うぜえ
Pythonはうざいけど、JavaとLispを削除してPythonを入れるならよいよ
PHPとかPerl、Rubyとかって、どれも大差ないだろ。
新しいものを追うことに美徳感じてるから Perlはゴミ Python最高
そして行き着く先はLISP。
Lisp族へ逝っちゃうのは老いも若きも産廃のみ。 だって奴ら実用プログラムなんて書かないんだろ?
Haskell板とかLISP板みると虫唾が走る 意識の高いクズばっかりだなって
やめてあげて! LISPerはあって当たり前と思えるようなライブラリも 整備されたドキュメントもない過酷な環境で生きてるかわいそうな人達なの! 「そんな苦労をものともせず最強の言語使う俺スゴイ」って正当化するしかないの!
たぶんLISP使いが人前でほかの言語を使うときは
LISP使い「ふっ・・・俺たちはLISPという精神と時の部屋に入って学んできた・・・」
とか思ってんだろうな
そして見下してるんだよ
「関数型言語って知ってる?」みたいに(笑)
こっちは実用的なものに興味があるのに変な自分の知識自慢とコア気取りをしててウザいな
>>952 のいうとおりだ
早く消えてほしい
プログラミング通気取るとか ”悟り!!”とかほざいてやってるやつらがうざい
意識の高いやつは車輪の再発明ができない 人と同じことをすると怒られるような気がしてマイナーな分野にいっちゃう 逆に、意識の低すぎるやつは実用のためなら再発明も盗作もするんだろうな
LISPerはむしろ再発明大好きで、「それくらい簡単にできるよ」とか言って 実際に再発明しちゃうから、コードを共有しないドキュメント書かない保守しない という説もある。怠惰の美徳が皆無
じゃあPerlerは? Perlerについて言ってみろ
> LISPerはむしろ再発明大好きで、「それくらい簡単にできるよ」とか言って でも、プロダクトレベルのものは見たことない。
>LISPerはむしろ再発明大好きで、「それくらい簡単にできるよ」とか言って実際に再発明しちゃうから それくらい簡単にできるってたとえばどんなこと?
どうせ簡単なことなんだろうなw
その点トッポってすげぇよな、最後までチョコたっぷりだもん。
たとえばSQLとか外部DSLってそのまま使えばいいのに 新しい内部DSLを作りたくなるのはなぜなのか
LISPは個人的には使う気にならないが アルゴリズムなどを考察する上で非常に適した言語の一つだと思ってるんで 尊敬はしている
>>935 PHP->javascript->python
今後はjavascriptだけで十分な要件を満たす
どっちかと言えば学術的な、研究のための言語ってイメージがあるかな LLにはLISP発祥の機能は沢山あるから凄いとは思うが 実用にしたいとはあんまり思わない
AI周りの教科書なんかはcommon lispで書かれてるから写経できるでしょ 今でもcommon lispが使われるような用途ってあるのかな というか、時代的にグレアムやESRに感化されてlispを学ぶ時代でもないんでねーの? プログラミング入門や実用的な価値からすれば、lispよかprologの方に軍配上がるしね
実用的なのにしか興味が無い
大昔、cadやgimpはcommon lispで書かれていたのは有名な話。 オブジェクト指向の方法論やOSSの活動で山ほどの設計が見える昨今では、 下手に書くよりかも読んだ方がはやいと思う。 古きよき日々、男たちが真の男であった計算機の黎明期にでも生まれたかったな
LISP → ラテン語 Python → 英語 的なイメージ。
プログラム言語は、いつからwebサイトを作るものに成り下がったんだろう
webサイト程度しか作れない低能には 実用プログラミング = webサイト構築 が成り立つというだけの話
てかね、今日日にcでemacsやviの派生物なんて書いたところで需要ないんだよ
クラウドに乗って人の子がやってきた以上、終わりの日が来たって悟るべき
クズは小難しいことで快感を覚えるんだろうなあ
975 :
デフォルトの名無しさん :2012/12/04(火) 10:35:00.02
>970 日本では1993〜1995年くらいから
1回使ったら終わりみたいな必要性のないWEBサービス作って その道の第一人者になりたいやつが多い
一発あたれば左手団扇な世界なんだから、 それ以降は後から来た奴の為にも油田を掘り起こすなんてやめて欲しい
関数型言語を使えない低能の嫉妬が心地よい
関数型言語が使える俺は凄い 使えないやつは低脳
このスレの御題の解答見るだけでも 関数型スタイルの素晴らしさを認めざるを得ない
関数型はいいところがあるが、 関数型だけでは大規模なものを作るのは難しい。
いや関数型はむしろ大規模なものを作るのに向いているのでは…… LISPの最大の難しさは関数型の概念でもマクロでもなくて、 情報を得ようとすると必ず立ちふさがる英語だと言ってみる(ゆとり)
関数型は副作用がある場合の対応が面倒。 副作用が無いようにしたほうがいいのはわかるが、 ユーザーが求めているものは副作用。 例えば処理結果が画面に表示されるとか
ロジック部分と出力部分を切り分けるのは常識で、 ちゃんと切り分けてたら全く面倒じゃない
処理を分離すること自体 関数型の方が得意だし
>>986 できるなら平行で動かしたい系で、計算完了順序が不定だが、
出力順は確定している場合は、出力部分でTCP/IPの
バッファリングのようなことをする必要があるのでしょうか。
出力がseek可能で、個別の計算結果の出力枠を固定長にできるのなら、 到着した分から虫食い的に埋めてくとかも有りかもなー。
>>987 こういうこと?
from multiprocessing import Pool
import time
def f(x):
time.sleep(x % 3)
print(x)
return x + 1
print(Pool(6).map(f, range(6)))
# 出力
0
3
4
1
2
5
[1, 2, 3, 4, 5, 6]
関数型スタイル(map)最高だな 手続き型forループとかウンコだわ
993 :
デフォルトの名無しさん :2012/12/06(木) 00:30:02.89
>>983 副作用のあるものはオブジェクト指向
ないものは関数型じゃだめなの?
>>993 別にオブジェクト指向は副作用の扱いが
得意ってワケじゃないよね
だから何だよ
オブジェクト指向は副作用の扱いが得意と言っていいと思うが 副作用の取り扱いにくいさはその影響が何処にまで及ぶのかがはっきりしないことであって、 その影響範囲をオブジェクトの単位で整理するっていうのはわりとマシな対処方法だと思う
もし影響範囲がわかるならlockなしでマルチスレッドに対処できることになる矛盾
みんなポインタの扱いが苦手
あわわ
1001 :
1001 :
Over 1000 Thread このスレッドは1000を超えました。 もう書けないので、新しいスレッドを立ててくださいです。。。