100本ノック on 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

ひとこと

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

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 ループ。

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 言語で「基礎プログラミング演習 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 言語で「基礎プログラミング演習 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!

ひとこと

簡単 ♪