384. Shuffle an Array

using System;
public class Solution {
    private int[] array;
    private int[] original;
    private Random rand = new Random();
    private int RandRange(int min, int max) {
        return rand.Next(min, max);
    }
    private void SwapAt(int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    public Solution(int[] nums) {
        array = (int[])nums.Clone();
        original = (int[])nums.Clone();
    }
    public int[] Reset() {
        array = (int[])original.Clone();
        return original;
    }
    public int[] Shuffle() {
        for (int i = 0; i < array.Length; i++) {
            int randIndex = RandRange(i, array.Length);
            SwapAt(i, randIndex);
        }
        return array;
    }
}

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    private vector<int>& array;
    private vector<int>& original;
    private Random rand = new Random();
    private int RandRange(int min, int max) {
        return rand.Next(min, max);
    }
    private void SwapAt(int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    public Solution(vector<int>& nums) {
        array = (int[])nums.Clone();
        original = (int[])nums.Clone();
    }
    public vector<int>& Reset() {
        array = (int[])original.Clone();
        return original;
    }
    public vector<int>& Shuffle() {
        for (int i = 0; i < array.size(); i++) {
            int randIndex = RandRange(i, array.size());
            SwapAt(i, randIndex);
        }
        return array;
    }
}

class Solution {
    private int[] array;
    private int[] original;

    Random rand = new Random();

    private int randRange(int min, int max) {
        return rand.nextInt(max - min) + min;
    }

    private void swapAt(int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public Solution(int[] nums) {
        array = nums;
        original = nums.clone();
    }
    
    public int[] reset() {
        array = original;
        original = original.clone();
        return original;
    }
    
    public int[] shuffle() {
        for (int i = 0; i < array.length; i++) {
            swapAt(i, randRange(i, array.length));
        }
        return array;
    }
}

class Solution {
  constructor(nums) {
    this.original = [...nums];
    this.array = [...nums];
  }

  reset() {
    this.array = [...this.original];
    return this.array;
  }

  shuffle() {
    for (let i = 0; i < this.array.length; i++) {
      const randIndex = Math.floor(Math.random() * (this.array.length - i)) + i;
      [this.array[i], this.array[randIndex]] = [this.array[randIndex], this.array[i]];
    }
    return this.array;
  }
}

import random

class Solution:
    def __init__(self, nums: list[int]):
        self.array = nums[:]
        self.original = nums[:]
    
    def reset(self) -> list[int]:
        self.array = self.original[:]
        return self.original
    
    def shuffle(self) -> list[int]:
        for i in range(len(self.array)):
            rand_index = random.randint(i, len(self.array) - 1)
            self.array[i], self.array[rand_index] = self.array[rand_index], self.array[i]
        return self.array

package main

import (
  "math/rand"
  "time"
)

type Solution struct {
  array    []int
  original []int
}

func Constructor(nums []int) Solution {
  original := make([]int, len(nums))
  copy(original, nums)
  return Solution{array: nums, original: original}
}

func (this *Solution) Reset() []int {
  copy(this.array, this.original)
  return this.original
}

func (this *Solution) Shuffle() []int {
  rand.Seed(time.Now().UnixNano())
  for i := range this.array {
    randIndex := rand.Intn(len(this.array)-i) + i
    this.array[i], this.array[randIndex] = this.array[randIndex], this.array[i]
  }
  return this.array
}

Algorithm

Реализуйте класс Solution:

Solution(int[] nums): Инициализирует объект целочисленным arrayом nums.

int[] reset(): Сбрасывает array в его исходную конфигурацию и returns его.

int[] shuffle(): returns случайное перемешивание arrayа.

Esempio:

Input: ransomNote = "a", magazine = "b"

Output: false

👨‍💻

Algoritmo: