We Keep Coding

Run IndexOf more than one time JS

How to search multiple same values and look if it meets the conditions without regex? Suppose that I have this string ***6**5****8*9***2
What I need to do is to check if the string has at least three times *** altogether and then if the number before and after the *** sums 11. In the example given, these conditions are met because: First, the string has three *** altogether, and then 9 + 2 is 11.
I have solved this problem using regex, match, and replace, but how I can do it without applying to those solutions.
I have tried to do this without regex but it did not work because indexOf is only giving me one result:
string = "***6**5****8*9***2";
for (var i = 0; i < string.length; i++) {
let where = (string.indexOf("***"));
let a = parseInt(string.charAt(where - 1));
let b = parseInt(string.charAt(where + 3));
if (a + b == 11){
isTrue = true;
}
}

You could split the string by stars amd keep the starts in the array then check if the value starts with a star, check the length and the left and right element for sum.
var string = "***6**5****8*9***2",
parts = string.split(/(\*+)/),
result = parts.some((s, i, { [i - 1]: l, [i + 1]: r }) =>
s[0] === '*' && s.length >= 3 && +l + +r === 11
);
console.log(result);
console.log(parts);

I tried to create a solution based off of your existing code:
string = "***6**5****8*9***2***4";
let where = 0;
// Skip leading *
while (where < string.length && '*' == string.charAt(where)) {
where += 1;
}
while (true) {
// Find three stars based on previous result
where = string.indexOf("***", where);
// No more triples
if (where == -1) break;
// Convert to digit - will be NaN if not a digit
let a = parseInt(string.charAt(where - 1));
// Find trailing digit
let j = where + 1;
// Skip to next non * char
while (j < string.length && '*' == string.charAt(j)) {
j += 1;
}
// No matches - quit
if (j == string.length) break;
// Parse digit
let b = parseInt(string.charAt(j));
// Do the math
if (!isNaN(a) && !isNaN(b)){
console.log(`${a} + ${b} = ${a+b}`);
}
where = j;
}

I wrote a simple Parser.I hope it can help you
string = "***6**5****8*9***2";
class Parser {
static parse(string) {
var lexer = new Lexer(string);
var token = lexer.getToken();
var prevNumberToken = null ;
while (token.type !== TOKEN_TYPE_END) {
if(token.type === TOKEN_TYPE_NUMBER){
if(prevNumberToken && prevNumberToken.value + token.value === 11 ) {
return true;
}
prevNumberToken = token ;
} else if(token.type !== TOKEN_TYPE_THREESTARS){
prevNumberToken = null ;
}
token = lexer.getToken();
}
return false;
}
}
class Lexer {
constructor(string) {
this._string = string;
this._index = -1;
this._len = string.length;
}
getToken() {
if (this._index < 0) {
this._index = 0;
return new Token(TOKEN_TYPE_START, '', -1);
}
if (this._index >= this._len) {
return new Token(TOKEN_TYPE_END, '', this._len);
}
if (this._string[this._index] === "*") {
return this._getStarToken()
} else {
return this._getNumberToken();
}
}
_getStarToken() {
var stars = "";
var i = this._index;
while (this._index < this._len && this._string[this._index] === "*") {
stars += "*";
this._index++;
}
if (stars.length === 3) {
return new Token(TOKEN_TYPE_THREESTARS, stars, i)
}
return new Token(TOKEN_TYPE_STARS, stars, i)
}
_getNumberToken() {
var numbers = "";
var i = this._index;
while (this._index < this._len && this._string[this._index] !== "*") {
if (this._string[this._index] >= "0" && this._string[this._index] <= "90") {
numbers += this._string[this._index];
this._index++;
} else {
throw new Error("invalid character")
}
}
return new Token(TOKEN_TYPE_NUMBER, parseInt(numbers), i);
}
}
class Token {
constructor(type, value, index) {
this._type = type
this._index = index
this._value = value
}
get type() { return this._type }
get index() { return this._index }
get value() { return this._value }
}
const TOKEN_TYPE_START = 1;
const TOKEN_TYPE_NUMBER = 2;
const TOKEN_TYPE_THREESTARS = 4;
const TOKEN_TYPE_STARS = 8;
const TOKEN_TYPE_END = 16;
console.log(Parser.parse(string));

Simpler way to write the scramble function

I want a simpler way for the function scramble(str1,str2) so that if a portion of str1 can be arranged to match str2 . Note that all the letters to be used are lowercase . I used the following code and it worked , but can anyone show me a simpler way .
function scramble(str1,str2){
str2 = str2.split('');
str1 = str1.split('');
let arr = [] , condition ;
arr.length = str2.length;
for(let i =0;i<str2.length;i++){
for(let a= 0 ;a<str1.length;a++){
if(str2[i] == str1[a]){
str1[a] = '';
arr[i] = 'true'
break;
}
}
}
for(let i = 0;i<arr.length;i++){
if(arr[i] == undefined){
return false
}
}
return true
}
console.log(scramble('rkqodlw','world')) //true;
console.log(scramble('cedewaraaossoqqyt','codewars'))//true
console.log(scramble('katas','steak')) //false
console.log(scramble('scriptjava','javascript'))//true
console.log(scramble('scriptingjava','javascript'))//true
console.log(scramble('scriptsjava','javascripts')//true
console.log(scramble('jscripts','javascript')) //false
console.log(scramble('aabbcamaomsccdd','commas')) //true

You could make count all chars in str1, then go over str2, decrement the count and return false if it reaches 0:
const count = {};
for(const char of str1)
count[char] = (count[char] || 0) + 1;
for(const char of str2)
if(!count[char]--) return false;
return true;

This problem is a version of generic issue of checking if one set of elements is a subset of another.
The base step to solve this task is to take first element of set1 and check if it is present in set2. If it isn't we return false. If it is we check the next element with set2 minus the matched element;
The base case is when we have an empty set (because empty set is a subset of any set)
function check(str1, str2) {
if (str2.length === 0) {
return true;
}
const [first, ...rest] = str1;
const idx = str2.indexOf(first);
if (idx !== -1) {
const str2Rest = [...str2.slice(0, idx), ...str2.slice(idx+1)];
return check(rest, str2Rest);
}
return true;
}
You can also first sort the strings and then go through both knowing that the matched char might be only on the current position or at the higher index
function sorted(str1, str2) {
str1 = [...str1].sort();
str2 = [...str2].sort();
let s1 = 0;
let s2 = 0;
while (s1 < str1.length && s2 < str2.length) {
if(str1[s1] === str2[s2]) {
s1 += 1;
}
s2 += 1;
}
return s1 === str1.length
}
The most performant solution for unsorted items is to go through the chars of both in the worst case only one:
function performant(str1, str2) {
const stash = {};
let s1 = 0;
let s2 = 0;
while (s1 < str1.length && s2 < str2.length) {
const ch1 = str[s1];
const ch2 = str[s2];
if(ch1 === ch2) {
s1 += 1;
s2 += 1;
continue;
}
if (stash[ch1]) {
s1 += 1;
stash[ch1] -= 1;
}
stash[ch2] = (stash[ch2] | 0) + 1;
s2 += 1;
}
return s1 === str1.length;
}

How to ignore spaces in string indexes and start with a capital letter on each word in a sentence

Basically, I have this code, where I want to change a given string to wEiRd CaSe, alternate between indexes, for example:
Starting from index 0 I want the letter to be capital, and then when the index got to an odd number, like 1, 3, 5, etc... I want to change it to uppercase.
So:
Stackoverflow should be StAcKoVeRfLoW, But I also want to work with strings, strings like this
This is a test should be: ThIs Is A TeSt
But my function returns : ThIs iS A TeSt
Here's my code:
"use strict";
var weirdCase = function(string) {
var characters = string.split("");
characters.forEach(function(value, index, characters) {
// If the index is even
if (index % 2 == 0) {
characters[index] = value.toUpperCase();
} else {
characters[index] = value.toLowerCase();
}
});
return characters.join("");
}
My question might be a bit misleading, I wanted to be wEiRd Case but also the first letter of the words to be capital, So I did this:
function toWeirdCase(string){
return string.split(' ').map(function(word){
return word.split('').map(function(letter, index){
return index % 2 == 0 ? letter.toUpperCase() : letter.toLowerCase()
}).join('');
}).join(' ');
}
Hope this helps someone

You can add another variable charIndex which you increase manually only if the value is no space. charIndex will represent the indexes for your string like it has no spaces in it.
"use strict";
var weirdCase = function(string) {
var characters = string.split("");
var charIndex = 0;
characters.forEach(function(value, index, characters) {
//Exclude spaces
if (value === " ") {
return;
}
// If the index is even
if (charIndex % 2 == 0) {
characters[index] = value.toUpperCase();
} else {
characters[index] = value.toLowerCase();
}
//Increment charIndex
charIndex += 1;
});
return characters.join("");
}

Should be as simple as this:
function WeIrDcAsE(string) {
let isUpperCase = true;
let result = '';
for (let character of string) {
if (isUpperCase) {
result += character.toUpperCase();
} else {
result += character.toLowerCase();
}
if (character.match(/[a-zA-Z]/)) {
isUpperCase = !isUpperCase;
} else {
isUpperCase = true;
}
}
return result;
}
console.log(WeIrDcAsE("This is a test!"));

In a much more simpler way...
a = "This is a test"
b = a.split('')
counter = 0
c = b.map(function(c) {
if (c === ' ') return c
if ((counter % 2) === 0) {
counter++
return c.toUpperCase()
}
counter++
return c.toLowerCase()
})
console.log(c.join(''))

This code can be simplified a lot, I think.
var weirdCase = function(str){
var upper = false;
for (var i = 0; i < str.length; i++){
if (str[i] != ' '){
if (upper){
str[i] = character.toUpperCase();
}else{
str[i] = character.toLowerCase();
}
upper = !upper;
}
}

I would do as follows;
var str = "this is a test",
result = str.split(" ")
.map(s => [].reduce
.call(s, (p,c,i) => p += i & 1 ? c.toLowerCase()
: c.toUpperCase(),""))
.join(" ");
console.log(result);

var string= 'Stackoverflow';
for (var i=0; i<string.length; i+=2)
string= string.substr(0,i) + string[i].toUpperCase() + string.substr(i+1);
Nev er mid, scratch this: I need to read more carefully, sorry.

How to check two string have same characters including special characters

I have two question
1) how can I check two shuffle string have same characters
Like I have
var str1 = "ansar##//1";
var str2 = "##//sanra1";
should return true
2) If not have same characters then which are the characters not exist in second sting
var str1 = "ansar##//123";
var str2 = "##//sanra";
Should return 123
I know I can get first question answer by
str1.length===str2.length && str1.split("").sort().join() == str2.split("").sort().join();
But not sure how to get characters not matched with second string

Consider these implementations:
1)
var str1 = "ansar##//1";
var str2 = "##//sanra1";
function first(str1, str2) {
return Array.prototype.every.call(str1, function(c) {
return str2.indexOf(c) > -1;
}, this);
}
console.log(first(str1, str2));
var str1 = "ansar##//123";
var str2 = "##//sanra";
function second() {
return Array.prototype.filter.call(str1, function(c) {
return str2.indexOf(c) === -1;
}, this).join('');
}
console.log(second(str1, str2));
Update for checking if strings contain same characters you can use ES6 Set:
const checkIfStringsContainSameCharacters = (string1, string2) => {
return new Set(string1).size === new Set(string1 + string2).size;
}

using a while loop seems a reasonable solution:
var str1 = "ansar##//1";
var str2 = "##//sanra12";
s1 = str1.split('');
s2 = str2.split('');
var i = s1.length + 1;
while (i--) {
if (s2.indexOf(s1[i]) >= 0)
s2.splice(s2.indexOf(s1[i]), 1);
}
console.log(s2)
the resulting array represents the letters of str2 not matched in str1

this will return empty string if character set in both strings is the same.
function findDiff (str1, str2)
{
var diff = '';
if (str1.length > str2.length)
{
var search = str1;
var compare = str2;
}
else
{
var search = str2;
var compare = str1;
}
for (var i = 0; i < search.length; i++)
{
var symbol = search[i];
if (compare.indexOf(symbol) === -1)
{
diff += symbol;
}
}
return(diff);
}
findDiff("ansar##//123", "##//sanra");
https://jsfiddle.net/tadaspaplauskas/pn7jnj8e/

This will return a true or false, if character in both string having the same character, and i think this is the most efficent way to do that.
a)
function hasSameCharacter(str1, str2) {
let a = Array.prototype.every.call(str1, (char) => str2.indexOf(char) > -1, this);
if (a) return Array.prototype.every.call(str2, (char2) => str1.indexOf(char2) > -1, this);
else return false;
}
console.log(hasSameCharacter(str1, str2));
b)
function hasSameCharacter(str1, str2) {
for (let i = 0; i < str1.length; i++) {
if (str2.indexOf(str1[i]) <= -1) return false;
}
for (let i = 0; i < str2.length; i++) {
if (str1.indexOf(str2[i]) <= -1) return false;
}
return true;
}
console.log(hasSameCharacter(str1, str2));
Hope this helps, happy coding :)

This code may help you to get output as per your wish.
var str1 = "ansar##//g123";
var str2 = "##//sanraD";
function strDiff(s1, s2){
var t,inter,a1,a2;
a1 = s1.split('');
a2 = s2.split('');
t = a2, a2 = a1, a1 = t;
inter = a1.filter(function (e) {
if (a2.indexOf(e) !== -1) return true;
});
for (i=0, len=inter.length; i<len; i++) {
for(var j = a1.length-1; j>=0;j--)
if (a1[j] === inter[i]) a1.splice(j, 1);
for(var k = a2.length-1; k>=0; k--)
if (a2[k] === inter[i]) a2.splice(k, 1);
}
if((a1.join('')+a2.join('')).length > 0)
return(a1.join('')+a2.join(''));
else
return "True";
}
var result = strDiff(str2,str1);
alert(result);

So I can't comment, because I don't have the ratings, but I tried Yuriy Yakym's solution (the second one, and a massive thank you Yuriy because I'd have struggled without that to work with in the beginning) and whilst it works for this example, if you add another 'a' say to str1, it won't show you that str2 doesn't actually have 3 'a's, because it's always going to reference the first appearance of the said character. In essence, you need to delete the found characters to ensure you are accounting for duplicates, or so it seems.
I developed the below from Yuriy's code to get it working for me. Please test it yourself. Happy to be disagreed with, but it seems, it will log out everything (including duplicates) that appears in str1 but doesn't appear inside str2:
const sorter = (str1, str2) => {
const arr = str1.split("");
const newArray = arr.filter((c) => {
if (str2.indexOf(c) === -1) {
return str2.indexOf(c) === -1
} else {
str2 = str2.replace(c, '');
}
})
return newArray.join("");
};
console.log(sorter(str1, str2));

function compare(str1, str2) {
if (str1.length !== str2.length) return false
let res = ''
let str2Copy = str2
for(let i = 0; i < str1.length; i++) {
for(let j = 0; j < str2Copy.length; j++) {
if(str1[i] === str2Copy[j]) {
res += str2Copy[j]
if (j === 0) {
str2Copy = str2Copy.slice(1)
} else if(j === str2Copy.length - 1) {
str2Copy = str2Copy.slice(0, str2Copy.length - 1)
} else {
str2Copy = str2Copy.slice(0, j) + str2Copy.slice(j, str2Copy.length - 1)
}
break;
}
}
}
if(res.length !== str1.length) {
return false
} else {
return true
}
}
console.log(compare('tester', 'retset'))

Showing unique characters in a string only once

I have a string with repeated letters. I want letters that are repeated more than once to show only once.
Example input: aaabbbccc
Expected output: abc
I've tried to create the code myself, but so far my function has the following problems:
if the letter doesn't repeat, it's not shown (it should be)
if it's repeated once, it's show only once (i.e. aa shows a - correct)
if it's repeated twice, shows all (i.e. aaa shows aaa - should be a)
if it's repeated 3 times, it shows 6 (if aaaa it shows aaaaaa - should be a)
function unique_char(string) {
var unique = '';
var count = 0;
for (var i = 0; i < string.length; i++) {
for (var j = i+1; j < string.length; j++) {
if (string[i] == string[j]) {
count++;
unique += string[i];
}
}
}
return unique;
}
document.write(unique_char('aaabbbccc'));
The function must be with loop inside a loop; that's why the second for is inside the first.

Fill a Set with the characters and concatenate its unique entries:
function unique(str) {
return String.prototype.concat.call(...new Set(str));
}
console.log(unique('abc')); // "abc"
console.log(unique('abcabc')); // "abc"

Convert it to an array first, then use Josh Mc’s answer at How to get unique values in an array, and rejoin, like so:
var nonUnique = "ababdefegg";
var unique = Array.from(nonUnique).filter(function(item, i, ar){ return ar.indexOf(item) === i; }).join('');
All in one line. :-)

Too late may be but still my version of answer to this post:
function extractUniqCharacters(str){
var temp = {};
for(var oindex=0;oindex<str.length;oindex++){
temp[str.charAt(oindex)] = 0; //Assign any value
}
return Object.keys(temp).join("");
}

You can use a regular expression with a custom replacement function:
function unique_char(string) {
return string.replace(/(.)\1*/g, function(sequence, char) {
if (sequence.length == 1) // if the letter doesn't repeat
return ""; // its not shown
if (sequence.length == 2) // if its repeated once
return char; // its show only once (if aa shows a)
if (sequence.length == 3) // if its repeated twice
return sequence; // shows all(if aaa shows aaa)
if (sequence.length == 4) // if its repeated 3 times
return Array(7).join(char); // it shows 6( if aaaa shows aaaaaa)
// else ???
return sequence;
});
}

Using lodash:
_.uniq('aaabbbccc').join(''); // gives 'abc'

Per the actual question: "if the letter doesn't repeat its not shown"
function unique_char(str)
{
var obj = new Object();
for (var i = 0; i < str.length; i++)
{
var chr = str[i];
if (chr in obj)
{
obj[chr] += 1;
}
else
{
obj[chr] = 1;
}
}
var multiples = [];
for (key in obj)
{
// Remove this test if you just want unique chars
// But still keep the multiples.push(key)
if (obj[key] > 1)
{
multiples.push(key);
}
}
return multiples.join("");
}
var str = "aaabbbccc";
document.write(unique_char(str));

Your problem is that you are adding to unique every time you find the character in string. Really you should probably do something like this (since you specified the answer must be a nested for loop):
function unique_char(string){
var str_length=string.length;
var unique='';
for(var i=0; i<str_length; i++){
var foundIt = false;
for(var j=0; j<unique.length; j++){
if(string[i]==unique[j]){
foundIt = true;
break;
}
}
if(!foundIt){
unique+=string[i];
}
}
return unique;
}
document.write( unique_char('aaabbbccc'))
In this we only add the character found in string to unique if it isn't already there. This is really not an efficient way to do this at all ... but based on your requirements it should work.
I can't run this since I don't have anything handy to run JavaScript in ... but the theory in this method should work.

Try this if duplicate characters have to be displayed once, i.e.,
for i/p: aaabbbccc o/p: abc
var str="aaabbbccc";
Array.prototype.map.call(str,
(obj,i)=>{
if(str.indexOf(obj,i+1)==-1 ){
return obj;
}
}
).join("");
//output: "abc"
And try this if only unique characters(String Bombarding Algo) have to be displayed, add another "and" condition to remove the characters which came more than once and display only unique characters, i.e.,
for i/p: aabbbkaha o/p: kh
var str="aabbbkaha";
Array.prototype.map.call(str,
(obj,i)=>{
if(str.indexOf(obj,i+1)==-1 && str.lastIndexOf(obj,i-1)==-1){ // another and condition
return obj;
}
}
).join("");
//output: "kh"

<script>
uniqueString = "";
alert("Displays the number of a specific character in user entered string and then finds the number of unique characters:");
function countChar(testString, lookFor) {
var charCounter = 0;
document.write("Looking at this string:<br>");
for (pos = 0; pos < testString.length; pos++) {
if (testString.charAt(pos) == lookFor) {
charCounter += 1;
document.write("<B>" + lookFor + "</B>");
} else
document.write(testString.charAt(pos));
}
document.write("<br><br>");
return charCounter;
}
function findNumberOfUniqueChar(testString) {
var numChar = 0,
uniqueChar = 0;
for (pos = 0; pos < testString.length; pos++) {
var newLookFor = "";
for (pos2 = 0; pos2 <= pos; pos2++) {
if (testString.charAt(pos) == testString.charAt(pos2)) {
numChar += 1;
}
}
if (numChar == 1) {
uniqueChar += 1;
uniqueString = uniqueString + " " + testString.charAt(pos)
}
numChar = 0;
}
return uniqueChar;
}
var testString = prompt("Give me a string of characters to check", "");
var lookFor = "startvalue";
while (lookFor.length > 1) {
if (lookFor != "startvalue")
alert("Please select only one character");
lookFor = prompt(testString + "\n\nWhat should character should I look for?", "");
}
document.write("I found " + countChar(testString, lookFor) + " of the<b> " + lookFor + "</B> character");
document.write("<br><br>I counted the following " + findNumberOfUniqueChar(testString) + " unique character(s):");
document.write("<br>" + uniqueString)
</script>

Here is the simplest function to do that
function remove(text)
{
var unique= "";
for(var i = 0; i < text.length; i++)
{
if(unique.indexOf(text.charAt(i)) < 0)
{
unique += text.charAt(i);
}
}
return unique;
}

The one line solution will be to use Set. const chars = [...new Set(s.split(''))];

If you want to return values in an array, you can use this function below.
const getUniqueChar = (str) => Array.from(str)
.filter((item, index, arr) => arr.slice(index + 1).indexOf(item) === -1);
console.log(getUniqueChar("aaabbbccc"));
Alternatively, you can use the Set constructor.
const getUniqueChar = (str) => new Set(str);
console.log(getUniqueChar("aaabbbccc"));

Here is the simplest function to do that pt. 2
const showUniqChars = (text) => {
let uniqChars = "";
for (const char of text) {
if (!uniqChars.includes(char))
uniqChars += char;
}
return uniqChars;
};

const countUnique = (s1, s2) => new Set(s1 + s2).size
a shorter way based on #le_m answer

let unique=myArray.filter((item,index,array)=>array.indexOf(item)===index)