Go：基础入门练习011 - 020

package main

import (
  "fmt"
  "sort"
  "strconv"
)

//011. 数组串联
//给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，
//数组下标 从 0 开始计数 ，对于所有 0 <= i < n 的 i ，满足下述所有要求：
//ans[i] == nums[i]
//ans[i + n] == nums[i]
//具体而言，ans 由两个 nums 数组 串联 形成。
//返回数组 ans 。
//示例 1：
//输入：nums = [1,2,1]
//输出：[1,2,1,1,2,1]
//解释：数组 ans 按下述方式形成：
//- ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
//- ans = [1,2,1,1,2,1]
//示例 2：
//输入：nums = [1,3,2,1]
//输出：[1,3,2,1,1,3,2,1]
//解释：数组 ans 按下述方式形成：
//- ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
//- ans = [1,3,2,1,1,3,2,1]

func getConcatenation(nums []int) []int {
  ans := []int{}
  ans = append(nums, nums...)
  return ans
}

//012. 一维数组的动态和
//给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。
//请返回 nums 的动态和。
//示例 1：
//输入：nums = [1,2,3,4]
//输出：[1,3,6,10]
//解释：动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。
//示例 2：
//输入：nums = [1,1,1,1,1]
//输出：[1,2,3,4,5]
//解释：动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。
//示例 3：
//输入：nums = [3,1,2,10,1]
//输出：[3,4,6,16,17]

func runningSum(nums []int) []int {
  new := make([]int, len(nums))
  temp := 0
  for i, v := range nums {
    temp += v
    new[i] = temp
  }
  return new
}

//013. 剑指 Offer 64. 求1+2+…+n
//求 1+2+...+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
//示例 1：
//输入: n = 3
//输出: 6
//示例 2：
//输入: n = 9
//输出: 45

func sumNums(n int) int {
  result := 0
  for i := 1; i <= n; i++ {
    result += i
  }
  return result
}

//014. 数组拆分 I
//给定长度为 2n 的整数数组 nums ，你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，
//使得从 1 到 n 的 min(ai, bi) 总和最大。
//返回该 最大总和 。
//示例 1：
//输入：nums = [1,4,3,2]
//输出：4
//解释：所有可能的分法（忽略元素顺序）为：
//1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
//2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
//3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
//所以最大总和为 4
//示例 2：
//输入：nums = [6,2,6,5,1,2]
//输出：9
//解释：最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9

func arrayPairSum(nums []int) (numsSum int) {
  sort.Ints(nums)
  for i := 0; i < len(nums); i += 2 {
    numsSum += nums[i]
  }
  return
}

//015. 只出现一次的数字 III
//给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。
//找出只出现一次的那两个元素。你可以按 任意顺序 返回答案。
//进阶：你的算法应该具有线性时间复杂度。你能否仅使用常数空间复杂度来实现？
//示例 1：
//输入：nums = [1,2,1,3,2,5]
//输出：[3,5]
//解释：[5, 3] 也是有效的答案。
//示例 2：
//输入：nums = [-1,0]
//输出：[-1,0]
//示例 3：
//输入：nums = [0,1]
//输出：[1,0]

func singleNumber(nums []int) (result []int) {
  map1 := map[int]int{}
  for _, v := range nums {
    if map1[v] == 0 {
      map1[v] = 1
    } else {
      map1[v] += 1

    }
  }
  for i, v := range map1 {
    if v == 1 {
      result = append(result, i)
    }
  }
  return
}

//016. 回文数
//给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
//回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
//例如，121 是回文，而 123 不是。
//示例 1：
//输入：x = 121
//输出：true
//示例 2：
//输入：x = -121
//输出：false
//解释：从左向右读, 为 -121 。从右向左读, 为 121- 。因此它不是一个回文数。
//示例 3：
//输入：x = 10
//输出：false
//解释：从右向左读, 为 01 。因此它不是一个回文数。

func isPalindrome(x int) bool {
  //转string，正面读取和反面读取
  newString := strconv.Itoa(x)
  for i := 0; i < len(newString); i++ {
    if string(newString[i]) != string(newString[len(newString)-i-1]) {
      return false
    }
  }
  return true
}

//017. 统计位数为偶数的数字
//给你一个整数数组 nums，请你返回其中位数为 偶数 的数字的个数。
//示例 1：
//输入：nums = [12,345,2,6,7896]
//输出：2
//解释：
//12 是 2 位数字（位数为偶数） 
//345 是 3 位数字（位数为奇数）  
//2 是 1 位数字（位数为奇数） 
//6 是 1 位数字 位数为奇数） 
//7896 是 4 位数字（位数为偶数）  
//因此只有 12 和 7896 是位数为偶数的数字
//示例 2：
//输入：nums = [555,901,482,1771]
//输出：1
//解释：
//只有 1771 是位数为偶数的数字。

func findNumbers(nums []int) (temp int) {

  for _, v := range nums {
    newString := strconv.Itoa(v)
    if len(newString)%2 == 0 {
      temp += 1
    }
  }
  return
}

//018. 数组中两元素的最大乘积
//给你一个整数数组 nums，请你选择数组的两个不同下标 i 和 j，使 (nums[i]-1)*(nums[j]-1) 取得最大值。
//请你计算并返回该式的最大值。
//示例 1：
//输入：nums = [3,4,5,2]
//输出：12
//解释：如果选择下标 i=1 和 j=2（下标从 0 开始），则可以获得最大值，(nums[1]-1)*(nums[2]-1) = (4-1)*(5-1) = 3*4 = 12 。
//示例 2：
//输入：nums = [1,5,4,5]
//输出：16
//解释：选择下标 i=1 和 j=3（下标从 0 开始），则可以获得最大值 (5-1)*(5-1) = 16 。
//示例 3：
//输入：nums = [3,7]
//输出：12

func maxProduct(nums []int) (result int) {
  sort.Ints(nums)
  return (nums[len(nums)-1] - 1) * (nums[len(nums)-2] - 1)
}

//019. 找出数组中的幸运数
//在整数数组中，如果一个整数的出现频次和它的数值大小相等，我们就称这个整数为「幸运数」。
//给你一个整数数组 arr，请你从中找出并返回一个幸运数。
//如果数组中存在多个幸运数，只需返回 最大 的那个。
//如果数组中不含幸运数，则返回 -1 。
//示例 1：
//输入：arr = [2,2,3,4]
//输出：2
//解释：数组中唯一的幸运数是 2 ，因为数值 2 的出现频次也是 2 。
//示例 2：
//输入：arr = [1,2,2,3,3,3]
//输出：3
//解释：1、2 以及 3 都是幸运数，只需要返回其中最大的 3 。
//示例 3：
//输入：arr = [2,2,2,3,3]
//输出：-1
//解释：数组中不存在幸运数。
//示例 4：
//输入：arr = [5]
//输出：-1
//示例 5：
//输入：arr = [7,7,7,7,7,7,7]
//输出：7

func findLucky(arr []int) int {
  map1 := map[int]int{}
  for _, v := range arr {
    if map1[v] == 0 {
      map1[v] = 1
    } else {
      map1[v] += 1
    }
  }
  var temp = []int{}
  maxNum := 0
  for i, v := range map1 {
    if i == v {
      temp = append(temp, v)
    }
  }
  for _, v := range temp {
    if v >= maxNum {
      maxNum = v
    }
  }
  if maxNum == 0 {
    maxNum = -1
  }
  return maxNum
}

//020. 面试题 01.02. 判定是否互为字符重排
//给定两个字符串 s1 和 s2，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。
//示例 1：
//输入: s1 = "abc", s2 = "bca"
//输出: true
//示例 2：
//输入: s1 = "abc", s2 = "bad"
//输出: false

func CheckPermutation(s1 string, s2 string) bool {
  //s1,s2元素和次数。
  var m1 = make(map[string]int)
  var m2 = make(map[string]int)

  var result bool
  for _, v := range s1 {
    if m1[string(v)] == 0 {
      m1[string(v)] = 1
    } else {
      m1[string(v)] += 1
    }
  }

  for _, v := range s2 {
    if m2[string(v)] == 0 {
      m2[string(v)] = 1
    } else {
      m2[string(v)] += 1
    }
  }
  temp := 0
  for i, v := range m1 {
    if v == m2[i] {
      temp += 1
    }
  }

  if temp == len(m2) {
    result = true
  } else {
    result = false
  }

  return result
}
func main() {
  r011 := getConcatenation([]int{1, 2, 1})
  fmt.Println("r011:", r011) // r011: [1 2 1 1 2 1]

  r012 := runningSum([]int{1, 2, 3, 4})
  fmt.Println("r012:", r012) // r012: [1 3 6 10]

  r013 := sumNums(6)
  fmt.Println("r013:", r013) // r013: 21

  r014 := arrayPairSum([]int{6, 2, 6, 5, 1, 2})
  fmt.Println("r014:", r014) // r014: 9

  r015 := singleNumber([]int{6, 2, 6, 5, 1, 2})
  fmt.Println("r015:", r015) // r015: [5 1]

  r016 := isPalindrome(121121)
  fmt.Println("r016:", r016) // r016: true

  r017 := findNumbers([]int{12, 345, 2, 6, 7896})
  fmt.Println("r017:", r017) // r017: 2

  r018 := maxProduct([]int{12, 345, 2, 6, 7896})
  fmt.Println("r018:", r018) // r018: 2715880

  r019 := findLucky([]int{1, 2, 2, 3, 3, 3})
  fmt.Println("r019:", r019) // r019: 3

  r020 := CheckPermutation("abc", "bca")
  fmt.Println("r020:", r020) // r020: true
}

微信公众号：玩转测试开发
欢迎关注，共同进步，谢谢！