AC 2008 1A C

2008/1A/C/C-large-practice.in

@@ -0,0 +1,101 @@
+100
+910062006
+1449613541
+1999999985
+444322222
+1605814285
+1999999992
+1193741318
+1016518317
+1570752061
+1999999995
+1177572005
+308200077
+800561938
+103
+1999999989
+1376932921
+1535334186
+1000875506
+1999999991
+1184485437
+1155744626
+1809415844
+75225234
+1995422805
+1562234411
+209877672
+276560520
+1999999988
+1064277706
+1225400731
+1109957771
+1894509466
+1011977351
+1191967198
+1365380858
+368818964
+1611433491
+1540548799
+546776723
+205
+203
+1865363233
+1480436753
+1477014138
+330356541
+1073741824
+1999999994
+1123049112
+1065829044
+1317056443
+1284145748
+1260829455
+1329765563
+1661296617
+1023
+1795024971
+1999999984
+1544963801
+936105644
+365921634
+861924427
+955677912
+1230910728
+1051461600
+1073741823
+1514881215
+1999999986
+1999999990
+587767441
+104
+1918517182
+1999999999
+410638565
+32769
+1598846451
+1095316023
+590464207
+204
+1999999993
+1731301533
+1999999983
+1999999996
+1999999981
+1737629019
+105
+1999999982
+2000000000
+903179180
+1813833154
+1736284618
+736875403
+1791276241
+1543660610
+1880802833
+1999999997
+1526692805
+1999999987
+1746961562
+1999999998
+526886908

2008/1A/C/C-small-practice.in

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

2008/1A/C/main.go

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func matMul(a, b []int) []int {
+	c := make([]int, 4)
+	c[0] = (a[0]*b[0] + a[1]*b[2]) % 1000
+	c[1] = (a[0]*b[1] + a[1]*b[3]) % 1000
+	c[2] = (a[2]*b[0] + a[3]*b[2]) % 1000
+	c[3] = (a[2]*b[1] + a[3]*b[3]) % 1000
+	return c
+}
+
+func estimate(scanner *bufio.Scanner) []string {
+	caseCnt := ReadInt(scanner)
+	answer := make([]string, caseCnt)
+	// Conjugation is the most important clue. Assume that a = 3 + √5,
+	// b = 3 - √5, then Xn = a^n + b^n is an integer. What's more, b^n < 1,
+	// so Xn is the 1st number that larger than a^n.
+	// a + b = 6, ab = 4, so a^2 - 6 + 4 = 0, b^2 - 6 + 4 = 0,
+	// X(n+2) = 6X(n+1) - 4Xn, for | X(n+1) | _   | X(n)   |
+	//                             | X(n)   | - B | X(n-1) |,
+	// B is [[6, -4], [1, 0]], B^n [X(1), X(0)] = [X(n+1), X(n)]
+	for i := 0; i < caseCnt; i++ {
+		power := ReadInt(scanner)
+		base := []int{6, -4, 1, 0}
+		res := []int{1, 0, 0, 1} // E
+		for power != 0 {
+			if power&1 == 1 {
+				res = matMul(res, base)
+			}
+			base = matMul(base, base)
+			power /= 2
+		}
+		// X1 = 6, X0 = 2
+		product := (6*res[2] + 2*res[3]) % 1000
+		product = (product + 999) % 1000 // a^n = Xn - 1
+		answer[i] = fmt.Sprintf("%03d", int(product))
+	}
+	return answer
+}
+
+func main() {
+	inputFiles := []string{"C-small-practice.in", "C-large-practice.in", "test.in"}
+	outputFiles := []string{"result-small.out", "result-large.out", "test.out"}
+	const (
+		small = iota
+		large
+		test
+	)
+
+	fileType := test
+
+	fin, _ := os.Open(inputFiles[fileType])
+	defer fin.Close()
+
+	scanner := bufio.NewScanner(fin)
+	answer := estimate(scanner)
+
+	fout, _ := os.Create(outputFiles[fileType])
+	defer fout.Close()
+
+	for i, v := range answer {
+		s := fmt.Sprintf("Case #%d: %s\n", i+1, v)
+		fout.WriteString(s)
+	}
+}

2008/1A/C/result-large.out

@@ -0,0 +1,100 @@
+Case #1: 607
+Case #2: 455
+Case #3: 735
+Case #4: 527
+Case #5: 735
+Case #6: 471
+Case #7: 607
+Case #8: 095
+Case #9: 055
+Case #10: 663
+Case #11: 935
+Case #12: 095
+Case #13: 807
+Case #14: 143
+Case #15: 535
+Case #16: 855
+Case #17: 807
+Case #18: 607
+Case #19: 543
+Case #20: 095
+Case #21: 407
+Case #22: 951
+Case #23: 847
+Case #24: 935
+Case #25: 943
+Case #26: 471
+Case #27: 151
+Case #28: 191
+Case #29: 607
+Case #30: 343
+Case #31: 143
+Case #32: 007
+Case #33: 743
+Case #34: 407
+Case #35: 007
+Case #36: 551
+Case #37: 543
+Case #38: 063
+Case #39: 743
+Case #40: 935
+Case #41: 143
+Case #42: 455
+Case #43: 855
+Case #44: 807
+Case #45: 455
+Case #46: 351
+Case #47: 047
+Case #48: 471
+Case #49: 951
+Case #50: 343
+Case #51: 591
+Case #52: 063
+Case #53: 943
+Case #54: 095
+Case #55: 743
+Case #56: 143
+Case #57: 151
+Case #58: 255
+Case #59: 951
+Case #60: 847
+Case #61: 903
+Case #62: 471
+Case #63: 791
+Case #64: 751
+Case #65: 743
+Case #66: 463
+Case #67: 807
+Case #68: 447
+Case #69: 455
+Case #70: 751
+Case #71: 527
+Case #72: 063
+Case #73: 535
+Case #74: 735
+Case #75: 743
+Case #76: 743
+Case #77: 903
+Case #78: 751
+Case #79: 655
+Case #80: 455
+Case #81: 543
+Case #82: 791
+Case #83: 655
+Case #84: 263
+Case #85: 935
+Case #86: 527
+Case #87: 751
+Case #88: 351
+Case #89: 247
+Case #90: 607
+Case #91: 143
+Case #92: 455
+Case #93: 047
+Case #94: 455
+Case #95: 095
+Case #96: 935
+Case #97: 903
+Case #98: 527
+Case #99: 407
+Case #100: 991

2008/1A/C/result-small.out

@@ -0,0 +1,29 @@
+Case #1: 935
+Case #2: 471
+Case #3: 903
+Case #4: 751
+Case #5: 027
+Case #6: 527
+Case #7: 055
+Case #8: 903
+Case #9: 135
+Case #10: 607
+Case #11: 351
+Case #12: 647
+Case #13: 991
+Case #14: 143
+Case #15: 047
+Case #16: 607
+Case #17: 135
+Case #18: 743
+Case #19: 151
+Case #20: 407
+Case #21: 991
+Case #22: 855
+Case #23: 447
+Case #24: 263
+Case #25: 943
+Case #26: 095
+Case #27: 463
+Case #28: 791
+Case #29: 335

2008/1A/C/test.in

@@ -0,0 +1,3 @@
+2
+5
+2

2008/1A/C/test.out

@@ -0,0 +1,2 @@
+Case #1: 935
+Case #2: 027

2008/1A/C/utils.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"bufio"
+	"strconv"
+	"strings"
+)
+
+// Pair ...
+type Pair struct {
+	_1 int
+	_2 int
+}
+
+// ReadInt ...
+func ReadInt(s *bufio.Scanner) int {
+	s.Scan()
+	i, _ := strconv.ParseInt(s.Text(), 10, 32)
+	return int(i)
+}
+
+// ReadInt64 ...
+func ReadInt64(s *bufio.Scanner) int64 {
+	s.Scan()
+	i, _ := strconv.ParseInt(s.Text(), 10, 64)
+	return i
+}
+
+// ReadInts ...
+func ReadInts(s *bufio.Scanner) []int {
+	s.Scan()
+	strs := strings.Split(s.Text(), " ")
+	nums := make([]int, len(strs))
+	for i, str := range strs {
+		num, _ := strconv.ParseInt(str, 10, 32)
+		nums[i] = int(num)
+	}
+	return nums
+}
+
+// ReadInt64s ...
+func ReadInt64s(s *bufio.Scanner) []int64 {
+	s.Scan()
+	strs := strings.Split(s.Text(), " ")
+	nums := make([]int64, len(strs))
+	for i, str := range strs {
+		num, _ := strconv.ParseInt(str, 10, 64)
+		nums[i] = num
+	}
+	return nums
+}