
Show HN: Design, data-structure, algorithm problems and their solutions - sangupta
https://github.com/sangupta/ps
======
ploggingdev
In
[https://github.com/sangupta/ps/blob/master/solutions/2016/fa...](https://github.com/sangupta/ps/blob/master/solutions/2016/fastest-
sorting-integers.md) the solution for fastest integer sorting is wrong.

    
    
        / build the boolean result array
        boolean[] result = new boolean[array.length];
        for(int index = 0; index < array.length; index++) {
          int num = array[index];
          result[num] = true;
        }
    

The _result_ array is the same size as the original array.

But when you do:

    
    
        int num = array[index];
        result[num] = true;
    

The index being referenced in the _result_ array is dependent on the value of
_num_. So if _num_ is greater than or equal to the length of the array, it
throws an _ArrayOutOfBoundsException_. And what happens when you try sorting
an array with elements having the same value?

Eg- try sorting {10,5,9}

Unrelated: HN needs to allow highlighting code inline.

~~~
sawmurai
Yep, should be

boolean[] result = new boolean[Math.max(array)];

~~~
ploggingdev
That won't be efficient memorywise since the size of the _result_ array is
dependant on the largest value in the array of values.

Consider sorting an array of 2 large integers {65000,30000}. To sort this
array, the result array will be initialized with 65000 elements. _Very_
inefficient.

~~~
sangupta
Using a sparse bit-array will reduce the memory space of the problem.

~~~
sangupta
I can work up one. Choosing the right bucket will be O(1) as the index is
integer. We can store the buckets for lookup in a hash-table or an array-of-
arrays, which again will be O(1). Reaching to the actual index should again be
O(1) - unless am messing something here.

------
rhardih
This phrase is misleading:

 _The fastest time to sort an integer array is O(N)_

It could be interpreted as generally applicable. The proposed method uses
reverse-indexed flagging, an approach which isn't really feasible if element
values are very large.

Generally, the lower bound for any comparison based sorting algorithm is Ω( n
log( n )).

~~~
EllipticCurve
That is true. Just want to add, that the lower bound for sorting is O(n
log(n)) for comparison based sorting in infinite universes. The comparison
based factor rules out sorting of any element, that can not be reduced to an
integer. Infinite universes in sense, that we don't know about the
elements/element-range beforehand.

Sorting in θ(n+k) w.c. and a.c. (most of the time this is equal to O(n)) is
possible for finite boundaries that allows for countingsort or bucketsort
(radixsort uses countingsort internally).

Some implementations of those algorithms in Python:
[https://github.com/MauriceGit/Advanced_Algorithms](https://github.com/MauriceGit/Advanced_Algorithms)

------
vijayr
Is there something like this for designing of databases? software
architecture? For example, things like - learning to design a HIPAA compliant
user database, designing a micro services architecture for a small but well
defined problem etc?

~~~
dtauzell
I think that falls more into the "patterns" space as the problem being solved
is not so clear cut. Here is a site with microservices patterns:
[http://microservices.io/patterns/](http://microservices.io/patterns/) .

------
joakleaf
A lot of discussion on bucket/pigeon hole sorting and O(n log n), but nobody
mentioning(?):

Integer Sorting in 0(n sqrt (log log n)) Expected Time and Linear Space, Yijie
Han and Mikkel Thorup, FOCS '02 Proceedings of the 43rd Symposium on
Foundations of Computer Science Pages 135-144

[http://dl.acm.org/citation.cfm?id=652131](http://dl.acm.org/citation.cfm?id=652131)

... Just thought I would throw it out there.

~~~
sangupta
Thanks a bunch. I mentioned similarities to bucket sort earlier in the day.

I will go over the mentioned paper and also mention it as a reference.

------
qwertyuiop924
After going back to solve last year's Advent of Code, I realized that I
_really_ need to know more about algorithms. So this is handy.

But I still can't solve last years' AoC. Oh well. I guess I'll just have to
keep working on it.

~~~
sn9
Check out Sedgewick's Algorithms course on Coursera.

~~~
qwertyuiop924
Thanks for the suggestion.

