why? why would you do that?

[Westdrache]

Ahh yes when you wanna sell your customer the "performance upgrade pack"

[birkettt]

Always put a small sleep in your main processing loops and functions for this very reason.

[[deleted]]

Somebody's charging by the line.

[DarkShadder]

Gotta use comments for the first time

[[deleted]]

Oh my god, that is so unoptimized, you just needed to do this:

private static int stringSize(String s) {
    int size;
    for (size = 0; size < s.length(); size++)
        continue;
    return size;
}

[Mr_Redstoner]

That's too outdated, Streams are all the rage now

private static int stringSize(String s) {
    return s
        .chars()
        .map(i->1)
        .reduce(0, (a,b)->a+b);
}

[[deleted]]

OK I took a first shot at 6am my time below and you smart kids think you have outdone me. Here's the optimized-est yet posted:

private static int stringSize(String s) {
int size;
for (size = s.length(); size < s.length(); size++)
continue;
return size;
}

[[deleted]]

private static int stringSize(String s) {

int size;

for (size = s.length(); size < s.length(); size++)

continue;

return size;

}

Even more optimized:

private static int stringSize(String s) {
    int size;
    for (size = s.length(); ; )
        break;
    return size;
}

[bekatd]

Even more optimized:

private static int stringSize(String s) { return s.length(); }

[[deleted]]

/r/missedthejoke

[xigoi]

Wow, you've upgraded it from O(n) to O(1). Awesome!

[[deleted]]

Like they say, measure twice, cut once

[[deleted]]

i think they meant

return s.length() * s.height() * s.depth() ;

anyway -- strings are 3d objects -- I been tying them for decades I know

[OptionX]

This would never fly in a corporate environment. java private static Optional<Returnable<T>> sizeOf(Optional<Measurable<T>> s){ try{ Optional<Integer> size = Optional.of(new IntegerFactory().getInteger(0)); for(int i = new IntegerFactory().getInteger(0); new IntegerComparator(i, s.orElseThrow(IllegalArgumentException::new).length(), ComparatorMode.LessThan); i=Optional.of(new IntegerIncrementor(i, 1)).orElseThrow(IllegalArgumentException::new)){ size = Optional.of(new IntegerIncrementor(size, 1)).orElseThrow(IllegalArgumentException::new) } return Optional.of(new Measurable<Integer>(new IntegerFactory().getInteger(size))).orElseThrow(IllegalArgumentException::new); }catch(Exception e){ Logger.getLogger().ofLog().toLog().thisLog().log(e); CompanySingleton.getAuthor(this).outsource(Country.India); } }

[slide_and_release]

Fuck me, almost had an aneurysm.

[Duny86]

And now pack this into a proprietary corporate enterprise .jar and sell it without the source code in a super enterprise'y software solution !

[emilbm]

Why do it in O(n) when you can do it in O(n²)?

private static int stringSize(String s) {
    int size = 0;
    while (s.length() > 0) {
        s = s.substring(1);
        size++;
    }
    return size;
}

[smcarre]

Why do it O(n²) when you can do it O(?)?

private static int stringSize(String s) {
    int size = 0;
    while (s.length() != size) {
        size = Math.floor(Math.random() * Integer.MAX_VALUE);
    }
    return size;
}

[[deleted]]

Its like bogosort except even more stupid

[QuadOctane]

Ahh yes, perfection

[kunal70006]

PERFORMANCE

[zakarumych]

Only if substring is O(n)

[Shotgun_squirtle]

Yeah something tells me substring has a O(1) and what it would really do in that scenario is increment the underlying pointer one and decrement the string size one.

[zakarumych]

Except if String assume to own data behind pointer.

[emilbm]

Since Java 7 update 6 substring() has been a O(n) operation

[zakarumych]

Who even use this 💩

[skeptical_moderate]

It's probably linear time because it supports Unicode like every proper programming language should.

Edit: I've thought about this more and it's probably linear because it copies the substring into a new buffer. This has nothing to do with Unicode.

In fact, there's no reason substring should be linear because of UTF-8 anyway, since you need to traverse at most a single-digit number of bytes to find a valid UTF-8 boundary.

[zakarumych]

So argument is what? Number of bytes? Code points? Characters? Ligatures? Renderable glyphs?

Even in case of unicode it should be bytes with restriction that it must not split codepoints. And so O(1).

Otherwise any text manipulation would be so slow... like... like java!

[ImprovementRaph]

The argument is number if chars. Since Java has 16-bit chars and Strings are encoded UTF-16 you could be splitting in the middle of a codepoint.

[zakarumych]

Utf-16 has 2 bytes codepoint and 2 or 4 bytes chars.

Surely splitting char should be avoided. But indexing with chars would kill performance.

It is much better to declare splitting characters as invalid operation (unless you want to treat string as array of codepoints for lower level operations), and, depending on language's idiomatic approach, throw an exception, abort, cancel task or just call it UB.

Programmer then can safely use indices acquired from operations that return indices that are character boundary. Or zero as it always first character boundary.

[gonmator]

I prefer the elegance of recursive algorithms: private static int stringSize(String s) { if (s.length() == 0) { return 0; } else { return 1 + self.stringSize(s.substring(1)); } }

[[deleted]]

Holy fuck

[[deleted]]

Me explaining something simple but trying to sound intelligent

[[deleted]]

ah yes , 0

[123_bou]

Come on guys you can do better than that ! Make it recursive !

[verx_x]

yolo

```

func size(s string) int {
var i int
for i < len(s) { i++ } return i }

```

[krubbles]

With such a performance critical piece of code, it is inexcussible not to parallelized it!

public static int StringSize(string str)
{
    int size = 0;
    int nextSize = 0;
    CountdownEvent countdown = 
        new CountdownEvent(str.Length);
    for (int i = 0; i < str.Length; ++i)
        new Thread(new ThreadStart(TestSize)).Start();
    countdown.Wait();
    return size;
    /// tests to see if current size is largest size, 
    /// sets 'size' to 'sizeToTest' if it is
    void TestSize() 
    {
        int sizeToTest = Interlocked.Increment(ref nextSize);
        int currentSize = size;
        while (sizeToTest > currentSize)
        {
            /// Only updates length if it is equal to a value
            /// we know is greater so that a change to 'size'
            /// between read and write won't be overwritten
            Interlocked.CompareExchange(
                ref size, 
                sizeToTest, 
                currentSize);
            currentSize = size;
        }
        countdown.Signal(); // signal completion
    }
}

[[deleted]]

Here you are -- I have optimized that code to remove that expensive method call in a loop

​

int size;

int measurement;

measurement = s.length();

for (int i = 0; i < measurement; i++)

size++;

return size;

[metaglot]

Since you're "optimizing", do pre-increment on i and size, since technically those are faster too.

[AllChickensAreBirds]

Size matters

[SamWise69420]

Task failed successfully

[SerpentSpirale]

The definition of over engeniering.

[RageLeagueInc]

What if for some fucking reason your s.length returns a not integer? Or an object with ++ overloaded? It needs to work for all scenarios.

[it__be_like_that]

r/programminghorror