Dos punteros

def invertir(a):
    """Da la vuelta a la lista en el sitio: un puntero en cada extremo que se acercan."""
    i, j = 0, len(a) - 1
    while i < j:
        a[i], a[j] = a[j], a[i]
        i, j = i + 1, j - 1


def palindromo(s):
    """¿Se lee igual al derecho que al revés? (Sin contar espacios ni mayúsculas.)"""
    t = s.replace(" ", "").lower()
    i, j = 0, len(t) - 1
    while i < j:
        if t[i] != t[j]:
            return False
        i, j = i + 1, j - 1
    return True


def par_que_suma(a, objetivo):
    """Posiciones de dos números de la lista ORDENADA que suman objetivo, o None."""
    izq, der = 0, len(a) - 1
    while izq < der:
        suma = a[izq] + a[der]
        if suma == objetivo:
            return izq, der
        if suma < objetivo:
            izq += 1                    # hace falta más: el de la izquierda no sirve con nadie
        else:
            der -= 1                    # sobra: el de la derecha no sirve con nadie
    return None


a = [1, 2, 3, 4, 5]
invertir(a)
print("Invertido:", a)
print("«anita lava la tina» es palíndromo:", "sí" if palindromo("anita lava la tina") else "no")
p = par_que_suma([1, 3, 4, 6, 8, 11, 13, 15], 17)
print(f"Suman 17 las posiciones {p[0]} y {p[1]}")

/** Da la vuelta al array en el sitio: un puntero en cada extremo que se acercan. */
function invertir(a) {
    for (let i = 0, j = a.length - 1; i < j; i++, j--) [a[i], a[j]] = [a[j], a[i]];
}

/** ¿Se lee igual al derecho que al revés? (Sin contar espacios ni mayúsculas.) */
function palindromo(s) {
    const t = s.replaceAll(" ", "").toLowerCase();
    for (let i = 0, j = t.length - 1; i < j; i++, j--)
        if (t[i] !== t[j]) return false;
    return true;
}

/** Posiciones de dos números del array ORDENADO que suman objetivo, o null. */
function parQueSuma(a, objetivo) {
    let izq = 0, der = a.length - 1;
    while (izq < der) {
        const suma = a[izq] + a[der];
        if (suma === objetivo) return [izq, der];
        if (suma < objetivo) izq++;       // hace falta más: el de la izquierda no sirve con nadie
        else der--;                        // sobra: el de la derecha no sirve con nadie
    }
    return null;
}

const a = [1, 2, 3, 4, 5];
invertir(a);
console.log("Invertido: [" + a.join(", ") + "]");
console.log("«anita lava la tina» es palíndromo: " + (palindromo("anita lava la tina") ? "sí" : "no"));
const p = parQueSuma([1, 3, 4, 6, 8, 11, 13, 15], 17);
console.log(`Suman 17 las posiciones ${p[0]} y ${p[1]}`);

using System;

class Program {
    // Da la vuelta al array en el sitio: un puntero en cada extremo que se acercan.
    static void Invertir(int[] a) {
        for (int i = 0, j = a.Length - 1; i < j; i++, j--) (a[i], a[j]) = (a[j], a[i]);
    }

    // ¿Se lee igual al derecho que al revés? (Sin contar espacios ni mayúsculas.)
    static bool Palindromo(string s) {
        string t = s.Replace(" ", "").ToLower();
        for (int i = 0, j = t.Length - 1; i < j; i++, j--)
            if (t[i] != t[j]) return false;
        return true;
    }

    // Posiciones de dos números del array ORDENADO que suman objetivo, o null.
    static (int, int)? ParQueSuma(int[] a, int objetivo) {
        int izq = 0, der = a.Length - 1;
        while (izq < der) {
            int suma = a[izq] + a[der];
            if (suma == objetivo) return (izq, der);
            if (suma < objetivo) izq++;       // hace falta más: el de la izquierda no sirve con nadie
            else der--;                        // sobra: el de la derecha no sirve con nadie
        }
        return null;
    }

    static void Main() {
        int[] a = { 1, 2, 3, 4, 5 };
        Invertir(a);
        Console.WriteLine("Invertido: [" + string.Join(", ", a) + "]");
        Console.WriteLine("«anita lava la tina» es palíndromo: " + (Palindromo("anita lava la tina") ? "sí" : "no"));
        var (i, j) = ParQueSuma(new[] { 1, 3, 4, 6, 8, 11, 13, 15 }, 17)!.Value;
        Console.WriteLine(
quot;Suman 17 las posiciones {i} y {j}");
    }
}

<?php
/** Da la vuelta al array en el sitio: un puntero en cada extremo que se acercan. */
function invertir(array &$a): void {
    for ($i = 0, $j = count($a) - 1; $i < $j; $i++, $j--) [$a[$i], $a[$j]] = [$a[$j], $a[$i]];
}

/** ¿Se lee igual al derecho que al revés? (Sin contar espacios ni mayúsculas.) */
function palindromo(string $s): bool {
    $t = strtolower(str_replace(" ", "", $s));
    for ($i = 0, $j = strlen($t) - 1; $i < $j; $i++, $j--)
        if ($t[$i] !== $t[$j]) return false;
    return true;
}

/** Posiciones de dos números del array ORDENADO que suman $objetivo, o null. */
function parQueSuma(array $a, int $objetivo): ?array {
    $izq = 0;
    $der = count($a) - 1;
    while ($izq < $der) {
        $suma = $a[$izq] + $a[$der];
        if ($suma === $objetivo) return [$izq, $der];
        if ($suma < $objetivo) $izq++;    // hace falta más: el de la izquierda no sirve con nadie
        else $der--;                       // sobra: el de la derecha no sirve con nadie
    }
    return null;
}

$a = [1, 2, 3, 4, 5];
invertir($a);
echo "Invertido: [" . implode(", ", $a) . "]\n";
echo "«anita lava la tina» es palíndromo: " . (palindromo("anita lava la tina") ? "sí" : "no") . "\n";
[$i, $j] = parQueSuma([1, 3, 4, 6, 8, 11, 13, 15], 17);
echo "Suman 17 las posiciones $i y $j\n";

def sin_repetidos(a):
    """Quita los repetidos de una lista ORDENADA sin otra lista: un puntero lento marca dónde escribir
    y uno rápido recorre. Devuelve cuántos distintos hay (quedan en a[0..k-1])."""
    if not a:
        return 0
    lento = 0
    for rapido in range(1, len(a)):
        if a[rapido] != a[lento]:       # uno nuevo: se copia detrás del último distinto
            lento += 1
            a[lento] = a[rapido]
    return lento + 1

/** Quita los repetidos de un array ORDENADO sin otro array: un puntero lento marca dónde escribir
    y uno rápido recorre. Devuelve cuántos distintos hay (quedan en a[0..k-1]). */
function sinRepetidos(a) {
    if (a.length === 0) return 0;
    let lento = 0;
    for (let rapido = 1; rapido < a.length; rapido++) {
        if (a[rapido] !== a[lento]) a[++lento] = a[rapido];   // uno nuevo: se copia detrás del último distinto
    }
    return lento + 1;
}

// Quita los repetidos de un array ORDENADO sin otro array: un puntero lento marca dónde escribir
// y uno rápido recorre. Devuelve cuántos distintos hay (quedan en a[0..k-1]).
static int SinRepetidos(int[] a) {
    if (a.Length == 0) return 0;
    int lento = 0;
    for (int rapido = 1; rapido < a.Length; rapido++) {
        if (a[rapido] != a[lento]) a[++lento] = a[rapido];   // uno nuevo: se copia detrás del último distinto
    }
    return lento + 1;
}

/** Quita los repetidos de un array ORDENADO sin otro array: un puntero lento marca dónde escribir
    y uno rápido recorre. Devuelve cuántos distintos hay (quedan en $a[0..k-1]). */
function sinRepetidos(array &$a): int {
    if (!$a) return 0;
    $lento = 0;
    for ($rapido = 1; $rapido < count($a); $rapido++) {
        if ($a[$rapido] !== $a[$lento]) $a[++$lento] = $a[$rapido];   // uno nuevo: se copia detrás del último distinto
    }
    return $lento + 1;
}