Its 2023 and **AI Models are on the rise**, even for a simple task. Then **why not use it for solving Coding problems?** One such popular model is **Chat-GPT**. Chat-GPT can be a valuable resource for students looking to solve coding-related problems. It can **provide quick answers to simple questions about syntax, algorithms, and data structures**, which can save students time and help them better understand programming concepts. Chat-GPT can also assist students with more complex coding problems by suggesting potential solutions, providing examples, or explaining coding concepts in a clear and concise way.

By using Chat-GPT, students can learn at their own pace and in a format that suits their learning style. They can ask questions and receive answers immediately, without having to wait for a teacher or tutor to become available.

__How to use Chat-GPT efficiently to solve Coding Problems?__

Chat-GPT is Phenomenal when it comes to problem-solving. Students can ask Chat-GPT-specific questions related to coding and programming, and it can provide step-by-step guidance on how to solve coding problems. Additionally, Chat-GPT can offer coding tips, tricks, and best practices, helping students to improve their coding skills and knowledge. With its vast knowledge base and ability to quickly process and analyze data, Chat-GPT is a valuable resource for students seeking coding help.

All of us know about the capabilities of Chat-GPT. Solving coding and Data Structure’s related problems is one of the major capabilities of Chat GPT. This ability of Chat GPT is very helpful for coders and debuggers around the world as Chat GPT helps in solving coding problems.

Note: If you are a beginner or New to programming then, first you should focus on your fundamentals and roots of programming then start solving problems on your own. But if you are stuck badly in any problem and you’re not able to find the exact answer or stuck in any edge-case or corner case then you can go for Chat GPT.

Using text-based AI models like Chat-GPT can be a bit tricky if you are new to it. To help you with this, we have compiled a **list of pointers to look for while using Chat-GPT to solve Coding Problems**:

**1. Be specificÂ **

When asking a coding question, be as specific as possible. Provide details on what you’re trying to accomplish, what code you’ve already written, what error messages you’re getting, and what you’ve tried so far. The more specific you are, the more helpful the response from Chat-GPT will be.

**2. Use proper keywords**

Use proper coding terminology when asking your question. This will help Chat-GPT better understand your question and provide more accurate responses.

**3. Break down your problem into smaller parts**

If you’re struggling with a larger coding problem, try breaking it down into smaller parts. This can make the problem easier to solve, and it can help Chat-GPT better understand what you’re trying to accomplish.

**4. Provide examples**

Providing examples of your code or the output you’re expecting can help Chat-GPT better understand your problem and provide more accurate responses.

**5. Check the Chat-GPT response**

Once Chat-GPT responds to your question, read the response carefully and make sure you understand it. If you don’t understand the response, try rephrasing your question or providing more details.

**6. Experiment and Improvise**

Use Chat-GPT’s responses to experiment with different solutions to your coding problem. Try out different code snippets or approaches and see what works best.

__How to form Query correctly to get Expected Answer From Chat-GPT?__

It’s observed that If one does not mention the clear Problem statement and all other required data-set which is required to solve the problem statement then Chat-GPT may give the wrong answer as Output.

There should be a plan to search the problem statement in Chat GPT:

**Define the problem:**Make sure you understand what the problem is asking you to do. Break down the problem into smaller parts if necessary.**Plan a solution:**Once you have understood the problem, plan a solution before starting to code. Think about the data structures and algorithms that could be used to solve the problem.**Write the code:**Implement your plan in code. Use a programming language that you are comfortable with.**Test your code:**Test your code with different inputs and make sure it is giving correct outputs.**Refine your solution:**If your code is not working correctly, refine your solution and try again.

__How to use Chat-GPT to solve different types of Coding Problems?__

__1. ____Data Structure and Algorithm (DSA)____ Related Problems__

Suppose, we want Chat GPT to solve the Tower-Of-Hanoi problem then we’ll follow the following steps:

**STEP 1:** Provide the Clear & Crisp Problem Statement so that it’s easier for the AI to understand the problem and there should be no scope of confusion here.

Example:Tower of Hanoi is a mathematical puzzle where we have three rods (A,B, andC) andNdisks. Initially, all the disks are stacked in decreasing value of diameter i.e., the smallest disk is placed on the top and they are on rodA. The objective of the puzzle is to move the entire stack to another rod (here consideredC), obeying the following simple rules:Â

- Only one disk can be moved at a time.
- Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.Â
- No disk may be placed on top of a smaller disk.

**STEP 2: **Provide Input/Output Examples with Output explanation:

Input: 2Output:Disk 1 moved from A to BDisk 2 moved from A to CDisk 1 moved from B to C

**STEP 3: **State the Required Result. Ask Chat-GPT to provide the result in the format you want.

Example:Solve this problem using recursion provides its explanation, algorithmic steps, C++ Code Implementation, and Complexity analysis.

**STEP 4: **Now, Chat-GPT will generate the required answer.

Generated Content:

So, this is how we can solve problem statements using Chat-GPT as we can see:

- We got an explanation of the problem statement
- Then, algorithmic steps to solve the problem
- C++ Implementation
- Complexity Analysis

Don’t worry, we have already tested Chat-GPT’s response for Tower of Hanoi problem with sample test cases here.

__2. Solving Complexity Analysis for Algorithms Using Chat-GPT__

Suppose, we want Chat-GPT to compute the Complexity of any algorithm, then we’ll follow the following steps:

**STEP 1**: Provide a clear and crisp problem statement so that it’s easier for the AI to understand the problem and there should be no scope of confusion here.

Example:ÂProvide the complexity analysis of the below code with Time complexity and Auxiliary Stack Space.

The given code is of Fibonacci problem using Recursion.

## C++

`#include <bits/stdc++.h>`

`using`

`namespace`

`std;`

`int`

`fib(`

`int`

`n)`

`{`

`if`

`(n == 0)`

`return`

`0;`

`if`

`(n == 1 || n == 2)`

`return`

`1;`

`else`

`return`

`(fib(n - 1) + fib(n - 2));`

`}`

`int`

`main()`

`{`

`int`

`n = 5;`

`cout <<`

`"Fibonacci series of 5 numbers is: "`

`;`

`for`

`(`

`int`

`i = 0; i < n; i++)`

`{`

`cout << fib(i) <<`

`" "`

`;`

`}`

`return`

`0;`

`}`

**Â STEP 2:Â ** Fetch the results

Expected Answer:Â

Time Complexity: O(2^{n}),ÂAuxiliary Space:O(n)

Generated Answer:The given code computes the first n numbers of the Fibonacci series using recursion.

- The time complexity of the fib() function can be computed using a recursive tree. Each node in the tree represents a recursive call to the fib() function. At each level of the tree, the number of nodes is twice the number of nodes at the previous level. Therefore, the height of the tree is n. The work done at each node is constant time, i.e., O(1).

Therefore, the time complexity of the fib() function is O(2^{n}).- The main() function calls the fib() function n times in the for loop. Since the time complexity of the fib() function is O(2^n), the time complexity of the main() function is O(n * 2
^{n}).

The space complexity of the program is O(n) because the maximum number of function calls that can be present in the call stack at any point in time is n.

__3. Converting/Translating Language of the Algorithm/Code Using Chat-GPT__

Suppose, we want Chat-GPT to change the Language of the code then we’ll follow the following steps:

**STEP 1: Â **Provide the Clear & Crisp Problem Statement so that it’s easier for the AI to understand the problem and there should be no scope of confusion here.

If we want to change the programming language of any Code then we can simply command Chat-GPT to do the needful.

Example: Convert the below code into Java## C++

`#include <bits/stdc++.h>`

`using`

`namespace`

`std;`

`int`

`fib(`

`int`

`n)`

`{`

`if`

`(n == 0)`

`return`

`0;`

`if`

`(n == 1 || n == 2)`

`return`

`1;`

`else`

`return`

`(fib(n - 1) + fib(n - 2));`

`}`

`int`

`main()`

`{`

`int`

`n = 5;`

`cout <<`

`"Fibonacci series of 5 numbers is: "`

`;`

`for`

`(`

`int`

`i = 0; i < n; i++)`

`{`

`cout << fib(i) <<`

`" "`

`;`

`}`

`return`

`0;`

`}`

**STEP 2:** Generating the results

Below is the Generated Code:

## Java

`import` `java.util.*; ` ` ` `public` `class` `Fibonacci { ` ` ` ` ` `public` `static` `int` `fib(` `int` `n) { ` ` ` `if` `(n == ` `0` `) ` ` ` `return` `0` `; ` ` ` `if` `(n == ` `1` `|| n == ` `2` `) ` ` ` `return` `1` `; ` ` ` `else` ` ` `return` `(fib(n - ` `1` `) + fib(n - ` `2` `)); ` ` ` `} ` ` ` ` ` `public` `static` `void` `main(String[] args) { ` ` ` `int` `n = ` `5` `; ` ` ` `System.out.print(` `"Fibonacci series of 5 numbers is: "` `); ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) { ` ` ` `System.out.print(fib(i) + ` `" "` `); ` ` ` `} ` ` ` `} ` `} ` |

**Output**

Fibonacci series of 5 numbers is: 0 1 1 2 3

__4. Creating JavaScript Functionalities for Development & Projects__

Suppose, we want Chat-GPT to make any JavaScript functionality that can display Increment and Decrements in the browsers then we’ll follow the following steps:

**STEP 1: **Provide the Clear & Crisp Problem Statement so that it’s easier for the AI to understand the problem and there should be no scope of confusion here.

Example:Create a JavaScript program that enables user to increment and decrement a value by one by clicking increment and decrement separately

STEP 2:Fetching the Results:As we can see that Chat-GPT has given us the generated code as HTML file.

**Output:** Sure! Here’s a simple JavaScript program that allows a user to increment and decrement a value by one by clicking on separate buttons:

## HTML

`<!DOCTYPE html> ` ` ` `<` `html` `> ` `<` `head` `> ` ` ` ` ` `<` `title` `>Increment and Decrement</` `title` `> ` ` ` ` ` `</` `head` `> ` `<` `body` `> ` ` ` ` ` `<` `h1` `>Increment and Decrement</` `h1` `> ` ` ` `<` `p` `>Current Value: <` `span` `id` `=` `"value"` `>0</` `span` `></` `p` `> ` `<` `button` `id` `=` `"increment"` `>Increment</` `button` `> ` `<` `button` `id` `=` `"decrement"` `>Decrement</` `button` `> ` ` ` ` ` `</` `body` `> ` `</` `html` `>` |

## Javascript

`<script> ` ` ` `const valueElem = document.getElementById(` `"value"` `); ` `const incrementButton = document.getElementById(` `"increment"` `); ` `const decrementButton = document.getElementById(` `"decrement"` `); ` ` ` ` ` `let value = 0; ` ` ` ` ` `function` `updateValue() { ` ` ` `valueElem.textContent = value; ` ` ` `} ` ` ` ` ` `function` `incrementValue() { ` ` ` `value += 1; ` `updateValue(); ` ` ` ` ` `} ` ` ` ` ` `function` `decrementValue() { ` ` ` ` ` `value -= 1; ` ` ` `updateValue(); ` ` ` `} ` ` ` ` ` `incrementButton.addEventListener(` `"click"` `, incrementValue); ` ` ` `decrementButton.addEventListener(` `"click"` `, decrementValue); ` ` ` ` ` `</script>` |

**STEP 3: Â **Testing the Generated Code

- Open any IDE (eg., Virtual Studio Code)
- Then, Create an
**index.html**file. - copy & paste the generated code
- Run with live server

As we can see that the code is working fine and we have 4 Components in the display:

1. Heading showing

“Increment and Decrement”.

2. Paragraph tag with span value will show theIncrement/Decrementvalues, Initially the value is 0.

3. Button to increment values

4. Another Button to decrement values.

__How NOT to Use Chat-GPT for Solving Coding Problems__

We have to be careful while solving coding-related problems using Chat-GPT because Chat-GPT does not claim 100% Accuracy for Generated Output. Suppose we are given a Problem Statement in Story Format / In-Sufficient Data / Wrong Examples / Wrong I/O. In That Case, Chat-GPT will surely Generate the Wrong Answer for an Input.

__Case 1: Not providing sufficient information to generate the desired output__

Let’s take an example of a popular problem **Print Spiral Matrix**. The task is to print a spiral matrix but in Anti-Clock-Wise Direction. So let’s give Chat-GPT a command to Print the Spiral Matrix in Anti-Clock Wise Direction.

Query asked:ÂGiven an m x n matrix, return all elements of the matrix in spiral order in an anticlockwise direction. Input:

matrix = [[1,2,3],[4,5,6],[7,8,9]].

Answer generated by Chat-GPT:

Now let’s try to run the generated C++ code against the above input with the expected output as [1 4 7 8 9 6 5 2 3]

## C++

`#include <iostream> ` `#include <vector> ` ` ` `using` `namespace` `std; ` ` ` `vector<` `int` `> AntispiralOrder(vector<vector<` `int` `>>& matrix) { ` ` ` `int` `top = 0, bottom = matrix.size() - 1, left = 0, right = matrix[0].size() - 1; ` ` ` `int` `dir = 1; ` ` ` `vector<` `int` `> result; ` ` ` ` ` `while` `(top <= bottom && left <= right) { ` ` ` `if` `(dir == 1) { ` ` ` `for` `(` `int` `i = left; i <= right; i++) { ` ` ` `result.push_back(matrix[top][i]); ` ` ` `} ` ` ` `top++; ` ` ` ` ` `for` `(` `int` `i = top; i <= bottom; i++) { ` ` ` `result.push_back(matrix[i][right]); ` ` ` `} ` ` ` `right--; ` ` ` ` ` `for` `(` `int` `i = right; i >= left; i--) { ` ` ` `result.push_back(matrix[bottom][i]); ` ` ` `} ` ` ` `bottom--; ` ` ` ` ` `for` `(` `int` `i = bottom; i >= top; i--) { ` ` ` `result.push_back(matrix[i][left]); ` ` ` `} ` ` ` `left++; ` ` ` `} ` ` ` `dir *= -1; ` ` ` `} ` ` ` ` ` `return` `result; ` `} ` ` ` `int` `main() { ` ` ` `vector<vector<` `int` `>> matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; ` ` ` ` ` `vector<` `int` `> result = AntispiralOrder(matrix); ` ` ` ` ` `for` `(` `int` `i = 0; i < result.size(); i++) { ` ` ` `cout << result[i] << ` `" "` `; ` `//1 4 7 8 9 6 5 2 3 ` ` ` `} ` ` ` ` ` `return` `0; ` `} ` |

**Output**

1 2 3 6 9 8 7 4 5

**Expected Output**

1 4 7 8 9 6 5 2 3

As we can see that we are getting the wrong answer for the above Inputs.

__Why Chat-GPT is producing incorrect output in this case?__

We have provided insufficient Information this is the main reason Why Chat-GPT is giving us the wrong Output:

Let’s see what should be the proper format for the above Example to get the expected answer:

Write a program to print a spiral matrix in an anticlockwise direction.

Command: Example:Input: arr = [[1,2,3],[4,5,6],[7,8,9]];Output: arr = [1,4,7,8,9,6,3,2,5]

**Generated Code:**

## C++

`#include <iostream> ` `#include <vector> ` ` ` `using` `namespace` `std; ` ` ` `vector<` `int` `> spiralOrder(vector<vector<` `int` `>>& matrix) { ` ` ` `vector<` `int` `> res; ` ` ` `if` `(matrix.empty()) { ` ` ` `return` `res; ` ` ` `} ` ` ` `int` `m = matrix.size(); ` ` ` `int` `n = matrix[0].size(); ` ` ` `int` `i = 0, j = n-1; ` ` ` `while` `(i < j && i <= m-i-1 && j >= n-j && j <= j-i) { ` ` ` `for` `(` `int` `k = i; k <= m-i-1; k++) { ` ` ` `res.push_back(matrix[k][i]); ` ` ` `} ` ` ` `for` `(` `int` `k = i+1; k <= j; k++) { ` ` ` `res.push_back(matrix[m-i-1][k]); ` ` ` `} ` ` ` `if` `(i < j && i <= m-i-2 && j >= n-j) { ` ` ` `for` `(` `int` `k = m-i-2; k >= i; k--) { ` ` ` `res.push_back(matrix[k][j]); ` ` ` `} ` ` ` `} ` ` ` `if` `(i < j && i <= m-i-1 && j >= n-j+1) { ` ` ` `for` `(` `int` `k = j-1; k >= i+1; k--) { ` ` ` `res.push_back(matrix[i][k]); ` ` ` `} ` ` ` `} ` ` ` `i++; ` ` ` `j--; ` ` ` `} ` ` ` `if` `(i == j) { ` ` ` `res.push_back(matrix[i][i]); ` ` ` `} ` ` ` `return` `res; ` `} ` ` ` `int` `main() { ` ` ` `vector<vector<` `int` `>> arr = {{1,2,3},{4,5,6},{7,8,9}}; ` ` ` `vector<` `int` `> res = spiralOrder(arr); ` ` ` `for` `(` `int` `i = 0; i < res.size(); i++) { ` ` ` `cout << res[i] << ` `" "` `; ` ` ` `} ` ` ` `cout << endl; ` ` ` `return` `0; ` `} ` |

**Output**

1 4 7 8 9 6 3 2 5

As we can see that we are getting the Correct answers for the above Inputs.

__Case 2: Chat-GPT is still new and learning__

Though Chat-GPT is able to produce almost every answer and even correct it to most extent, still it is very new and learning. So there might be cases where it shows you incorrect answers, or fail to give you the correct answer the first time.Â

For example,Â

Here’s how Chat-GPT failed to provide complexity analysis for Fibonacci Number Recursion approach the first time.

But gave the correct output the second time.

__Why can’t you trust Chat-GPT to generate the correct output every time?__

Chat-GPT is designed to generate responses based on the patterns and relationships it has learned from large amounts of text data. While it can generate impressive and often highly accurate responses, it is not perfect and can still make errors or generate responses that are inappropriate or irrelevant.

One reason for this is that Chat-GPT lacks the ability to truly understand the context and the nuances of language in the same way that humans do. It may not be able to discern sarcasm, humor, or other subtle cues that can greatly affect the meaning of a message.

**Example:**

**We want to convert the language of any code, Let’s say a C++ program to JavaScript:**

Here is the C++ Code which we want chat-GPT to convert into JavaScript:

## C++

`#include <bits/stdc++.h> ` `using` `namespace` `std; ` `#define int long long ` ` ` `// Function to find Number of subarrays ` `// which are repetition of same array ` `// twice on swapping any number ` `// of elements ` `int` `noOfSubarrays(` `int` `N, ` `int` `A[]) ` `{ ` ` ` ` ` `// Initializing "mp" and "cnt" ` ` ` `map<vector<` `int` `>, ` `int` `> mp; ` ` ` `vector<` `int` `> cnt(10, 0); ` ` ` `mp[cnt]++; ` ` ` ` ` `// Iterating through the array and ` ` ` `// updating "mp" and "cnt" ` ` ` `for` `(` `int` `i = 0; i < N; i++) { ` ` ` `cnt[A[i]]++; ` ` ` `cnt[A[i]] %= 2; ` ` ` `mp[cnt]++; ` ` ` `} ` ` ` ` ` `// Initialize a variable "ans" ` ` ` `// to store the answer ` ` ` `int` `ans = 0; ` ` ` ` ` `// Iterating through the map and ` ` ` `// accordingly updating the "ans" ` ` ` `for` `(` `auto` `it : mp) { ` ` ` `int` `temp = it.second; ` ` ` `ans += (temp * (temp - 1)) / 2; ` ` ` `} ` ` ` ` ` `// Return final answer ` ` ` `return` `ans; ` `} ` ` ` `// Driver's code ` `int32_t main() ` `{ ` ` ` `int` `N = 8; ` ` ` `int` `A[] = { 2, 0, 2, 3, 0, 3, 2, 2 }; ` ` ` ` ` `int` `answer = noOfSubarrays(N, A); ` ` ` ` ` `// Function Call ` ` ` `cout << answer << endl; ` ` ` ` ` `return` `0; ` `}` |

**Output**

4

Command:Convert the below C++ code into JavaScript

Expected Output: 4

Generated Output:Â

Below is the generated code:

## Javascript

`// Function to find Number of subarrays ` `// which are repetition of same array ` `// twice on swapping any number ` `// of elements ` `function` `noOfSubarrays(N, A) { ` ` ` ` ` `// Initializing "mp" and "cnt" ` ` ` `let mp = ` `new` `Map(); ` ` ` `let cnt = ` `new` `Array(10).fill(0); ` ` ` `mp.set(cnt, 1); ` ` ` ` ` `// Iterating through the array and ` ` ` `// updating "mp" and "cnt" ` ` ` `for` `(let i = 0; i < N; i++) { ` ` ` `cnt[A[i]]++; ` ` ` `cnt[A[i]] %= 2; ` ` ` `mp.set(cnt, (mp.get(cnt) || 0) + 1); ` ` ` `} ` ` ` ` ` `// Initialize a variable "ans" ` ` ` `// to store the answer ` ` ` `let ans = 0; ` ` ` ` ` `// Iterating through the map and ` ` ` `// accordingly updating the "ans" ` ` ` `for` `(let temp of mp.values()) { ` ` ` `ans += (temp * (temp - 1)) / 2; ` ` ` `} ` ` ` ` ` `// Return final answer ` ` ` `return` `ans; ` `} ` ` ` `// Driver's code ` `let N = 8; ` `let A = [2, 0, 2, 3, 0, 3, 2, 2]; ` ` ` `let answer = noOfSubarrays(N, A); ` ` ` `// Function Call ` `console.log(answer); ` |

**Output**

36

As we can see that **Chat-GPT is giving wrong answer** after compiling and testing the generated Javascript code.

Additionally, Chat-GPT is only as reliable as the data it has been trained on. If it has been exposed to biased or incomplete data, it may produce responses that are similarly flawed.

Therefore, it’s important to approach any output generated by Chat-GPT with a critical eye and to use your own judgment to determine whether the response is accurate or appropriate in a given context.

__What to do when Chat-GPT fails to solve your Coding Problems?__

If you’re unable to access Chat-GPT efficiently to solve coding problems, there are several alternatives that you can consider:

**Use other online resources**

There are plenty of other online resources available for coding help, such as Stack Overflow, GitHub, Codecademy, and many others. These resources provide tutorials, forums, and other support for a wide range of programming languages and topics.

**Join online coding communities**

Joining online coding communities can be helpful in getting coding help from other developers. You can join forums, chat groups, or social media platforms like Reddit, Twitter, or Discord, where you can connect with other developers and seek help.

**Look for a Mentor**

If you need more personalized and one-on-one help, you can hire a tutor who can guide you through your coding problems. Many online platforms offer coding tutors who can provide help and guidance on various programming languages.

**Attend coding boot camps**

Coding boot camps are intensive programs designed to teach coding skills in a short period. These programs offer comprehensive training and mentorship, and they can be a great option for those who want to learn to code quickly and efficiently.

__Should we use Chat-GPT to solve Coding Problems?__Â

With all these discussions, it is normal to be at a stand-off on whether to use Chat-GPT to solve coding problems or not!Â

Definitely YES!!! But proceed with Caution.

We can solve any coding-related problem using Chat-GPT and it will even answer the query in seconds. The only thing we need to concern about is that we should provide every single required detail to the textbox In-order to get the expected results, and verify every result it generates because after all **Chat-GPT is still LEARNING!**