Longest Palindromic Substring

function longestPalindrome(s) {
  if (s.length === 0) return "";
  let start = 0, end = 0;
  const expand = (left, right) => {
    while (left >= 0 && right < s.length && s[left] === s[right]) {
      left--;
      right++;
    }
    return [left + 1, right - 1];
  };
  for (let i = 0; i < s.length; i++) {
    const [l1, r1] = expand(i, i);
    if (r1 - l1 > end - start) { start = l1; end = r1; }
    const [l2, r2] = expand(i, i + 1);
    if (r2 - l2 > end - start) { start = l2; end = r2; }
  }
  return s.slice(start, end + 1);
}

console.log(longestPalindrome("babad"));

public class Main {
    static int[] expand(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }
        return new int[]{left + 1, right - 1};
    }

    static String longestPalindrome(String s) {
        if (s.isEmpty()) return "";
        int start = 0, end = 0;
        for (int i = 0; i < s.length(); i++) {
            int[] a = expand(s, i, i);
            if (a[1] - a[0] > end - start) { start = a[0]; end = a[1]; }
            int[] b = expand(s, i, i + 1);
            if (b[1] - b[0] > end - start) { start = b[0]; end = b[1]; }
        }
        return s.substring(start, end + 1);
    }

    public static void main(String[] args) {
        System.out.println(longestPalindrome("babad"));
    }
}

fun expand(s: String, l: Int, r: Int): IntArray {
    var left = l
    var right = r
    while (left >= 0 && right < s.length && s[left] == s[right]) {
        left--
        right++
    }
    return intArrayOf(left + 1, right - 1)
}

fun longestPalindrome(s: String): String {
    if (s.isEmpty()) return ""
    var start = 0
    var end = 0
    for (i in s.indices) {
        val a = expand(s, i, i)
        if (a[1] - a[0] > end - start) {
            start = a[0]
            end = a[1]
        }
        val b = expand(s, i, i + 1)
        if (b[1] - b[0] > end - start) {
            start = b[0]
            end = b[1]
        }
    }
    return s.substring(start, end + 1)
}

fun main() {
    println(longestPalindrome("babad"))
}

func longestPalindrome(_ s: String) -> String {
    if s.isEmpty { return "" }
    let chars = Array(s)
    var start = 0, end = 0
    func expand(_ l: Int, _ r: Int) -> (Int, Int) {
        var left = l, right = r
        while left >= 0 && right < chars.count && chars[left] == chars[right] {
            left -= 1
            right += 1
        }
        return (left + 1, right - 1)
    }
    for i in 0..<chars.count {
        let (l1, r1) = expand(i, i)
        if r1 - l1 > end - start { start = l1; end = r1 }
        let (l2, r2) = expand(i, i + 1)
        if r2 - l2 > end - start { start = l2; end = r2 }
    }
    return String(chars[start...end])
}

print(longestPalindrome("babad"))

String longestPalindrome(String s) {
  if (s.isEmpty) return '';
  int start = 0, end = 0;
  List<int> expand(int l, int r) {
    while (l >= 0 && r < s.length && s[l] == s[r]) {
      l--;
      r++;
    }
    return [l + 1, r - 1];
  }

  for (var i = 0; i < s.length; i++) {
    final a = expand(i, i);
    if (a[1] - a[0] > end - start) {
      start = a[0];
      end = a[1];
    }
    final b = expand(i, i + 1);
    if (b[1] - b[0] > end - start) {
      start = b[0];
      end = b[1];
    }
  }
  return s.substring(start, end + 1);
}

void main() {
  print(longestPalindrome("babad"));
}

#include <iostream>
#include <string>
#include <utility>
using namespace std;

pair<int, int> expand(const string& s, int left, int right) {
    while (left >= 0 && right < (int) s.size() && s[left] == s[right]) {
        left--;
        right++;
    }
    return {left + 1, right - 1};
}

string longestPalindrome(const string& s) {
    if (s.empty()) return "";
    int start = 0, end = 0;
    for (int i = 0; i < (int) s.size(); i++) {
        auto a = expand(s, i, i);
        if (a.second - a.first > end - start) { start = a.first; end = a.second; }
        auto b = expand(s, i, i + 1);
        if (b.second - b.first > end - start) { start = b.first; end = b.second; }
    }
    return s.substr(start, end - start + 1);
}

int main() {
    cout << longestPalindrome("babad") << endl;
    return 0;
}

#include <stdio.h>
#include <string.h>

int main() {
    char s[] = "babad";
    int n = strlen(s);
    int start = 0, maxLen = 1;
    for (int i = 0; i < n; i++) {
        for (int k = 0; k < 2; k++) {
            int left = i, right = i + k;
            while (left >= 0 && right < n && s[left] == s[right]) {
                left--;
                right++;
            }
            int len = right - left - 1;
            if (len > maxLen) {
                maxLen = len;
                start = left + 1;
            }
        }
    }
    for (int i = start; i < start + maxLen; i++) putchar(s[i]);
    putchar('\n');
    return 0;
}