func solver(in *ProblemReader.ProblemReader) string {
turnAround := in.Num()
nums := in.NNums(2)
nA, nB := nums[0], nums[1]
allTrips := make([]trip, nA+nB)
for _, v := range allStations {
v.clear()
}
for j := 0; j < nA; j++ {
allTrips[j] = readTrip(in, A, B)
}
for j := 0; j < nB; j++ {
allTrips[nA+j] = readTrip(in, B, A)
}
sort.Sort(tripArray(allTrips))
for _, t := range allTrips {
src, dst := allStations[t.src], allStations[t.dst]
// fmt.Printf("trip:%v, from %v to %v\n", t, src, dst)
src.getTrain(t.depart)
dst.addTrain(t.arrive + turnAround)
}
return fmt.Sprintf("%d %d", allStations[A].reserved, allStations[B].reserved)
}
func solver(in *ProblemReader.ProblemReader) string {
word := []byte(in.Line())
lastVal = -1
letterVal := make(map[byte]int)
for _, c := range word {
if _, ok := letterVal[c]; !ok {
letterVal[c] = nextVal()
}
}
base := int64(lastVal + 1)
if base == 1 {
base++
}
sum := int64(0)
mul := int64(1)
//fmt.Println("letterVal: ", letterVal, "word:", word)
for j := len(word) - 1; j >= 0; j-- {
sum += mul * int64(letterVal[word[j]])
//fmt.Println("letter: ", word[j], "val: ", letterVal[word[j]], "mul: ", mul, "sum: ", sum)
mul *= base
}
return fmt.Sprintf("%d", sum)
}
func solver(in *ProblemReader.ProblemReader) string {
words := in.Words()
reversed := make([]string, len(words))
for pos, word := range words {
reversed[len(words)-pos-1] = word
}
return strings.Join(reversed, " ")
}
func loadBoard(in *ProblemReader.ProblemReader) *board {
hw := in.NNums(2)
b := new(board)
b.height, b.width = hw[0], hw[1]
b.cell = make([][]*Cell, b.height)
for j := 0; j < b.height; j++ {
b.cell[j] = make([]*Cell, b.width)
altitude := in.NNums(b.width)
for k := 0; k < b.width; k++ {
b.cell[j][k] = &Cell{altitude: altitude[k]}
}
}
return b
}
func solver(in *ProblemReader.ProblemReader) string {
n := in.Num()
v1 := in.NNums(n)
v2 := in.NNums(n)
sort.SortInts(v1)
sort.SortInts(v2)
var sum int64 = 0
for j := 0; j < n; j++ {
sum += int64(v1[j]) * int64(v2[n-j-1])
}
return fmt.Sprint(sum)
}
func solver(in *ProblemReader.ProblemReader) string {
nums := in.NNums(2)
board, toWin := nums[0], nums[1]
assert(toWin <= board)
lines := make([]string, board)
for j := 0; j < board; j++ {
line := []byte(in.Line())
if len(line) != board {
log.Fatalf("Expected %#v to be %d long", string(line), board)
}
shiftLine(line)
lines[j] = string(line)
}
return winner(lines, toWin)
}
func solver(in *ProblemReader.ProblemReader) string {
line := in.Line()
scores := make([]int, len(PATTERN))
for j := range line {
c := line[j]
for k := len(PATTERN) - 1; k >= 0; k-- {
if c == PATTERN[k] {
if k == 0 {
scores[k] = (scores[k] + 1) % 10000
} else {
scores[k] = (scores[k] + scores[k-1]) % 10000
}
}
}
}
return fmt.Sprintf("%04d", scores[len(scores)-1])
}
func solver(in *ProblemReader.ProblemReader) string {
n := in.Num()
wires := make([]Wire, n)
for j := 0; j < n; j++ {
wire := in.NNums(2)
wires[j] = Wire{wire[0], wire[1]}
}
sort.Sort(WireSlice(wires))
cross := 0
for j := 0; j < n; j++ {
for k := j + 1; k < n; k++ {
if wires[k].b < wires[j].b {
cross++
}
}
}
return fmt.Sprintf("%d", cross)
}
func solver(in *ProblemReader.ProblemReader) string {
credit := in.Num()
items := in.Num()
prices := in.NNums(items)
p0, p1 := pairSum(credit, prices)
return fmt.Sprintf("%d %d", p0+1, p1+1)
}
func solver(in *ProblemReader.ProblemReader) string {
nums := in.NNums(2)
existing, toCreate := nums[0], nums[1]
tree := newTree()
for j := 0; j < existing; j++ {
tree.add(in.Line())
}
additions := 0
for j := 0; j < toCreate; j++ {
additions += tree.add(in.Line())
}
return fmt.Sprintf("%d", additions)
}
func solver(in *ProblemReader.ProblemReader) string {
nEngines := in.Num()
engines := make([]string, nEngines)
for j := 0; j < nEngines; j++ {
engines[j] = in.Line()
}
terms := in.Num()
available := make(map[string]bool)
reset(available, engines, "")
changes := 0
for j := 0; j < terms; j++ {
term := in.Line()
if _, ok := available[term]; ok {
available[term] = false, false
if len(available) == 0 {
changes++
reset(available, engines, term)
}
}
}
return fmt.Sprintf("%d", changes)
}
func solver(in *ProblemReader.ProblemReader) string {
flavours := in.Num()
nCustomers := in.Num()
customers := make([]*customer, nCustomers)
for j := 0; j < nCustomers; j++ {
customers[j] = newCustomer(in.Nums())
}
malted := make(map[int]bool, flavours)
for j := 0; j < flavours; j++ {
malted[j+1] = false
}
keepLooking := true
for keepLooking {
keepLooking = false
// Is there anybody unhappy?
for _, c := range customers {
if !c.happyWith(malted) {
// Unhappy, but can be made happy with malt
if c.likesMalted && !malted[c.malted] {
malted[c.malted] = true
keepLooking = true
} else {
return "IMPOSSIBLE"
}
}
}
}
reply := make([]string, flavours)
for j := 0; j < flavours; j++ {
reply[j] = ternary(malted[j+1], "1", "0")
}
return strings.Join(reply, " ")
}
func readTrip(in *ProblemReader.ProblemReader, src string, dst string) trip {
sched := in.Words()
return trip{src, dst, parseT(sched[0]), parseT(sched[1])}
}