Is there a single word to describe a solution that hasn't been optimized?

You might try pre-optimized code.

How about the initial version of the code?

If you are bent on using a single word here draft is the first one that comes to my mind. According to Merriam-Webster:

a version of something (such as a document) that you make before you make the final version

More specifically:

5 a : delineation, representation
b : scheme, design
c : a preliminary sketch, outline, or version

Otherwise I think the suggestions made by @Othya are quite fitting:

initial implementation, beta and alpha

All the more when considering a software related environment.
Seeing as you are talking about code the difference between optimized and non-optimized code may very well be a different algorithm so picking out an easy-to-spot feature of the different algorithms as namesakes might be another approach. As an example consider Insertion-Sort versus Merge-Sort.

Speaking as a professional programmer, I would say "unoptimized," even though it is not a dictionary term, is sufficiently conducive of your meaning, especially to other programmers. Furthermore, it is a term I personally use on a regular basis.

Despite its non-word status, even to the non-technical person (e.g. a client or a high-level executive), the general meaning of the term is immediately intuitive.

You might consider referring to the original solution to a problem as a hack, call it hackish, or say that it was hacked together, especially if the solution is rough. It's not uncommon for robust, optimized code solutions to evolve from humbly hackish beginnings.

This wouldn't work if your initial, non-optimal solution is well-formed and carefully crafted. I'd also hesitate to use this term in professional documentation or in communications with anyone outside of your developer peer group (e.g. bosses, customers). In these scenarios, I'd stick to the other answers provided here.

I usually hear the initial implementation of a piece of software referred to as version zero, but I have heard initial version used often as well.

Since you should not be optimizing code without first profiling it, the term you should use on code that has unknown performance issues is unprofiled.

If the code has been profiled, it means that if performance is a problem, the sources of the performance issues have been identified, but not yet fixed. I would say the code still has performance bugs, or use the negation of the technical term performant, and say the code is nonperformant.

I like prototype for this.

It conveys that it is unfinished or unrefined, without attacking it by referring to it as a hack, or venturing off-industry to use words such as draft.

Prototype can (in some situations) connote that the product is still missing features or design assets, so if you want to make it clear that these are not the case, you can manage these expectations by saying, working prototype or even final prototype - but if you don't, all you really risk is impressing people with how complete the product appears.

{Note however that, conversely, in other situations, "prototype" means precisely a very rough yet finished version which, specifically, contains every single feature which will be present in the final product. Then again, in certain milieu, prototype means very specifically: the first hand-produced item which is precisely and totally exactly as the final product should be, representing the final quality and finish of the product for sale, once the final product comes off a production line.}

alpha and beta are also good words for early, functioning-but-not-final versions of code in progress, but these refer more to a project-in-whole (or a version thereof), while a prototype can refer to a single feature.

Some general words that might be are:

Crude

Half-baked

There is no one word to your situation exactly. "first iteration" and unoptimized are two different things. A first iteration of code may be highly optimized or a highly mature codebase may have zero optimizations, most of the time new code is not optimized but there is no direct correlation. Also optimization can mean a few things: run time optimization, compile time optimization, source code optimization etc. I think in your case you are talking about source code optimization.

Also it is confusing to me that the code is at its initial version but it is slower than the optimized one, what is the optimized one if there is only an initial version?

More context would help. I'm a software engineer, non-optimised code is just called non-optimised. An inelegant algorithm might be brute force or you might just describe a first stab at some code as crude, clunky or ugly.

I'm a little out of my depth here, in terms of the names of parts of speech, but "optimized", when used as an adjective, is apparently known as a deverbal adjective. And, according to that reference, deverbal adjectives may be modified with ordinary prefixes, such as "un".

Therefore, "unoptimized" is a perfectly valid word.

'First pass' could refer to an initial attempt. It doesn't have the 'not finalised or released officially' connotations of draft or beta.

I also think that these days 'v1.0' is acquiring a general using meaning 'first attempt before refinement' beyond its strict software definition.

There is an idiom in general usage (at least in the US), "quick and dirty," which means something that was expedient and easily done but is not of the best quality. In the software business this phrase is often used to describe code that was written with the goal of getting something that "works" as soon as possible, without any attempt to optimize it (or, usually, to do many of the other things that would make a piece of software viable in the long run).

This is especially applicable to the first version of a piece of software. So if you want to emphasize that the code you are working with is only in its first iteration, and there has not been time yet to optimize it, you could call it quick and dirty code.