Hello, today we are testing free artificial intelligences, GPT-3.5 and the new one from the company. I will not be working on projects but rather on separate functions, on small micro-tasks.

Let's see how they handle it. Here, we have a task to remove all elements from an array except for the first and last ones. The array should be modified, meaning if we have an array like this, it should remove the middle elements, and the resulting array should look like this.

Let's try to check what happens. We will edit this in ChatGPT and send it here. It shouldn't hang; right now, it has a heavy load due to the hype.

So, let's see. I decided to increase it. Yes, it seems like a cool solution. The array is fine; that's not its problem. So, GPT provided an alternative solution, essentially using a slide and doing a lot of checks, with many comments explaining the code. It also provided an example.

By the way, there is also an example here. In principle, an equivalent solution can be checked through recording; it is absolutely correct.

Great, so far so good. Ideally, it should be smarter; it has what is called a chain of reasoning.

The second task is to write an extension method for the standard array class so that we can get a new array as a result. Here is an example given. This method should be pure and should not mutate the original array. The iteration goes element by element: the first with the first, the second with the second, and the third with the third. This should be clear from the example.

I believe I have said everything needed. The instance extension method, yes, it is an instance because it is called on the array. The task seems to be set correctly. Let's check what happens.

So, here we go. There are some errors, but I wrote it myself, so I think it should still be clear what is meant. The method simply takes an array. ChatGPT responded instantly.

Oh, they also need to be of the same length. We need to state that they are of the same length.

Ah, I see. I don't set very good tasks. So, let's see what we got here. Index, then Map, that is possible. Yes, that can be done.

Good solution. Let's see what we have.

Yes, there is also a check for errors. Okay, the class is correctly defined. It used Zip, and I did something similar in one of my previous videos.

In principle, again, this is an alternative solution. GPT's solution is based on Zip. Let's place the code solutions side by side. Each solution has its pros and cons.

The thing is, Zip essentially creates an intermediate array of pairs, and then we only do the mapping. Here, the intermediate array will not be created, so this solution is a bit longer. It may not be as high-level, but it uses less memory, so it will work faster.

This solution is shorter, but it is more high-level. In Ruby, by the way, I inserted it incorrectly. I inserted it in the wrong place; this is Ruby.

In Ruby, this is usually faster. I would prefer that. On the other hand, arrays can be large and can accumulate.

So, yes, it is not obvious. In general, we managed to do it very quickly, actually without any problems.

Okay, let's move on. Here, maybe I forgot some conditions again.

The next task is to write a function that does not use... Well, let's say using only the methods Push and Pop.

So, we need to write a function in CSP that would use these standard stack methods. In CSP, we have a built-in generic collection called Stack.

This function should remove duplicate elements, specifically consecutive duplicates. For example, if we have a sequence like A12 3 A 4 5 6, it should remove the second A.

From the example, it may not be obvious that duplicates can be adjacent, so we should clarify that we need to remove them completely.

Let's add an example to make it clearer.

So, let's add that the function should return a new stack. Mutation of parameters is allowed and even encouraged.

Let's add that we will only use these methods. This is a task for algorithmic thinking.

Let's quickly provide an example. For instance, something like this should transform into this.

The description is generally clear. Yes, there is an example, and mutation is allowed. We can add a static function if needed.

So, let's write it down. Yes, additional functions are allowed if necessary.

Let's take our code, insert it, and run it.

Something strange is happening with it. Well, it seems to be working.

Yes, it works.

So, ChatGPT finished and explained the work.

Well, it is roughly the same speed-wise.

Let's see what we got. I will copy this.

So, CSP, yes, I will just insert it into the class now.

This is ChatGPT 3.5, specifically the free version. There is also a paid version that is smarter.

So, for now, let's move the usage; maybe we won't need it, but let's keep it just in case.

Let's see. It connected everything. Great job!

I already have it as a separate class. Let's not format it.

So, here is our function. Yes, the correct name comes in.

If the collection is empty, just return.

Well, we should consider some special cases.

When formatting, it is usually recommended to either format it like this or use brackets.

In many style guides, this is done because when the code is written like this, the probability of error slightly increases.

Here, the risk is not that high, but still, I personally don't like it.

I try to teach students not to write like this.

It is better to write like this if you want to do one command.

This check is not super necessary, as we are still creating a new stack if the stack is empty.

So, here, a new stack is created.

We didn't save on that.

One variable is created.

Okay, and then these checks will be two.

I agree there is a difference, and then the return is also there, so two checks against one.

When this check is there, it turns out that in 50% of cases, it is one case.

We speed up other cases a little bit.

So, the value of this check is questionable in my opinion.

Let's leave that comment.

So, what else does it do?

Okay, it creates a new stack and remembers what it last pushed there.

As long as there is an element in the original stack that can be changed, we are extracting from the top of the stack.

If the previous element we pushed into the new stack is either not there or is different from the current one, we push this new element and remember it.

What else does it do?

An arithmetic moment is that if we extract from the stack using Pop, the elements will be extracted in reverse order.

So, when I extract them, they will go like this: dcba.

This means the stack will be reversed.

I used to have the start of the stack here, and now the start of the stack will be here.

You can analyze this; it is a well-known fact.

Therefore, it wants to reverse everything.

So, it has a temporary stack and then uses the original stack as another stack that is emptied.

To avoid creating a new stack, it returns this stack.

Formally, mutations of the original stack were allowed, but then the task becomes a bit strange if we duplicate the stack.

It was meant that this stack is just emptied, so it uses the original parameter as a temporary stack.

It is clear that creating another one would add some load.

For example, if it created two here, it would just reassign everything.

The task allowed it, but we still use it additionally.

So, on the other hand, there is nothing to complain about because any mutations of the stack were allowed.

But this pattern of reversal, if repeated, would result in extracting, pushing, extracting, pushing, and it would reverse.

So, it goes through the stack in the original order, and the first non-repeating element is pushed.

This is correct.

Well, there were no other options here.

Great, let's see.

I hoped that ChatGPT would struggle with something.

I needed to come up with a more complex task, apparently.

Let's see what the disk returns.

Okay, we have some code here.

This is an example it generated.

Okay, fundamentally, it also decided to do it interestingly.

They both decided to do it this way.

Let's see what it came up with.

It also decided to check for null.

This is a controversial area.

Do we need to check for null or not?

It seems to me that we are coming to a stack that does not exist and returning an empty stack.

Strictly speaking, this was not mentioned in the task.

So, in principle, this can be considered okay.

On the other hand, it seems unnecessary.

This is a controversial area.

I personally don't like how they format this.

It is usually not recommended to do it this way.

So, why are we creating a new one?

Maybe we should return null instead.

This is a controversial area.

It is not an error in any case.

I don't know; I would consider it an error if I started checking.

I would either consider it a complete error and stop working or return null.

If I want a quieter handling, this is a very quiet error handling.

It completely hides the error, and we can work directly with the stack if it came in by mistake.

This will lead to further errors.

So, this idea is quite controversial.

In modern C#, there is a nullability feature.

I don't know if this nullability is applicable.

If you know, please write in the comments.

So, this can be done, but it probably needs to be in strict mode.

Well, this check for null is a bit more appropriate in this case because it creates one stack.

Let's shorten its code a bit.

There are too many comments explaining simple actions, which programmers usually don't do.

For example, it says, "Temporary variable for saving the last extracted element."

From the context, it is clear that it is probably an element.

And probably this is a temporary variable since it is called "last."

It is definitely a variable because we see that it is a variable.

It doesn't explain what it means and why it is so.

Explanations are great for understanding the code, but leaving comments like this is not very convenient.

In an integrated environment, you can probably turn this off.

Nevertheless, I personally prefer how GPT explains it separately.

This is a nuance, but it is not very important.

So, let's see what we have in the end.

It creates one stack and then does exactly the same as GPT.

Right, it was called "last," but it is not essential.

I like that it created a separate stack and didn't torture the original stack additionally.

I don't know why I prefer this option a bit more.

Maybe it empties the stack that was passed instead of using the original stack for its purposes.

In any case, this is a problematic task.

But this task is specifically designed so that Pop can be done easily.

So, everything is practically the same here, just through a new variable, which I like a bit more.

So, this is a bit better.

This check is also a bit more meaningful here because it creates two.

This makes sense to reduce the location.

I don't know; it is also questionable.

Well, everything is super.

The last task is to write a function called "reachable."

The function should check if it is possible to reach point A from point B by taking steps.

This is also a pretty simple task.

I didn't expect that there would be more questions and discussions.

In general, the function checks if point B is reachable from point A by moving with a certain step.

These points can be located in any order; they can be from left to right or right to left.

So, A and B can have negative steps.

Let's add that the function checks if point B is reachable.

If someone starts at point A and moves with a certain step, we can add that.

Okay, let's see.

So, it seems that it shouldn't do these checks.

This is also a controversial topic.

Should we check them or not?

Although probably, we should return if accidentally.

Let's not do that; I don't want it to generate this code.

Let's see what happens.

So, again, this is not the right place.

ChatGPT, let's run it.

ChatGPT wrote everything.

Okay, let's copy it.

So, we are copying the Scala code.

So far, everything is cool.

I just asked it to write something, and it didn't handle it.

The task was more complex; it needed to write a whole module that extended another module from a known library.

So, this is the second solution.

I copied it with the test.

So, the main thing is not to mix anything up.

I asked it to just create a function.

Yes, write a function.

Here is the function.

Yes, here is the function.

I think ChatGPT went the right way here.

It decided to write everything out, creating some kind of object for no reason.

This is strange; how do I call this function now if it is in an object?

It just inserted it into this object.

I don't know; I didn't like that it decided to put it into an object.

Why?

Okay, let's compare.

So, here we have ChatGPT, the free version.

The paid version is more powerful.

So, let's look at "reachable."

The start and step types are correct.

The return types are defined because it seems that is required.

If the step is zero, it should return.

If the points are the same, then if the step is zero, the start and end should be equal.

So, if we have a zero step, we cannot go anywhere.

This is nicely formatted.

It didn't create a second one.

Instead, it went mathematically and subtracted the delta from the end and start.

So, there is some delta between A and B.

Let's call it delta.

He simply divides this delta by the step.

He checks what that results in.

So, division in Scala works like in Java.

If these are real numbers, the division will be real.

So, first, he determines that they are co-directional.

He decided to check it this way.

By the way, division is definitely possible here because the step is not equal to zero.

At least in the first approximation, we can divide.

In principle, yes, because if they are co-directional, then the delta is positive, and the step is positive.

If the delta is positive and the step is positive, then their ratio will also be greater than zero.

If the step is not equal to zero, at least, or equal to zero, it can only be if the start is equal to zero.

Then, in any case, it is reachable.

He also checks that the delta, which is the distance between A and B, is oriented.

So, it is zero in magnitude.

Is the magnitude even applicable to doubles?

Did they do that?

I don't know; I think the magnitude is only applicable to integers.

Let's check what this is.

So, to run this, we need to have a main method marked.

In simple cases, there are other simpler ways to run it.

So, let's try, for example, 1.5 in magnitude or 70 in magnitude.

So, 1.5.

Yes, it works.

Scala is great; I didn't know that.

So, it checks that with such a step, it is possible to reach this distance by moving with that step.

So, why is this check needed?

What is the orientation?

Because in magnitude, there is no sign.

In the end, it could result in reverse movement.

For example, if I have A as 10 and B as 20, but the delta is -1, it would be A, and the signs would be a problem.

You should analyze this; it is a well-known fact.

So, it wants to check the orientation.

This is an interesting solution.

Let's see what the code is doing.

So, it decided to create an object called "sone."

This is a class and its instance at the same time.

It probably confused it and decided to create this constant here.

So, it starts talking about the problems with real numbers.

That they are approximate numbers.

And there can be accumulated errors.

Even without that, it creates a static method.

So, the static method "reachable" is also boolean.

And it also handled this case, by the way, just like GPT.

It starts with the step being zero.

It doesn't use brackets, but honestly, as far as I know, this is not how it is written.

This is old syntax.

In Scala 3, it should be written like this.

If we want it in one line, it should be like this.

If in two lines, it should be like this.

I don't know why he chose this old version; it is not very clear.

So, this is an outdated syntax.

Then he decided to go this way, more readable, let's say.

Here, he really made everything very compact.

Maybe it was worth separating it a bit.

This is probably a small minus of this solution.

But it also depends on the culture of the project you are working on.

So, good code can be written like this.

The main thing is not to jump between different styles, such as more detailed and self-documenting code and more compact computational code.

Here, he went with a more compact style.

These comments I really don't like.

All this about calculating the difference between the end and start is unnecessary.

This is an example of an anti-pattern of excessive commenting.

The check for the difference with tolerance is also unnecessary.

He called it delta or difference.

Then the same goes for the step.

But he went an interesting way through mabs.

I thought we write "mabs" with a lowercase letter in Scala.

Strangely, you can write it with a capital letter too.

I have only seen it written with a lowercase letter.

I am not an expert, so I don't know if this is normal or not.

It looks like some Java style.

So, the key difference is that here, we compare the EPS.

Here, we just do the math.

I hope everything is perfect.

In the end, I think this solution is better because it is more practical in production.

This will be a more useful solution that will make sense in most cases than just transferring the math to floating-point numbers.

I didn't like how he formatted everything.

I wouldn't have included this constant here.

But maybe he meant that there would be some general constant in the program.

I would have made it an optional parameter, for example.

This could be an interesting option.

Of course, the task had all the parameters specified.

Here, it seems like too much freedom.

But I would still go for it.

Personally, I would have made the tolerance.

Or this is also called "if short."

I would have set it to 1, maybe even -9, depending on how many calculations are happening.

Let's take -9, for example.

So, by default, it will be like this.

But if desired, it can be changed.

The only thing is that this object will no longer be needed.

The constant will be a parameter now.

There will be micro-overheads for passing this new parameter, which may often not be needed.

I don't know; I think this is not worth it.

This is not a good idea.

It is important to consider the context of what you are doing.

If it is some kind of numerical task, that is one option.

If it is just a regular code, then it requires performance.

So, this is the test.

This test is not needed, actually.

Let's check our test.

So, this should work, but let's check anyway.

It should work.

So, is it reachable from -0.9 to 0.4 with a step of 0?

Let's check.

Oh, I changed it.

That was my mistake.

Let's rewrite the syntax.

I don't like this old syntax.

I don't want you to see this.

Let's use mabs.

I don't know how to do it correctly.

Honestly, I need to Google it to see how it is done.

I think it should be like this.

So, it is unreachable, by the way.

This is very strange.