I recently interviewed at Stripe, which consisted of five rounds, including a screening round. While I cannot disclose specific questions, I compiled a list of interview experiences from Stripe's Glassdoor section, which could be beneficial to others.

Process : same as explained here
https://medium.com/tech-pulse/no-leetcode-the-stripe-interview-experience-cf1b29e6f55d

**Blurr Credit Card: **

We can assume that the input string contains tokens separated by a single whitespace.

• Credit card numbers are represented by strings that contain anywhere from 13-16 digits (inclusive).
• The function will analyze the input string and look for any token that looks
  like a credit card (ie it contains between 13-16 digits).

The function will then replace all of the digits with an "x" character
EXCEPT for the last 4 digits for that token.
It will then return the full string with the data redacted.
Examples
// 16 digit number gets redacted, other tokens will not be touched
redact_card_numbers("1234567890123456 is a number")
returns "xxxxxxxxxxxx3456 is a number"
// No credit card found, no transformation needed
redact_card_numbers("basic_string 12345 no redaction")
returns "basic_string 12345 no redaction"
// 16 digit number in the middle of the string is redacted, other tokens are left alone.
redact_card_numbers("an embedded number 1234567890123456 in the string")
returns "an embedded number xxxxxxxxxxxx3456 in the string"

PART 2

Fortunately, credit card numbers have some additional structure to them.
For example:

• Cards issued by Visa will start with a 4 and will only have 13 OR 16 digits in them.
• Cards issued by American Express will ALWAYS have the first two digits of 34 or 37
  and will always contain 15 digits.
• Cards issued by Mastercard will ALWAYS be 16 digits and will ALWAYS have the
  first two digits between 51-55 (inclusive) OR will have the first four digits
  between 2221-2720 (inclusive)
  Modify your redact_card_numbers function to only redact valid Mastercard, Visa, or
  American Express credit card numbers. Like the previous part, the redaction will replace
  all of the digits with an “x” character EXCEPT for the last 4 digits.
  Examples
  // No credit card found, no transformation needed
  redact_card_numbers("basic_string 12345 no redaction")
  returns "basic_string 12345 no redaction"
  // 16 digit number does not get redacted as it does not match brand criteria
  redact_card_numbers("1234567890123456 is not a card")
  returns "1234567890123456 is not a card"
  // 16 digit number Visa does get redacted as it matches brand criteria
  redact_card_numbers("4234567890123456 is a valid visa")
  returns "xxxxxxxxxxxx3456 is a valid visa"

Account Balancing :

Similar to leetcode account balancing . https://leetcode.com/problems/optimal-account-balancing/description/

URL Compression :

Part1 :
Given a String, split it into major parts separated by special char / (slash).
For each major part that’s split by /, we can further split it into minor parts separated by . (dot).

We assume the given Strings:

• Only have lower case letters and two separators (., /).
• Have no empty minor parts (no leading / trailing separators or consecutive separators like "/a", "a/", "./..").
• Have >= 3 letters in each minor part.

Produce a final output String such that for each minor part, we only keep the first and last letter of it, interpolated with the count of letters in between.

Function to implement :

String compress_part_one(String s) {
return compressed_s;
}

## Examples

Example 1

Given input =>
stripe.com/payments/checkout/customer.maria
output =>s4e.c1m/p6s/c6t/c6r.m3a

For example, imagine compressing a URL such as "section/how.to.write.a.java.program.in.one.day".
After compressing it by following the rules in Part 1, the second major part still has 9 minor parts after compression.

Task: Therefore, to further compress the String, we want to only keep at most m (m>0) compressed minor parts from Part 1 within each major part.

If a major part has more than m minor parts, we keep the first (m-1) minor parts as is,
but concatenate the first letter of the m-th minor part and the last letter of the last minor part with the count of letters in the original string.
This means that if you build on top of results that have numeronyms, you should expand
on the numbers to count the number or letters in the original String, e.g, "w1w.s4e.c1m"
should be compressed into "w10m" instead of "w7m" (go through the examples below). You can either reuse Part 1 output or not.
If a major part has less than or equal to m minor parts, keep all the individual minor parts as they are from Part 1.

Example :
Given:
str = stripe.com/payments/checkout/customer.maria.doe
minor_parts = 2

(after Part 1 compression)
=>
s4e.c1m/p6s/c6t/c6r.m3a.d1e

(then after Part 2 compression)
=>
s4e.c1m/p6s/c6t/c6r.m6e

Step-by-step guide for part 2 compression:

1. For the last major part "c6r.m3a.d1e", keep the first 2-1=1 minor part "c6r"
2. For the rest of the minor parts "m3a.d1e", compress into "m6e"
3. Combine "c6r.m6e" (from step 1 and 2) as the last compressed major part
4. Do the same for the rest of the major parts (if applicable)

Example starter code

String compress_part_two(String str, Int minor_parts) {
// You can either use results from compress_part_one(str) or not.
return compressed_s;
}

Penalty :

    its only one part .
   https://leetcode.com/problems/minimum-penalty-for-a-shop/description/