Check Odd numbers without modulo operator - javascript

I am creating a function that returns whether the passed in number is odd Without the modulo operator. The tricky part is that it should work for NEGATIVE numbers and ZERO.
here's my codes so far:
function testodd(num) {
return (num/2)*2==num;
}
var output = testodd(17);
console.log(output); // --> true
Am I making some mistakes here? Or is there a better way to do this?

you can use Bitwise operator and get same result. does this help.
<script type="text/javascript">
function oddOrEven(x) {
return ( x & 1 ) ? "odd" : "even";
}
console.log(oddOrEven(10));
</script>
For more detail about bitwise operator

Hi you can do it with bitwise AND (&) operator to check if a number is even or odd.
function testodd(num) {
if((num & 1) == 0){
return true
}
return false;
}
var output = testodd(17);
console.log(output); // --> false
var output = testodd(-16);
console.log(output); // --> true
var output = testodd(0);
console.log(output); // --> true

Try a bit-wise operation
function testodd(num) {
return num & 1; // num AND 0x1 checks for the least significant bit, indicating true or falsey
}

Remove the decimal part after division using Math.floor.
Math.floor(num / 2) * 2 === num;
For even numbers, there is no loss in decimal value. For odd numbers, decimal point value will be lost and comparison will falsy.

Here is a horribly inefficient method using recursion:
function checkOdd(num)
{
num = Math.abs(num);
if(num==0)
return false;
else if(num==1)
return true;
else
return checkOdd(num-2);
}
Of course you should never use it.

Since there's already an answer I will show you an alternative away of doing it with regex
function checkOdd(num){
console.log(/^\d*[13579]$/.test(num));
}
checkOdd(105);
Would only work with reasonably sized integers

Try
function testodd(num){
if num < 0{
var number = -num
}
int i = 1;
int product = 0;
while (product <= num)
{
product = divisor * i;
i++;
}
// return remainder
return num - (product - divisor);
}

Use this function to check if a number is odd or even, without using the modulo operator %. This should work for negative numbers and zero.
function checkOdd(num) {
// your code here
if(num<0){ //Check if number is negative
num=-num; //Convert it into positive number
}
let b=Math.floor(num/2) //Taking value for loop iteration
for(var i=1;i<=b;i++){
num=num-2; //Will check the number is odd if it subtraction end to 1 by decrementing -2 to the number
if(num==1){
return true; //return true if number is odd
}
}
return false; //return false if number is even
}

You can use isInteger method
function isEven(n){
return Number.isInteger(n / 2);
}

function odd(num) {
if (num === 0) {
return false;
}
num = Math.abs(num);
while (num >= 2) {
num = num - 2;
}
if (num === 1) {
return true;
} else {
return false;
}
}

Even number
lets take an even number say 6;
6 divided by 2 is 3;
Math.round(3) is 3;
Math.floor(3) is 3;
3===3 eveluates to true so 6 is an even number;
Odd number
lets take an odd number say 9;
9 divided by 2 is 4.5;
Math.round(4.5) is 5;
Math.floor(4.5) is 4;
5===4 evaluates to false so 9 is an odd number;
function evenChecked(num) {
if (Math.round(num / 2) === Math.floor(num / 2)) {
return `${num} is even`;
} else {
return `${num} is odd`;
}
}
console.log(evenChecked(23));
console.log(evenChecked(90));
console.log(evenChecked(56));
console.log(evenChecked(49));

Related

To check the repeating digits in a single number in JS

I used random function, to generate a 4 digit number.
The generated 4 digit random number should not be in the sequence of 1111, 2222, 3333, .... The generated random number could be of any number except 1111, 2222, 3333, 4444,..
I used the below approach,
But, i could get the repeating of digits using the below code. Could somebody please help.
function repeatingDigit(n) {
let num = n.toString();
for (var i = 0; i <= num.length; i++) {
if (num.substr(i) == num.substr(++i)) {
alert('This pattern can not be used');
}
else {
return parseInt(n);
}
}
}
repeatingDigit(Math.floor(1000 + Math.random() * 9000));
Thank you.
You could just check if it's divisible by 1111:
function repeatingDigit(n) {
if (n % 1111 === 0) {
alert('This pattern can not be used');
}
return n;
}
repeatingDigit(Math.floor(1000 + Math.random() * 9000));
You can use a regular expression to test for that:
function repeatingDigit(n) {
let num = n.toString();
if (/(\d)\1{3}/.test(num)) {
alert('This pattern can not be used');
} else {
return parseInt(n);
}
}
repeatingDigit(Math.floor(1000 + Math.random() * 9000));
The regular expression /(\d)\1{3}/ tests for digits \d and checks if the following three characters are the same as the first found digit.
You can also use every() function which is inbuilt function provided by javascript to check wheather number is repeated or not after splitting number to array.
function repeatingDigit(num) {
var arr = String(num).split('');
if(arr.every(function (digit) { return digit === arr[0]}))
return 'Repeated Number!!';
else
return num;
}
console.log(repeatingDigit(Math.floor(1000 + Math.random() * 9000)))
Hope This Answer Will Help You! Happy Coding :)

I've got a problem with recursion in my code [duplicate]

I need help creating the code to find the factorial of a number. The task is to
Create a variable to store your answer and initialize it to one
Create a loop that beings at the given value, fact
Check if fact is one or zero
multiply fact with your answer variable
At the end of the loop decrease fact
Print answer using console.log
The pseudocode is
while(factorial)
if factorial == 0 or factorial == 1
break
result => result * factorial
factorial => factorial - 1
My code below isn't complete because I'm confused by the pseudocode.
function nth_fact(nth){
var a = 1
while(nth_fact)
if (nth_fact == 0 || nth_fact == 1){
break;
result => result * nth_fact
nth_fact => nth - 1
console.log()
}
}
At first lets examine what went wrong:
var a = 1
What is a? Its definetly not a good name for a variable. Maybe name it to result ? The same applies to nth which should be named factorial and nth_fact which should rather be factorize or sth. You should also always use ; to end a statement.
while(nth_fact)
As your while loop contains multiple statements (the if and the two assignments) you need to open a block here by using { right after the condition. nth_fact refers to the function, you rather want to take factorial here.
if (nth_fact == 0 || nth_fact == 1){
break;
Now you open a block statement for the if, but you never close it. So you need another } after the break.
result => result * nth_fact
nth_fact => nth - 1
console.log()
=> is the arrow function expression, but you want the assignment operator =. Also you need to pass something to console.log, e.g. console.log(result)
All together:
function factorize(factorial){
var result = 1;
while(factorial){
if (factorial == 0 || factorial == 1){
break;
}
// ?
factorial = factorial - 1;
console.log(result);
}
return result;
}
That pseudocode is indeed confusing, because what it calls factorial is actually not the factorial -- it's the current value, which the result (which is actually the factorial we're looking for) is multiplied by. Also, if is superfluous, because while already checks for the same condition. So the correct pseudocode would be
currentValue = argument
factorial = 1
while (currentValue > 1)
factorial = factorial * currentValue
currentValue = currentValue - 1
// now, 'factorial' is the factorial of the 'argument'
Once you get this sorted out, here's a bonus assignment:
create a function range(a, b) that creates an array of numbers from a to b. For example, range(5, 8) => [5, 6, 7, 8]
create a function product(array) that multiples array elements by each other. For example, product([2, 3, 7]) => 42
write the factorial function using product and range
I solve this this way
function factorial(number) {
let num = 1;
let result = 1;
while (num <= number) {
result = result * num;
num++;
}
return result;
}
const myNumber = factorial(6);
console.log(myNumber);
function factorial(num) {
var result = 1
while (num) {
if ((num) == 0 || (num) == 1) {
break;
} else {
result = result * num;
num = num - 1;
}
}
return `The factorial of ${val} is ${result}`
}
let val = prompt("Please Enter the number : ", "0");
var x = parseInt(val);
console.log(factorial(x));
A Short And Clean Code is :
let number = 5;
let numberFactorial = number;
while(number > 1){
numberFactorial = numberFactorial * (number-1);
number--;
}
console.log(numberFactorial);
function factorize(factorial) {
if(factorial == 0 | factorial == 1) {
return 1
}
else{
var result = factorial;
while(factorial >= 1 ){
if(factorial-1 == 0) {
break
};
result = result * (factorial - 1);
factorial = factorial-1;
//DEBUG: console.log(factorial + ' ' + result);
};
return(result);
}
}
If you want more info about functions, can see in my GitHub, good learning!
Github: https://github.com/bennarthurdev/JavaScript/tree/main/FUNCOES
You used the right approach. Just the syntax was wrong. Here it is:
function nth_fact(nth){
var result = 1 ;
while(nth){
if ((nth) == 0 || (nth) == 1)
break ;
result = result * nth;
nth = nth - 1
}
console.log(result);
return result;
}

Javascript Function defaulting to wrong answer (I think)

Hi can somebody tell me why the output to my function defaults to even when you insert over 17 numbers? It's probably super simple, please go easy on me!
function oddOrEven(number) {
var number = document.getElementById('number').value;
if(number % 2 != 0) {
document.getElementById('demo').innerHTML = "Odd";
}
else {
document.getElementById('demo').innerHTML = "Even";
}
if (number.length === 0) {
document.getElementById('demo').innerHTML = "Odd / Even";
}
}
You can simplify this whole thing. If you are always grabbing the input with id 'number' you don't need to pass a param, and then after a simple test you can inline the answer you want:
function oddOrEven(){
var val = document.getElementById('number').value;
var number = parseInt(val, 10);
// if it's not a valid number, you'll have NaN here which is falsy
if (number) {
document.getElementById('demo').innerHTML = (number % 2) ? "Even" : "Odd";
}
}
All that said, I just caught that you're talking about 17 digits (thanks to #JJJ's comment) rather than using the function more than once. The problem in this case is that JS integers have a size limit. If you parse anything larger it returns a number you're not going to expect. There are a lot of discussion of general handling of very large numbers here: http://2ality.com/2012/07/large-integers.html, but for your modulus problem you could take the last digit and check if that's odd or even like so:
function oddOrEven(){
var val = document.getElementById('number').value;
var number = parseInt(val, 10);
// if it's not a valid number, you'll have NaN here which is falsy
if (number) {
var lastDigit = val[val.length-1];
document.getElementById('demo').innerHTML = (parseInt(lastDigit, 10) % 2) ? "Even" : "Odd";
}
}

See if a number is equal to 1 or every 5th number

I want to check if a number is equal to 1 or every 5th number after that.
Eg. 1,6,11,16,21,... Then I want to set a value.
Something like
if (checkForOneOrFifth(rowNumber)){
$("#x"+rowNumber+"_Location").val('myText');
$("#x"+rowNumber+1+"_Location").val('myText');
$("#x"+rowNumber+2+"_Location").val('myText');
$("#x"+rowNumber+3+"_Location").val('myText');
$("#x"+rowNumber+4+"_Location").val('myText');
}
var checkForOneOrFifth = function(number) {
if(something here){
return true;
}else{
return false;
}
};
Thanks for any help
Scott
You can use the mod operator to check that for you:
var checkforoneorffith = function(number){
return (number - 1) % 5 == 0;
}

Check if a number has a decimal place/is a whole number

I am looking for an easy way in JavaScript to check if a number has a decimal place in it (in order to determine if it is an integer). For instance,
23 -> OK
5 -> OK
3.5 -> not OK
34.345 -> not OK
if(number is integer) {...}
Using modulus will work:
num % 1 != 0
// 23 % 1 = 0
// 23.5 % 1 = 0.5
Note that this is based on the numerical value of the number, regardless of format. It treats numerical strings containing whole numbers with a fixed decimal point the same as integers:
'10.0' % 1; // returns 0
10 % 1; // returns 0
'10.5' % 1; // returns 0.5
10.5 % 1; // returns 0.5
Number.isInteger(23); // true
Number.isInteger(1.5); // false
Number.isInteger("x"); // false:
Number.isInteger() is part of the ES6 standard and not supported in IE11.
It returns false for NaN, Infinity and non-numeric arguments while x % 1 != 0 returns true.
Or you could just use this to find out if it is NOT a decimal:
string.indexOf(".") == -1;
Simple, but effective!
Math.floor(number) === number;
The most common solution is to strip the integer portion of the number and compare it to zero like so:
function Test()
{
var startVal = 123.456
alert( (startVal - Math.floor(startVal)) != 0 )
}
Number.isSafeInteger(value);
In JavaScript, isSafeInteger() is a Number method that is used to return a Boolean value indicating whether a value is a safe integer. This means that it is an integer value that can be exactly represented as an IEEE-754 double precision number without rounding.
//How about byte-ing it?
Number.prototype.isInt= function(){
return this== this>> 0;
}
I always feel kind of bad for bit operators in javascript-
they hardly get any exercise.
Number.isInteger() is probably the most concise. It returns true if it is an integer, and false if it isn't.
number = 20.5
if (number == Math.floor(number)) {
alert("Integer")
} else {
alert("Decimal")
}
Pretty cool and works for things like XX.0 too!
It works because Math.floor() chops off any decimal if it has one so if the floor is different from the original number we know it is a decimal! And no string conversions :)
var re=/^-?[0-9]+$/;
var num=10;
re.test(num);
convert number string to array, split by decimal point. Then, if the array has only one value, that means no decimal in string.
if(!number.split(".")[1]){
//do stuff
}
This way you can also know what the integer and decimal actually are. a more advanced example would be.
number_to_array = string.split(".");
inte = number_to_array[0];
dece = number_to_array[1];
if(!dece){
//do stuff
}
function isDecimal(n){
if(n == "")
return false;
var strCheck = "0123456789";
var i;
for(i in n){
if(strCheck.indexOf(n[i]) == -1)
return false;
}
return true;
}
parseInt(num) === num
when passed a number, parseInt() just returns the number as int:
parseInt(3.3) === 3.3 // false because 3 !== 3.3
parseInt(3) === 3 // true
Use following if value is string (e.g. from <input):
Math.floor(value).toString() !== value
I add .toString() to floor to make it work also for cases when value == "1." (ends with decimal separator or another string). Also Math.floor always returns some value so .toString() never fails.
Here's an excerpt from my guard library (inspired by Effective JavaScript by David Herman):
var guard = {
guard: function(x) {
if (!this.test(x)) {
throw new TypeError("expected " + this);
}
}
// ...
};
// ...
var number = Object.create(guard);
number.test = function(x) {
return typeof x === "number" || x instanceof Number;
};
number.toString = function() {
return "number";
};
var uint32 = Object.create(guard);
uint32.test = function(x) {
return typeof x === "number" && x === (x >>> 0);
};
uint32.toString = function() {
return "uint32";
};
var decimal = Object.create(guard);
decimal.test = function(x) {
return number.test(x) && !uint32.test(x);
};
decimal.toString = function() {
return "decimal";
};
uint32.guard(1234); // fine
uint32.guard(123.4); // TypeError: expected uint32
decimal.guard(1234); // TypeError: expected decimal
decimal.guard(123.4); // fine
You can multiply it by 10 and then do a "modulo" operation/divison with 10, and check if result of that two operations is zero. Result of that two operations will give you first digit after the decimal point.
If result is equal to zero then the number is a whole number.
if ( (int)(number * 10.0) % 10 == 0 ){
// your code
}
function isDecimal(num) {
return (num !== parseInt(num, 10));
}
You can use the bitwise operations that do not change the value (^ 0 or ~~) to discard the decimal part, which can be used for rounding. After rounding the number, it is compared to the original value:
function isDecimal(num) {
return (num ^ 0) !== num;
}
console.log( isDecimal(1) ); // false
console.log( isDecimal(1.5) ); // true
console.log( isDecimal(-0.5) ); // true
function isWholeNumber(num) {
return num === Math.round(num);
}
When using counters with decimal steps, checking if number is round will actually fail, as shown below. So it might be safest (although slow) to format the number with 9 (could be more) decimal places, and if it ends with 9 zeros, then it's a whole number.
const isRound = number => number.toFixed(9).endsWith('000000000');
for (let counter = 0; counter < 2; counter += 0.1) {
console.log({ counter, modulo: counter % 1, formatted: counter.toFixed(9), isRound: isRound(counter) });
}
Perhaps this works for you?
It uses regex to check if there is a comma in the number, and if there is not, then it will add the comma and stripe.
var myNumber = '50';
function addCommaStripe(text){
if(/,/.test(text) == false){
return text += ',-';
} else {
return text;
}
}
myNumber = addCommaStripe(myNumber);
You can use this:
bool IsInteger() {
if (num.indexOf(".") != -1) // a decimal
{
return Math.ceil(num) == Math.floor(num); // passes for 1.0 as integer if thats the intent.
}
return Number.isSafeInteger(num);
}
to check if the number is integer or decimal.
Using Number.isInteger(num) can help check what would count as whole number and what would not.
For example:
let num1 = 6.0000000000000001; // 16 decimal places
let num2 = 6.000000000000001; // 15 decimal places
Number.isInteger(num1); // true, because of loss of precision
// while:
Number.isInteger(num2); // false
So, in my opinion it's safe to use Number.isInteger() over other suggested ways if what you need is to know what is an integer mathematically.
Function for check number is Decimal or whole number
function IsDecimalExist(p_decimalNumber) {
var l_boolIsExist = true;
if (p_decimalNumber % 1 == 0)
l_boolIsExist = false;
return l_boolIsExist;
}

Categories