访问这个链接看效果: https://xtea.io/ts.html
其实原理很简单，基于google提供的自定义搜索 cse.google.com.
创建步骤如下：
- 在搜索的网站输入
t.me电报群组的网站。 - 给搜索引擎定义一个名字，如：电报搜索。
- 点击
创建按钮. - 创建成功了，点击
公开地址就可以访问了.
大功告成，试试效果吧。
首先要时刻铭记，学习的目的就是为了在实践中应用，要带着问题和目的去学习，而不是为了学习而学习。
根据我的经验，最好的学习路径应该是： 学习 -> 实践 -> 遇到问题 -> 学习 -> 实践 …
一台安装了Xcode的Mac电脑。
老规矩，先从hellow world程序开始。
var myString = "Hello, World!"
print(myString)
看起来，语言还是比较简洁讨人喜欢的。参数使用的var，和JS一样。而打印方法和python 3是一样的。
重点的是我们了解到，swift语言是不强制使用分号结尾的。
定义变量
直接关键字 var，无需关注数据类型可以直接赋值，和js看起来是一样的。
var msg = "\n hello world \n"
var num = 1984 // 数字
var float_num = 1999.0 // 浮点数字
var flag = true // 布尔类型
// 可变类型，重复赋值
num = 1997
float_num = 2012.01
使用关键字 let 来定义常量，效果通Java中的 final。
值得注意的是，虽然swift看起来像解释性语言一样方便，但是实际上他还是强类型的语言。可以强制定义其数据的类型。
var msg:String = "\n hello world \n"
var num:Int = 1984 // 数字
var float_num:Float = 1999.0 // 浮点数字
var flag:Bool = true // 布尔类型
数组
创建数组方式一，以下实例创建了一个类型为 Int ，数量为 3，初始值为 0 的空数组：
var someInts = [Int](repeating: 0, count: 3)
创建数组方式二：
var someInts:[Int] = [10, 20, 30]
可以直接使用下标访问数组，下标从0开始。新增元素可以用使用append方法或者直接 +=
var someInts = [Int]()
someInts.append(20) // 添加 20
someInts.append(30) // 添加 30
someInts += [40] // 添加 40
数组的长度使用 count 属性; isEmpty来判断是否为空数组。
字符串
掌握字符串的处理是入门一个开发语言的基本操作，因此要重点学习下字符串处理相关的方法。
var greeting = "Hi"
var name = "jack"
var msg = greeting + " " + name
print(msg) // Hi jack
var msg2 = "\(greeting) \(name)"
print(msg2) // Hi jack
print(msg == msg2) // true
格式化字符串和数字时候直接使用 “(parm)”来替代既可以，非常方便。
属性count和isEmpty在字符串处理同样适用。
关于nil
代表空的指针，和java中的null、python中的None相同。
运算符
包含多种运算符，例如：算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符及其他运算符。基本与其它高级语言无区别，再此不做多余记录。
注意：swift3 中已经取消了++、–。
注释
//这是一行注释
/* 这也是一条注释，
但跨越多行 */
程序的3中结构：顺序、选择和循环。下面看一下如果来处理选择和循环。
选择
不需要括号包含布尔表达式, 其它与Java相同。
if boolean_expression {
/* 如果布尔表达式为真将执行的语句 */
}
var a = 1
// && = 与 ， || = 或
if a < 10 {
print("a 小于 10")
}
循环
循环数组
var someStrs = [String]()
someStrs.append("Apple")
someStrs.append("Amazon")
someStrs.append("Runoob")
someStrs += ["Google"]
// 仅元素
for item in someStrs {
print(item)
}
// 元素与下标
for (index, item) in someStrs.enumerated() {
print("在 index = \(index) 位置上的值为 \(item)")
}
循环字符串
for ch in "Runoob" {
print(ch)
}
其余与其它语言无异同。
数组刚才已经提到了，下面讲解下字典（对应Java里的Hash table)
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someVar = someDict[1] // 访问字典元素
someDict.updateValue("One 新的值", forKey: 1) // 修改字典元素
var removedValue = someDict.removeValue(forKey: 2) // 删除字典元素
// 遍历字典
for (key, value) in someDict {
print("字典 key \(key) - 字典 value \(value)")
}
let dictKeys = [Int](someDict.keys) // 所有的key
let dictValues = [String](someDict.values) // 所有的value
print("输出字典的键(key)")
print("输出字典的值(value)")
访问这个链接看效果: https://xtea.io/ts.html
其实原理很简单，基于google提供的自定义搜索 cse.google.com.
创建步骤如下：
t.me 电报群组的网站。创建按钮.公开地址 就可以访问了.大功告成，试试效果吧。
1.不要迟到
迟到的行为非常恶劣，会给人第一印象非常差。另外迟到会让应聘者非常慌张，不利于面试发挥。总之，宁可取消面试也千万不要迟到。
2.要闷头做题
对于工程师的面试总要一项就是写代码，但是千万不要拿到一个题立刻开始写代码，这个情况基本就是Fail了，不管是否写的正确。
原因是你缺少有效沟通，看到一道题要先和面试官确定理解是否正确，输入值的范围(正数/负数) 、是否有序等、是否可以用方法A，时间复杂度的要求、空间复杂度的要求。这些问题都需要逐一的澄清才能往后做。沟通是很重要的技能，这将决定你今后的职业生涯的高度。
3.不要自High
大多数同学基于一个面试官的问题，迫切的希望引入到自己的领地，把准备的面经快速的讲出来。但是没有抓住重点，也许面试官想问的根本不是这个问题。所以保持一个良好的问题澄清习惯，回答之前先确定是否是你心中的问题，然后在进一步回答。
Btw，现在的应届生都很厉害，技术都在伯仲之间。但是还是要做出一些差异性，比如有自己的开源项目是很加分的。
]]>使用BFS的拓扑排序.
class Solution {
public String alienOrder(String[] words) {
if (words == null || words.length == 0) {
return "";
}
// init nodes.
int[] indegree = new int[256];
Arrays.fill(indegree, -1);
Set<Character>[] edges = new Set[256];
build(words, indegree, edges);
// start bfs.
Queue<Character> queue = new LinkedList();
Set<Character> hset = new HashSet();
for (char root : findRoots(indegree)) {
queue.offer(root);
hset.add(root);
}
String ans = "";
if (queue.size() == 0) {
return ans;
}
while (queue.size() > 0) {
char node = queue.poll();
ans += node;
for (char next : edges[node]) {
indegree[next]--;
if (indegree[next] == 0) {
if (hset.contains(next)) {
continue;
}
queue.offer(next);
hset.add(next);
}
}
}
int charCount = 0;
for (int i = 0; i < 256; i++) {
if (edges[i] != null) {
charCount++;
}
}
if (ans.length() != charCount) {
return "";
}
return ans;
}
public void build(String[] words, int[] indegree, Set<Character>[] edges) {
// init
for (String word : words) {
for (char ch : word.toCharArray()) {
if (edges[ch] == null) {
indegree[ch] = 0;
edges[ch] = new HashSet<Character>();
}
}
}
for (int i = 0; i < words.length; i++) {
for (int j = i + 1; j < words.length; j++) {
int index = findFirstNonEquals(words[i], words[j]);
if (index == -1) {
continue;
}
char from = words[i].charAt(index);
char to = words[j].charAt(index);
// build edges.
if (from != to && !edges[from].contains(to)) {
edges[from].add(to);
indegree[to]++;
}
}
}
}
public int findFirstNonEquals(String a, String b) {
int i = 0;
while (i < a.length() && i < b.length()) {
if (a.charAt(i) == b.charAt(i)) {
i++;
} else {
return i;
}
}
return -1;
}
public List<Character> findRoots(int[] indegree) {
List<Character> roots = new ArrayList();
for (int i = 0; i < 256; i++) {
if (indegree[i] == 0) {
roots.add((char) i);
}
}
return roots;
}
}
这个题可以用DFS、BFS或者使用Dijkstra算法，以下是我使用Dijkstra实现。
public class Maze2 {
class Point implements Comparator<Point> {
int x, y;
int distance;
public Point() {
}
public Point(int x, int y, int distance) {
this.x = x;
this.y = y;
this.distance = distance;
}
@Override
public int compare(Point o1, Point o2) {
return o1.distance - o2.distance;
}
}
public int shortestDistance(int[][] maze, int[] start, int[] destination) {
if (maze == null || maze.length == 0) {
return -1;
}
int m = maze.length;
int n = maze[0].length;
// distanceTo from start to current point.
int[][] distance = initDistance(m, n, start);
PriorityQueue<Point> priorityQueue = new PriorityQueue<>(new Point());
// put start to heap.
priorityQueue.offer(new Point(start[0], start[1], 0));
// start bfs.
while (priorityQueue.size() > 0) {
Point point = priorityQueue.poll();
List<Point> nextPoints = findNextPoints(point, maze);
for (Point np : nextPoints) {
if (np.distance < distance[np.x][np.y]) {
distance[np.x][np.y] = np.distance;
// put to heap and mark visited.
priorityQueue.offer(np);
}
}
}
// shortest distanceTo from start to destination
int ans = distance[destination[0]][destination[1]];
return ans == Integer.MAX_VALUE ? -1 : ans;
}
private int[][] initDistance(int m, int n, int[] start) {
int[][] ans = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
ans[i][j] = Integer.MAX_VALUE;
}
}
ans[start[0]][start[1]] = 0;
return ans;
}
private List<Point> findNextPoints(Point point, int[][] maze) {
int[][] directions = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
List<Point> ans = new ArrayList<>();
// go four directions.
for (int i = 0; i < directions.length; i++) {
int nx = point.x;
int ny = point.y;
int step = 0;
// move until next is wall.
while (canMove(nx + directions[i][0], ny + directions[i][1], maze)) {
nx += directions[i][0];
ny += directions[i][1];
step++;
}
Point np = new Point(nx, ny, point.distance + step);
ans.add(np);
}
return ans;
}
public boolean canMove(int x, int y, int[][] maze) {
int r = maze.length;
int c = maze[0].length;
if (x < 0 || x >= r || y < 0 || y >= c) {
return false;
}
return maze[x][y] == 0;
}
}
今天刷了这个题，被饶了很久，原因把 visted 和 wall 这2种情况混淆了。特此留念！
class Solution {
int[][] directions = {
{1, 0}, {-1, 0}, {0, 1}, {0, -1}
};
public boolean hasPath(int[][] maze, int[] start, int[] destination) {
boolean[][] visited = new boolean[maze.length][maze[0].length];
return helper(maze, start, destination, visited);
}
public boolean helper(int[][] maze, int[] start, int[] destination, boolean[][] visited) {
int x = start[0];
int y = start[1];
if (!canMove(x, y, maze)) {
return false;
}
visited[x][y] = true;
for (int i = 0; i < directions.length; i++) {
int nx = x;
int ny = y;
// move until next is wall.
while (canMove(nx + directions[i][0], ny + directions[i][1], maze)) {
nx += directions[i][0];
ny += directions[i][1];
}
// check if visited.
if (visited[nx][ny]) {
continue;
}
// check if find destination
if (nx == destination[0] && ny == destination[1]) {
return true;
}
// recursion with new start.
if (helper(maze, new int[]{nx, ny}, destination, visited)) {
return true;
}
}
return false;
}
public boolean canMove(int x, int y, int[][] maze) {
int r = maze.length;
int c = maze[0].length;
if (x < 0 || x >= r || y < 0 || y >= c) {
return false;
}
if (maze[x][y] == 1) {
return false;
}
return true;
}
}
总体的思路：分治， 每三个数字当成一组处理，这样方便增加单位。
有很多细节需要考虑，比如0的时候，另外：11 - 19 这个范围需要特殊处理。
PS: 说实话，如果面试遇到这类问题并且之前没有做过，那就等着跪吧。
class Solution {
private String[] oneMap = {"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
private String[] n10Map = {"Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
private String[] n20Map = {"Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};
public String numberToWords(int num) {
if (num == 0) {
return "Zero";
}
List<String> ans = new ArrayList();
String[] units = {"Thousand", "Million", "Billion"};
int unitIndex = -1;
while (num > 0) {
if (num % 1000 != 0) {
String nums = toWords(num % 1000);
if (unitIndex >= 0) {
ans.add(units[unitIndex]);
}
ans.add(nums);
}
num /= 1000;
unitIndex++;
}
return toResultString(ans);
}
public String toWords(int num) {
String snum = String.valueOf(num);
if (snum.length() == 1) {
return oneNumber(num);
} else if (snum.length() == 2) {
return twoNumber(num);
} else {
int kOfNum = snum.charAt(0) - '0';
String ans = oneNumber(kOfNum);
if (ans.length() > 0) {
ans += " Hundred";
}
String tw = twoNumber(Integer.parseInt(snum.substring(1)));
return tw.length() == 0 ? ans : ans + " " + tw;
}
}
public String oneNumber(int n) {
if (n == 0) {
return "";
}
return oneMap[n - 1];
}
public String twoNumber(int n) {
if (n == 0) {
return "";
}
if (n < 10) {
return oneNumber(n);
}
if (n < 20) {
return n10Map[n - 10];
}
String ans = n20Map[n / 10 - 2];
String last = oneNumber(n % 10);
if (last.length() > 0) {
return ans + " " + last;
}
return ans;
}
private String toResultString(List<String> ans) {
StringBuffer sb = new StringBuffer();
for (int i = ans.size() - 1; i >= 0; i--) {
sb.append(ans.get(i) + " ");
}
return sb.toString().trim();
}
}
在给定一个数组中，存在0 - k个peak节点(值大于左右2个邻居的), 目标是将旗子放到peak的位置，并且两个peak的距离(下标差)必须大于等于总旗子数量。
先从简单的方案入手，要想知道最多能插入旗子的数量，总共需要2个步骤：
这个过程可以用以下伪代码来代替，但是注意这只是第一步，还没到正式开始写代码的阶段。
public int solution(int[] A) {
List<Integer> peaks = getAllPeaks(A);
int ans = 0;
for (int i = 1; i < peak.size(); i ++) {
if (canPutFlags(peaks, i)) {
ans = i;
}else{
break;
}
}
return ans;
}
其中canPutFlags方法可以依次遍历全有的peak, 判断具体是否满足，如果满足则可以放入旗子。最后判断放入的总旗子是否满足条件。
时间复杂度: O(N) + O(N) * O(N) = O(N^2)
整个程序瓶颈在于第二阶段，寻找最大旗子的过程。那么我们看下是否能够优化呢？
尝试寻找规律，如果存在满足条件旗子数为K，那么K - 1 也一定满足。因此可以使用二分法来减少每次搜索的数量。
尝试从中间位置 MID = PEAK_SIZE / 2，分为2种情况：
现在我们的代码变成：
public int solution(int[] A) {
List<Integer> peaks = getAllPeaks(A);
return binarySearch(peaks, 1, peaks.size());;
}
时间复杂度: O(N) + O(N) * O(N * log(N)) = O(N * log(N))
总体的复杂度下降了一个量级，下面开始真正写代码.
一般来说我们最好将代码按照模块化的方式拆分成若干函数，这样做虽然代码量变多，但是好处多多。
PS：面试时间不够，可以抓大放小，简单的方法和面试官说一下思路。
// you can also use imports, for example:
import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
// write your code in Java SE 8
if (A == null || A.length == 0) {
return 0;
}
// 1. find all peaks.
List<Integer> peaks = getAllPeaks(A);
// find max flags, range from 1 - k
// 2. binary search.
return binarySearch(peaks);
}
private List<Integer> getAllPeaks(int[] A) {
List<Integer> peaks = new ArrayList();
for (int i = 1; i < A.length - 1; i++) {
if (A[i] > A[i + 1] && A[i] > A[i - 1]) {
peaks.add(i);
}
}
return peaks;
}
private Integer binarySearch(List<Integer> peaks) {
int begin = 1, end = peaks.size();
while (begin + 1 < end) {
int mid = begin + (end - begin) / 2;
if (canPutFlags(peaks, mid)) {
begin = mid;
} else {
end = mid;
}
}
if (canPutFlags(peaks, end)) {
return end;
}
if (canPutFlags(peaks, begin)) {
return begin;
}
return 0;
}
public boolean canPutFlags(List<Integer> peaks, int flags) {
if (peaks.size() == 0) {
return false;
}
int lastIndex = peaks.get(0);
int usedFlags = 1;
for (int p = 1; p < peaks.size(); p++) {
int pIndex = peaks.get(p);
if (pIndex - lastIndex >= flags) {
usedFlags++;
lastIndex = pIndex;
}
if (usedFlags == flags) {
return true;
}
}
// ensure only one peek.
return usedFlags == flags;
}
}
设计一些极端的case，避免产生corner case，例如：
结果查看： https://app.codility.com/demo/results/trainingKNHF4F-8UV/
]]>主要还是专注在技术领域，如果能够帮助别人那更是再好不过。
世界很美好，加油吧！
]]>