# ☕ 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.

# 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"]`

Here’s the question in LeetCode

*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”`

Here’s the question in LeetCode.

**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

## Create your profile

## Only paid subscribers can comment on this post

Log in## Check your email

For your security, we need to re-authenticate you.

Click the link we sent to , or click here to log in.