# ☕ The Future of Cloud Computing

### Competition in Cloud Computing is heating up. Startups are thriving by carving out their own niches in the space. One cloud computing startup just raised $50 million dollars.

Hi Everyone!

Hope you’re all having a great day!

Here’s your Interview Problem, Yesterday’s Solution and Tech Snippets for the day!

# Tech Dive

# Tech Snippets

**Rescale raises $50 million dollars to build high performance infrastructure as a service for enterprises.**- Competition in the Cloud Computing space is heating up.
**Startups are finding profits by****targeting niches where enterprises haven’t migrated to the cloud yet.** - Computing in the science and engineering community remains largely on-premises, in private data centers. HPC (High Performance Computing) spend by enterprises is expected to reach $55 billion dollars by 2024. This encompases areas like aerospace engineering, automotive engineering, bioinformatics, etc.
**Less than 20% of High Performance Computing workloads run in the cloud today.**- Rescale is building infrastructure as a service for HPC workloads and has now raised $50 million dollars in a new fundraising round.
**Rescale enables their customers to run HPC jobs on AWS, Azure, GCP and Oracle, allowing for a multi-cloud strategy for their customers.**- Their network spans 8 million servers with resources like Nvidia Tesla P100 GPUs, Intel Skylake processors and over 1 TB of RAM, delivering a total of 1,400 petaflops of compute.
- Using Rescale’s platform, customers also gain access to software that supports more than 600 simulation applications in areas like aerospace, oil & gas, life sciences, electronics, etc.
- Rescale says that over 300 businesses use its hardware and software, among them Amgen, Denso, Airbus, Nissan, Oak Ridge National Labs, Samsung, and the University of Pennsylvania.
*Read More*

- Competition in the Cloud Computing space is heating up.

# Interview Question

You are given a string s that contains *only* digits.

Return *all* possible valid IP addresses that can be obtained from s (without changing the order of the digits in s).

Example

Input: “25525511135”

Output: ["255.255.11.135","255.255.111.35"]

Input: "0000"

Output: ["0.0.0.0"]

Input: "010010"

Output: ["0.10.0.10","0.100.1.0"]

Input: "101023"

Output:["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3", "101.0.2.3"]

*We’ll send a detailed solution tomorrow, so make sure you move our emails to primary, so you don’t miss them!*

**Gmail users**—move us to your primary inbox

**On your phone?**Hit the 3 dots at the top right corner, click "Move to" then "Primary"**On desktop?**Back out of this email then drag and drop this email into the "Primary" tab near the top left of your screen

**Apple mail users**—tap on our email address at the top of this email (next to "From:" on mobile) and click “Add to VIPs”

# Previous Solution

**As a refresher, here’s the previous question**

Given two non-negative integers num1 and num2 represented as strings, return the product of num1 and num2, also represented as a string.

(Converting the strings to integers, multiplying them and the converting back to a string doesn’t count as a solution lol)

Example

Input - “2”, “3”

Output - “6”

Input - “123”, “456”

Output - “56088”

**Solution**

We can solve this question by simulating the regular steps you go through when multiplying two numbers.

We’ll use an array called product to keep track of the product of our two numbers.

The maximum number of digits that the product can have is the sum of the digits of our two original numbers.

Therefore, we’ll initialize product as

product = [0] * (len(num1) + len(num2))

Additionally, to make the indexing a bit easier, we’ll reverse num1 and num2.

This makes the smallest digit (the ones place) in num1 and num2 be at index 0.

Otherwise, the most significant digit is at index 0.

Then, we’ll iterate through num2 and then have a nested loop where we iterate through num1

We’ll multiply the current digit at num1 times the digit at num2 and then set the corresponding digit in product equal to the that.

If we’re at digit i in num2 and digit j in num1, then the corresponding digit in product is i + j.

Then, we have to check for any carry overs. If the product of those two digits is greater than 9, then we have to carry over the tens place to the next digit in product.

After iterating through both nested loops, we’ll remove any trailing 0s in product.

Then, we can reverse product (remember that we reversed num1 and num2 to make the indexing easier) and return it!

**Can you analyze the time complexity of our solution? Reply back with the time and space complexity!**

Best,

Arpan