preface

Here’s a breakdown of the interview questions, some of which are personal, some of which refer to other people’s opinions, and some of which refer directly to other people’s articles. The answers given in this article are just a primer. If you want to explore further, you need to understand in detail through other channels. Due to my limited knowledge, the answer is not enough or wrong. Also hope you pointed out that small white must actively correct, erratum.

Interview Questions

Work related

Q1: Introduce the business architecture and technical architecture of the system. This is a necessary problem, so you need to prepare the difficulties in the project and your own solutions in advance. It is best if you have encountered and solved it yourself, or if you have not encountered it yourself, then it is ok to integrate the difficulties solved by others in the project. To sum up: to have a bright spot, and oneself is in-depth thinking and in-depth understanding.

Q2: The service RT increases suddenly and then recovers. How do I locate the service

1. The interface may time out due to network jitter
2. The gc effects

Java article

Java based

Q1: The difference between Java environment variables CLASspath and PATH

1. Path environment variable: The system is used to specify the full path of the executable file. JAVA files can be executed even if the JDK path is not set in path, but the full path must be written out
2. Classpath environment variable: The path to the Java lookup class

Q2: The difference between overwriting and overloading. Can constructors be overridden

class Person {
    String name;
    public Person(a) {}
    public Person(String name) {this.name = name; }public void talk(a) {System.out.println("person talk");}
}
class Student extends Person {
    String stuNumber;
    public Student(a) {}
    public Student(String name, String stuNumber) {
        super(name);
        this.stuNumber = stuNumber;
    }
    @Override
    public void talk(a) {System.out.println("student talk");}
}
Copy the code

Overrides: Subclasses override methods of their parent class that require inheritance. The @override annotation is generally used, but it doesn’t matter if it’s not. The Student class overrides the Talk method of the Person class.

Overload: the function name is the same, but the number of arguments is different or the parameter type is different. Note that methods that return different values are not overloaded. The constructor is overloaded by the number of arguments in the code above.

Constructors cannot be overridden because overrides require consistent method names. The constructor’s method name is the class name. Subclasses cannot have the same name as their parent, so they cannot have the same constructor. So constructors cannot be overridden, but they can be overridden.

Q3: Introduces some common Java tool commands

The command	instructions
jps	Vm process status tool, which lists VM processes
jstat	Vm statistics monitoring tool to monitor THE running status of VMS
jinfo	Java configuration information tool
jmap	Generates a heap dump snapshot

A collection of

Q1: Implementation principle of HashMap

See: Java HashMap working principle and implementation

Q2: Why is HashMap thread unsafe

See: Why isn’t HashMap thread safe?

Q3: How is currentHashMap thread-safe

See: High Concurrency Programming Series: Implementation principles of ConcurrentHashMap (JDK1.7 and JDK1.8)

Q4: What are Java containers? Which containers are synchronous and which are concurrent?

See the Java Synchronous container and concurrent Container for details

Java containers include Map, List, and Set

Synchronization containers in Java fall into two classes:

1. Vector/Stack/HashTable, whose methods are all synchronous methods, usessynchronizedmodified
2. The Collections class provides static factory methods to create the class (such as by Collections. SynchronizedXxxx method)

Concurrent containers in Java: The JAVa.util.concurrent package (or JUC) in the JDK provides several very useful concurrent containers.

1. CopyOnWriteArrayList – Thread-safe ArrayList
2. CopyOnWriteArraySet – a thread-safe Set that contains a CopyOnWriteArrayList inside, so is essentially implemented by CopyOnWriteArrayList.
3. ConcurrentSkipListSet – the thread-safe equivalent of TreeSet. It’s an ordered Set. It is implemented by ConcurrentSkipListMap.
4. ConcurrentHashMap – Thread-safe HashMap. Use segmenting lock to realize efficient concurrency.
5. ConcurrentSkipListMap – Thread-safe ordered Map. Efficient concurrency with hop tables.
6. ConcurrentLinkedQueue – Thread-safe unbounded queue. Single linked lists are used at the bottom. Support FIFO.
7. ConcurrentLinkedDeque – Thread-safe unbounded two-ended queue. The bottom layer uses bidirectional linked lists. Support FIFO and FILO.
8. ArrayBlockingQueue – A blocking queue for an array implementation.
9. LinkedBlockingQueue – Block queue for list implementation.
10. LinkedBlockingDeque – A two-way list implementation of a two-ended blocking queue.

thread

Q1: How do I make thread A execute after thread B

1. CountDownLatch. The thread Alatch.await(), thread Blatch.countDown()
2. Wait () and notify (). There may be thread Bnotify()Execute first, causing thread A to remain blocked

Q2: Understanding and application scenarios of ThreadLocal

See: ThreadLocal in Java for details

The Thread class contains two variables, threadLocals and inheritableThreadLocals, both of type ThreadLocalMap.

Why does Thread use map instead of a single value store (T value), which is shared by multiple threads? ThreadLocal is designed to solve this problem

Considerations for using ThreadLocal: The Entry key in a ThreadLocalMap uses a weak reference to the ThreadLocal object. If there is no other dependency on ThreadLoca, the ThreadLocal object in a ThreadLocalMap will be reclaimed. However, the corresponding value will not be reclaimed. In this case, there may be items whose key is null but value is not null in the Map. In practice, the remove method should be invoked to avoid memory leakage.

Q3: What are the states of a thread’s life cycle? How do they flow from one to the other

Please refer to: Java multithreading learning (iii)- the life cycle of threads

Q4: Thread pool submission process

Q5: The task queue in the thread pool is full. How to handle this problem

• AbortPolicy: direct throw RejectedExecutionException anomalies. Is the default processing strategy for the default thread pool in Executors
• DiscardPolicy: do nothing
• DiscardOldestPolicy: Discards the oldest task and executes a new one
• CallerRunsPolicy: Call thread execution

Q6: A thread-safe way

• Automic: Uses the supplied atomic class
• Syntronized: Synchronizes code blocks
• Lock: lock
• Volatile: Ensures visibility

Q7: two threads alternately print the contents of two arrays

public class Test1 {
    public static void main(String[] args) {
    	int[] nums1 = {1.3.5.7.9};
    	int[] nums2 = {2.4.6.8.10};
    	Object obj = new Object();
    
    	Thread t1 = new Thread(() -> {
    		synchronized (obj) {
    			for (int n : nums1) {
    				System.out.print(n + "\t");
    				try {
    					obj.notifyAll();
    					obj.wait();
    				} catch (Exception e) {
    
    				}
    			}
    		}
    	});
    
    	Thread t2 = new Thread(() -> {
    		synchronized (obj) {
    			for (int n : nums2) {
    				System.out.print(n + "\t");
    				try {
    				    obj.notifyAll();
    					obj.wait();
    				} catch(Exception e) { } } } }); t1.start(); t2.start(); }}Copy the code

The lock

Q1: Is the lock of a synchronized method class or object? Synchronized code blocks are passed in as locks.

Q2: Synchronized is A reentrant lock. Q2: Synchronized is A reentrant lock

Q3: Differences between Synchonized and ReentrantLock

1. synchonizedIs a Java keyword;ReentrantLockIs the class
2. synchonizedUnfair lock;ReentrantLockThe default is unfair lock, but there are two ways to implement fair lock and unfair lock.
3. synchonizedCan be used in synchronized code blocks, synchronized methods;ReentrantLockThe use oflock()andunlock()

The same

1. Both are reentrant locks
2. Both are synchronous blocking modes

Q4: What are live locks, starvation, no locks, deadlocks? How do I check if a thread has a lock

Deadlock: A situation in which two or more processes (or threads) are waiting for each other to execute because they are competing for resources and cannot proceed without external forces. The system is said to be in a deadlock state or a deadlock occurs in the system. These processes that are always waiting for each other are called deadlocked processes.

Deadlock conditions:

1. Mutually exclusive: Thread access to a resource is exclusive. If one thread pair occupies a resource, the other threads must wait until the resource is released.

2. Request and hold: Thread T1 has held at least one resource, R1, but makes a request for another resource, R2, which is occupied by another thread, T2. Therefore, thread T1 must also wait, but does not release its held resource, R1.

3. Inalienable: A resource acquired by a thread cannot be stripped by another thread before it is used up. It can only be released after it is used up.

4. Loop waiting for

A live lock is when thread 1 is allowed to use the resource, but it politely lets other threads use the resource first. Thread 2 is also allowed to use the resource, but it is polite enough to let other threads use the resource first. So you make me, I make you, the last two threads can’t use the resource.

For example, there was A small bridge in the middle of the road, which could only accommodate one car. Two cars, A and B, came from both ends of the bridge. A was more polite and suggested that B should go first, while B was also more polite and suggested that A should go first.

Hunger means that if thread T1 occupies resource R, thread T2 requests to block R, and then T2 waits. T3 also requests resource R, and when T1 releases the blockade on R, the system first approves T3’s request, while T2 still waits. T4 then requests to block R, and when T3 releases the block on R, the system approves T4’s request…… T2 may wait forever.

Unfair locking improves throughput but inevitably leads to starvation in some threads, or in low-priority threads

No lock: No lock, that is, no resource is locked. That is, all threads can access and modify the same resource, but only one thread can modify the resource successfully. The typical feature of lockless is that each modification operation is performed within a loop, and the thread will attempt to modify the shared resource repeatedly. If there are no conflicts, the modification succeeds and exits, otherwise the next loop attempt will continue. Therefore, if multiple threads modify the same value, one thread will succeed, and the others will try again and again until the modification succeeds. CAS principle and application is the realization of no lock.

Thread. HoldsLock (Object OBj) : Returns true if and only if the current Thread has an OBJ lock. This method use case asserts whether the current thread holds the lock. assert Thread.holdsLock(obj);

Q5: Synchronization implementation principle reference: In-depth analysis of the principle of synchronization

Q6: Pessimistic locking, optimistic locking example in Java

• Exclusive locks such as synchronized and ReentrantLock in Java are implementations of the pessimistic locking idea.
• Java. Util. Concurrent. Atomic package this atomic variable classes is to use the optimistic locking a way of implementation of CAS

jvm

Q1: Introduce some of the JVM parameters you know

parameter	instructions	note
-Xms	Minimum heap size	Generally, -xms and -xmx have the same size to avoid memory expansion
-Xmx	Maximum heap size	Generally, -xms and -xmx have the same size to avoid memory expansion
-Xmn	Young generation size	There are 1 Eden and 2 Survivor. The default ratio is 8:1
-XX:SurvivorRatio	Ratio of Eden to Survivor	The default 8:1
-XX:PermSize	Permanent generation size	-xx :PermSize and -xx :MaxPermSize must be the same size to avoid automatic expansion at runtime
-XX:MaxPermSize	Maximum permanent band	-xx :PermSize Must be the same as -xx :MaxPermSize
-XX:+UserConcMarkSweepGC	Using the CMS collector

Q2: Why does Java adopt garbage collection rather than C/C++ explicit memory management

In C++, the memory occupied by an object is held until the program finishes running and cannot be allocated to other objects until it is explicitly freed. In Java, when there is no object reference to the memory originally allocated to an object, that memory becomes garbage. Garbage collection automatically frees memory, reducing the programming burden, and one of the JVM’s system-level threads automatically frees that chunk of memory. Release unwanted memory to avoid memory leaks

Java disallows the display of memory collection, the JVM determines the timing of collection, and avoids the problem of developers forgetting to free memory

Q3: JVM memory model

Q4: JVM memory allocation strategy

1. Objects are allocated first in Eden. When Eden does not have enough space to allocate objects, the virtual machine initiates a Minor GC. All virtual machine objects cannot be placed into Survivor space during garbage collection and are moved to the old age through allocation guarantee mechanism.
2. Big object goes straight to the old age
3. If a long-term object enters the old age, you can run -xx: MaxTenuringThreshold to set the age
4. Dynamic object age determination. The HotSpot virtual machine does not always require objects to be -xx in order to better accommodate the memory conditions of different applications: MaxTenuringThreshold can be promoted to the old age. If the total size of all objects of the same age in Survivor space is greater than half of Survivor space, objects older than or equal to this age can directly enter the old age without waiting until -xx: MaxTenuringThreshold Specifies the required age

Q5: What are the garbage collection algorithms

• Mark-clear: Memory fragmentation occurs
• Mark-copy: The young generation uses this algorithm for garbage collection
• Mark-tidy: Move all surviving objects towards one end of the memory space, increasing latency

Class loading

This article is all you need to read about class loaders. In-depth understanding of Java class loading mechanisms. But there is an error at the end of this article: in the picture below, the value of counter2=1 should be counter2=0

Q1: Difference between classLoader and class.forname ()

Both class.forname () and classLoader can be used in Java to load classes. In addition to loading the class’s.class file into the JVM, class.forname () interprets the class and executes its static block. The classLoader only does one thing: it loads a. Class file into the JVM. It does not execute static blocks, only newInstance. Class. ForName (name, initialize, loader) functions with parameters can also control whether static blocks are loaded. And only the newInstance() method is invoked to create objects of the class using the call constructor

MySQL article

Q1: What index types does MySQL have

1. The only index
2. The full text indexing
3. Joint index
4. Normal index

Q2: Why InnoDB uses B+ tree index structure

Please refer to Tencent technical engineering article: In-depth understanding of the underlying principles of Mysql indexing.

Q3: Introduces clustered indexes, non-clustered indexes, and index coverage

See article: mysql clustered index and non-clustered Index

Q4: How to improve SQL performance, SQL optimization experience in work

Improving SQL performance I think it’s important to let MySQL choose the right index.

At work, Xiao Bai has optimized SQL in the system. It is mainly reflected in the following aspects (this is only white in the work encountered, with you encountered should have different oh) :

1. MySQL failed to select an index
2. Field type error caused index missing
3. An SQL statement that could have been overwritten by an index was checked back to the table

Q5: MySQL database isolation level

See: Mysql database isolation level

The Spring piece

Q1: Introduce Spring IOC and AOP

See: An in-depth understanding of Spring’s two main features: IoC and AOP

IOC: Inversion of control. Before IOC, when object A depended on object B, A needed to create an instance of B through new, and the control was on object A. IOC is about handing control of an object to the IOC container.

AOP: Faceted programming (AOP) is vertical programming. For example, business A and business B now need the same operation. In the traditional way, we might add the relevant operation code to both A and B. With AOP, we can write the code once, and both A and B share the same code. In addition, when A and B need to add new operations, they can flexibly add new business logic without changing the original code. AOP is mainly used in signature verification, parameter verification, logging, transaction control, authority control, performance statistics, exception processing and so on

Q2: How is AOP implemented

Spring implements AOP through dynamic proxies.

See: From proxy mechanisms to Spring AOP

Q3: How does Spring implement transaction management

Please refer to: Probably the most beautiful Spring transaction management detail

Q4: Spring transaction propagation mechanism

See: Spring transaction propagation behavior for details

Q5: Spring Bean life cycle

Consider: Please stop asking about the life cycle of Spring Beans!

Redis article

Q1: How does Redis implement distributed lock

This is implemented using setnx key Value and the expire key is used to set the timeout.

The problem with this approach is that since these two steps are not a transaction, it is possible to fail to set the timeout. If the timeout period fails to be set, the key will never expire, occupying the memory.

Solution:

1. You can write your own Lua script to make this an atomic operation
2. Redis providesSET key value [EX seconds] [PX milliseconds] [NX|XX]

Q2: Redis supports several data structures

String, List, Set, Zset, Map, GEO, Bitmap

Q3: Low-level implementation of string data structures

The string base of Redis is implemented by SDS simple dynamic strings.

features

1. Space preallocation: When a string is modified and space expansion is required, it can be divided into the following two situations:
   1. If the space is less than 1 MB after expansion, preallocate the same size as the used space (the used space contains the string after expansion).
   2. If the space is larger than 1 MB after expansion, 1 MB is allocated
2. Lazy release: To avoid the problem of releasing and then expanding, Redis adopts the lazy release policy, usingfreeField to record unused length, waiting to be used. It also provides apis to free up space when needed.

Q4: Map data structure underlying implementation

Redis dictionary uses hash table as the underlying implementation, a hash table can have multiple hash table nodes, and each hash table node stores a key value pair in the dictionary.

The dictionary data structure is an array of two hash tables. Used during capacity expansion.

Redis’s hash algorithm uses the MurmurHash2 algorithm.

Q5: Redis expiration key deletion policy

Scheduled deletion: When you set the expiration time of a key, create a timer to delete the key immediately when the expiration time of the key comes. Advantages: Memory friendly and can release memory in real time disadvantages: CPU unfriendly and occupies a large amount of CPU to delete expired keys

Lazy deletion: the key is left to expire, but each time a key is retrieved from the key space, the retrieved key is checked to see if it is expired, and if so, the key is deleted. Advantages: CPU-friendly, which can be detected only when used. Disadvantages: Memory-unfriendly Implementation: The function expireIfNeeded is called before reading or writing redis commands to determine whether the key needs to expire

Delete periodically: Every once in a while, the program checks the database and removes expired keys. As for how many expired keys to delete and how many databases to check, it is determined by the algorithm advantages: Both memory and CPU implementation: The Redis server periodically operates the Redis. C /serverCron function, the activeExpireCycle function will be called. Each time the function is run, a number of random keys from a number of databases are checked and the expired keys are removed.

Q6: Redis elimination strategy

• Noeviction: Write requests will no longer be served, errors will be returned (except DEL requests and some special requests)
• Allkeys-lru: uses the lru algorithm to weed out allkeys
• Volatile – LRU: Uses the LRU algorithm to flush out expired keys
• Allkeys-random: randomly weed out data from allkeys
• Volatile -random: Randomly weed out keys with expiration dates
• Volatile – TTL: The key whose expiration time is set is discarded according to its expiration time. The earlier the key expires, the earlier the key is discarded

Q7: The underlying implementation of Zset

Jump table. Refer to the easy-to-understand Redis data structure basics tutorial

Kafka article

Q1: How does Kafka ensure high performance and reliability

Please refer to: In-depth interpretation of Kafka data reliability.

Voice-over: This article needs to be read carefully to understand each piece. Once you understand what this article says, you should have no problem dealing with the Kafka interview questions.

Q2: Kafka supports transactions

Kafka transaction mechanism and Exactly Once semantics implementation principle

Q3: Role of ZooKeeper in Kafka

• Rebalance the consumer
• Choose the main

Programming problem

All of these are Leetcode medium difficulty questions, you can brush up

Q1: To find A over B, you can’t use division

Divide two numbers

public int divide(int dividend, int divisor) {
    if (dividend == 0) {
      return 0;
    }
    if (dividend == Integer.MIN_VALUE && divisor == -1) {
      return Integer.MAX_VALUE;
    }
    int flag = -1;
    if ((dividend > 0 && divisor > 0) || (dividend < 0 && divisor < 0)) {
      flag = 1;
    }
    long a = Math.abs((long) dividend);
    long b = Math.abs((long) divisor);
    return flag * getRes(a, b);
  }

  private int getRes(long a, long b) {
    if (a < b) {
      return 0;
    }
    int count = 1;
    long tmp = b;
    while (a > b << 1) {
      b = b << 1;
      count = count << 1;
    }
    return count + getRes(a - b, tmp);
  }
Copy the code

Q2: Given an array of n numbers, concatenate the numbers and find the maximum number to concatenate

Q3: Find the penultimate KTH node in the linked list

Q4: The best time to buy and sell stocks

To find the maximum profit, we need to find the minimum purchase price. Assume that NUMS [I] is the lowest purchase price and NUMs [j] is the highest purchase price. When I < j, the maximum profit is nums[j] -nums [I].

For a full description, see: 121. The best time to buy and sell stocks

public int maxProfit(int[] prices) {
    int len = prices.length;
    if (len <= 1) {
        return 0;
    }
    // Store the minimum purchase price
    int minBuyPrice = prices[0];
    
    // Store the highest selling price
    int maxSellPrice = 0;
    
    for (int i = 1; i < len; i++) {
        // Calculate the highest selling price: compare the current highest selling price with that day's selling price. Where price[I] -minbuyprice is the selling price of the day
        maxSellPrice = Math.max(maxSellPrice, prices[i] - minBuyPrice);
        
        // Update the minimum purchase price
        minBuyPrice = Math.min(minBuyPrice, prices[i]);
    }
    return maxSellPrice;
}
Copy the code

Q5: Copy a linked list with a random pointer

Q6: Eliminate 816. For example, the original string 12881616 returns 12. 12881616 -> 12816 -> 12

Tip: Use stack data structures

Q7: The number of odd and even numbers in the array is the same. Swap the contents so that the odd subscript stores the odd number and the even subscript stores the even number

Q8: leetcode 154 items

Link: 154. Find the minimum value II in the rotation sorted array

154. Find the minimum value II in the rotation sorted array

Q9: single linked list structure, each node represents the number from 0 to 9. Given two linked lists, sum them. Examples are 9->9 and 2->1. The sum is 1->2->2

Three ideas, please refer to: Leetcode 445. Add two numbers II

Q10: Implement an LRU data structure, insert and query requirementsTime complexity

1. This can be implemented directly using LinkedHashMap.
2. The use of aLinkedListstoragekeyInsert to O(1), usemapStore k-V mappings to achieve O(1) query complexity

public class Main {
    // Use map to store existing keys to facilitate O(1) query complexity
	HashMap<String, Integer> map = new HashMap<>();
	// The order in which keys are stored, for the most recently accessed keys, is moved to the head of the queue
	LinkedList<String> lruKeys = new LinkedList<>();
	// LRU structure size
	int size = 4;

	public static void main(String[] args) {
		Main main = new Main();
		main.set("math".100);
		main.set("chiness".200);
		main.set("english".210);
		main.print();

		System.out.println("-- -- -- -- -- -- --");

		main.set("music".250);
		main.set("draw".250);
		main.print();

		System.out.println("-- -- -- -- -- -- --");
		main.get("english");
		main.print();
	}

	private void print(a) {
		for (String key : lruKeys) {
			System.out.println(key + "="+ map.get(key)); }}private void set(String key, int val) {
		if (map.containsKey(key)) {
			map.put(key, val);
			moveToFirst(key);
		} else {
			if(lruKeys.size() == size) { String removeKey = lruKeys.removeLast(); map.remove(removeKey); } map.put(key, val); lruKeys.addFirst(key); }}private int get(String key) {
		if (map.containsKey(key)) {
			moveToFirst(key);
			return map.get(key);
		}
		return 0;
	}

	private void moveToFirst(String key) { lruKeys.remove(key); lruKeys.addFirst(key); }}Copy the code

Q11: the longest substring of a text

Leetcode 5: the longest callback substring

Thinking topic

Q1: 36 cars, 6 tracks, how many times can you select the 3 fastest cars (no timekeeping)

8 times = 6 plus 1 plus 1.

Analysis:

1. First of all, 36 cars were randomly divided into 6 groups for competition, ranked each group and selected the first place in each group (6 times).
2. Conduct another round of competition for the 6 cars resulting from Step 1, and select the top three, assuming that they are car A, car B and car C (once).
3. The second and third winners are selected from the group where car A is (the group in step 1) and the second winners are selected from the group where car B is (the group in step 1). (Because car A is the first, there is A possibility that the second and third place of car A’s group is higher than car B and C; Similarly, the second place of car B in the group is more likely than car C; Since only the 3 fastest cars are selected, there is no need to select cars from car C’s group.)
4. Then, the three cars selected in Step 3 will be joined by car A, car B and car C for A race, and the top three will be selected (once).
5. The result of step 4 is the three fastest cars

Q2: Find duplicates in 1000W data

The use of bitmap. Do not use bloom filters because bloom filters are not 100% accurate.

Q3: With two glass balls and a 256-story building, how can you quickly locate the lowest floor where the glass balls will break

Plan 1: take glass ball layer by layer from low to high test.

Plan two: dichotomy. But if the glass sphere breaks in the middle, there’s no dichotomy, just layer by layer.

Plan three: take glass ball test floor is N, 2N, 3n…. This kind of. If the glass sphere is broken on the 2n floor, the other glass sphere is tested from n+1 to 2n-1 floor by floor.

In fact, it can be seen that plan 3, when n=1, is plan 1 layer by layer experiment; When n is 128, that’s plan two. So how do we solve for n in order to get an optimal result?

Let’s say the floor that broke the marbles is 256 steps n. The number of times is 256/n+n. To minimize this value, 256/n = n is required. So n is equal to 16.

Q4: There are 100 wolves and 1 sheep. Wolves can eat grass, but they prefer to eat sheep. Hypothesis: A: Only one Wolf can eat at A time, and once he eats the sheep, he becomes A sheep himself. B: All wolves don’t want to be eaten. Will the sheep be eaten?

Use mathematical induction.

1. When there is a Wolf and a sheep, the sheep must be eaten. (Because when a Wolf turns into a sheep, it won’t be eaten)
2. When there are two wolves and one sheep, the sheep must not be eaten. (Because if a Wolf eats the sheep, it will become one Wolf and one sheep, so it must be eaten.)
3. When there are three wolves and one sheep, the sheep must be eaten. (Because if a Wolf eats the sheep, it will become 2 wolves and 1 sheep, safe)

So in summary, when there’s an odd number of wolves, the sheep will be eaten; Even number of wolves, sheep will not be eaten.

The interview result

Before the interview

1. Prepare your resume and make sure it has no typos.
2. Be familiar with the items in the skills and projects section of your resume. To some technology is familiar with, understanding is to understand, to seek truth from facts. Otherwise, it is very embarrassing to be questioned by the interviewer
3. Prepare a 1 to 2 minute introduction
4. Try a few companies that don’t want to work for you, because you have a good chance of getting passed in the first place
5. As you approach the interview, prepare a few questions for the interviewer in advance and communicate afterward.

In the interview

1. Don’t be nervous. Yes is yes, no is no. Even if you can’t also say their own thinking and understanding.
2. For programming problems, boundary problems and exceptions need to be fully considered

After the interview

1. Review the interview you just had. Summarize and collect relevant knowledge points for questions that you don’t know or questions that you don’t answer well.