Study on ashitaka blog

人文学を勉強したい

Sat, 21 Feb 2026 21:53:57 +0900

最近、非論理的で複雑な事象について、細部を捨象せず、非論理的で複雑なまま伝え、それを受け止めることの重要性を感じている。

論理的な思考方法は、論理的に筋が通ってる事象のみを重要視しストーリーを作っていく。論理的に筋が通っている話は、相手の論理的思考により正確に理解してもらえる可能性が高いからである。

しかし、論理的なストーリーを紡ぐ過程において、非論理的な事象はノイズであり相手の論理的思考を阻害するため、なるべく捨象される。故に、実世界で起こった客観視可能な事実がストーリーの中で幅を利かせて、個々人の主観的な感情なんかは片隅に追いやられる。

30歳になってやっと人文学の価値が分かってきた。30年も生きててこんなに無機質で論理的な文章しか書けないのが悲しい。

ブルシット・ジョブが増殖している？

Wed, 02 Oct 2024 20:22:12 +0900

みなさん自分の仕事には意味があると思っていますか？

社会的に必要なさそうだが、お金のために意味があるように見せかけていませんか？

私は2020年に社会人になって4年経ちますが、やっと経済、特に資本主義に基づいた経済というものがどのように回っているかがわかってきました。

世の中のあらゆるモノや実体のないコトまで商品化されている
大企業とは安定した収益を得る仕組みを持っている企業である
お金を借りたら増やして返すのが当たり前
マーケティングとは本来存在しなかった顧客の欲求を駆り立てる性質がある
経済は成長し続けることが前提となっている

などの、学生時代では文字面でしかわかっていなかったことが実感を伴ってくる感じです。

資本主義経済への理解が進むにつれて労働の捉え方に対してもだんだん変化がでてきました。

学生時代には塾チューターのバイトから始まり、塾講師、レストラン、居酒屋、ゲーム会社での開発、神社の年末年始警備、ボールボーイといろんなバイトを経験しました。

ただ学生時代は仕送りをもらっているため義務ではなく、バイトはあくまでも得られる経験、楽しい仲間、おいしい賄い、小遣い稼ぎのためでした。

学生時代が終了すると、平日8時間労働する社会人スタイルが主流になるので、長いものに巻かれるべくサラリーマンになりました。

バイト時代との大きな違いとして、お金がないと生活していけない現代においては、既に結婚し子どもも生まれた今、労働によりお金を稼ぐことは権利ではなく義務になりつつあることです。

もう一つの大きな違いとして、自分のためだけではなく社会への恩返しを意識して働いている点です。

私が学生時代に享受してきた教育によって培われてきたITの分野において日本に役立てないかと考え、前職はヤフー、現職はグラファーに所属し、例えば業務効率化のためのプロダクト開発において一定役割を果たせてきたと思っています。

ただ生成AIが台頭してきた今、エンジニアのただコーディングするだけの役割なんかは不要になりつつあり、十数年後ずっと同じ仕事をしているとは到底考えられません。

そこで育休を機に改めて仕事の社会的意義について考えたく、農業とかにも興味を持ち始めたりしていて、以下の動画に出会いました。

https://youtu.be/IZs9w3ud5yQ?si=FyYsVIJnDx77Kdpa

この動画で紹介されているデヴィッド・グレーバーのブルシット・ジョブという本が、若干タイトルで釣られている感もありますが気になり、読んでみました。

週15時間労働はなぜ実現しなかったのか

1930年、ジョン・メイナード・ケインズは、20世紀末までにイギリスやアメリカのような国々ではテクノロジーの進歩によって週15時間労働が達成されるだろう、と予測したが、それはまだ達成されていない。むしろ、テクノロジーは私たちをいっそう働かせるための方法を考案するために活用されてきたと指摘します。

確かにこんだけ技術が進歩していれば働く時間って減っても良さそうですよね〜、なんで減っていないんでしょうか。大量生産大量消費のせいだとされることが多いようですが、グレーバーはそれも否定します。

無意味な仕事がでっち上げられている

グレーバーによると、それは無意味な仕事がでっち上げられているからだそうです。著書においては、それをブルシット・ジョブと名付け、取り巻き、脅し屋、尻拭い、書類穴埋め人、タスクマスターの5つに分類しています。

無意味な仕事というのはこの世には存在するとは思っていましたが、人類学者が指摘するような社会問題になっているとは思っておらず驚きました。

ブルシット・ジョブの定義

ブルシット・ジョブとは、被雇用者本人でさえ、その存在を正当化しがたいほど、完璧に無意味で、不必要で、有害でもある有償の雇用の形態である。とはいえ、その雇用条件の一環として、本人はそうではないと取り繕わなければならないように感じている。としています。

社会的意義を客観的に測ることは困難であるが故に本人の主観を尺度としてるのが面白いですよね。またマフィアの殺し屋なんかを除外するために取り繕う条件を入れたり、詐欺師なんかを除外するために有償である条件を入れたりしています。

まとめ

自分はITの仕事に携わっていますが、捉えようによっちゃあ実は書類穴埋め人に仕事を助けるために業務効率化のプロダクトを開発しているだけで、その人を助けたところでまた新たな書類穴埋め作業が生まれるのかもしれないと思ったりしました。

周りの医療や教育などのエッセンシャルワーカーとして働いている人たちのほうがよっぽど社会的意義のある仕事のように見えます。

みなさんの仕事はいかがでしょうか？

2024年から始まる教育とエミール

Sun, 22 Sep 2024 19:49:03 +0900

エミールにたどり着くまで

自分が父親になり早3ヶ月間が経ち、娘は体重が出生時の2.5倍になり、謎の言葉を発するようになるなどすくすく成長しております。

まだ3ヶ月だと本人ができることは限られているので自分が娘に与える影響も限定的ですが、これから自由に動き出して意思疎通ができるようになるとその影響は大きくなっていきます。

その成長が見られるのは楽しみと思う反面、こんなに他人の人生に影響を与えることもないので責任を感じる側面もあります。

別に手取り足取りいろいろ教えてやらねばと思ってはおらず勝手に成長していくものと思って入るのですが、完全に無為自然な状態を作り出すことはできずどうやっても自分の趣味嗜好が入ってしまうものです。

そんな思いを持ちながら最近ハマっているコテンラジオの教育の歴史を聞いていて、

https://open.spotify.com/episode/7tRKPVrgbMDZiDTEF94MlU?si=JkZsLSDVS16lRnmQkT1-lQ

話の中で近代教育の古典としてルソーのエミールが紹介されていました。

自分が受けた教育では、「エミール」という単語は「小説風教育論である」ということしか学びませんでした。

中身を学ばずになんの意味があるんやと思いつつ、まぁ確かに学生時代に内容を教えられてもなんのこっちゃやったやろうなと思います。

娘が生まれて自分が教育なるものを実践せねばならない立場になった今、この本にとても興味がでて満を持して読んでみました。

読んだと言っても一部を抜粋して解説がされている以下の本を読んだまでです。時代背景の説明がないと理解できないと思ったので。

『ルソーエミールシリーズ世界の思想 (角川選書 1005 シリーズ世界の思想)』永見文雄

https://bookmeter.com/books/18383149

この本を読んで感じたことをツラツラと書いてみようと思います。

中学生までは理性が眠っている

エミールにおいて1歳までの乳児期、1歳から12歳までの幼児期、12歳から15歳までの少年期は事物との物理的関係で自己を認識しており、理性は眠っているとされています。

それに対して15歳から20歳の青春期に入って他者との道徳的関係で自己を認識し、20歳から25歳の思春期において他者との社会的関係で自己を認識し、子どもから大人へ移行するとされています。

この定義によると今の日本の中学生まではまだ「他者」をちゃんと認識できていないということになります。

子どもと接するにあたって、大人が暗黙的に守っている社会的ルールを押し付けるのはアンフェアなのでそうならないように気をつけたいなと思っていましたが、案外それを気をつけなければならない期間は長いのかもなと思いました。

最初らへん感覚めちゃ大事

人間は生まれながらにして感覚器官を備えており、この器官を通じて外部の刺激を受け止めることによって感覚が形成され、人間の形成とは専ら感覚を出発点とする認識の発達である、とルソーは考えています。

この考え方にはとても共感できます。

人間が何かを判断するときに判断材料があればあるほど外界の事象を加味した判断ができますが、その判断材料は知覚することで初めて手に入れることができます。いくらものの考え方を教えたとしても、何も知覚できていなければ意味がないのです。

あれ何これ何と質問される時期が来ると思うのですが、変に現代の大人が共通認識として持っている科学的知見や社会的通念を持って説明せずに、何だと思う〜？とか言ってあるがままを知覚してもらうのがいいのかなと思ったり。

時間を無駄にするのが教育

ルソーは「子どもの教育とは、時を稼ぐために時を無駄にすることを心得ていなければならない仕事なのだ」「自然の働きに逆らうことになるといけないから、自然に代わってあなた方が手を出したりする前に、長い間、自然の働くままにまかせておくのがよい。子供時代は理性の眠りの時期だということを考えるがよい」としています。

私は小学生時代に、柔道、水泳、エレクトーン、英会話といろんな習い事をさせてもらってためになったので、自分の子どもにもと思っていたのですが、ルソー的には違うようです。

本人が望む習い事はさせたいですが、ただ遊びたいのであれば遊ばせるのがいいのかもですね。

幼児期においては勉強は不要

「どんな勉強においても、表現される事物の観念がなければ、それを表現する記号には何の意味もない」にもかかわらず、人々は子どもにこの記号だけを教えて、それが表現する事物を教えることはできていない。したがって、子どもは単に知識を詰め込むだけの勉強は子どもの判断力を育てない、それどころか駄目にする、ということになるそうです。

小学生時代の道徳の授業とかがこれにあたりそうですよね。教訓っぽいことを含んだエピソードを全員で読んだりしてましたが、確かに都度その教訓を読み取って理解していた気はしないです。

観念が必要ないただの計算とかならやらせてもいいのかもですね、それも本人が望めばですが。

まとめ

ツラツラ書こうと思ったんですが、幼児期で終わってしまいました、その後の少年期からも面白かったので気になる方は読んでみてください。

最後将来を誓ったソフィーとの定住地を探す話が出てきて、都会を離れた自然な穏やかな生活が大事とされていて、それは実践できてますルソーパイセンとなったりもしました。

1995年から私が受けてきた教育には何の不満もなくとても感謝しているのですが、失われた30年にどっぷり浸かっていて社会の変化に対応できていなかった感も否めないです。

2024年になった今、教育に変化が求められているようになりましたが、自分からは今も昔も変わらない大切だと思うことを伝えていきたいです。

LlamaIndexを触ってみる (Part 1)

Sun, 17 Dec 2023 05:50:40 +0900

現職では、RAG(Retrieval-Augmented Generation)を使ったアプリケーションを構築しています。

RAGを実装するにあたっての有用なライブラリとしてLlamaIndexというものがあります。

https://docs.llamaindex.ai/en/stable/index.html

このドキュメントを読んでみて、今まで自分になかった気づきを軽くまとめておきます。ただの走り書きなのでめちゃ読みにくいです。

気づきたち

エンジンは、データへの自然言語アクセスを提供します。例えば：クエリエンジンは、知識を強化した出力のための強力な検索インターフェイスです。チャットエンジンは、データとのマルチメッセージの「往復」対話のための会話型インターフェイスです。

「エンジン」という単位がある。

https://docs.llamaindex.ai/en/stable/getting_started/concepts.html#stages-within-rag

読み込み: これは、データが保存されている場所 (テキストファイル、PDF、別の Web サイト、データベース、API など) からパイプラインにデータを取得することを指します。 LlamaHub では、数百ものコネクタから選択できます。

RAGのためにデータを読み込むコネクタがLlamaHubに数百ほど公開されている。

https://docs.llamaindex.ai/en/stable/getting_started/concepts.html#querying-stage

ルーター: ルーターは、ナレッジベースから関連するコンテキストを取得するためにどの取得者を使用するかを決定します。より具体的には、 RouterRetriever クラスは、クエリを実行する 1 つまたは複数の候補取得者を選択する役割を果たします。セレクターを使用して、各候補者のメタデータとクエリに基づいて最適なオプションを選択します。
ノードポストプロセッサ: ノードポストプロセッサは、取得したノードのセットを受け取り、それらに変換、フィルタリング、または再ランキングロジックを適用します。
レスポンスシンセサイザー: 応答シンセサイザーは、ユーザークエリと取得されたテキストチャンクの指定されたセットを使用して、LLM からの応答を生成します。

RAGのクエリする段階においては、ただクエリする以外にもルーティングする、受け取ったノードを加工する、ノードを使ってレスポンスを生成する、という概念が実装されている。

https://docs.llamaindex.ai/en/stable/getting_started/concepts.html#putting-it-all-together

クエリエンジン: クエリエンジンは、データに対して質問できるようにするエンドツーエンドのパイプラインです。自然言語クエリを受け取り、取得して LLM に渡した参照コンテキストとともに応答を返します。
チャットエンジン: チャットエンジンは、データと会話するためのエンドツーエンドのパイプラインです (1 回の質疑応答ではなく、複数回のやり取り)。
エージェント: エージェントは、一連のツールを介して世界と対話する、LLM を利用した自動化された意思決定者です。エージェントは、所定のタスクを完了するために任意の数のステップを実行し、事前に決められたステップに従うのではなく、最適な行動方針を動的に決定できます。これにより、より複雑なタスクに取り組むための柔軟性がさらに高まります

RAGアプリケーションは大きくこの3つに別れる。

https://docs.llamaindex.ai/en/stable/use_cases/extraction.html

LLM は、大量の非構造化データを取り込んで構造化形式で返すことができ、LlamaIndex はこれを簡単にするように設定されています。 LlamaIndex を使用すると、LLM に自然言語を読み取り、名前、日付、住所、数値などの意味的に重要な詳細を識別させ、ソース形式に関係なく、それらを一貫した構造化形式で返すことができます。これは、チャットログや会話トランスクリプトなどの非構造化ソース資料がある場合に特に便利です。構造化データを取得したら、それをデータベースに送信したり、コードで構造化出力を解析してワークフローを自動化したりできます。

非構造化データにおける名前、日付、住所、数値などの意味的に重要な詳細を構造化形式で抽出するユースケースも紹介されている。

Vimmerを卒業してCursorerになる

Sun, 10 Dec 2023 04:33:09 +0900

お久しぶりです。ChatGPTを使えば毎週ブログ記事かけるっしょっと思っていたのですか、気づけば前回投稿から半年以上経ってました。

ゴルフし過ぎました。

2020年に社会人になってからVimで開発をし続けていたのですが、ついにVimを卒業してCursorというAIベースのエディタに転向しました。

理由は「Vimを使っている時点で、自分でコードを書こうとしてしまって、AIにコードを書かせる癖がつかないから」です。

今年の9月からAIに関するプロダクトの開発チームにjoinしたのも転向しようという考えに至るきっかけとなりました。

そんなAIベースエディタのCursorをどのように使っているのかを書き残しておきます。

Cursorとは

https://cursor.sh/

VSCodeからForkされて開発されたコードエディタです。AIとペアプロできる感じになっています。

開発者が見た感じ4人。。。強い。。。

https://anysphere.co/

Cursorでできること

コードについて質問できる

こんな感じでなんの処理をしているのかなんかを質問できます。

そのほかにも、

なんの処理をしているかだけでなく、そのコードが書かれている背景を推測してもらうとかもよくやります。

エンジニアリングにおいて、自分がわかっていない領域を認知するメタ認知能力はとても大事です。先輩エンジニアにしょうもない質問はできないですが、AIならお構いなく質問できるかも…?

コードを書いてくれる

こんな感じで勝手にコード書いてくれます。Github Copilotではこれから書こうとする行を補完してくれるのみで具体的な指示はコメントを駆使する必要があるのですが、Cursorだとコードの外で指示を書いたりAcceptしたりRejectしたりできるのが良いです。

コードを修正してくれる

エラーが出た場合はそのエラー文をコピーして解消方法を探して見つけたらそれをコピーして…と割と大変なんですが、ボタン1クリックで原因を見つけてボタン1クリックで解消してくれます。最強。

コマンドも書いてくれる

このコマンドのオプションなんだっけ…?ってなってmanでいちいち調べるのめんどくさいですよね…

最新のツールのコマンドなんかは学習されていない場合もあるかもなのですが、curlなんかの枯れたツールのコマンドなんかは安心して書いてもらえます。

Vimの操作感は捨て難い…!

init.vim をそのまま読み込ませてそのまま動作させるわけには行かないのですが(行けるかもなのですが)、VSCodeの settings.json で自分がやりたい操作を定義し直しました

{
  "vim.normalModeKeyBindings": [
    {
      "before": ["C-h"],
      "after": ["^"]
    },
    {
      "before": ["C-l"],
      "after": ["$"]
    },
    {
      "before": ["C-y", "t"],
      "commands": [
        {
          "command": "workbench.view.explorer"
        }
      ]
    },
    {
      "before": ["g", "r"],
      "commands": [
        {
          "command": "editor.action.revealDefinition"
        }
      ]
    },
    {
      "before": ["\\", "r", "n"],
      "commands": [
        {
          "command": "editor.action.rename"
        }
      ]
    },
    {
      "before": ["K"],
      "commands": [
        {
          "command": "editor.action.showHover"
        }
      ]
    }
  ],
  "vim.visualModeKeyBindings": [
    {
      "before": ["C-h"],
      "after": ["^"]
    },
    {
      "before": ["C-l"],
      "after": ["$"]
    }
  ],
  "vim.operatorPendingModeKeyBindings": [
    {
      "before": ["C-h"],
      "after": ["^"]
    },
    {
      "before": ["C-l"],
      "after": ["$"]
    }
  ],
}

まるっと私のVSCodeの設定を載せておきます。

ChatGPTと文字数制限しりとりしてみた

Sun, 23 Apr 2023 15:40:51 +0900

こんな感じでちょっと特殊なしりとり始めてみました。限界しりとりの時間制限がないバージョンで、本来なら文字数を決めるカードが必要になってくるのですが、その役割もChatGPTに任せてみます。

文字数制限しりとりスタート!

関西弁を要求してみると、、、

コテコテの関西弁使ってくれました、ただ「ん」で終わってくるので指摘してみます。

「ん」のルールは覚えたのですが、今度はしりとりの肝心なしりを取るルールを間違えてきます。

やっと直してくれました。続けます。

めっちゃ間違えられたので自分もわざと間違えてみます。

一丁前に指摘してくるw

誰にでもあると言った矢先に自分が間違えてきます。

ことごとく間違ってきます。やはり万能のAGIとかではなく、もっともらしい単語を予測してそれを出力する言語モデルなので、出力してみて

しりとりのルールを満たしているか
文字数制限をみたしているか

をチェックする機構はないようです。出力中にそのチェックを許すようにしたのですが、

出力している内容をもとにその先を出力するところまでできているように見せかけてできていなさそうでした。

まとめ

LLMの出力をアプリケーションにおいて利用するには、この出力のゆらぎと戦う必要がありそうです。

Stable DiffusionをDiffusion Beeで動かしてみた

Fri, 21 Apr 2023 16:50:04 +0900

先日までMidjourneyの無料版が使えていたので、アイコン作ってもらおうと思って以下を生成しました。

ものの10分ぐらいでこれくらいのクオリティかけるのすごいですよね。

ただそのMidjourneyの無料版が一時停止になってしまい使えなくなってしまいました…

もう一度画像生成を触ってみたかったので、今回はすべて自分のPCで画像を生成してみました。

使うのは以下です

Diffusion Bee https://diffusionbee.com/
- Stable Diffusionという画像生成モデルをMacで動かすツール
andite/anything-v4.0 https://huggingface.co/andite/anything-v4.0
- アニメ風画像を生成できるStable Diffusionモデルの1種

まずDiffusion Beeをダウンロードします。

私はM1 MacじゃないのでIntelのやつをダウンロードしました。。。

ダウンロードするだけデフォルトのモデルが入っていて動かせるのですが、何かに特化したモデルの方が綺麗に生成できると思って、andite/anything-v4.0をダウンロードしてimportしました

これでMidjourneyと同じプロントを試してみようと思います。

高校生の時に見ていたブラッディマンデイの主人公に憧れてエンジニアになったと言っては過言なんですが、その高木藤丸の特徴を抽出してMidjourneyに絵にしてもらったんです。

こんな感じでプロンプトを作りました(確か)

抽出された単語を減らしてプロンプト完成です!

早速これを使って画像を生成します。

自分のPCが雑魚いのか、Resolutionは256x256でStepsは10にしないと真っ黒な画像が生成されてしまったので注意してください🙏

チラッと見えているのですが、3~4分待つとこんな感じの画像が生成できました。

。。。Midjourneyほどの感動は得られませんでしたが、ちゃんとPCらしきものがあったり、なんか賢そうなのですごいです。

自分のPCで生成するには限界そうだったので、次はGoogle Colabを使ってもうちょっと高画質な画像にチャレンジしてみようと思います💪

Salesforce認定 Experience Cloudコンサルタント試験をChatGPTに解かせてみた

Thu, 20 Apr 2023 14:40:49 +0900

解かせてみたシリーズ第2弾です。

Salesforceの勉強している人が辛そうだったので、自分の周りで一番Salesforceに詳しそうなChatGPTに聞いてみました。

Insight

Salesforceという一企業のSaaSに関する知識も余裕で学習できている
1問間違えたけど人間も間違えていた問題
ただ解答させるのではなく、なぜその解答になったのですか? と追加で質問できるため、家庭教師みたい。家庭教師いらなくなるのでは。。。

やりとり

USER

あなたはSalesforceのすべての資格を持った試験対策の講師です。以下の設問に対して解答しわかりやすく解説してください。

Cloud Kicks（CK）は、ユーザーが情報を簡単に検索して閲覧できるように、サイトのコンテンツを整理したいと考えています。この目標を達成するためにCKが使用すべき3つの機能はどれですか？

□ 注目のトピック □ ナビゲーションツリー □ ナビゲーショントピック □ コンテンツグラフ □ コンテンツトピック

ASSISTANT

Cloud Kicks（CK）がサイトのコンテンツを整理し、ユーザーが情報を簡単に検索して閲覧できるようにするために、以下の3つの機能を使用することをお勧めします。

注目のトピック (Featured Topics)
ナビゲーションツリー (Navigation Tree)
コンテンツトピック (Content Topics)

解説:

注目のトピック (Featured Topics): これは、コミュニティやサイトのホームページに表示される、選択したトピックのリストです。ユーザーに重要なトピックを簡単に見つけてもらうために使用します。CKは、これを使って注目すべきコンテンツをハイライトし、ユーザーが求める情報へのアクセスを容易にすることができます。
ナビゲーションツリー (Navigation Tree): ナビゲーションツリーは、サイト上の構造化されたコンテンツを表示する階層的なメニューシステムです。これにより、ユーザーは関連するページ間を容易に移動できます。CKは、ナビゲーションツリーを使用して、コンテンツの整理とユーザーの探索をサポートできます。
コンテンツトピック (Content Topics): これは、コンテンツを関連するトピックにタグ付けするために使用されるカテゴリーシステムです。トピックを使用することで、ユーザーは関連する情報を簡単に見つけられるようになります。CKは、コンテンツトピックを使って、サイト上の情報を関連性のあるグループに整理し、ユーザーが求める情報へのアクセスを容易にすることができます。

USER

正解は注目のトピック、ナビゲーショントピック、コンテンツトピックだそうです。が、あなたのナビゲーションツリーという解答も間違っていないように思います。なぜナビゲーションツリーではなくナビゲーショントピックが正解になっているかの見解を教えてください。

ASSISTANT

おっしゃる通り、正解は注目のトピック、ナビゲーショントピック、コンテンツトピックです。私の最初の回答では、ナビゲーションツリーを含めていましたが、正しくはナビゲーショントピックです。お詫び申し上げます。

ナビゲーショントピックとナビゲーションツリーの違いについて説明します。

ナビゲーショントピック (Navigation Topics): これは、Salesforceコミュニティ内でコンテンツを整理するためのメインの方法です。ナビゲーショントピックは、ユーザーが特定のトピックをクリックすることで、関連する情報をすぐに見つけることができるようになります。これはコミュニティ内の情報探索を容易にするために使用されます。ナビゲーショントピックは、コンテンツを関連性のあるグループに整理し、ユーザーが求める情報へのアクセスを容易にすることができます。
ナビゲーションツリー (Navigation Tree): これは、サイト上の構造化されたコンテンツを表示する階層的なメニューシステムです。ナビゲーションツリーは、主にウェブサイトやポータルで使用される機能であり、Salesforceコミュニティ内ではあまり一般的ではありません。

ナビゲーショントピックが正解になっている理由は、Salesforceコミュニティにおいて、ナビゲーショントピックがコンテンツの整理とユーザーの情報探索をより効果的にサポートするためです。ナビゲーションツリーはウェブサイトやポータルで役立ちますが、Salesforceコミュニティのコンテンツ整理にはナビゲーショントピックが適しています。

USER

ありがとうございます、次の問題です。

Universal Containersは、チャネル販売、リード配布、および取引登録をサポートするサイトの作成を検討しています。UCはどのテンプレートを選択する必要がありますか？

□ ヘルプセンター □ カスタマーアカウントポータル □ パートナーセントラル □ 自分で作る

ChatGPTに京都大学2014年度の数学の問題を解かせてみた

Wed, 19 Apr 2023 14:18:15 +0900

これとてもやってみたかったんです。

自分は2017年から3年間研究室で数理最適化に関する研究をしていました。

数理最適化の考え方は機械学習の考え方と違って泥臭くて、分析したい対象の振る舞いを全て数式化してボトムアップで解を見つける方法なんです。

それとは違って機械学習は、論理はよくわからんが予測して答えがあってればOKという方法です。

これだけ聞くとなんとチャラい考えといいますか…答えだけ書いて道筋示さない学生みたいですよね。

だから当時は機械学習なんてそんなもん答えがあってたとしても何の意味が…みたいに穿った見方でみていました。

ですが、2023年現在の大規模言語モデルの人間の問いに対する回答は、ちゃんと人間が求める背景を汲み取って予測した単語を吐き出してくれるので、予測の羅列とはもう思えないですよね…

そんなChatGPTが今日解く問題はこちら!

https://bouseijuku.sakura.ne.jp/2014kyoto-sugaku.pdf

整数問題です。なぜなら文章として入力しやすいからです。

解答はこちら。

では質問してみましょう。

Let’s ask ChatGPT

### USER
自然数 a，b はどちらも3で割り切れないが， a^3 + b^3 は81で割り切れる．このような a，b の
組 (a , b) のうち， a^2 + b^2 の値を最小にするものと，そのときの a^2 + b^2 の値を求めよ．

### ASSISTANT
a、bは3で割り切れないので、aとbは3の倍数ではありません。このため、aとbは形式3k + 1または3k + 2のどちらかになります。

a^3 + b^3 が81で割り切れるため、a^3 + b^3 = 81n（nは整数）でなければなりません。

仮にaとbがどちらも形式3k + 1であると仮定しましょう。この場合、a = 3x + 1、b = 3y + 1と表すことができます。ここで、xとyは整数です。

a^3 + b^3 = (3x + 1)^3 + (3y + 1)^3
           = 27x^3 + 27x^2 + 9x + 1 + 27y^3 + 27y^2 + 9y + 1
           = 27(x^3 + x^2 + y^3 + y^2) + 9(x + y) + 2

この式が81の倍数であるため、9(x + y) + 2は9の倍数でなければなりません。しかし、これは矛盾です。なぜなら、9(x + y) + 2は必ず2を余りとして残すからです。したがって、aとbは形式3k + 1のどちらもできません。

同様に、aとbがどちらも形式3k + 2である場合も矛盾が生じます。

従って、aとbは形式3k + 1と3k + 2のどちらか一方が成り立つ必要があります。

例えば、a = 3x + 1、b = 3y + 2（または、a = 3x + 2、b = 3y + 1）とします。すると、a^3 + b^3は81で割り切れます。

a^2 + b^2 を最小にするようなaとbを求めたいので、a = 1, b = 2（または a = 2, b = 1）とします。これは、aとbが3で割り切れない最小の整数です。この場合、

a^2 + b^2 = 1^2 + 2^2 = 1 + 4 = 5

したがって、aとbの組(a, b)が(1, 2)または(2, 1)の場合、a^2 + b^2の値は最小で5になります。

### USER
a^3 + b^3 が81で割り切れなくないですか?

### ASSISTANT
すみません、その通りです。私の説明が間違っていました。
...

だめでした。ChatGPTを論破するの気持ちいいですよね。

ChatGPT4 本格RPG「チャット転生〜死んだはずの幼馴染が異世界で勇者になっていた件」をプレイしてみた

Tue, 18 Apr 2023 12:58:49 +0900

以下で紹介されているゲームをやってみました！

https://note.com/fladdict/n/n2a82d26f10dc

こんなちょっとのプロンプトでゲームになってるのすごいですよね。。。

では早速。

ASSISTANT

友達の名前：ユイ

外見：金髪のロングヘアで瞳の色は青、スリムで華奢な身体つき。

性格：快活で明るく、面倒見が良い。困っている人を放っておけない性格。

口調・態度：穏やかで丁寧な口調。時折、子供っぽいところも見せる。

【物語の進行】0点【危機の高まり】0点【技術革新】0点

ある日、君は亡くなったはずの幼馴染のユイから謎のメッセージを受け取る。

ユイ「ねえ、もしかしてこれ…君に繋がってるのかな？私、どうやら別の世界で生き返ったみたいなんだ。でも、こっちの世界は魔王がいて大変なことになっているみたいで…君の知識が役立つかもしれないと思って、このチャットで繋がってみたんだけど。」

君は彼女の言葉を信じられるかどうか分からないが、一度話を聞いてみることにする。

ユイ「グリーンハウスっていうのは、屋内で栽培を行うことができる施設で、天候に左右されずに一定の環境を保てるんだね。それなら、食料生産が安定するし、不足している地域でも役立ちそうだね！」

【物語の進行】30点【危機の高まり】0点【技術革新】30点

ユイ「これからグリーンハウスを試してみる方法を調べて、食料不足に悩む人たちにも提案してみるね。君の知識が本当に助かるよ。ありがとう！」

しかし、そのころ魔王は新たな計画を立てていた。農村部の水源を毒で汚染し、人々を苦しめていた。ユイはこの問題を解決するためにもう一度、君の力を借りることになる。

ユイ「魔王が農村部の水源を毒で汚染してしまったみたいなんだ。このままじゃ人々が大変なことになってしまう。毒を水から取り除く方法を知っているかな？君の知識がまた助けてくれると嬉しいな。」

USER

魔王ひどいやつやなー、、、もう魔王倒しに行った方が早いんちゃう?

ASSISTANT

ユイ「うん、魔王は本当にひどいやつだよね。でも、今すぐ魔王を倒しに行くには力が足りないんだ。だから、少しでも人々の苦しみを和らげる方法を見つけたいと思っているんだ。水の毒を取り除く方法があれば、それを使って水源を綺麗にして、人々が安心して水を飲めるようになるんじゃないかな。君の知識で何かアイデアはないかな？」

USER

ほーなんかー、、、シンプルに沸騰させるのがええんちゃうかな? 手の込んだ毒じゃないなら煮沸消毒でええはずや

GPT-4のスクリプト実行したら記事全部消えた

Mon, 17 Apr 2023 15:25:19 +0900

昨日に引き続きなんかGPT-4で遊ぼうとしたのですが、Wordpressにおいてソースコードが綺麗に表示されていないのがとても気になっていました。

WordPressでPrism.jsを使ってシンタックスハイライトを行う方法

これでやっていたのですが、クラスをいちいち指定するのがめんどくさいのです。

そこで、いい感じのプラグインないか聞いてみました。これは普通にGoogleに聞きました。ノウハウではなくこういった拾いものを探す時はやっぱりネットサーフィン。以下のサイトで

https://re-inx.com/syntax-highlighter

こやつに出会いました。

https://ja.wordpress.org/plugins/code-block-pro/

シンプルできれい

楽。

こやつに決めた。

が、全ての記事1つ1つこいつを当てていくのは大変。そこでChatGPT。

それは誰でも思いつくねんな〜

ほう。

おー、なんかいけそ〜〜〜

ここでGPT-4ちゃん召喚。

このスクリプトを実行する前に、以下の手順に従ってください。

1. このスクリプトをテキストエディタに貼り付け、`convert_code_blocks.sh`のような名前で保存します。
2. ターミナルを開き、スクリプトの保存場所に移動します。
3. `chmod +x convert_code_blocks.sh`を実行して、スクリプトに実行権限を付与します。
4. スクリプトを実行する前に、WordPressサイトのバックアップを作成します。
5. `./convert_code_blocks.sh`を実行して、スクリプトを実行します。

よーわからんけどいけるっしょ! と思って実行したら全部記事消えました。そこからはもうGPT-4の言うことは何も信じれず…全部Googleで調べてバックアップを復元しました。。。

まとめ

生成したコードを実行するときは気をつけましょう!!!

## USER
ちなみにさっきのスクリプトで記事全部消えたからおこです

## ASSISTANT
大変申し訳ございません。指示されたスクリプトが問題を引き起こしたことをお詫び申し上げます。この状況を解決するために、以下のステップを試してみてください。

1. **バックアップから復元**: WordPressのバックアップがある場合は、バックアップから記事を復元することができます。これには、データベースのバックアップと、`wp-content`ディレクトリのバックアップが必要です。バックアップがある場合は、データベースとファイルを復元して、記事を回復することができます。

2. **リビジョンをチェック**: WordPressは、記事の各バージョンをリビジョンとして保存しています。記事が完全に削除されていない場合、以前のリビジョンを使用して記事を復元できることがあります。これには、WordPressの管理画面から、編集画面にアクセスし、「リビジョン」ボックスをチェックして、以前のバージョンを選択する必要があります。

3. **キャッシュやバックアッププラグインを確認**: キャッシュプラグインやバックアッププラグインを使用している場合は、これらのプラグインが保存しているデータを確認して、記事を復元できるかどうかを確認してください。

今後のトラブルを避けるために、以下の注意点をお勧めします。

- 実行する前に、スクリプトやコマンドの内容をよく理解しておくことが重要です。
- 開発環境やステージング環境でスクリプトやコマンドをテストしてから本番環境で実行することをお勧めします。
- 定期的にバックアップを取得し、適切な場所に保管しておくことが重要です。これにより、データが失われた場合でも復元できるようになります。

再度、問題が発生したことに対してお詫び申し上げます。今後のトラブルを避けるために、これらのアドバイスに従っていただければと思います。

だそうです😠

ChatGPTでテトリス作ってみた

Sun, 16 Apr 2023 02:42:37 +0900

お久しぶりです。前回投稿が2022-08-15なので、サボりすぎですね…

情報のインプットは好奇心から頑張れるというか知識を得るのが楽しいのでやるんですが、情報のアウトプットって既に知っている知識を使うことなので気が進まないものですよね…定着させるには大事なんですが、特に定着させるモチベーションもなく…

ただ、やっとそのアウトプットを勝手にやってくれる時代がやってきました。そうChatGPTです。こやつにコンテンツを作ってもらう取り組みがどれくらい続くかチャレンジをやってみようと思い、ChatGTP Plus課金しちゃいました!

こやつを使って今日はテトリス作っちゃいます!

完成形

テトリスって、どんなブロックがあってどういうふうに回転してどこで壁にぶつかってとか、まじめに実装すると考えることいっぱいあるのですが、そんなことを考えずに一瞬で作ってくれました。天才です。

が、それを作ってから手直ししていく過程が大変だったので、会話の過程をご覧いただけたらと思います。

会話highlight

一瞬でコード書けるスーパーエンジニア

## USER
# 命令書:
あなたはフロントエンドエンジニアです。
以下の制約条件と入力文をもとにゲームのソースコードを出力してください。

# 制約条件:
* HTML、CSS、Javascriptのみで動く

# 入力文：
テトリス

# 出力文：

深津式プロンプト(https://chatgpt-lab.com/n/ne1643b7f10e6)を使ってみようとしたのですが、大して制約条件を書くことなく出力しちゃいました。

index.html を作って動かしたらこれ

もうエンジニアいらんやん…

すぐ解決策に走る初心者エンジニア

なんか右の画面いっぱいまでブロックが動かせなくて質問するのですが…

これやっても直りませんでした。どこが問題かを分析せず解決策に走る初心者エンジニアみたいです。でも、根気よく質問すると…

ちゃんとうごきました!

「コード見せて」といってくるベテランエンジニア

「次のブロックを表示」という機能追加もちょっとバグっていて、いろいろ質問して直そうとしたのですが

なかなか直らないとみたやコード全体を要求してきました。今度はこっちがなかなかバグを治せない初心者エンジニアみたいです…

かわいい

最後にお礼にコードレビューしてみると…?

GPT-4の使用上限にひっかかって、GPT-3.5になりました。。。コンテキストをちゃんと解釈してくれてない回答感ありますよね…KY…

ChatGPTと喋った内容

Takaaki

# 命令書:
あなたはフロントエンドエンジニアです。
以下の制約条件と入力文をもとにゲームのソースコードを出力してください。

# 制約条件:
* HTML、CSS、Javascriptのみで動く

# 入力文：
テトリス

# 出力文：

ChatGPT

以下は、HTML、CSS、Javascriptを使用してテトリスゲームを実装するための簡単なソースコードです。このコードをhtmlファイルにコピーして実行することができます。

<!DOCTYPE html>
<html lang="ja">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>テトリス</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
        }

        canvas {
            border: 1px solid #000;
        }
    </style>
</head>
<body>
    <canvas id="game" width="320" height="640"></canvas>
    <script>
        const canvas = document.getElementById("game");
        const context = canvas.getContext("2d");
        const scale = 20;

        context.scale(scale, scale);

        const arenaSweep = () => {
            outer: for (let y = arena.length - 1; y > 0; y--) {
                for (let x = 0; x < arena[y].length; x++) {
                    if (!arena[y][x]) {
                        continue outer;
                    }
                }
                const row = arena.splice(y, 1)[0].fill(0);
                arena.unshift(row);
                ++y;
            }
        };

        const collide = (arena, player) => {
            const [m, o] = [player.matrix, player.pos];
            for (let y = 0; y < m.length; ++y) {
                for (let x = 0; x < m[y].length; ++x) {
                    if (m[y][x] && (arena[y + o.y] && arena[y + o.y][x + o.x]) !== 0) {
                        return true;
                    }
                }
            }
            return false;
        };

        const createMatrix = (w, h) => {
            const matrix = [];
            while (h--) {
                matrix.push(new Array(w).fill(0));
            }
            return matrix;
        };

        const draw = () => {
            context.fillStyle = "#000";
            context.fillRect(0, 0, canvas.width, canvas.height);

            drawMatrix(arena, { x: 0, y: 0 });
            drawMatrix(player.matrix, player.pos);
        };

        const drawMatrix = (matrix, offset) => {
            matrix.forEach((row, y) => {
                row.forEach((value, x) => {
                    if (value) {
                        context.fillStyle = "red";
                        context.fillRect(x + offset.x, y + offset.y, 1, 1);
                    }
                });
            });
        };

        const merge = (arena, player) => {
            player.matrix.forEach((row, y) => {
                row.forEach((value, x) => {
                    if (value) {
                        arena[y + player.pos.y][x + player.pos.x] = value;
                    }
                });
            });
        };

        const playerDrop = () => {
            player.pos.y++;
            if (collide(arena, player)) {
                player.pos.y--;
                merge(arena, player);
                playerReset();
                arenaSweep();
            }
            dropCounter = 0;
        };

        const playerMove = (offset) => {
            player.pos.x += offset;
            if (collide(

#### Takaaki
続けてください

#### ChatGPT
arena, player)) {
                player.pos.x -= offset;
            }
        };

        const playerReset = () => {
            const pieces = "TJLOSZI";
            player.matrix = createPiece(pieces[(pieces.length * Math.random()) | 0]);
            player.pos.y = 0;
            player.pos.x = ((arena[0].length / 2) | 0) - ((player.matrix[0].length / 2) | 0);

            if (collide(arena, player)) {
                arena.forEach(row => row.fill(0));
                alert("ゲームオーバー");
            }
        };

        const playerRotate = (dir) => {
            const pos = player.pos.x;
            let offset = 1;
            rotate(player.matrix, dir);

            while (collide(arena, player)) {
                player.pos.x += offset;
                offset = -(offset + (offset > 0 ? 1 : -1));

                if (offset > player.matrix[0].length) {
                    rotate(player.matrix, -dir);
                    player.pos.x = pos;
                    return;
                }
            }
        };

        const rotate = (matrix, dir) => {
            for (let y = 0; y < matrix.length; ++y) {
                for (let x = 0; x < y; ++x) {
                    [matrix[x][y], matrix[y][x]] = [matrix[y][x], matrix[x][y]];
                }
            }

            if (dir > 0) {
                matrix.forEach(row => row.reverse());
            } else {
                matrix.reverse();
            }
        };

        const createPiece = (type) => {
            if (type === "T") {
                return [
                    [1, 1, 1],
                    [0, 1, 0],
                    [0, 0, 0]
                ];
            } else if (type === "J") {
                return [
                    [0, 1, 0],
                    [0, 1, 0],
                    [1, 1, 0]
                ];
            } else if (type === "L") {
                return [
                    [0, 1, 0],
                    [0, 1, 0],
                    [0, 1, 1]
                ];
            } else if (type === "O") {
                return [
                    [1, 1],
                    [1, 1]
                ];
            } else if (type === "S") {
                return [
                    [0, 1, 1],
                    [1, 1, 0],
                    [0, 0, 0]
                ];
            } else if (type === "Z") {
                return [
                    [1, 1, 0],
                    [0, 1, 1],
                    [0, 0, 0]
                ];
            } else if (type === "I") {
                return [
                    [0, 1, 0, 0],
                    [0, 1, 0, 0],
                    [0, 1, 0, 0],
                    [0, 1, 0, 0]
                ];
            }
        };

        let dropCounter = 0;
        let dropInterval = 1000;
        let lastTime = 0;

        const update = (time = 0) => {
            const deltaTime = time - lastTime;
            lastTime = time;

            dropCounter += deltaTime;
            if (dropCounter > dropInterval) {
                playerDrop();
            }

            draw();
            requestAnimationFrame(update);
        };

#### Takaaki
続けてください

#### ChatGPT
const arena = createMatrix(10, 20);

        const player = {
            pos: { x: 0, y: 0 },
            matrix: null
        };

        document.addEventListener("keydown", event => {
            if (event.keyCode === 37) {
                playerMove(-1);
            } else if (event.keyCode === 39) {
                playerMove(1);
            } else if (event.keyCode === 40) {
                playerDrop();
            } else if (event.keyCode === 81) {
                playerRotate(-1);
            } else if (event.keyCode === 87 || event.keyCode === 38) {
                playerRotate(1);
            }
        });

        playerReset();
        update();
    </script>
</body>
</html>

このコードは、テトリスゲームの基本的な機能を実装しています。プレイヤーは矢印キーを使ってピースを操作し、Qキーで反時計回りに回転、Wキーまたは上矢印キーで時計回りに回転させることができます。行が埋まると消え、ゲームが続行します。ピースがスタックして画面上部に達すると、ゲームオーバーになります。このコードを自由にカスタマイズして、さらに機能を追加したり、見た目を改善したりすることができます。

Makefileで改行文字を扱う

Mon, 15 Aug 2022 14:29:47 +0900

最近、Github CLIの存在を知って使いこなそうと頑張っている。

その中のコマンドの1つとしてPRを作成するコマンド gh pr create がある。

https://cli.github.com/manual/gh_pr_create

オプションの1つである --body を使えば、PRのbodyもコマンドラインから渡せてしまう。


gh pr create --web --body "
### What

プルリクエストをコマンドラインから作成してみた
"

ただし、これをMakefileの中でやろうとすると以下のようなエラーになる。

# Makefile
create-pr:
	gh pr create --web --body "
	### What

	プルリクエストをコマンドラインから作成してみた
	"

# execute `make create-pr`
gh pr create --web --body "
/bin/sh: -c: line 0: unexpected EOF while looking for matching `"'
/bin/sh: -c: line 1: syntax error: unexpected end of file
make: *** [create-pr] Error 2

Makefileの中では1行1コマンドとして解釈されてしまうため、ダブルクオーテーションの終わりを探してくれない。

Vimのヤンクレジスタを使いこなしたい

Sat, 13 Aug 2022 20:41:55 +0900

大学4回生からプログラミングを始めて、Atoms、Sublime Text、VS Code、IntelliJといろんなエディタを触ってきましたが、社会人になってからVimをずっと使い続けています。

最初は慣れないキーストロークでノロノロコーディングするのが苦痛でしたが、今ではVim以外でトラックパッドを触るのがめんどくさいと感じるようになってきました。

といってもまだまだVimを使いこなせておらず、工夫すれば簡単に終わりそうな操作があってもコーディングに集中したく、Vimの使い方を調べることは少ないです。

しかし、よくある操作でいつもうまくできない「単語をコピーして入れ替える」についてやっとちゃんと調べることにしてみました。

参考

この本の抜粋になります。

https://www.amazon.co.jp/dp/4048916599/

よくある間違い

キーストロークバッファの内容yiwcollection = getCollection();process(somethingInTheWay, target);jwwcollection = getCollection();process(somethingInTheWay, target);diwcollection = getCollection();process(, target);Pcollection = getCollection();process(somethingInTheWay, target);

初期の頃にやっていたとてもあるあるの行動です。ただ単語を削除してヤンク(コピー)した単語をはりつけたいだけなのですが、単語を削除した際に無名レジスタに削除した単語が格納されてしまうため、そのままPut操作を行うと、削除した単語が貼り付けられてしまいます。

Visual modeを使った回避策

いままでよくやっていたのがこの方法です。

キーストロークバッファの内容yiwcollection = getCollection();process(somethingInTheWay, target);jwwcollection = getCollection();process(somethingInTheWay, target);vecollection = getCollection();process(somethingInTheWay, target);pcollection = getCollection();process(collection, target);

こうすると選択対象と削除とヤンクした単語の貼り付けが同時に行われるので、削除した単語がはりつけられることはなくなります。しかし、入れ替えたい対象が2箇所以上あった時に、この操作をした後にはすでに無名レジスタには somethingInTheWay が格納されてしまっています。

ブラックホールレジスタを使った回避策

Vimには "_ というブラックホールレジスタ(消去専用レジスタ)が用意されています。保存したいわけではなくただ削除したのであれば、このレジスタにつっこめばいいわけです。これを使うと、先ほどの問題が解決します。

キーストロークバッファの内容yiwcollection = getCollection();process(somethingInTheWay, target);jwwcollection = getCollection();process(somethingInTheWay, target);"_diwcollection = getCollection();process(, target);Pcollection = getCollection();process(collection, target);

ただちょっとめんどくさいですよね? いちいち単語を削除するときはブラックホールレジスタに入れんとあかんから "_ を削除前に指定して…と考えることが多くなります。

ヤンクレジスタを使った回避策

おそらくこれが正解です。

キーストロークバッファの内容yiwcollection = getCollection();process(somethingInTheWay, target);jwwcollection = getCollection();process(somethingInTheWay, target);diwcollection = getCollection();process(, target);“0Pcollection = getCollection();process(collection, target);

2020年度に読んだ本のまとめ

Tue, 23 Mar 2021 16:49:44 +0900

今年度はたくさん本を読んだので学生時代に読んだものも含めてまとめておく。

お金

世の中には"金持ち"がいることはなんとなくわかっていたが, 金持ちがなぜ金持ちなのかがとてもよくわかる。ロバート・キヨサキほど貪欲に金持ちになりたいという思いはないけれど, お金の心配をしない自由な生活がしたいと思った。

資金計画, 金融資産運用, タックスプランニング, 保険, 不動産, 相続・事業承継という分野に関して幅広くわかる。気がする。もともと疎い人が触りを学ぶ分にはちょうどよかった。次は簿記の勉強でもしようと思う。

生き方

LIFE SHIFT(ライフ・シフト)

人生100年時代において, 有形資産だけでなく無形資産の形成にも力を入れるべきだと主張している。

ワーク・シフト ─孤独と貧困から自由になる働き方の未来図<2025>

9年前の2012年に描かれているあと4年後の未来がとてもリアルで, “働く"ということについてとても考えさせられる。

ノマドライフ好きな場所に住んで自由に働くために、やっておくべきこと

学生の頃からたくさん海外に行って社会人になってフルリモートで働いている自分にとっては、共感できるというか既に実践している部分が多かった。時間や場所の制約を取り払ってやりたいことに集中できる状態を常に意識したい。

下流老人一億総老後崩壊の衝撃

社会保障や社会システムにより日本人の約9割が生活保護基準相当で暮らす高齢者になるという話。経済的に豊かで健康であることはもちろん大事だが、人間関係を大切にすることを見失わないようにしたい。

完訳 7つの習慣人格主義の回復

非常に共感できる習慣だった。また読み直したい。

2022――これから10年、活躍できる人の条件

8年前にかかれたとは思えないほど世の中の流れを正確に言い当てている。2024年に会社という存在が形骸化するという話は、出社せず仕事をしている今とても納得感があり、枠組みに囚われない考え方を大事にしたい。日本の未来に期待を持たせてくれる内容で嬉しい。

ハイ・コンセプト「新しいこと」を考え出す人の時代

デザイン・物語・調和・共感・遊び心・生きがいの6つの感性に新しい時代を生きる鍵が隠されているという。2006年に出版された本でありながら情報化社会の次の時代に対する考え方として共感できる部分がたくさんあった。

君に友だちはいらない

京都大学産官学連携本部イノベーションマネジメントサイエンス研究部門客員准教授だった人の本。切磋琢磨は本当に大事だと思っているのですごく共感できた。

学びを結果に変えるアウトプット大全

ノウハウ本はあまり頭に入ってこない…

ハック思考〜最短最速で世界が変わる方法論〜

もうちょっと深い話が欲しかった…

IT

みずほ銀行システム統合、苦闘の19年史史上最大のITプロジェクト「3度目の正直」

自分の職業柄こんなプロジェクトよくやり遂げたなと思ってたのに, 最近また障害を起こしてて目眩がしそう。

シン・ニホン AI×データ時代における日本の再生と人材育成

お気に入りの本。自分は日本が好きなので死ぬまでにこういったビジョンが実現できていたらいいなと思う。

マイクロサービスアーキテクチャ

Thu, 10 Dec 2020 23:48:37 +0900

O`REILLY発行のマイクロサービスアーキテクチャを読んだのでその内容を軽くまとめる。

以下の記事を参考にした。

書籍「マイクロサービスアーキテクチャ」まとめ（前編）

書籍「マイクロサービスアーキテクチャ」まとめ（後編）

要点

1章マイクロサービス

マイクロサービスとは

マイクロサービスとは, 協調して動作する小規模で自律的なサービス。DDD(ドメイン駆動設計), CI・CD(継続的インテグレーション・デリバリ), インフラ仮想化, 自動化, アジャイル開発といったさまざまな分野から生まれたものでありこれらを総合的に実践する必要がある。

以下がマイクロサービスの利点である。

技術異質性…サービスごとに異なる技術を使うことができる
回復性(レジリエンス)…障害のあるコンポーネントを切り離せる
スケーリング…必要なサービスのみスケーリング
デプロイの容易性…必要なサービスのみデプロイ
組織面の一致…アーキテクチャと組織を一致させる
合成可能性…再利用することができる
交換可能にするための最適化…2週間程度で作り直せる

マイクロサービス以外の分解テクニック

共有ライブラリ
モジュール

2章進化的アーキテクト

マイクロサービスのアーキテクトは建築士(アーキテクト)というより都市計画家(アーバンプランナー)であり, あらゆる不測の事態に備えて計画するのではなく, 可能性が低いことを必要以上に指定したい衝動を避けて, 変化を許容するように計画する。

以下が進化的アーキテクトの主な責務とされている。

ビジョン…システムが顧客や組織の要件を満たすのを助けるシステムの技術ビジョンを, 明確に伝えるようにする
共感…顧客や同僚に対する自分の判断の影響を理解する
協調…できるだけ多くの仲間や同僚と関わり, ビジョンの定義, 改良, 実行に役立てる
適応性…顧客や組織の要求により技術ビジョンを変更する
自律性…チームに対して標準化と自律性の実現との間の適切なバランスを見出す
ガバナンス…実装しているシステムを技術ビジョンに合わせる

3章サービスのモデル化方法

以下が優れたマイクロサービスを設計するのに必要な性質

疎結合性…連携するサービスに関して必要最低限のことだけしか把握しないようにする
高凝縮性…関連する振る舞いを1箇所にまとめておく

4章統合

データベースの共有によるサービスの連携は, かんたんではあるが疎結合性と高凝縮性の両方を失うことになり, マイクロサービスを採用する意味がなくなる。

コレオグラフィ

サービス間の通信プロトコルとしては, リクエスト/レスポンスとイベントベースがある。前者では, HTTP + RESTをデフォルトの選択肢とする。後者では, あるサービスがイベントを発行して他のサービスが受信するための基板が必要になる。

複数のサービスによって一つの処理が構成される場合の制御方法としては, オーケストレーションとコレオグラフィがある。前者は基点となるサービスが他のサービスをリクエスト/レスポンスで呼び出し, 処理全体のフローを制御する。コレオグラフィでは, 基点となるサービスがイベントベースでイベントを発行して, 他のサービスがそれを受信して個々に処理を行う。

マイクロサービスの原則を満たすためには, コレオグラフィによる連携を模索すべき。

そのためには, 一連のイベントの最初にユニークな相関IDを発番して, イベントに乗せて伝搬させなければならない。

認証・認可のしくみとフロー(FIDO, OAuth, SAML)

Tue, 24 Nov 2020 14:51:59 +0900

業務にてOpen ID Connect(OIDC)を使った認証の仕組みを作ったが, いまだにOIDCがどういったものであるかを理解しないままだった。

そんな中, Software Design 2020年11月号にて認証・認可が取り上げられていたので, その中でOIDCについて詳しく書かれていた第2章ついてまとめる。

第2章認証・認可のしくみとフロー ~ FIDOからOAuth, SAMLまで一挙に解説 ~

ソーシャルログイン

外部のソーシャルネットワークサービス(Facebook, Twitterなど)を使って認証を行い, その結果をもって対象のWebサービスの認可を行う仕組み。対象のWebサービス側のID管理データベースへの新規登録を大幅に簡素化することができる。

Fast IDentity Online (FIDO)

生体認証を中心とする新しいオンライン認証技術。その名のとおり, 高速なオンライン認証を実現する。WebサービスではなくFIDO認証サーバで認証処理を行う。

Open Authorization (OAuth)

アプリ(Oauthクライアント)がユーザーの代わりにAPI(リソース)にアクセスすることを許す(権限移譲する)認可フレームワーク。これによって, Facebookにログイン(認証)したあとは, Instagramも利用(APIアクセスを認可)できるようになり, パスワードをサービスごとに設定・送信する手間から開放される。

OAuth 2.0

以下の点がOAuth 1.0と異なる。

Webサービスだけでなくスマホアプリも対象
アクセストークンを受け渡す仕組みを改善
HTTPSが必須

以下の4種類の認可フローが用意されている。比較的よく使われるのがAuthorization Code Grant。

以下がOAuth 2.0の仕組みである。スマホアプリは, 認可サーバの「認可エンドポイント」から認可コードを発行してもらう。次に, スマホアプリはアクセストークンを発行してもらうために, HTTPリクエストのペイロード部分に「grant_type=authorization_code&code=<認可コード>」という形で認可コードを入れ, 認可サーバの「トークンエンドポイント」に提出する。こうして取得したアクセストークンをHTTPリクエストのヘッダ部分などに「Authorization: Bearer <アクセストークン>」のように入れ, APIに提出する。

あくまで認可のしくみであり, 認証のしくみについては定義されていない。

リフレッシュトークン

アクセストークンを更新するためのトークン。

Webサービスは認証・認可のあと, HTTP Cookieによってユーザーを特定しているが, APIはトークンによって実行権限の有無を判定する。このトークンに, アクセストークンとリフレッシュトークンが含まれている。

OpenID Connect (OIDC)

認証結果を含むアイデンティティ情報も受け渡しできるようにOAuth 2.0を拡張したプロトコル。認証結果を含むアイデンティティ情報を「IDトークン」に入れて受け渡す。

アイデンティティ情報とはユーザーの属性情報や認証した日時などの情報であり, これをAPI側が確認できるようになる。

AWS認定ソリューションアーキテクト[アソシエイト]

Sun, 15 Nov 2020 09:06:25 +0900

会社での社内ツールを開発する際にAWSを参考にすることが多いので, AWS認定ソリューションアーキテクト[アソシエイト] という本を使って一通り勉強してみた。

内容

VPC (Virtual Private Cloud)

利用者ごとのプライベートなネットワークを作成できる。セキュリティグループやネットワークACL(Access Control List)を使って通信制御を行う。

CloundFront

HTMLファイルやCSS, 画像, 動画といった静的コンテンツをキャッシュし, オリジンサーバーの代わりに配信するCDN(Contents Delivery Network)サービス。ELBやEC2だけでなくS3をオリジンサーバにすることもできる。

Route53

ドメイン管理機能と権威DNS機能を持つサービス。以下のような自由なトラフィックルーティングが可能

シンプルルーティング
フェイルオーバールーティング
位置情報ルーティング
地理的近接性ルーティング
レイテンシールーティング
複数値回答ルーティング
加重ルーティング

EC2 (Elastic Compute Cloud)

仮想サーバーを必要な数だけすぐに立てることができるIaaS型サービス。AMI(Amazon Machine Image)を選んでインスタンスを生成する。スポットインスタンスというAWSが余らせているEC2リソースを入札形式で安く利用する方式なんかもある。

ELB (Elastic Load Balancing)

ロードバランサーを提供するサービス。Auto Scalingという, システムの利用状況に応じて自動的にELBに紐づくインスタンスの台数を増減させる機能がある。

ECS (Elastic Container Service)

Dockerコンテナの実行環境を提供するサービス。

AWS Fargate

ECSのCluster用のEC2インスタンスを使わずにコンテナを動かすことのできるサービス。

EKS (Elastic Container Service for Kubernetes)

Kubernetesを利用する際のmasterを提供するサービス。

ECR (Elastic Container Registry)

コンテナイメージを管理するレジストリを提供するサービス。

Lambda

サーバーを用意しなくてもプログラムを実行できる環境を提供するサービス。

CloudWatch

定期的にAWSリソースの状態を取得し, 問題がある場合はそれを運用者に通知するサービス。CPU使用率などの基本的なログをモニタリングするだけでなく, CloudWatch Logsを使ってアプリケーションログをモニタリングしたり, CloudWatch Eventsを使って独自のトリガーと何かしらの後続のアクションとの組み合わせを定義したりできる。

競プロ勉強会第2回

Fri, 29 May 2020 05:42:54 +0900

今回から新たに電電時代の学友Rくんも参加してくれました! 何回も一緒に定期テスト解いてるので知っていたのですが, さすがの賢さでした…

CODE FESTIVAL 2015 予選A D 壊れた電車

今までと同じようにチェック関数を用意してから二分探索を行う問題。p = max(minute - dist *2, (minute - dist)/2) + x[i] + 1;のところで詰まってました…

int n, m;
int x[100010];
bool isCheck(LL minute) {
    LL p = 0;
    REP(i, m) {
        int dist = x[i] - p;
        if (dist > minute) {
            return false;
        } else if (dist> 0) {
            p = max(minute - dist *2, (minute - dist)/2) + x[i] + 1;
        } else {
            p = max(p, x[i] + minute + 1);
        }
    }
    return p >= n;
}
int main(int argc, char *argv[]) {
    cin >> n >> m;
    REP(i, m) {
        cin >> x[i];
        x[i]--;
    }
    LL left = 0;
    LL right = n * 2;
    LL mid;
    while (right - left > 1) {
        mid = (right + left) / 2;
        if (isCheck(mid)) {
            right = mid;
        } else {
            left = mid;
        }
    }
    if (isCheck(left)) {
        cout << left << endl;
    } else {
        cout << right << endl;
    }
    return 0;
}
```cpp

### [ARC 060 C 高橋君とカード](https://atcoder.jp/contests/arc060/tasks/arc060_a)

全探索すればいけた問題。いろいろ小難しいことを考えがちだが, まず全探索や貪欲法を考えてそっからチューニングしていくべきだと思った。けど、これ一瞬で書いてるFさんには一生届かない気もしてます。

```cpp
int n, a;
int x[51];
int main(int argc, const char *argv[])
{
    cin >> n >> a;
    REP(i, n) {
        cin >> x[i];
        x[i] -= a;
    }
    map<LL, LL> m;
    m[0] = 1;
    REP(i, n) {
        map<LL, LL> mTmp = m;
        REPI(it, mTmp) {
            m[it->first + x[i]] += it->second;
        }
    }
    cout << m[0] - 1 << endl;
    return 0;
}
```cpp

競プロ勉強会第1回

Wed, 27 May 2020 09:24:33 +0900

先週やった第1回のことをメモっときます。

JOI 2007 本選 C ダーツ

ダーツやのに4回投げる問題。ここで2回なげる結果を全て記録して, その要素の組み合わせを二分探索で考えて3回っぽくする感動的な解法。

upper_boundとlower_boundの違いを履き違えていたが, upper_boundは探索したいkeyより大きいイテレータを返し, lower_boundは探索したいkey以上のイテレータを返す。


int n, m;
int p[100000002];
int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> p[i];
    }
    vector<int> v;
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= n; j++) {
            v.push_back(p[i] + p[j]);
        }
    }
    int ans = 0;
    sort(v.begin(), v.end());
    int vMax = *(v.end() - 1);
    for (int i = 0; i < v.size(); i++) {
        int nokori = min(m - v[i], vMax);
        if(nokori < 0) break;
        auto it = upper_bound(v.begin(), v.end(), nokori);
        int sum = *(it - 1) + v[i];
        ans = max(ans, sum);
    }
    cout << ans << endl;
    return 0;
}
```cpp

### [ABC 023 D 射撃王](https://atcoder.jp/contests/abc023/tasks/abc023_d)

いける高度を二分探索する。mid, left, rightを使って二分探索を書く方法でバグらせまくったので, `while(right - left) { mid = (right + left) / 2; ...`をテンプレとして使っていきたい。

```cpp

LL n;
LL h[100001], s[100001];
bool isok(LL x) {
    VI count(n);
    REP(i, n) {
        if (h[i] > x) {
            return false;
        } else {
            count[min(n - 1, (x - h[i]) / s[i])]++;
        }
    }
    REP(j, n - 1) { count[j + 1] += count[j]; }
    REP(j, n) {
        if (count[j] > j + 1) return false;
    }
    return true;
}
int main() {
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> h[i] >> s[i];
    }
    LL inf = 1e18;
    LL right = inf;
    LL left = 0;
    LL middle;
    while (right - left > 1) {
        middle = (right + left) / 2;
        if (isok(middle)) {
            right = middle;
        } else {
            left = middle;
        }
    }
    if (isok(right)) {
        cout << right << endl;
    } else {
        cout << left << endl;
    }
    return 0;
}
```cpp

SECCON beginners CTF 2020

Mon, 25 May 2020 13:31:28 +0900

研究室の人たちを誘って出場したんですが, 自分は一問も解けずにチームの人らがめっちゃ解いてくれました…

自分が解けなかった問題を先輩の解説やふるつきさんとやっていく気持ちさんのwriteupをみて, 復習します。

[Web] Spy

# auth.calc_password_hash(salt, password) adds salt and performs stretching so many times.
# You know, it's really secure... isn't it? :-)
hashed_password = auth.calc_password_hash(app.SALT, password)
if hashed_password != account.password:
    return render_template("index.html", message="Login failed, try again.", sec="{:.7f}".format(time.perf_counter()-t))

この最後の"{:.7f}".format(time.perf_counter()-t)がみそ。ハッシュ化は時間のかかる処理なので, 実行時間の違いによってDBにレコードが存在するかがわかる。

[Web] Tweetstore

limit, ok := r.URL.Query()["limit"]
    if ok && (limit[0] != "") {
        sql += " limit " + strings.Split(limit[0], ";")[0]
    }

SQLインジェクションってことはわかっただけで時間が解けた問題。最初UNION ALL句でpg_userを覗けば終わりだと思ったのだが, limit句の後ろでUNION ALL句をつけるにはselect文全体に()が必要らしい…

答えはlimit句内でサブクエリを使う方法。limitのクエリパラメータを(select ascii(substr(usename,1,1)) from pg_user limit 1 offset 1)みたいにすれば表示された件数がusenameの1文字目のasciiコードになる。めちゃCTFっぽい。

蟻本 | 2-2 猪突猛進! "貪欲法"

Fri, 22 May 2020 17:41:28 +0900

硬貨の問題

const int v[6] = {1, 5, 10, 50, 100, 500};
int c[6];
int A;
void solve() {
    int ans = 0;
    for (int i = 5; i >= 0; --i) {
        int t = min(A / v[i], c[i]);
        A -= t * v[i];
        ans += t;
    }
    printf("%d\n", ans);
}
```cpp

### 区間スケジューリング問題

```cpp
const int MAX_N = 100000;
int N, s[MAX_N], t[MAX_N];
pair<int, int> itv[MAX_N];
void solve() {
    for (int i = 0; i < N; ++i) {
        itv[i].first = t[i];
        itv[i].second = s[i];
    }
    sort(itv, itv + N);
    int ans = 0;
    int t = 0;
    for (int i = 0; i < N; ++i) {
        if (t < itv[i].second) {
            t = itv[i].first;
            ans++;
        }
    }
    printf("%d\n", ans);
}
```cpp

### Best Cow Line

```cpp
int N;
char s[100000];
void solve() {
    cin >> N;
    for (int i = 0; i < N; ++i) {
        cin >> s[i];
    }
    int a = 0, b = N - 1;
    while (a <= b) {
        //左からと右からを比較
        bool left = false;
        for (int i = 0; a + i <= b; ++i) {
            if (s[a + i] < s[b - i]) {
                left = true;
                break;
            } else if (s[a + i] > s[b - i]) {
                left = false;
                break;
            }
        }
        if (left) {
            putchar(s[a++]);
        } else {
            putchar(s[b--]);
        }
    }
    putchar('\n');
}
```cpp

### Saruman's Army

```cpp
int n, r;
int x[1010];
void solve() {
    cin >> n >> r;
    for (int i = 0; i < n; ++i) {
        cin >> x[i];
    }
    sort(x, x + n);
    int i = 0, ans = 0;
    while (i < n) {
        int s = x[i++];
        while (i < n && x[i] <= s + r) {
            i++;
        }
        int p = x[i - 1];
        while (i < n && x[i] <= p + r) {
            i++;
        }
        ans++;
    }
    printf("%d\n", ans);
}
```cpp

### Fence Repair

```cpp
int n, l[50010];
void solve() {
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> l[i];
    }
    LL ans = 0;
    while (n > 1) {
        int mii1 = 0, mii2 = 1;
        if (l[mii1] > l[mii2]) {
            swap(mii1, mii2);
        }
        for (int i = 2; i < n; ++i) {
            if (l[i] < l[mii1]) {
                mii2 = mii1;
                mii1 = i;
            } else if (l[i] < l[mii2]) {
                mii2 = i;
            }
        }
        int t = l[mii1] + l[mii2];
        ans += t;
        if (mii1 == n - 1) {
            swap(mii1, mii2);
        }
        l[mii1] = t;
        l[mii2] = l[n - 1];
        n--;
    }
    printf("%lld\n", ans);
}
```cpp

蟻本 | 2-1 すべての基本 "全探索"

Fri, 22 May 2020 17:31:10 +0900

最近蟻本の初級編をやり直したのだが2-1と2-2の記事がなかったので一応貼り付けとく

部分和問題

bool dfs(int i, int sum) {
    if (i == n) {
        return sum == k;
    }
    if (dfs(i + 1, sum)) {
        return true;
    }
    if (dfs(i + 1, sum + a[i])) {
        return true;
    }
    return false;
}
void solve() {
    if (dfs(0, 0)) {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }
}
```cpp

### Lake Counting

```cpp
int n, m;
char field[110][110];
void dfs(int x, int y) {
    //置き換える
    field[x][y] = '.';
    for (int dx = -1; dx <= 1; ++dx) {
        for (int dy = -1; dy <= 1; ++dy) {
            int nx = x + dx;
            int ny = y + dy;
            if (0 <= nx && nx < n && 0 <= ny && ny < m &&
                field[nx][ny] == 'W') {
                dfs(nx, ny);
            }
        }
    }
}
void solve() {
    int res = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (field[i][j] == 'W') {
                dfs(i, j);
                res++;
            }
        }
    }
    printf("%d\n", res);
}
```cpp

### 迷路の最短路

```cpp
char maze[MAX_N][MAX_N + 1];
int n, m;
int sx, sy;
int gx, gy;
int d[MAX_N][MAX_N];
//移動４方向ベクトル
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// (sx, sy)から(gx, gy)への最短距離を求める
// たどり着けないとINF
int bfs() {
    queue<P> que;
    //全ての点をINFで初期化
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            d[i][j] = INF;
        }
    }
    //スタート地点をqueに入れて距離を0にする
    que.push(P(sx, sy));
    d[sx][sy] = 0;
    //キューが空になるまでループ
    while (que.size()) {
        //キューの先頭を取り出す
        P p = que.front();
        que.pop();
        //ゴールなら終了
        if (p.first == gx && p.second == gy) {
            break;
        }
        //移動4方向ループ
        for (int i = 0; i < 4; ++i) {
            //移動した後の点を(nx, ny)とする
            int nx = p.first + dx[i];
            int ny = p.second + dy[i];
            //移動が可能か
            //すでに訪れていないか
            if (0 <= nx && nx < n && 0 <= ny && ny < m && maze[nx][ny] != '#' &&
                d[nx][ny] == INF) {
                //移動できるならばキューに入れて、距離を代入
                que.push(P(nx, ny));
                d[nx][ny] = d[p.first][p.second] + 1;
            }
        }
    }
    return d[gx][gy];
}
void solve() {
    int res = bfs();
    printf("%d\n", res);
}
```cpp

競プロ勉強会第0回

Sat, 16 May 2020 02:26:38 +0900

最近atcoderをやっていることをツイートしたら, めちゃめちゃ頭のいいFさんにお声がけいただいて,つよつよエンジニア学生Aくんも誘って, 競プロの勉強会をすることにしました。

僕はそんなに頭がよくなく理解が遅いかつ実装が遅いのでなかなか恐れ多い勉強会ですが, 頑張って食らいついていこうと思っております。

僕はC++を使っていて, FさんとAくんはPythonを使ってます。 Fさんは来週からC++使うそうです。あっという間に抜かされそうです。

今週はatcoder150を解きました。

D - Semi Common Multiple

長さ N の偶数からなる正の整数列 A = a_1, a_2, …, a_N と、整数 M が与えられます。任意の k ( 1 ≤ k ≤ N) に対して以下の条件を満たす正の整数 X を A の「半公倍数」と定義します。 X = a_k * (p + 0.5) を満たす負でない整数 p が存在する。 1 以上 M 以下の整数のうちの A の半公倍数の個数を求めてください。

半公倍数の理解に時間がかかった。Aの要素が2で割れる回数が全て等しくなければならないというところがミソ。

E - Change a Little Bit

0, 1からなる長さ N の異なる 2 つの数列 S , T に対し、関数 f (S , T) を以下のように定めます。 S に対し以下の操作を繰り返して T と等しくすることを考える。このとき行う操作のコストの和として考えられる最小の値が f(S , T) である。 S_i を ( 0 から 1 、もしくは 1 から 0 に) 変更する。この操作のコストは、変更の直前に S_j ≠ T_j ( 1 ≤j ≤N) であったような整数 j の個数を D として、 D * C_i である。 0 , 1 からなる長さ N の異なる 2 つの数列の組 (S , T) は 2^N × ( 2^N − 1) 通り考えられます。これらすべてに対する f( S , T) の和を 10^9 + 7 で割った余りを計算してください。

作って理解するOS

Fri, 15 May 2020 13:00:43 +0900

小学生の時にWindowsXPを触った時は, PCというものの中身をいつか全部理解したいなとか思ってました。天才少年です。

そんな夢をかなえるためにOSを作っちゃおうと思い, 作って理解するOS - x86系コンピュータを動かす理論と実装という本に取り組むことにしました。その第3部から実装が始まるのですが, ハマりポイントがたくさんあると思うのでメモしていこうと思います。

docker, vagrantでは動かなかった

詳しいエラーを忘れてしましましたが, display Xに関する部分でエラーが起きてしまいます。

本ではWindows上で実装しているのですが, Macに問題が起きると嫌なので最初仮想環境でやろうと頑張ってましたが, GUIを起動する感じなのでだめでした。解決策になってないのですが諦めてParallels上でWindows10を動かす力技に取り組むことにしました。

文字コードがShift-JIS

これはビビった。UTF-8じゃないんや。

iodebugをUnloadする

本の通り進めてもハマるところがここ。Plugin Control > Edit > iodebug > Unloadすればいけた。

Vue.js チートシート

Sun, 10 May 2020 07:24:04 +0900

vuejsの気になったところ

watcherの注意点

wacherの中ではthisを使えない。なるべくcomputedを使う。

watch: {
    counter() {
        const vm = this;
        setTimeout(() => {
            vm.counter = 0;
        }, 3000);
    },
},

v-onディレクティブでの注意点

<!-- method event handler。vue側がいい感じに解釈 -->
<button @click="countUp">+1</button>
<!-- javascript式 -->
<button @click="countUp()">+1</button>

v-showの特徴

display: noneのcssがかかる
全てdomに追加されるため初期描画が遅い
要素を削除せずにcssをかけるだけなので描画の切り替えが早い
elseがない

v-forの特徴

要素の変更が最小限になるようになるべく再利用する
予期しないバグを生む可能性があるので, key属性をつける

仮想ノード

createElemetで作られているのは仮想DOMを作るための仮想ノードである。いわゆるDocument Object Modelではなくjavascriptのオブジェクトである。

new Vue({
        data: {
          name: "tak",
        },
        render(createElement) {
          return createElement("h1", "hello, " + this.name)
        }
      }).$mount("#app3");

仮想DOM

DOMの変更を高速に反映するための仕組み。DOMを直接変更するには時間がかかるので, 仮想DOMを変更し前の仮想DOMとの差分を反映して高速に描画する。

Babel

JavaScriptのコードを新しい書き方から古い書き方へと変換するツール

Webpack

webpackは、モジュールを束ねるツールです。モジュールとは、プログラム内のJavaScriptファイル（以下：jsファイル）やsassファイルなどのことです。webpackを使うことで、複数のjsファイルをひとつのjsファイルにまとめたり、複数のsassファイルをひとつのsassファイルにしたりできます。

Dockerチートシート

Wed, 29 Apr 2020 06:00:40 +0900

Dockerの忘れそうなところをメモ。

Dockerコンテナの実行

docker run

pull, create, startを一気にやっちゃう

-v /User/takaaki/html:/usr/share/nginx/html:ro

バイトマウントする。roとかだとread onlyオプションをつけることができる。

-rm

コンテナを停止したときに削除する。

-d

バックグランド実行

-e AUTHOR="Takaaki"

環境変数を設定できる。

--link static-site:ss

リンク先に通信できるようになる。リンク先の環境変数を追加できる。

docker build

イメージを作成。引数にビルドコンテキストを指定。

ビルドコンテキスト…イメージが参照する範囲を指定する。ここで指定した範囲がDocker Hubにpushされるため小さい方がいい。Dockerfileがあるディレクトリの場所でもある。

docker create

イメージからコンテナを作成。

-i

コンテナの標準入力を取得して双方向に接続.

-t

コンテナ内にtty(eletypewriter)を割り当てる。

docker cp

文字通りコピー。ホストからコンテナ、コンテナからホストどちらにもできる。

docker add

これは文字通りではない。tarを自動で展開したりURLからダウンロードしたりする処理が走る。cpが推奨される。

docker pause, docker unpause

docker stop, docker start

docker inspect

docker rmi

イメージを削除。

docker rm

コンテナを削除。

docker attach

コンテナに接続される。exitで抜けるとstopされる。itで実行していたならばctrl + p, ctrl + qで抜けるとstopされない。

docker exec

コンテナ内でコマンドを実行。docker exec -it {image} /bin/bashとしてbashを実行するのによく使われ、exitで抜けてもstopされないため安全であり推奨される。

WordPressでPrism.jsを使ってシンタックスハイライトを行う方法

Sat, 18 Apr 2020 02:02:43 +0900

久しぶりにテーマを更新したらPrism.jsが消えちゃってたのでいれなおしました。参考にしたのは以下のサイトです。

WordPressでPrism.jsを使いコードのシンタックスハイライトを行う方法 https://stupiddog.jp/note/archives/718

Prism.jsのダウンロード

https://prismjs.com/download.htmlに行って自分の好みのjsとcssをダウンロードします。僕は以下のように設定しました。

themes=prism-tomorrow&languages=markup+css+clike+javascript+bash+c+cpp+cmake+css-extras+diff+django+git+go+haskell+http+java+javadoc+javadoclike+javastacktrace+jsdoc+js-templates+json+jsonp+json5+julia+kotlin+latex+makefile+markdown+markup-templating+nginx+perl+php+phpdoc+php-extras+python+r+jsx+tsx+ruby+rust+sqf+sql+swift+typescript+vim+yaml&plugins=line-highlight+line-numbers+show-invisibles+autolinker+wpd+custom-class+file-highlight+show-language+jsonp-highlight+highlight-keywords+remove-initial-line-feed+inline-color+previewers+autoloader+keep-markup+command-line+unescaped-markup+normalize-whitespace+data-uri-highlight+toolbar+copy-to-clipboard+download-button+match-braces+diff-highlight+filter-highlight-all+treeview

やり過ぎた感あります。

WordPress内に配置

最初適当に配置してヘッダーいじればいいやと思って、Cyberduck繋いでうろちょろしてたんですが, WordPressが提供している方法があるそうです。以下のディレクトリに配置しました

/public_html/wp-content/themes/baskerville/js/prism.js
/public_html/wp-content/themes/baskerville/prism.css

cssはディレクトリがなかったのでbaskerville直下に入れてみました。

ヘッダーで読み込む

public_html/wp-content/themes/baskerville/functions.phpのファイルに追記しました。


/* ---------------------------------------------------------------------------------------------
   For Prism (2020/4/18, Takaaki Sawa)
   --------------------------------------------------------------------------------------------- */
function my_enqueue_scripts() {
  $theme_uri = get_template_directory_uri();
  wp_enqueue_script( 'prism-js', $theme_uri . '/js/prism.js', array('jquery'), false, true );
  wp_enqueue_style( 'prism-css', $theme_uri . '/prism.css');
}
add_action( 'wp_enqueue_scripts', 'my_enqueue_scripts' );

最後に

ってな感じです。ブログ書くのってめんどくさいですね。

正規表現チートシート

Wed, 05 Jun 2019 07:27:16 +0900

udemyの教材で正規表現の勉強をした。いままでなんとなく書いていたたが, これからはなんでもかける気がする…

基本的な記号

= 文字または数字を1文字分指定する
^(キャロット) = 直後の文字または数字を指定しない
-(ハイフン) = 文字数字の範囲を指定する
(バックスラッシュ) = 直後のメタ文字を単なる文字として扱う
. (ワイルドカード) = なんでもよし
|(パイプ) = 左右のどちらかにマッチするか判定する
()(丸かっこ) = 正規表現をグループ化する

数量詞

繰り返したいパターンの直後におく

+(プラス) = 1回以上の繰り返し
*(アスタリスク) = 0回以上の繰り返し
?(クエスチョンマーク) = 入力なしか1文字のみ
{n} = n回の繰り返し
{n, } = n回以上の繰り返し
{n, m} = n回以上, m回以下の繰り返し

一致方法

最長一致(デフォルト)
最短一致
- ?を数量詞の最後につける

区切り

^ = カバーする範囲の先頭を行頭に指定
$ = カバーする範囲の最後を行末に指定
\b = スペースや改行による単語の区切り前後につけて単語を見つける
\B = \b以外の区切り単語の中の文字列を見つける

1文字のメタ文字では機能が逆になる

ショートコード

[0-9] = \d
[^0-9] = \D
[a-zA-Z0-9_] = \w
[^a-zA-Z0-9_] = \W
\n = 改行
\t = タブ
\r = リターン
\f = 改ページ
[\n\t\r\f ] = \s
[^\n\t\r\f ] = \S

修飾子

g(global) = マッチする結果すべてを抽出
i(case-insensitive) = 大文字と小文字を区別しない
m(multiline) = ^と$の挙動を変え, 複数行を対象にする

日本語

ひらがな
- [ぁ-ん]
- [\u3041-\u3096]
- [\x{3041}-\x{3096}]
カタカナ
- [ァ-ヶ]
- [\u30A1-\u30FA]
- [\x{30A1}-\x{30FA}]
漢字
- [亜-煕]
- [々〇〻\u3400-\u9FFF\uF900-\uFAFF]|[\uD840-\uD87F][\uDC00-\uDFFF]
- [々〇〻\x{3400}-\x{9FFF}\x{F900}-\x{FAFF}]|[\x{D840}-\x{D87F}][\x{DC00}-\x{DFFF}]
半角文字以外
- [^\x01-\x7E]

応用

フリーダイヤル
- /0120-((\d{2}-\d{4})|(\d{3}-\d{3}))/
市街局番
- /\d{2, 4}-\d{2, 4}-\d{4}/
携帯番号
- /(090|080|070)-\d{4}-\d{4}/
URL
- /http[s]?://[\w/%&$#?()=~+-]+/
メールアドレス
- /[\w-]+@([/w-]+.)+[a-zA-Z]{2, }

感想

とりあえず正規表現が使えそうだったらこのページを参考に書いてみようと思う.

蟻本 | 2-7 GCJの問題に挑戦してみよう(1)

Tue, 21 May 2019 14:05:06 +0900

今まで学んだことを生かして4問解いてみた. 答えと全然違う実装をしたくないので, 問題を読んで実装の流れを考えたら答えをみるという流れでやってみた.

Minimum Scalar Product (2008 Round1A A)

2つのベクトル成分を自由に入れ替えて内積を最小にする問題. 最初は数の正負を考えて, 正の数で絶対値が大きいものには負の数で絶対値が大きいものと積を取るようにみたいなことを考えていたが, シンプルに2つの成分を順と逆順でソートすればよかった.

const int MAX_N = 800;
typedef long long ll;
int n;
int v1[MAX_N], v2[MAX_N];
void solve() {
    sort(v1, v1 + n);
    sort(v2, v2 + n);
    ll ans = 0;
    for (int i = 0; i < n; i++) {
        ans += (ll)v1[i] * (ll)v2[n - i - 1];
    }
    printf("%lld\n", ans);
}
```cpp

### Crazy Rows (2009 Round2 A)

行をバブルソートする問題. 行列が与えられて下三角行列がどうとか難しい話をしているが案外簡単で, 上から順に行を埋めていくことを考える. 動かす行は上の行にすることで, 動かす操作数を最小化する.

実装のポイントとしては`a[i]: i行目の最後に現れる1の位置-1 ~ N-1`を定義することで行列より扱いやすくしている. また, 配列の要素を入れ替える`swap`をうまく使って再帰的な処理を実現している.

```cpp
void solve() {
    int res = 0;
    // 配列にする
    for (int i = 0; i < N; i++) {
        a[i] = -1;
        for (int j = 0; j < N; j++) {
            if (M[i][j] == 1) {
                a[i] = j;
            }
        }
    }
    for (int i = 0; i < N; i++) {
        int pos = -1;  // i + 1行目に移動する行番号
        for (int j = i; j < N; j++) {
            if (a[j] <= i) {
                pos = j;
                break;
            }
        }
        // 実際にスワップ
        for (int j = pos; j > i; j--) {
            swap(a[j], a[j - 1]);
            res++;
        }
    }
    printf("%d\n", res);
}
```cpp

### Bribe the Prisoners (2009 Round 1C C)

囚人の問題. 普通に問題として面白かった. アルゴリズムのポイントとしては, 空き部屋の概念と端の概念を一緒にしていかに再帰を実現するか.

実装のポイントとしては, 動的計画法を用いるために`dp[MAX_Q + 1][MAX_Q + 2]: (i, j)を解放するのに必要な金貨`を定義して使うところ. dpがどういう動きをするのかが最初わかりにくいので具体的な例でdpテーブルを埋める作業をしてみる. 幅が小さい順に調べるモチベーションがわかる.

```cpp
const int MAX_Q = 100;
int P, Q, A[MAX_Q + 2];
// (i, j)を解放するのに必要な金貨
int dp[MAX_Q + 1][MAX_Q + 2];
void solve() {
    // 簡単のため端をAに追加する
    A[0] = 0;
    A[Q + 1] = P + 1;
    // 初期化
    for (int q = 0; q <= Q; q++) {
        dp[q][q + 1] = 0;
    }
    // 幅が小さい順にdpを埋めていく
    for (int w = 2; w <= Q + 1; w++) {
        for (int i = 0; i + w <= Q + 1; i++) {
            int j = i + w;
            int t = INT_MAX;
            // 最初に解放する囚人を全て試し最小コストのものを探す
            for (int k = i + 1; k < j; k++) {
                t = min(t, dp[i][k] + dp[k][j]);
            }
            // 最初の解放では解放する囚人にかかわらずA[j] - A[i] - 2の金貨が必要
            dp[i][j] = t + A[j] - A[i] - 2;
        }
    }
    printf("%d\n", dp[0][Q + 1]);
}
```cpp

### Millionaire (2008 APAC local onsites C)

お金の掛け方が整数に限られていないので, 全探索ができない. ここで, ラウンドが1回しかなかった場合, 金額によって0%, P%, 100%の3つの確率に分けられることに気づく. さらに2ラウンドの場合は, 5つの確率に分けられる. この考えかたを動的計画法で実装する.

実装のポイントとしては, iラウンド目の確率はi-1ラウンド目の確率をもとに計算するので, 2つの配列`prv`と`nxt`を用意してうまく使うところにある. i-1ラウンド目の状態から正解・不正解する場合を確率の独立性を生かして考える.

```cpp
typedef long long ll;
const int MAX_M = 15;
int M, X;
double P;
double dp[2][(1 << MAX_M) + 1];
void solve() {
    // n = 2^M
    int n = 1 << M;
    double \*prv = dp[0], \*nxt = dp[1];
    memset(prv, 0, sizeof(double) * (n + 1));
    // 既に100万円持っていれば確率1
    prv[n] = 1.0;
    for (int r = 0; r < M; r++) {
        for (int i = 0; i <= n; i++) {
            int jub = min(i, n - i);
            double t = 0.0;
            for (int j = 0; j <= jub; j++) {
                t = max(t, P * prv[i + j] + (1 - P) * prv[i - j]);
            }
            nxt[i] = t;
        }
        swap(prv, nxt);
    }
    // 全勝した場合の金額 / 100万円
    int i = (ll)X * n / 1000000;
    printf("%.6f\n", prv[i]);
}
```cpp

### 感想

アルゴリズムに落とし込むところは発想力, そのあとの実装は再帰などをどう実現するかの数学力が必要なのではないかと思った.

蟻本 | 2-6 数学的な問題を解くコツ

Sun, 12 May 2019 03:28:45 +0900

ユークリッドの互除法やエラストテネスの篩, 繰り返し二乗法の計算を勉強した.

線分上の格子点の個数

最大公約数-1がこの問題の解となる. ユークリッドの互除法を元にgcdを実装.


#include <iostream>
#include <vector>
using namespace std;
int x_1, x_2, y_1, y_2;
int gcd(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}
int main(int argc, char const *argv[]) {
    cin >> x_1 >> y_1 >> x_2 >> y_2;
    int x_diff = abs(x_1 - x_2);
    int y_diff = abs(y_1 - y_2);
    cout << gcd(x_diff, y_diff) - 1 << endl;
    return 0;
}
```cpp

### 双六

ユークリッドの互除法を拡張する. `ax+by=1`を満たす整数`x, y`を探すには以下のようなスクリプトを書く.

```cpp

int extgcd(int a, int b, int& x, int& y) {
    int d = a;
    if (b != 0) {
        d = extgcd(b, a % b, y, x);
        y -= (a / b) * x;
    } else {
        x = 1;
        y = 0;
    }
    return d;
}
```cpp

### 素数判定

素数かどうかは`2 ~ √n`までを調べればよい.

```cpp

// 素数判定
bool is_prime(int n) {
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) return false;
    }
    return true;
}
// 約数の列挙
vector<int> divisor(int n) {
    vector<int> res;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            res.push_back(i);
            if (i != n / i) {
                res.push_back(n / i);
            }
        }
    }
    return res;
}
// 素因数分解
map<int, int> prime_factor(int n) {
    map<int, int> res;
    for (int i = 2; i * i <= n; i++) {
        while (n % i == 0) {
            ++res[i];
            n /= i;
        }
    }
    if (n != 1) {
        res[n] = 1;
    }
    return res;
}
```cpp

### 素数の個数

エラストテネスの篩と呼ばれるアルゴリズムを使って数える. 最小の素数の倍数をどんどん省いていく.

```cpp

int sieve(int n) {
    int p = 0;
    for (int i = 0; i <= n; i++) {
        is_prime[i] = true;
    }
    is_prime[0] = is_prime[1] = false;
    for (int i = 2; i <= n; i++) {
        if (is_prime[i]) {
            prime[p++] = i;
            for (int j = 2 * i; j <= n; j += i) {
                is_prime[j] = false;
            }
        }
    }
    return p;
}
```cpp

### 区間内の素数の個数

篩を2つ用いることで, 特定の区間の素数の個数を調べることができる. 区間`[a, b)`を調べる場合は, `[2, √b)`と`[a, b)`の篩を別々に作っておく.

```cpp

const int MAX_N = 100000000;
const int MAX_SORT_B = 100000000;
typedef long long ll;
bool is_prime[MAX_N];
bool is_prime_small[MAX_SORT_B];
int a, b;
void segment_sieve(ll a, ll b) {
    for (int i = 0; (ll)i * i < b; i++) {
        is_prime_small[i] = true;
    }
    for (int i = 0; i < b - a; i++) {
        is_prime[i] = true;
    }
    for (int i = 2; (ll)i * i < b; i++) {
        if (is_prime_small[i]) {
            for (int j = 2 * i; (ll)j * j < b; j += i) {
                is_prime_small[j] = false;
            }
            for (ll j = max(2LL, (a + i - 1) / i) * i; j < b; j += i) {
                is_prime[j - a] = false;
            }
        }
    }
}
```cpp

### Carmichael_Numbers

繰り返し二乗法を用いてべき乗を計算する. 基本的な考え方としては`x^22 = x^16 * x^4 * x^2`のようにx^2^i

を順次求めながら計算する.

```cpp

ll mod_pow(ll x, ll n, ll mod) {
    ll res = 1;
    while (n > 0) {
        if (n & 1) {
            res = res * x % mod;
        }
        x = x * x % mod;
        n >>= 1;
    }
    return res;
}
```cpp

## 感想

最後のビット計算をうまく使う実装は自分でできる気がしない…

蟻本 | 2-5 あれもこれも実は "グラフ"

Wed, 08 May 2019 14:22:01 +0900

グラフを使った解法を勉強した. グラフの表現方法として隣接行列と隣接リストの2つがあって, 最短経路問題を特にはベルマンフォード法, ダイクストラ法, ワーシャル-フロイド法があり, 最小全域木問題を特にはプリム法とクラスカル法がある. この一部を使った演習問題を紹介する.

二部グラフ判定

深さ優先探索を用いて, 隣接している頂点をどんどん塗っていく. グラフは隣接リストを使って表現されている.

#include <iostream>
#include <vector>
using namespace std;
const int MAX_V = 10000;
vector<int> G[MAX_V];
int V, E;
int color[MAX_V];
//頂点を1と-1で塗っていく
bool dfs(int v, int c) {
    color[v] = c;
    for (int i = 0; i < G[v].size(); i++) {
        // 隣接している頂点が同じ色ならfalse
        if (color[G[v][i]] == c) {
            return false;
        }
        // 隣接している頂点がまだ塗られていないなら-cで塗る
        if (color[G[v][i]] == 0 && !dfs(G[v][i], -c)) {
            return false;
        }
    }
    return true;
}
int main(int argc, char const *argv[]) {
    cin >> V >> E;
    for (int i = 0; i < E; i++) {
        int s, t;
        cin >> s >> t;
        G[s].push_back(t);
        G[t].push_back(s);
    }
    for (int i = 0; i < V; i++) {
        if (color[i] == 0) {
            if (!dfs(i, 1)) {
                printf("No\n");
                return 1;
            }
        }
    }
    printf("Yes\n");
    return 0;
}
```cpp

### Roadblocks

道を辺として, 交差点を頂点として2番目に短い経路を求める問題. 基本的にはダイクストラ法を用いるが, ２番目に短い経路も記憶しておくところがみそ.

```cpp
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int MAX_N = 1000;
const int INF = 99999999;
struct edge {
    int to, cost;
};
typedef pair<int, int> P;  // firstは最短距離, secondは頂点の番号
int N, R, E;
vector<edge> G[MAX_N];  // グラフの隣接リスト表現
int dist[MAX_N];
int dist2[MAX_N];
void read() {
    cin >> N >> R >> E;
    for (int i = 0; i < E; i++) {
        int s, t, c;
        cin >> s >> t >> c;
        edge x, y;
        x.to = s;
        y.to = t;
        x.cost = c;
        y.cost = c;
        G[s].push_back(y);
        G[t].push_back(x);
    }
}
void solve() {
    priority_queue<P, vector<P>, greater<P> > que;
    fill(dist, dist + N, INF);
    fill(dist2, dist2 + N, INF);
    // 発ノード
    dist[0] = 0;
    que.push(P(0, 0));
    while (!que.empty()) {
        P p = que.top();
        que.pop();
        int v = p.second;
        int d = p.first;
        if (dist2[v] < d) {
            // 2番目の最短路より長い
            continue;
        }
        // vと隣接している頂点を更新
        for (int i = 0; i < G[v].size(); i++) {
            edge e = G[v][i];
            int d2 = d + e.cost;
            if (dist[e.to] > d2) {
                // 最短より短い場合
                swap(dist[e.to], d2);
                que.push(P(dist[e.to], e.to));
            }
            if (dist2[e.to] > d2 && dist[e.to] < d2) {
                // ２番目より短い場合
                dist2[e.to] = d2;
                que.push(P(dist2[e.to], e.to));
            }
        }
    }
    printf("%d\n", dist2[N - 1]);
}
int main(int argc, char const *argv[]) {
    read();
    solve();
    return 0;
}
```cpp

### Conscription

人を頂点として親密度をコスト付きの辺として, 最小全域木をもとめる問題. この時, コストの高い辺を使いたいのでコストの正負を反転させる. また, この問題は男と女が分けられているが, 特殊な構造を使わなかった.

最小全域木を求めるときはクラスカル法を用いた. クラスカル法はUnionFind木の手法を応用している.

```cpp
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int MAX_N = 50000;
const int MAX_E = 50000;
const int MAX_R = 50000;
// union find
// --------------------------------------------
int par[MAX_N];
int depth[MAX_N];
void init_union_find(int n) {
    for (int i = 0; i < n; i++) {
        par[i] = i;
        depth[i] = 0;
    }
}
int find(int x) {
    if (par[x] == x) {
        return x;
    } else {
        return par[x] = find(par[x]);
    }
}
void unite(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y) return;
    if (depth[x] < depth[y]) {
        par[x] = y;
    } else {
        par[y] = x;
        if (depth[x] == depth[y]) depth[x]++;
    }
}
bool same(int x, int y) { return find(x) == find(y); }
struct edge {
    int u, v, cost;
};
bool comp(const edge& e1, const edge& e2) { return e1.cost < e2.cost; }
edge es[MAX_E];
int V, E;
int kruskal() {
    sort(es, es + E, comp);
    init_union_find(V);
    int res = 0;
    for (int i = 0; i < E; i++) {
        edge e = es[i];
        if (!same(e.u, e.v)) {
            unite(e.u, e.v);
            res += e.cost;
        }
    }
    return res;
}
int N, M, R;
int x[MAX_R], y[MAX_R], d[MAX_R];
void read() {
    cin >> N >> M >> R;
    for (int i = 0; i < R; i++) {
        cin >> x[i] >> y[i] >> d[i];
    }
}
void solve() {
    V = N + M;
    E = R;
    for (int i = 0; i < E; i++) {
        es[i] = (edge){x[i], N + y[i], -d[i]};
    }
    printf("%d\n", 10000 * (V) + kruskal());
}
int main(int argc, char const* argv[]) {
    read();
    solve();
    return 0;
}
```cpp

### Layout

牛を頂点と考え, 牛の番号, 仲の良さ, 仲の悪さをコストつきの辺として最短経路を求める問題. 発想としては, 全てを制約条件に落としこんだ結果, 両辺に変数が1つずつしか現れていないことに着目する.

今回は負の辺があるのでベルマンフォード法を用いる. 負閉路が存在するかどうかは, 牛の数だけupdateを行ったあとにも更新があるかどうかで判断する.

```sql
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int MAX_ML = 10000;
const int MAX_MD = 10000;
const int MAX_N = 1000;
const int INF = 99999999;
int N, ML, MD;
int AL[MAX_ML], BL[MAX_ML], DL[MAX_ML];
int AD[MAX_MD], BD[MAX_MD], DD[MAX_MD];
int d[MAX_N];
bool updated;
void read() {
    cin >> N >> ML >> MD;
    for (int i = 0; i < ML; i++) {
        cin >> AL[i] >> BL[i] >> DL[i];
    }
    for (int i = 0; i < MD; i++) {
        cin >> AD[i] >> BD[i] >> DD[i];
    }
}
void update(int& x, int y) {
    if (x > y) {
        x = y;
        updated = true;
    }
}
void bellmanford() {
    for (int k = 0; k <= N; k++) {
        updated = false;
        // i+1からiへコスト0
        for (int i = 0; i + 1 < N; i++) {
            if (d[i + 1] < INF) {
                update(d[i], d[i + 1]);
            }
        }
        // ALからBLへコストDL
        for (int i = 0; i < ML; i++) {
            if (d[AL[i] - 1] < INF) {
                update(d[BL[i] - 1], d[AL[i] - 1] + DL[i]);
            }
        }
        // BDからADへコスト-DD
        for (int i = 0; i < MD; i++) {
            if (d[BD[i] - 1] < INF) {
                update(d[AD[i] - 1], d[BD[i] - 1] - DD[i]);
            }
        }
    }
}
void solve() {
    // 負閉路チェック
    fill(d, d + N, 0);
    bellmanford();
    if (updated) {
        printf("%d\n", -1);
        return;
    }
    fill(d, d + N, INF);
    d[0] = 0;
    bellmanford();
    int res = d[N - 1];
    if (res == INF) {
        res = -2;
    }
    printf("%d\n", res);
}
int main(int argc, char const* argv[]) {
    read();
    solve();
    return 0;
}
```cpp

## 感想

最後の牛の並びを最短経路問題に変換する方法はむずすぎる….

蟻本 | 2-4 データを工夫して記憶する "データ構造"

Tue, 30 Apr 2019 00:17:51 +0900

平成最後の日も蟻本の勉強をしてみた. 二分木, 二分探索木, Union-Find木を使った問題を3問解いた.

priority_queueを用いる問題

1 expedition

ガソリンを補給する回数を最小限に抑える問題. 探索としては, 今あるガソリンで次のガソリンスタンドに辿り着けなかったら, 過去に通過した供給量が一番大きいガソリンスタンドで補給したことにする. ここで, ガソリンスタンドをpriority_queueに入れて, 供給量が大きいもの順に並べていた.


#include 
#include 
using namespace std;
const int MAX_N = 10000;
int N, L, P;
int A[MAX_N + 1], B[MAX_N + 1];
void read() {
    cin >> N >> L >> P;
    for (int i = 0; i < N; i++) {
        cin >> A[i];
    }
    for (int i = 0; i < N; i++) {
        cin >> B[i];
    }
}
void solve() {
    A[N] = L;
    B[N] = 0;
    priority_queue que;
    int ans = 0, pos = 0, tank = P;
    for (int i = 0; i <= N; i++) {
        int d = A[i] - pos;
        // ガソリンを補給
        while (tank - d < 0) {
            if (que.empty()) {
                puts("-1");
                return;
            }
            tank += que.top();
            que.pop();
            ans++;
        }
        tank -= d;
        pos = A[i];
        que.push(B[i]);
    }
    printf("%d\n", ans);
}
int main(int argc, char const *argv[]) {
    read();
    solve();
    return 0;
}
```cpp

### 2 fence repair

なるべく長い板を切らせないように目的の板の集合を手に入れる問題. ナイーブに実装すると`O(N^2)`時間になってしまうが, `priority_queue`を用いれば`O(NlogN)`時間になる.

```cpp

const int MAX_N = 10000;
int n, l[MAX_N];
void solve() {
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> l[i];
    }
    LL ans = 0;
    priority_queue, greater > que;
    for (int i = 0; i < n; i++) {
        que.push(l[i]);
    }
    while (que.size() > 1) {
        int l1, l2;
        l1 = que.top();
        que.pop();
        l2 = que.top();
        que.pop();
        ans += l1 + l2;
        que.push(l1 + l2);
    }
    printf("%lld\n", ans);
}
int main() {
    solve();
    return 0;
}
```cpp

#### `priority_queue`の小さい順

```cpp
priority_queue<int, vector<int>, greater<int> > que;
```cpp

このように宣言する.

### 3 食物連鎖

複数の情報から矛盾している情報の数を求める. 食物連鎖の関係に矛盾がないことを調べるのにUnion-Find木を用いる. 情報を見ると, 同じ種類に属するか捕食被食の関係にあるという情報だけで種類を特定できない. そこで, 3通りのUnion-Find木を作って1つの木が同時に実現するということにする.

以下がUnion-Find木の実装である.

```cpp
// union find
// --------------------------------------------
int par[MAX_N];
int depth[MAX_N];
// 初期化
void init(int n) {
    for (int i = 0; i < n; i++) {
        par[i] = i;
        depth[i] = 0;
    }
}
// 木の根を返す
int find(int x) {
    if (par[x] == x) {
        return x;
    } else {
        return par[x] = find(par[x]);
    }
}
// 木を併合する
void unite(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y) return;
    if (depth[x] < depth[y]) {
        par[x] = y;
    } else {
        par[y] = x;
        if (depth[x] == depth[y]) depth[x]++;
    }
}
bool same(int x, int y) { return find(x) == find(y); }
int N, K;
int T[MAX_K], X[MAX_K], Y[MAX_K];
void solve() {
    cin >> N >> K;
    for (int i = 0; i < K; i++) {
        cin >> T[i] >> X[i] >> Y[i];
    }
    init(N * 3);
    int ans = 0;
    for (int i = 0; i < K; i++) {
        int t = T[i];
        int x = X[i] - 1, y = Y[i] - 1;  // 0...N-1
        // 正しくない番号
        if (x < 0 || x >= N || y < 0 || y >= N) {
            ans++;
            continue;
        }
        if (t == 1) {
            // xとyは同じ種類という情報
            if (same(x, y + N) || same(x, y + N * 2)) {
                ans++;
            } else {
                unite(x, y);
                unite(x + N, y + N);
                unite(x + N * 2, y + N * 2);
            }
        } else {
            if (same(x, y) || same(x, y + N * 2)) {
                ans++;
            } else {
                unite(x, y + N);
                unite(x + N, y + N * 2);
                unite(x + N * 2, y);
            }
        }
    }
    printf("number of wrong info is %d\n", ans);
}
int main() {
    solve();
    return 0;
}
```cpp

## 感想

Union-Find木を知らなかったので, 食物連鎖の実装が綺麗でわかりやすかった. これも標準のライブラリがあればいいのに…

蟻本 | 2-3 値を覚えて再利用 "動的計画法"

Sat, 27 Apr 2019 18:49:31 +0900

アルゴリズム活用力は, 主にコーディングの試験の際に見られるところであり, webアプリやモバイルアプリを作るのにはあまり必要ないかもしれない. しかし, 将来転職する際にAtcoderである程度の成績を納めていたら強いのではという理由と, 単に楽しいからという理由で蟻本の中級くらいやりたいなと思っている. ってか, 今日のAtcoder全然解けへんくて萎えた…

今回は, 2_3 値を覚えて再利用"動的計画法"を勉強した.

01ナップサック問題

dpを使った動的計画法の初歩が書かれていた. 全探索を行うとO(2^n)かかってしまうところが, メモ化によりO(nW)の計算量で済む. この問題のコツは, 品物と重さを引数として価値の総和を出した時に計算結果を残しておくという発想から.


const int MAX_N = 100;
int n, W;
int w[MAX_N], v[MAX_N];
// dp[i+1][j]: i番目までの品物から重さの総和がj以下となるように選んだ時の,
// 価値の総和の最大値
int dp[MAX_N + 1][MAX_N + 1];
int main() {
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> w[i] >> v[i];
    }
    cin >> W;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= W; j++) {
            if (j < w[i]) {
                dp[i + 1][j] = dp[i][j];
            } else {
                dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
            }
        }
    }
    printf("max sum value is %d\n", dp[n][W]);
    return 0;
}
```cpp

#### 参考: メモ化テーブルを初期化する方法

```cpp
memset(dp, -1, sizeof(dp));
```cpp

ってな感じで, 0と-1ならば初期化できる. 1はできない.

### 最長共通部分列問題

この問題のコツは, 2つも文字列を引数とした計算結果をメモ化するところである. 最初のうちはDPテーブルをかくと漸化式が浮かびやすいかなと思う.

```cpp

const int MAX_N = 1000;
int n, m;
char s[MAX_N], t[MAX_N];
int dp[MAX_N][MAX_N];
int main() {
    cin >> n >> m >> s >> t;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (s[i] == t[j]) {
                dp[i + 1][j + 1] = dp[i][j] + 1;
            } else {
                dp[i + 1][j + 1] = max(dp[i + 1][j], dp[i][j + 1]);
            }
        }
    }
    cout << "max value is " << dp[n][m] << endl;
    return 0;
}
```cpp

### 個数制限なしのナップサック問題

個数制限がなくなったことで, 愚直に計算するとforループがもう一つ増えてしまう. そこで無駄に計算を行なっている箇所を探して, 漸化式を簡単にする. コツとしては, DPテーブルをみて漸化式の動きをみて, 簡単になる箇所がないかを探すのみだと思う.

#### 参考: 偶奇を考えた配列の再利用

```cpp
for (int i = 0; i < n; i++) {
    for (int j = 0; j <= W; j++) {
        if (j < w[i]) {
            dp[(i + 1) & 1][j] = dp[i & 1][j];
        } else {
            dp[(i + 1) & 1][j] =
                max(dp[i & 1][j], dp[(i + 1) & 1][j - w[i]] + v[i]);
        }
    }
}
```cpp

`(i + 1) & 1`の使い方がめちゃうまい気がする… こうして, 2行分のデータを確保できる.

### 01ナップサック問題その2

重さの制約条件が緩くなって, Wが10^9まで飛んでしまった時は, Wでforループを回したくなくなる. そんなときは, メモ化けする対象を入れ替えることでうまくいく. メモ化の値に大きくなるものを入れるのがコツな気がする.

```cpp

const int MAX_N = 100;
const int MAX_V = 100;
const int INF = 99999999;
int n, W;
int w[MAX_N], v[MAX_N];
// dp[i+1][j]: i番目までの品物から価値の総和がjとなるよう選んだときの,
// 重さの総和の最小値 そのような解が存在しない場合は十分大きな値INF
int dp[MAX_N + 1][MAX_N * MAX_V + 1];
int main() {
    // 入力値の読み込み
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> w[i] >> v[i];
    }
    cin >> W;
    // 解く
    fill(dp[0], dp[0] + MAX_N * MAX_V + 1, INF);
    dp[0][0] = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= MAX_N * MAX_V; j++) {
            if (j < v[i]) {
                dp[i + 1][j] = dp[i][j];
            } else {
                dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i]);
            }
        }
    }
    int res = 0;
    for (int i = 0; i <= MAX_N * MAX_V; i++) {
        if (dp[n][i] <= W) {
            res = i;
        }
    }
    printf("max sum value is %d\n", res);
    return 0;
}
```cpp

### 個数制限付き部分和

bool値をメモ化けするのは無駄がある. そこで大きな値である残りの`a_i`を入れることで漸化式が改善されて計算量を落とすことができる.

```cpp

const int MAX_N = 100;
const int MAX_K = 100000;
int n;
int K;
int a[MAX_N];
int m[MAX_N];
// dp[i+1][j]: i番目まででjを作る際に余る最大のi番目の個数(作れない場合は-1)
int dp[MAX_K];
int main() {
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> a[i] >> m[i];
    }
    cin >> K;
    memset(dp, -1, sizeof(dp));
    dp[0] = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= K; j++) {
            if (dp[j] >= 0) {
                dp[j] = m[i];
            } else if (j < a[i] || dp[j - a[i]] < 0) {
                dp[j] = -1;
            } else {
                dp[j] = dp[j - a[i]] - 1;
            }
        }
    }
    if (dp[K] > 0) {
        printf("answer is YES\n");
    } else {
        printf("answer is NO\n");
    }
    return 0;
}
```cpp

### 最長増加部分列問題

案外奥が深い問題. 部分文字列の候補があがってくるのでそれをメモ化すると`O(n^2)`で解くことができるが, 候補よりも, 最終要素がなにであるかに着目すると`O(n \log n)`で解くことができる. ここらへんは地頭の良さ.

#### 参考: lower_bound

```cpp
fill(dp, dp + n, INF);
for (int i = 0; i < n; i++) {
    * lower_bound(dp, dp + n, a[i]) = a[i];
}
printf("%ld\n", lower_bound(dp, dp + n, INF) - dp);
```cpp

ってな感じで, ソートされた列aから二分探索で`a_i <= k`となりような最小の`a_i`のポインタを求めることができる.

### 分割数

最適化だけでなく場合の数にも応用.

```cpp

const int MAX_N = 1000;
const int MAX_M = 1000;
int n, m;
int M;
int dp[MAX_M + 1][MAX_N + 1];
int main(int argc, char const *argv[]) {
    cin >> n >> m;
    cin >> M;
    dp[0][0] = 1;
    for (int i = 1; i <= m; i++) {
        for (int j = 0; j <= n; j++) {
            if (j >= i) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - i];
            } else {
                dp[i][j] = dp[i - 1][j];
            }
        }
    }
    printf("%d\n", dp[m][n] % M);
    return 0;
}
```cpp

### 重複組み合わせ

これはめちゃめちゃ難しかった. これも,

- 何をメモ化するか
  - 漸化式が作れるように
  - 計算量が多くならないように
- 1つ前の値を意識する
  - DPテーブルから漸化式を導き出す

みたいなところが大事である.

```cpp

const int MAX_N = 1000;
int n, m;
int a[MAX_N + 1];
int M;
int dp[MAX_N + 1][MAX_N + 1];
int main(int argc, char const *argv[]) {
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    cin >> M;
    // 1つも選ばない方法は常に1通り
    for (int i = 0; i <= n; i++) {
        dp[i][0] = 1;
    }
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            if (j - 1 - a[i] >= 0) {
                dp[i + 1][j] =
                    (dp[i + 1][j - 1] + dp[i][j] - dp[i][j - 1 - a[i]] + M) % M;
            } else {
                dp[i + 1][j] = (dp[i + 1][j - 1] + dp[i][j]) % M;
            }
        }
    }
    printf("%d\n", dp[n][m]);
    return 0;
}
```cpp

## 感想

蟻本なかなか重たい. 結構な練習を積まないと身につかない. やっぱり初級編だけ終わらせようかなと思ってきた…

Study on ashitaka blog

人文学を勉強したい

ブルシット・ジョブが増殖している？

週15時間労働はなぜ実現しなかったのか

無意味な仕事がでっち上げられている

ブルシット・ジョブの定義

まとめ

2024年から始まる教育とエミール

エミールにたどり着くまで

中学生までは理性が眠っている

最初らへん感覚めちゃ大事

時間を無駄にするのが教育

幼児期においては勉強は不要

まとめ

LlamaIndexを触ってみる (Part 1)

気づきたち

Vimmerを卒業してCursorerになる

Cursorとは

Cursorでできること

コードについて質問できる

コードを書いてくれる

コードを修正してくれる

コマンドも書いてくれる

Vimの操作感は捨て難い…!

ChatGPTと文字数制限しりとりしてみた

まとめ

Stable DiffusionをDiffusion Beeで動かしてみた

Salesforce認定 Experience Cloudコンサルタント試験をChatGPTに解かせてみた

Insight

やりとり

USER

ASSISTANT

USER

ASSISTANT

USER

ChatGPTに京都大学2014年度の数学の問題を解かせてみた

Let’s ask ChatGPT

ChatGPT4 本格RPG「チャット転生 〜 死んだはずの幼馴染が異世界で勇者になっていた件」をプレイしてみた

ASSISTANT

USER

ASSISTANT

USER

ASSISTANT

USER

ASSISTANT

USER

ASSISTANT

USER

ASSISTANT

USER

ASSISTANT

USER

ASSISTANT

USER

ASSISTANT

USER

ASSISTANT

USER

GPT-4のスクリプト実行したら記事全部消えた

まとめ

ChatGPTでテトリス作ってみた

完成形

会話highlight

一瞬でコード書けるスーパーエンジニア

すぐ解決策に走る初心者エンジニア

「コード見せて」といってくるベテランエンジニア

かわいい

最後にお礼にコードレビューしてみると…?

ChatGPTと喋った内容

Takaaki

ChatGPT

Makefileで改行文字を扱う

Vimのヤンクレジスタを使いこなしたい

参考

よくある間違い

Visual modeを使った回避策

ブラックホールレジスタを使った回避策

ヤンクレジスタを使った回避策

2020年度に読んだ本のまとめ

お金

ChatGPT4 本格RPG「チャット転生〜死んだはずの幼馴染が異世界で勇者になっていた件」をプレイしてみた

1章マイクロサービス

2章進化的アーキテクト

3章サービスのモデル化方法

4章統合

第2章認証・認可のしくみとフロー ~ FIDOからOAuth, SAMLまで一挙に解説 ~

AWS認定ソリューションアーキテクト[アソシエイト]

競プロ勉強会第2回

競プロ勉強会第1回

競プロ勉強会第0回