Go言語用ポストイット

Golangの外部パッケージを使いこなそう！アクセス制限のポイントを解説

Fri, 14 Apr 2023 21:00:07 +0900

はじめに

こんにちは、Golang プログラマの皆さん。今回の記事では、Golang の外部パッケージの少し複雑な例について、サンプルコードを交えて説明します。

Golang のパッケージに関する知識を深めることで、より一層効率的でシンプルなコードを書けるようになると思います。

本記事の対象読者

Golang の基本的な構文とパッケージシステムについては理解していることを前提としています。本記事を読む前に以下の事柄については把握していることをお勧めします。

外部・内部パッケージの違い
アクセス制御の仕組み
import 文の使い方
基本的なデータ型と関数・メソッドの使い方

これらの前提知識に加え、次のエントリでは、特に外部パッケージに焦点を当てて詳細に説明しています。

検証環境

1
2


$ go version
go version go1.20.2 darwin/arm64

今回のエントリをまとめようと思ったきっかけ

私が今回のブログ記事を書くきっかけとなったのは、次のリンクページでした。

Go 言語で ( 関数|メソッド|変数 ) がパッケージ外部に公開されるかどうかを見分けるチートシート

このページには、Golang の外部/内部パッケージに関する非常に興味深い情報がありました。特に自分が誤解していた点を修正し、パッケージのインポートやアクセスに関する詳細な説明が記載されていたため、更に理解が深まりました。

ただ実際に動かしてみると、外部パッケージのリソース参照に関して、記事に書かれている内容と異なる挙動をしている点がありました。そのため、その点を取り入れた新しいブログ記事を書くことに決めました。

今回のエントリで取り扱うソースコードとディレクトリ構造

早速サンプルコードを交えて、外部パッケージのリソース呼び出しの挙動を確認していきます。エントリ内では 2 つのソースコードが登場します。

sub.go ( package = dir )
main.go ( package = main )

フォルダ構成は以下のようになっています。 go.mod ファイルは go mod init hello というコマンドで作成しました。

1
2
3
4
5
6


$ tree
.
├── dir
│   └── sub.go
├── go.mod
└── main.go

main.go が sub.go の様々なリソースを呼び出すようになっています。

Airを使ってホットリロードを導入しGoプログラミング効率を上げる

Fri, 14 Apr 2023 08:30:02 +0900

はじめに

PHP や Ruby といった LL 言語でのプログラミングでは大部分のコードの変更が即座に反映されます。いわゆるホットリロード機能があるため、コードを変更したあとにすぐに動作確認が可能です。

Go 言語はコンパイル言語であり、 go run を使っていたとしても実質的にはコンパイルしています。そのため変更を反映するためには「実行プロセスの停止」→「コンパイル」の手順を踏む必要があります。開発中にコード変更のたびにこれを行うのは面倒なので、ホットリロードの仕組みを導入したいと思いました。

Air というツールの情報をよく見るので導入してみました。

検証環境

1
2


$ go version
go version go1.20.2 darwin/arm64

Air とは？

Github で公開されています。

GitHub - cosmtrek/air: ☁️ Live reload for Go apps

Go アプリケーション向けにホットリロード ( Live reload ) の機能を提供するツールとのことです。

開発のきっかけについて作者が述べています。 Gin フレームワークを使った Web サイトの開発を始めたとき Gin にライブリローディング機能がなく苦痛を感じたということです。 Fresh というツールを見つけたそうですが、柔軟性がなさそうと思い、より良いものを自作することにしたそうです。

特徴

ログをカラフルに出力してくれる
ビルドだけでなく、その他のコマンドも実行可能だ
特定のディレクトリを無視することができる
Air が起動したあとに追加されたディレクトリも自動的に監視してくれる

インストール方法

Go 1.16 以上を導入している場合は、いつものように go install を使うのが良いでしょう。

Go言語で簡単にDBアクセスを実現！GORMを使ってORMを体験しよう-Create編(2)

Thu, 13 Apr 2023 08:30:23 +0900

はじめに

以下の 2 つのエントリで Go 言語で利用可能な O/R マッパーである GORM の概要、導入方法、基本的な使い方とデータの登録方法について学びました。

今回は前回のデータ登録 Create で説明しきれなかった登録機能とアソシエーション(テーブル同士の関連)の設定されているデータの登録方法を学びます。

また、 default キーワードを使ってカラムを作成したときにハマるケースについても説明します。

「Belongs To」アソシエーションと関連モデルの登録方法

belongs to アソシエーションは１対１のモデル関係を表現する際に使用されます。

特に、一方のモデルがもう一方に「属する」 ( 依存している ) 関係を表現します。

例をあげます。

作成中のアプリケーションに users と companies という 2 つのモデルがあるとします。 users モデルは必ず companies テーブルのレコードに依存しているとします。

このような状況で users テーブルと companies テーブルにデータを登録する処理を、 GORM のコードで記述してみます。 ( データベース環境の用意を省略するために、今回は SQLite を使用しています )

Go言語で簡単にDBアクセスを実現！GORMを使ってORMを体験しよう-Create編(1)

Wed, 12 Apr 2023 08:30:47 +0900

はじめに

前回は GORM の導入方法と基本的な機能を紹介しました。

Go 言語で簡単に DB アクセスを実現！GORM を使って ORM を体験しよう-導入編 | Go 言語用ポストイット

gorm.Open 関数を呼び出した結果、取得される gorm.DB インスタンス ( インスタンスと呼んでいいのか Go 言語の思想がわからませんが ) のメソッドを使って様々な操作を行うことができます。

今回は Create (登録処理)に関するさまざまな機能を紹介します。

Create ( 登録 )

gorm.DB#Create() を使います。

サンプルコードを以下に記載します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package main

import (
	"fmt"
	"time"

	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

type User struct {
	gorm.Model
	Name string
	Age uint
	Biarthday time.Time
}

func main() {
	db, _ := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})

	db.AutoMigrate(&User{})

	user := User{Name: "Jinzhu", Age: 18, Biarthday: time.Now()}
	result := db.Create(&user)

	fmt.Printf("%+v\n", user.ID) // Value of user.ID is 1
	fmt.Printf("%+v\n", result.Error) // Value of result.Error is nil
	fmt.Printf("%+v\n", result.RowsAffected) // Value of result.RowsAffected is 1
}

gorm.DB#Create() を実行した結果は「戻り値」と「引数で指定した構造体(のポインタ)」から取得できます。

Go言語で簡単にDBアクセスを実現！GORMを使ってORMを体験しよう-導入編

Tue, 11 Apr 2023 08:48:37 +0900

はじめに

Go 言語上で SQL を発行せずに DB アクセスを実現するための GORM というライブラリを触ってみます。

GORM は Go 言語上で SQL を発行せずに DB アクセスを実現するための O/R マッパーライブラリです。特徴として、アソシエーション機能、イベントフック、トランザクションなどが提供されています。本記事では、GORM の基本的な使い方を紹介し、次回以降に登録・更新・削除操作に踏み込んで行きたいと思っています。

検証環境

1
2
3
4
5


$ go version
go version go1.20.2 darwin/arm64

$ grep 'gorm.io/gorm' go.mod
	gorm.io/gorm v1.24.6 // indirect

GORM とは？

名前から推測できる通り、GO 言語で使える O/R マッパーライブラリです。

特徴

O/R マッパーとして提供されている他言語のライブラリと同じような機能が提供されています。
アソシエーション機能 ( Has one、Has many、Belongs to、Many to many、Polymorphism などなど )
イベントフック ( 利用できるトリガは Before、After create、S;ve、Update、Delete、Find など )
トランザション、ネスティッドトランザクション、セーブポイントにロールバック、コミット
プリペアドステートメント
バッチインサート
SQL ビルド
Upsert、Lock、インデックスヒント
マイグレーション
ロギング

インストール方法

go mod init 、 go mod tidy を実行し、ディレクトリ配下に go.mod ファイルが存在している状態であれば、以下のコマンドを実行するだけでインストールできます。

Go言語の標準ライブラリを触ってみる-"slices"

Sun, 09 Apr 2023 08:30:03 +0900

はじめに

こんにちは、皆さん。今回は Go 言語の標準ライブラリの中でも特に重要な役割を担う “slices” について詳しく解説していきます。

“slices” は、Go 言語で配列を扱う際に便利な機能を提供してくれるライブラリです。配列を効率的に操作するために、Go 言語では “slices” を使うことが推奨されています。今回は、“slices” の機能を詳しく解説していきますので、ぜひ最後までご覧ください。

検証環境

1
2


$ go version
go version go1.20.2 darwin/arm64

標準ライブラリ “slices” とは？

Go 言語の標準ライブラリの中でも特に重要な役割を担う “slices” とは、Go 言語で配列を扱う際に便利な機能を提供してくれるライブラリです。 “slices” は、Go 言語で配列を効率的に操作するために、標準ライブラリとして提供されています。

要素の検索、ソートのための便利な機能も提供されています。

使い方

以下のインポート処理をコードのヘッダー部に記述します。

1

import "golang.org/x/exp/slices"

これで、“slices” 標準ライブラリを使う準備が整いました。

“slices” の機能

“slices” 標準ライブラリでは、以下の機能を提供しています。

`Clone` : スライスのコピー

以下のサンプルコードを見てみましょう。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import (
	"fmt"
)

func main() {

	s := []int{1, 2, 3, 4, 5}

	// スライスのサブスライスを作成
	sub := s[1:3]

	// スライスを変更
	s[2] = 10

	// サブスライスを表示
	fmt.Println(sub) // [2, 10]
}

上記のコードでは、スライスからサブスライスを作成しています。

Go言語の標準ライブラリを触ってみる-"strings"

Sat, 08 Apr 2023 08:30:28 +0900

はじめに

こんにちは！今回は Go 言語の標準ライブラリライブラリである “strings” について紹介します。

皆さん、文字列操作で頻繁に使うライブラリといえば何が思い浮かびますか？ Go 言語では、標準パッケージに含まれる “strings” が文字列操作に特化したライブラリです。 “strings” を使いこなせば、文字列操作がより簡単便利になること間違いありません。この記事では、様々な関数をサンプルコードとともに解説していきます。

標準ライブラリ的な検索や置換から、正規表現を使った高度な操作まで、幅広くカバーしています。

また、ライブラリの使い方だけでなく、実際にコードを書いてみることで理解を深めることができます。この記事を通して、Go 言語の文字列処理ライブラリを扱うスキルアップを目指しましょう！

それでは、早速 “strings” の世界を覗いてみましょう。

検証環境

1
2


$ go version
go version go1.20.2 darwin/arm64

標準ライブラリ “strings” とは？

Go 言語の標準ライブラリである"strings"は、文字列関連の操作を提供するパッケージです。以下は、strings パッケージの主な機能・特徴です。

文字列の比較、切り出し、置換、連結などの基本的な操作を提供します。
大文字・小文字の変換、空白文字のトリム ( 削除 ) や分割、パディング ( 埋め合わせ ) など、多様な文字列処理をサポートします。
UTF-8 エンコードに対応しているため、Unicode 文字列にも対応します。
他の Go 言語の標準パッケージと同様に、高速に動作するように設計されています。

strings パッケージは、多くの Go アプリケーションで利用される基本的な機能を提供しており、文字列処理に関わる開発者にとっては非常に便利なツールです。

使い方

“strings” パッケージをインポートします。コードの上部に以下の import 構文を記述します。

1

import "strings"

利用頻度が高そうな関数

個人的に利用頻度が高そうだなと思う関数について機能とサンプルコードを紹介します。

Goライブラリ"samber/lo"を使ってLodash/jQueryのようにスライス/マップを操作する

Fri, 07 Apr 2023 13:40:26 +0900

はじめに

Go 言語を使った開発をしている方にオススメのライブラリをご紹介します。

皆さん、Go 言語で Lodash や jQuery のようにスライス ( 配列 ) やマップを操作できたら便利だと思いませんか？今回の記事では、samber/loという Go 言語のライブラリとよく利用する関数をご紹介します。

samber/loとはどのようなライブラリで、どういう使い方ができるのでしょうか？また、面倒くさがり屋なエンジニアに向けた Tips もありますので、ぜひ最後までご覧ください。 FilterやUniqなど、個人的に使いやすい関数についても解説しています。この記事を読んで、samber/loを使って開発効率をアップさせましょう！

検証環境

1
2


$ go version
go version go1.20.2 darwin/arm64

`samber/lo` とは？

GitHub - samber/lo: ? A Lodash-style Go library based on Go 1.18+ Generics ( map, filter, contains, find… )

Lodash と呼ばれ得る JavaScript のライブラリのインターフェイスを模倣して作られています。

Reflection を使って同様の機能を提供するライブラリ ( ex: go-funk ) もありますが、こちらは Go1.18 以上から利用可能となった Generics の仕組みを導入しています。それにより、型チェックが行われコンパイルのタイミングで不正な代入を検出できます。

Go言語のテンプレート機能text/templateを使ってみる

Thu, 06 Apr 2023 12:06:51 +0900

はじめに

現在作成中のプログラムでテンプレートを使ってメール送信文面を用意しようと思いました。

Go の組み込みテンプレート機能を使って実現しましたが、基本機能以外にどんな機能があるか知りたいと思い調べてみました。

提供モジュール

template というパッケージを利用します。

組み込みモジュール text の中で提供されており、利用したい場合には text/template を Import する事となります。

特徴

テンプレートとなるテキストデータの中に、埋め込みたいデータを記述できます。

多くの場合、埋め込みデータの型は「構造体」または「マップ」が使われます。

テンプレートファイルの文字コード

UTF-8 を利用します。

埋め込みデータの参照

テンプレート内に {{ と }} で囲んだ部分にデータを埋め込めます。

埋め込んだデータの「フィールド」を . で始まるように記述することで参照できます。

実際にサンプルコードを見たほうが早いので以下にコードを掲載します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import (
	"os"
	"text/template"
)

func main() {
	type Inventory struct {
		Material string
		Count uint
	}

	sweaters := Inventory{"wool", 17}

	templateText := "{{.Count}} items are made of {{.Material}}"

	tmpl, _ := template.New("test").Parse(templateText)
	tmpl.Execute(os.Stdout, sweaters)
}

エラーハンドリングは省略しています。

Ginでgin-jwtを使って簡単にAPIに認証機能を実現する

Sat, 01 Apr 2023 08:30:50 +0900

はじめに

前回のエントリで、API に JWT 認証の仕組みを実現してみました。

それなりのコード量となりましたが、JWT 認証に関わらず認証は多くのサービスで必須といっても良い機能です。

すでにライブラリがありそうだと思って探すとやはりありました。

GitHub - appleboy/gin-jwt: JWT Middleware for Gin framework

こちらを使って JWT 認証機能を実現してみます。

gin-jwt ( JWT Middleware for Gin Framework ) とは

前回使ったモジュールである jwt-go を内部で利用しています。

Gin フレームワークの Middleware 機能を利用しており、簡単に導入できます。

また、コントローラロジックと JWT のチェックロジックを切り離して見通しを良くできます。

リクエストフィルタとして JWT のチェックを行うだけでなく、 ログイン や トークンのリフレッシュ のためのコントローラ関数も組み込みで用意されており、機能が豊富です。

gin-jwt を使って JWT 認証を実装してみる

いつものように使ってみます。

プロジェクトの作成

プロジェクトフォルダの作成、移動、モジュールの初期化を行います。その後 git-jwt の version2 をインストールします。

1
2
3
4
5
6
7
8


$ mkdir gin-jwt

$ cd gin-jwt

$ go mod init genzouw/gin-jwt
go: creating new go.mod: module genzouw/gin-jwt

$ go get github.com/appleboy/gin-jwt/v2

`main.go` 実装

main.go を作成します。

Go 言語用 Web フレームワーク "Gin" でログイン認証を実装

Fri, 31 Mar 2023 08:30:12 +0900

はじめに

前回までで、Gin フレークワームを使った本当に簡単なプログラムを組むことができました。

今回はログイン認証機構を実装していきます。

JSON Web Token とは？

JSON Web Token ( JWT ) は、RFC 7519 で定義された標準規格です。 JWT は、クライアントとサーバー間で情報を安全にやり取りするための仕組みです。オブジェクトを使用して、クライアントとサーバー間で情報を暗号化し、署名し、またはその両方を行うことができます。

JWT についてはここまでにして本題に入りたいと思います。

作成する REST API について

3 つのエンドポイントを作成します。

「サインアップ」エンドポイント
「ログイン」エンドポイント
「ログイン後にしか呼び出しできない」エンドポイント

「サインアップ」エンドポイント

当然ながら、ログイン前にユーザーのサインアップ ( ユーザー登録 ) が必要です。このパスは JWT を不要にし公開したままにします。

/api/register

「ログイン」エンドポイント

ログインに利用されるパスです。「ユーザー名」と「パスワード」を受け取り、JWT を生成して返却します。

/api/ogin

「ログイン後にしか呼び出しできない」エンドポイント

このパスは JWT が必須となります。

/api/admin/user

作業開始 ( セットアップ )

まずはプロジェクトフォルダを作成します。

1
2
3


$ mkdir jwt-gin

$ cd jwt-gin

お約束の go.mod ファイルを作成します。ここで作成するモジュール(アプリケーション)名は jwt-gin としました。

Go 言語で使える Web フレームワーク "Gin" を始める

Thu, 30 Mar 2023 08:30:56 +0900

Gin とは？

Go 言語で使える Http Web フレームワーク。

“Martini” のような API が特徴ですが、 Martini の 40 倍以上の速さがあります。

とにかく速度が要求されるのであれば、Gin がおすすめです。

特徴

速い

Radix Tree に基づいたルーティング機構
メモリ消費量が少ない
リフレクションを使わない
API 性能が予測しやすい

ミドルウェア

クライアントからのリクエストは、ミドルウェアのチェイン ( フィルタ ) を多段的に経由して、最終的にアクションによって処理されます。

ミドルウェアには以下のようなものがあります。

ロギング
認証・認可
GZIP による圧縮

クラッシュフリー

Gin は Http リクエストに対する処理中に発生した panic を捉えて、自動的に復旧します。

サーバーは特定のアクションの処理失敗によってダウンするようなことなく稼働し続けます。

例えば、 panic 発生を Sentry のようなサービスに通知できます。

JSON 検証

Gin はリクエストとして受け取った JSON のフォーマットが正しいかを検証してくれます。

フォーマットだけでなく、JSON 内の必須属性の値がセットされているかといったこともチェック可能です。

ルーティンググループ

ルーティングをグルーピングして管理できます。

認証必須のパス と 認証不要なパス
API v1 バージョンのパス と API v2 バージョンのパス

グルーピングしたルーティングパスの階層に限界はなく、性能影響もありません。

"vim-go"を使って Vim での Go 開発を効率化する

Tue, 28 Mar 2023 09:58:04 +0900

はじめに

いつも使っているエディタは NeoVim です。 NeoVim は、Vim の改良版であり、多くの Vim ユーザーから熱狂的な支持を受けています。本当はなんどか VS Code への移行も試みましたが、どうしても指が慣れて他のエディタや IDE に移行できません。結局 coc.vim を導入した NeoVim 住民として生活し続けています。

少しでも VS Code に近い開発効率の良い環境を作ろうと、いくつかのプラグインを導入しています。その一つとして coc.vim があります。 coc.vim は、Vim のための統合型コード補完ツールであり、Go 言語をはじめとした様々なプログラミング言語に対応しています。 coc.vim を使えば、コード補完やシンタックスハイライトなどの機能を実現することができます。

Vim による Go 言語の開発を効率化するためのプラグインとしてもう一つ重要「vim-go」があります。今回は “vim-go” について調べたことをまとめたいと思います。

“vim-go” とは？

以下の Github Page で公開されているツールです。

GitHub - fatih/vim-go: Go development plugin for Vim

Go 言語を開発する上で、NeoVim と vim-go の組み合わせは非常に便利です。これらを使いこなすことで、開発効率をさらに向上させることができます。

vim-go が提供する機能は非常に多岐にわたるため、全てを理解するには時間がかかります。しかし、vim-go を使いこなせば、コード記述やリファクタリング、テスト、デバッグなどの作業を非常にスムーズに行うことができるでしょう。

vim-go は、Go 言語の開発者にとって非常に便利なプラグインであり、Go 言語を開発するために必要なほとんどのツールが含まれています。

このプラグインを使用することで、バグの検出、文法のチェック、コード補完、デバッグなどの作業を簡単に実行できます。

「vim-plug」などのプラグインマネージャーを使用して vim-go をインストールすることができますが、インストール方法についてはここでは紹介しません。

Go 言語で GCP Cloud Storage のバケットの中身をすべて取得する

Tue, 09 Nov 2021 09:28:13 +0900

はじめに

Go 言語で GCP cloud Storage のバケットの中身を操作したかったのですが、 Cloud Storage を Go 言語で操作するのが初めてだったので、まずはバケット内のオブジェクトをすべて取得し標準出力するスクリプトを書いてみることにしました。

検証環境

1
2


$ go version
go version go1.17.2 darwin/amd64

準備

作業ディレクトリを作成し、スクリプトを作成します。

1
2
3
4
5
6


$ mkdir gcs-example

$ cd gcs-example

$ go mod init genzouw/gcs-example
go: creating new go.mod: module genzouw/gcs-example

生成された go.mod ファイルを確認します。

1
2
3
4


$ cat go.mod
module genzouw/gcs-example

go 1.17

スクリプト作成

エディタで main.go ファイルを作成します。もちろんファイル名や使用するエディタは何でも構いません。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみる-No.85「石取りゲーム」

Tue, 06 Jul 2021 08:00:35 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック上級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 85 石取りゲーム

最初に石の個数を入力し（10 個以上とする）、二人のプレイヤーが交互に 1〜3 個ずつ石を取り、最後の 1 個を取った方が負けとなるゲームがある。このゲームプログラムを作成せよ。具体的には実行例を参照のこと。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


# 【実行例、下線部は入力例】
$ ./knock85
石の数を入力してください（10以上）: 15
石の数: 15
プレイヤー1の番です
何個取る（1〜3個）? 3
石の数: 12
プレイヤー2の番です
何個取る（1〜3個）? 2
石の数: 10
プレイヤー1の番です
何個取る（1〜3個）? 4
プレイヤー1の番です
何個取る（1〜3個）? 3
石の数: 7
プレイヤー2の番です
何個取る（1〜3個）? 3
石の数: 4
プレイヤー1の番です
何個取る（1〜3個）? 2
石の数: 2
プレイヤー2の番です
何個取る（1〜3個）? 1
石の数: 1
プレイヤー2の勝ち
$ ./knock85
石の数を入力してください（10以上）: 10
石の数: 10
プレイヤー1の番です
何個取る（1〜3個）? 3
石の数: 7
プレイヤー2の番です
何個取る（1〜3個）? 2
石の数: 5
プレイヤー1の番です
何個取る（1〜3個）? 3
石の数: 2
プレイヤー2の番です
何個取る（1〜3個）? 3
石の数: -1
プレイヤー2の反則負け

回答

`knock85.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


package main

import (
	"fmt"
)

func main() {
	const countOfPlayers = 2

	stones := 0
	for stones < 10 {
		fmt.Print("石の数を入力してください。(10以上) : ")
		fmt.Scan(&stones)
	}

	fmt.Printf("石の数: %d\n", stones)

	for playerNo := 1; ; playerNo = playerNo%countOfPlayers + 1 {
		takedStones := 0
		for !(1 <= takedStones && takedStones <= 3) {
			fmt.Printf("プレイヤー%dの番です\n", (playerNo))
			fmt.Print("何個取る(1〜3個) ? ")
			fmt.Scan(&takedStones)
		}

		stones -= takedStones
		fmt.Printf("石の数: %d\n", stones)

		switch stones {
		case -1:
			fmt.Printf("プレイヤー%dの反則負け\n", (playerNo))
		case 0:
			fmt.Printf("プレイヤー%dの負け\n", (playerNo))
		case 1:
			fmt.Printf("プレイヤー%dの勝ち\n", (playerNo))
		}

		if stones <= 1 {
			break
		}
	}
}

実行

1

$ go run knock85.go

ひとこと

プレイヤーが間違って全部とってしまったケースの出力例が無いため、仕様を想像し実装しました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみる-No.84「トランプを切る」

Mon, 05 Jul 2021 08:00:26 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック上級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 84 トランプを切る

トランプをランダムに順番を変えて表示するプログラムを作成せよ。トランプは 4 つのスート（マーク）、1〜13 までの数字の 52 枚である。トランプを表現する配列を作り、適当に順序を入れ替えていけばよい。適当に順序を入れ替えるには、例えば 2 つの入れ替えるカードを乱数を使って選び、それらを入れ替える操作を何回も繰り返せばよい。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例、表示の方法はこの通りでなくてもよい】
$ ./knock84
ダイヤ5
クローバーA
クローバー7
ダイヤ8
クローバー10
ダイヤK
ダイヤ4
スペード9
ハートQ
（以下略）

回答

`knock84.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


package main

import (
	"fmt"
	"math/rand"
	"strconv"
)

func main() {
	marks := []string{
		"ダイヤ",
		"ハート",
		"スペード",
		"クローバー",
	}

	numbers := make([]int, 13)
	for i := range numbers {
		numbers[i] = i + 1
	}

	cards := make([]string, 0, 52)
	for _, mark := range marks {
		for _, number := range numbers {
			cards = append(cards, mark+strconv.Itoa(number))
		}
	}

	rand.Shuffle(len(cards), func(i, j int) {
		cards[i], cards[j] = cards[j], cards[i]
	})

	for _, c := range cards {
		fmt.Println(c)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112


$ go run knock84.go
スペード13
スペード1
クローバー5
クローバー13
ハート1
ハート10
クローバー8
スペード12
ハート6
スペード9
ハート12
ダイヤ3
スペード3
ハート3
クローバー2
ダイヤ10
ダイヤ2
スペード4
クローバー3
クローバー7
ダイヤ1
スペード5
ハート4
クローバー12
ダイヤ6
ハート7
スペード2
クローバー1
ハート13
スペード11
ダイヤ12
ダイヤ7
クローバー6
ハート11
スペード10
ダイヤ11
ハート5
クローバー4
ハート2
ダイヤ9
クローバー11
クローバー10
ダイヤ13
ダイヤ5
ダイヤ8
ダイヤ4
スペード7
ハート8
ハート9
スペード8
クローバー9
スペード6

# 件数を確認
$ go run knock84.go | wc -l
52

# 並べ替えてみる
$ go run knock84.go | sort
クローバー1
クローバー10
クローバー11
クローバー12
クローバー13
クローバー2
クローバー3
クローバー4
クローバー5
クローバー6
クローバー7
クローバー8
クローバー9
スペード1
スペード10
スペード11
スペード12
スペード13
スペード2
スペード3
スペード4
スペード5
スペード6
スペード7
スペード8
スペード9
ダイヤ1
ダイヤ10
ダイヤ11
ダイヤ12
ダイヤ13
ダイヤ2
ダイヤ3
ダイヤ4
ダイヤ5
ダイヤ6
ダイヤ7
ダイヤ8
ダイヤ9
ハート1
ハート10
ハート11
ハート12
ハート13
ハート2
ハート3
ハート4
ハート5
ハート6
ハート7
ハート8
ハート9

ひとこと

変数をいくつか定義しましたが、変数を極力減らしても良かったかなと思いました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみる-No.83「じゃんけん 5 回勝負」

Sun, 04 Jul 2021 08:00:18 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック上級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 83 じゃんけん 5 回勝負

次の仕様のじゃんけんプログラムを作成せよ。・人間は、グー、チョキ、パーをそれぞれ 0、1、2 の数字で入力する。・コンピュータは乱数を使って出す手を選ぶ。乱数の使い方は演習資料の高度なテクニック集を見よ。・5 回勝負として、人間とコンピュータの勝った回数を数え、勝敗がつくたびに 1 回ずつ表示する。あいこは決着がつくまで再勝負。途中でどちらかが 3 勝しても、5 回最後まで勝負を続ける。・指定された範囲以外の値を入力したら負けにする

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# 【実行例。下線部は入力値の例。メッセージはこの通りでなくてよい。】
$ ./knock83
あなたの手を選んでください(グー0、チョキ1、パー2): 0
コンピュータはチョキ
あなたの勝ち
あなた1勝、わたし0勝
あなたの手を選んでください(グー0、チョキ1、パー2): 2
コンピュータはパー
あいこ
あなたの手を選んでください(グー0、チョキ1、パー2): 2
コンピュータはチョキ
わたしの勝ち
あなた1勝、わたし1勝
あなたの手を選んでください(グー0、チョキ1、パー2): 3
そんな手はありません。あなたの負け
あなた1勝、わたし2勝
（中略）
あなた3勝、わたし2勝
あなたの総合勝利です。参りました。

回答

`knock83.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


package main

import (
	"fmt"
	"math/rand"
	"strconv"
	"time"
)

func main() {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))

	choices := map[int]string{
		0: "グー",
		1: "チョキ",
		2: "パー",
	}

	wins := 0
	for i := 0; i < 5; i++ {
		isSettled := false
		for !isSettled {
			var choice int

			fmt.Print("あなたの手を選んでください(グー0、チョキ1、パー2): ")
			fmt.Scan(&choice)
			if choices[choice] == "" {
				fmt.Println("そんな手はありません。あなたの負け")
				break
			}

			computerChoice := r.Intn(3)
			fmt.Println("コンピュータは" + choices[computerChoice])

			switch computerChoice - choice {
			case 1, -2:
				fmt.Println("あなたの勝ち")
				wins++
				isSettled = true
			case 0:
				fmt.Println("あいこ")
			default:
				fmt.Println("コンピュータの勝ち")
				isSettled = true
			}
		}
		fmt.Println("あなた" + strconv.Itoa(wins) + "勝、コンピュータ" + strconv.Itoa(i+1-wins) + "勝")
	}

	if wins*2 > 5 {
		fmt.Println("あなたの総合勝利です。参りました。")
	}
}

実行

1

$ go run knock83.go

ひとこと

ロジックが汚い。マジックナンバー残ったまま。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみる-No.82「パスカルの三角形 ☆」

Sat, 03 Jul 2021 08:00:44 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック上級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 82 パスカルの三角形 ☆

パスカルの三角形とは、1 段目は 1 のみ、2 段目からは段の数だけ数字が並び、両端は 1、その間は左上と右上の値を足した値、として作っていった数字の並びである（Wikipedia「パスカルの三角形」参照）。このパスカルの三角形を 15 段まで計算して表示するプログラムを作成せよ。ただし表示は左詰で値はスペースで区切って表示するのでよい（三角形に並べなくてもよい）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 【実行例】
$ ./knock82
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1
1 13 78 286 715 1287 1716 1716 1287 715 286 78 13 1
1 14 91 364 1001 2002 3003 3432 3003 2002 1001 364 91 14 1

回答

`knock82.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import (
	"fmt"
)

func main() {
	nums := make([]int, 15)
	nums[0] = 1
	for i := 0; i < len(nums); i++ {
		for j := i; j > 0; j-- {
			nums[j] += nums[j-1]
		}

		for _, n := range nums[0 : i+1] {
			fmt.Printf("%d ", n)
		}
		fmt.Println()
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


$ go run knock82.go
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1
1 13 78 286 715 1287 1716 1716 1287 715 286 78 13 1
1 14 91 364 1001 2002 3003 3432 3003 2002 1001 364 91 14 1

ひとこと

もう少しシンプルに書ける気もします。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみる-No.81「中間値」

Fri, 02 Jul 2021 08:00:57 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック上級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 81 中間値

３つの整数値を入力させ、3 つの値のうち 2 番目に大きい値を表示するプログラムを作成せよ。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock81
3つの値を入力: 23 24 25
24

$ ./knock81
3つの値を入力: 16 8 21
16

回答

`knock81.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := make([]int, 3)

	fmt.Print("3つの値を入力: ")
	fmt.Scanf("%d %d %d", &nums[0], &nums[1], &nums[2])

	sort.Slice(nums, func(i, j int) bool { return nums[i] < nums[j] })

	fmt.Println(nums[1])
}

実行

1
2
3
4
5
6
7


$ go run knock81.go
3つの値を入力: 23 24 25
24

$ go run knock81.go
3つの値を入力: 16 8 21
16

ひとこと

sort.Slice 関数を使って事前にソートしてみました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみる-No.80「互いに素 ☆」

Thu, 01 Jul 2021 08:00:00 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック上級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 80 互いに素 ☆

2 つの正の整数値を入力させ、互いに素であるか判定するプログラムを作成せよ。なお、2 つの正の整数が互いに素とは、1 以外に共通公約数を持たない関係のことである。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock80
2つの値をスペースで区切って入力: 23 24
互いに素

$ ./knock80
2つの値をスペースで区切って入力: 69 23
互いに素でない

回答

`knock80.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import (
	"fmt"
	"math"
)

func main() {
	var a, b int

	fmt.Print("2つの値をスペースで区切って入力: ")
	fmt.Scanf("%d %d", &a, &b)

	message := "互いに素"

	for i := 2; i <= int(math.Min(float64(a), float64(b))); i++ {
		if a%i == 0 && b%i == 0 {
			message = "互いに素でない"
		}
	}

	fmt.Println(message)
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


$ go run knock80.go
2つの値をスペースで区切って入力: 23 24
互いに素

$ go run knock80.go
2つの値をスペースで区切って入力: 69 23
互いに素でない

$ go run knock80.go
2つの値をスペースで区切って入力: 2 3
互いに素

$ go run knock80.go
2つの値をスペースで区切って入力: 2 6
互いに素でない

$ go run knock80.go
2つの値をスペースで区切って入力: 6 9
互いに素でない

ひとこと

互いに素の判定方法が正しいのか少し自信がありません。。。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.59「行列の和」

Wed, 30 Jun 2021 08:00:54 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 59 行列の和

3x3 行列の和を求めて表示するプログラムを作成せよ。行列の値は 2 次元配列で表現し、繰り返しを使って計算すること。 3x3 行列とは縦 3 つ、横 3 つの 9 つの要素(値)をひとまとめにして扱うものである。2 つの 3x3 行列の和は次式のように、それぞれ同じ位置にある値を足したものとして計算できる。

例えば a12 という要素は、1 行目 2 列目の要素という意味である。それぞれ同じ位置にある要素を足せばよい。なお、入力値は 1 行ずつ 3 つの値をスペースで区切って入力するようにするとよい。このためには、scanf("%d %d %d", &a[0][0], &a[0][1], &a[0][2]);のように書く(No. 57 参照)。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.58「棒グラフ」

Tue, 29 Jun 2021 08:00:44 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 58 棒グラフ

0 以上の整数値を 5 つ入力させ、それぞれの値に対して、次の形式でグラフを描くプログラムを作成せよ。形式：左端に値を表示し、適切に空白を空けて":“を書く（:で揃えるためにタブ\t を使うとよい）。その後ろに値の数だけ*を描くが、5 個おきに空白を１つ入れる。具体例は下記の実行例を参照すること。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例、下線部は入力例】
$ ./knock58
input data[0]: 7
input data[1]: 10
input data[2]: 14
input data[3]: 15
input data[4]: 21
7	:***** **
10	:***** *****
14	:***** ***** ****
15	:***** ***** *****
21	:***** ***** ***** ***** *

回答

`knock58.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package main

import (
	"fmt"
	"strconv"
)

func main() {
	nums := make([]int, 5)

	for i := 0; i < len(nums); i++ {
		fmt.Printf("input data[%d]: ", i)
		fmt.Scan(&nums[i])
	}

	for _, n := range nums {
		bar := ""
		for i := 0; i < n; i++ {
			if i%5 == 0 && i > 0 {
				bar += " "
			}
			bar += "*"
		}
		fmt.Println(strconv.Itoa(n) + "\t:" + bar)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock58.go
input data[0]: 7
input data[1]: 10
input data[2]: 14
input data[3]: 15
input data[4]: 21
7 :***** **
10 :***** *****
14 :***** ***** ****
15 :***** ***** *****
21 :***** ***** ***** ***** *

ひとこと

Java では推奨されない String 型の append 処理、Go 言語ではどうなんでしょうね？

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.57「テスト集計」

Mon, 28 Jun 2021 08:00:22 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 57 テスト集計

まず受験者数を入力させ、次に受験者数ごとに英語、数学、国語の点数をスペースで区切って入力させる（具体的な入力方法は下記の scanf の使い方の説明、および入力データの中身を見よ）。入力が終了したら、英語、数学、国語の平均点、および各受験生の合計点を計算して表示するプログラムを作成せよ。受験者数は 100 人までとする。なお、データの個数とデータはファイルからリダイレクトで入力させればよいので、入力のためのメッセージは不要である（実行例を参照すること）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


# 【実行例、データファイルは下のリンクから取得せよ】
$ ./knock57 < examSmall.data
平均点 英語:46, 数学:51, 国語:55
個人合計点
0: 141
1: 114
（途中省略）
8: 96
9: 188

$ ./knock57 < examMiddle.data
平均点 英語:55, 数学:53, 国語:54
個人合計点
0: 136
1: 64
（途中省略）
48: 265
49: 167

$ ./knock57 < examLarge.data
平均点 英語:52, 数学:51, 国語:51
個人合計点
0: 151
1: 241
（途中省略）
98: 107
99: 178

回答

`knock57.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


package main

import (
	"fmt"
	"io"
	"log"
)

func main() {
	var eng, math, lang int

	// 一行目は不要
	var dummy int
	fmt.Scanln(&dummy)

	totalScoreOfEng := 0
	totalScoreOfMath := 0
	totalScoreOfLang := 0
	var eachTotalScore []int

	for true {
		_, err := fmt.Scanf("%d %d %d", &eng, &math, &lang)
		if err == io.EOF {
			break
		} else if err != nil {
			log.Fatal(err)
		}

		totalScoreOfEng += eng
		totalScoreOfMath += math
		totalScoreOfLang += lang

		eachTotalScore = append(eachTotalScore, eng+math+lang)
	}

	fmt.Printf(
		"平均点 英語:%d, 数学:%d, 国語:%d\n",
		totalScoreOfEng/len(eachTotalScore),
		totalScoreOfMath/len(eachTotalScore),
		totalScoreOfLang/len(eachTotalScore),
	)
	fmt.Println("個人合計点")
	for i, score := range eachTotalScore {
		fmt.Printf("%d: %d\n", i, score)
	}
}

実行

事前にデータファイルをダウンロードしておきます。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.56「2 進数変換」

Sun, 27 Jun 2021 08:00:39 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 56 2 進数変換

0〜65535 の整数値を入力させ、入力値を 16 桁の 2 進数に変換して表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例、下線部は入力例】
$ ./knock56
input number: 127
0000000001111111

$ ./knock56
input number: 10000
0010011100010000

$ ./knock56
input number: 65535
1111111111111111

回答

`knock56.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	fmt.Printf("%016b\n", n)
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock56.go
input number: 127
0000000001111111

$ go run knock56.go
input number: 10000
0010011100010000

$ go run knock56.go
input number: 65535
1111111111111111

ひとこと

fmt.Printf 関数で %b を利用すると、与えられた数を 2 進数に変換してくれます。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.55「夢想花 again」

Sat, 26 Jun 2021 08:00:35 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 55 夢想花 again

「とんで」を 9 回「まわって」を 3 回繰り返した後「まわる」と表示して改行する、を 3 回繰り返すプログラムを作成せよ。「とんで」「まわって」と 3 行文の繰り返しは必ず繰り返し構文を使うこと。

1
2
3
4
5


# 【実行例】
$ ./knock55
とんでとんでとんでとんでとんでとんでとんでとんでとんでまわってまわってまわってまわる
とんでとんでとんでとんでとんでとんでとんでとんでとんでまわってまわってまわってまわる
とんでとんでとんでとんでとんでとんでとんでとんでとんでまわってまわってまわってまわる

回答

`knock55.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import (
	"fmt"
)

func main() {
	for i := 0; i < 3; i++ {
		for j := 0; j < 9; j++ {
			fmt.Print("とんで")
		}
		for j := 0; j < 3; j++ {
			fmt.Print("まわって")
		}
		fmt.Println("まわる")
	}
}

実行

1
2
3
4


$ go run knock55.go
とんでとんでとんでとんでとんでとんでとんでとんでとんでまわってまわってまわってまわる
とんでとんでとんでとんでとんでとんでとんでとんでとんでまわってまわってまわってまわる
とんでとんでとんでとんでとんでとんでとんでとんでとんでまわってまわってまわってまわる

ひとこと

ただ多重ループするだけ。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.54「最大最小」

Fri, 25 Jun 2021 08:00:36 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 54 最大最小

まずデータの個数を入力させ、次にデータの個数だけ整数値を入力させる。この入力データの中で最大値と最小値を求め表示するプログラムを作成せよ。データの個数は 100 個までとする。なお、データの個数とデータはファイルからリダイレクトで入力させればよいので、入力のためのメッセージは不要である（実行例を参照すること）。

1
2
3
4
5
6
7
8
9


# 【実行例、データファイルは下のリンクから取得せよ】
$ ./knock54 < small.data
最小値 = 128, 最大値 = 962

$ ./knock54 < middle.data
最小値 = 20, 最大値 = 988

$ ./knock54 < large.data
最小値 = 5, 最大値 = 996

回答

`knock54.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"strconv"
	"strings"

	"github.com/wesovilabs/koazee"
)

func main() {
	data, err := ioutil.ReadAll(os.Stdin)

	if err != nil {
		log.Fatal(err)
	}

	nums := koazee.StreamOf(
		strings.Split(string(data), "\n"),
	).Filter(func(val string) bool {
		return len(val) > 0
	}).Sort(func(v1, v2 string) int {
		n1, _ := strconv.Atoi(v1)
		n2, _ := strconv.Atoi(v2)
		return n1 - n2
	})

	fmt.Printf("最小値 = %v, 最大値 = %v\n", nums.First().Val(), nums.Last().Val())
}

実行

事前にデータファイルをダウンロードしておきます。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.53「素因数分解」

Thu, 24 Jun 2021 08:00:49 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 53 素因数分解

自然数の入力値を素因数分解して結果を表示するプログラムを作成せよ。

1
2
3
4


# 【実行例、下線部は入力例】
$ ./knock53
input number: 840
2 2 2 3 5 7

回答

`knock53.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	fmt.Println(factor(n))
}

func factor(n int) []int {
	for i := 2; i <= n; i++ {
		if n%i == 0 {
			return append(append([]int{}, i), factor(n/i)...)
		}
	}

	return nil
}

実行

1
2
3


$ go run knock53.go
input number: 840
[2 2 2 3 5 7]

ひとこと

解けたは解けたが、あっているのかが少々自信がないです。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.52「閏年」

Wed, 23 Jun 2021 08:00:06 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 52 閏年

西暦を入力したらその年が閏（うるう）年かどうかを判定するプログラムを作成せよ。なお、4 で割り切れる年のうち、100 で割り切れないか、400 で割り切れる年は閏年である。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


【実行例、下線部は入力例】
$ ./knock52
input year: 2015
2015年は閏年でない
$ ./knock52
input year: 2016
2016年は閏年である
$ ./knock52
input year: 2100
2100年は閏年でない
$ ./knock52
input year: 2000
2000年は閏年である

回答

`knock52.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import (
	"fmt"
)

func main() {
	var year int

	fmt.Printf("input year: ")
	fmt.Scan(&year)

	suffix := "ない"

	if year%400 == 0 || (year%4 == 0 && year%100 != 0) {
		suffix = "ある"
	}

	fmt.Printf("%v年は閏年で%v\n", year, suffix)
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


$ go run knock52.go
input year: 2015
2015年は閏年でない

$ go run knock52.go
input year: 2016
2016年は閏年である

$ go run knock52.go
input year: 2100
2100年は閏年でない

$ go run knock52.go
input year: 2000
2000年は閏年である

ひとこと

この問題もいつものやつですね。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.51「お支払い」

Tue, 22 Jun 2021 08:00:01 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 51 お支払い

指定した金額を 100 円玉と 10 円玉と 1 円玉だけで、できるだけ少ない枚数で支払いたい。金額を入力するとそれぞれの枚数を計算して表示するプログラムを作成せよ。

1
2
3
4


# 【実行例、下線部は入力例】
$ ./knock51
input money: 12345
100円玉123枚, 10円玉4枚, 1円玉5枚

回答

`knock51.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import (
	"fmt"
	"strings"
)

func main() {
	var price int

	fmt.Printf("input money: ")
	fmt.Scan(&price)

	coins := []int{
		100,
		10,
		1,
	}

	outputs := make([]string, len(coins))

	for i, coin := range coins {
		outputs[i] = fmt.Sprintf("%v円玉%v枚", coin, price/coin)
		price = price % coin
	}

	fmt.Println(strings.Join(outputs, ", "))
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock51.go
input money: 12345
100円玉123枚, 10円玉4枚, 1円玉5枚

$ go run knock51.go
input money: 100
100円玉1枚, 10円玉0枚, 1円玉0枚

$ go run knock51.go
input money: 7
100円玉0枚, 10円玉0枚, 1円玉7枚

ひとこと

5 円玉を追加した場合でも、改修は 1 行追加で実現できます。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.50「foobar」

Mon, 21 Jun 2021 08:00:13 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 50 foobar

1 から 100 までの値を繰り返しで表示するが、3 の倍数の時は foo、5 の倍数の時は bar と数字の代わりに表示するプログラムを作成せよ。なお、3 と 5 の両方の倍数の時は foobar と表示される。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 【実行例】
$ ./knock50
1
2
foo
4
bar
foo
（途中省略）
97
98
foo
bar

回答

`knock50.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
	"fmt"
	"strconv"
)

func main() {
	for i := 1; i <= 100; i++ {
		txt := ""
		if i%3 == 0 {
			txt += "foo"
		}
		if i%5 == 0 {
			txt += "bar"
		}
		if txt == "" {
			txt = strconv.Itoa(i)
		}
		fmt.Println(txt)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


$ go run knock50.go
1
2
foo
4
bar
foo
7
8
foo
bar
11
foo
13
14
foobar
16
17
foo
(途中省略)
97
98
foo
bar

ひとこと

いつものやつですね。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.49「九九」

Sun, 20 Jun 2021 08:00:14 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 49 九九

九九の表を、2 重の繰り返しを使って表示するプログラムを作成せよ。2 重の繰り返しを使わず単に表示するだけではダメ。値の間はタブ(\t)を使って間をあけること。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 【実行例】
$ ./knock49
1	2	3	4	5	6	7	8	9
2	4	6	8	10	12	14	16	18
3	6	9	12	15	18	21	24	27
4	8	12	16	20	24	28	32	36
5	10	15	20	25	30	35	40	45
6	12	18	24	30	36	42	48	54
7	14	21	28	35	42	49	56	63
8	16	24	32	40	48	56	64	72
9	18	27	36	45	54	63	72	81

回答

`knock49.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import (
	"fmt"
	"strconv"
	"strings"
)

func main() {
	nums := make([]string, 9)

	for i := 0; i < 9; i++ {
		for j := 0; j < 9; j++ {
			nums[j] = strconv.Itoa((i + 1) * (j + 1))
		}

		fmt.Println(strings.Join(nums, "\t"))
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


$ go run knock49.go
1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81

ひとこと

やはり C/C++/Java/C# といった言語の流れを組んでいるようですね。タブ文字の出力が同じ方法で実現できました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.48「繰り返し計算」

Sat, 19 Jun 2021 08:00:03 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 48 繰り返し計算

最初に 2 以上の整数値を入力し、次の規則で計算し、計算回数と計算結果を表示し、計算結果が 1 になるまで繰り返すプログラムを作成せよ。規則：ある値が偶数ならその値を 1/2 にする。奇数ならその値を 3 倍して 1 を足す。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 【実行例、下線部は入力例】
$ ./knock48
input number: 3
1: 10
2: 5
3: 16
4: 8
5: 4
6: 2
7: 1

回答

`knock48.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	for i := 1; n != 1; i++ {
		if n%2 == 0 {
			n = n / 2
		} else {
			n = n*3 + 1
		}

		fmt.Printf("%v: %v\n", i, n)
	}
}

実行

1
2
3
4
5
6
7
8
9


$ go run knock48.go
input number: 3
1: 10
2: 5
3: 16
4: 8
5: 4
6: 2
7: 1

ひとこと

特にひねりは有りません。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.47「値の入れ替え」

Wed, 26 May 2021 15:00:25 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 47 値の入れ替え

異なる整数値を 2 つ入力し、それぞれ別の変数に格納する。そして、それらの変数の値を入れ替えた後、それぞれの変数の値を表示するプログラムを作成せよ。単に順序を変えて表示するだけではダメ。必ず変数の値を入れ替えること。下の実行例の場合、まず変数 a に 2、b に 5 が入力された状態から、a の値が 5、b の値が 2 になるように入れ替える。

1
2
3
4
5


# 【実行例、下線部は入力例】
$ ./knock47
input a: 2
input b: 5
a = 5, b = 2

回答

`knock47.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import (
	"fmt"
)

func main() {
	var a, b int

	fmt.Printf("input a: ")
	fmt.Scan(&a)

	fmt.Printf("input b: ")
	fmt.Scan(&b)

	a, b = b, a

	fmt.Printf("a = %v, b = %v\n", a, b)
}

実行

1
2
3
4


$ go run knock47.go
input a: 2
input b: 5
a = 5, b = 2

ひとこと

複数の変数に同時に代入できる言語ならではの入れ替え方法でした。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.46「入場料」

Wed, 26 May 2021 12:00:37 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 46 入場料

神山美術館の入場料金は、一人 600 円であるが、5 人以上のグループなら一人 550 円、20 人以上の団体なら一人 500 円である。人数を入力し、入場料の合計を計算するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例、下線部は入力例】
$ ./knock46
人数 3
料金 1800

$ ./knock46
人数 7
料金 3850

$ ./knock46
人数 22
料金 11000

回答

`knock46.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Printf("人数 ")
	fmt.Scan(&n)

	pricePerPerson := 600

	switch {
	case n >= 20:
		pricePerPerson = 500
	case n >= 5:
		pricePerPerson = 550
	}

	fmt.Printf("料金 %v\n", pricePerPerson*n)
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock46.go
人数 3
料金 1800

$ go run knock46.go
人数 7
料金 3850

$ go run knock46.go
人数 22
料金 11000

ひとこと

switch-case 構文である必要はないですが、 if 文の代わりにつかってみました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.45「タクシー料金」

Wed, 26 May 2021 08:00:05 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 45 タクシー料金

初乗り料金が 1700m まで 610 円、それ以降は 313m ごとに 80 円のタクシーがある。このタクシーに乗った距離を m 単位で入力し、料金を計算するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例、下線部は入力例】
$ ./knock45
距離 10000
金額 2770

$ ./knock45
距離 2013
金額 690

$ ./knock45
距離 2014
金額 770

回答

`knock45.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"fmt"
	"math"
)

func main() {
	var distance int
	fmt.Printf("距離 ")
	fmt.Scan(&distance)

	payPerUser := (distance - 1700 - 1 + 313) / 313 * 80

	fmt.Printf("金額 %v\n", 610+math.Max(float64(payPerUser), 0))
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


$ go run knock45.go
距離 10000
金額 2770

$ go run knock45.go
距離 2013
金額 690

$ go run knock45.go
距離 2014
金額 770

$ go run knock45.go
距離 1
金額 610

ひとこと

前回同様できる限り浮動小数を利用したくなかったことも有り、計算式が若干わかりにくくなってしまいました。

gRPC の概要を掴むために、特徴、アーキテクチャ、ライフサイクルを理解する

Wed, 26 May 2021 07:53:15 +0900

はじめに

gRPC の概要を掴むために、特徴、アーキテクチャ、ライフサイクルについて理解した内容を整理しました。

gRPC ってそもそもなに？という方は前回のエントリを読んで頂くと理解が深まると思います。

gRPC を使いためには「サービス定義」が必要

多くの RPC システムと同じように、 gRPC も 「サービスを定義」 するという思想に基づいています。 サービス は メソッド を所有しています。 メソッド はリモートから呼び出されることを想定していて、1 つ以上のパラメータを受け取り、1 つ以上の値を返却します。

「サービス定義」の構成要素を視覚化すると以下のようになります。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


- サービス X
 - メソッド A
 - パラメータ(インプットとなるメッセージ)
 - 戻り値(アウトプットとなるメッセージ)
 - メソッド B
 - メソッド C
 ...
- サービス Y
- サービス C
...

gRPC では インターフェイス定義言語(IDL) として Protocol Buffers を利用します。 IDL を使って、「サービス」のメソッドインターフェイスと、サービスメソッドのパラメータや戻り値となる「メッセージ」のデータ構造を定義します。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.44「通貨換算」

Tue, 25 May 2021 15:00:20 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 44 通貨換算

換算したい金額（円単位）と 1 ドル何円かを整数値で入力すると、入力した金額が何ドル何セントか計算して表示するプログラムを作成せよ。1 セントは 1/100 ドルである。結果は整数値でよい（1 セント未満の端数切り捨て）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 【実行例、下線部は入力例】
$ ./knock44
何円? 10000
1ドルは何円? 120
10000円は83ドル33セント

$ ./knock44
何円? 15000
1ドルは何円? 125
15000円は120ドル0セント

回答

`knock44.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import (
	"fmt"
)

func main() {
	var yen, rate int
	fmt.Printf("何円? ")
	fmt.Scan(&yen)
	fmt.Printf("1ドルは何円? ")
	fmt.Scan(&rate)

	fmt.Printf("%v円は%vドル%vセント\n", yen, yen/rate, yen*100/rate%100)
}

実行

1
2
3
4
5
6
7
8
9


$ go run knock44.go
何円? 10000
1ドルは何円? 120
10000円は83ドル33セント

$ go run knock44.go
何円? 15000
1ドルは何円? 125
15000円は120ドル0セント

ひとこと

浮動小数は不要ですね。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.43「2 次方程式の解の判別」

Tue, 25 May 2021 12:00:21 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 43 2 次方程式の解の判別

2 次方程式 ax^2 + bx + c = 0 （x^2 は x の 2 乗の意味）の係数 a, b, c を入力し、2 次方程式の解が 2 つの実数解か、重解か、2 つの虚数解かを判別するプログラムを作成せよ。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.42「小さい順?」

Tue, 25 May 2021 08:00:48 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 42 小さい順?

整数値を 3 つ入力させ、それらの値が小さい順（等しくてもよい）に並んでいるか判定し、小さい順に並んでいる場合は OK、そうなっていない場合は NG と表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# 【実行例、下線部は入力例】
$ ./knock42
input number 1: 1
input number 2: 2
input number 3: 3
OK

$ ./knock42
input number 1: 1
input number 2: 1
input number 3: 3
OK

$ ./knock42
input number 1: 2
input number 2: 1
input number 3: 3
NG

回答

`knock42.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := make([]int, 3)

	for i := 0; i < 3; i++ {
		fmt.Printf("input number %v: ", i+1)
		fmt.Scan(&nums[i])
	}

	if sort.SliceIsSorted(nums, func(i, j int) bool { return nums[j]-nums[i] > 0 }) {
		fmt.Println("OK")
	} else {
		fmt.Println("NG")
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


$ go run knock42.go
input number 1: 1
input number 2: 2
input number 3: 3
OK

$ go run knock42.go
input number 1: 1
input number 2: 1
input number 3: 3
OK

$ go run knock42.go
input number 1: 2
input number 2: 1
input number 3: 3
NG

ひとこと

sort パッケージに SliceIsSorted という、ソート済みかどうかをチェックするズバリな件数が用意されていました。便利！

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.41「1 桁の自然数?」

Mon, 24 May 2021 15:00:56 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 41 1 桁の自然数?

整数値を入力させ、その値が一桁の自然数かそうでないか判定するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# 【実行例、下線部は入力例】
$ ./knock41
input number: 6
6 is a single figure.

$ ./knock41
input number: 10
10 is not a single figure.

$ ./knock41
input number: -3
-3 is not a single figure.

$ ./knock41
input number: 0
0 is not a single figure.

回答

`knock41.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	judge := "not a single figure"
	if 0 < n && n <= 9 {
		judge = "a single figure"
	}

	fmt.Printf("%v is %v.\n", n, judge)
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


$ go run knock41.go
input number: 6
6 is a single figure.

$ go run knock41.go
input number: 10
10 is not a single figure.

$ go run knock41.go
input number: -3
-3 is not a single figure.

$ go run knock41.go
input number: 0
0 is not a single figure.

ひとこと

お恥ずかしながら、「自然数」という言葉の定義に一番悩みました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみる-No.40「even or odd」

Mon, 24 May 2021 12:00:13 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック中級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック中級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 40 even or odd

整数値を入力させ、その値が偶数ならば even、奇数ならば odd と表示するプログラムを作成せよ。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock40
input number: 6
6 is even.

$ ./knock40
input number: 7
7 is odd.

回答

`knock40.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	judge := "odd"
	if n%2 == 0 {
		judge = "even"
	}

	fmt.Printf("%v is %v\n", n, judge)
}

実行

1
2
3
4
5
6
7


$ go run knock40.go
input number: 6
6 is even

$ go run knock40.go
input number: 7
7 is odd

ひとこと

あれ？中級編でもまだまだ初級編で実施した内容とほぼ同じな気が。。。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.39「もっと・配列要素の参照」

Mon, 24 May 2021 08:00:29 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 39 もっと・配列要素の参照

{3, 7, 0, 8, 4, 1, 9, 6, 5, 2}で初期化される大きさ 10 の整数型配列を宣言し、最初は参照する要素番号を 0 とする。この参照する要素番号の配列要素の値から次の要素番号の配列要素の値を引いた値を表示し、参照する要素番号を 1 増やす。この手順を 9 回繰り返すプログラムを作成せよ。（具体的にどのような手順かは実行例を見て考えよう。）

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.38「さらに・配列要素の参照」

Sun, 23 May 2021 15:00:36 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 38 さらに・配列要素の参照

{3, 7, 0, 8, 4, 1, 9, 6, 5, 2}で初期化される大きさ 10 の整数型配列を宣言し、最初は参照する要素番号を 0 とし、この参照する要素番号の配列要素の値を表示し、次にその配列要素の値を次の参照する要素番号とし、この次の参照する要素番号の配列要素の値を表示し、さらにその配列要素の値を次の参照する要素番号とし、……を 10 回繰り返すプログラムを作成せよ。（具体的にどのような手順かは実行例を見て考えよう。）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例】
$ ./knock38
3
8
5
1
7
6
9
2
0
3

回答

`knock38.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import (
	"fmt"
)

func main() {
	nums := []int{
		3, 7, 0, 8, 4, 1, 9, 6, 5, 2,
	}

	idx := 0
	for i := 0; i < len(nums); i++ {
		fmt.Println(nums[idx])
		idx = nums[idx]
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock38.go
3
8
5
1
7
6
9
2
0
3

ひとこと

問題を理解するための力のほうが試させている気がします。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.37「続々・配列要素の参照」

Sun, 23 May 2021 12:00:48 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 37 続々・配列要素の参照

{3, 7, 0, 8, 4, 1, 9, 6, 5, 2}で初期化される大きさ 10 の整数型配列を宣言し、整数値を入力させ、要素番号が入力値の配列要素の値を参照し、さらにその参照した値を要素番号とする配列要素の値を参照して表示するプログラムを作成せよ。入力値が配列の要素の範囲外であるかどうかのチェックは省略してよい。

1
2
3
4


# 【実行例、下線部は入力例】
$ ./knock37
input index: 8
value = 1

回答

`knock37.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import (
	"fmt"
)

func main() {
	var i int
	fmt.Printf("input index: ")
	fmt.Scan(&i)

	nums := []int{
		3, 7, 0, 8, 4, 1, 9, 6, 5, 2,
	}

	fmt.Printf("value = %v\n", nums[nums[i]])
}

実行

1
2
3


$ go run knock37.go
input index: 8
value = 1

ひとこと

前回に引き続き、特に面白さはないです。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.36「続・配列要素の参照」

Sun, 23 May 2021 08:00:57 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 36 続・配列要素の参照

{3, 7, 0, 8, 4, 1, 9, 6, 5, 2}で初期化される大きさ 10 の整数型配列を宣言し、整数値を 2 つ入力させ、要素番号が入力値である 2 つの配列要素の値の積を計算して表示するプログラムを作成せよ。入力値が配列の要素の範囲外であるかどうかのチェックは省略してよい。

1
2
3
4
5


# 【実行例、下線部は入力例】
$ ./knock36
input index1: 3
input index2: 6
8 * 9 = 72

回答

`knock36.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
	"fmt"
)

func main() {
	var i1 int
	fmt.Printf("input index1: ")
	fmt.Scan(&i1)

	var i2 int
	fmt.Printf("input index2: ")
	fmt.Scan(&i2)

	nums := []int{
		3, 7, 0, 8, 4, 1, 9, 6, 5, 2,
	}

	fmt.Printf("%v * %v = %v\n", nums[i1], nums[i2], nums[i1]*nums[i2])
}

実行

1
2
3
4


$ go run knock36.go
input index1: 3
input index2: 6
8 * 9 = 72

ひとこと

特に面白さは無いです。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.35「配列要素の参照」

Sat, 22 May 2021 15:00:47 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 35 配列要素の参照

{3, 7, 0, 8, 4, 1, 9, 6, 5, 2}で初期化される大きさ 10 の整数型配列を宣言し、整数値を入力させ、要素番号が入力値である配列要素の値を表示するプログラムを作成せよ。入力値が配列の要素の範囲外であるかどうかのチェックは省略してよい。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock35
input index: 0
array[0] = 3

$ ./knock35
input index: 5
array[5] = 1

回答

`knock35.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input index: ")
	fmt.Scan(&n)

	nums := []int{
		3, 7, 0, 8, 4, 1, 9, 6, 5, 2,
	}

	fmt.Printf("array[%v] = %v\n", n, nums[n])
}

実行

1
2
3
4
5
6
7


$ go run knock35.go
input index: 0
array[0] = 3

$ go run knock35.go
input index: 5
array[5] = 1

ひとこと

配列と添字の指定方法でした。他のプログラム言語と同様です。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.34「入力値抜き改」

Sat, 22 May 2021 12:00:57 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 34 入力値抜き改

整数値を入力させ、1 から 9 まで、入力値と入力値+1 以外を表示するプログラムを作成せよ。入力値が 9 の場合は 9 のみ表示しない。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 【実行例、下線部は入力例】
$ ./knock34
input number: 7
1
2
3
4
5
6
9

回答

`knock34.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	for i := 1; i <= 9; i++ {
		switch i {
		case n:
		case n + 1:
		default:
			fmt.Println(i)
		}
	}
}

実行

1
2
3
4
5
6
7
8
9


$ go run knock34.go
input number: 7
1
2
3
4
5
6
9

ひとこと

Go 言語の switch-case は書きやすいですね。頭を使わずにさらっと掛ける。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.33「入力値抜き」

Sat, 22 May 2021 08:00:59 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 33 入力値抜き

整数値を入力させ、1 から 9 まで、入力値以外を表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 【実行例、下線部は入力例】
$ ./knock33
input number: 7
1
2
3
4
5
6
8
9

回答

`knock33.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	for i := 1; i <= 9; i++ {
		if i != n {
			fmt.Println(i)
		}
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


$ go run knock33.go
input number: 7
1
2
3
4
5
6
8
9

$ go run knock33.go
input number: 3
1
2
4
5
6
7
8
9

ひとこと

単純にループ処理を記述しました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.32「5 の倍数で bar」

Fri, 21 May 2021 15:00:49 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 32 5 の倍数で bar

1 から 20 まで順に表示するが、5 の倍数の場合は数字の代わりに bar と表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 【実行例】
$ ./knock32
1
2
3
4
bar
6
（途中、7から18まで省略）
19
bar

回答

`knock32.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"fmt"
	"strconv"
)

func main() {
	for i := 1; i <= 20; i++ {
		txt := strconv.Itoa(i)
		if i%5 == 0 {
			txt = "bar"
		}
		fmt.Println(txt)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


$ go run knock32.go
1
2
3
4
bar
6
7
8
9
bar
11
12
13
14
bar
16
17
18
19
bar

ひとこと

もう少しスカッとするようなロジックを書きたい。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.31「棒グラフ改」

Fri, 21 May 2021 12:00:03 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 31 棒グラフ改

整数値を入力させ、その個数だけ*を、5 個おきに空白（スペース）を入れて表示するプログラムを作成せよ。入力値が 0 以下の値の場合は何も書かなくてよい。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock31
input number: 7
***** **

$ ./knock31
input number: 13
***** ***** ***

回答

`knock31.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	for i := 0; i < n; i++ {
		if i%5 == 0 && i != 0 {
			fmt.Print(" ")
		}
		fmt.Print("*")
	}
	fmt.Println()
}

実行

1
2
3
4
5
6
7


$ go run knock31.go
input number: 7
***** **

$ go run knock31.go
input number: 13
***** ***** ***

ひとこと

もう少しきれいなロジックにでき無いものか。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.30「棒グラフ」

Fri, 21 May 2021 08:00:09 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 30 棒グラフ

整数値を入力させ、その個数だけ*を表示するプログラムを作成せよ。入力値が 0 以下の値の場合は何も書かなくてよい。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock30
input number: 7
*******

$ ./knock30
input number: 13
*************

回答

`knock30.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import (
	"fmt"
	"strings"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	fmt.Println(strings.Repeat("*", n))
}

実行

1
2
3
4
5
6
7


$ go run knock30.go
input number: 7
*******

$ go run knock30.go
input number: 13
*************

ひとこと

strings パッケージは Java の commons ライブラリ並に覚えると有益そう。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.29「5 つの合計」

Thu, 20 May 2021 15:00:55 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 29 5 つの合計

整数値を 5 回入力させ、それらの値の合計を表示するプログラムを繰り返しを使って作成せよ。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock29
input number: 11
input number: 22
input number: 33
input number: 44
input number: 55
sum = 165

回答

`knock29.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
	"fmt"
)

func main() {
	var nums [5]int

	for i := 0; i < len(nums); i++ {
		fmt.Printf("input number: ")
		fmt.Scan(&nums[i])
	}

	sum := 0
	for _, n := range nums {
		sum += n
	}

	fmt.Printf("sum = %v\n", sum)
}

実行

1
2
3
4
5
6
7


$ go run knock29.go
input number: 11
input number: 22
input number: 33
input number: 44
input number: 55
sum = 165

ひとこと

Sum 関数のようなものは用意されていないのでしょうか？

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.28「n の階乗」

Thu, 20 May 2021 12:00:48 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 28 n の階乗

整数値を入力させ、その値の階乗を表示するプログラムを作成せよ。ただし、0 以下の値を入力した場合は 1 と表示する。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock28
input number: 10
factorial = 3628800

$ ./knock28
input number: -2
factorial = 1

回答

`knock28.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	fmt.Printf("factorial = %v\n", factorial(n))
}

func factorial(n int) int {
	if n <= 0 {
		return 1
	} else {
		return n * factorial(n-1)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


$ go run knock28.go
input number: 10
factorial = 3628800

$ go run knock28.go
input number: -2
factorial = 1

$ go run knock28.go
input number: 0
factorial = 1

$ go run knock28.go
input number: 1
factorial = 1

$ go run knock28.go
input number: 2
factorial = 2

$ go run knock28.go
input number: 3
factorial = 6

ひとこと

再帰処理+関数定義の問題でした。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.27「1 から n までの和」

Thu, 20 May 2021 08:00:46 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 27 1 から n までの和

整数値を入力させ、1 からその値までの総和を計算して表示するプログラムを作成せよ。ただし、0 以下の値を入力した場合は 0 と表示する。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock27
input number: 10
sum = 55

$ ./knock27
input number: -2
sum = 0

回答

`knock27.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	sum := 0

	for i := 0; i < n; i++ {
		sum += (i + 1)
	}

	fmt.Printf("sum = %v\n", sum)
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock27.go
input number: 10
sum = 55

$ go run knock27.go
input number: -2
sum = 0

$ go run knock27.go
input number: 5
sum = 15

ひとこと

単純な for ループ。

gRPCの概要を理解し `proto` ファイルから `protoc` でコードを生成してみる

Wed, 19 May 2021 19:19:49 +0900

はじめに

ここ2ヶ月、時間を見つけてはGo言語を学んでいきました。素人ながら簡単なロジックならなんとか組めるようになってきました。（組み込みライブラリの使い方はまだまだですが。）

そして、ようやくここまで来ました。 Go言語を学習し始めたのも、 gRPC を習得したかったからと言っても過言では有りません。

まずは概要を学んだので、その内容をエントリにまとめておきます。また、 proto ファイルという定義ファイルを作成し、 protoc というコマンドを使って定義ファイルからクライアントコード、サーバコードを生成してみました。

gRPC って？

gRPCの特徴を列挙してみます。

Remote Procedure Call ( RPC ) のひとつ
近年開発されたオープンソースの フレームワーク
多くの環境で実行可能
負荷分散、トレーシング、ヘルスチェックなどの機能にも対応可能な仕組み
通信効率が良い

その他に以下のような特徴もあります。 ( 公式ページを参照したものなので、抽象度が高くあまりピンと来ません。 )

サービス定義が簡単

Protocol Buffers を使ってサービスを定義できます。通信はシリアライズされたバイナリデータに変換されるため、転送効率が良いです。

すぐに始められて、かつスケーラビリティに優れている

ランタイムと開発環境を 1 行でインストールできます。それにも関わらず、1 秒間に 100 万回の RPC リクエストを処理可能なスケーラビリティを持っています。

さまざまな言語と実行環境に対応

さまざまな言語と実行環境に対応しています。適切な「クライアント」と「サーバ」のスタブコードを自動生成できます。

双方向ストリーミングと統合認証

「双方向ストリーミング」と「統合認証」の機能が組み込まれています。

gRPC は　“Protocol Buffers” をどのように利用している？

もう少しだけ具体的な話に掘り下げてみたいと思います。

gRPC は、 Protocol Buffers という技術を利用してます。

Protocol Buffers は、 gRPC の中で大きく 2 つの目的で利用されています。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.26「switch-case」

Wed, 19 May 2021 15:00:15 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 26 switch-case

整数値を入力させ、その値が 1 なら one、2 なら two、3 なら three、それ以外なら others と表示するプログラムを swicth-case 文を使って作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# 【実行例、下線部は入力例】
$ ./knock26
input number: 1
one

$ ./knock26
input number: 2
two

$ ./knock26
input number: 3
three

$ ./knock26
input number: 0
others

回答

`knock26.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	switch n {
	case 1:
		fmt.Println("one")
	case 2:
		fmt.Println("two")
	case 3:
		fmt.Println("three")
	default:
		fmt.Println("others")
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


$ go run knock26.go
input number: 1
one

$ go run knock26.go
input number: 2
two

$ go run knock26.go
input number: 3
three

$ go run knock26.go
input number: 0
others

ひとこと

Go 言語の switch-case 構文の練習でした。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.25「-10 未満?、-10 以上 0 未満?、0 以上?」

Wed, 19 May 2021 12:00:42 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 25 -10 未満?、-10 以上 0 未満?、0 以上?

整数値を入力させ、その値が-10 未満なら range 1、-10 以上 0 未満であれば range 2、0 以上であれば range 3、と表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例、下線部は入力例】
$ ./knock25
input number: -15
range 1

$ ./knock25
input number: -10
range 2

$ ./knock25
input number: 0
range 3

回答

`knock25.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	if n < -10 {
		fmt.Println("range 1")
	} else if n < 0 {
		fmt.Println("range 2")
	} else {
		fmt.Println("range 3")
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock25.go
input number: -15
range 1

$ go run knock25.go
input number: -10
range 2

$ go run knock25.go
input number: 0
range 3

ひとこと

無駄に書いてもわかりにくくなるため、領域の一方しか記述しません。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.24「-10 以上 0 未満、または、10 以上」

Wed, 19 May 2021 08:00:55 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 24 -10 以上 0 未満、または、10 以上

整数値を入力させ、その値が-10 以上 0 未満、または、10 以上であれば OK、そうでなければ NG と表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例、下線部は入力例】
$ ./knock24
input number: -5
OK

$ ./knock24
input number: 10
OK

$ ./knock24
input number: 5
NG

回答

`knock24.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	if (-10 <= n && n < 0) || 10 <= n {
		fmt.Println("OK")
	} else {
		fmt.Println("NG")
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


$ go run knock24.go
input number: -5
OK

$ go run knock24.go
input number: 10
OK

$ go run knock24.go
input number: 5
NG

$ go run knock24.go
input number: -11
NG

$ go run knock24.go
input number: -1
OK

$ go run knock24.go
input number: -1
OK

$ go run knock24.go
input number: 0
NG

$ go run knock24.go
input number: 9
NG

$ go run knock24.go
input number: 10
OK

ひとこと

AND と OR 条件の混在。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.23「-5 以上 10 未満」

Tue, 18 May 2021 15:00:45 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 23 -5 以上 10 未満

整数値を入力させ、その値が-5 以上 10 未満であれば OK、そうでなければ NG と表示するプログラムを作成せよ。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock23
input number: 0
OK

$ ./knock23
input number: 10
NG

回答

`knock23.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	if -5 <= n && n < 10 {
		fmt.Println("OK")
	} else {
		fmt.Println("NG")
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


$ go run knock23.go
input number: 0
OK

$ go run knock23.go
input number: 10
NG

$ go run knock23.go
input number: -6
NG

$ go run knock23.go
input number: -5
OK

$ go run knock23.go
input number: 9
OK

$ go run knock23.go
input number: 10
NG

ひとこと

以上と未満が混在して混乱させる問題。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.22「-10 以下または 10 以上」

Tue, 18 May 2021 12:00:50 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 22 -10 以下または 10 以上

整数値を入力させ、その値が-10 以下、または、10 以上であれば OK と表示するプログラムを作成せよ。

1
2
3
4
5
6


# 【実行例、下線部は入力例】
$ ./knock22
input number: 10
OK
$ ./knock22
input number: 0

回答

`knock22.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	if n <= -10 || 10 <= n {
		fmt.Println("OK")
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


$ go run knock22.go
input number: 10
OK

$ go run knock22.go
input number: 0

$ go run knock22.go
input number: -10
OK

$ go run knock22.go
input number: -9

$ go run knock22.go
input number: 9

$ go run knock22.go
input number: 10
OK

ひとこと

OR 条件 の練習。 AND 条件 として連結すると常に false となってしまいます。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.21「5 より大きく 20 より小さい」

Tue, 18 May 2021 08:00:59 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 21 5 より大きく 20 より小さい

整数値を入力させ、その値が 5 よりも大きく、かつ、20 よりも小さければ OK と表示するプログラムを作成せよ。

1
2
3
4
5
6


# 【実行例、下線部は入力例】
$ ./knock21
input number: 10
OK
$ ./knock21
input number: 5

回答

`knock21.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	if 5 < n && n < 20 {
		fmt.Println("OK")
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


$ go run knock21.go
input number: 10
OK

$ go run knock21.go
input number: 5

$ go run knock21.go
input number: 20

$ go run knock21.go
input number: 19
OK

$ go run knock21.go
input number: 6
OK

ひとこと

if 構文の条件が複数となるケースでした。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみる-No.20「割って掛ける」

Mon, 17 May 2021 15:00:48 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック初級編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック初級編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 20 割って掛ける

整数値を 2 つ入力させ、1 つめの値を 2 つめの値で割った結果を表示し、続けてその結果に 2 つめの値を掛けた結果を表示するプログラムを作成せよ。計算はすべて整数型で行うこと（割り切れない場合は自動的に小数点以下が切り捨てられる）。

1
2
3
4
5
6


# 【実行例、下線部は入力例】
$ ./knock20
input 1st value: 10
input 2nd value: 3
result: 3
result: 9

回答

`knock20.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import (
	"fmt"
)

func main() {
	var n1, n2 int

	fmt.Printf("input 1st number: ")
	fmt.Scan(&n1)

	fmt.Printf("input 2nd number: ")
	fmt.Scan(&n2)

	fmt.Println(n1 / n2)
	fmt.Println(n1 / n2 * n2)
}

実行

1
2
3
4
5


$ go run knock20.go
input 1st number: 10
input 2nd number: 3
3
9

ひとこと

あれ？新しい要素がないような。。。四則計算も以前出た問題ですし。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.19「配列を入力値を格納」

Mon, 17 May 2021 12:00:54 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 19 配列を入力値を格納

要素数 5 の整数型の配列を宣言し、すべての配列に対して順に入力された整数値を代入し、すべての要素の値を表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例、下線部は入力例】
$ ./knock19
input number: 4
input number: 6
input number: 7
input number: 3
input number: 1
4
6
7
3
1

回答

`knock19.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import (
	"fmt"
)

func main() {
	var nums [5]int

	for i := 0; i < len(nums); i++ {
		fmt.Printf("input number: ")
		fmt.Scan(&nums[i])
	}

	for _, n := range nums {
		fmt.Println(n)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock19.go
input number: 4
input number: 6
input number: 7
input number: 3
input number: 1
4
6
7
3
1

ひとこと

今回はスライスではなく配列を使用。長さ固定ということで、5 要素の配列を活用しました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.18「配列を入力値で初期化」

Sun, 16 May 2021 15:00:46 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 18 配列を入力値で初期化

要素数 10 の整数型の配列を宣言し、整数値を入力させ、すべての配列の要素を入力値として、すべての要素の値を表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 【実行例、下線部は入力例】
$ ./knock18
input number: 6
6
6
6
6
6
6
6
6
6
6

回答

`knock18.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	// 初期化
	nums := []int{
		n,
		n,
		n,
		n,
		n,
		n,
		n,
		n,
		n,
		n,
	}

	for _, n := range nums {
		fmt.Println(n)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


$ go run knock18.go
input number: 6
6
6
6
6
6
6
6
6
6
6

ひとこと

今回のやり方がきれいな方法でないことはもちろんわかっています。。。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.17「配列を初期化」

Sun, 16 May 2021 12:00:59 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 17 配列を初期化

要素数 10 の整数型の配列を宣言し、i 番目の要素の初期値を i とし、順に値を表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 【実行例】
$ ./knock17
0
1
2
3
4
5
6
7
8
9
$

回答

`knock17.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

import (
	"fmt"
)

func main() {
	nums := []int{
		0,
		1,
		2,
		3,
		4,
		5,
		6,
		7,
		8,
		9,
	}

	for _, n := range nums {
		fmt.Println(n)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock17.go
0
1
2
3
4
5
6
7
8
9

ひとこと

問題では配列という記述がありましたが、 スライス を利用しました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.16「0 でおしまい」

Sat, 15 May 2021 15:00:02 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 16 0 でおしまい

整数値を入力させ、入力値が 0 でなければ再度入力させ、0 であれば終了するプログラムを作成せよ。

1
2
3
4
5
6


# 【実行例、下線部は入力例】
$ ./knock16
input number: 5
input number: 3
input number: -4
input number: 0

回答

`knock16.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import (
	"fmt"
)

func main() {
	n := -1

	for n != 0 {
		fmt.Printf("input number: ")
		fmt.Scan(&n)
	}
}

実行

1
2
3
4
5


$ go run knock16.go
input number: 5
input number: 3
input number: -4
input number: 0

ひとこと

不正な初期値 方式を使う前は while true 型のループを加工として知りましたが、 Go 言語だと for true {...} と記述するんですね。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.15「2 ずつカウントアップ」

Sat, 15 May 2021 12:00:21 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 15 2 ずつカウントアップ

整数値を入力させ、0 から入力値を超えない値まで 2 ずつ増やして表示するプログラムを作成せよ。

1
2
3
4
5
6
7


【実行例、下線部は入力例】
$ ./knock15
input number: 7
0
2
4
6

回答

`knock15.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	for i := 0; i <= n; i += 2 {
		fmt.Println(i)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


$ go run knock15.go
input number: 7
0
2
4
6

$ go run knock15.go
input number: 8
0
2
4
6
8

ひとこと

gofmt が優秀です。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.14「カウントダウン」

Fri, 14 May 2021 15:00:27 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 14 カウントダウン

整数値を入力させ、入力値から 0 まで数を 1 ずつ減らして表示するプログラムを作成せよ。

1
2
3
4
5
6
7
8
9


# 【実行例、下線部は入力例】
$ ./knock14
input number: 5
5
4
3
2
1
0

回答

`knock14.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	for i := 0; i <= n; i++ {
		fmt.Println(i)
	}
}

実行

1
2
3
4
5
6
7
8


$ go run knock14.go
input number: 5
5
4
3
2
1
0

ひとこと

おそらく出題者の意図はこうではないはずですが、やっぱりループは 0 からカウントアップしたほうが書きやすいんですよね。なれの問題で。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.13「カウントアップ」

Fri, 14 May 2021 12:00:22 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 13 カウントアップ

整数値を入力させ、0 から入力値まで数を 1 ずつ増やして表示するプログラムを作成せよ。

1
2
3
4
5
6
7
8
9


# 【実行例、下線部は入力例】
$ ./knock13
input number: 5
0
1
2
3
4
5

回答

`knock13.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	for i := 0; i <= n; i++ {
		fmt.Println(i)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


$ go run knock13.go
input number: 5
0
1
2
3
4
5

$ go run knock13.go
input number: 2
0
1
2

ひとこと

for ループの終了条件を < から <= に変更する、という課題でした。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.12「ごあいさつ n 回」

Thu, 13 May 2021 15:00:43 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 12 ごあいさつ n 回

整数値を入力させ、その値の回数だけ Hello World!を繰り返して表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 【実行例、下線部は入力例】
$ ./knock12
input number: 7
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!

回答

`knock12.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	for i := 0; i < n; i++ {
		fmt.Println("Hello World!")
	}
}

実行

1
2
3
4
5
6
7
8
9


$ go run knock12.go
input number: 7
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!

ひとこと

前回との違いは for の繰り返し回数が変数になっただけです。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.11「ごあいさつ 10 回」

Thu, 13 May 2021 12:00:33 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 11 ごあいさつ 10 回

Hello World!を 10 回繰り返して表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例、下線部は入力例】
$ ./knock11
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!

回答

`knock11.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import (
	"fmt"
)

func main() {
	for i := 0; i < 10; i++ {
		fmt.Println("Hello World!")
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


$ go run knock11.go
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!

# 一応行数を確認
$ go run knock11.go | wc -l
10

ひとこと

for 構文を習得。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.10「絶対値」

Wed, 12 May 2021 15:00:20 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 10 絶対値

整数値を入力させ、その値を絶対値にして表示するプログラムを作成せよ。（できれば変数の値を絶対値に変えるようにせよ）

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock10
input number: 1
absolute value is 1

$ ./knock10
input number: -2
absolute value is 2

回答

`knock10.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import (
	"fmt"
	"math"
)

func main() {
	var n float64

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	fmt.Printf("absolute value is %v\n", math.Abs(n))
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock10.go
input number: 1
absolute value is 1

$ go run knock10.go
input number: -2
absolute value is 2

$ go run knock10.go
input number: 0
absolute value is 0

ひとこと

math パッケージに絶対値算出用の関数があるという勘が当たりました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.09「正?負?0?」

Wed, 12 May 2021 12:00:17 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 09 正?負?0?

整数値を入力させ、値が正であれば positive、負であれば negative、0 であれば zero と表示するプログラムを作成せよ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 【実行例、下線部は入力例】
$ ./knock09
input number: 1
positive

$ ./knock09
input number: -1
negative

$ ./knock09
input number: 0
zero

回答

`knock09.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	if n > 0 {
		fmt.Println("positive")
	} else if n == 0 {
		fmt.Println("zero")
	} else {
		fmt.Println("negative")
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run knock09.go
input number: 1
positive

$ go run knock09.go
input number: -1
negative

$ go run knock09.go
input number: 0
zero

ひとこと

else if 構文を学びました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.08「正の整数？」

Tue, 11 May 2021 15:00:22 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 08 正の整数？

整数値を入力させ、値が正であれば positive と表示するプログラムを作成せよ。ただし 0 は正には含まない。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 【実行例、下線部は入力例】
$ ./knock08
input number: 1
positive

$ ./knock08
input number: -1

$ ./knock08
input number: 0

回答

`knock08.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	if n > 0 {
		fmt.Println("positive")
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run ./07
input number: 1
not zero

$ go run ./07
input number: 0
zero

$ go run ./07
input number: 1
not zero

ひとこと

比較演算子の > を利用。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.07「0 or not 0」

Tue, 11 May 2021 12:00:45 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 07 0 or not 0

整数値を入力させ、値が 0 なら zero、0 でなければ not zero と表示するプログラムを作成せよ。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock07
input number: 0
zero

$ ./knock07
input number: 1
not zero

回答

`knock07.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	if n == 0 {
		fmt.Println("zero")
	} else {
		fmt.Println("not zero")
	}
}

実行

1
2
3
4
5
6
7


$ go run knock07.go
input number: 0
zero

$ go run knock07.go
input number: 1
not zero

ひとこと

前回の if 構文に続き、 else 構文を使いました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.06「0?」

Mon, 10 May 2021 15:00:21 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 06 0?

整数値を入力させ、値が 0 なら zero と表示するプログラムを作成せよ。

1
2
3
4
5
6
7


# 【実行例、下線部は入力例】
$ ./knock06
input number: 0
zero

$ ./knock06
input number: 1

回答

`knock06.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"fmt"
)

func main() {
	var n int

	fmt.Printf("input number: ")
	fmt.Scan(&n)

	if n == 0 {
		fmt.Println("zero")
	}
}

実行

1
2
3
4
5
6


$ go run knock06.go
input number: 0
zero

$ go run knock06.go
input number: 1

ひとこと

if 構文を使いました。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.05「四則計算」

Mon, 10 May 2021 12:00:37 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 05 四則計算

整数値を 2 つ入力させ、それらの値の和、差、積、商と余りを求めるプログラムを作成せよ。なお、差と商は 1 つ目の値から 2 つ目の値を引いた、あるいは割った結果とする。余りは無い場合も 0 と表示するのでよい。

1
2
3
4
5
6
7
8


# 【実行例、下線部は入力例】
$ ./knock05
input 1st number: 123
input 2nd number: 7
和: 130
差: 116
積: 861
商: 17, 余り: 4

回答

`knock05.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import (
	"fmt"
)

func main() {
	var n1, n2 int

	fmt.Printf("input 1st number: ")
	fmt.Scan(&n1)

	fmt.Printf("input 2nd number: ")
	fmt.Scan(&n2)

	fmt.Printf("和: %v\n", n1+n2)
	fmt.Printf("差: %v\n", n1-n2)
	fmt.Printf("積: %v\n", n1*n2)
	fmt.Printf("商: %v, 余り: %v\n", n1/n2, n1%n2)
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


$ go run knock05.go
input 1st number: 123
input 2nd number: 7
和: 130
差: 116
積: 861
商: 17, 余り: 4

$ go run knock05.go
input 1st number: 123
input 2nd number: 3
和: 126
差: 120
積: 369
商: 41, 余り: 0

ひとこと

今回も簡単ですね。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.04「入力と計算」

Sun, 09 May 2021 12:00:59 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 04 入力と計算

整数値を入力させ、その入力値を 3 倍した計算結果を表示するプログラムを作成せよ。

1
2
3
4


# 【実行例、下線部は入力例】
$ ./knock04
input number: 123
answer = 369

回答

`knock04.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Printf("input number: ")
	fmt.Scan(&n)

	fmt.Printf("answer = %v\n", n*3)
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


$ go run knock04.go
input number: 123
answer = 369

$ go run knock04.go
input number: -30
answer = -90

$ go run knock04.go
input number: abc
2021/05/06 10:41:42 strconv.Atoi: parsing "abc": invalid syntax
exit status 1

ひとこと

strconv パッケージを利用して入力された文字列( string )変数値を変換する処理を記述していましたが、数値変数に直接 fmt.Scan できることを知りました。

Go 言語でコードをコンパイルし、ローカルにインストールする

Sun, 09 May 2021 08:00:31 +0900

はじめに

当エントリは以下のエントリの続きとなっています。

チュートリアルエントリの最後では、 go のサブコマンドについて学んでいきます。

go run コマンドはコードのコンパイルと実行のための便利なショートカットではありますが、実行可能なバイナリファイルを生成するわけでは有りません。

当エントリでは、以下の 2 つの新しいコマンドを紹介します。

go build : パッケージをコンパイルします。コンパイルの際には依存ライブラリも同梱されます。
go install : コンパイルとインストールを同時に行います。

早速作業を始めてみよう！

1. `hello` ディレクトリで `go build` コマンドを実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


$ basename $PWD
hello

$ go build

$ ls -l
total 2016
-rw-r--r-- 1 root root 135 Apr 23 12:16 go.mod
-rwxr-xr-x 1 root root 2055550 May 5 23:01 hello
-rw-r--r-- 1 root root 281 May 4 00:12 hello.go

2. `hello` ディレクトリで、生成された `hello` ファイルを実行

動作確認してみます。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.03「入力」

Sat, 08 May 2021 15:00:08 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 03 入力

整数値を入力させ、その入力値を表示するプログラムを作成せよ。

1
2
3
4


# 【実行例、下線部は入力例】
$ ./knock03
input number: 123
your number is 123

回答

`knock03.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import (
	"fmt"
)

func main() {
	var input string
	fmt.Printf("input number: ")
	fmt.Scan(&input)
	fmt.Printf("your number is %v\n", input)
}

実行

1
2
3


$ go run knock03.go
input number: 123
your number is 123

ひとこと

ポイントは fmt.Scan 関数を利用する点ですね。学びました！

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.02「余り」

Sat, 08 May 2021 12:00:15 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 02 余り

12345 を 7 で割った余りを表示するプログラムを作成せよ。

1
2
3


# 【実行例】
$ ./knock02
12345 ÷ 7 の余りは 4

回答

`knock02.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import (
	"fmt"
)

func main() {
	x := 12345
	y := 7
	fmt.Printf("%v ÷ %v の余りは %v\n", x, y, x%y)
}

実行

1
2


$ go run knock02.go
12345 ÷ 7 の余りは 4

ひとこと

簡単 ♪

Go 言語でユニットテストを作成する(組み込み機能)

Sat, 08 May 2021 08:00:24 +0900

はじめに

当エントリは以下のエントリの続きとなっています。

ここまででアプリケーションコードの開発が終わりました。

ここからはテストコードの追加を行っていきます。

開発中にコードをテストすることによって、変更を加えたときに組み込んでしまうバグを早期に検知することができます。

作成済みの Hello 関数をテストしてみます。

Go 言語の組み込みユニットテスト機能を使って簡単にテストできます。

コーディング開始！

1. `greetings` ディレクトリにテストコードを追加

greetings_test.go というファイルを作成します。

ファイル名の最後が _test.go で終わるコードを作成すると、 go test コマンド実行時にテストを含むコードとして扱われます。

2. `greetings_test.go` ファイルに以下のコードを記述し保存

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package greetings

import (
	"regexp"
	"testing"
)

func TestHelloName(t *testing.T) {
	name := "genzouw"
	want := regexp.MustCompile(`\b` + name + `\b`)
	msg, err := Hello("genzouw")
	if !want.MatchString(msg) || err != nil {
		t.Fatalf(`Hello("genzouw") = %q, %v, want match for %#q, nil`, msg, err, want)
	}
}

func TestHelloEmpty(t *testing.T) {
	msg, err := Hello("")
	if msg != "" || err == nil {
		t.Fatalf(`Hello("") = %q, %v, want "", error`, msg, err)
	}
}

コード解説

かんたんに解説します。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.01「足し算」

Fri, 07 May 2021 15:00:04 +0900

はじめに

「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみます。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 01 足し算

12345+23456 を計算して結果を表示するプログラムを作成せよ。

1
2
3


# 【実行例】
$ ./knock01
12345 + 23456 = 35801

回答

`knock01.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import (
	"fmt"
)

func main() {
	x := 12345
	y := 23456
	fmt.Printf("%v + %v = %v\n", x, y, x+y)
}

実行

1
2


$ go run knock01.go
12345 + 23456 = 35801

ひとこと

このぐらいであればまだまだ大丈夫です。

Go 言語で「基礎プログラミング演習 I 〜100 本ノック基礎編」を解いてみる-No.00「ご挨拶」

Fri, 07 May 2021 12:00:59 +0900

はじめに

Go 言語のチュートリアルを終えて少しだけ理解が深まりました。

Go 言語の思想や特徴をもう少し理解しておくのが良さそうな気もしましたが、同時並行して実際にプログラミングを解きながら実践力を身に着けていこうと思います。

取り扱う問題は以下のサイトを引用させていただきました。

基礎プログラミング演習 I 〜100 本ノック基礎編

検証環境

1
2
3
4
5
6
7
8
9


$ uname -moi
x86_64 unknown GNU/Linux

$ head -n 2 /etc/os-release
PRETTY_NAME="Debian GNU/Linux 10 (buster)"
NAME="Debian GNU/Linux"

$ go version | head -n 1
go version go1.16.3 linux/amd64

問題

No. 00 ご挨拶

実行すると Hello World!と表示するプログラムを作成せよ。

1
2
3


# 【実行例】
$ ./knock00
Hello World!

回答

`knock00.go`

1
2
3
4
5
6
7
8
9


package main

import (
	"fmt"
)

func main() {
	fmt.Println("Hello World!")
}

実行

1
2


$ go run knock00.go
Hello World!

ひとこと

簡単 ♪

Go 言語の組み込みモジュールを触ってみる-環境変数の取得・設定(os.Getenv、os.Setenv)

Fri, 07 May 2021 08:00:24 +0900

はじめに

今回は os パッケージに内包されている、 環境変数を取得したり、設定したりするための組み込み関数 を紹介します。

検証環境

1
2
3
4
5


$ uname -moi
x86_64 MacBookPro16,1 Darwin

$ go version
go version go1.16.3 darwin/amd64

インターフェイス

1

func Getenv(key string) string

1

func Setenv(key, value string) error

説明

Getenv 関数を使うと、環境変数の名前を指定して値を取得することができます。 Setenv 関数を使うと、環境変数の名前と値を指定して設定することができます。

Getenv は環境変数が設定されていないのか、値が空なのかの区別ができないため、両者を区別したい場合には LookupEnv 関数を使います。

サンプルコード

`main.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


package main

import (
	"log"
	"os"
)

func main() {
	// ログ出力フォーマットを調整
	log.SetFlags(0)

	// 1. 環境変数 PWD を取得
	pwd := os.Getenv("PWD")
	log.Println(pwd)

	// 2. 環境変数 VAR1 を取得
	var var1 string
	var ok bool
	var1 = os.Getenv("VAR1")
	log.Println(var1)

	var1, ok = os.LookupEnv("VAR1")
	log.Println(ok)

	// 3. 環境変数 VAR1 を設定→取得
	err := os.Setenv("VAR1", "ABC")
	if err != nil {
		log.Fatal(err)
	}

	var1 = os.Getenv("VAR1")
	log.Println(var1)

	var1, ok = os.LookupEnv("VAR1")
	log.Println(ok)
}

実行

1
2
3
4
5
6


$ go run main.go
/workdir

false
ABC
true

ひとこと

外部から実行環境ごとの設定の違いを注入するために、環境変数の利用は重要です。

Go 言語の組み込みモジュールを触ってみる-ファイルの書き出し(os.WriteFile)

Thu, 06 May 2021 08:00:48 +0900

はじめに

今回は os パッケージの WriteFile 関数を使ってみます。

検証環境

1
2
3
4
5


$ uname -moi
x86_64 MacBookPro16,1 Darwin

$ go version
go version go1.16.3 darwin/amd64

インターフェイス

1

func WriteFile(name string, data []byte, perm FileMode) error

説明

ファイル名を受け取り、そのファイルにデータを書き込みます。もしファイルが存在しなかった場合には、事前に指定されたパーミッションのファイルを作成します。

正常終了時は error の戻り値が nil となります。

サンプルコード

`main.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import (
	"log"
	"os"
)

func main() {
	text := "Hello. Here is genzouw."
	err := os.WriteFile("/tmp/test.txt", []byte(text), 0764)

	if err != nil {
		log.Fatal(err)
	}
}

実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


$ ls -l /tmp/test.txt
"/tmp/test.txt": No such file or directory (os error 2)

$ go run ./main.go

$ ls -l /tmp/test.txt
.rwxr--r-- 23 genzouw 4 5 16:52 /tmp/test.txt*

$ cat /tmp/test.txt
Hello. Here is genzouw.

ひとこと

ファイルの書き込みもできるようになりました。文字列をそのまま書き込めず、一度 []byte のようにスライスに変換しないといけないのが若干面倒です。

Go 言語の組み込みモジュールを触ってみる-ファイルの読み込み(os.ReadFile)

Wed, 05 May 2021 08:00:59 +0900

はじめに

Go 言語の学習が少し進んできたため、いくつかの組み込みパッケージを触ってさらなる学習を進めていこうと思います。

今回取り上げるのは os パッケージの ReadFile 関数を取り上げます。

検証環境

1
2
3
4
5


$ uname -moi
x86_64 MacBookPro16,1 Darwin

$ go version
go version go1.16.3 darwin/amd64

インターフェイス

1

func ReadFile(name string) ([]byte, error)

説明

ファイル名を受け取り、ファイルの内容を返します。

正常終了時は error の戻り値が nil となります。

ReadFile はファイル全体を読み込むため、 error == EOF となることはありません。

( ということは他の関数では EOF となるケースが有るということでしょうか。 )

サンプルコード

`main.go`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
	"log"
	"os"
)

func main() {
	data, err := os.ReadFile("/tmp/test.txt")

	if err != nil {
		log.Fatal(err)
	}

	os.Stdout.Write(data)
}

実行

1
2
3
4


$ echo 'hello' > /tmp/test.txt

$ go run ./main.go
hello

ひとこと

ようやくファイルを読み込めるようになりました。

Go 言語で map(Key-Value 型の仕組み)をサンプルコードを通して理解する

Tue, 04 May 2021 09:32:59 +0900

はじめに

今回のエントリではここまで作成したモジュールを変更して複数の人々に挨拶を返却したいと思います。言い換えると「複数の入力」を受け取り、その入力とペアになる「複数の出力」を返す仕組みを実現してみます。

当エントリは以下のエントリの続きとなっています。事前に一読しておくことをおすすめします。

また、 スライス についても理解してきましょう。

`Hello` 関数はパラメータを 1 つしか受け取れないため修正したいが…

ここまで作成した Hello 関数のパラメータを 1 つだけの状態から複数受け取れるように変更したいとしましょう。

しかし、すでに genzouw/greetings モジュールが公開されており、　Hello 関数の呼び出し元が存在しているため、関数の入力パラメータの型が変更されると壊れてしまいます。

こんなときは、名前の異なる別関数を新規作成します。

他言語でも同様の考えではありますが、Go 言語は特に後方互換を考慮した考えを強く意識しているように感じます。

コーディング開始！

1. `greetings/greetings.go` を開き、コードを変更

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


package greetings

import (
	"errors"
	"fmt"
	"math/rand"
	"time"
)

func Hello(name string) (string, error) {
	if name == "" {
		return "", errors.New("empty name")
	}

	message := fmt.Sprintf(randomFormat(), name)

	return message, nil
}

func Hellos(names []string) (map[string]string, error) {
	messages := make(map[string]string)
	for _, name := range names {
		message, err := Hello(name)
		if err != nil {
			return nil, err
		}
		messages[name] = message
	}
	return messages, nil
}

func init() {
	rand.Seed(time.Now().UnixNano())
}

func randomFormat() string {
	formats := []string{
		"Hi, %v. Welcome!",
		"Great to see you, %v!",
		"Hail, %v! Well met!",
	}

	return formats[rand.Intn(len(formats))]
}

前回からの差分は以下になります。

Go 言語のスライスの使い方、仕組みを理解する-その 2 pointer / length / capacity

Mon, 03 May 2021 08:00:52 +0900

はじめに

前回のエントリで スライス と配列の違いや使い方について触れました。

今回は スライス の内部はどうなっているのか？についてもう少しだけ深堀りしていきたいと思います。

スライスの内部を覗いてみる

スライスの実体は、 「配列」 の 「一部分を指す」 ものです。文章だけではわかりにくいですが、 「配列」 が存在している必要があります。

スライスは以下 3 つの情報を持っています。

pointer : 「配列へのポインタ」
length : 「配列へのポインタ」から切り取る「要素数」
capacity : 「配列へのポインタ」から配列の最後の要素までの「要素数」

make([]byte, 5) という命令が実行された場合は、以下のような配列と スライス が生成されます。

1

s := make([]byte, 5)

1
2
3
4
5
6


[配列]
| h | << [スライス] length=5 / capacity=5
| e |
| l |
| l |
| o |

配列
- 5 つの要素を持つ配列が生成されます。
スライス
- pointer ( ポインタ ) は配列の先頭を指しています。
- length=5 となります、ポインタ位置から 5 つの要素を参照できます。
- capacity=5 となります。

**length ( 長さ ) ** と **capacity ( 容量 ) ** の違いが今ひとつわかりませんが、先に進んでいきます。

Go 言語のスライスの使い方、仕組みを理解する-その1

Sat, 01 May 2021 10:00:14 +0900

はじめに

前回のエントリでスライスが登場したので、理解を整理しました。

Go 言語における **スライス ( Slices ) ** 　型は順番に並んだデータを取り扱う場合に便利です。 スライス は他言語に用意されている **配列 ( Arrays ) ** に似ていますが、少し変わった特徴を持っています。

スライス とは何なのか、 スライス とはどのように使われるのかを見ていきます。

※今回は触りにとどめ、次回でスライスの内部はどの様になっているのか？を掘り下げてみていきます 。

配列 ( Arrays )

スライス型は Go の配列型をベースとした機能になります。そのため、スライスを理解するためには配列を理解する必要があります。

配列型の定義には、 「長さ」 と 「型」 の指定が必要です。例えば、 [4]int という型は int 型(整数型)の要素を 4 つ持つ配列を表します。

配列の型は、サイズを含めて個別です。 [4]int型と[5]int型は、int なので一緒に見えますが、両者は別の型です。

配列の各要素の値を参照したい場合には、他のプログラミング言語同様 a[0] のように指定します。 ( ここでは、 a という変数に格納されている一番最初の要素を参照する例を表しています。 )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 4つの要素を持つint型配列を作成
var a [4]int

// 最初の要素に1を代入
a[0] = 1

// 変数iに最初の要素を設定
i := a[0]

// このタイミングで i == 1 となっている

// 要素数の異なる配列を作成
var b [5]int

// b = a はできない。 a = b できない。

int 型配列を初期化しなかった場合は、 0 で初期化されます。

Go 言語でランダムな文字列を返却する( `math/rand` ライブラリ )

Sat, 01 May 2021 08:00:52 +0900

はじめに

今回は、いままで作成した greetings モジュールを変更し、 毎回同じ文字列を返却する仕組み だったものから、 事前に登録されていたいくつかの挨拶文字列からランダムで 1 つ選び返却する仕組み にします。

当エントリは以下のエントリの続きとなっています。事前に一読しておくことをおすすめします。

今回の仕組みを実現するために、 Go 言語に用意されている **スライス ( slice ) ** という組み込み型を利用します。

スライス ( slice ) とは？

配列 ( array ) に似ている組み込み型です。

「配列」 は格納できる要素数が固定です。 「スライス」 は要素を追加したり削除された場合に動的にサイズが変更される「配列」です。 Go 言語における便利な組み込み型の一つです。

他のエントリでスライスについて詳しく取り上げてみましたので、是非参考ください！

コーディング開始

ここでは、挨拶文言を 3 つ用意し、スライスに格納しておくことにしましょう。このスライスからランダムに要素を選び、関数の戻り値に利用します。

1. `greetings/greetings.go` を開き、コードを変更

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


package greetings

import (
	"errors"
	"fmt"
	"math/rand"
	"time"
)

func Hello(name string) (string, error) {
	if name == "" {
		return "", errors.New("empty name")
	}

	message := fmt.Sprintf(randomFormat(), name)

	return message, nil
}

func init() {
	rand.Seed(time.Now().UnixNano())
}

func randomFormat() string {
	formats := []string{
		"Hi, %v. Welcome!",
		"Great to see you, %v!",
		"Hail, %v! Well met!",
	}

	return formats[rand.Intn(len(formats))]
}

前回からの差分は以下になります。

Go 言語でエラーを返却し、受け取った側で適切に処理する

Fri, 30 Apr 2021 10:09:59 +0900

はじめに

エラーハンドリングは、コードの安定性・堅牢性には必要不可欠です。

今回は、前回作成した greetings モジュールに少しだけコードを追加しながら、以下の内容について学んで行きます。

モジュールからエラーを返却する方法
モジュールから返却されたエラーを呼び出し元でハンドリングする方法

当エントリは以下のエントリの続きとなっています。事前に一読しておくことをおすすめします。

コーディング開始

早速コーディングを始めていきます。

1. `greetings/greetings.go` を開き、コードを追記

「挨拶をする相手の名前がわからない場合には、挨拶をせずにエラーとする」、そんな仕様を追加してみます。

name パラメータが空だった場合には、呼び出し元にエラーを返却します。以下のコードを greetings.go に記述します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package greetings

import (
	"errors"
	"fmt"
)

func Hello(name string) (string, error) {
	if name == "" {
		return "", errors.New("empty name")
	}

	message := fmt.Sprintf("Hi, %v. Welcome!", name)

	return message, nil
}

もともとのコードから変更した箇所は以下のようになります。( git diff 実行結果を添付 )

Go 言語でパッケージを自作して、それを呼び出してみる - その2

Tue, 30 Mar 2021 08:00:45 +0900

はじめに

前回のエントリでは greetings というモジュール ( 正式名は genzouw/greetings モジュール) を作成しました。

今回のエントリでは、別のモジュール ( アプリケーション) から前回作成した greetings モジュール内にある Hello 関数を呼び出してみます。

ということで、もし前回のエントリが見れていない場合は、一読することをお勧めします 。

コーディング開始！

それでは早速作成していきましょう。

1. ホームディレクトリ直下に `hello` というディレクトリを作成

1
2
3
4
5


$ cd

$ mkdir hello

$ cd hello

ディレクトリを作成した後は、前回作成した greetings ディレクトリと hello ディレクトリは同じ階層に並ぶはずです。

1
2
3


<home>/
 |-- greetings/
 |-- hello/

2. モジュールフォルダを作成したら、いつものように `go mod init` コマンドを実行

ここでもやはり、モジュール名は github のリポジトリ名をイメージして命名 しましょう。

1
2


$ go mod init genzouw/hello
go: creating new go.mod: module genzouw/hello

3. テキストエディタを開き、`hello` ディレクトリの中に `hello.go` というファイルを作成

もちろん好きなエディタで構いません 。

Go 言語でパッケージを自作して、それを呼び出してみる - その1

Mon, 29 Mar 2021 20:02:41 +0900

はじめに

前回は、外部モジュールの呼び出し方を学びました。

世界中の優秀なエンジニアの方々が作成したモジュールを利用できれば、できることの幅が随分広がります。

そんな便利な部品 モジュール を自作してみようというのが今回のエントリです。

検証環境

1
2
3
4
5
6


$ head -n 2 /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"

$ go version
go version go1.16.2 linux/amd64

学習のゴール

今回＋次回のエントリでの学習のゴールは、2 つのモジュールを作成するところまでとします。

1 つ目は他のライブラリまたはアプリケーションからインポートされることを目的とした ライブラリの作成
2 つ目は先に作成したライブラリを利用する アプリケーションの作成

今回エントリは 1 のライブラリの作成までとします。次回エントリで 2 を進めていきます。

モジュール作成の前に用語や概念を整理をしておきます

用語が増えだしたので、自作モジュールの作成の前に頭の中を整理しておきたいと思います。

チュートリアルを読む限りだと、「ライブラリ」と「アプリケーション」いずれも 「モジュール」 と呼ぶようです。

モジュール の中には複数の「ディレクトリ」が含まれています。「ディレクトリ」の中には複数の「Go コード」が含まれていますが、ディレクトリに含まれている「Go コード」のパッケージは必ず同一でなければいけません。

モジュールの中には機能や特徴が関係している関数をグループ化して入れておきます。全く関係のないものを寄せ集めてモジュール化するのは、他の人が理解しにくくなるのでやめておいた方がいいでしょう。

モジュール : パッケージをグループ化したもの。
パッケージ : Go 言語 のソースコードをグループ化したもの。ディレクトリと考えてよさそう。
ソースコード : 関数 ( や構造体、インターフェイス ) を記述したもの。

また Java の経験者からは違和感があると思いますが、ディレクトリ名とパッケージ名は一致する必要はありませんし、ディレクトリ階層とパッケージ階層も一致する必要はありません。ただし、できればディレクトリ名とパッケージ名は一致するようにしたほうがよいようです。必然的にパッケージ名にはディレクトリ名に利用できないような文字列は利用されなくなります。

Go言語で外部パッケージの関数を呼び出す

Fri, 26 Mar 2021 08:00:05 +0900

他のエンジニアが作られた関数を外部パッケージとして読み込み、自分のコードから呼び出す

前回の続きからの内容となります。ぜひ前回学習した内容を一読しておいてください！

Go 言語で “Hello, World” プログラムをコーディングしてみる | Go 言語用ポストイット

今回は “Hello world” と表示していた挨拶文を、別の関数 ( 外部パッケージの関数 ) を使って生成させてみたいと思います。

**[pkg.go.dev] ( https://pkg.go.dev/ ) ** というサイトを開き “quote” というモジュールを検索します。
検索結果から rsc.io/quote というモジュールを探してクリックします ( rsc.io/quote/vN のように名前の後方にバージョンが付与されているかもしれません )。
Documentation セクションを探しましょう。
- ここに “quote” モジュールに含まれている関数が一覧表示されているはずです。
- 書かれている関数は、このパッケージが提供されてしているものです。自分のコードから呼び出すことが可能です。
ページの一番上には rsc.io/quote というモジュールの中に “quote” パッケージが含まれていると書かれています。
- 2022-03-27 現在、英文で “Package quote collects pithy sayings.” と書かれていました。

**pkg.go.dev ** サイトでは多くのモジュールが公開されています。モジュールで提供されている関数は、自分のコードから自由に呼び出すことができます。

時間と共に新しいバージョンが公開されていきます。

go コマンドを使ってアップグレードに追従することが可能です。

前回作成したコードから `rsc.io/quote` パッケージをインポートして関数を呼び出してみる

以下のようにパッケージのインポートと関数の呼び出し処理を追記します。

1
2
3
4
5
6
7
8
9


package main

import "fmt"

import "rsc.io/quote"

func main() {
 fmt.Println(quote.Go())
}

新しく追加したモジュールを要求する

依存ライブラリのリストに rsc.io/quote モジュールを追加します。依存ライブラリを管理している設定ファイルは、前回作成した go.mod ファイルとなります。 PHP や Ruby といった他言語のライブラリ管理ツール ( Composer / Gem ) とは異なり、設定ファイルに自分で追記する必要はありません。

Go言語で "Hello, World" プログラムをコーディングしてみる

Thu, 25 Mar 2021 08:00:51 +0900

前回のエントリで Go 言語 の実行・開発環境をセットアップできました。

いよいよコーディングしてみます。

今回は公式ページのチュートリアルを参考にして、実際にソースコードを書きながら Go 言語 の学習を進めていこうと思います。

今回のエントリで学ぶことをさっくり箇条書き

チュートリアルで網羅しているのは以下の内容になります。

いくつかのシンプルな “Hello, World” コード
作成したコードを実行するための go コマンドの使い方
作成したコードの中で使っているパッケージを検索するための 言語パッケージ検索ツール の使い方
外部モジュールで提供されている関数の呼び出し方法

前提条件・推奨条件

Go 言語 のチュートリアルを進めるにあたって、以下の事項が推奨されています。

Go 言語 以外のプログラミング経験
- チュートリアルで記述することは非常にシンプルですが、いくつかの関数は C 言語や Java など他のプログラミング言語と同様の機能が登場します。
- 他のプログラミング言語経験したことがあれば理解が容易になります。
使い慣れたテキストエディタ
- 多くの適正化が Go 言語 をサポートしています。 ( 例 : VSCode、 GoLand、 Vim )
使い慣れたターミナル.
- 使い慣れたターミナルを使いましょう。
- Linux macOS であれば標準の Terminal を使うことも出来ます。 Windows であれば PowerShell や cmd を利用できます。

ちなみに、僕は iTerm + Vimmer を使います 。

コーディング開始！

それではいよいよ、コーディングを進めていきます。

1. ターミナルを開きます

2. ターミナルに以下のように入力します

ホームディレクトリに移動しましょう。

Go言語の実行・開発環境のセットアップ (Go インストール)

Wed, 24 Mar 2021 08:00:59 +0900

いよいよ Go 言語のダウンロードとインストールに進みます。

Go インストールのいくつかの方法

インストールの方法はいくつかあるようです。

一つのホストに複数の Go 言語バージョンをインストールする方法
ソースコードからインストールする方法
インストーラーをダウンロードしてインストールする方法

特別なことを考えないのであれば 3 つ目のインストールを使う方法が簡単そう です。こちらの方法でインストールを進めていこうと思います。

Go 言語をインストール

ダウンロードしたパッケージをインストールする方法は Linux、 Mac、 Windows でそれぞれ異なるようですが、公式ドキュメントを見る限り Linux と Mac におけるインストール手順は、いずれも /use/local ディレクトリにインストールする手順となっていました。そのためどちらの資料を参考にしても同じ手順となるかと思います。

1. Go インストーラーをダウンロード

以下のページを開き、インストーラーをダウンロードします。 ( インストーラーというかただの tar ファイルな気もします。 )

Download and install - The Go Programming Language

以下のコマンドを実行してダウンロードしても良いです。

1

$ curl -L -O https://golang.org/dl/go1.16.2.linux-amd64.tar.gz

2. 適切なディレクトリに配置

どこに配置してもいいとは思いますが、ドキュメント通り /usr/local/go に配置するために以下のコマンドを実行します。

ここではすでに古いバージョンがインストールされていたことを考慮し、一度削除を行っています。

1

$ rm -rf /usr/local/go && tar -C /usr/local -xzf go1.16.2.linux-amd64.tar.gz

3. 環境変数 PATH への追加

go コマンドが /usr/local/go/bin ディレクトリに配置されているはずです。 go コマンドがこのディレクトリから検出されるように、環境変数 PATH に追加します。

Go言語ってどんな言語？

Tue, 23 Mar 2021 07:34:24 +0900

僕が今まで知っていた Go 言語の情報とすれば、以下のようなものでした。

検索エンジンとして馴染み深い Google が開発
オープンソースのプログラミング言語 ( 今の世の中、オープンソースでないのプログラミング言語もあるのか？と思ってしまいます。 )

こんな状態の僕ですが、Go 言語を学習していきたいと思います。

一緒に頑張りましょう！

公式ページを読み進めてみる

まずは公式ページのドキュメントを読み進めてみます。

Google 製のオープンソースのプログラミング言語

先程触れたように、Google 製のオープンソースのプログラミング言語です。

つまり変更したいと思ったら Go 言語を自分で拡張することができます。( 僕はできません。 )

並列実行処理の記述が容易

公式ページのドキュメントには Go 言語の特徴として 並列実行処理が容易に記述できる という点が挙げられています。 まだ一切コーディングしていませんしソースコードを読んでわけでもないので全くピンと来ませんがそういうものなのでしょう。

インタプリタ型言語とコンパイル型言語の両方の特定を持ち合わす

インタプリタ型言語の特性 に加えて、 コンパイル型言語の特性 も持っているようです。開発中は インタプリタ型言語の特定 を活かして、ソースコードの修正が即座に反映され再実行できます。

代表的なインタプリタ型言語
- JavaScript
- Ruby
- Python
- PHP

本番環境にデプロイする際には、 コンパイル言語の特性 を活かし、コンパイルを行いアーキテクチャーに最適なバイナリコードを生成します。これにより、 実行速度が速く かつ 容量が小さくなる というメリットがあるようです。

静的型付け言語

静的型付け言語 の特徴があるということです。 JavaScript や Ruby と言った言語とは異なり、静的型付けの特徴により変数に想定しない値が入ることを防ぎます。

代表的な静的型付け言語
- C
- C#
- Java
代表的な動的型付け言語
- JavaScript
- Ruby
- Python
- PHP

静的型付け言語は特にチーム開発をした場合に品質の向上に効果的です。

Go言語について学習開始します！

Mon, 22 Mar 2021 20:57:06 +0900

はじめに

最近はめっきりシェルスクリプトのことばかり調べたり学習したりする日々が続いていました。

https://genzouw.com/

ところが、受け持ったシステムが Go言語を導入しているケースばかりになってきました 。

いよいよ学習に迫られてきたということで、 40過ぎのおじさんががんばってGo言語を学習したいと思いました 。

せっかくなので Go言語を学習して得た知識もブログ化して公開していきたいと思います 。

なぜ今まで続けていたブログと分割したの？

今まで続けていたブログの方が、Linuxやシェルスクリプトのエントリでコンプレックスを形成し、作った本人が言うのもなんですがなんとも近寄りがたくなってきたためです。

Go言語という、僕の中では新しい知識領域については分けて投稿しようかなと思った次第です。

誰か見るの？

誰がみるんでしょうね（笑）

誰も見なくてもいいのです。

ひとこと

さて、どこまで続くかわかりませんがGo言語の学習初めて行きたいと思います。

Go言語用ポストイット

Golangの外部パッケージを使いこなそう！アクセス制限のポイントを解説

はじめに

本記事の対象読者

検証環境

今回のエントリをまとめようと思ったきっかけ

今回のエントリで取り扱うソースコードとディレクトリ構造

Airを使ってホットリロードを導入しGoプログラミング効率を上げる

はじめに

検証環境

Air とは？

特徴

インストール方法

Go言語で簡単にDBアクセスを実現！GORMを使ってORMを体験しよう-Create編(2)

はじめに

「Belongs To」アソシエーションと関連モデルの登録方法

Go言語で簡単にDBアクセスを実現！GORMを使ってORMを体験しよう-Create編(1)

はじめに

Create ( 登録 )

Go言語で簡単にDBアクセスを実現！GORMを使ってORMを体験しよう-導入編

はじめに

検証環境

GORM とは？

特徴

インストール方法

Go言語の標準ライブラリを触ってみる-"slices"

はじめに

検証環境

標準ライブラリ “slices” とは？

使い方

“slices” の機能

Clone : スライスのコピー

Go言語の標準ライブラリを触ってみる-"strings"

はじめに

検証環境

標準ライブラリ “strings” とは？

使い方

利用頻度が高そうな関数

Goライブラリ"samber/lo"を使ってLodash/jQueryのようにスライス/マップを操作する

はじめに

検証環境

samber/lo とは？

Go言語のテンプレート機能text/templateを使ってみる

はじめに

提供モジュール

特徴

テンプレートファイルの文字コード

埋め込みデータの参照

Ginでgin-jwtを使って簡単にAPIに認証機能を実現する

はじめに

gin-jwt ( JWT Middleware for Gin Framework ) とは

gin-jwt を使って JWT 認証を実装してみる

プロジェクトの作成

main.go 実装

Go 言語用 Web フレームワーク "Gin" でログイン認証を実装

はじめに

JSON Web Token とは？

作成する REST API について

「サインアップ」エンドポイント

「ログイン」エンドポイント

「ログイン後にしか呼び出しできない」エンドポイント

作業開始 ( セットアップ )

Go 言語で使える Web フレームワーク "Gin" を始める

Gin とは？

特徴

速い

ミドルウェア

クラッシュフリー

JSON 検証

ルーティンググループ

"vim-go"を使って Vim での Go 開発を効率化する

はじめに

“vim-go” とは？

Go 言語で GCP Cloud Storage のバケットの中身をすべて取得する

はじめに

検証環境

準備

スクリプト作成

Go 言語で「基礎プログラミング演習 I 〜100 本ノック上級編」を解いてみる-No.85「石取りゲーム」

はじめに

`Clone` : スライスのコピー

`samber/lo` とは？

`main.go` 実装

`knock85.go`

`knock84.go`

`knock83.go`

`knock82.go`

`knock81.go`

`knock80.go`

`knock58.go`