Given two binary strings, return the sum of the two binary strings.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: a = "11", b = "1"
Output: "100"</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: a = "1010", b = "1011"
Output: "10101"</pre>

Binary Addition

Given a string s and a string array called dict, return a string such that all substrings of s that belong in dict are wrapped with bold tags: &lt;b&gt; and &lt;/b&gt;. If two substrings overlap each other then wrap them together by a bold tag. If two substrings are consecutive then also wrap them together by the same bold tag.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
s = "abcxyz123"
dict = ["abc","123"]
Output:
"&lt;b&gt;abc&lt;/b&gt;xyz&lt;b&gt;123&lt;/b&gt;"
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
s = "aaabbcc"
dict = ["aaa","aab","bc"]
Output:
"&lt;b&gt;aaabbc&lt;/b&gt;c"
</pre>
Note:
<ol>
<li>dict won't contain duplicates, and the size won't exceed 100.</li>
<li>The strings in input have length in range [1, 1000].</li>
</ol>

Bold String

Given two strings that represent non-negative integers, return the sum of the two numbers.
Constraints:
<ol>
<li>The length of both <code>num1</code> and <code>num2</code>&nbsp;does not exceed 5100.</li>
<li>Assume valid input:&nbsp;<code>num1</code> and <code>num2</code> contains only digits <code>0-9</code>.</li>
<li>Assume valid input:&nbsp;<code>num1</code> and <code>num2</code> does not contain any leading zero.</li>
<li>You are not allowed to use a Big Int library or convert the integers to strings.</li>
</ol>

Big Int Strings

Given a simple expression string, return the evaluation of it.
The expression string contains only open ( and closed parentheses),&nbsp;non-negative&nbsp;integers, + sign, - sign, * sign, / sign, and empty spaces. The integer division should always truncate towards 0.
You can always assume a valid string.
Some examples:
<pre style="white-space: pre-wrap; word-break: keep-all;">"1 + 1" = 2
" 6-4 / 2 " = 4
"2*(5+5*2)/3+(6/2+8)" = 21
"(2+6* 3+5- (3*14/7+2)*5)+3"=-12
</pre>
&nbsp;

Simple Calculator III

Given a set of words and a string s, return s with all keywords wrapped in the bold tags: &lt;b&gt; and &lt;/b&gt;.
The result string should contain the least number of bold tags as possible.
For example, given that <code>words = ["ab", "bc"]</code> and <code>S = "aabcd"</code>, we should return <code>"a&lt;b&gt;abc&lt;/b&gt;d"</code>. Returning&nbsp;<code>"a&lt;b&gt;a&lt;b&gt;b&lt;/b&gt;c&lt;/b&gt;d"</code>&nbsp;contains more bold tags so it is incorrect.
&nbsp;

Bold Words In String

Given a string s, return the number of non-empty contiguous substrings such that they have an equal number of 0's and 1's, and all the 0's and 1's are grouped consecutively.&nbsp;
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "00110011"
Output: 6
Explanation: These are the 6 substrings that have same number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".

</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "10101"
Output: 4
Explanation: These are the 4 substrings: "10", "01", "10", "01" that have same number of consecutive 1's and 0's.
</pre>
&nbsp;
&nbsp;

Number Of Binary Substrings

Given a string representing integer n, return the closest integer that is a palindrome (it can't be the same number).
'Closest' is defined as the smallest absolute difference between two integers.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "123"
Output: "121"
</pre>
Note:
<ol>
<li>The input n is always a positive integer represented as a string and will never exceed length 18.</li>
<li>If two palindrome integers are 'closest', then return the smaller one as an answer.</li>
</ol>

Identify Nearest Palindrome

Return the index of the first non-repeating character in a given string. If there are no non-repeating characters then return -1.
Examples:
<pre style="white-space: pre-wrap; word-break: keep-all;">s = "swecareers"
return 1.

s = "loveswecareers",
return 0.
</pre>
Note: Assume the string only contains lowercase letters.

First Non Repeating Character

You are playing a game where you are given a string that contains only + and - characters. You and your friend take turns flipping two consecutive "++" into "--". The game ends when one person can't make any moves anymore and the other person becomes the winner.
Return all possible states after one move. If there is no valid move then return an empty list.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: <code>s = "++++"</code> Output: [ "--++", "+--+", "++--" ]</pre>
&nbsp;

Flipping Characters

Given a sentence that contains words with only lowercase and uppercase letters only and separated by spaces, convert the sentence into our new language.
These are the rules of the new language:
<ul>
<li>If a word starts with a vowel (a, e, i, o, or u), append <code>"ma"</code>&nbsp;at the end of the string. For example, the word 'apple' gets converted to 'applema'. &nbsp;</li>
<li>If a word starts with a consonant letter (i.e. not a vowel), delete the first letter and append it to the end along with&nbsp;<code>"ma"</code>. For example, the word <code>"goat"</code>&nbsp;becomes <code>"oatgma"</code>. &nbsp;</li>
<li>Add one letter <code>'a'</code>&nbsp;to the end of each word for its word index in the sentence, starting with 1. For example,&nbsp;the first word gets <code>"a"</code> added to the end, the second word gets <code>"aa"</code> added to the end and so on.</li>
</ul>
Return the&nbsp;final sentence representing the conversion from <code>S</code>&nbsp;to Goat&nbsp;Latin.&nbsp;
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "I speak Goat Latin"
Output: "Imaa peaksmaaa oatGmaaaa atinLmaaaaa"
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "The quick brown fox jumped over the lazy dog"
Output: "heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa"
</pre>

New Language

Given a non-negative integer return it as an English word representation.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 123
Output: "One Hundred Twenty Three"
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 12345
Output: "Twelve Thousand Three Hundred Forty Five"</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 1234567
Output: "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
</pre>
Example 4:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 1234567891
Output: "One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety One"
</pre>

Number To Word

Given an integer, return the roman numeral conversion of it. The input is between 1 and 3999.
Roman numerals are represented by 7 different symbols. Here are the symbols and their corresponding integer value:
<pre style="white-space: pre-wrap; word-break: keep-all;">Symbol Value
I 1
V 5
X 10
L 50
C 100
D 500
M 1000</pre>
Example: Two is written as II. Twelve is written as XII. Twenty-seven is written as XXVII.
Roman numerals are written largest to smallest from left to right. However, there are edge cases. The roman numeral for four is not <code>IIII</code>. Instead, the number four is written as <code>IV</code>. This is because we subtract one from the five symbol. The same case applies to the number nine, which is written as <code>IX</code>. There are six cases when subtraction is used to create the roman numeral:
<ul>
<li><code>I</code> can be placed before <code>V</code> (5) and <code>X</code> (10) to make 4 and 9.&nbsp;</li>
<li><code>X</code> can be placed before <code>L</code> (50) and <code>C</code> (100) to make 40 and 90.&nbsp;</li>
<li><code>C</code> can be placed before <code>D</code> (500) and <code>M</code> (1000) to make 400 and 900.</li>
</ul>
&nbsp;
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:&nbsp;3
Output: "III"</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:&nbsp;4
Output: "IV"</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:&nbsp;9
Output: "IX"</pre>
Example 4:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:&nbsp;58
Output: "LVIII"
Explanation: L = 50, V = 5, III = 3.
</pre>
Example 5:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:&nbsp;1994
Output: "MCMXCIV"
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.</pre>

Roman Conversion

You are given a string of digits from&nbsp;<code>2-9,</code> inclusive. You must return all possible letter combinations that the string can represent.&nbsp;
A mapping of digits to letters is given below, just like on the telephone buttons.&nbsp;
Return your output in lexicographical order.
&nbsp;
<img src="http://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Telephone-keypad2.svg/200px-Telephone-keypad2.svg.png" />
&nbsp;
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "45"
Output: ["gj","gk","gl","hj","hk","hl","ij","ik","il"]
</pre>
&nbsp;

Phone Number Combinations

Given a string s, return the first instance of the longest contiguous palindrome substring.

Example 1:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;ctctd&quot;
Output: &quot;ctc&quot;
Note: &quot;tct&quot; is the first instance of the longest substring that is a palindrome.
</pre>

Example 2:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;caad&quot;
Output: &quot;aa&quot;
</pre>

Longest Palindrome In String

Given a string s and an integer k, return the length of the longest substring that contains k distinct characters.
Example 1:
<div>
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: s = "eceba", k = 2
Output: 3
Explanation: "ece" which its length is 3.</pre>
<div>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: s = "aa", k = 1
Output: 2
Explanation: "aa" which its length is 2.
</pre>
</div>
</div>

K Distinct Characters

Given a string, return the size of the longest substring such that it contains at most 2 distinct characters.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "eceba"
Output: 3
Explanation: t is "ece" which its size is 3.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "ccaabbb"
Output: 5
Explanation: t is "aabbb" which its size is 5.
</pre>

Two Distinct Character Substring

You are given a string, s. Find the length of the longest substring without repeating characters.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "abcabc"
Output: 3 
Explanation: Longest substring is <code>"abc"</code>, with the length of 3.</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "ffewef"
Output: 3
Explanation: Longest substring is <code>"few"</code>, with the length of 3.</pre>
&nbsp;

Maximum Substring With Non Repeating Characters

You are given a string, <code>s</code>, which only contains brackets ' ( ' and ' ) '. Find the length of the longest valid brackets. 

Example 1:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;())&quot;
Output: 2
Explanation: The longest valid bracket substring is <code>&quot;()&quot;</code>
</pre>

 

Example 2:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;<code>()(()))()</code>&quot;
Output: 6
Explanation: The longest valid bracket substring is <code>&quot;()(())&quot;</code>
</pre>

Longest Valid Brackets

Given 2 strings called: S and T, return the minimum substring in S that contains all characters of T. Do it in O(n) complexity. If no substring exists then return the empty string. If the substring exists then you are guaranteed to only have one unique solution.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"
</pre>
&nbsp;

Minimum Full Window

Given a string called paragraph and a list of words called banned, return the most frequent word that occurs in the paragraph but is also not a word in the list of banned words.
You may assume that there is always one word that isn't banned and the answer is unique. Also, note that words in banned will always be lowercase and won't contain punctuation but the words in the paragraph are not case sensitive and contain punctuation. Return your answer in lowercase.
Example:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: 
paragraph = "Bob hit a ball, the hit BALL flew far after it was hit."
banned = ["hit"]
Output: "ball"
Explanation: 
"hit" shows up 3 times, but it is banned so it doesn't count.
"ball" shows up 2 times and it's not banned. 
</pre>
&nbsp;
Note: 
<ul>
<li><code>paragraph</code> only has letters, spaces, or the following punctuation symbols:&nbsp;<code>!?',;.</code></li>
<li>There are no hyphenated words or words with apostrophes or other punctuation symbols.</li>
</ul>

Normal Word

Given a string that represents an hour and minute in the format "HH:MM", return the next closest timestamp using the same digits and keeping the same format. You are allowed to re-use digits and assume valid input.
For example, "02:34", "11:09" are valid. "2:34", "11:9" are invalid.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "19:34"
Output: "19:39"
Explanation: The next timestamp you can create using these digits: 1, 9, 3, 4, is 19:39, which occurs 5 minutes later. It can't be 19:33, since it occurs the next day.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "23:59"
Output: "22:22"
Explanation: The next timestamp you can create using these digits: 2, 3, 5, 9, is 22:22. You can assume that the output is the next day because time only moves forward.
</pre>

Closest Timestamp

In NBA playoffs, the teams are arranged so that a strong team plays with rather a weak team. For example, rank 1 team is matched with rank nth team, which makes the games more interesting. Return the final contest matches in the form of a string.


You are given n teams and let the corresponding integers between 1 and n represent the strength of the team. Rank 1 is the strongest team and Rank n is the weakest team. Use parentheses('(', ')') and commas(',') to represent the contest team pairing and follow the pattern of always matching stronger teams with weaker teams. 

Example 1: 
<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: 2
Output: (1,2)
Explanation: 
Initially, we have the team 1 and the team 2, placed like: 1,2.
Then we pair the team (1,2) together with '(', ')' and ',', which is the final answer.
</pre>


Example 2: 
<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: 4
Output: ((1,4),(2,3))
Explanation: 
In the first round, we pair the team 1 and 4, the team 2 and 3 together, as we need to make the strong team and weak team together.
And we got (1,4),(2,3).
In the second round, the winners of (1,4) and (2,3) need to play again to generate the final winner, so you need to add the paratheses outside them.
And we got the final answer ((1,4),(2,3)).
</pre>


Example 3: 
<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: 8
Output: (((1,8),(4,5)),((2,7),(3,6)))
Explanation: 
First round: (1,8),(2,7),(3,6),(4,5)
Second round: ((1,8),(4,5)),((2,7),(3,6))
Third round: (((1,8),(4,5)),((2,7),(3,6)))
Since the third round will generate the final winner, you need to output the answer (((1,8),(4,5)),((2,7),(3,6))).
</pre>


Note: 
<ol>
<li>The n is in range [2, 212].</li>
<li>Assume that the input n will always be able to converted into the form 2k, where k is a positive integer.</li>
</ol>

Output Contest Matches

Given a string, return the number of palindromic substrings.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "abc"
Output: 3
Explanation: 3 palindromic strings: "a", "b", "c".
</pre>
&nbsp;
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "aaa"
Output: 6
Explanation: 6 palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
</pre>
&nbsp;
Note:
<ol>
<li>The length of the input string won't exceed 1000.</li>
<li>If substrings have the same characters but different start and end indexes then count them as different strings.</li>
</ol>

Count Palindrome Substrings

Given a string, s, and a string that represents a regular expression pattern, p, implement an algorithm to check if pattern p matches pattern p. You only need to support <code>'.'</code> and <code>'*'</code>.
<pre style="white-space: pre-wrap; word-break: keep-all;">'.' Matches any single character.
'*' Matches zero or more of the preceding element.
</pre>
Note:
<ul>
<li><code>s</code>&nbsp;can be empty and contains only lowercase letters <code>a-z</code>.</li>
<li><code>p</code> can be empty and contains only lowercase letters <code>a-z</code>, and characters like&nbsp;<code>.</code>&nbsp;or&nbsp;<code>*</code>.</li>
</ul>
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
s = "aa"
p = "a"
Output: false
Explanation: "a" doesn't match the string "aa".
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
s = "aa"
p = "a*"
Output: true
Explanation:&nbsp;'*' means zero or more of the precedeng&nbsp;element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".
</pre>
Example 3:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
s = "ab"
p = ".*"
Output: true
Explanation:&nbsp;".*" means "zero or more (*) of any character (.)".
</pre>
Example 4:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
s = "aab"
p = "c*a*b"
Output: true
Explanation:&nbsp;c can be repeated 0 times, a can be repeated 1 time. Therefore it matches "aab".
</pre>
Example 5:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input:
s = "mississippi"
p = "mis*is*p*."
Output: false
</pre>

Match Regular Expression

Given a string and check if you can arrange all characters in such a way that no two adjacent characters are the same.
If it is possible, return your result. Otherwise, return an empty string.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: S = "aab"
Output: "aba"
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: S = "aaab"
Output: ""
</pre>
&nbsp;
&nbsp;

Restructure String

Given a string, reverse all the characters that are not letters but keep the non-letters in the same place. Return this string.
<div>&nbsp;</div>
<div>
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "ab-cd"
Output: "dc-ba"
</pre>
<div>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "a-bC-dEf-ghIj"
Output: "j-Ih-gfE-dCba"</pre>
<div>
&nbsp;
<div>
<code></code>
</div>
</div>
</div>
</div>

Reverse Letters

Given a string return the string with all the vowels in reverse order.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "hello"
Output: "holle"
</pre>
<div>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "swecareers"
Output: "sweceraers"</pre>
</div>
Note: Vowels are: 'a', 'e', 'i', 'o', 'u'. 'y' is not a vowel.
&nbsp;

Vowel Reversal

Given a string that represents a sentence, return the sentence with every word in reverse order.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "Let's take SWECareers contest"
Output: "s'teL ekat sreeraCEWS tsetnoc"
</pre>
Note: In the sentence, every word is separated by a single space.

Word Reversal III

The format of an email string is made up of a local name and a domain name separated by the @ sign.
For example, given the email&nbsp;<code>alice@swecareers.com</code>,&nbsp;<code>alice</code> is the local name, and <code>swecareers.com</code> is the domain name.
The email string may also contain&nbsp;<code>'.'</code>s or <code>'+'</code>s.
If you add a period ('.') between characters in the local name of the email string then mail sent to that email address will be forwarded to the same address without the periods in the local name. For example, mail sent to "alice.z@swecareers.com" will be forwarded to "alicez@swecareers.com".&nbsp;
If you add a plus symbol ('+') in the local name of the email string, all characters after the first plus sign will be ignored. This allows filtering of emails. For example all mail sent to m.y+name@email.com&nbsp;will be forwarded to my@email.com.
Both rules can be applied at the same time.
Given a list of strings that represent emails, if you send one email to each address in the list, return the number of different addresses that actually receive mail.
&nbsp;
<div>
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: ["test.email+alex@swecareers.com","test.e.mail+bob.cathy@swecareers.com","testemail+david@swecareer.scode.com"]
Output: 2
Explanation:&nbsp;Only "testemail@swecareers.com" and "testemail@swecareer.scode.com" actually receive emails
</pre>
&nbsp;
Constraints:
<ul>
<li><code>1 &lt;= emails[i].size &lt;= 100</code></li>
<li><code>1 &lt;= emails.size &lt;= 100</code></li>
<li>Each <code>emails[i]</code> contains only one <code>'@'</code> character.</li>
<li>In each email string, the local and domain parts are non-empty.</li>
<li>Local names cannot start with a <code>'+'</code> character.</li>
</ul>
</div>

Send Emails

Given a string, return true if the string can be a valid number.
Examples: <code>"0"</code> =&gt; <code>true</code> <code>" 0.1 "</code> =&gt; <code>true</code> <code>"abc"</code> =&gt; <code>false</code> <code>"1 a"</code> =&gt; <code>false</code> <code>"2e10"</code> =&gt; <code>true</code> <code>" -90e3&nbsp; &nbsp;"</code> =&gt; <code>true</code> <code>" 1e"</code> =&gt; <code>false</code> <code>"e3"</code> =&gt; <code>false</code> <code>" 6e-1"</code> =&gt; <code>true</code> <code>" 99e2.5&nbsp;"</code> =&gt; <code>false</code> <code>"53.5e93"</code> =&gt; <code>true</code> <code>" --6 "</code> =&gt; <code>false</code> <code>"-+3"</code> =&gt; <code>false</code> <code>"95a54e53"</code> =&gt; <code>false</code>
Here are valid characters in a decimal number:
<ul>
<li>Numbers 0-9</li>
<li>Exponent - "e"</li>
<li>Positive/negative sign - "+"/"-"</li>
<li>Decimal point - "."</li>
</ul>
Remember that the context of this matters and that this problem is meant to be ambiguous so that you can carefully gather the specifications and implement a complete solution.

Valid Number

Given a string, s, that is not empty you are allowed to remove at most one character. Return whether the string can make a palindrome.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "aba"
Output: True
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Input: "abca"
Output: True
Explanation: You could delete the character 'c'.
</pre>
Note:
<ol>
<li>The string will only have lowercase letters a-z. The max length of the string is 50000.</li>
</ol>

Correct Palindome II

Determine if a given string is a palindrome when ignoring punctuation and cases.

Note:&nbsp;Empty string is a valid palindrome.

Example 1:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;A man, a plan, a canal: Panama&quot;
Output: true
</pre>

Example 2:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;race a car&quot;
Output: false
</pre>

Correct Palindome

You are given a string with the characters <code>&#39;(&#39;</code>, <code>&#39;)&#39;</code>, <code>&#39;{&#39;</code>, <code>&#39;}&#39;</code>, <code>&#39;[&#39;</code> and <code>&#39;]&#39;</code>, determine if the string has a valid sequence of brackets.

An input string is valid if all brackets are be closed by the same type of brackets and in the correct order.

An empty string is&nbsp;also valid.

Example 1:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;()&quot;
Output: true
</pre>

Example 2:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;()[]{}&quot;
Output: true
</pre>

Example 3:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;(]&quot;
Output: false
</pre>

Example 4:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;([)]&quot;
Output: false
</pre>

Example 5:

<pre style="white-space: pre-wrap; word-break: keep-all;">
Input: &quot;{[]}&quot;
Output: true
</pre>

Validate Brackets

Given a string s and an abbreviation abbr, return true if the string matches the abbreviation otherwise return false.
The string "word" can have these abbreviations:
<pre style="white-space: pre-wrap; word-break: keep-all;">["word", "1ord", "w1rd", "wo1d", "wor1", "2rd", "w2d", "wo2", "1o1d", "1or1", "w1r1", "1o2", "2r1", "3d", "w3", "4"]
</pre>
Note: Assume the string s&nbsp;only has lowercase letters and abbr&nbsp;only has lowercase letters and digits.
Example 1:
<pre style="white-space: pre-wrap; word-break: keep-all;">Given s = "internationalization", abbr = "i12iz4n":

Return true.
</pre>
Example 2:
<pre style="white-space: pre-wrap; word-break: keep-all;">Given s = "apple", abbr = "a2e":

Return false.
</pre>

Problem Title	Difficulty	Frequency in Interviews
Longest Palindrome In String	Medium
Maximum Substring With Non Repeating Characters	Medium
Validate Brackets	Easy
Number To Word	Hard
Send Emails	Easy
Minimum Full Window	Hard
Match Regular Expression	Hard
Phone Number Combinations	Medium
Binary Addition	Easy
Longest Valid Brackets	Hard
Simple Calculator III	Hard
Normal Word	Easy
Roman Conversion	Medium
Correct Palindome	Easy
First Non Repeating Character	Easy
K Distinct Characters	Hard
Count Palindrome Substrings	Medium
Identify Nearest Palindrome	Hard
Restructure String	Medium
Valid Number	Hard
Big Int Strings	Easy
Word Reversal III	Easy
Closest Timestamp	Medium
Two Distinct Character Substring	Hard
Correct Palindome II	Easy
Bold String	Medium
Vowel Reversal	Easy
Reverse Letters	Easy
Word Abbreviations	Easy
Output Contest Matches	Medium
New Language	Easy
Bold Words In String	Easy
Number Of Binary Substrings	Easy
Flipping Characters	Easy

Most Frequently Asked String Interview Questions

Sort By: Company Questions

Sort By: Problem Type