 1628809860

# JavaScript Algorithms and Data Structures: Math - Bit Manipulation

#### Get Bit

This method shifts the relevant bit to the zeroth position. Then we perform AND operation with one which has bit pattern like 0001. This clears all bits from the original number except the relevant one. If the relevant bit is one, the result is 1, otherwise the result is 0.

See getBit.js for further details.

#### Set Bit

This method shifts 1 over by bitPosition bits, creating a value that looks like 00100. Then we perform OR operation that sets specific bit into 1 but it does not affect on other bits of the number.

See setBit.js for further details.

#### Clear Bit

This method shifts 1 over by bitPosition bits, creating a value that looks like 00100. Than it inverts this mask to get the number that looks like 11011. Then AND operation is being applied to both the number and the mask. That operation unsets the bit.

See clearBit.js for further details.

#### Update Bit

This method is a combination of "Clear Bit" and "Set Bit" methods.

See updateBit.js for further details.

#### isEven

This method determines if the number provided is even. It is based on the fact that odd numbers have their last right bit to be set to 1.

``````Number: 5 = 0b0101
isEven: false

Number: 4 = 0b0100
isEven: true
``````

See isEven.js for further details.

#### isPositive

This method determines if the number is positive. It is based on the fact that all positive numbers have their leftmost bit to be set to 0. However, if the number provided is zero or negative zero, it should still return false.

``````Number: 1 = 0b0001
isPositive: true

Number: -1 = -0b0001
isPositive: false
``````

See isPositive.js for further details.

#### Multiply By Two

This method shifts original number by one bit to the left. Thus all binary number components (powers of two) are being multiplying by two and thus the number itself is being multiplied by two.

``````Before the shift
Number: 0b0101 = 5
Powers of two: 0 + 2^2 + 0 + 2^0

After the shift
Number: 0b1010 = 10
Powers of two: 2^3 + 0 + 2^1 + 0
``````

See multiplyByTwo.js for further details.

#### Divide By Two

This method shifts original number by one bit to the right. Thus all binary number components (powers of two) are being divided by two and thus the number itself is being divided by two without remainder.

``````Before the shift
Number: 0b0101 = 5
Powers of two: 0 + 2^2 + 0 + 2^0

After the shift
Number: 0b0010 = 2
Powers of two: 0 + 0 + 2^1 + 0
``````

See divideByTwo.js for further details.

#### Switch Sign

This method make positive numbers to be negative and backwards. To do so it uses "Twos Complement" approach which does it by inverting all of the bits of the number and adding 1 to it.

``````1101 -3
1110 -2
1111 -1
0000  0
0001  1
0010  2
0011  3
``````

See switchSign.js for further details.

#### Multiply Two Signed Numbers

This method multiplies two signed integer numbers using bitwise operators. This method is based on the following facts:

``````a * b can be written in the below formats:
0                     if a is zero or b is zero or both a and b are zeroes
2a * (b/2)            if b is even
2a * (b - 1)/2 + a    if b is odd and positive
2a * (b + 1)/2 - a    if b is odd and negative
``````

The advantage of this approach is that in each recursive step one of the operands reduces to half its original value. Hence, the run time complexity is O(log(b)) where b is the operand that reduces to half on each recursive step.

See multiply.js for further details.

#### Multiply Two Unsigned Numbers

This method multiplies two integer numbers using bitwise operators. This method is based on that "Every number can be denoted as the sum of powers of 2".

The main idea of bitwise multiplication is that every number may be split to the sum of powers of two:

I.e.

``````19 = 2^4 + 2^1 + 2^0
``````

Then multiplying number x by 19 is equivalent of:

``````x * 19 = x * 2^4 + x * 2^1 + x * 2^0
``````

Now we need to remember that x * 2^4 is equivalent of shifting x left by 4 bits (x << 4).

See multiplyUnsigned.js for further details.

#### Count Set Bits

This method counts the number of set bits in a number using bitwise operators. The main idea is that we shift the number right by one bit at a time and check the result of & operation that is 1 if bit is set and 0 otherwise.

``````Number: 5 = 0b0101
Count of set bits = 2
``````

See countSetBits.js for further details.

#### Count Bits to Flip One Number to Another

This methods outputs the number of bits required to convert one number to another. This makes use of property that when numbers are XOR-ed the result will be number of different bits.

``````5 = 0b0101
1 = 0b0001
Count of Bits to be Flipped: 1
``````

See bitsDiff.js for further details.

#### Count Bits of a Number

To calculate the number of valuable bits we need to shift 1 one bit left each time and see if shifted number is bigger than the input number.

``````5 = 0b0101
Count of valuable bits is: 3
When we shift 1 four times it will become bigger than 5.
``````

See bitLength.js for further details.

#### Is Power of Two

This method checks if a number provided is power of two. It uses the following property. Let's say that powerNumber is a number that has been formed as a power of two (i.e. 2, 4, 8, 16 etc.). Then if we'll do & operation between powerNumber and powerNumber - 1 it will return 0 (in case if number is power of two).

``````Number: 4 = 0b0100
Number: 3 = (4 - 1) = 0b0011
4 & 3 = 0b0100 & 0b0011 = 0b0000 <-- Equal to zero, is power of two.

Number: 10 = 0b01010
Number: 9 = (10 - 1) = 0b01001
10 & 9 = 0b01010 & 0b01001 = 0b01000 <-- Not equal to zero, not a power of two.
``````

See isPowerOfTwo.js for further details.

This method adds up two integer numbers using bitwise operators.

It implements full adder electronics circuit logic to sum two 32-bit integers in two's complement format. It's using the boolean logic to cover all possible cases of adding two input bits: with and without a "carry bit" from adding the previous less-significant stage.

Legend:

• A: Number A
• B: Number B
• ai: ith bit of number A
• bi: ith bit of number B
• carryIn: a bit carried in from the previous less-significant stage
• carryOut: a bit to carry to the next most-significant stage
• bitSum: The sum of ai, bi, and carryIn
• resultBin: The full result of adding current stage with all less-significant stages (in binary)
• resultDec: The full result of adding current stage with all less-significant stages (in decimal)
``````A = 3: 011
B = 6: 110
┌──────┬────┬────┬─────────┬──────────┬─────────┬───────────┬───────────┐
│  bit │ ai │ bi │ carryIn │ carryOut │  bitSum │ resultBin │ resultDec │
├──────┼────┼────┼─────────┼──────────┼─────────┼───────────┼───────────┤
│   0  │ 1  │ 0  │    0    │    0     │     1   │       1   │     1     │
│   1  │ 1  │ 1  │    0    │    1     │     0   │      01   │     1     │
│   2  │ 0  │ 1  │    1    │    1     │     0   │     001   │     1     │
│   3  │ 0  │ 0  │    1    │    0     │     1   │    1001   │     9     │
└──────┴────┴────┴─────────┴──────────┴─────────┴───────────┴───────────┘
``````

## References

Read this in other languages: français, 简体中文.

The Original Article can be found on https://github.com

#javascript #algorithms #datastructures #math

## Buddha Community  1620466520

If you accumulate data on which you base your decision-making as an organization, you should probably think about your data architecture and possible best practices.

If you accumulate data on which you base your decision-making as an organization, you most probably need to think about your data architecture and consider possible best practices. Gaining a competitive edge, remaining customer-centric to the greatest extent possible, and streamlining processes to get on-the-button outcomes can all be traced back to an organization’s capacity to build a future-ready data architecture.

In what follows, we offer a short overview of the overarching capabilities of data architecture. These include user-centricity, elasticity, robustness, and the capacity to ensure the seamless flow of data at all times. Added to these are automation enablement, plus security and data governance considerations. These points from our checklist for what we perceive to be an anticipatory analytics ecosystem.

#big data #data science #big data analytics #data analysis #data architecture #data transformation #data platform #data strategy #cloud data platform #data acquisition 1628809860

## JavaScript Algorithms and Data Structures: Math - Bit Manipulation

#### Get Bit

This method shifts the relevant bit to the zeroth position. Then we perform AND operation with one which has bit pattern like 0001. This clears all bits from the original number except the relevant one. If the relevant bit is one, the result is 1, otherwise the result is 0.

See getBit.js for further details.

#### Set Bit

This method shifts 1 over by bitPosition bits, creating a value that looks like 00100. Then we perform OR operation that sets specific bit into 1 but it does not affect on other bits of the number.

See setBit.js for further details.

#### Clear Bit

This method shifts 1 over by bitPosition bits, creating a value that looks like 00100. Than it inverts this mask to get the number that looks like 11011. Then AND operation is being applied to both the number and the mask. That operation unsets the bit.

See clearBit.js for further details.

#### Update Bit

This method is a combination of "Clear Bit" and "Set Bit" methods.

See updateBit.js for further details.

#### isEven

This method determines if the number provided is even. It is based on the fact that odd numbers have their last right bit to be set to 1.

``````Number: 5 = 0b0101
isEven: false

Number: 4 = 0b0100
isEven: true
``````

See isEven.js for further details.

#### isPositive

This method determines if the number is positive. It is based on the fact that all positive numbers have their leftmost bit to be set to 0. However, if the number provided is zero or negative zero, it should still return false.

``````Number: 1 = 0b0001
isPositive: true

Number: -1 = -0b0001
isPositive: false
``````

See isPositive.js for further details.

#### Multiply By Two

This method shifts original number by one bit to the left. Thus all binary number components (powers of two) are being multiplying by two and thus the number itself is being multiplied by two.

``````Before the shift
Number: 0b0101 = 5
Powers of two: 0 + 2^2 + 0 + 2^0

After the shift
Number: 0b1010 = 10
Powers of two: 2^3 + 0 + 2^1 + 0
``````

See multiplyByTwo.js for further details.

#### Divide By Two

This method shifts original number by one bit to the right. Thus all binary number components (powers of two) are being divided by two and thus the number itself is being divided by two without remainder.

``````Before the shift
Number: 0b0101 = 5
Powers of two: 0 + 2^2 + 0 + 2^0

After the shift
Number: 0b0010 = 2
Powers of two: 0 + 0 + 2^1 + 0
``````

See divideByTwo.js for further details.

#### Switch Sign

This method make positive numbers to be negative and backwards. To do so it uses "Twos Complement" approach which does it by inverting all of the bits of the number and adding 1 to it.

``````1101 -3
1110 -2
1111 -1
0000  0
0001  1
0010  2
0011  3
``````

See switchSign.js for further details.

#### Multiply Two Signed Numbers

This method multiplies two signed integer numbers using bitwise operators. This method is based on the following facts:

``````a * b can be written in the below formats:
0                     if a is zero or b is zero or both a and b are zeroes
2a * (b/2)            if b is even
2a * (b - 1)/2 + a    if b is odd and positive
2a * (b + 1)/2 - a    if b is odd and negative
``````

The advantage of this approach is that in each recursive step one of the operands reduces to half its original value. Hence, the run time complexity is O(log(b)) where b is the operand that reduces to half on each recursive step.

See multiply.js for further details.

#### Multiply Two Unsigned Numbers

This method multiplies two integer numbers using bitwise operators. This method is based on that "Every number can be denoted as the sum of powers of 2".

The main idea of bitwise multiplication is that every number may be split to the sum of powers of two:

I.e.

``````19 = 2^4 + 2^1 + 2^0
``````

Then multiplying number x by 19 is equivalent of:

``````x * 19 = x * 2^4 + x * 2^1 + x * 2^0
``````

Now we need to remember that x * 2^4 is equivalent of shifting x left by 4 bits (x << 4).

See multiplyUnsigned.js for further details.

#### Count Set Bits

This method counts the number of set bits in a number using bitwise operators. The main idea is that we shift the number right by one bit at a time and check the result of & operation that is 1 if bit is set and 0 otherwise.

``````Number: 5 = 0b0101
Count of set bits = 2
``````

See countSetBits.js for further details.

#### Count Bits to Flip One Number to Another

This methods outputs the number of bits required to convert one number to another. This makes use of property that when numbers are XOR-ed the result will be number of different bits.

``````5 = 0b0101
1 = 0b0001
Count of Bits to be Flipped: 1
``````

See bitsDiff.js for further details.

#### Count Bits of a Number

To calculate the number of valuable bits we need to shift 1 one bit left each time and see if shifted number is bigger than the input number.

``````5 = 0b0101
Count of valuable bits is: 3
When we shift 1 four times it will become bigger than 5.
``````

See bitLength.js for further details.

#### Is Power of Two

This method checks if a number provided is power of two. It uses the following property. Let's say that powerNumber is a number that has been formed as a power of two (i.e. 2, 4, 8, 16 etc.). Then if we'll do & operation between powerNumber and powerNumber - 1 it will return 0 (in case if number is power of two).

``````Number: 4 = 0b0100
Number: 3 = (4 - 1) = 0b0011
4 & 3 = 0b0100 & 0b0011 = 0b0000 <-- Equal to zero, is power of two.

Number: 10 = 0b01010
Number: 9 = (10 - 1) = 0b01001
10 & 9 = 0b01010 & 0b01001 = 0b01000 <-- Not equal to zero, not a power of two.
``````

See isPowerOfTwo.js for further details.

This method adds up two integer numbers using bitwise operators.

It implements full adder electronics circuit logic to sum two 32-bit integers in two's complement format. It's using the boolean logic to cover all possible cases of adding two input bits: with and without a "carry bit" from adding the previous less-significant stage.

Legend:

• A: Number A
• B: Number B
• ai: ith bit of number A
• bi: ith bit of number B
• carryIn: a bit carried in from the previous less-significant stage
• carryOut: a bit to carry to the next most-significant stage
• bitSum: The sum of ai, bi, and carryIn
• resultBin: The full result of adding current stage with all less-significant stages (in binary)
• resultDec: The full result of adding current stage with all less-significant stages (in decimal)
``````A = 3: 011
B = 6: 110
┌──────┬────┬────┬─────────┬──────────┬─────────┬───────────┬───────────┐
│  bit │ ai │ bi │ carryIn │ carryOut │  bitSum │ resultBin │ resultDec │
├──────┼────┼────┼─────────┼──────────┼─────────┼───────────┼───────────┤
│   0  │ 1  │ 0  │    0    │    0     │     1   │       1   │     1     │
│   1  │ 1  │ 1  │    0    │    1     │     0   │      01   │     1     │
│   2  │ 0  │ 1  │    1    │    1     │     0   │     001   │     1     │
│   3  │ 0  │ 0  │    1    │    0     │     1   │    1001   │     9     │
└──────┴────┴────┴─────────┴──────────┴─────────┴───────────┴───────────┘
``````

## References

Read this in other languages: français, 简体中文.

The Original Article can be found on https://github.com

#javascript #algorithms #datastructures #math 1620629020

## Getting Started With Data Lakes

### Frameworks for Efficient Enterprise Analytics

The opportunities big data offers also come with very real challenges that many organizations are facing today. Often, it’s finding the most cost-effective, scalable way to store and process boundless volumes of data in multiple formats that come from a growing number of sources. Then organizations need the analytical capabilities and flexibility to turn this data into insights that can meet their specific business objectives.

This Refcard dives into how a data lake helps tackle these challenges at both ends — from its enhanced architecture that’s designed for efficient data ingestion, storage, and management to its advanced analytics functionality and performance flexibility. You’ll also explore key benefits and common use cases.

### Introduction

As technology continues to evolve with new data sources, such as IoT sensors and social media churning out large volumes of data, there has never been a better time to discuss the possibilities and challenges of managing such data for varying analytical insights. In this Refcard, we dig deep into how data lakes solve the problem of storing and processing enormous amounts of data. While doing so, we also explore the benefits of data lakes, their use cases, and how they differ from data warehouses (DWHs).

#big data #data analytics #data analysis #business analytics #data warehouse #data storage #data lake #data lake architecture #data lake governance #data lake management 1621986060

## Basics of Data Structure Algorithms

If I ask you what is your morning routine, what will you answer? Let me answer it for you. You will wake up in the morning, freshen up, you’ll go for some exercise, come back, bath, have breakfast, and then you’ll get ready for the rest of your day.

If you observe closely these are a set of rules that you follow daily to get ready for your work or classes. If you skip even one step, you will not achieve your task, which is getting ready for the day.

These steps do not contain the details like, at what time you wake up or which toothpaste did you use or did you go for a walk or to the gym, or what did you have in your breakfast. But all they do contain are some basic fundamental steps that you need to execute to perform some task. This is a very basic example of algorithms. This is an algorithm for your everyday morning.

In this article, we will be learning algorithms, their characteristics, types of algorithms, and most important the complexity of algorithms.

#### What are Data Structure Algorithms?

Algorithms are a finite set of rules that must be followed for problem-solving operations. Algorithms are step-by-step guides to how the execution of a process or a program is done on a machine to get the expected output.

• Do not contain complete programs or details. They are just logical solutions to a problem.
• Algorithms are expressible in simple language or flowchart.

#### Characteristics of an Algorithm in Data Structure

No one would follow any written instructions to follow a daily morning routine. Similarly, you cannot follow anything available in writing and consider it as an algorithm. To consider some instructions as an algorithm, they must have some specific characteristics :

1. Input: An algorithm, if required, should have very well-defined inputs. An algorithm can have zero or more inputs.

2. Output: Every algorithm should have one or more very well-defined outputs. Without an output, the algorithm fails to give the result of the tasks performed.

3. Unambiguous: The algorithm should be unambiguous and it should not have any confusion under any circumstances. All the sentences and steps should be clear and must have only one meaning.

4. Finiteness: The steps in the algorithm must be finite and there should be no infinite loops or steps in the algorithm. In simple words, an algorithm should always end.

5. Effectiveness: An algorithm should be simple, practically possible, and easy to understand for all users. It should be executable upon the available resources and should not contain any kind of futuristic technology or imagination.

6. Language independent: An algorithm must be in plain language so that it can be easily implemented in any computer language and yet the output should be the same as expected.

#### Data flow of the Algorithm in Data Structure

1. Problem: To write a solution you need to first identify the problem. The problem can be an example of the real-world for which we need to create a set of instructions to solve it.

2. Algorithm: Design a step-by-step procedure for the above problem and this procedure, after satisfying all the characteristics mentioned above, is an algorithm.

3. Input: After creating the algorithm, we need to give the required input. There can be zero or more inputs in an algorithm.

4. Processing unit: The input is now forwarded to the processing unit and this processing unit will produce the desired result according to the algorithm.

5. Output: The desired or expected output of the program according to the algorithm.

#### Why do we need Data Structure Algorithm?

Suppose you want to cook chole ( or chickpeas) for lunch. Now you cannot just go to the kitchen and set utensils on gas and start cooking them. You must have soaked them for at least 12 hours before cooking, then chop desired vegetables and follow many steps after that to get the delicious taste, texture, and nutrition.

This is the need for algorithms. To get desired output, you need to follow some specific set of rules. These rules do not contain details like in the above example, which masala you are using or which salt you are using, or how many chickpeas you are soaking. But all these rules contain a basic step-by-step guide for best results.

We need algorithms for the following two reasons :

1. Performance: The result should be as expected. You can break the large problems into smaller problems and solve each one of them to get the desired result. This also shows that the problem is feasible.

2. Scalability: When you have a big problem or a similar kind of smaller problem, the algorithm should work and give the desired output for both problems. In our example, no matter how many people you have for lunch the same algorithm of cooking chickpeas will work every single time if followed correctly.

Let us try to write an algorithm for our lunch problem :

1. Soak chickpeas in the night so that they are ready till the next afternoon.

2. Chop some vegetables that you like.

3. Set up a utensil on gas and saute the chopped vegetables.

4. Add water and wait for boiling.

5. Add chickpeas and wait until you get the desired texture.

The real-world example that we just discussed is a very close example of the algorithm. You cannot just start with step 3 and start cooking. You will not get the desired result. To get the desired result, you need to follow the specific order of rules. Also, each instruction should be clear in an algorithm as we can see in the above example.

#algorithms in data structure #data structure algorithms #algorithms 1617959340

## 4 Tips To Become A Successful Entry-Level Data Analyst

Companies across every industry rely on big data to make strategic decisions about their business, which is why data analyst roles are constantly in demand. Even as we transition to more automated data collection systems, data analysts remain a crucial piece in the data puzzle. Not only do they build the systems that extract and organize data, but they also make sense of it –– identifying patterns, trends, and formulating actionable insights.

If you think that an entry-level data analyst role might be right for you, you might be wondering what to focus on in the first 90 days on the job. What skills should you have going in and what should you focus on developing in order to advance in this career path?

Let’s take a look at the most important things you need to know.

#data #data-analytics #data-science #data-analysis #big-data-analytics #data-privacy #data-structures #good-company