that's new,,why do you choose rust boss of all this other languages

operAhdam:
that's new,,why do you choose rust boss of all this other languages

Cause it's one of the best programming languages ever, honestly you should try it.

Deicide:
Cause it's one of the best programming languages ever, honestly you should try it.

e easy pass python

Explain the question well, shuffle array as in how?

Think4Myself:
Explain the question well, shuffle array as in how?

You never play WHAT before? How them day take shuffle cards. Let's say you have input [1,2,3] you can shuffle it to be [1, 2, 3] or [1, 3, 2] or [3, 1, 2] etc

operAhdam:

e easy pass python

No but way more faster than python

Deicide:
Cause it's one of the best programming languages ever, honestly you should try it.

As a C++ and Python programmer, I can tell you that this code is not 'readable' by human eyes... is this even a HLL?

Ikechukwu183:

As a C++ and Python programmer, I can tell you that this code is not 'readable' by human eyes... is this even a HLL?

That's because Nairaland code formatting is useless.

Deicide:

You never play WHAT before? How them day take shuffle cards. Let's say you have input [1,2,3] you can shuffle it to be [1, 2, 3] or [1, 3, 2] or [3, 1, 2] etc

Ok

As a Java dev I can't read the code The while loop is not in addendum to Java way of implementing while loop.

Deicide:
Was able to come up with this using rust.
...
Can someone improve on this? use whatever programming language you like. And are there other rust programmers on this section? Complexity of this code? O(2^n) yeah it's that terrible.

There is a problem that causes infinity loop in this code can you spot it?

from random import randrange

def shuffle(arr):
  for i in range(len(arr)):
    rand_idx = randrange(len(arr))
    arr[rand_idx], arr[i] = arr[i], arr[rand_idx]
  return arr
  
  
arr = [1,2,3,4,5]
print(shuffle(arr))

Here's something pretty simple, time complexity should be O (n log n), since the time complexity of the randrange function is O (log n).
It's being quite a while since I did anything in rust, I don't want to fight the borrow checker right now Rust used to be my favorite language but it's just too painful to do anything substantial with it, try implementing a doubly linkeldlist in Rust and you'll agree that C++ is easy compared to Rust.

namikaze:

from random import randrange

def shuffle(arr):
  for i in range(len(arr)):
    rand_idx = randrange(len(arr))
    arr[rand_idx], arr[i] = arr[i], arr[rand_idx]
  return arr
  
  
arr = [1,2,3,4,5]
print(shuffle(arr))

Brilliant one

namikaze:

from random import randrange

def shuffle(arr):
  for i in range(len(arr)):
    rand_idx = randrange(len(arr))
    arr[rand_idx], arr[i] = arr[i], arr[rand_idx]
  return arr
  
  
arr = [1,2,3,4,5]
print(shuffle(arr))

Nice one

parkervero:
As a Java dev I can't read the code The while loop is not in addendum to Java way of implementing while loop.

You just have to get used to it to love it

Ikechukwu183:
Brilliant one

Python for the win

Deicide:
Nice one

I modified my post, check it out.

namikaze:

Here's something pretty simple, time complexity should be O (n log n), since the time complexity of the randrange function is O (log n).
It's being quite a while since I did anything in rust, I don't want to fight the borrow checker right now Rust used to be my favorite language but it's just too painful to do anything substantial with it, try implementing a doubly linkeldlist in Rust and you'll agree that C++ is easy compared to Rust.

Yeah I agree there are something that are Impossible in rust without using the unsafe key work like i probably did in my code to reduce time & space complexity. But I love the language it makes you as a programmer to be very careful with what you write.

Can you guess the complexity of my code since lookup in a hashmap is O(1) so am thing O(n^2 + random(n)) I don't even know what that means

I'll like to see someone try this with JS

TastyFriedPussy:
I'll like to see someone try this with JS

It'll be easy with Js

Deicide:
Yeah I agree there are something that are Impossible in rust without using the unsafe key work like improbable did in my code to reduce time & space complexity. But I love the language it makes you as a programmer to be very careful with what you write.

Can you guess the complexity of my code since lookup in a hashmap is O(1) so am thing O(n^2 + random(n)) I don't even know what that means

My guy even with the unsafe keyword it gets complex real quick, I know what I faced when I tried implementing a doubly linkedlist in Rust, it was crazy. Memory management in C/C++ is much simpler than in Rust.
I agree though learning rust will make you better developer overall.

Guy you're brave, using recursion inside a while loop, I hail thee loolz, well let me see if I can figure out the complexity...

Deicide:
It'll be easy with Js

Sorry, what's the role of the count parameter?

namikaze:

My guy even with the unsafe keyword it gets complex real quick, I know what I faced when I tried implementing a doubly linkedlist in Rust, it was crazy. Memory management in C/C++ is much simpler than in Rust.
I agree though learning rust will make you better developer overall.

Guy you're brave, using recursion inside a while loop, I hail thee loolz, well let me see if I can figure out the complexity...

Even on reddit they would advise you not to implement a double linked list or even a Linked list in rust exexpt you wanna run mad But you can use Box<T> to make the running mad slower

My code actually runs fast despite the recursion, it mostly just depends on if it gets the random number right. Best case would be O(n) but that's impossible but it can happen just that the chance are small especially if the input is large.

I'll rewrite this code in C++ so I can test the complexity properly. The lazy_load for HasSet I did up there I don't have the crate for it

namikaze:

Sorry, what's the role of the count parameter?

That's the base case of the recursion; if that's not there the code would run forever

Deicide:
That's the base case of the recursion; if that's not there the code would run forever

Ok, say for instance I called the function on a vector, [1,2,3,4,5];
what would pass as argument for the count parameter?

namikaze:

Ok, say for instance I called the function on a vector, [1,2,3,4,5];
what would pass as argument for the count parameter?

like this shuffle([1,2,3,4,5], 5);

5 here is the length of the vector.

Deicide:
Even on reddit they would advise you not to implement a double linked list or even a Linked list in rust exexpt you wanna run mad But you can use Box<T> to make the running mad slower

My code actually runs fast despite the recursion, it mostly just depends on if it gets the random number right. Best case would be O(n) but that's impossible but it can happen just that the chance are small especially if the input is large.

I'll rewrite this code in C++ so I can test the complexity properly. The lazy_load for HasSet I did up there I don't have the crate for it

I remember the Box<T> construct lol, and to think I was able to implement a linkedlist (single) in it I don't think I have the code anymore but I'll check my GitHub later.

Ofcourse it would run fast, rust if fast af. I do think it's not that great to let your algorithm depend on "picking the right number" but I get you.

Deicide:
like this shuffle([1,2,3,4,5], 5);
5 here is the length of the vector.

Ok sure.

namikaze:

I remember the Box<T> construct lol, and to think I was able to implement a linkedlist (single) in it I don't think I have the code anymore but I'll check my GitHub later.

Ofcourse it would run fast, rust if fast af. I do think it's not that great to let your algorithm depend on "picking the right number" but I get you.

That's why this code wouldn't work if they we duplicate in the input array. Who knows maybe if I stroll out later the solution might come to my head

Deicide:
That's why this code wouldn't work if they we duplicate in the input array. Who knows maybe if I stroll out later the solution might come to my head

You should definitely go for walk
You used the hashset to reduce lookup from O(n) to O(1) didn't you? nice one.
Also an instance where random() keeps returning an index to a value that's already in the hashset continuously till count gets to zero would yield undesired results.

namikaze:

You should definitely go for walk
You used the hashset to reduce lookup from O(n) to O(1) didn't you? nice one.

Yeah, Things I learnt on leetcode

Also an instance where random() keeps returning an index to a value that's already in the hashset continuously till count gets to zero would yield undesired results.

Yes the complexity is dependent on the random number. So it can be infinite ): so don't try on large dataset.

Deicide:

Yeah, Things I learnt on leetcode

Yes the complexity is dependent on the random number. So it can be infinite ): so don't try on large dataset.

Another way to express your solution without the recursion would be;

function shuffle(Array arr) 
{
   HashSet seenIndices = new HashSet()
   Array result = new Array()
   for (int i in 0 to arr.length())
   {
      rand_idx = random num in range(0, arr.length())
      while (seenIndices.contains(rand_idx)
      {
        rand_idx = random num in range(0, arr.length())
      }
      result.add(arr[rand_idx])
      seenIndices.add(rand_idx)
    }
  return result;
}

This I think follows the same idea, but would still depend on the random function, so not recommended.