We Keep Coding

Replace instances of an array in a string with another array

I'm working on a JS applet that requires replacement of array entries in a given string with entires from another array. This is my code as it now stands:
const string = "Lion, Unicorn, Unicorn";
const array1 = ["Lion", "Unicorn"];
const array2 = ["Fox", "Hound"];
const string2 = string.replaceAll(array1[0],array2[0]) //returns "Fox, Unicorn, Unicorn"
My desired output is :
Fox, Hound, Hound.
Specifically, I'd like to turn the contents of string2 into a function that repeats for every item in an array, but have no idea where to start.
Thanks!

Do you mean something like this?
I hope I understood the question well.
You can write a recursive function:
let string = "Lion, Unicorn, Unicorn";
let array1 = ["Lion", "Unicorn"];
let array2 = ["Fox", "Hound"];
function myCustomReplace(str, a1, a2) {
let wordToReplace=a1.shift(); // a1[0] - if array change matters
let replacementWord=a2.shift(); // a2[0] - if array change matters
if (!wordToReplace || !replacementWord) return str;
str=str.replaceAll(wordToReplace, replacementWord );
return myCustomReplace(str,a1,a2); // rturn myCustomReplace(str,a1.slice(1),a2.slice(1)) - if array change matters
}
console.log(
myCustomReplace(string,array1,array2)
)

It's sometimes worthwhile to first transform the inputs into a shape that is easier to work on. For this problem, the input sentence is better thought of as an array of words, and the two arrays used for replacement are better represented as a single object mapping input words to output words...
let string = "Lion, Unicorn, Unicorn";
let array1 = ["Lion", "Unicorn"];
let array2 = ["Fox", "Hound"];
// transform the inputs
let input = string.split(", ");
let translator = array1.reduce((acc, key, i) => {
acc[key] = array2[i];
return acc;
}, {});
// now input is ['Lion', 'Unicorn', ...]
// and transator is { 'Lion' : 'Fox', ... }
// now the problem is just a two-liner, mapping the input over the translator
let output = input.map(e => translator[e] || e)
console.log(output.join(", "))

If we use split(', ') to convert the string to an array of single words, we can use map() to replace them by searching for a pair with indexOf():
Please see comments in the code. A one-liner can be found at the end.
const string = "Lion, Unicorn, Unicorn";
const array1 = ["Lion", "Unicorn"];
const array2 = ["Fox", "Hound"];
// Split on ', '
let splitted = string.split(', ');
// Map
let result = splitted.map(w => {
// Get position in array1
const i = array1.indexOf(w);
// If we've found something
if (i !== -1) {
// Return replacement
return array2[i];
} else {
// Return original
return w;
}
});
// Create string
result = result.join(', ');
// Show
console.log(result);
// Or, as a one-liner
let result2 = string.split(', ').map(w => (array1.indexOf(w) !== -1) ? array2[array1.indexOf(w)] : w).join(', ');
console.log(result2);

Split String Every 2 Character into Array

I have a problem with my code. I have a series of string. For example I made this:
var a = 12345678
I want to split these string into an array, so that it will produce something like this:
[12,23,34,45,56,67,78]
I already tried this code:
var newNum = a.toString().match(/.{1,2}/g)
and it returns this result instead of the result I wanted
[12,34,56,78]
Are there any solution to this? Thanks in advance.

Shortest way:
'abcdefg'.split(/(..)/g).filter(s => s);
// Array(4) [ "ab", "cd", "ef", "g" ]
Explanation: split(/(..)/g) splits the string every two characters (kinda), from what I understand the captured group of any two characters (..) acts as a lookahead here (for reasons unbeknownst to me; if anyone has an explanation, contribution to this answer is welcome). This results in Array(7) [ "", "ab", "", "cd", "", "ef", "g" ] so all that's left to do is weed out the empty substrings with filter(s => s).

Hope this helps.
var a = 12345678;
a= a.toString();
var arr=[];
for (var i =0; i<a.length-1; i++) {
arr.push(Number(a[i]+''+a[i+1]));
}
console.log(arr);

You could use Array.from() like this:
let str = "12345678",
length = str.length - 1,
output = Array.from({ length }, (_,i) => +str.slice(i, i+2))
console.log(output)
Here's a generic solution for getting varying size of chunks:
function getChunks(number, size) {
let str = number.toString(),
length = str.length - size + 1;
return Array.from({ length }, (_,i) => +str.slice(i, i + size))
}
console.log(getChunks(12345, 3))
console.log(getChunks(12345678, 2))

We can do this using Array.reduce :
Firstly, convert the number into a string and then split it into an array
Secondly, apply reduce on the resulting array, then append current element ele with the next element only if the next element exists.
Lastly, after the append is done with the current and next element convert it back to a number by prefixing it with an arithmetic operator + and then add it to the accumulator array.
var a = 12345678;
const result = a.toString().split("").reduce((acc, ele, idx, arr) => {
return arr[idx + 1] ? acc.concat(+(ele + arr[idx + 1])) : acc;
}, []);
console.log(result);
console.assert(result, [12,23,34,45,56,67,78]);

Another approach, using reduce
var a = 12345678
a.toString()
.split('')
.reduce((c,x,i,A)=>i>0?c.concat([A[i-1]+A[i]]):c,[])

The pattern is start with the first two digits (12) and then add eleven until you have an array that ends with the last digit of the input string (8).
let str = `12345678`;
const eleven = string => {
let result = [];
let singles = string.split('');
let first = Number(singles.splice(0, 2).join(''));
for (let i = 0; i < string.length-1; i++) {
let next = 11 * i;
result.push(first+next);
}
return result;
}
console.log(eleven(str));

var a = 12345678;
console.log(
String(a)
.split("")
.map((value, index, array) => [value, array[index + 1]].join(''))
.map(item => Number(item))
);
output - [ 12, 23, 34, 45, 56, 67, 78, 8 ]
explanation
String(a) - convert your number value 'a' into string, to prepare for operations
split("") - convert string value into array
.map((value, index, array) => [value, array[index + 1]] ...
for every item from array, take current value and next value, and put them into array cell
.join('')) - then create string from this array value like this [ '1', '2' ] => ['12']
.map(item => Number(item)) - at the end, convert every array item into number.

You could use a recursive approach. Here I used an auxiliary function to perform the recursion, and the main function to convert the number to a string.
See example below:
const arr = 12345678;
const group = a => group_aux(`${a}`);
const group_aux = ([f, s, ...r]) =>
!s ? [] : [+(f+s), ...group_aux([s, ...r])];
console.log(group(arr));

My requirement is to convert a MD5 string (with length: 32) to a Uint8Array (with length: 16) as the key of AES algorithm. Reference from the post above, thanks.
var a = 'a12ab32fd78a89efa12ab32fd78a89ef';
var arr=[];
for (var i =0; i<a.length-1; i+=2) {
arr.push(parseInt(a[i]+''+a[i+1], 16));
}
console.log(arr.length);
console.log(arr);
console.log(new Uint8Array(arr));

If order doesn't matter, a more legible solution is:
let even = '12345678'.match(/(..)/g)
let odd = '2345678'.match(/(..)/g)
let result = [...even, ...odd]
If order does matter, just use .sort():
result.sort()

Convert javascript string to array

I have string like this
'10:00','13:00','12:00','15:00','08:00','12:00'
I need it in format like this
Array(3)
Array[0] ['10:00', '13:00']
Array[1] ['12:00', '15:00']
Array[2] ['08:00', '12:00']
I tried with split method but without success.

You could replace single quotes with double quotes, add brackes and parse it as JSON and get an array, which is the grouped by two elements.
var string = "'10:00','13:00','12:00','15:00','08:00','12:00'",
array = JSON
.parse('[' + string.replace(/'/g, '"') + ']')
.reduce((r, s, i) => r.concat([i % 2 ? r.pop().concat(s) : [s]]), []);
console.log(array);
.as-console-wrapper { max-height: 100% !important; top: 0; }

var str = "'10:00','13:00','12:00','15:00','08:00','12:00'";
var oldArray = str.split(',');
var newArray = [];
while(oldArray.length){
let start = 0;
let end = 2;
newArray.push(oldArray.slice(start, end));
oldArray.splice(start, end);
}
console.log(newArray);

How about:
"'10:00','13:00','12:00','15:00','08:00','12:00'"
.replace(/'/g, '').replace(/(,[^,]*),/g,"$1;")
.split(';').map(itm => itm.split(','))

In this case you want to compare 2 values.
To do this you can make a for loop that reads the current value and the last value and compares the two.
If the last value is higher than current value, the splitting logic happens.
Either you add the current value to the last item (which is an array of strings) in the results array or you add a new array of strings at the end of the results array.

One potential solution:
let S = "'10:00','13:00','12:00','15:00','08:00','12:00'";
let R = S.split(',');
let I = 0;
let A = new Array([],[],[]);
R.map((object, index) => {
A[I][index % 2] = R[index];
if (index % 2 == 1) I++;
});
console.log(A);

You can use String.split(',') to split into individual values, then group them based on their positions (result of integer division with 2).
I am using groupBy from 30 seconds of code (disclaimer: I am one of the maintainers of the project/website) to group the elements based on the integer division with 2. Short explanation:
Use Array.map() to map the values of an array to a function or property name. Use Array.reduce() to create an object, where the keys are produced from the mapped results.
The result is an object, but can be easily converted into an array using Object.values() as shown below:
var data = "'10:00','13:00','12:00','15:00','08:00','12:00'";
const groupBy = (arr, fn) =>
arr.map(typeof fn === 'function' ? fn : val => val[fn]).reduce((acc, val, i) => {
acc[val] = (acc[val] || []).concat(arr[i]);
return acc;
}, {});
var arr = data.split(',');
arr = groupBy(arr, (v, i) => Math.floor(i / 2));
arr = Object.values(arr);
console.log(arr);
.as-console-wrapper { max-height: 100% !important; top: 0; }

I think use JSON.parse is better:
var array = "'10:00','13:00','12:00','15:00','08:00','12:00'";
array = JSON.parse( '[' + array.replace(/'/g,'"') + ']' );
var array2 = [];
for(var i=0;i < array.length - 1; i++){
array2.push([array[i], array[i+1]]);
}
console.log(array2);

JavaScript to split data and calculate sums

I believe what I need are two JavaScript functions. I am receiving a comma separated string that holds two types of data: 1) device name followed by 2) numeric value. These two values are separated by a comma, and each set is also separated by a comma. Example string below:
Device_A,5,Device_C,2,Device_A,10,Device_B,8,Device_B,2,Device_C,7
What I want to do is create two separate functions. The first function finds the unique device names and returns just the names in a comma separated string. The second function would calculate the sum of the numeric values for each device. The expected results from the example string above would return:
Function 1 (Device List):
Device_A, Device_B, Device_C
Function 2 (Sums per Device List):
15,10,9
The lists do not need to return in any particular order as long at they both match up. All I have successfully done at this point is return a list of unique values (including numeric values)... I'm stuck on separating the list, but still referring to device name to sum up all of the values.
Thanks in advance. Let me know if you have any questions!
Matt

You could use an object for collecting the names and count.
This edit contains a shared function and two function for the result in equal order.
function getGrouped(data) {
var array = data.split(','),
temp = Object.create(null),
i = 0;
while (i < array.length) {
temp[array[i]] = (temp[array[i]] || 0) + +array[i + 1] || 0;
i += 2;
}
return temp;
}
function getDevices(data) {
var temp = getGrouped(data);
return Object.keys(temp).sort().join();
}
function getCounts(data) {
var temp = getGrouped(data);
return Object.keys(temp).sort().map(function (k) { return temp[k]; }).join();
}
var data = "Device_A,5,Device_C,2,Device_A,10,Device_B,8,Device_B,2,Device_C,7";
console.log(getDevices(data));
console.log(getCounts(data));

When starting out on a problem like this, I think it's wise to not worry about doing it in a single loop or in a fancy one-liner at first.
A) Start out by defining what data structures you need and how to go from one format to another:
Convert my string of data to a list of keys and values
Somehow group these keys and values based on the key
Sum the values for each group
Return a list of all unique keys
Return a list of all summed values
B) Then, try to see if any of the code you've written has the potential be re-used by other parts of your application and refactor accordingly.
C) Finally, assess if there are performance bottle necks and only if there are, optimize for performance.
A. A function for each step:
// 1. From string to array of keys and values
// You already figured this one out. Split by ","!
const namesAndValuesFromString =
str => str.split(",");
// 2. Grouping by key
// Let's first make pairs:
const deviceValuePairs = devicesAndValues => {
let pair = [];
const pairs = [];
devicesAndValues.forEach(x => {
pair.push(x);
if (pair.length === 2) {
pairs.push(pair);
pair = [];
}
});
return pairs;
};
// Key value pairs are a nice starting point for constructing a grouped object:
const kvpsToDeviceValuesObj = kvps => {
const valuesByDevice = {};
kvps.forEach(([key, value]) => {
value = Number(value);
if (!valuesByDevice[key]) {
valuesByDevice[key] = [];
}
valuesByDevice[key].push(value);
});
return valuesByDevice;
};
// 3. Now, we can get to summing the values arrays
const sumValueArrays = valuesByDevice => {
const summedValuesByDevice = {};
// Loop over the objects entries
Object.entries(valuesByDevice).forEach(
([key, values]) => {
summedValuesByDevice[key] = values
.reduce((a, b) => a + b);
}
);
return summedValuesByDevice;
};
// 4. + 5. Now that we have an object with device ids as keys, and summed values inside, we can retrieve the two lists
const getDevices = Object.keys;
const getSums = Object.values;
// Running the code:
const namesAndValues =
namesAndValuesFromString("A,5,C,2,A,10,B,8,B,2,C,7");
console.log(namesAndValues);
const kvps = deviceValuePairs(namesAndValues);
console.log(kvps);
const valuesByDevice = kvpsToDeviceValuesObj(kvps);
console.log(valuesByDevice);
const sumValues = sumValueArrays(valuesByDevice);
console.log(sumValues);
const devices = getDevices(sumValues);
console.log(devices);
const sums = getSums(sumValues);
console.log(sums);
B. Refactoring!
Once you understand each of those steps, you'll start to see things that can be generalized or combined. That's where the fun starts :)
// UTILITIES
const split = del => arr => arr.split(del);
const toPairs = arr => {
let pair = [];
return arr.reduce(
(pairs, x) => {
pair.push(x);
if (pair.length === 2) {
pairs.push(pair);
pair = [];
}
return pairs;
}, []);
};
const sum = (x, y = 0) => +x + y;
const kvpsToGroups = grouper => kvps =>
kvps.reduce(
(groups, [key, value]) => Object.assign(groups, {
[key]: grouper(value, groups[key])
}), {});
// YOUR APP
const sumGrouper = kvpsToGroups(sum);
const dataSplitter = split(",");
const parseData = str => sumGrouper(toPairs(dataSplitter(str)));
// MAIN
const result = parseData("A,5,C,2,A,10,B,8,B,2,C,7");
console.log("devices:", Object.keys(result));
console.log("sums:", Object.values(result));

another way by regexs
let str = "Device_A,5,Device_C,2,Device_A,10,Device_B,8,Device_B,2,Device_C,7", obj = {}
str.match(/(\w+,[0-9]+)/g).forEach((s) => {
s = s.split(',')
obj[s[0]] = (obj[s[0]] || 0) + (Number(s[1]) || 0)
})
console.log(obj)

Something like this should do it:
var input = "Device_A,5,Device_C,2,Device_A,10,Device_B,8,Device_B,2,Device_C,7";
var output = input.split(',').reduce((accumulator, currentValue, currentIndex, array) => {
accumulator[currentValue] = (accumulator[currentValue] || 0)
+ parseInt(array[currentIndex + 1]);
array.splice(0,1);
return accumulator;
}, {});
console.log(Object.keys(output));
console.log(Object.keys(output).map(k => output[k]));

Search string using RegEx for repeated letters and outputting into two-dimensional array in Javascript

I just started getting into RegEx. So far I have something like this but it looks like my pattern is off.
function hasRepeatedLetters(str) {
var patt = /[a-zA-Z]/g;
var result = patt.exec(str);
return result;
}
console.log(hasRepeatedLetters('aaBcDDbcca'));
I'd like to be able to input any argument with a combo of letters and the output to be a two-dimensional array with the first value being the repeated letter and the second value being the repeated letters length.
[["a",3],["b",1],["B",1],["c",3],["D",2]]

Here is a map / object based solution
var str = 'aaBcDDbcca';
var map = {}; // create a hash for keys and their counts
// loop over all characters and then add count
Array.from(str).forEach(function(character) {
map[character] = map[character] ? map[character] + 1 : 1;
});
// finally, convert map to a 2D array with 1st item as key and second item as count
var counts = Object.keys(map).map(function(key) {
return [key, map[key]];
})
console.log(counts);

You could use an ES6 Map for this, which has some nice features:
a map's set method returns the map again
the spread syntax applied on a map produces the desired array of pairs
function hasRepeatedLetters(str) {
return [...[...str].reduce( (acc, c) => acc.set(c, (acc.get(c) || 0) + 1), new Map )];
}
console.log(hasRepeatedLetters('aaBcDDbcca'));
.as-console-wrapper { max-height: 100% !important; top: 0; }

Possible solution, using Array#forEach function.
var str = 'aaBcDDbcca'.split(''), obj = {};
str.forEach(v => obj[v] ? obj[v]++ : obj[v] = 1);
var res = Object.keys(obj).map(v => [v, obj[v]]);
console.log(JSON.stringify(res));
Personally, I would suggest you to keep it as an object.
var str = 'aaBcDDbcca'.split(''), obj = {};
str.forEach(v => obj[v] ? obj[v]++ : obj[v] = 1);
console.log(JSON.stringify(obj));