Nicksxs's Blog

public enum Env{
  LOCAL, DEV, FWS, FAT, UAT, LPT, PRO, TOOLS, UNKNOWN;

  public static Env fromString(String env) {
    Env environment = EnvUtils.transformEnv(env);
    Preconditions.checkArgument(environment != UNKNOWN, String.format("Env %s is invalid", env));
    return environment;
  }
}

/**
 * Here is the brief description for all the predefined environments:
 * <ul>
 *   <li>LOCAL: Local Development environment, assume you are working at the beach with no network access</li>
 *   <li>DEV: Development environment</li>
 *   <li>FWS: Feature Web Service Test environment</li>
 *   <li>FAT: Feature Acceptance Test environment</li>
 *   <li>UAT: User Acceptance Test environment</li>
 *   <li>LPT: Load and Performance Test environment</li>
 *   <li>PRO: Production environment</li>
 *   <li>TOOLS: Tooling environment, a special area in production environment which allows
 * access to test environment, e.g. Apollo Portal should be deployed in tools environment</li>
 * </ul>
 */

Env apolloEnv = ApolloInjector.getInstance(ConfigUtil.class).getApolloEnv();

public int[][] spiralMatrixIII(int rows, int cols, int rStart, int cStart) {
        int size = rows * cols;
        int x = rStart, y = cStart;
        // 返回的二维矩阵
        int[][] matrix = new int[size][2];
        // 传入的参数就是入口第一个
        matrix[0][0] = rStart;
        matrix[0][1] = cStart;
        // 作为数量
        int z = 1;
        // 步进，1，1，2，2，3，3，4 ... 螺旋矩阵的增长
        int a = 1;
        // 方向 1 表示右，2 表示下，3 表示左，4 表示上
        int dir = 1;
        while (z < size) {
            for (int i = 0; i < 2; i++) {
                for (int j= 0; j < a; j++) {
                    // 处理方向
                    if (dir % 4 == 1) {
                        y++;
                    } else if (dir % 4 == 2) {
                        x++;
                    } else if (dir % 4 == 3) {
                        y--;
                    } else {
                        x--;
                    }
                    // 如果在实际矩阵内
                    if (x < rows && y < cols && x >= 0 && y >= 0) {
                        matrix[z][0] = x;
                        matrix[z][1] = y;
                        z++;
                    }
                }
                // 转变方向
                dir++;
            }
            // 步进++
            a++;
        }
        return matrix;
    }

public int firstBadVersion(int n) {
    // 类似于双指针法
    int left = 1, right = n, mid;
    while (left < right) {
        // 取中点
        mid = left + (right - left) / 2;
        // 如果不是错误版本，就往右找
        if (!isBadVersion(mid)) {
            left = mid + 1;
        } else {
        // 如果是的话就往左查找
            right = mid;
        }
    }
    // 这里考虑交界情况是，在上面循环中如果 left 是好的，right 是坏的，那进入循环的时候 mid == left
    // 然后 left = mid + 1 就会等于 right，循环条件就跳出了，此时 left 就是那个起始的错误点了
    // 其实这两个是同一个值
    return left;
}

public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        // 当前最近的和
        int closestSum = nums[0] + nums[1] + nums[nums.length - 1];
        for (int i = 0; i < nums.length - 2; i++) {
            if (i == 0 || nums[i] != nums[i - 1]) {
                // 左指针
                int left = i + 1;
                // 右指针
                int right = nums.length - 1;
                // 判断是否遍历完了
                while (left < right) {
                    // 当前的和
                    int sum = nums[i] + nums[left] + nums[right];
                    // 小优化，相等就略过了
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    while (left < right && nums[right] == nums[right - 1]) {
                        right--;
                    }
                    // 这里判断，其实也还是希望趋近目标值
                    if (sum < target) {
                        left++;
                    } else {
                        right--;
                    }
                    // 判断是否需要替换
                    if (Math.abs(sum - target) < Math.abs(closestSum - target)) {
                        closestSum = sum;
                    }
                }
            }
        }
        return closestSum;
    }