AC 2008 1B A

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

@@ -0,0 +1,11 @@
+10
+30123 10 6 6 9 66778418 106445782 123456789
+50000 783829464 786868124 837609671 717461242 519483675 665188817 1000000000
+20 548484 605575 606312 455648 195789 319535 654321
+4 10 7 1 2 0 1 20
+49999 1 1 1 1 999999 0 1000000
+100000 1 1 1 1 999999998 0 999999999
+100000 1 1 1 9999 0 0 100000000
+30012 11 11 4 9 777755284 19270656 1000000000
+49999 84202831 79348670 97525962 77032063 87780295 64754586 100000123
+6 2 1 2 1 1 2 11

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

@@ -0,0 +1,11 @@
+10
+100 1 1 1 99 0 0 100
+99 690 831 972 863 735 341 1000
+30 10 11 1 2 77 31 100
+10 1 1 1 1 9 0 10
+30 1 8 1 7 87 20 100
+6 2 1 2 1 1 2 11
+10 1 1 1 1 999998 0 999999
+20 993 697 870 694 380 339 1000
+100 670462 754917 817851 801885 787243 210931 1000000
+4 10 7 1 2 0 1 20

2008/1B/A/main.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func generateData(p []int64) []Pair64 {
+	n, A, B, C, D, x0, y0, M := p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]
+	result := make([]Pair64, n)
+	result[0] = Pair64{x0, y0}
+	for i := 1; int64(i) < n; i++ {
+		result[i]._1 = (A*result[i-1]._1 + B) % M
+		result[i]._2 = (C*result[i-1]._2 + D) % M
+	}
+	return result
+}
+
+func cropTriangle(scanner *bufio.Scanner) []int {
+	caseCnt := ReadInt(scanner)
+	answer := make([]int, caseCnt)
+	for i := 0; i < caseCnt; i++ {
+		params := ReadInt64s(scanner)
+		pts := generateData(params)
+		bucket := make([]int, 9)
+		for _, p := range pts {
+			x, y := p._1%3, p._2%3
+			bucket[y*3+x]++
+		}
+		// 3 cases: 3 points in same class;
+		// 2 same, 1 diffrent (impossible); 3 diffrent.
+		for j := 0; j < 9; j++ {
+			answer[i] += bucket[j] * (bucket[j] - 1) * (bucket[j] - 2) / 6
+		}
+		for j := 0; j < 9; j++ {
+			for k := j + 1; k < 9; k++ {
+				for l := k + 1; l < 9; l++ {
+					if (j/3+k/3+l/3)%3 == 0 && (j%3+k%3+l%3)%3 == 0 {
+						answer[i] += bucket[j] * bucket[k] * bucket[l]
+					}
+				}
+			}
+		}
+	}
+	return answer
+}
+
+func main() {
+	inputFiles := []string{"A-small-practice.in", "A-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 := cropTriangle(scanner)
+
+	fout, _ := os.Create(outputFiles[fileType])
+	defer fout.Close()
+
+	for i, v := range answer {
+		s := fmt.Sprintf("Case #%d: %d\n", i+1, v)
+		fout.WriteString(s)
+	}
+}

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

@@ -0,0 +1,10 @@
+Case #1: 4554669905240
+Case #2: 2314676702925
+Case #3: 969
+Case #4: 1
+Case #5: 6943194527776
+Case #6: 55553888922222
+Case #7: 18554889032160
+Case #8: 500550245867
+Case #9: 2314538164950
+Case #10: 3

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

@@ -0,0 +1,10 @@
+Case #1: 52305
+Case #2: 50720
+Case #3: 1224
+Case #4: 30
+Case #5: 449
+Case #6: 3
+Case #7: 42
+Case #8: 241
+Case #9: 17996
+Case #10: 1

2008/1B/A/test.in

@@ -0,0 +1,3 @@
+2
+4 10 7 1 2 0 1 20
+6 2 0 2 1 1 2 11

2008/1B/A/test.out

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

2008/1B/A/utils.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"bufio"
+	"strconv"
+	"strings"
+)
+
+// Pair ...
+type Pair struct {
+	_1 int
+	_2 int
+}
+
+// Pair64 ...
+type Pair64 struct {
+	_1 int64
+	_2 int64
+}
+
+// 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
+}