gnar1zard / group8 Goto Github PK

Code is utterly lacking any form of documentation to describe the functionality/implementation. Needs detailed comments to describe the code/logic.

This method is meant to calculate the Euclidean distance between a passed in data point and every point within a passed in array. It returns an array with the distances between each point. The code likely needs slight refactoring to make it overall more efficient and slightly more readable

Current test file has no documentation whatsoever. This issue needs to be addressed and completed asap. Seeking to add comments and function descriptions.

Unity's LEGO code is hard to understand due to various reasons. There little to no documentation to help the viewer understand what or why code bits exist. In addition, there are certain syntactical elements that are new to me, and I cannot understand what they do.

This issue involved the complexity of recursive mergesort. While at this point in our programming careers we are all very much aware of recursive merge sort, to newer programmers it can often appear as a very daunting task. So, this issue will attempt to use ChatGPT to make the complex algorithm more simple for newer programers.

This is a Java test file that simulates the creation of a 3x2 game board for PacMan. The test file however is severely lacking documentation. Comments need to be added to detail what each of the tests is doing as well as explain the creation of the board.

The code snippet I am focusing takes in a dataset and provides an SVM using different kernels and compares the results amongst the kernels. The areas which need improvement the most are the codes readabilty, reduced redundancy, as well as improved mantainabiitly. My goal with refractoring is to improve all of these as well as possibly increase the accuracy of the results from the use of libraries.

This code is meant to implement the KNN machine learning algorithm. However, the code needs additional documentation and ChatGPT will be used to do so

The code is used in a game world to paint over the terrain whenever a specific object moves there. It is fairly optimized but lacks clarity due to how the code is written and the methods use to accomplish this.

This code snippet is meant to read out of a file and count up the votes then declare a winner. It uses hashmaps to do it. However, the code itself is quite bulky and complex so something should be done to make it more simple.

• Several values are duplicated
• Generally hard to read

Group8/gpt/RyanA_gpt/RyanA_complicatedCode.py

While the function works and is optimized with memoization, its current implementation could be confusing and might not be safe in all usage contexts.

The current file is not intuitive and could use some work for overall better readability.

This C# file lacks general comments or documentation explaining its use and function. The file holds registry data for units that are being created with UnitType and has some obsolete methods that are no longer in use.

I have a Classification project in which my from scratch KNN algorithm exhibits a lack of proper documentation and has very few comments explaining what is going on. This serves as a problem for anyone that I show this code to and I would like chatGPT to remedy this situation by adding proper documentation to my KNN function.

While pre-emptively looking into potential pathing solutions for our game project I came across the A* pathing algorithm as a generally recommended algorithm for NPC pathing logic for games in unity. I decided that it might be a good idea to have ChatGPT break this algorithm down into more digestible segments and to potentially refactor portions of it to be more understandable. This code segment was not written by me and was grabbed from the public repo at this link:
https://github.com/LostTrainDude/astar-pathfinding-unity/blob/master/Assets/Scripts/AStar.cs

While looking in some of my first year programming projects I found a function in a C++ Reversi project that exhibited terrible amounts of code duplication when checking for player input. Rather than using an intelligent solution like a bool flag on player 1 and 2 to cut down on duplicated code, I seem to have mostly copy and pasted the player 1 code for player 2, creating a huge amount of extra code that could be cut in half. I am going to ask reversi to refactor it to properly use a bool flag for player 1 and 2 and also to remove redundant if -> else if statements that could either be one if statement and/or make them into a more readable inverted condition statement.

The issue arises from the fact that each logging function does essentially the same thing: it formats a message with a specific log level (INFO, WARNING, ERROR), fetches the current time, and prints the message to the console. The only differences are the log level and the message itself.

The following code is meant to handle weapons in an FPS game. The idea of this class is not hard to understand overall however looking into the implementation that has little documentation the code can be hard to follow in some instances.