Solución de Longest Substring Without Repeating Characters

Aporto mi posible solución:

    public static int LongestSubStringWithoutRepeat(string text)
    {
        var hash = new HashSet<char>();
        int count = 0;
        int max = 0;
        int p = 0;

        while (text.Length > p)
        {
            if (!hash.Contains(text[p]))
            {
                hash.Add(text[p]);
                count++;
                p++;
            }
            else
            {
                if (count > max) max = count;
                hash.Clear();
                count = 0;
            }
        }
        if (count > max) max = count;
        return max;
    }

El p2 como se mueve constante con enumerate() funciona. El usar max o min no afecta la Big O. El p2 - p1 + 1 es porque es inclusivo y toca tener en cuenta el valor inicial y final.

Siempre me puso a pensar en muchas formas, pero esta es una posible solución

    // a, b, c, a, b, c, b, b
    public int countWithoutRepeating (String s) {
        if (s.length() < 2) return 0;

        int currentCount = 0;
        int maxCount = 0;

        int pointerA = 0;
        int pointerB = 0;

        for (int i = 0; i < s.toCharArray().length; i++) {
            // B

            boolean repeated = false;
            int j = pointerA; // 6
            // 6 < 7
            while (j < pointerB) {
                // b == b
                if (s.charAt(j) == s.charAt(i)) {
                    repeated = true;
                    break;
                }

                j++;
            }

            // 3 --> 3, 1
            maxCount = Math.max(maxCount, currentCount);

            // true
            if (repeated) {
                currentCount = 0;
                pointerA = pointerB; // 7
            }

            currentCount++; // 1
            pointerB++; // 8
        }

        return maxCount;
    }

Test.

public class LongestSubstringTest {

    LongestSubstring object = new LongestSubstring();

    @Test
    public void shouldBeThreeByABC () {
        String s = "abcabcbb";
        assertEquals(3,object.countWithoutRepeating(s));
    }

    @Test
    public void shouldBeFifteen () {
        String s = "jdkafnlcdsalkxcmpoiuytfccv";
        assertEquals(15,object.countWithoutRepeating(s));
    }

}

Lo mas enredado es saber cuando mover el pointer que casi no se mueve hehe:

Mi solucion en TypeScript:

export const longestSubstringWithoutRepeatingChars = (s: string): number => {
  let substring: { [key: string]: number } = {};
  let prevMaxValue = 0;
  let p1 = 0;
  let p2 = 0;

  while (p2 < s.length) {
    const char = s[p2];

    if (substring[char] !== undefined) {
      if (substring[char] >= p1) {
        prevMaxValue = Math.max(prevMaxValue, (p2 - p1));

        p1 = substring[char] + 1;
        substring[char] = p2;
        p2++;
      } else {
        substring[char] = p2;
        p2++;
      }
    } else {
      substring[char] = p2;
      p2++;
    }
  }

  return Math.max(prevMaxValue, (p2 - p1));
};

def longest_sub_without_repeating_chars(txt):
    # Pueden haber duplicados en este contexto.
    # Todo se convierte a mínusculas.
    l_txt = list(txt)
    ap1 = 0 # Apunta al inicio de la subcadena más larga
    ap2 = 0 # Apunta al final de la subcadena más larga
    dict_comb = {} # Almacena el índice de las letras por cada subcadena
    mayor_tam = 1 # Mayor tamaño a retornar

    while ap2 < len(l_txt):
        if l_txt[ap2] in dict_comb:
            if ap2 - ap1 > mayor_tam:
                mayor_tam = ap2 - ap1

            ap1 = ap2
            dict_comb = {} # Vaciar el diccionario para guardar los índices
            #  de la siguiente subcadena

        dict_comb[l_txt[ap2]] = ap2
        ap2 += 1

    return mayor_tam

    # Si por ejemplo tenemos una solución que en espacio es o(n^2), pero
    #  en performance es rápida, es bueno preguntar al entrevistador si
    #  está bien presentarla así. Es decir cual es el atributo de calidad a
    #  priorizar

txt = "abcabcbb"
sal = longest_sub_without_repeating_chars(txt)
print(sal)

txt = "jdkafnlcdsalkxcmpoiuytfccv"
sal = longest_sub_without_repeating_chars(txt)
print(sal)

txt = "jdkafnlcdsalkxcmpoiuytfavadswlkxcmpoiuytfñazadsalkxcmpoiuytf"
sal = longest_sub_without_repeating_chars(txt)
print(sal)

comparto mis solución en JS:

function longestSubstring(s){
    let p1 = 0
        p2 = p1 + 1
        subString = s[p1]
        largestLength = 0

    while(p2 < s.length) {
        if(subString.includes(s[p2])){
            p1 = p2
            p2 = p1 + 1
            subString = s[p1]
        } else {
            subString = subString + s[p2]
            p2++

            if(subString.length > largestLength){
                largestLength = subString.length
            }
        }

    }

    return largestLength
}