Welcome To Sora Park

Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0.

Assume the environment does not allow you to store 64-bit integers (signed or unsigned).

Example 1:

Input: x = 123 Output: 321

Example 2:

Input: x = -123 Output: -321

Example 3:

Input: x = 120 Output: 21

Example 4:

Input: x = 0 Output: 0

Constraints:

• -231 <= x <= 231 - 1

class Solution {
public:
    long reverse(long x) {
        bool neg = false;
        if (x < 0)
        {
            neg = true;
            x *= -1;
        }

        long reversed = 0;
        while (x > 0)
        {
            reversed *= 10;
            reversed += (x % 10);
            x /= 10;
        }
        if (reversed > INT_MAX)
        {
            return 0;
        }
        else
        {
            reversed = (neg ? (reversed * -1) : reversed);
        }
        return reversed;
    }
};

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)P A H N A P L S I I G Y I R

And then read line by line: "PAHNAPLSIIGYIR"

Write the code that will take a string and make this conversion given a number of rows:

string convert(string s, int numRows);

Example 1:

Input: s = "PAYPALISHIRING", numRows = 3 Output: "PAHNAPLSIIGYIR"

Example 2:

Input: s = "PAYPALISHIRING", numRows = 4 Output: "PINALSIGYAHRPI" Explanation: P I N A L S I G Y A H R P I

Example 3:

Input: s = "A", numRows = 1 Output: "A"

Constraints:

• 1 <= s.length <= 1000
• s consists of English letters (lower-case and upper-case), ',' and '.'.
• 1 <= numRows <= 1000

class Solution {
public:
    string convert(string s, int numRows) {
        string ans = "";
        int step = (numRows + (numRows - 2));
        int loops = step < 1 ? 1 : (int)ceil((double)s.length() / (double)step);
        int cur = 0, start, end;
        while (ans.length() < s.length())
        {
            for (int i = 0; i < loops; i++)
            {
                start = (step * i) + cur;
                if (cur == 0)
                {
                    if (start < s.length()) ans += s[start];
                }
                else
                {
                    end = (step + (step * i)) - cur;
                    if (start < s.length()) ans += s[start];
                    if (end < s.length() && end > start) ans += s[end];
                }
            }
            cur++;
        }
        return ans;
    }
};

There is an unordered array, P, consisting of integers that are less than 100,000.

Check whether there is a pair of values that can sum up to the given sum, k.

bool test(const vector<int>& arr, int k)
{
	unordered_set<int> unord;
	for (int value : arr)
	{
		if (unord.find(value) != unord.end())
		{
			return true;
		}
		unord.insert(k - value);
	}
	return false;
}

Given a string s, return the longest palindromic substring in s.

Example 1:

Input: s = "babad" Output: "bab" Note: "aba" is also a valid answer.

Example 2:

Input: s = "cbbd" Output: "bb"

Example 3:

Input: s = "a" Output: "a"

Example 4:

Input: s = "ac" Output: "a"

Constraints:

• 1 <= s.length <= 1000
• s consist of only digits and English letters.

class Solution {
public:
    string longestPalindrome(string s) {
        string palindrome = "";
        int n = s.length();
        if (n < 2)
        {
            return s;
        }
        
        n = (n * 2) + 1;
        int pals[n];
        memset(pals, 0, sizeof(int) * n);
        pals[0] = 0, pals[1] = 1;
        int centreIndex = 1, rightIndex = 2;
        int maxPalLen = 0, maxCentreIndex = 0;
        int left, diff, start, end;
        
        for (int right = 2; right < n; right++)
        {
            left = (2 * centreIndex) - right;
            diff = (rightIndex - right);
            
            if (diff > 0)
            {
                pals[right] = min(pals[left], diff);
            }
            
            while (((right + pals[right]) < n &&
                    (right - pals[right]) > 0) &&
                   (((right + pals[right] + 1) % 2 == 0) ||
                    (s[(right + pals[right] + 1) / 2] ==
                     s[(right - pals[right] - 1) / 2])))
            {
                pals[right]++;
            }
            
            if (pals[right] > maxPalLen)
            {
                maxPalLen = pals[right];
                maxCentreIndex = right;
            }
            if (right + pals[right] > rightIndex)
            {
                centreIndex = right;
                rightIndex = (right + pals[right]);
            }
        }
        
        start = (maxCentreIndex - maxPalLen) / 2;
        end = start + maxPalLen - 1;
        
        for (int i = start; i <= end; i++)
        {
            palindrome += s[i];
        }
        
        return palindrome;
    }
};