二三事

package main

import "fmt"

func main() {
  const sample = "\xbd\xb2\x3d\xbc\x20\xe2\x8c\x98"

  fmt.Println("Println:")
  fmt.Println(sample)

  fmt.Println("Byte loop:")
  for i := 0; i < len(sample); i++ {
    fmt.Printf("%x ", sample[i])
  }
  fmt.Printf("\n")

  fmt.Println("Printf with %x:")
  fmt.Printf("%x\n", sample)

  fmt.Println("Printf with % x:")
  fmt.Printf("% x\n", sample)

  fmt.Println("Printf with %q:")
  fmt.Printf("%q\n", sample)

  fmt.Println("Printf with %+q:")
  fmt.Printf("%+q\n", sample)

  fmt.Println("Byte loop with %q:")
  for i := 0; i < len(sample); i++ {
    fmt.Printf("%q ", sample[i])
  }
  fmt.Printf("\n")
}

package main

import "fmt"

func main() {
  const placeOfInterest = `⌘`

  fmt.Printf("plain string: ")
  fmt.Printf("%s", placeOfInterest)
  fmt.Printf("\n")

  fmt.Printf("quoted string: ")
  fmt.Printf("%+q", placeOfInterest)
  fmt.Printf("\n")

  fmt.Printf("hex bytes: ")
  for i := 0; i < len(placeOfInterest); i++ {
    fmt.Printf("%x ", placeOfInterest[i])
  }
  fmt.Printf("\n")
}

package main

import "fmt"

func main() {
  const nihongo = "日本語"
  for index, runeValue := range nihongo {
    fmt.Printf("%#U starts at byte position %d\n", runeValue, index)
  }

  const str = "abc"
  for index, runeValue := range str {
    fmt.Printf("%#U starts at byte position %d\n", runeValue, index)
  }
}

package main

import (
  "fmt"
  "unicode/utf8"
)

func main() {
  const nihongo = "日本語"
  for i, w := 0, 0; i < len(nihongo); i += w {
    runeValue, width := utf8.DecodeRuneInString(nihongo[i:])
    fmt.Printf("%#U starts at byte position %d\n", runeValue, i)
    w = width
  }
}

import "sort"

func findContentChildren(g []int, s []int) int {
  sort.Ints(g)
  sort.Ints(s)
  var ans, gi int
  for i, _ := range s {
    for j := gi; j < len(g); j += 1 {
      if g[j] <= s[i] {
	gi = j + 1
	ans += 1
	break
      }
    }
  }

  return ans
}

func max(a, b int) int {
  if a > b {
    return a
  } else {
    return b
  }
}

func candy(ratings []int) int {
  if len(ratings) == 0 {
    return 0
  }
  if len(ratings) == 1 {
    return 1
  }

  candys := make([]int, len(ratings))
  candyHelper(ratings, candys, 0, len(candys))
  ans := 0
  for i, _ := range candys {
    ans += candys[i]
  }

  return ans
}

func candyHelper(ratings, candys []int, start, end int) {
  if start >= end {
    return
  }

  ti := start
  tn := 0
  for i := start + 1; i < end; i += 1 {
    if ratings[i] == ratings[ti] && ti+tn+1 == i {
      tn += 1
      continue
    }

    if ratings[i] < ratings[ti] {
      ti = i
      tn = 0
    }
  }

  var cs, ce int
  if ti > start && ti+tn < end-1 {
    cs, ce = 1, 1
  } else if ti == start && ti+tn == end-1 {
    if start > 0 && end < len(ratings) {
      cs, ce = candys[start-1]+1, candys[end]+1
    } else if start == 0 && end == len(ratings) {
      cs, ce = 1, 1
    } else if start == 0 {
      cs, ce = 1, candys[end]+1
    } else if end == len(ratings) {
      cs, ce = candys[start-1]+1, 1
    }
  } else if ti == start {
    if start > 0 {
      cs = candys[start-1] + 1
    } else {
      cs = 1
    }
    ce = 1
  } else if ti+tn == end-1 {
    if end < len(ratings) {
      ce = candys[end] + 1
    } else {
      ce = 1
    }
    cs = 1
  }

  if tn == 0 {
    candys[ti] = max(cs, ce)
  } else {
    candys[ti], candys[ti+tn] = cs, ce
    for i := 1; i < tn; i += 1 {
      candys[ti+i] = 1
    }
  }

  candyHelper(ratings, candys, start, ti)
  candyHelper(ratings, candys, ti+tn+1, end)
}

package main

import "fmt"



func main() {
  fmt.Println(candy([]int{2, 1, 3, 1}))
  fmt.Println(candy([]int{2, 1, 3, 1, 4, 5}))
  fmt.Println(candy([]int{2}))
  fmt.Println(candy([]int{2, 1 }))
  fmt.Println(candy([]int{1, 2 }))
  fmt.Println(candy([]int{3,2,1}))
  fmt.Println(candy([]int{1,2,3}))
  fmt.Println(candy([]int{2,2,1}))
  fmt.Println(candy([]int{2,1,1}))
  fmt.Println(candy([]int{2,2}))
  fmt.Println(candy([]int{2,1,1,2}))
  fmt.Println(candy([]int{2,1,1,1,3}))
  fmt.Println(candy([]int{1,2,2}))
}

import "strings"

func isMatch(s string, p string) bool {
  for strings.Contains(p, "**") {
    p = strings.Replace(p, "**", "*", -1)
  }

  return match(s, p)
}

func match(s string, p string) bool {
  if len(s) == 0 && len(p) == 0 {
    return true
  }

  if len(p) == 0 && len(s) > 0 {
    return false
  }

  if len(s) == 0 {
    for i, _ := range p {
      if p[i:i+1] != "*" {
	return false
      }
    }
    return true
  }

  if p[0:1] == "?" || p[0] == s[0] {
    return match(s[1:], p[1:])
  }

  if p[0:1] == "*" {
    return match(s, p[1:]) || isMatch(s[1:], p)
  }

  return false
}

func isMatch(s string, p string) bool {
  slen, plen := len(s), len(p)
  i, j := 0, 0
  is, ip := -1, -1
  for i < slen {
    if j == plen {
      if ip == -1 {
	return false
      } else {
	is += 1
	i = is
	j = ip + 1
      }
      continue
    }

    if p[j:j+1] == "*" {
      is = i
      ip = j
      j += 1
    } else {
      if s[i] == p[j] || p[j:j+1] == "?" {
	i += 1
	j += 1
      } else if ip == -1 {
	return false
      } else {
	is += 1
	i = is
	j = ip + 1
      }
    }
  }

  for j < plen && p[j:j+1] == "*" {
    j += 1
  }

  return j == plen
}

func maxNumber(nums1 []int, nums2 []int, k int) []int {
  if k < 1 {
    return []int{}
  }
  if len(nums2) > len(nums1) {
    nums1, nums2 = nums2, nums1
  }

  num := nums1[0]
  ai := 0
  ni := 0
  prev_ai := 1
  for i := 0; i < len(nums1); i += 1 {
    if len(nums1)+len(nums2)-i < k {
      break
    }

    if nums1[i] > num {
      prev_ai = ai
      num = nums1[i]
      ai, ni = 0, i
    }

    if nums1[i] == num {
      if 0 != prev_ai && ai != 0 {
	num = nums1[i]
	ai, ni = 0, i
      }
    }

    for j := 0; j < len(nums2); j += 1 {
      if len(nums1)+len(nums2)-(i+j) < k {
	break
      }

      if nums2[j] > num {
	prev_ai = ai
	num = nums2[j]
	ai, ni = 1, j
      }

      if nums2[j] == num {
	if 1 != prev_ai && ai != 1 {
	  num = nums2[j]
	  ai, ni = 1, j
	}
      }
    }
  }

  ans := []int{num}
  if ai == 0 {
    return append(ans, maxNumber(nums1[ni+1:], nums2, k-1)...)
  } else {
    return append(ans, maxNumber(nums1, nums2[ni+1:], k-1)...)
  }
}

func maxNumber(nums1 []int, nums2 []int, k int) []int {
  ans := make([]int, k)
  len1, len2 := len(nums1), len(nums2)
  for i := max(k-len2, 0); i <= min(k, len1); i += 1 {
    ans = maxInts(ans, merge(getMax(nums1, i), getMax(nums2, k-i)))
  }

  return ans
}

func getMax(nums []int, k int) []int {
  ans := make([]int, 0)
  drop := len(nums) - k
  for i := 0; i < len(nums); i += 1 {
    for drop > 0 && len(ans) > 0 && nums[i] > ans[len(ans)-1] {
      drop -= 1
      ans = ans[:len(ans)-1]
    }
    ans = append(ans, nums[i])
  }

  return ans[:k]
}

func merge(lnums []int, rnums []int) []int {
  ans := make([]int, 0, len(lnums)+len(rnums))
  li, ri := 0, 0
  ll, lr := len(lnums), len(rnums)
  for li < ll && ri < lr {
    if lnums[li] > rnums[ri] {
      ans = append(ans, lnums[li])
      li += 1
    } else if lnums[li] < rnums[ri] {
      ans = append(ans, rnums[ri])
      ri += 1
    } else {
      if isMaxInts(lnums[li:], rnums[ri:]) {
	ans = append(ans, lnums[li])
	li += 1
      } else {
	ans = append(ans, rnums[ri])
	ri += 1
      }
    }
  }

  if li < ll {
    ans = append(ans, lnums[li:]...)
  }
  if ri < lr {
    ans = append(ans, rnums[ri:]...)
  }

  return ans
}

func maxInts(lnums []int, rnums []int) []int {
  i := 0
  ll, lr := len(lnums), len(rnums)
  for i < ll && i < lr {
    if lnums[i] > rnums[i] {
      return lnums
    }

    if lnums[i] < rnums[i] {
      return rnums
    }

    i += 1
  }

  if i == ll && i == lr {
    return lnums
  } else if i < ll {
    return lnums
  } else {
    return rnums
  }
}

func isMaxInts(lnums, rnums []int) bool {
  i := 0
  ll, lr := len(lnums), len(rnums)
  for i < ll && i < lr {
    if lnums[i] > rnums[i] {
      return true
    }

    if lnums[i] < rnums[i] {
      return false
    }

    i += 1
  }

  if i == ll && i == lr {
    return true
  } else if i < ll {
    return true
  } else {
    return false
  }
}

func max(a, b int) int {
  if a > b {
    return a
  } else {
    return b
  }
}

func min(a, b int) int {
  if a < b {
    return a
  } else {
    return b
  }
}

package main

import "fmt"



func main() {
  fmt.Println(maxNumber([]int{3, 4, 6, 5}, []int{9, 1, 2, 5, 8, 3}, 5))
  fmt.Println(maxNumber([]int{6, 7}, []int{6, 0, 4}, 5))
  fmt.Println(maxNumber([]int{3, 9}, []int{8, 9}, 3))
}

func removeDuplicateLetters(s string) string {
  sM := make(map[string]int)
  for i := 0; i < len(s); i += 1 {
    sM[s[i:i+1]] += 1
  }

  var ans string
  drop := len(s) - len(sM)
  eM := make(map[string]bool)
  for i := 0; i < len(s); i += 1 {
    if eM[s[i:i+1]] {
      drop -= 1
      sM[s[i:i+1]] -= 1
      continue
    }

    for drop > 0 && len(ans) > 0 && s[i:i+1] <= ans[len(ans)-1:] && sM[ans[len(ans)-1:]] > 1 {

      drop -= 1
      sM[ans[len(ans)-1:]] -= 1
      eM[ans[len(ans)-1:]] = false
      ans = ans[:len(ans)-1]
    }
    ans += s[i : i+1]
    eM[s[i:i+1]] = true
  }

  return ans[:len(sM)]
}

package main

import "fmt"



func main() {
  fmt.Println(removeDuplicateLetters("bcabc"))
  fmt.Println(removeDuplicateLetters("cbacdcbc"))
  fmt.Println(removeDuplicateLetters("ccacbaba"))
  fmt.Println(removeDuplicateLetters("rusrbofeggbbkyuyjsrzornpdguwzizqszpbicdquakqws"))
}

func jump(nums []int) int {
  if len(nums) < 2 {
    return 0
  }

  dp := make([]int, len(nums))
  dp[0] = 0
  for i := 1; i < len(nums); i += 1 {
    dp[i] = len(nums)
    for j := i-1; j >= 0; j -= 1 {
      if nums[j] >= i-j {
	dp[i] = min(dp[i], dp[j]+1)
      }
    }
  }

  return dp[len(dp)-1]
}

func min(a, b int) int {
  if a < b {
    return a
  } else {
    return b
  }
}

package main

import "fmt"



func main() {
  fmt.Println(jump([]int{2, 3, 1, 1, 4}))
}

func intersectionSizeTwo(intervals [][]int) int {
  sort.Slice(intervals,
    func(i, j int) bool {
      return intervals[i][1] < intervals[j][1] ||
	intervals[i][1] == intervals[j][1] && intervals[i][0] < intervals[j][0]
    })

  new_intervals := make([][]int, 0)
  left := intervals[0][0]
  right := intervals[0][1]
  for i := 1; i < len(intervals); i += 1 {
    interval := intervals[i]
    if interval[1] == right {
      left = interval[0]
    } else if interval[0] > left {
      new_intervals = append(new_intervals, []int{left, right})
      left = interval[0]
      right = interval[1]
    }
  }
  new_intervals = append(new_intervals, []int{left, right})
  fmt.Println(new_intervals)

  first := new_intervals[0][1] - 1
  second := first + 1
  ans := 2
  for i := 1; i < len(new_intervals); i += 1 {
    interval := new_intervals[i]
    if interval[0] > second {
      ans += 2
      first = interval[1] - 1
      second = first + 1
    } else if interval[0] > first {
      ans += 1
      first = second
      second = interval[1]
    }
  }

  return ans
}

type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] > h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x interface{}) {
  *h = append(*h, x.(int))
}

func (h *IntHeap) Pop() interface{} {
  old := *h
  n := len(old)
  x := old[n-1]
  *h = old[0 : n-1]
  return x
}

func scheduleCourse(courses [][]int) int {
  sort.Slice(courses,
    func(i, j int) bool {
      return courses[i][1] < courses[j][1] ||
	courses[i][1] == courses[j][1] && courses[i][0] < courses[j][0]
    })

  h := &IntHeap{}
  heap.Init(h)
  curTime := 0
  for i := 0; i < len(courses); i += 1 {
    course := courses[i]
    curTime += course[0]
    heap.Push(h, course[0])
    if curTime > course[1] {
      curTime -= heap.Pop(h).(int)
    }
  }

  return h.Len()
}

package main



func main() {
  fmt.Println(scheduleCourse([][]int{
    []int{100, 200}, []int{200, 1300},
    []int{1000, 1250}, []int{2000, 3200}}))

  fmt.Println(scheduleCourse([][]int{
    []int{5, 5}, []int{1, 2}, []int{2, 6}, []int{2,7}}))
}

func minPatches(nums []int, n int) int {
  miss, ans, i := 1, 0, 0
  for miss <= n {
    if i < len(nums) && nums[i] <= miss {
      miss += nums[i]
      i += 1
    } else {
      miss += miss
      ans += 1
    }
  }

  return ans
}

func minSwapsCouples(row []int) int {
  n, ans := len(row), 0
  for i := 0; i < n; i += 2 {
    var dest int
    if row[i]%2 == 0 {
      dest = row[i] + 1
    } else {
      dest = row[i] - 1
    }

    if row[i+1] == dest {
      continue
    }

    ans += 1
    for j := i + 2; j < n; j += 1 {
      if row[j] == dest {
	row[i+1], row[j] = row[j], rows[i+1]
	break
      }
    }
  }

  return ans
}

func findMaximizedCapital(k int, W int, Profits []int, Capital []int) int {
  if k < 1 || len(Profits) < 1 {
    return W
  }

  max_profit, index := -1, -1
  for i := 0; i < len(Profits); i += 1 {
    if Capital[i] <= W && Profits[i] > max_profit {
      max_profit = Profits[i]
      index = i
    }
  }

  if index < 0 {
    return W
  }

  return findMaximizedCapital(k-1, W+max_profit,
    append(Profits[0:index], Profits[index+1:]...),
    append(Capital[0:index], Capital[index+1:]...))
}

package main

import "fmt"



func main() {
  fmt.Println(findMaximizedCapital(2, 0, []int{1, 2, 3}, []int{0, 1, 1}))
}