forked from javascript-obfuscator/javascript-obfuscator
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathArrayUtils.ts
More file actions
122 lines (95 loc) · 3.07 KB
/
ArrayUtils.ts
File metadata and controls
122 lines (95 loc) · 3.07 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import { inject, injectable } from 'inversify';
import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
import { IArrayUtils } from '../interfaces/utils/IArrayUtils';
import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
@injectable()
export class ArrayUtils implements IArrayUtils {
/**
* @type {IRandomGenerator}
*/
private readonly randomGenerator: IRandomGenerator;
/**
* @param {IRandomGenerator} randomGenerator
*/
public constructor (
@inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator
) {
this.randomGenerator = randomGenerator;
}
/**
* @param {number} length
* @returns {number[]}
*/
public createWithRange (length: number): number[] {
const range: number[] = [];
for (let i: number = 0; i < length; i++) {
range.push(i);
}
return range;
}
/**
* @param {T[]} array
* @returns {T | null}
*/
public findMostOccurringElement <T extends string | number> (array: T[]): T | null {
const arrayLength: number = array.length;
if (!arrayLength) {
return null;
}
const elementsMap: Partial<{[key in T]: number}> = {};
let mostOccurringElement: T = array[0];
let mostOccurringElementCount: number = 1;
for (const element of array) {
const currentElementCount: number = elementsMap[element] ?? 0;
const updatedElementCount: number = currentElementCount + 1;
if (updatedElementCount > mostOccurringElementCount) {
mostOccurringElement = element;
mostOccurringElementCount = updatedElementCount;
}
elementsMap[element] = updatedElementCount;
}
return mostOccurringElement;
}
/**
* @param {T[]} array
* @returns {T | undefined}
*/
public getLastElement <T> (array: T[]): T | undefined {
const arrayLength: number = array.length;
return array[arrayLength - 1] ?? undefined;
}
/**
* @param {T[]} array
* @param {number} times
* @returns {T[]}
*/
public rotate <T> (array: T[], times: number): T[] {
if (!array.length) {
throw new ReferenceError('Cannot rotate empty array.');
}
if (times <= 0) {
return array;
}
const newArray: T[] = array;
let temp: T | undefined;
while (times--) {
temp = newArray.pop();
if (temp) {
newArray.unshift(temp);
}
}
return newArray;
}
/**
* @param {T[]} array
* @returns {T[]}
*/
public shuffle <T> (array: T[]): T[] {
const shuffledArray: T[] = [...array];
for (let i: number = shuffledArray.length; i; i--) {
const j: number = Math.floor(this.randomGenerator.getMathRandom() * i);
[shuffledArray[i - 1], shuffledArray[j]] = [shuffledArray[j], shuffledArray[i - 1]];
}
return shuffledArray;
}
}