The Job Hunt Begins: Exploring Boss and LinkedIn

My search started on two of the most widely used platforms for job hunting: LinkedIn and Boss, a popular Chinese job application tool. On LinkedIn, I sent applications to over 200 internships, expecting that sheer numbers would help me land at least a few responses. But to my surprise, most of the responses I received were automated rejection messages, courtesy of an ATS (Applicant Tracking System). For some reason, recruiters had set up ATS systems even for internship positions, which felt somewhat off-putting, especially considering the job market. I did manage to get a few responses, mostly for coding assessments, but those were generic auto-replies everyone receives after applying.

Discovering Boss App’s Premium Features

Not one to give up easily, I turned to Boss App, which is specifically tailored for the Chinese job market. The app offered a premium feature that helped analyze job competition and gave you the ability to send out more than 50 resumes per day. I bought a one-month subscription and started sending out my applications. Initially, I didn’t optimize my online profile on the Boss platform, which led to only 25 recruiters viewing my resume. The results weren’t exactly promising.

However, I realized my mistake — I hadn’t taken the time to optimize my profile on Boss. Once I updated my details and made sure my skills were clearly highlighted, things began to change. Almost overnight, I started receiving invitations from recruiters daily — anywhere between 4 and 6 job offers, many from well-known companies. Even though some of these companies did not hire international students, I kept applying, knowing that rejection was a part of the process. After all, I had no industry experience and lacked referrals, so rejection was something I was bracing myself for.

The Interview Struggles: Rejection and Surprises

As expected, I faced plenty of rejection emails. One particular interview went really well, lasting almost an hour, and I felt confident that I had done a great job. But just one week later, I received an email saying that my skills didn’t match what they were looking for. I couldn’t help but laugh. It was disheartening, but I knew it was part of the process.

Additionally, many of the companies I applied to required fluency in Chinese, something I lacked. I was comfortable with basic Chinese, but fluency was still out of my reach. These roles were quickly ruled out, but I didn’t let it discourage me. I continued to push forward.

A Coincidence of Timing: Two Interviews, One Day

Finally, things took an interesting turn. I received two interview requests for the same day. At first, I was a bit overwhelmed by the coincidence, but I decided to go for both — one in the morning and the other in the afternoon. The first interview went smoothly, and after speaking with the CEO, I was introduced to the team, and he showed me some of the company’s exciting projects and mission. I was beyond thrilled and didn’t expect the process to move so quickly.

By the end of the day, I had an offer from the company, and it felt like all my hard work had finally paid off. Given how quickly things had progressed, I made the decision to cancel the second interview.

Conclusion: The Challenges Were Worth It

In summary, the journey to finding an internship in China wasn’t easy, but it was full of valuable lessons. I faced many challenges, from rejections and language barriers to the frustrations of automated responses. Yet, each obstacle helped me grow stronger and more resilient. Ultimately, my efforts paid off when I landed a position that was a perfect fit for my skills and interests.

For anyone considering applying for an internship in China, my advice is simple: keep pushing through the rejections, optimize your online profiles, and remain persistent. The journey may not be quick, but the rewards can be worth the effort.

Understanding Approximation Ratios

An approximation ratio quantifies how close the solution obtained by an approximation algorithm is to the optimal solution. It's defined differently for minimization and maximization problems:

• Minimization Problems:

  \( \text{Approximation Ratio } \rho = \frac{\text{Algorithm's Solution Cost}}{\text{Optimal Solution Cost}} \geq 1 \)

• Maximization Problems: \(\text{Approximation Ratio } \rho = \frac{\text{Optimal Solution Value}}{\text{Algorithm's Solution Value}} \geq 1 \)

An algorithm with an approximation ratio \((\rho)\) guarantees that the solution it produces is within a factor of ( \(\rho\) ) of the optimal solution for any instance of the problem.

Types of Approximation Algorithms

Approximation algorithms can be categorized based on their approximation ratios and the techniques they employ. Here's an overview of the different types:

1. Constant-Factor Approximation Algorithms

• Definition: Algorithms that guarantee a solution within a constant factor of the optimal solution, regardless of the input size.

• Approximation Ratios: Fixed constants like \(\frac{1}{2} ), 2, ( \frac{3}{2}\), etc.

• Examples:

  • ( \(\frac{1}{2} \) )-Approximation: The Extended Greedy Knapsack (ExtGreedyKS) algorithm for the 0-1 Knapsack problem guarantees at least half of the optimal value.

  • 2-Approximation: The Greedy Vertex Cover algorithm provides a vertex cover no more than twice the size of the optimal cover.

  • ( \(\frac{3}{2}\) )-Approximation: Christofides' algorithm for the Metric Traveling Salesman Problem (TSP) guarantees a tour no more than 1.5 times the optimal length.

Key Characteristics:

• Simplicity: Often based on greedy or straightforward heuristic methods.

• Efficiency: Typically run in polynomial time.

• Applicability: Useful when a reasonably good solution is acceptable, and computational resources are limited.

2. Polynomial Time Approximation Schemes (PTAS)

• Definition: A family of algorithms where, for any fixed \(\epsilon > 0\), the algorithm produces a solution within a factor of \((1 + \epsilon)\) of the optimal solution in polynomial time.

• Approximation Ratios: Arbitrarily close to 1, depending on \( \epsilon\).

• Examples:

  • Knapsack Problem: Has a PTAS that provides solutions within any desired accuracy.

  • Scheduling Problems: Some variants admit PTAS algorithms.

Key Characteristics:

• Trade-off: As \( \epsilon\) decreases (seeking a solution closer to optimal), the running time increases, often exponentially in \(\frac{1}{\epsilon}\).

• Flexibility: Users can choose \( \epsilon\) based on acceptable approximation and available computational resources.

3. Fully Polynomial Time Approximation Schemes (FPTAS)

• Definition: A PTAS where the running time is polynomial both in the input size and \(( \frac{1}{\epsilon} )\).

• Approximation Ratios: Similar to PTAS, but more efficient for small \(( \epsilon )\).

• Examples:

  • Knapsack Problem: Also admits an FPTAS, making it possible to get very close to the optimal solution efficiently.

  • Subset Sum Problem: Has an FPTAS.

Key Characteristics:

• Efficiency: More practical for small \(( \epsilon )\) compared to general PTAS algorithms.

• Applicability: Suitable for problems where even small deviations from the optimal solution are significant.

4. Logarithmic and Polylogarithmic Approximation Algorithms

• Definition: Algorithms where the approximation ratio grows logarithmically with the input size or some parameter of the input.

• Approximation Ratios: \(( \rho(n) = O(\log n) ) or ( \rho(n) = O((\log n)^k) )\).

• Examples:

  • Set Cover Problem: Has a \(( \ln n )\)-approximation algorithm.

  • Facility Location Problems: Often admit logarithmic approximation ratios.

Key Characteristics:

• Scalability: Approximation ratio worsens slowly with increasing input size.

• Complexity: Typically more sophisticated algorithms, sometimes involving LP relaxation.

5. Randomized Approximation Algorithms

• Definition: Algorithms that use randomization to achieve a good expected approximation ratio or guarantee with high probability.

• Approximation Ratios: Vary based on the problem and randomization technique.

• Examples:

  • MAX 3-SAT Problem: Randomized algorithms can achieve a \(( \frac{7}{8} )\)-approximation.

  • Load Balancing Problems: Randomized rounding can provide good approximations.

Key Characteristics:

• Expected Performance: Guarantees hold on average over multiple runs.

• Probabilistic Guarantees: May require running the algorithm multiple times to achieve high confidence.

6. Problem-Specific Approximation Algorithms

• Definition: Algorithms tailored to specific problems, exploiting unique properties to achieve better approximation ratios.

• Examples:

  • Metric TSP: Specific algorithms like Christofides' algorithm achieve better ratios due to the triangle inequality.

  • Scheduling Problems: Algorithms may achieve different approximation ratios based on constraints like precedence or resource limitations.

Key Characteristics:

• Customization: Designed for the nuances of a particular problem.

• Performance: Approximation ratios may vary widely.

Approximation Ratios in Context

The approximation ratio achievable often depends on the problem's complexity and structure:

• Some problems have constant-factor approximations but cannot be approximated better unless P = NP.

  • Vertex Cover: Best known approximation ratio is 2; improving this is a significant open problem.

• Other problems admit PTAS or FPTAS.

  • Knapsack Problem: Despite being NP-hard, it has an FPTAS.

• Certain problems are hard to approximate within any reasonable factor.

  • Clique Problem: No efficient approximation algorithm achieves a good approximation ratio unless P = NP.

How Many Types Are There?

There is an extensive variety of approximation algorithms, and they can be classified based on:

• Approximation Ratio Achieved:

  • Exact \(( \rho = 1 )\)

  • Constant-factor (e.g., \(\rho = 2 ), ( \rho = \frac{3}{2} \) )

  • Logarithmic-factor \(( \rho = O(\log n) )\)

  • Arbitrarily close to 1 (PTAS and FPTAS)

• Algorithmic Technique Used:

  • Greedy methods

  • Dynamic programming

  • Linear programming relaxation and rounding

  • Primal-dual methods

  • Randomized algorithms

• Problem Characteristics:

  • Whether the problem is a maximization or minimization problem

  • Specific properties like submodularity, metric spaces, or graph structures

In summary, there isn't a fixed number of types of approximation algorithms. Instead, the types are defined based on their approximation ratios and methods, which are often tailored to specific problems. The field is dynamic, with ongoing research discovering new algorithms and improving existing ones.

Summary of Common Approximation Ratios

• Exact Algorithms \(( \rho = 1 )\):

  • Provide optimal solutions but are often impractical for NP-hard problems due to high computational complexity.

• Constant-Factor Approximations:

  • \(\rho = \frac{1}{2}\): Algorithms guarantee at least half the optimal value.

  • \(\rho = 2\): Solutions are at most twice the optimal cost or size.

• PTAS and FPTAS \(( \rho = 1 + \epsilon )\):

  • Solutions can be made arbitrarily close to optimal by choosing a small ( \(\epsilon\) ).

• Logarithmic Approximations \(( \rho = O(\log n) )\):

  • Approximation ratio grows with the logarithm of the problem size.

Conclusion

The field of approximation algorithms encompasses a wide range of algorithms with different approximation ratios, designed to tackle various optimization problems. The types and approximation ratios depend on:

• The specific problem and its computational complexity.

• The algorithmic techniques applicable to the problem.

• The desired balance between solution quality and computational efficiency.

Understanding these types helps in selecting appropriate algorithms for practical applications where exact solutions are unattainable due to time or resource constraints.

- Comprehensive evaluation of possibilities ensures the best outcome. | - Faster than exact methods for large n.
- Simple to implement.
- Guarantees a solution within 50% of the optimal value. | | Disadvantages | - Computationally expensive for large numbers of items or capacities.
- High memory usage in dynamic programming implementations. | - May not reach the optimal solution.
- Approximation ratio limited to 1/21/21/2; solutions can be significantly less than optimal in worst-case scenarios. | | Example Scenario | Allocating a fixed budget across projects to maximize ROI when precise optimization is critical. | Quickly estimating the most valuable set of tasks to undertake when under time pressure and exact optimization is less critical. |

Explanation:

• 0-1 Knapsack Problem:

  • Nature of the Problem: A classic combinatorial optimization problem that's NP-hard.

  • Solution Techniques: Typically involves dynamic programming for exact solutions, which can be time-consuming for large datasets.

  • Optimal Solution: Guarantees the maximum possible total value without exceeding capacity, but computationally intensive.

• ExtGreedyKS Algorithm:

  • Purpose: Offers a practical solution when exact computation is infeasible.

  • Mechanism:

    • Greedy Approach: Prioritizes items with the highest value-to-weight ratio.

    • Single Item Consideration: Ensures high-value items aren't overlooked due to their weight.

  • Performance Guarantee: Ensures the solution is at least half as good as the optimal one.

Key Differences Summarized:

• Exactness vs. Efficiency:

  • The 0-1 Knapsack problem seeks the exact optimal solution but may be inefficient for large inputs.

  • The ExtGreedyKS algorithm sacrifices exactness for efficiency, providing a solution quickly with a known approximation ratio.

• Applicability:

  • Use the 0-1 Knapsack methods when the optimal solution is necessary, and computational resources are sufficient.

  • Apply the ExtGreedyKS algorithm when a good enough solution is acceptable, especially under time or resource constraints.

Final Notes:

• Understanding the trade-offs between the exact methods for the 0-1 Knapsack problem and the approximate nature of the ExtGreedyKS algorithm is crucial for selecting the appropriate approach based on the specific needs of a problem.

• The ExtGreedyKS algorithm is especially valuable in real-world applications where decisions must be made rapidly, and an approximate solution is preferable to an exact one that requires excessive computation time.

Key Differences:

1. Problem Solving:

   • P: Problems can be both solved and verified in polynomial time.

   • NP: Problems may not be solved in polynomial time but can be verified in polynomial time.

   • NP-complete: Problems are the hardest in NP and are solvable if any NP problem is solved in polynomial time.

   • NP-hard: Problems are as hard as NP-complete but not necessarily in NP (i.e., they might not even have a verifiable solution in polynomial time).

2. Inclusion:

   • P: Subset of NP.

   • NP-complete: Subset of NP-hard.

   • NP-hard: Not necessarily a subset of NP.

3. Implication:

   • Solving any NP-complete problem in polynomial time implies P=NP.

   • Solving an NP-hard problem does not necessarily affect P=NP, as NP-hard problems might not be verifiable.

Math Relationship:

• P ⊆ NP.

• NP-complete ⊆ NP.

• NP-complete ⊆ NP-hard.

• NP-hard includes problems that might not belong to NP.

Key Innovations:

1. Multi-Head Differential Attention: Enhances focus on relevant data, reducing noise and improving model accuracy.

2. SwiGLU Activation: A novel feed-forward module that improves in-context learning by adjusting input flow dynamically.

3. Layer Efficiency: Implements RMSNorm and learnable matrices for better parameter optimization.

   This architecture significantly enhances language model performance, showing promising results in tasks like text summarization and question answering by minimizing common issues like hallucinations.

   With applications in large-scale NLP tasks and beyond, the Differential Transformer is a cutting-edge contribution to AI research.

   For more details, check out the full paper here: arXiv:2410.05258

Problem Raised:

So, let's start as you can see below picture where I use type for data type checking but when we want to check between the Array and Object it will show the same output object data type because JavaScript is treated as the object but as a human, we see different data type.

Solution

Now we can handle this data type checking using the getPrototypeOf method and its constructor property. Below the picture, you can see the different types of data shown in the output Object is return true and Array is return false. Keep in mind it is very useful when you need exactly object and array type checking.

Are you thinking of a real-life use case?

Well, let's see the use case suppose you have an API endpoint you don't know after fetching the data will show in an array or object. Or you have an endpoint but the endpoint randomly gives data using sometimes object and sometimes an array, now you need to ensure which type of data comes each time.

Below the image, I demonstrate using a fake API that gives random output in array and object. I check if the data type array just simply passes it to another function for the next task. Else if the condition checks the exact object data type and spreads that object then wraps it in the array.

const getProducts =()=>{
//hit the apt endpotnt using queryfetch(
fetch(`https://api.ecommerce.com/random-products`)
.then((res)=> res.json( ))
.then((data)=> {if(data instanceof Array)
{//checking the response if data is array
console.log(data);
}
else if(0bject.getPrototype0f(data).constructor === 0bject){
//checking strictly get object data type
const createArray =[{...data }];//spread the objects value and key
console.log(createArray);
};
getProducts();//invoking the function