Posts on otokichi3's tech-ish blog

WordPress コンテナに Cocoon テーマをアップロードする方法

Sun, 05 Oct 2025 09:41:14 +0900

はじめに

WordPress に Cocoon をインストールする際、WordPress をホストしているサーバの設定が初期状態のままだとアップロードに失敗するケースがあります。本記事は起きるエラーと原因、その対処法を説明します。

起きるエラー

XServer レンタルサーバーでは初期状態でも発生しません。WordPress コンテナを使った場合にのみ発生します。Cocoon テーマのアップロード時に発生するエラーは以下の画面のものです。

「辿ったリンクは期限が切れています。」という文言なので WordPress の構築や設定に問題があるように感じますが、実際はそうではありません。

原因

ini ファイルという設定ファイルに定義された upload_max_filesize と post_max_size の値が小さいことです。 Cocoon 親テーマは約 22 MB ですが、上記の設定はデフォルトで以下の状態です。

...
; Maximum size of POST data that PHP will accept.
; Its value may be 0 to disable the limit. It is ignored if POST data reading
; is disabled through enable_post_data_reading.
; https://php.net/post-max-size
post_max_size = 2M
...
; Maximum allowed size for uploaded files.
; https://php.net/upload-max-filesize
upload_max_filesize = 2M
...

なお、upload_max_filesize のみを変更してもエラーは解消しません。どちらもエラーの原因です。

対処法

以下の通り変更します。

...
; Maximum size of POST data that PHP will accept.
; Its value may be 0 to disable the limit. It is ignored if POST data reading
; is disabled through enable_post_data_reading.
; https://php.net/post-max-size
post_max_size = 1G
...
; Maximum allowed size for uploaded files.
; https://php.net/upload-max-filesize
upload_max_filesize = 1G
...

1G は大きすぎる値に感じますが、XServer の初期設定です。XServer は様々なお客様が利用した膨大なユースケースに応じた設定になっているはずなので、1G でほぼ問題が起きることはないということでしょう。

手順

PHP だと /usr/local/etc/php/php.ini が上記の設定ファイルですが、以下の箇所に配置しても反映されません。

# pwd
/usr/local/etc/php
# ls
conf.d  php.ini-development  php.ini-production

WordPress ではさらに深い /usr/local/etc/php/conf.d の中の wordpresss.ini で設定されます。

# pwd
/usr/local/etc/php/conf.d
# ls
docker-php-ext-bcmath.ini  docker-php-ext-imagick.ini  docker-php-ext-opcache.ini  error-logging.ini
docker-php-ext-exif.ini    docker-php-ext-intl.ini     docker-php-ext-sodium.ini   opcache-recommended.ini
docker-php-ext-gd.ini      docker-php-ext-mysqli.ini   docker-php-ext-zip.ini      wordpress.ini

もちろん docker exec wordpress xxx のようにコンテナ内でコマンドを実行して変更する方法もありますが、これはコンテナ再作成に伴い元に戻るので、突然またアップロードできなくなる可能性があります。このため、ローカル環境に置いてある wordpress.ini をコンテナの該当ディレクトリに配置する方式を取ります。

まずは手元に wordpress.ini を用意します。デフォルトではコンテナ内に wordpress.ini は存在しないため、代わりに php.ini-production を再利用します。

`1`	`$ docker exec wordpress /bin/cat /usr/local/etc/php/php.ini-proudction > wordpress.ini`

これで手元に wordpress.ini が作成されます。次に、2つの設定値を変更します。これは上述の通り 1G などに変更するといいです。

最後に compose.yml (docker compose のための設定ファイル) に以下の通り記述します

services:
  wordpress:
    image: wordpress:latest
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wordpress.ini:/usr/local/etc/php/conf.d/wordpress.ini

volumes によってこの設定ファイルと同じディレクトリ内にある wordpress.ini が /usr/local/etc/php/conf.d/wordpress.ini に配置されます。これで WordPress 上に Cocoon テーマをインストールできるようになります。

おまけ

Cocoon は低サイズ版のテーマを用意しており、そちらであれば初期設定でも、また設定を変更できない環境でもアップロードできます。なので、普段からコンテナを利用しておりどうしてもコンテナ化したい場合以外は低サイズ版をアップロードするのが早いでしょう。

ほかの方法として、Custom PHP Settings プラグインを利用する方法があります。このプラグインは、起動しているサーバ上の ini ファイルを画面から編集できるようにするものです。ややこしい設定ファイルをいじる必要がないので、楽に変更できます。ただし、コンテナ環境の場合は再作成でもとに戻るため注意が必要です。

2824. Count Pairs Whose Sum is Less than Target

Thu, 08 May 2025 23:41:47 +0900

はじめに

整数の配列 nums と整数 target が与えられるので、0 <= i < j <= n かつ nums[i] + nums[j] < target を満たす組の数をカウントせよ、という問題。簡単そうですよね。簡単です。とりあえず、いわゆる brute force で解けます。

初手

解いちゃうのどうなの？と思いますが、とりあえず解く方法が分かっていたので二重ループで解きました。時間計算量は最良ではないです。

func countPairs(nums []int, target int) int {
    ans := 0
    for i := 0; i < len(nums); i++ {
        for j := i + 1; j < len(nums); j++ {
            if nums[i] + nums[j] < target {
                ans++
            }
        }
    }
    return ans
}

i を固定して j をカウントアップし、一つ一つ条件に合う組をカウントしていく方法です。直感的です。

最良と思われる手

Two Pointers を使います。そして、0 <= i < j <= n から勝手に課してしまった制約を取り払います。それは「与えられた nums の配列は並び替えずそのまま使う」というものです。この制約は、あくまで 2 つのインデックスの大小関係のみを定義しており、与えられた配列 nums の順番に制限を課すものではありません。つまり、並び替えてもいいのです。ソートしましょう。ソートすれば、Two Pointers で解けます。

func countPairs(nums []int, target int) int {
    slices.Sort(nums)
    ans := 0
    left := 0
    right := len(nums) - 1
    for left < right {
        if nums[left]+nums[right] < target {
            ans += right - left
            left++
        } else {
            right--
        }
    }
    return ans
}

正直なところ、解き方は以下に詳しく、私もこれを見たので、これ以上の分かりやすい説明はできません。

https://leetcode.com/problems/count-pairs-whose-sum-is-less-than-target/solutions/3933451/two-pointers-approach-easy-to-understand-in-9-languages

が、あえて私の言葉で説明します。

とりあえず、昇順にソートします。話はそれからです。昇順にソートすると、一番左と一番右は、もちろんそれぞれ最小値と最大値となります。あとは、個別のケースを考えます。まず、たとえば、最小値＋最大値 < target となった場合、どうでしょう？最小値の方のポインタを右にずらした場合、一つ前と同じかそれより大きい合計になることが明らかです。なので、最大値を指す右側のポインタを一つ左にずらします。すると、最大値と同じかそれより小さい値が指し示されるので、target より合計が小さくなる可能性があります。

左のポインタを left、右のポインタを right としたとき、nums[left] + nums[right] < target となった場合はどうすべきでしょう？この場合、right をいくら左に移動していっても、必ず target より小さくなります。これは、配列が昇順にソートされているからです。なので、right - left 分だけ条件を満たす組があることが分かります。つまり、ans += right - left となります。

これで左側と右側両方のポインタの動きが理解できたので、後はそれをコードに起こすだけです。

この方法は、最初のソートによる O(nlogn) と、要素分だけポインタを動かすので O(n) の時間計算量となりますが、O(nlogn) としてしまって良いと思います。初手は二重ループでしたので O(n^2) でした。十分高速ですね。

2465. Number of Distinct Averages

Wed, 07 May 2025 23:11:14 +0900

はじめに

整数の配列 nums の最大値と最小値を取り出しては平均値を算出し、ユニークな平均値の数を答えよ、というもの。つまり [4,1,4,0,3,5] であれば、分かりやすく昇順に並べると [0, 1, 3, 4, 4, 5] で、まず [0, 5] の平均値 2.5、そして [1, 4] の平均値 2.5、[3, 4] の平均値 3.5 の 3 つがあります。 2.5 は 2 回登場するため、答えには 1 回だけカウントアップします。よって答えは 2 です。

まずは失敗した手をご覧あれ。

失敗

最初に書いたように、昇順にソートした後前と後ろの値から次々に平均値を算出し、それをハッシュマップに格納します。また、ハッシュマップに格納した回数をカウントすることで答えが導けます。つまづいたのは、平均として返される float64 の値をどう map に格納するかです。これで行けるかな？と提出したところ 11/36 pass で、原因不明でした。そこで print 文を埋め込むと期待通り map のキーに格納できていないことが分かり、悩んでいるときに突然頭がすっきりして出てきた答えが次の手です。

https://leetcode.com/problems/number-of-distinct-averages/submissions/1627683780

func distinctAverages(nums []int) int {
    slices.Sort(nums)
    seen := make(map[string]bool, len(nums))
    ans := 0
    for i := 0; i < len(nums) / 2; i++ {
        avg := string((nums[i] + nums[len(nums) - i - 1]) / 2.0)
        if !seen[avg] {
            ans++
            seen[avg] = true
        }
    }
    return ans
}

成功

平均を取るのをやめ、単に 2 つの値の合計値をハッシュマップに格納する方法にしました。目的は一意な平均値の数ですが、一意な和の数と捉えても変わりません。 4 つの値をそれぞれ a, b, c, d とし、(a + b) / 2 = (c + d) / 2 が成り立つとき、両辺に 2 をかけると a + b = c + d となるためです。それだけです。

https://leetcode.com/problems/number-of-distinct-averages/submissions/1627853118

func distinctAverages(nums []int) int {
    slices.Sort(nums)
    seen := make(map[int]bool, len(nums))
    ans := 0
    for i := 0; i < len(nums) / 2; i++ {
        sum := nums[i] + nums[len(nums) - i - 1]
        if !seen[sum] {
            ans++
            seen[sum] = true
        }
    }
    return ans
}

他の回答もキーワードはソート、ハッシュマップ、Two Pointers だったので、これ以上の説明は割愛します。

2395. Find Subarrays With Equal Sum

Sun, 04 May 2025 11:19:45 +0900

はじめに

整数の配列から、2 値の合計が等しい 2 つのサブ配列があるか調べよ、という問題。 nums = [4,2,4] なら、インデックス ([0, 1], [1, 2]) が該当するため、真。ここで、以下の制約の通り、サブ配列とは連続したインデックスであることが保証されており、単に隣り合うインデックス同士を足した結果を走査するだけでよい。

A subarray is a contiguous non-empty sequence of elements within an array.

https://leetcode.com/problems/find-subarrays-with-equal-sum/description/

初手

久しぶりに 5 分程度で解けました。制約の通り、隣り合うインデックスの合計を map に保存しておき、過去に同じ合計が存在すれば true です。もうそれだけです。時間計算量は O(n) で、Beats 100% です。

https://leetcode.com/problems/find-subarrays-with-equal-sum/submissions/1624846018

func findSubarrays(nums []int) bool {
    m := make(map[int]bool, 1000)
    for i := 0; i < len(nums) - 1; i++ {
        sum := nums[i] + nums[i+1]
        if m[sum] {
            return true
        }
        m[sum] = true
    }
    return false
}

Solutions を見ても異なる考え方が見つからないため、この問題はこれだけ。

2399. Check Distances Between Same Letters

Sat, 03 May 2025 11:16:48 +0900

はじめに

ちょっとややこしい問題でした。英小文字からなる文字列と全アルファベットごとの距離を表した配列が与えられ、文字列に登場するアルファベットが距離配列に示される距離を守っているかを調べる問題。たとえば abba と [2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] が与えられたとき、a は距離 2 なので、距離を守っています。 b についても、その距離は 0 なので、距離を守っています。よってこの入力に対して true を返します。なお、英小文字については「必ず 2 つのみ存在する」ことが約束されています。

考え方は、文字列を一つずつループしながら「本当に示された距離に次の英小文字が現れるか」を調べるというものです。 next というのは、距離の配列に与えられた距離に基づき、現在の文字が次に登場するインデックスを示す変数です。確かに next の位置に同じ文字があれば OK、もしなければ、その時点で NG です。

少しはまったのが、単純にループを回すと、2回目に登場する文字についても同じ条件判定をしてしまう点です。つまり、2回目の a について同じ検査をすると、3回目が存在しないことが約束されているため、必ず false を返してしまいます。このため、seen という map を用意し、過去にすでに見た文字であればスキップするようにしています。

この解法で Beats 100% です。エレガントではない気がしますね。

https://leetcode.com/problems/check-distances-between-same-letters/submissions/1624032889

func checkDistances(s string, distance []int) bool {
    seen := make(map[byte]bool, 26)
    for i, c := range []byte(s) {
        if seen[c] {
            continue
        }
        next := i + distance[c - 'a'] + 1
        if next >= len(s) || s[next] != c {
            return false
        }
        seen[c] = true
    }
    return true
}

改善版

初手で考えていた方法が洗練されたのがこの改善版なんですが、“今見ている英小文字は2回目のものだ” という判定をする seen が少しコードを複雑にしており、それを無くしたものです。最初は distance[i] に距離をマイナスにしたものを代入していけばいいと思ったんですが、distance[c - 'a'] = -1 とすることで、2回目はその文字自身を参照し、一致するので OK ですね。もちろん、愚直に distance[c - 'a'] = -d - 2 としても pass します。でも、単に -1 とあった方がシンプルでいいです。個人的に。

https://leetcode.com/problems/check-distances-between-same-letters/submissions/1624042985

func checkDistances(s string, distance []int) bool {
    for i, c := range []byte(s) {
        d := distance[c - 'a']
        next := i + d + 1
        if  next >= len(s) || s[next] != c {
            return false
        }
        distance[c - 'a'] = -1
    }
    return true
}

2367. Number of Arithmetic Triplets(en)

Fri, 02 May 2025 23:14:13 +0900

Introduction

You’re given a strictly increasing array of integers nums, and you need to count how many triplets satisfy the following conditions. Looking at the constraints, 3 <= nums.length <= 200, I immediately thought, “Alright, brute force should work just fine.” And, sure enough, the hint basically winks at you and says, “Brute force, huh? Maybe give it a shot?” Yeah, I got this.

1
2

i < j < k,
nums[j] - nums[i] == diff and nums[k] - nums[j] == diff

So, with a slight blush of overconfidence, I banged out the code below.

LeetCode Submission

func arithmeticTriplets(nums []int, diff int) int {
    ans := 0
    for i := 0; i < len(nums); i++ {
        for j := i + 1; j < len(nums); j++ {
            for k := j + 1; k < len(nums); k++ {
                if nums[j] - nums[i] == diff && nums[k] - nums[j] == diff {
                    ans++
                }
            }
        }
    }
    return ans
}

No explanation needed—none whatsoever. It’s just a straight-up brute force, checking every possible triplet. Done. Let’s move on.

Round Two

After a bit of thinking, I landed on a better approach. It’s not like I’m jumping for joy—it beats 100% of submissions, but it doesn’t feel elegant. Probably because I didn’t fully validate the algorithm before coding. My first instinct was to aim for O(n), but I settled for O(n²) to get something working.

The idea? Track the previous state while iterating. For example, with the input below, nums[1]: 1 pairs with nums[2]: 4 to satisfy diff. You store that 4 as the previous value, then look for the next index that satisfies diff relative to 4. In this case, it’s nums[4]: 7. Since the array is guaranteed to be strictly increasing, you don’t need to keep searching—any further values will have a larger difference than diff. Boom, double loop does the trick.

`1`	`Input: nums = [0,1,4,6,7,10], diff = 3`

LeetCode Submission

func arithmeticTriplets(nums []int, diff int) int {
    ans := 0
    for i := 0; i < len(nums); i++ {
        prev := nums[i]
        for j := i + 1; j < len(nums); j++ {
            if nums[j] - prev == diff {
                if prev != nums[i] {
                    ans++
                    break
                }
                prev = nums[j]
            }
        }
    }
    return ans
}

The Elegant Solution

Hold up—whoa. Check out this solution. The code speaks for itself. It’s clean, simple, and probably why this problem is tagged as “Easy.” Sure, brute force works, but this? This is poetry. No need to even think about time complexity in the brute force case, but this approach makes you appreciate the problem’s simplicity.

It’s a single loop. The logic? Dead simple. If you find a value that’s at least diff * 2, check if n - diff and n - diff * 2 exist earlier in the array. If they do, increment the count. That’s it.

LeetCode Submission

func arithmeticTriplets(nums []int, diff int) int {
    cnt, ans := make([]int, 201), 0
    for _, n := range nums {
        if n >= 2*diff {
            ans += cnt[n-diff] & cnt[n-diff*2]
        }
        cnt[n] = 1
    }
    return ans
}

In production code, I’d avoid declaring and initializing multiple variables in one line like this—it’s a bit too clever for maintainability. Competitive programming loves this kind of concise flair, but in the real world, you write for the poor soul who has to maintain your code. So, you might see something like this instead:

var (
    cnt []int
    ans int
)

cnt = make([]int, 201)
ans = 0

Looks verbose, right? But separating “here’s the variable” from “here’s its value” makes it easier to grok for whoever’s debugging at 2 a.m. In this case, though, it’s not the best example—let’s just say I’ll save that rant for another post.

2367. Number of Arithmetic Triplets

Fri, 02 May 2025 22:18:47 +0900

はじめに

必ず増加していく整数の配列 nums から以下の条件を満たす回数を数えよ、という問題。制限を見ると 3 <= nums.length <= 200 とあったので、これは総当たりでいけるな、とまず思いました。で、Hint には案の定「これは総当たりでいけるかな〜？？」と書いてありました。ええ、いけますとも。

1
2

i < j < k,
nums[j] - nums[i] == diff and nums[k] - nums[j] == diff

というわけで顔を赤くしながら書いたコードが以下。

https://leetcode.com/problems/number-of-arithmetic-triplets/submissions/1623622064

func arithmeticTriplets(nums []int, diff int) int {
    ans := 0
	for i := 0; i < len(nums); i++ {
		for j := i + 1; j < len(nums); j++ {
			for k := j + 1; k < len(nums); k++ {
                if nums[j] - nums[i] == diff && nums[k] - nums[j] == diff {
                    ans++
                }
			}
		}
	}
    return ans
}

説明する必要なんて1ミリもございません。条件どおりに総当りしただけです。とりあえず次いきましょう。

2回目

ちょっと考えてみたら答えにたどり着きました。答えと言っても Beats 100% になったもののそんなしっくり来てません。解く前にアルゴリズムが正しいことを確認していないから・・・。初めは O(n) で実装できないか考えたんですが、まずは O(n^2) でも良いからできないか、という風に考えました。その結果、一つ前の状態を管理しながら探索すれば解けることに気づきました。つまり、以下の説明にある入力のとき、nums[1]: 1 に diff が一致するのは nums[2]: 4 です。このとき、前回は 4 であったと記録します。そして、次は 4 に対して diff が一致するインデックスを探します。今回は nums[4]: 7 ですね。この配列は必ず増加することが約束されているので、これ以上探しても diff より大きな差になる値しか見つかりません。よって二重ループで解けました。

`1`	`Input: nums = [0,1,4,6,7,10], diff = 3`

https://leetcode.com/problems/number-of-arithmetic-triplets/submissions/1623629925

func arithmeticTriplets(nums []int, diff int) int {
    ans := 0
	for i := 0; i < len(nums); i++ {
        prev := nums[i]
		for j := i + 1; j < len(nums); j++ {
            if nums[j] - prev == diff {
                if  prev != nums[i] {
                    ans++
                    break
                }
                prev = nums[j]
            }
		}
	}
    return ans
}

美しい手

いやいやいや・・・。この Solution を見てください。コードがすべてを語っています。かつ、非常にシンプルな考え方です。だからこそ Easy に分類されているのかもしれませんが。いや、単に総当たりで解けるから Easy ですね。計算量という概念が登場しません。

単一ループです。考え方は簡単です。diff * 2 の値が見つかったら、それ以前に n - diff と n - diff * 2 の値がないか確認するだけです。あればカウントアップします。 https://leetcode.com/problems/number-of-arithmetic-triplets/submissions/1623650212

func arithmeticTriplets(nums []int, diff int) int {
    cnt, ans := make([]int, 201), 0
    for _, n := range nums {
        if (n >= 2 * diff) {
            ans += cnt[n - diff] & cnt[n - diff * 2]
        }
        cnt[n] = 1
    }
    return ans
}

実際の商用コードではあまり複数の変数の宣言と代入を同時に行うことはありませんが、競技プログラミングならではのシンプルさですね。商用コードはメンテナンスされる前提なので、メンテナンスする人にとって分かりやすいコードにしておくことが望ましいです。その意味では、たとえば以下のように書いたりします

var (
    cnt []int
    ans int
)

cnt = make([]int, 201)
ans = 0

無駄に思えるでしょう。しかし「この変数を使います」と「この変数に値を代入します」が分かれていることにより、少し分かりやすくなっています。まあ、この例ではしっくり来ませんね。この説明は他に譲ります。

Play with Go closure

Fri, 02 May 2025 09:53:24 +0900

はじめに

1. クロージャとは何か

何かを知るには、まず公式の Playground で遊んでみることが大事です。そして、公式 playground に書いてある説明がすべてです。

Go functions may be closures. A closure is a function value that references variables from outside its body. The function may access and assign to the referenced variables; in this sense the function is “bound” to the variables.

訳すとこうです。

Go 関数はクロージャにもなります。クロージャはその（関数定義）本体の外にある変数を参照する関数値です。その関数は、参照する変数にアクセスしたり値を代入したりします。そういう意味で、関数は変数にバインドされています。

つまり、関数として定義されたコードブロックの外にある変数を参照する関数値です。ここで「関数値」がしっくり来ないかもしれませんが、単に関数ポインタだと思えばいいです。以下のコードを見てください。

package main

import "fmt"

func main() {
	f := func() {
		fmt.Println("Hello, World!")
	}
	fmt.Println(f)
	fmt.Println(f())
}

このコードにおいて、f に代入された値が関数値です。実態は、無名関数 func を実行するアドレスです。実行結果は以下の通りです。表示されるメモリアドレスは実行ごとに変わりうるものです。

1
2
3

% go run main.go
0x102548750
Hello, World!

そして、クロージャとはその関数本体の外部の変数を参照する関数です。以下のコードにおいて定義された無名関数はクロージャです。counter 変数の値のことです。

package main

import "fmt"

func main() {
	var count int
	counter := func() int {
		count++
		return count
	}
	fmt.Println(counter)
	fmt.Println(counter())
}

1
2
3

% go run closure.go
0x100c1c7a0
1

2. Go でのクロージャの基本的な動作

無名関数という一つのハードルを避け、main ともう一つの関数を用いて説明します。

以下、繰り返しになりますが、main 関数内の counter 変数にセットされた値がクロージャです。

package main

import "fmt"

func counter() func() int {
	var count int
	return func() int {
		count++
		return count
	}
}
func main() {
	counter := counter()
	fmt.Println(counter()) // 1
	fmt.Println(counter()) // 2
	fmt.Println(counter()) // 3
}

このクロージャは func() int 型の値です。関数として実行すると、1, 2, 3 と値が増加しているのが分かります。これは、変数のキャプチャという仕組みを利用しています。Go では、 counter() という関数が定義された時点で count 変数のスコープは counter() 関数内と決まります。また、内部で返される無名関数は、自身の無名関数外部にある count という変数をキャプチャします。この仕組みによってクロージャが意味を持ちます。つまり、キャプチャしないのであれば、この無名関数は宣言されていない変数を参照することになり、コンパイルエラーとなります。undefined: count というよく見るエラーになります。

3. クロージャの実際の使用例

身近な例として、net/http パッケージを用いた例を紹介します。正直なところ、この例を考えるのに 1h 以上使いました。経験が豊富でなく、実用に耐えうる例を示せる自信がなかったためです。余談です。

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

// 無名関数はレキシカルスコープに定められたスコープにある logger 変数をキャプチャする
func createHandler(logger *log.Logger) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		logger.Printf("Request from %s to %s", r.RemoteAddr, r.URL.Path) // loggerをキャプチャ
		fmt.Fprintf(w, "Hello from %s!", r.URL.Path)
	}
}

func main() {
	// 2つのロガーを定義
	userLogger := log.New(os.Stdout, "user: ", log.LstdFlags)
	adminLogger := log.New(os.Stdout, "admin: ", log.LstdFlags)

    // エンドポイントごとに異なるロガーを設定
	http.HandleFunc("/user", createHandler(userLogger))
	http.HandleFunc("/admin", createHandler(adminLogger))

	// サーバ起動
	log.Fatal(http.ListenAndServe(":8080", nil))
}

上記の例でクロージャは createHandler の戻り値である無名関数です。この無名関数は、createHandler の引数である logger をキャプチャし、その無名関数内で参照しています。よって、http.HandlerFunc によってエンドポイントに登録されたハンドラは、サーバ起動時に初期化され、以降再利用されます。

なんとなく、この構成だとリクエストが来るたびクロージャが logger をキャプチャするためメモリ効率が悪そうに見えましたが、ハンドラはあくまでサーバ起動時に登録されるため、以降は再利用されるためメモリ効率は悪くありません。加えて、logger はポインタのため、アドレスを指し示すためのサイズである 8 バイトで十分です。エンドポイントが 10 個あろうと、せいぜい 8 * 10 = 80 バイトしか使わず、現代の多くの Web サービスにおいて無視できるサイズと言えると思います。

4. クロージャの注意点と落とし穴

loop 変数のキャプチャ

ループ時に外部変数をキャプチャすると、想定していない値になることがあります。

下記のプログラムは、クロージャであるゴルーチンがループカウンタ i をキャプチャし出力するものです。 sync パッケージの sync.WaitGroup と wg.Wait() により、すべてのゴルーチンが終了するまで待ってから終わるプログラムです。ぱっと見、ループカウンタの値を出力するだけの、何か意図を隠してそうな怪しいコードに見えますよね。

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			fmt.Printf("i=%d, addr=%p\n", i, &i)
		}()
	}
	wg.Wait()
}

結果は以下の通りです。

% go version
go version go1.21.13 darwin/arm64
% go run ./loop_closure.go
i=3, addr=0x1400009c018
i=3, addr=0x1400009c018
i=3, addr=0x1400009c018

すべて i=3 と表示されていますね。ゴルーチンは非同期で実行されるので、無名関数のクロージャはループ終了後に変数 i をキャプチャし、すべて 3 になってしまっています。

しかし、この問題は Go 1.22 で解消されています。

% go version
go version go1.22.0 darwin/arm64
% go run ./loop_closure.go
i=0, addr=0x14000112018
i=2, addr=0x14000112038
i=1, addr=0x14000112030

出力される順番は非同期のため不定ですが、確かに 3 ではなくループカウンタの値が出力されています。このため、Go 1.21 までは起こるが、Go 1.22 以降は起こらない問題、と理解して良いと思います。

キャプチャした変数の共有

これは簡単な例です。また、あまりこういう実装をしてしまう人はいないと信じますが、2つの無名関数が同じ変数 count をキャプチャしているせいで、count 変数の値が分かりにくくなります。

package main

import (
    "fmt"
)

func main() {
    count := 0
    inc := func() { count++ }
    dec := func() { count-- }
    inc()
    dec()
    fmt.Println(count) // 0
}

パフォーマンスへの影響

通常、関数は、関数内で使用する変数をスタックに保存します。しかし、その関数外でも参照されうる変数はヒープに保存されます。ヒープはスタックに比べ低速なため、クロージャの多用はパフォーマンスの低下を招きます。ただ、スタックとヒープでどの程度パフォーマンスに差が出るかというと、次のベンチマークから明らかにします。

package main

import "testing"

func ToHeap() *int {
	v := 1
	return &v
}

func ToStack() int {
	v := 1
	return v
}

func Closure() func() int {
	v := 1
	return func() int {
		return v
	}
}

func BenchmarkToHeap(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = ToHeap()
	}
}

func BenchmarkToStack(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = ToStack()
	}
}

func BenchmarkClosure(b *testing.B) {
	for i := 0; i < b.N; i++ {
		fn := Closure()
		_ = fn()
	}
}

ToHeap() は、変数のアドレスを返します。ToStack() は、変数の値そのものを返します。 ToHeap() の戻り値はアドレスのため、関数内で定義した v に代入された 1 があるアドレスは利用される可能性があります。利用される可能性のあるデータはヒープに保存します。

一方で、ToStack() は関数の終了時に変数 v は不要になります。このため、v はスタックに保存され、関数の終了時に破棄され、それ以上 v を管理する必要はありません。

なお、このようにスタックに保存するかヒープに保存するかを調べることをエスケープ解析と言います。これについては別途紹介したいと思っています。

長くなりましたが結果です。

% go test -bench=. -gcflags="-m -l"
# main/stack_and_heap [main/stack_and_heap.test]
./main_test.go:6:2: moved to heap: v
./main_test.go:17:9: func literal escapes to heap
...
BenchmarkToHeap-10      210585192                5.500 ns/op
BenchmarkToStack-10     1000000000               0.6821 ns/op
BenchmarkClosure-10     150774753                8.021 ns/op
...

Heap は Stack に比べ約 8.3 倍高速です。参考にしたブログでは約10倍の差があったため、ランタイムによってスタックとヒープの性能差が変わるのかもしれません。

https://note.com/kyfk/n/n56a2e2ef77f6

よって、せいぜいナノ秒単位の差ではありますが、クロージャもヒープに保存するため、パフォーマンスを意識する必要があります。

なお、クロージャは、関数リテラルそのものがヒープに保存されることが実行結果の以下の文から分かります。

./main_test.go:17:9: func literal escapes to heap

5. まとめ

無名関数じゃないよ、クロージャだよ。

2351.First Letter to Appear Twice

Thu, 01 May 2025 00:07:35 +0900

はじめに

Easy の中でも簡単な問題です。Go は byte や rune が絡むので少し面倒ですが。文字列 s の中から、最初に 2 回登場したアルファベットを答えなさい、というだけの問題です。 abcabc なら a、abedgdbca なら b です。それだけです。

https://leetcode.com/problems/first-letter-to-appear-twice/submissions/1622046931

func repeatedCharacter(s string) byte {
    l := make(map[byte]bool, len(s))
    ans := byte(0)
    for _, c := range []byte(s) {
        if _, b := l[c]; b {
            ans = c
            break
        }
        l[c] = true
    }
    return ans
}

もう少しシンプルにならないかなぁと Grok 3 に手伝ってもらって簡素化したのが以下です。

func repeatedCharacter(s string) byte {
    seen := make(map[byte]bool)
    for _, c := range []byte(s) {
        if seen[c] {
            return c
        }
        seen[c] = true
    }
    return 0
}

まあ、AtCoder の探索問題でよく用いられる seen という変数を使ったのと、return を導入したのみです。

面白い解法

bitmask を使った解法がありました。アルファベットは26種類なので、32bit あればビットをフラグと見立てて過去に現れた文字かどうかを判定できます。たとえば、abfa という文字をループしたとき、seen 変数のビットマスクは次のように変化します。

a: 0000 0000 0000 0000 0000 0000 0000 0001
b: 0000 0000 0000 0000 0000 0000 0000 0011
f: 0000 0000 0000 0000 0000 0000 0010 0011
a: ここで return

1 << (ch - 'a') の部分で、ビットマスクのどの桁に 1 をセットするかを決め、seen |= bit の部分で実際に 1 をセットしています。論理和ですね。ちなみにこの解法は、DFSやBFSなどの探索系の問題でよく使われるテクニックですので、頭の片隅に置いておきましょう。

https://leetcode.com/problems/first-letter-to-appear-twice/solutions/2382459/go-bitmask

func repeatedCharacter(s string) byte {
	// Use a bitmask to keep track of whether a character has
	// been seen before.
	var seen int
	for _, ch := range s {
		bit := (1 << (ch - 'a'))
		if seen&bit > 0 {
			return byte(ch)
		}
		seen |= bit
	}
	return 0
}

翌日 bitmask を使って自力で解いたものです。 bm & n == n は、bm & n > 0 でも OK です。この論理積の結果は 0 or 1 以上だからです。また、最後の return は、問題文より、文字列中に必ず一度は同じアルファベットが2回登場することが書かれていますので、何を返してもいいです。ただし、return 文がない場合はエラーとなりますので、return 文は必要です。

func repeatedCharacter(s string) byte {
    // solution: bitmask
    bm := 0
    for _, b := range []byte(s) {
        n := 1 << (b - 'a')
        if bm & n == n {
            return b
        }
        bm |= n
    }
    return s[0]
}

2200. Find All K-Distant Indices in an Array

Wed, 23 Apr 2025 23:12:19 +0900

はじめに

少し文章読解の難易度が他の Easy より高い問題です。とはいえ AtCoder に慣れた諸氏であれば読解の難しさはないかもしれません。何せ、単に与えられた条件のとおりのコードを書けば PASS するので。
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/description/

|i - j| <= k and nums[j] == key という条件を満たすインデックス i を整数の配列 nums から列挙せよ、という問題です。つまり、配列すべてのインデックスがその条件を満たすなら、すべてのインデックスを含む配列 [0, 1, 2,..., len(nums)-1] を返せば OK です。

初手

とりあえず素直な実装です。ナイーブな実装とも言いますが、ナイーブと書くと何かを許されるような錯覚を覚えるので、素直な実装と呼びます。
https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/submissions/1615723359

func findKDistantIndices(nums []int, key int, k int) []int {
    ans := []int{}
    for i := 0; i < len(nums); i++ {
        for j := 0; j < len(nums); j++ {
            if check(i, j, nums[j], key, k) {
                // fmt.Println("true")
                ans = append(ans, i)
                break
            }
        }
    }
    return ans
}

func check(i, j, n, key, k int) bool {
    // fmt.Println(i, j, n, key)
    return abs(i, j) <= k && n == key 
}

func abs(i, j int) int {
    if i - j < 0 {
        return -(i - j)
    }
    return i - j
}

テストケースの nums の要素数が増えたとき、デバッグとして書いているプリント文によってエラーが出たため、コメントアウトした状態で提出しています。単に、二重ループの中で条件に合致するインデックスがあればスライスに追加する、それだけのコードです。注意点として、i == j の場合も OK なのと、append 後は break することです。 i == j が OK というのがしっくり来ない人がいるかもしれませんが、問題文に書かれている条件に i ≠ j はありませんので、当然 OK なのです。

ただ、当然のごとく O(n^2) の計算量となっており、改善の余地があります。生成 AI は「頻度マップ」と呼んでいましたが頻度カウンターを使った実装により改善ができるのかもしれません。後日書きます。

二回目

実は二回目を出す前に Solutions を見て理想の形での提出はしています。しかし、一夜明けて自分でも書けないと意味がないことから、何も見ずに書いたコードがこちらです。

https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/submissions/1620861465

func findKDistantIndices(nums []int, key int, k int) []int {
    ans := make(map[int]bool)
    for i, v := range nums {
        if v == key {
            start := max(0, i - k)
            end := min(len(nums) - 1, i + k)
            for j := start; j <= end; j++ {
                ans[j] = true
            }
        }
    }
    ans2 := []int{}
    for k, _ := range ans {
        ans2 = append(ans2, k)
    }
    sort.Ints(ans2)
    return ans2
    
}

考え方の基礎はこの Solution を参考にしています。

nums[j] == key という条件から、この問題は key に一致するインデックスを起点とした探索をすればよいと考えることができます。1つ目の条件は |i - j| <= k であって、これは j <= i - k と j <= i + k の二通りが考えられます（絶対値記号の外し方より）i - k と i + k は、i はインデックスを指すので、そのインデックスの左右 k 分の距離と理解できます。よって、やるべきことは key が見つかったとき、その左右 k 分の幅を記録していく、という作業です。

上記のコードで言うと、start, end が探索の始点と終点です。重複を考慮すればよかったんですが、上記はとりあえず map に詰め込んで最後に重複なく取り出す、という流れです。start, end の間の区間に見つかったインデックスを map に入れておくことで、最後にキーをすべて取り出せば答えになります。計算量は、LeetCode AI によれば O(Nk+NLogN) でした。遅い。大きく負けている。

最終手

結局最後まで Solutions にお世話になってしまいました。重複をなくす処理の max が思いつかず。道筋立てて考えると当然なんですが、自分では解いておらず、Solutions を見て回答したからこうなってますね。つまり理解できていない。

一つ前のコードとの差異は、答えの変数を map から整数のスライスに変えたことと重複をなくす処理を加えたことです。これで Beats 100% です。不甲斐ない気持ちでいっぱい。

https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/submissions/1621162468

func findKDistantIndices(nums []int, key int, k int) []int {
	ans := []int{}
	for i, v := range nums {
		if v == key {
			start := max(0, i-k)
			// 重複をなくす
			if len(ans) > 0 {
				start = max(ans[len(ans)-1]+1, start)
			}
			end := min(len(nums)-1, i+k)
			for j := start; j <= end; j++ {
				ans = append(ans, j)
			}
		}
	}
	return ans

}

extra 手

他の Solution を見てきれいだなと思い真似しました。 TC（Time Complexity）は O(n) です。from, to を1行に書いたのと、現在どこかを記録する prev 変数の導入によりコードがシンプルになっています。やはり Simplicity is the ultimate sophistication ですね。N.Y. の MoMA に着ていった T シャツにプリントされた文字です。学芸員さんに「良いメッセージだね」って言われたのが今でも記憶に残っています。はい。

https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/submissions/1622022845

func findKDistantIndices(nums []int, key int, k int) []int {
	ans := []int{}
	prev := -1
	for i, v := range nums {
		if v == key {
			from, to := max(i - k, 0, prev + 1), min(i + k, len(nums) - 1)
            for ; from <= to; from++ {
                ans = append(ans, from)
                prev = from
            }
		}
	}
    return ans
}

2006. Count Number of Pairs With Absolute Difference K

Mon, 21 Apr 2025 23:59:09 +0900

はじめに

問題の読解は容易です。整数の配列 nums が与えられるので、次の 2 つの条件を満たすペアがいくつあるか数えろ、というものです。

i < j
|nums[i] - nums[j]| == k

ここで |x| は x の絶対値を表します。

よく見る問題です。計算量を考えなければ、二重ループで当然のごとく解ける問題です。というわけで初手いってみましょう。

初手

二重ループです。ご容赦ください。
https://leetcode.com/problems/count-number-of-pairs-with-absolute-difference-k/submissions/1613654919

解説するまでもありません。問題文の条件に従って二重ループによってカウントし、その数を返すだけです。 Go は math.Abs が用意されていますが、引数が float64 なので取り扱いが面倒です。絶対値を求めるのは簡単なので、毎回 abs 関数を実装するのが良いと思います。どこかからコードスニペットとして拾ってくるももちろんいいと思います。

func countKDifference(nums []int, k int) int {
    ans := 0
    for i := 0; i < len(nums); i++ {
        for j := i + 1; j < len(nums); j++ {
            if abs(nums[i], nums[j])  == k {
                ans += 1
            }
        }
    }
    return ans
}

func abs(m, n int) int {
    v := m - n
    if v < 0 {
        return -v
    }
    return v
}

計算量に何も気を使っていないものの、このコードは Beats 48.65% 🤔です。

最終手

何も誇れたもんじゃないですが、Solutions を見てまま書いた提出です。すごく簡潔ですね。
https://leetcode.com/problems/count-number-of-pairs-with-absolute-difference-k/submissions/1614667796

func countKDifference(nums []int, k int) int {
    m := make(map[int]int)
    ans := 0
    for _, v := range nums {
        m[v]++
        ans += m[v - k] + m[v + k]
    }
    return ans
}

まずは、絶対値を含む式の変形を発想するところが入口です。つまり、| nums[i] - nums[j] | == k という式を解きます。数1で登場します。細かくは書きませんが、 nums[i] - nums[j] が正の場合と負の場合が考えられます。負のときは - (nums[i] - nums[j]) == k と表現でき、正のときは単に nums[i] - nums[j] == k と表現できます。これらは nums[i] + k == nums[j], nums[i] - k == nums[j] と等しいです。これを利用して今回の問題を解いています。

ループの最初の m[v]++ は、その数字が登場する回数をカウントしています。初期値は 0 なので、一回目は必ず 1 になります。そして、次が肝であり、先ほどの式の活きるところです。 m[v - k] は nums[i] - k であり、m[v + k] は nums[i] - k です。絶対値の計算では正と負の両方の場合があるので、m[v - k] は正の場合、m[v + k] は正の場合のその数のカウントです。たとえば、nums = [1, 2, 2, 1] の1つ目の 2 を取り扱うとき、m[v - k] は m[2 - 1] -> m[1] == 1, m[v + k] は m[2 + 1] -> m[3] == 0、よって 1 です。これを実際に繰り返していくとそのロジックが理解できると思います。僕はそうして理解しました。というよりそうしないと理解できません。

以上です！

653. Two Sum IV - Input is a BST

Sat, 19 Apr 2025 00:41:35 +0900

はじめに

653.Two Sum IV - Input is a BST です。結構苦戦しました。1 時間はかかった気がする。まずは二分木、加えて二分探索木というものを扱うすべをあまり知らなかったところが大きい。もちろん、学生時代に木構造は学んでいたものの…思い出せない…

問題を理解するのは簡単です。二分探索木とある値 k が与えられるので、二分探索木のある 2 つのノードの値の合計がある値 k になるかを調べ、なるなら true、ならないなら false を返す、という問題です。この問題は 1.Two Sum の類似問題として引用されていました。なので、解き方は Two Sum を知っていれば少し参考になる部分があります。それでは辛い初手をご覧ください。

初手（深さ優先探索：DFS）

ひとまず、あまりにも詰まったので途中で Grok 3 に相談してます。そのとき、

root ノードの値を map に入れ忘れていること
グローバル変数を使うと、テストケース全体で使い回され、予期せぬ挙動をすることの 2 点を指摘され、直しました。

そしてこの 2 点を改善し AC となったのが以下のコードです。
https://leetcode.com/problems/two-sum-iv-input-is-a-bst/submissions/1610648203

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func findTarget(root *TreeNode, k int) bool {
    hm := make(map[int]int)
    index := 0
    hm[root.Val] = index
    index = search(root.Left, hm, index)
    _ = search(root.Right, hm, index)
    for val, i := range hm {
        c := k - val
        if j, ok := hm[c]; ok && i != j {
            return true
        }
    }
    return false
}

func search(n *TreeNode, hm map[int]int, index int) int {
    if n == nil {
        return index
    }
    index += 1
    hm[n.Val] = index
    if n.Left != nil {
        index = search(n.Left, hm, index)
    }
    if n.Right != nil {
        index = search(n.Right, hm, index)
    }
    return index
}

僕の大の苦手な再帰関数です。どうにか自力で書きました。やっていることは簡単です。単に与えられた根のノードの左のノードと右のノードを search という再帰関数に渡し、その再帰関数は map に値を入れつつ、インデックスを増加させていきます。 1.Two Sum でやった通り、すべての値とその値の添字さえあれば単一のループで解を導けます。ノードのすべての値とその添字を持つ map である hm をループし、Two Sum よろしく k ｰ value を計算し、その値が map にあるか確認します。このとき、同じ値を利用しないよう注意しつつ、値があれば true、なければ false を返せばいいだけです。計算量は O(n) です。

解けたとはいえ、すごくゴリ押しした感が否めません。計算量も悪くはないはずですが、スマートさを微塵も感じません。Solutions を見て改善します。

再帰しない DFS

AtCoder をしていたときに両方書いていた記憶はありますが、DFS は必ずしも再帰関数を用いなくとも解ける・・・はずです。なので、単一の関数内のループで実装してみました。
https://leetcode.com/problems/two-sum-iv-input-is-a-bst/submissions/1611115653

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func findTarget(root *TreeNode, k int) bool {
    stack := []*TreeNode{root}
    hm := make(map[int]int)
    hm[root.Val] = 0
    index := 1
    for len(stack) > 0 {
        node := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        hm[node.Val] = index
        index += 1
        if node.Left != nil {
            stack = append(stack, node.Left)
        }
        if node.Right != nil {
            stack = append(stack, node.Right)
        }
    }
    for val, i := range hm {
        c := k - val
        if j, ok := hm[c]; ok && i != j {
            return true
        }
    }
    return false
}

スタックが肝です。DFS には変わりありません。BFS（深さ優先探索）にするなら、キューを使います。ただ、上記のコードで少し気持ち悪いのは、ルートノードの右側から探索が始まる点です。スタックは LIFO なので、次のループで取り出されるノードは、最後に積んだノードです。上記のコードだと、以下のことです。

1
2
3

        if node.Right != nil {
            stack = append(stack, node.Right)
        }

なので、例1だと、⑥のノードから探索が始まります。

ところで Solution をぱっと見たところ、インデックスの管理なんてしていませんでした。つまり、Two Sum に引きずられて index が重複していないかを見る必要なんてないようです。次はその解法を試します。

最終手

もう solutions 見ましたよね。DFS で解いています。以前よりシンプルなコードになったのがおわかりでしょうか。 1.Two Sum に引きずられてインデックスの重複を避ける考え方を省きました。単に、探索中に出てくる数字を記憶していき、k - n が記憶した数字の中にあれば true を返す、というものです。再帰代表みたいな書き方ですね。知らんけど。
https://leetcode.com/problems/two-sum-iv-input-is-a-bst/submissions/1613601062

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func findTarget(root *TreeNode, k int) bool {
    return dfs(root, k, map[int]bool{})
}

func dfs(node *TreeNode, k int, m map[int]bool) bool {
    if node == nil {
        return false
    }
    if m[k - node.Val] {
        return true
    }
    m[node.Val] = true
    return dfs(node.Left, k, m) || dfs(node.Right, k, m)
}

計算量は、再帰によるノードの探索とハッシュマップの探索がノード数分かかりますが、単に O(n) で良いと思います。 LeetCode の AI もそう言っています。

なお、この解法は Beats 100.00% 👏 です。

im-select を使って VSCode Vim の半角カナ入力を自動で脱する

Thu, 10 Apr 2025 23:10:18 +0900

最初に

VSCode Vim 使ってますよね？使っていたら、インサートモードからノーマルモードに切り替えた際に、日本語入力から英数入力になってほしいですよね？僕の場合、Cmd + j をノーマルモードに戻るキーバインドに設定しています。Esc でも戻れます。

ここで登場するのが、im-select です。

やること

Install im-select

HomeBrew で im-select をインストールします。

1
2

brew tap daipeihust/tap
brew install im-select

brew tap は、公式以外の formula を取得するコマンドです。 HomeBrew 経由でインストールした場合、バイナリの保存先は /opt/homebrew/bin/im-select になります。後で使います。

Edit VSCode settings.json

VSCode の settings.json をいじります。

    "vim.autoSwitchInputMethod.defaultIM": "com.apple.keylayout.ABC",
    "vim.autoSwitchInputMethod.obtainIMCmd": "/usr/bin/true",
    "vim.autoSwitchInputMethod.switchIMCmd": "/opt/homebrew/bin/im-select {im}",
    "vim.autoSwitchInputMethod.enable": true,

以上です。ことえりや Google IME、SKK などをお使いの方は必要に応じて defaultIME を変更ください。あとは、通常どおりインサートモードからノーマルモードに戻れば、IME（Mac では単に IM:Input Method と呼ぶ？）がデフォルトに戻ります。

肝は、

デフォルトが ABC という IM
IM の取得は常に true を返すだけ
- 本来はインサートモード移行時にノーマルモードのときの IM に切り替えるために使う

です。

ともあれ、ノーマルモードへの移行時は defaultIM に戻る、とだけ覚えておけば十分そうです。

1. Two_Sum

Thu, 10 Apr 2025 22:42:16 +0900

問題

数字の配列と一つの数字が与えられるため、足すと与えられた数字になる 2 つの数字を配列から探し、そのインデックスを答えよ、という問題。なお解は必ず一つしかない。 https://leetcode.com/problems/two-sum/description/

初手

わざわざ時間計算量 O(n^2) にならないようにできるかな？って書いてあるけど二重ループによる総当たりしか浮かばずこれで通した。説明するべくもないけど、単に i, j を使って配列の先頭から 2 つの数字を足していき、target と等しくなれば終了しています。総当たりです。最悪計算量は O(n^2) です。

func twoSum(nums []int, target int) []int {
    for i := 0; i < len(nums); i++ {
        for j := i + 1; j < len(nums); j++ {
            if nums[i] + nums[j] == target {
                return []int{i, j}
            }
        }
    }
    return []int{}
}

最終手

答えを見て、1 日空けてから解いたら自力では解けませんでした。明日もやらねば。考え方は、1 ループ目で nums の値をキーに、nums のインデックスを値に持つ map を作ります。 2 ループ目で、target - nums[i] を計算しておき、その値が 1 ループ目で用意した map のキーにあれば、そのときのインデックスが答えになります。ただし、i == j だと同じ値を 2 度利用しているだけなので、 i != j とする必要があります。

func twoSum(nums []int, target int) []int {
    hm := make(map[int]int, len(nums))
    for i, v := range nums {
        hm[v] = i
    }
    for i, v := range nums {
        c := target - v
        if j, ok := hm[c]; ok && i != j {
            return []int{i, hm[c]}
        }
    }
    return []int{}
}

これは最悪でも O(n*2) ですね。nums を 2 回ループする以上の処理は必要ありません。実際は Go の map はハッシュテーブルで実装されており、その探索に O(1)を要するため、もう少し計算量がかかりますが無視しましょう。

Hugo の PaperMod テーマの設定ファイルを toml にする

Thu, 27 Feb 2025 17:24:34 +0900

はじめに

PaperMod は Hugo の人気テーマの一つです。
しかし、example サイトの設定ファイルが yaml で公開されており、toml 化する必要があります。
この記事では、yaml をどうやって toml にしたか記します。
なお、非常に簡単です。

yaml を toml にする

上記の example サイトの config.yml の内容をコピーします。

YAML-TO-TOML に貼り付け、toml 化します。以上です。

toml

toml は yaml に次ぐ設定ファイルフォーマットです。人が理解しやすいように作られています。その構成を見れば一目瞭然ですが、[ ] で囲われたところにカテゴリ、その下にそのカテゴリの設定を記述します。実際は、下記の例だと params.ShowShareButtons や params.profileMode.enabled のように、階層構造を成していると見ると理解しやすいと思います。YAML 脳として。 TOML パーサが作れそうな気になりますね。字句解析や構文解析などは忘却の彼方ですが。

[params]
ShowShareButtons = false
ShowCodeCopyButtons = true

[params.profileMode]
enabled = false
title = "PaperMod"
imageUrl = "#"
imageTitle = "my image"

終わり

hugo v0.110.0 からデフォルトの設定ファイル名が config.toml になっています。 toml にも慣れ親しんでおきましょう。ところで Hugo はまだメジャーバージョンが 0 なんですね。

GitHub Issue を作成し、ブランチを作るところまで CLI で完結させる

Wed, 26 Feb 2025 23:16:07 +0900

つまづくところなどありません。
GitHub CLI を使い、Issue を作り、作成した Issue からブランチを作成する話です。
早速作ります。

Issue を作る

$ gh issue create -t "GitHub Issue から branch を作成するところまで CLI で 行う"

Creating issue in otokichi3/otokichi-tech

? Body <Received>
? What's next? Submit
https://github.com/otokichi3/otokichi-tech/issues/3
$ gh issue develop 3 -b main -c
github.com/otokichi3/otokichi-tech/tree/3-github-issue-から-branch-を作成するところまで-cli-で行う
From https://github.com/otokichi3/otokichi-tech
 * [new branch]      3-github-issue-から-branch-を作成するところまで-cli-で行う -> origin/3-github-issue-から-branch-を作成するところまで-cli-で行う

１つ目のコマンドは、単に -t オプションでタイトルを指定して Issue を作成しているだけです。
２つ目のコマンドが面白いですね。develop ですって。
issue は問題なので fix する方がしっくり来ますが、ともあれ develop の後に Issue 番号もしくは URL、そしてベースブランチを -b オプションで指定します。
最後の -c オプションは checkout のオプションです。そのブランチをチェックアウトします。

develop コマンドは物珍しかったので help を貼っておきます。

$ gh issue develop --help
Manage linked branches for an issue.

When using the `--base` flag, the new development branch will be created from the specified
remote branch. The new branch will be configured as the base branch for pull requests created using
`gh pr create`.


USAGE
  gh issue develop {<number> | <url>} [flags]

FLAGS
  -b, --base string          Name of the remote branch you want to make your new branch from
      --branch-repo string   Name or URL of the repository where you want to create your new branch
  -c, --checkout             Checkout the branch after creating it
  -l, --list                 List linked branches for the issue
  -n, --name string          Name of the branch to create

INHERITED FLAGS
      --help                     Show help for command
  -R, --repo [HOST/]OWNER/REPO   Select another repository using the [HOST/]OWNER/REPO format

EXAMPLES
  # List branches for issue 123
  $ gh issue develop --list 123
  
  # List branches for issue 123 in repo cli/cli
  $ gh issue develop --list --repo cli/cli 123
  
  # Create a branch for issue 123 based on the my-feature branch
  $ gh issue develop 123 --base my-feature
  
  # Create a branch for issue 123 and checkout it out
  $ gh issue develop 123 --checkout
  
  # Create a branch in repo monalisa/cli for issue 123 in repo cli/cli
  $ gh issue develop 123 --repo cli/cli --branch-repo monalisa/cli

LEARN MORE
  Use `gh <command> <subcommand> --help` for more information about a command.
  Read the manual at https://cli.github.com/manual
  Learn about exit codes using `gh help exit-codes`

感想

何がいいかというと、CLI で完結させられる点です。GUI を持つ SourceTree や VSCode などのアプリケーション上でやっても結構ですが、コマンドを打つのはエンジニアらしくで気持ちがいいですね。それだけです。

余談

当たり前ですが、Pull Request の作成とマージまで CLI で完結します。以下はその記録です。 --fill-verbose オプションをつけると PR のタイトルと本文も書いてくれます。便利。ところで issue タイトルがブランチ名になるので、issue タイトルは英語にしておきましょう。

$ gh pr create --assignee @me --fill-verbose
Warning: 1 uncommitted change

Creating pull request for 4-hugo-papermod-の-config-を-toml-にて行う into main in otokichi3/otokichi-tech

https://github.com/otokichi3/otokichi-tech/pull/5
$ gh pr merge --merge --delete-branch
✓ Merged pull request otokichi3/otokichi-tech#5 (4 hugo papermod の config を toml にて行う)
remote: Enumerating objects: 1, done.
remote: Counting objects: 100% (1/1), done.
remote: Total 1 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
Unpacking objects: 100% (1/1), 967 bytes | 483.00 KiB/s, done.
From https://github.com/otokichi3/otokichi-tech
 * branch            main       -> FETCH_HEAD
   ab62f6b..c02990c  main       -> origin/main
Updating ab62f6b..c02990c
Fast-forward
 content/posts/papermod-with-toml-config.md | 45 +++++++++++++++++++++++++++++++++++++++++++++
 hugo.toml                                  | 46 ++++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 87 insertions(+), 4 deletions(-)
 create mode 100644 content/posts/papermod-with-toml-config.md
✓ Deleted local branch 4-hugo-papermod-の-config-を-toml-にて行う and switched to branch main
✓ Deleted remote branch 4-hugo-papermod-の-config-を-toml-にて行う

ai-commit によるコミットメッセージ作成

Wed, 26 Feb 2025 13:47:08 +0900

はじめに

AI に職を奪われることを危惧している紳士諸君も、AI を使いこなせなければ確かに食べていけなくなるかもしれない。そんな中、git の commit message を手動で入力するのはアホらしくありませんか？だって、要約を得意とする生成 AI があるのに、わざわざ自分で内容を要約した一文、ないしいくつかのメッセージを自分で考えるんですよ？それは AI にやらせましょう。ai-commit にやらせましょう。

ai-commit

2025/02/23時点でググって上位に出るこれです。
https://github.com/insulineru/ai-commit

npm でインストールし、OpenAI の API Key をセットし、あとは使うだけの代物です。

1
2
3

$ npm install -g ai-commit

added 109 packages in 21s

OpenAI API Key の発行は、ログイン状態で下記のリンクを踏んでください。
https://platform.openai.com/account/api-keys

.bash_profile あたりに環境変数をセットください。

早速、今は Hugoの初期生成した hello-world.md を書き換えてこの記事の内容にしていますので、これを ai-commit にやってもらいます。

僕が commit message を書くなら、以下の感じです。

rename hello-world.md to ai-commit.md

change its content from greeting to ai-commit testing

そして結果は以下の通りです。

1
2
3

$ ai-commit 
No changes to commit 🙅
May be you forgot to add the files? Try git add . and then run this script again.

ステージングし忘れてました。気を取り直してもう一度。

$ ai-commit 
file:///home/xxx/.nvm/versions/node/v22.12.0/lib/node_modules/ai-commit/node_modules/chatgpt/build/index.js:307
              const error = new ChatGPTError(msg, { cause: res });
                            ^

ChatGPTError: OpenAI error 429: {
    "error": {
        "message": "You exceeded your current quota, please check your plan and billing details. For more information on this error, read the docs: https://platform.openai.com/docs/guides/error-codes/api-errors.",
        "type": "insufficient_quota",
...

未入金でした。OpenAI の API を使うには、最低でも 5 ドルの入金が必要です。 5 ドルの入金後に気づいたのですが、過去別のアカウントで 5 ドル入金していました。そのアカウントの残高を見ると、すでに 0 でしたが。有効期限が切れたようです。お金の有効期限・・・。

強く気を取り直して、以下が ai-commit によるコミットメッセージです。

$ ai-commit 
Proposed Commit:
------------------------------
♻️ refactor: rename hello-world.md to ai-commit.md and change its content to focus on AI commit messages with ai-commit.
------------------------------
? Do you want to continue? Yes
Committing Message... 🚀 
Commit Successful! 🎉

よくないですね。実は、この時点ではファイル名は hello-world.md のままでした。なので、この記事本文の情報からコミットメッセージを要約してはいるものの、変更を正しく把握できてませんね。

以下の git status の状態で ai-commit を実行します。

$ git status
On branch main
Your branch is ahead of 'origin/main' by 1 commit.
  (use "git push" to publish your local commits)

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   ai-commit-intro.md
        deleted:    hello-world.md

一応、--list オプションと --language japanese オプションを使って 5 つの選択肢から最善のものを選んだのですが、以下の通りでした。

$ ai-commit --list --language japanese
? Select a commit message 📝 docs: Update instructions for setting OpenAI API Key
Committing Message... 🚀 
Commit Successful! 🎉

どういうプロンプトが発行されているか気になった人は GitHub を覗いてみてください。 https://github.com/insulineru/ai-commit/blob/main/openai.js#L27

あまり洗練されているようには思えませんね。

改善してほしい点

日本語に対応してほしい
生成されたコミットメッセージがいまいちなとき、コミットを中止できるようにしてほしい（Ctrl + C せざるを得ない）
Conventional commit に対応してほしい
プロンプトに埋め込む変数を設定ファイル上で設定させてほしい

他の AI commit message generator を使ってみるとしましょう。

事後談

AI コミットの Zenn 記事に比較があったので、その中から現在スター数の最も多い aicommitsを使ってみたところ、サイコーでした。
※最初の ai-commit はスター数 366, aicommits は 8.3k

$ aicommits 
┌   aicommits 
│
◇  Detected 1 staged file:
     hugo.toml
│
◇  Changes analyzed
│
◇  Use this commit message?

   Update title in hugo.toml to remove unnecessary apostrophe

│  Yes
│
└  ✔ Successfully committed!