Nivel inicial10 min de lectura · Revisado el 8 de noviembre de 2026

Qué es un isograma: significado, ejemplos y la kata

Si alguien te pide «una mesa para cuatro», el camarero y tú entendéis lo mismo. Con «isograma» no pasa: según a quién preguntes, significa una cosa u otra. En un pasatiempo da igual. En un programa, no: si tú entiendes una cosa y quien te lo pidió otra, el código estará mal aunque funcione.

Aquí verás los dos significados, ejemplos comprobados uno a uno con código y, al final, la kata del isograma resuelta paso a paso con TDD.

Qué es un isograma

La palabra viene del griego isos, «igual», y gramma, «letra». Un isograma es una palabra o frase en la que todas las letras aparecen el mismo número de veces.

• Si cada letra aparece una vez, el isograma no repite ninguna letra: «murciélago».
• Si cada letra aparece dos veces, se dice que es un isograma de segundo orden: «coco» (dos c y dos o).
• Y así sucesivamente.

Ejemplos de segundo orden, comprobados letra a letra con el código de la kata:

Qué es un heterograma

Un heterograma (del griego héteros, «diferente») es una palabra o frase sin ninguna letra repetida. Es el caso particular del isograma en el que cada letra aparece una sola vez.

Algunos heterogramas en español, también comprobados con código:

«Murciélago» es famoso por otra razón: tiene las cinco vocales. Para contar, la é vale como una e más; lo verás en la kata.

¿Por qué se confunden?

Por cómo empezó la palabra. Según Wikipedia, el estudioso de los juegos de palabras Dmitri Borgmann describió estas palabras en su libro Language on Vacation (1965) y las llamaba «isogramas», no «heterogramas». Wikipedia en español, en cambio, usa «heterograma» para la palabra sin letras repetidas y deja «isograma» para el sentido amplio.

La kata de programación, escrita en inglés, sigue el uso de Borgmann: llama isogram a lo que Wikipedia en español llama heterograma. Ninguno de los dos usos es un error; el problema es no decir cuál usas.

La kata del isograma

Una kata es un ejercicio corto que se repite para practicar, como las escalas de un músico (lo explicamos en qué es una kata y un koan). La del isograma aparece, por ejemplo, en Codewars: escribe una función que diga si una palabra es un isograma, entendido como palabra sin letras repetidas; la cadena vacía cuenta como isograma y no se distinguen mayúsculas de minúsculas.

Parece de cinco minutos, y lo es, hasta que llegan las palabras en español. Vamos a resolverla con TDD: primero un test que falla (rojo), después el código mínimo para que pase (verde) y luego, si hace falta, mejorarlo sin cambiar lo que hace (refactor). Si TDD te suena nuevo, empieza por TDD: desarrollo dirigido por tests.

Necesitas una carpeta con un package.json que contenga { "type": "module" }, un fichero isograma.js y otro isograma.test.js. Los tests se lanzan con:

node --test

Paso 1: la cadena vacía

El caso más pequeño que se te ocurra. Empezar por él obliga a crear la función sin pensar todavía en cómo resolver el problema.

// isograma.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { esIsograma } from './isograma.js';

test('una cadena vacía es un isograma', () => {
  assert.equal(esIsograma(''), true);
});

Con una función vacía, el test falla por la razón esperada: la función no devuelve nada.

✖ una cadena vacía es un isograma
  actual: undefined,
  expected: true,

El código mínimo para que pase es devolver true. Parece una trampa, y en parte lo es: el siguiente test la va a desmontar.

// isograma.js
export const esIsograma = (palabra) => true;

Paso 2: una letra repetida

test('una palabra con una letra repetida no es un isograma', () => {
  assert.equal(esIsograma('aba'), false);
});

✖ una palabra con una letra repetida no es un isograma
  actual: true,
  expected: false,

Ahora sí hay que resolverlo. Un Set guarda cada valor una sola vez, como una lista de invitados en la que no puedes apuntar dos veces a la misma persona. Si al pasar las letras a un Set hay menos que en la palabra, alguna estaba repetida.

export function esIsograma(palabra) {
  const letras = [...palabra];
  return new Set(letras).size === letras.length;
}

Para comprobar que no funciona solo por casualidad, añade el caso contrario. Pasa a la primera, y está bien: confirma el comportamiento.

test('una palabra sin letras repetidas es un isograma', () => {
  assert.equal(esIsograma('conquistable'), true);
});

Paso 3: mayúsculas

«Ana» repite la a, aunque una sea mayúscula.

test('no distingue mayúsculas de minúsculas', () => {
  assert.equal(esIsograma('Ana'), false);
});

✖ no distingue mayúsculas de minúsculas
  actual: true,
  expected: false,

Basta con pasar la palabra a minúsculas antes de contar:

const letras = [...palabra.toLowerCase()];

Paso 4: tildes

Aquí empieza el español. En «acá», ¿la a y la á son la misma letra? Para la kata, sí: una tilde no convierte una vocal en otra letra.

test('una vocal con tilde cuenta como la misma vocal', () => {
  assert.equal(esIsograma('acá'), false);
});

✖ una vocal con tilde cuenta como la misma vocal
  actual: true,
  expected: false,

Antes, una pieza: Unicode es la tabla con la que el ordenador numera cada letra y cada signo. En ella, una tilde puede guardarse pegada a su letra («á») o como una pieza suelta que se coloca encima de la letra anterior.

El truco es normalize('NFD'): separa cada letra de su tilde, de modo que la «á» pasa a ser una «a» seguida de una tilde suelta. Después se borran las tildes sueltas, que en Unicode son «marcas» (\p{M}):

const letras = [...palabra.toLowerCase().normalize('NFD').replace(/\p{M}/gu, '')];

Paso 5: la ñ

La ñ no es una n con adorno: es otra letra. «Niño» no repite ninguna.

test('la ñ es una letra distinta de la n', () => {
  assert.equal(esIsograma('niño'), true);
});

✖ la ñ es una letra distinta de la n
  actual: false,
  expected: true,

Este rojo es el más valioso de la kata: el arreglo de las tildes ha roto la ñ. Para Unicode, la virgulilla de la ñ (la rayita ondulada de encima) es una marca más, así que el paso anterior la quitaba y «niño» se convertía en «nino», con dos n. Sin este test, el fallo habría pasado desapercibido hasta que alguien escribiera su nombre.

La solución es borrar todas las marcas menos la virgulilla (U+0303) y volver a juntar las letras con normalize('NFC'):

// isograma.js
// Quita las tildes y la diéresis, pero no la virgulilla de la ñ, que es otra letra.
const SIN_TILDES = /[\u0300-\u0302\u0304-\u036f]/g;

export function esIsograma(palabra) {
  const letras = [...palabra.toLowerCase().normalize('NFD').replace(SIN_TILDES, '').normalize('NFC')];
  return new Set(letras).size === letras.length;
}

Con eso, los seis tests pasan.

Paso 6: refactor

Con todo en verde, toca dejar el código claro. La limpieza de la palabra merece nombre propio, letrasDe; lo demás no cambia:

// isograma.js
// Quita las tildes y la diéresis, pero no la virgulilla de la ñ, que es otra letra.
const SIN_TILDES = /[\u0300-\u0302\u0304-\u036f]/g;

export function letrasDe(palabra) {
  return [...palabra.toLowerCase().normalize('NFD').replace(SIN_TILDES, '').normalize('NFC')];
}

export function esIsograma(palabra) {
  const letras = letrasDe(palabra);
  return new Set(letras).size === letras.length;
}

node --test

✔ una cadena vacía es un isograma
✔ una palabra con una letra repetida no es un isograma
✔ una palabra sin letras repetidas es un isograma
✔ no distingue mayúsculas de minúsculas
✔ una vocal con tilde cuenta como la misma vocal
✔ la ñ es una letra distinta de la n
ℹ pass 6
ℹ fail 0

Bonus: el isograma en sentido estricto

Si lo que quieres es el otro significado, que cada letra aparezca las mismas veces, se cuenta cuántas veces sale cada letra y se comprueba que todas las cuentas coinciden. Reutiliza letrasDe, así que las tildes y la ñ ya están resueltas:

// estricto.js
import { letrasDe } from './isograma.js';

export function todasIgualDeVeces(palabra) {
  const veces = new Map();
  for (const letra of letrasDe(palabra)) veces.set(letra, (veces.get(letra) ?? 0) + 1);
  return new Set(veces.values()).size <= 1;
}

Sus tests documentan los dos significados de un vistazo: «zambombazo» y «conquistable» pasan; «papelera», no. Con los tres de esta función son nueve tests, y todos pasan.

Lo que enseña esta kata

• Los casos límite están en el idioma, no en el algoritmo. El Set resuelve el problema en dos líneas. Lo difícil son las mayúsculas, las tildes y la ñ, y solo aparecen si alguien escribe el test.
• Un test es una definición. «¿Cuenta la á como a?» no lo decide el código, lo decides tú. El test deja la decisión por escrito, a la vista de quien venga después.
• Un arreglo puede romper otra cosa. El paso 5 lo demuestra: sin un test para la ñ, el arreglo de las tildes habría introducido un fallo sin que nadie lo notara.

Esto último pesa más cuando el código lo escribe un asistente de IA. Si le pides «una función que diga si una palabra es un isograma», elegirá un significado sin avisarte y probablemente no pensará en la ñ. Si antes escribes los tests, le das el contrato y una forma de comprobar que lo cumple. Es una interpretación propia, pero es la idea central de la IA limpia.

Tu siguiente paso

1. Haz la kata tú, sin mirar la solución, y añade un test que no esté aquí: ¿qué pasa con «pingüino» o con una palabra con guion?
2. Elige la siguiente en la lista de katas para practicar TDD.
3. Si quieres entender el ciclo con más calma, lee el algoritmo de TDD.

Fuentes

• Diccionario de la lengua española (RAE, 24.ª edición): ni «isograma» ni «heterograma» tienen entrada. Comprobado el 8 de noviembre de 2026 en dle.rae.es.
• Heterograma, en Wikipedia en español, consultada el 8 de noviembre de 2026. De ahí salen la etimología, las dos definiciones y la atribución del término a Dmitri Borgmann (Language on Vacation, 1965). Es una fuente secundaria: el libro de Borgmann no se ha consultado.
• Enunciado de la kata: Isograms, en Codewars, el mismo que se cita en la lista de katas.
• Ejemplos: los isogramas «murciélago», «conquistable», «culteranismo» y «yuxtaponer», y los de segundo orden de la tabla («coco», «insistente», «carrascoso», «quisquilloso» y «zambombazo»), están en la lista de palabras de Linux /usr/share/dict/spanish (paquete wspanish, 86.016 entradas). «Repúblicas», «centrifugado» e «hiperblanduzcos» vienen de la lista de heterogramas de Wikipedia. La propia lista de Wikipedia de isogramas de segundo orden contiene errores («papelera», «acondicionar», «escritura» e «intestinos» no lo son); aquí solo se usan palabras verificadas. Todos se han comprobado letra a letra con el código del artículo.
• Código: todo el código se ha ejecutado con Node.js 24.21.0 y node:test el 8 de noviembre de 2026. Las salidas de terminal son las reales, recortadas a las líneas que importan.