leetcode-javascript/solutions/0906-super-palindromes.js at development · Anuj9826/leetcode-javascript · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
/**
 * Super Palindromes
 * Time Complexity: O(R^(1/4) * log(R)^2)
 * Space Complexity: O(log R)
 */
var superpalindromesInRange = function (
  lowerBoundAsString,
  upperBoundAsString,
) {
  const lowerLimitBigInt = BigInt(lowerBoundAsString);
  const upperLimitBigInt = BigInt(upperBoundAsString);
  let totalSuperPalindromes = 0;

  const checkPalindromeString = (textToCheck) => {
    let firstPointer = 0;
    let secondPointer = textToCheck.length - 1;
    while (firstPointer < secondPointer) {
      if (textToCheck[firstPointer] !== textToCheck[secondPointer]) {
        return false;
      }
      firstPointer++;
      secondPointer--;
    }
    return true;
  };

  const maximumCandidateBase = 100000;

  for (let currentBase = 1; currentBase < maximumCandidateBase; currentBase++) {
    const baseNumberString = currentBase.toString();

    const oddLengthCandidateBuilder = [];
    oddLengthCandidateBuilder.push(baseNumberString);
    for (
      let digitIndex = baseNumberString.length - 2;
      digitIndex >= 0;
      digitIndex--
    ) {
      oddLengthCandidateBuilder.push(baseNumberString[digitIndex]);
    }
    const oddPalindromeString = oddLengthCandidateBuilder.join("");

    const oddPalindromeBigInt = BigInt(oddPalindromeString);
    const oddPalindromeSquare = oddPalindromeBigInt * oddPalindromeBigInt;

    if (
      oddPalindromeSquare > upperLimitBigInt &&
      oddPalindromeBigInt > 1000000000n
    ) {
      return totalSuperPalindromes;
    }

    if (
      oddPalindromeSquare >= lowerLimitBigInt &&
      oddPalindromeSquare <= upperLimitBigInt
    ) {
      const oddSquareString = oddPalindromeSquare.toString();
      if (checkPalindromeString(oddSquareString)) {
        totalSuperPalindromes++;
      }
    }

    const evenLengthCandidateBuilder = [];
    evenLengthCandidateBuilder.push(baseNumberString);
    for (
      let characterIndex = baseNumberString.length - 1;
      characterIndex >= 0;
      characterIndex--
    ) {
      evenLengthCandidateBuilder.push(baseNumberString[characterIndex]);
    }
    const evenPalindromeString = evenLengthCandidateBuilder.join("");

    const evenPalindromeBigInt = BigInt(evenPalindromeString);
    const evenPalindromeSquare = evenPalindromeBigInt * evenPalindromeBigInt;

    if (
      evenPalindromeSquare > upperLimitBigInt &&
      evenPalindromeBigInt > 1000000000n
    ) {
      return totalSuperPalindromes;
    }

    if (
      evenPalindromeSquare >= lowerLimitBigInt &&
      evenPalindromeSquare <= upperLimitBigInt
    ) {
      const evenSquareString = evenPalindromeSquare.toString();
      if (checkPalindromeString(evenSquareString)) {
        totalSuperPalindromes++;
      }
    }
  }

  return totalSuperPalindromes;
};