Search for Autodesk intern linkedin

maps, sorting and simple D Given a string “aabbbccccc” count the occurences of every

character. Output: a = 2, b = 3, c = 5. Asked me to code it as soon as possible. Could do it within

a minute.
SA question
MAtrix
Based on the information you've provided question pattern
2. cycle t shift array
3.string ,suffix
4. 8 by 8 cube max length where robot can travel
about the Autodesk hiring process and the questions asked in each round, here's a summary of the
key topics and concepts you should focus on in your preparation:

### Online Test (Round 1):

1. **String Manipulation:**
- Basic string operations.
- Handling string patterns and structures.

2. **Arrays:**
- Array manipulation and operations.
- Understanding array-related algorithms.

3. **Sliding Window Technique:**

- Understanding and implementing sliding window algorithms.
- Solving problems that involve maintaining a subset of elements.

You
Exciting News: Delighted to share that I've accepted a 6-month internship at

Autodesk! 🚀 Application Process: Embarking on this journey through a college

recruitment drive, the four-round process was both challenging and
enlightening, offering a comprehensive assessment of my skills and alignment
with Autodesk's innovative spirit. Round 1 - Coding Assessment: The initial
CodeSignal online assessment rigorously tested my grasp of data structures
and algorithms. From array manipulation to regex pattern matching and a
nuanced modification of the maximum subarray sum problem, I tackled each
question methodically, securing a score of 568/600. Interview Round

Highlights: 👨‍💻 Technical Interview I and II: (35 + 45 mins) The first technical
interview covered data preprocessing intricacies, outlier analysis
methodologies, distinctions between perspective and descriptive analysis, and
practical coding challenges (standard leetcode) followed by discussion on
addressing overfitting and underfitting while training models. The second
interview delved into Python proficiency, API data handling, operating
systems, networking with a focus on the transport layer, and SQL discussions
encompassing various types of joins. Additionally, the conversation extended
to application-based queries involving data-specific Python libraries and file
data reading in hierarchical directories, along with inquiries into the past

projects. 😊 Managerial Discussion (1 hr 30 min approx): What I anticipated as

an HR round transformed into an engaging managerial discussion with
Padmaja M.. The conversation started with an exploration of my soft skills and
transitioned into a discussion about my unpublished research project. Despite
data privacy issues hindering a live project showcase, her understanding and
support led to a verbal explanation. We traversed through the intricacies of
data privacy, strategies for data analysis and modeling, and a creative
exploration of my tech-related terminology explanation approach. The hour-
long discussion seamlessly flowed into past internship experiences, my
problem-solving approach, and unique questions that allowed me to
showcase my creative thinking. Importantly, during the Q&A session, I gained
invaluable insights into Autodesk's remarkable work-life balance and vibrant
culture. This was undeniably the best interview experience yet with coolest
manager ever! Acknowledgments: A special shoutout to Krishna Chaturvedi
(He/Him) for orchestrating a seamless recruitment process, and heartfelt
gratitude to neetcode.io (Navdeep Singh) for being my go-to platform,
boosting confidence in data structures and algorithms. Eagerly awaiting the
opportunity to immerse myself in Autodesk's vibrant work culture during my
internship starting in January 2024. hashtag#Autodesk hashtag#Internship
hashtag#Gratitude what are the imp points i need to make as i am also
preparing for autodesk

### Technical Interview - Round 1:

1. **Binary Tree:**
- Calculating the height of a binary tree.
- Implementing tree traversal algorithms.

2. **Binary Search:**
- Implementing Binary Search algorithm.
- Analyzing time complexity of Binary Search.

3. **DBMS (Database Management Systems):**

- Basic concepts of databases.
- Understanding of SQL queries.

4. **OOPS (Object-Oriented Programming):**

- Concepts of OOP (Encapsulation, Inheritance, Polymorphism, Abstraction).
- Understanding class and object relationships.

### Technical Interview - Round 2:

1. **Binary Tree:**
- Printing the Left View of a Binary Tree.
- Non-recursive approaches for tree problems.
2. **Queue:**
- Understanding and implementing queue-based algorithms.
- Analyzing time complexity of queue-based solutions.

3. **Javascript:**
- Basics of Javascript.
- Lexical scoping in Javascript.

4. **Core Subjects:**
- ACID properties in databases.
- Polymorphism and Runtime Polymorphism.

### HR Interview (Round 3):

1. **Personal Background:**
- Be prepared to introduce yourself.
- Questions about your family background.

2. **Knowledge about Autodesk:**

- Research about Autodesk, its products, and its industry.
- Be prepared to explain why you want to be a part of Autodesk.

3. **Projects on Resume:**
- Thorough understanding of the projects on your resume.
- Be ready to explain the challenges faced and lessons learned.

4. **Working Environment:**
- Ability to work efficiently in an environment with strangers.
- Confidence in your communication and interpersonal skills.

### General Tips:

1. **Coding Practice:**
- Regularly practice coding problems on string manipulation, arrays, binary trees, and queues.
- Use platforms like LeetCode, HackerRank, or GeeksforGeeks for coding practice.

2. **Data Structures and Algorithms:**

- Strengthen your understanding of fundamental data structures (arrays, linked lists, trees) and
algorithms (searching, sorting, dynamic programming).

3. **Database Concepts:**
- Review basic concepts of Database Management Systems, including SQL queries.

4. **OOP Principles:**
- Understand and apply Object-Oriented Programming principles.

5. **Javascript (if applicable):**

- Brush up on basics of Javascript, especially lexical scoping.

6. **Company Research:**
- Gather information about Autodesk's products, culture, and recent news.
- Understand the role you are applying for and how your skills align with it.

7. **Communication Skills:**
- Practice effective communication during technical discussions and HR interviews.

Remember to tailor your preparation based on your strengths and weaknesses. Regular practice and a
thorough understanding of core concepts will enhance your performance in technical interviews.
Good luck with your preparation!
Certainly! Here are the questions along with their answers in Java:

### Problem 1:

#### Question:
You are given an array of positive integers `arr`. Determine how many triangles can be formed with
side lengths equal to adjacent elements from `arr`. Construct an array of integers of length `arr.length
- 2`, where the ith element is equal to 1 if it's possible to form a triangle with side lengths `arr[i]`, `arr[i
+ 1]`, and `arr[i + 2]`, otherwise 0.

```java

//User function Template for Java

class Solution
{
int[] canMakeTriangle(int A[], int N)
{

int ans[] = new int[N-2];

for(int i=0;i<A.length-2;i++){

int a = A[i];
int b = A[i+1];
int c = A[i+2];

if((a+b)>c && (a+c)>b && (b+c)>a){

ans[i] = 1;
}else{
ans[i] = 0;
}
}

return ans;
}
}
#### Example:
```java
int[] arr1 = {1, 2, 2, 4};
int[] result1 = solution(arr1); // Output: [1, 0]

int[] arr2 = {2, 10, 2, 10, 2};

int[] result2 = solution(arr2); // Output: [0, 1, 0]

int[] arr3 = {1000000000, 1000000000, 1000000000, 1000000000};

int[] result3 = solution(arr3); // Output: [1, 1]
```

### Problem 2:

#### Question:
Given an array of integers `a`, your task is to calculate the digits that occur the most number of times
in the array. Return the array of these digits in ascending order.

```java
import java.util.*;

public static List<Integer> solution(int[] a) {

Map<Integer, Integer> digitCount = new HashMap<>();

for (int num : a) {

while (num > 0) {
digitCount.put(num % 10, digitCount.getOrDefault(num % 10, 0) + 1);
num /= 10;
}
}

int maxFrequency = Collections.max(digitCount.values());

List<Integer> result = new ArrayList<>();

for (Map.Entry<Integer, Integer> entry : digitCount.entrySet()) {

if (entry.getValue() == maxFrequency) {
result.add(entry.getKey());
}
}

Collections.sort(result);
return result;
}
```

#### Example:
```java
int[] a = {25, 2, 3, 57, 38, 41};
List<Integer> result = solution(a); // Output: [2, 3, 5]
```

### Problem 3:

#### Question:
Given an array of integers `a` of even length, split it into two arrays of equal length such that all the
numbers are unique in each of them. If there is no solution, return an empty array.

```java
import java.util.*;

public static List<List<Integer>> solution(int[] a) {

Map<Integer, Integer> countMap = new HashMap<>();
List<List<Integer>> result = new ArrayList<>();

for (int num : a) {

countMap.put(num, countMap.getOrDefault(num, 0) + 1);
}

for (int num : a) {

if (countMap.get(num) > 2) {
return new ArrayList<>(); // No solution if any number occurs more than twice.
}
 if (countMap.get(num) == 2) {
result.get(0).add(num);
result.get(1).add(num);
countMap.put(num, 0); // Mark as used.
} else {
if (result.get(0).size() < a.length / 2) {
result.get(0).add(num);
} else {
result.get(1).add(num);
}
}
}

return result;
}
```

#### Example:
```java
int[] arr4 = {2, 1, 2, 3, 3, 4};
List<List<Integer>> result4 = solution(arr4); // Output: [[2, 1, 3], [2, 3, 4]]

int[] arr5 = {1, 2, 2, 1};

List<List<Integer>> result5 = solution(arr5); // Output: [[1, 2], [2, 1]]

int[] arr6 = {2, 2, 3, 3, 2, 2};

List<List<Integer>> result6 = solution(arr6); // Output: []
```

Feel free to test these solutions and let me know if you have any questions or need further
clarification on any part of the code!

In an online assessment for Autodesk, we were asked to solve the following question:

Given an array of strings words, find the number of pairs where either the strings are equal or one
string ends with another. In other words, find the number of such pairs i j ( 0 <= i < j < words.length)
that words[i] is a suffix of words[j], or words[j] is a suffix of words[i].

Example

For words = ["back", "backdoor", "gammon", "backgammon", "comeback","come", "door"], the

output should be solution (words) = 3.

The relevant pairs are:

words [0] = "back" and words [4] = "comeback".

words[1] = "backdoor" and words [6] = "door"

words[2]="gammon" and words[3] ="backgammon"

The problem you're describing is about finding pairs of strings in an array where one string is either
equal to another or is a suffix of another string. Your provided code looks correct for the task, and it
should work for many cases. However, to improve efficiency and handle larger inputs, you can
optimize the solution.
Here's an optimized version of your code:

java
Copy code
public class Solution {
public static int solution(String[] words) {
int count = 0;

for (int i = 0; i < words.length; i++) {

for (int j = i + 1; j < words.length; j++) {
if (words[i].equals(words[j]) || isSuffix(words[i], words[j])) {
count++;
break; // No need to check the reverse condition if a match is found.
} else if (isSuffix(words[j], words[i])) {
count++;
}
}
}

return count;
}

private static boolean isSuffix(String str1, String str2) {

return str2.endsWith(str1);
}
}
Changes made:

Optimization: When you find a pair where words[i] is equal to words[j] or is a suffix of words[j], you
can break out of the inner loop because there's no need to check the reverse condition (suffix of
words[i] in words[j]).

Code Organization: Moved the code into a class named Solution.

To understand why some test cases are failing, consider checking the constraints and edge cases. The
constraints might involve the size of the array (words.length) or the length of individual strings within
the array. Ensure that your code can handle the upper bounds specified in the constraints.

For example, if the constraints state that 1 <= words[i].length <= 100, then you need to make sure
that your code performs well even when dealing with very long strings.

Without the specific details of the failed test cases, it's challenging to provide an exact solution.
Consider reviewing the test cases where your code failed and check for edge cases or scenarios that
your implementation might not cover. If possible, share more information about the failed test cases
for a more targeted analysis.

Certainly! Let's cover the basics of SQL and normalization concepts in Database Management Systems
(DBMS).
### Basics of SQL:

#### 1. **SELECT Statement:**

- Retrieve data from one or more tables.
```sql
SELECT column1, column2 FROM table_name WHERE condition;
```

#### 2. **INSERT Statement:**

- Add new records to a table.
```sql
INSERT INTO table_name (column1, column2) VALUES (value1, value2);
```

#### 3. **UPDATE Statement:**

- Modify existing records in a table.

```sql
UPDATE table_name SET column1 = value1 WHERE condition;
```

#### 4. **DELETE Statement:**

- Remove records from a table.
```sql
DELETE FROM table_name WHERE condition;
```

#### 5. **CREATE TABLE:**

- Define a new table.
```sql
CREATE TABLE table_name (
column1 datatype,
column2 datatype,
...
);
```

#### 6. **ALTER TABLE:**

- Modify an existing table (add, modify, or drop columns).
```sql
ALTER TABLE table_name ADD column_name datatype;
```

#### 7. **JOIN:**
- Combine rows from two or more tables based on a related column.
```sql
SELECT * FROM table1 JOIN table2 ON table1.column = table2.column;
```

#### 8. **GROUP BY and Aggregate Functions:**

- Group rows that have the same values in specified columns.
```sql
SELECT column1, COUNT(column2) FROM table_name GROUP BY column1;
```

#### 9. **Subqueries:**
 - Nest a query within another query.
```sql
SELECT column1 FROM table_name WHERE column2 IN (SELECT column2 FROM another_table);
```

#### 10. **Indexes:**

- Improve the speed of data retrieval operations on a database table.
```sql
CREATE INDEX index_name ON table_name (column1, column2);
```

### Normalization and Database Design Concepts:

#### 1. **First Normal Form (1NF):**

- Eliminate duplicate columns from the same table.

#### 2. **Second Normal Form (2NF):**

- Meet the requirements of 1NF and remove partial dependencies.

#### 3. **Third Normal Form (3NF):**

- Meet the requirements of 2NF and remove transitive dependencies.

#### 4. **Entity-Relationship Diagrams (ERD):**

- Visual representation of database entities and their relationships.

#### 5. **Primary Key and Foreign Key:**

- Primary key uniquely identifies each record in a table.
- Foreign key establishes a link between two tables.

#### 6. **Normalization Process:**

- The process of organizing data to minimize redundancy and dependency.

#### 7. **Denormalization:**
- Intentionally adding redundancy to improve query performance.

#### 8. **ACID Properties:**

- Atomicity, Consistency, Isolation, Durability – properties that guarantee database transactions are
processed reliably.

These SQL and normalization concepts provide a foundation for working with relational databases and
designing efficient database structures. Practice implementing these concepts in a database
management system like MySQL, PostgreSQL, or SQLite to strengthen your skills.
UPDATAED DATA
OS
Operating System lies in the category of system software. It basically
manages all the resources of the computer. An operating system acts as an
interface between the software and different parts of the computer or the
computer hardware.
 What is spooling?
 Explain the core functions of an operating system.
 What is RAID? Different types of RAID
 What are the causes of Failure in Operating System?
 What is cache?
 What is a Disk Scheduling Algorithm?
 What is thread in OS?
 What is different between main memory and secondary memory.
 What is the concept of thrashing?
 What’s the difference between Mutex and Semaphore ?
Computer Networks
A computer network is a system that connects numerous independent
computers in order to share information (data) and resources. The
integration of computers and other different devices allows users to
communicate more easily.
 Explain the OSI model and its seven layers.
 Differentiate between TCP and UDP protocols.
 What is Kernel in Operating system?
 Explain the concept of subnetting.
 Explain TCP/IP Model .
 What are the different types of networks?
 What are Firewalls?
 What is meant by NOS?
 What is Proxy Server?
 What is the SMTP protocol?
DBMS and SQL
Database Management System is a software or technology used to manage
data from a database. Some popular databases are MySQL, Oracle,
MongoDB, etc. DBMS provides many operations e.g. creating a database,
Storing in the database, updating an existing database, delete from the
database.
 What’s the difference Between Clustered and Non-Clustered
Index?
 What are the key differences between DBMS and RDBMS?
 What is Normalization?
 What are the types of subquery?
 What is SQL Injection?
 What is the E-R model?
 What is a transaction?
 What is DML (Data Manipulation Language)?
 What’s the difference between DELETE, DROP and
TRUNCATE
 What is Denormalization?

DSA Questions
Problems Practise

Count the number of possible triangles Solve

Count More than n/k Occurences Solve

Nth Fibonacci Number Solve

Topological Sorting Solve

Shortest path in a Binary Maze Solve

Detect Cycle in a Directed Graph Solve

Balance a Binary Search Tree Solve

Matrix Chain Multiplication Solve

 Problems Practise

LRU Cache Solve

Implementing Dijkstra Algorithm Solve

Rabin-Karp Algorithm for Pattern Searching Solve

Fractional Knapsack Problem Solve

Travelling Salesman Problem Solve

Check for BST Solve

Array to BST Solve

Word Break Solve

Find median in a stream Solve

Remove duplicate elements from sorted Array Solve

Combination Sum Solve

Diameter of a Binary Tree Solve

Burning Tree Solve

Trapping Rain Water Solve

N-Queen Problem Solve

Rotate a Linked List Solve

DFS of Graph Solve

Reverse a Stack Solve

 Problems Practise

Bridges in a graph Solve

Overlapping Intervals Solve

Convert Infix expression to Postfix expression Solve

Reduce the string by removing K consecutive identical characters Solve

Edit Distance Solve

Word Ladder Solve

Alien Dictionary Solve

Segregate 0s and 1s Solve

Find the longest substring with k unique characters in a given

Solve
string

Maximum length substring having all same characters after k

Solve
changes

Longest Palindromic Substring Solve

The Stock Span Problem Solve

QuickSort on Doubly Linked List Solve

Maximum path sum in matrix Solve

Capacity To Ship Packages Within D Days Solve

Chocolate Distribution Problem Solve

Permutations of a given string Solve

 Problems Practise

Maximum Width of Tree Solve

Merge K sorted linked lists Solve

Wildcard Pattern Matching Solve

Delete middle element of a stack Solve

Circular tour Solve

Rotten Oranges Solve

Next higher palindromic number using the same set of digits Solve

Rotate Array Solve

Split a Circular Linked List into two halves Solve

Flattening a Linked List Solve

Triplet Sum in Array Solve

Majority Element Solve

Top View of Binary Tree Solve

Convert an array to reduced form Solve

Find the number of islands using DFS Solve

Rotate by 90 degree Solve

Largest Sum Contiguous Subarray Solve

Clone a linked list with next and random pointer Solve

 Problems Practise

Rearrange characters Solve

Longest Path in a matrix Solve

Find the Missing Number Solve

Top K Frequent Elements in Array Solve

Stack using two queues Solve

Snake and Ladder Problem Solve

Decode the string Solve

Minimum edges Solve

Search in a row-column sorted Matrix Solve

Sure, here's a rough categorization of the topics you listed from easier to harder:

1. **Array to BST**
2. **Count More than n/k Occurrences**
3. **Segregate 0s and 1s**
4. **Next higher palindromic number using the same set of digits**
5. **Rotate Array**
6. **Rotate a Linked List**
7. **Delete middle element of a stack**
8. **Split a Circular Linked List into two halves**
9. **Flattening a Linked List**
10. **Convert an array to reduced form**
11. **Search in a row-column sorted Matrix**
12. **Merge K sorted linked lists**
13. **Stack using two queues**
14. **Permutations of a given string**
15. **Majority Element**
16. **Find the Missing Number**
17. **Top K Frequent Elements in Array**
18. **Count the number of possible triangles**
19. **Balance a Binary Search Tree**
20. **LRU Cache**
21. **QuickSort on Doubly Linked List**
22. **Triplet Sum in Array**
23. **Chocolate Distribution Problem**
24. **Capacity To Ship Packages Within D Days**
25. **Word Ladder**
26. **Alien Dictionary**
27. **Bridges in a graph**
28. **DFS of Graph**
29. **Detect Cycle in a Directed Graph**
30. **Topological Sorting**
31. **Array to BST**
32. **Check for BST**
33. **Top View of Binary Tree**
34. **N-Queen Problem**
35. **Burning Tree**
36. **Diameter of a Binary Tree**
37. **Word Break**
38. **The Stock Span Problem**
39. **Rearrange characters**
40. **Find median in a stream**
41. **Remove duplicate elements from sorted Array**
42. **Find the longest substring with k unique characters in a given string**
43. **Maximum length substring having all same characters after k changes**
44. **Longest Palindromic Substring**
45. **Permutations of a given string**
46. **Edit Distance**
47. **Longest Path in a matrix**
48. **Longest Path in a matrix**
49. **Maximum path sum in matrix**
50. **Rotten Oranges**
51. **Snake and Ladder Problem**
52. **Travelling Salesman Problem**
53. **Wildcard Pattern Matching**
54. **Split a Circular Linked List into two halves**
55. **Flattening a Linked List**
56. **Decode the string**
57. **Minimum edges**
58. **Matrix Chain Multiplication**
59. **Implementing Dijkstra Algorithm**
60. **Fractional Knapsack Problem**
61. **Maximum Width of Tree**
62. **Word Ladder**
63. **Alien Dictionary**
64. **Bridges in a graph**
65. **DFS of Graph**
66. **Detect Cycle in a Directed Graph**
67. **Topological Sorting**
68. **Shortest path in a Binary Maze**
69. **Rabin-Karp Algorithm for Pattern Searching**
70. **Edit Distance**
71. **Word Ladder**
72. **Alien Dictionary**
73. **Longest Path in a matrix**
74. **Find the longest substring with k unique characters in a given string**
75. **Maximum length substring having all same characters after k changes**
76. **Longest Palindromic Substring**
This ordering is subjective and may vary depending on individual familiarity and expertise with
different algorithms and problem-solving techniques.

Mern interview –

I applied through university. The process took 2 days. I interviewed at Autodesk

(Lucknow) in Nov 2023

Interview

There were three interview rounds which were held on-campus. In the first round,
they asked questions on my final-year project discussing about the various tech-
stacks like ReactJS and how did I implemented the authentication part of that
website using JWT token. Later on, they also asked some basic DSA questions
related to linked list and strings. In the subsequent rounds, they asked me deep
questions on C++ pointers, NodeJS and MongoDB ranging from direct theory
questions to the implementation part. Third round was a good composition of HR
round and technical as the interviewer asked me my favourite music composer
followed by making me write down the database of a popular audio-editing
software known as Audacity.

Interview questions
 1. How did you implement the authentication page of your website using
JWT tokens ? Apart from JWT token, what else can you use for the
same ? 2. What are the various queries you can use in MongoDB for
achieving CRUD operations in your project ? 3. Design the database for a
music-editing software like Audacity displaying various tables like albums,
tracks, effects etc. 4. Reverse a linked list. 5. How does a Google-Pay API
work and how does your website come to know whether a payment
through an external interface is successful or not ? 6. Reverse a string
using proper classes and all so that all the properties of object-oriented
programming can be used in a single programming file. Also, instead of
directly taking inputs from the console, you have to allow users to make
choices on taking inputs while abstracting the input methods from the user
at the same time ?

1. Differentiate between Arrays & LinkedList

2. What are Data structures and its types
3. Java inheritance
4. Why AutoDesk?
5. Java HashMap
6. Rate yourself in NodeJS, ReactJS, NextJS, AWS
Explain any 1 project in detail for 5 minutes.

What is the major challenge you have faced in

engineering/internship/project and how did you overcome it?

Explain your internship experience in detail for 5 minutes.

Detailed information and questions were asked regarding

internship, 1 major project.

How do you see Apprentice role compared to SDE role? Will

you prefer SDE in a different company over Apprentice at
AutoDesk?

This was a elimination round. Based on resume, self rating on

NodeJS, ReactJS, skillset; Candidates would be differentiated
for different roles like SDE, Test, Product support, DevOps,
Salesforce and others.

Third round:

Scheduled on the same day afternoon at 2pm

One-to-One Interview

1. Rate yourself in Java (Because in the 2nd round, I

said that I’m good in Java)
2. Explain Abstraction
3. Interface vs Abstract method
4. Why Java does’nt support multiple inheritance.
Explain
5. Explain ‘Generic’ in Java
6. Explain ‘Static’ in Java
7. Integration of uv, u/v
8. Quotient rule in Calculus
9. Blackbox vs Whitebox testing
10. Given a string “aabbbccccc” count the occurences of
every character. Output: a = 2, b = 3, c = 5. Asked me
to code it as soon as possible. Could do it within a
minute.
11.Explain JOIN in SQL
12. What is Normalization?
13. Explain Agile development
14. What is REST API?
15. Unit testing vs System testing, Performance testing
16. Why is testing required?
17.What is AWS Lamda?
18. What is S3 bucket in AWS?
19. Explain steps in the development of a software
product
20. What is User testing and its types.
21. Types of testing.
22. Explain memory management in Java
23. Garbage collection in Java
24. Log a + Log b = ?
25. Some other Log mathematical questions.