We Keep Coding

Recursive function to return each character in Input

i am trying to use recursion to return each character in a string. However, the output is not
//We define a function with input parameter.
function countCharInString(string) {
//vi Define an empty objec
const result = {};
//we loop through the length of string
for (let i = 0; i < string.length; i++) {
//create another variable for each element in string
const ch = string[i];
//BASE CASE: if string is empty, return Object with nothing
if (!result[ch]) {
return result[ch]=0;
} else {
//RECURSION: 1 plus whatever the length of the substring from the next character onwards is
return countCharInString(result[ch] + 1)
}
}
}
console.log(countCharInString("Vi skal tælle bogstaver"))
the output should be the following:
var result = {
l : 3,
a : 2,
e : 2,
s : 2,
t : 2,
v : 2,
b: 1,
i : 1,
k : 1,
o : 1,
r : 1,
æ : 1
};

i would suggest to do it with a simple reduce like so
var inputString = 'donald duck';
var result = inputString.split('').reduce((acc, char, index) => {
if (acc[char] !== undefined) {
acc[char] = acc[char] + 1;
}
else {
acc = { ...acc, [char]: 1 }
}
return acc
}, {})
see: https://jsfiddle.net/yswu91zh/21/

Only recursion would not give you the output that you are asking for. After recursively counting character you have to sort it by frequency and then by character. I have excluded a bunch of punctuation with space from counting, if you want exclude more just add it to the punctuation string. You have to use String.prototype.localeCompare() method to compare the characters. This method compares two strings in the current locale. As you are using Danish language you have to specify locale as da.
const punctuations = '.,:;!? ';
const countCharInString = (str, p = {}) => {
if (str.length === 0) return p;
const key = str[0].toLowerCase();
if (!punctuations.includes(key)) {
if (!p[key]) p[key] = 1;
else p[key] += 1;
}
return countCharInString(str.slice(1), p);
};
const cmp = (x, y) => {
if (x[1] === y[1]) {
return x[0].localeCompare(y[0], 'da');
}
return x[1] < y[1] ? 1 : -1;
};
const ret = Object.fromEntries(
Object.entries(countCharInString('Vi skal tælle bogstaver')).sort(cmp)
);
console.log(ret);

How to convert string to array with ranges JavaScript

Consider the following string: 7, 20, 22, 30–32, 33, 36–40, 46
I developed some code that will automatically parse said string into an array with the given ranges as follows.
Note: A typical use-case for this would be - to search for selected pages within a pdf with 100's of pages
var number_string = "7, 20, 22, 30–32, 33, 36–40, 46".toString().replace(/–/gi, '-').replace(/ /gi, '').split(',');
var new_arr = [];
$.each(number_string, function(index, value) {
if (value.match(/-/gi)) {
var range_arr = value.split('-');
var sub_arr = range(range_arr[0], range_arr[1]);
$.each(sub_arr, function(sub_index, sub_value) {
new_arr.push(parseInt(sub_value, 10));
});
} else {
new_arr.push(parseInt(value, 10));
}
});
console.log(new_arr);
function range(lowEnd, highEnd) {
var arr = [],
c = highEnd - lowEnd + 1;
while (c--) {
arr[c] = highEnd--
}
return arr;
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
Was there a more streamlined non jQuery method that could have been leveraged here that is also, simple, light weight and easy to read? Please no ES6 stuff as that is Greek to me.
Note: The ToInt function is just a function that returns a valid number or 0.

The jQuery.map() method acts like a flat map (returned sub arrays are flattend). In the map's callback function, use String.search() to check if there's a dash. If not convert to number with the + operator and return. If there's a dash, split, use a for loop to convert the min and max to an array, and return the array.
function convert(str) {
var arr = jQuery.map(str.split(', '), function(s) {
if(s.search('–') === -1) return +s;
var minmax = s.split('–');
var range = [];
for(var i = +minmax[0]; i <= +minmax[1]; i++) range.push(i);
return range;
});
return arr;
}
var number_string = "7, 20, 22, 30–32, 33, 36–40, 46";
var result = convert(number_string);
console.log(result);
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
Using ESNext I would use Array.flatMap() instead of jQuery.map(), with String.inclues() to detect the dash, and Array.from() to generate the sub array.
const convert = (str) =>
str.split(', ')
.flatMap(s => {
if(!s.includes('–')) return +s;
const [min, max] = s.split('–');
return Array.from({ length: max - min + 1 }, (_, n) => n + +min);
});
var number_string = "7, 20, 22, 30–32, 33, 36–40, 46";
var result = convert(number_string, '–');
console.log(result);

I'd use .reduce. First split the initial string by commas. If the string being iterated over doesn't have -, then just push the number to the accumulator; otherwise, split by - to get a low and high number, then use a for loop to push all numbers from low to high to the accumulator:
const ToInt = Number;
const numArr = "7, 20, 22, 30–32, 33, 36–40, 46".split(', ');
const result = numArr.reduce((a, str) => {
if (!str.includes('–')) {
a.push(ToInt(str));
return a;
}
const [low, high] = str.split('–');
for (let i = Number(low); i <= high; i++) {
a.push(i);
}
return a;
}, []);
console.log(result);
If for some reason you don't want to use ES6, you can transform it to ES5 with Babel:
"use strict";
function _slicedToArray(arr, i) {
return (
_arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest()
);
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance");
}
function _iterableToArrayLimit(arr, i) {
var _arr = [];
var _n = true;
var _d = false;
var _e = undefined;
try {
for (
var _i = arr[Symbol.iterator](), _s;
!(_n = (_s = _i.next()).done);
_n = true
) {
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i["return"] != null) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
function _arrayWithHoles(arr) {
if (Array.isArray(arr)) return arr;
}
var ToInt = Number;
var numArr = "7, 20, 22, 30–32, 33, 36–40, 46".split(", ");
var result = numArr.reduce(function(a, str) {
if (str.indexOf("–") === -1) {
a.push(ToInt(str));
return a;
}
var _str$split = str.split("–"),
_str$split2 = _slicedToArray(_str$split, 2),
low = _str$split2[0],
high = _str$split2[1];
for (var i = Number(low); i <= high; i++) {
a.push(i);
}
return a;
}, []);
console.log(result);
(but the ES6 version is more concise and probably a lot easier to read and understand)

I have my own implementation for this purpose
parseStringRange accepts strings like '1,2,3' and '1,2,3-5,6,7', also removes invalid chars (not numbers or , or -) and return one array with all numbers.
the function also returns the numbers ordered and removes duplicates, the user also can input unordered numbers even in range, '1-5' and '5-1' will return same output.
const parseStringRange = (range = '') =>
`${range}`
?.replace(/[^0-9,-]/g, '') //remove invalid chars
?.split(',') //convert 1,2 to [1, 2]
?.flatMap(s => { //convert 1-3 to [1,2,3]
if (!s.includes('-')) return [s]
const [min, max] = s.split('-').map(e => Number(e))
if (min > max) var i = -1
else var i = 1
const r = []
for (let p = min; p != max; p += i)
r.push(p)
r.push(max)
return r;
})
?.map(e => Number(e)) //convert all string numbers to number
?.reduce((t, e, i, a) => {
if (!t)
t = [... new Set(a)]
return t
}, null) //remove duplicates
?.sort((a, b) => a - b) //sort numbers, smallest first

Function that returns the sum of all numbers passed in arguments

I need help. Can you help me to solve this task.
Write the function that returns the summ of all numbers even string numbers that are passed as arguments and the amount of these numbers is unlimited.
If one of the parameters is an array, then
Sum is also added to the sum of the values of this array (if any of the
Values of this array is also an array, then the result is added
Also the sum of its values, and so on).
var sum = getSum (1, '1', 'one', [2, '2', 'two']);
console.log(sum);
I've tried to write something like this:
function getSum(){
var separeted = string.split(",");
var sum =0;
for(var i=0;i<arguments.length;i++){
sum += parseInt(arguments[i].toString()..match(/(\d+)/));
}
return sum;
}
var sum = getSum(1,"1","one",[2,'2', 'two']);
console.log(sum);
and here I've stacked. I think that I will need split and filter but how to combine that all in one function I can't find.
Thanks.

You could define a recursive function like so:
function getSum () {
return Array.from(arguments).reduce((sum, value) => {
if (Array.isArray(value)) {
sum += getSum.apply(this, value)
} else {
sum += Number(value)
}
return sum
}, 0)
}
var sum = getSum (1, '1', '3', [2, '2', '10']);
console.log(sum);
In order to account for string numbers, you must define a mapping from words to numbers and iteratively traverse the string of words to generate the number. Here's a possible implementation of that:
var stringToNumber = (function () {
const primary = new Map([
['zero', 0],
['one', 1],
['two', 2],
['three', 3],
['four', 4],
['five', 5],
['six', 6],
['seven', 7],
['eight', 8],
['nine', 9]
])
const secondary = new Map([
['ten', 10],
['eleven', 11],
['twelve', 12],
['thirteen', 13],
['fourteen', 14],
['fifteen', 15],
['sixteen', 16],
['seventeen', 17],
['eighteen', 18],
['nineteen', 19]
])
const prefix = new Map([
['twenty', 20],
['thirty', 30],
['forty', 40],
['fifty', 50],
['sixty', 60],
['seventy', 70],
['eighty', 80],
['ninety', 90]
])
const magnitude = new Map([
['hundred', 1e2],
['thousand', 1e3],
['million', 1e6],
['billion', 1e9],
['trillion', 1e12],
['quadrillion', 1e15],
['quintillion', 1e18],
['sextillion', 1e21],
['septillion', 1e24],
['octillion', 1e27],
['nonillion', 1e30],
['decillion', 1e33]
])
const types = { primary, secondary, prefix, magnitude }
class Parser {
static parse(word) {
if (isNaN(word)) {
const [type = null] = Object.keys(types)
.filter(type => types[type].has(word))
const value = types[type] ? types[type].get(word) : NaN
return { type, sign: 1, value }
} else {
const value = Math.abs(word)
const sign = Math.sign(word)
const [type = 'primary'] = Object.keys(types)
.filter(type => Array.from(types[type].values()).includes(value))
return { type, sign, value }
}
}
constructor() {
this.words = []
}
push(word) {
const parsed = Parser.parse(word)
if (parsed.type === null) {
return this.words.length
}
return this.words.push(parsed)
}
valueOf() {
if (this.words.length === 0) {
return NaN
}
const words = this.words
let total = 0
let { type: lastType, sign, value: run } = words[0]
let maxMagnitude = lastType === 'magnitude' ? run : 1
for (const { type, value } of words.slice(1)) {
switch (type) {
case 'magnitude':
if (value > maxMagnitude) {
run = (total + run) * value
total = 0
maxMagnitude = value
} else {
run *= value
}
break
case 'secondary':
case 'prefix':
switch (lastType) {
case 'magnitude':
total += run
run = value
break
case 'primary':
case 'secondary':
case 'prefix':
run = Number(String(run) + String(value))
}
break
case 'primary':
switch (lastType) {
case 'magnitude':
total += run
run = value
break
case 'prefix':
run += value
break
case 'primary':
case 'secondary':
run = Number(String(run) + String(value))
}
}
lastType = type
}
return sign * (total + run)
}
}
return function stringToNumber (string) {
const words = string
.trim()
.toLowerCase()
.split(/\s+/g)
const parser = new Parser()
for (const word of words) {
parser.push(word)
}
return parser.valueOf()
}
})()
function getSum () {
return Array.from(arguments).reduce((sum, value) => {
if (Array.isArray(value)) {
sum += getSum.apply(this, value)
} else if (!isNaN(value)) {
sum += Number(value)
} else {
sum += stringToNumber(String(value))
}
return sum
}, 0)
}
var sum = getSum (1, '1', 'one hundred thousand', [2, '2', 'twenty six hundred']);
console.log(sum);

Thanks to everyone I found the solution in the old "O'reilly Javascript by David Flanagan"
so as I thought in my loop I had to check if it's not null than change the element into Number()
Here is the code from the book
function flexisum(a) {
var total = 0;
for(var i = 0; i < arguments.length; i++) {
var element = arguments[i], n;
if (element == null) continue; // Ignore null & undefined
if (isArray(element)) // if argument is array
n = flexisum.apply(this, element); // count sum of all elements
else if (typeof element === "function") // if it's a function
n = Number(element()); // call and convert it to the 'number'
else n = Number(element); // or to convert it anyway
if (isNaN(n)) // If it was not possible to convert to a number, initiate exc.
throw Error("flexisum(): can't convert " + element +
"into the number");
total += n; // Otherwise, add n to the total
}
return total;
}
but in my case I've chaged it for my needs and took away the exc. so it could count sum without string words.
if (isNaN(n)) continue;
total += n;
}
So, thanks to everybody.
Books are the good sourse))))

i think need to iterate any number of label ,so you can use following method
function jsArrSum(arr) {
var sum = 0;
for (var i = 0; i < arr.length; i++) {
if (typeof arr[i] == 'object')
sum += jsArrSum(arr[i]);
else
sum += arr[i];
}
return sum;
}
jsArrSum(array);

Finding a Single Integer in an array using Javascript

I was able to pull all single integers after 'reduce', but not working when there's all duplicates and output should be 0, not hitting my else or else if - code keeps outputting 0 vs the single integers
var singleNumber = function(nums) {
var sorted_array = nums.sort();
for (var i=0; i < sorted_array.length; i++){
var previous = sorted_array[i-1];
var next = sorted_array[i+1];
var singles = {key: 0};
var singlesArray = [];
if (sorted_array[i] !== previous && sorted_array[i] !== next){
singlesArray.push(sorted_array[i]);
singlesArray.reduce(function(singles, key){
singles.key = key;
//console.log('key', key);
return singles.key;
},{});
}
else if(singlesArray.length === 0) {
singles.key = 0;
return singles.key;
}
}
console.log('singles.key', singles.key);
return singles.key;
};
console.log(singleNumber([2,1,3,4,4]));

// tests
const n1 = [1,2,3,4,4] //[1,2,3]
const n2 = [1] //[1]
const n3 = [1,1] //0
const n4 = [1,1,1] //0
const n5 = [1,5,3,4,5] //[1,3,4]
const n6 = [1,2,3,4,5] //[1,2,3,4,5]
const n7 = [1,5,3,4,5,6,7,5] //[1,3,4,6,7]
const singleNumber = numbers => {
const reducer = (acc, val) => {
// check to see if we have this key
if (acc[val]) {
// yes, so we increment its value by one
acc[val] = acc[val] + 1
} else {
// no, so it's a new key and we assign 1 as default value
acc[val] = 1
}
// return the accumulator
return acc
}
// run the reducer to group the array into objects to track the count of array elements
const grouped = numbers.reduce(reducer, {})
const set = Object.keys(grouped)
// return only those keys where the value is 1, if it's not 1, we know its a duplicate
.filter(key => {
if (grouped[key] == 1) {
return true
}
})
// object.keys makes our keys strings, so we need run parseInt to convert the string back to integer
.map(key => parseInt(key))
// check to array length. If greater than zero, return the set. If it is zero, then all the values were duplicates
if (set.length == 0) {
return 0
} else {
// we return the set
return set
}
}
console.log(singleNumber(n7))
https://jsbin.com/sajibij/edit?js,console

Check for Anagram in 2 strings

I've created a function that checks if 2 words are anagrams, but I want to make it better. I feel the declaration of the counter after in the if statement is not quite well, if anybody have a better solution would be great.
function checkAnagram(string1, string2){
if(string1.length !== string2.length){
return false;
}
for(var i = 0; i < string1.length; i++){
if(count <= 0){
return false;
}
var count = 0;
for(var t = 0; t < string2.length; t++){
//counter = 0
if(string2[t].toLowerCase() == string1[i].toLowerCase()){
//counter++;
count++;
break;
}
}
}
return true;
}

Here is a much easier way of doing it:
var s1 = "test"
var s2 = "tset"
function testAnagram (s1, s2){
if(!s1 || !s2 || s1.length !== s2.length){return false;}
var lS1 = s1.toLowerCase();
var lS2 = s2.toLowerCase();
if(lS1 === lS2) {return false;}
var rS1 = lS1.split('').sort().join('');
var rS2 = lS2.split('').sort().join('');
return rS1 === rS2;
}
var result = testAnagram(s1, s2);
alert(result);

Your code returns true for strings 'aabb' and 'abcc', which are not anagrams. You can just sort the strings and check if they're equal:
function checkAnagram(string1, string2) {
return string1.toLowerCase().split("").sort().join("") === string2.toLowerCase().split("").sort().join("")
}

function checkAnagram(string1, string2) {
return string1.replace(/[^\w]/g,'').toLowerCase().split('').sort().join('') ===
string2.toLowerCase().replace(/[^\w]/g,'').split('').sort().join('')
}

If you don't want to use prebuild methods like .split() .sort() .join() then
function isAnagrams(stringA, stringB) {
// just to remove special char and convert it to lowercase
stringA = stringA.replace(/[^\w]/g, "").toLowerCase();
stringB = stringB.replace(/[^\w]/g, "").toLowerCase();
if (stringA.length !== stringB.length) return false;
let aCharMap = {};
let bCharMap = {};
/*
making of mapObject of both string, containing character as property and
count of that character as value
*/
for (let i = 0; i < stringA.length; i++) {
bCharMap[stringB[i]] = bCharMap[stringB[i]] + 1 || 1;
aCharMap[stringA[i]] = aCharMap[stringA[i]] + 1 || 1;
}
// checking both CharMap value
for (let q of stringB) {
if (bCharMap[q] !== aCharMap[q]) {
return false;
}
}
return true;
}
console.log(`isAnagram : ${isAnagrams('rail safety', 'fairy tales')}`)
so if you pass isAnagrams('rail safety','fairy tales'); then character map will look like this
aCharMap = { r: 1, a: 2, i: 1, l: 1, s: 1, f: 1, e: 1, t: 1, y: 1 }
bCharMap = { f: 1, a: 2, i: 1, r: 1, y: 1, t: 1, l: 1, e: 1, s: 1 }
then we will compare if they have same value or not based on that result will be decided

function isAnagram(str1, str2){
if(str1.length !== str2.length){
return false
}
let string1 = str1.toLowerCase().split('').sort().join('');
let string2 = str2.toLowerCase().split('').sort().join('');
return string1 === string2
}
isAnagram('abcdef', 'AbcFed')