Si lo subes a github sin indicar ninguna licencia, por defecto tienes los derechos de autoría. Es decir, el copyright de toda la vida.

Si alguien quiere utilizarlo de cualquier forma, tiene que pedirte una licencia explícitamente para su uso. Y ya tu decides.
 Por eso recomiendo github.

Y wayback machine es una forma de tener un registro por si el día de mañana por lo que sea Microsoft te cierra la cuenta de github o te borra el repo, tienes el registro ahí de que fuiste el primero en publicar ese trabajo en la red.



Tengo ganas de ver el cifrado. Me apasiona la criptografía y yo mismo he desarrollado algoritmos clásicos y modernos. Me lo leere y te daré mi opinion cuando lo publiques.

Esa madre aun existe?

No creo, esa guera de Rusia con Ucrania no creo que llegue a terminar por una conversación entre ellos, Rusia tiene muchos intereses en quedarse con Ucrania como para rendirse así de fácil, eso no terminara bien

Esa debe ser IT

La verdad que visitar Corea del Norte es uno de mis objetivos, me da mucha curiosidad ver en carne viva la situación que ellos viven

Este uno de eso fragmento que yo me acuerdo vi ese reportaje hace ya años


Si ese episodio es muy antiguo es del año 2015 hasta ahora, algo ha cambiado en corea del norte tienes mas misiles por ejemplo, más edificios tipo turístico eso si solo para los coreanos  para los extranjeros nada de nada.

 

JERARQUIA.EQV es de las "nuevas" fórmulas que ponen para intentar ser más legibles, como desventaja es que solo funciona con valores numéricos, la fórmula madre CONTAR.SI hace exactamente lo mismo con más lógica, estas dos formulas son completamente equivalentes, aparte de que CONTAR.SI funciona con números y texto:

  A        B          C
 +-----------------------------  
1|     JERARQUIA.EQV   CONTAR.SI
2| 9         1            1
3| 9         1            1
4| 9         1            1
5| 8         4            4

=JERARQUIA.EQV(A2;$A$2:$A$5;0)

=CONTAR.SI($A$2:$A$5;">"&A2)+1


No hay error porque está usando rangos dinámicos CONTAR.SI($Q$124:Q124;Q124), ves que $Q$124 inmoviliza esa coordenada, pero Q124 no está inmovilizado, por eso al arrastrar la fórmula $Q$124 se mantendrá mientras que Q124 se irá incrementando por cada celda que se arrastre aumentando el rango dinámicamente, el último Q124 es la condición, es decir, cuenta cuantas apariciones del valor último (Q124) hay en el rango dinámico $Q$124:Q124

Teniendo todo lo anterior claro, puedes utilizar:

=CONTAR.SI($A$2:$A$5;">"&A2)+CONTAR.SI($A$2:A2;A2)

---
Otra opción por la que podrías optar es usar Macros, siempre hay gente purista que lo quiere hacer todo con fórmulas madre, otros con fórmulas matriciales, otros todo con tablas dinámicas, otros todo con macros, etc, es una locura XD, pero es bueno conocer un poco de todo.



Con darle click derecho al nombre de la hoja, Ver código abres el editor de macros, arriba tienes el ámbito (General y Worksheet), se elige Worksheet que corresponde a la Hoja actual, luego se elige el evento, se utilizará Change porque este se ejecuta cada vez que hay cambios en alguna celda de la hoja

El código es:

Private Sub Worksheet_Change(ByVal Target As Range)
  Application.EnableEvents = False
  promedios = Range("L131:L137").Value
  ataqueTipos = Range("B131:B137").Value
  For i = 2 To UBound(promedios)
    For j = 1 To UBound(promedios) + 1 - i
      If promedios(j, 1) < promedios(j + 1, 1) Then
        tmp = promedios(j, 1)
        promedios(j, 1) = promedios(j + 1, 1)
        promedios(j + 1, 1) = tmp
        tmp = ataqueTipos(j, 1)
        ataqueTipos(j, 1) = ataqueTipos(j + 1, 1)
        ataqueTipos(j + 1, 1) = tmp
      End If
    Next
  Next
  Range("B127") = ataqueTipos(1, 1)
  Range("B128") = ataqueTipos(2, 1)
  Application.EnableEvents = True
End Sub

1. Indica el tipo de estructura (Private Sub) en este caso es una Procedimiento (función que no devuelve valor), el nombre es Worksheet_Change (puede ser cualquiera, pero el nombre por defecto ya es bastante claro al dar a entender que corresponde al evento Change de la Hoja), luego están los argumentos del Procedimiento, por defecto está el argumento de nombre Target de tipo (As) Range (rango de celdas) y se pasa por valor (ByVal)

2. Esta línea desactiva los eventos, claro, sino cualquier cambio en el Excel volvería a llamar a este Procedimiento, incluso este Procedimiento puede hacer cambios y no queremos que se re-llame, al menos no hasta terminar

3 y 4. Declaro dos variables Array, el primero para guardar los "promedios", y el otro para guardar los "ataques tipos", los Range siempre devuelven Arrays bidimensionales (Fila, Columna), además estos Arrays empezarán con índice 1 en lugar de 0

5 al 16. Es el famoso algoritmo de ordenación Burbuja, los bucles en las Macros de Excel (VBA) tienen diferente sintaxis a las que ya conoces, For inicializar_variable To valor_maximo_de_variable, por ejemplo el clásico for (i = 0; i < 10; i++) en VBA es: For i = 0 To 9, no requiere el i++ porque se sobreentiende que la variable debe aumentar de uno en uno con cada iteración

Ubound devuelve el último índice de un Array, si el Array es: vocales = ("a", "e", "i", "o", "u"), UBound(vocales) devolverá 4 porque se sobreentiende que el array vocales empieza con índice 0:

vocales(0) = "a"
vocales(1) = "e"
vocales(2) = "i"
vocales(3) = "o"
vocales(4) = "u"

Ah, y los Arrays en VBA usan paréntesis en lugar de corchetes como se puede ver. Considerando que Range devuelve un Array bidimensional y que además el primer índice empieza en 1, sería algo así suponiendo que las vocales están en el rango "A1:A5" :

vocales = Range("A1:A5")

Es lo mismo que:

vocales(1,1) = "a"
vocales(2,1) = "e"
vocales(3,1) = "i"
vocales(4,1) = "o"
vocales(5,1) = "u"

Recuerda: vocales(fila, columna), si usas UBound(vocales) devuelve el último índice del array, es decir 5

El Algoritmo de Ordenación es muy popular así que no lo explicaré, salvo las líneas 11, 12 y 13 porque lo que hacen es replicar esa misma ordenación con el Array "ataqueTipos" para replicar esa ordenación, también decir que en todos los casos se está índicando el 1 en por ejemplo promedio(j,1) porque el Array es bidimensional pero como solo tiene una Columna y no necesitamos más, ponemos 1, solo varía la Fila

17 y 18 Escriben el primer y segundo valor del Array ordenado en la celda de resultados

19 Vuelve a activar los eventos

---
Adjunto el archivo de excel para que lo revises, y otra cosa importante de las Macros es que para que se conserven debes guardar el archivo como .xlsm en lugar de .xlsx, el propio excel te lo recordará, aparte de los permisos y confianza en las macros claro, esa es la desventaja de las macros, muy escandalosas

https://mega.nz/file/0wYUwajC#ulsigtqFbg-HURicEbyU8zLyTYgq8dpBN3CWIhE3vYk

Si A y B deben mantenerse ponles un $ delante: $A $B, ambos son indicadores de columnas, si arrastras verticalmente nunca cambiarán, si arrastras horizontalmente si cambiaran salvo que tengan los $ delante, los números son indicadores de filas, de forma similar nunca cambiaran si arrastras horizontalmente, pero si cambiaran si arrastras verticalmente salvo que tengan el $ delante


Solo fija A y B, no los números:

=SI(Y(CONTAR.SI($N$2:$N$9;$A19)>0; CONTAR.SI($N$2:$N$9;$B19)>0); $N$10; "")


N solo cambiará a M si arrastras horizontalmente hacia la izquierda y solo si le quitas los $, pero que luego M cambie a O?, eso ya está raro, supongo que te equivocaste

Recuerda que puedes presionar el atajo de teclado F4 para que la fijación ($) vaya cambiando entre: Fijar todo ($A$1), solo Columna ($A1), solo Fila (A$1) o nada (A1), obviamente tienes que tener el cursor en el A1 o seleccionarlo, también te vale para Rangos (A1:A5)

Como bien comenta el compañero Manolo, yo también te recomiendo Github para compartir tus trabajos y para licenciarlos podes usar Creative Commons:

https://creativecommons.org.ar/licencias/

en la celda N12 tengo esto:
=SI(CONTAR.SI($N$2:$N$9;B12)>1; $N$10; "")
más abajo se repite, cambiando B12 por B13, etc
Más abajo la fórmula cambia a:
=SI(Y(CONTAR.SI($N$2:$N$9;A19)>0; CONTAR.SI($N$2:$N$9;B19)>0); $N$10; "")
más abajo se repite, cambiando A19 y B19, por A20 y B20, luego 21, etc
Finalmente, más abajo cambia a:
=SI(CONTAR.SI($N$2:$N$9;B124)>0; $N$10; "")
y más abajo se repite cambiando B124 por B125, etc

Debo crear columnas al lado de esa, y es muy tedioso cambiar las letras.
A y B deben mantenerse, pero si le pongo los $ no van a cambiar los números cuando quiera que lo hagan hacia abajo.
Y N debe cambiar a M, luego a O, etc, pero si no le pongo los $ aumentarían los números de los rangos cuando quiera que la fórmula se aplique más abajo.

¿comprendes? ¿hay alguna forma de automatizar eso mejor? Por ejemplo se me ocurre hacer un programa que genere las fórmulas separadas con tab, luego creo las columnas y pego esas fórmulas

...

La respuesta de GPT es complicada para mí:
Sí, comprendo el problema: necesitas arrastrar fórmulas hacia abajo (que cambien los números de fila) y también copiarlas hacia la derecha a nuevas columnas, donde la letra de la columna de búsqueda (N) cambie a M, O, P, etc., pero sin que se “rompan” las referencias al arrastrar.

Claves para resolverlo sin macros:
- Usa referencias mixtas para filas/columnas según necesites que varíen.
- Usa DESREF/INDICE con COINCIDIR o con COLUMNAS/ FILAS para construir rangos que cambien de columna al copiar a la derecha.
- Evita “letras fijas” en las fórmulas; genera el rango por posición.

Propuesta 1: construir el rango N2:N9 de forma dinámica según la columna
- Supón que pegas en la primera columna (por ejemplo, columna C) y que quieres que:
  - En esa columna use N2:N9.
  - A la derecha, use O2:O9, luego P2:P9, etc. (o M, O, … ajusta el desplazamiento).
- Usa INDICE con DESREF o directamente DESREF sobre N2:N9 y desplaza por el número de columnas copiadas.

Ejemplo base (para la primera fórmula):
- Rango base: $N$2:$N$9
- Desplazamiento horizontal: COLUMNAS($C:C)-1 si pegas primero en C; ajusta a tu columna real.

Fórmula que cambia N→O→P al copiar a la derecha y mantiene filas al copiar hacia abajo:
=SI(CONTAR.SI(DESREF($N$2:$N$9;0;COLUMNAS($C:C)-1); B12)>1; INDICE($N:$N;10); "")
Notas:
- DESREF($N$2:$N$9;0;COLUMNAS($C:C)-1) empieza en N2:N9 y se mueve 0 filas y (n-1) columnas a la derecha cuando copias a la derecha.
- B12 no lleva $ para que al arrastrar hacia abajo cambie a B13, B14, etc.
- INDICE($N:$N;10) devuelve N10. Si quieres que también cambie de N a O al copiar a la derecha, usa DESREF para N10 igual que para el rango:
  DESREF($N$10;0;COLUMNAS($C:C)-1)

Entonces la versión completa que también mueve la celda de resultado:
=SI(CONTAR.SI(DESREF($N$2:$N$9;0;COLUMNAS($C:C)-1); B12)>1; DESREF($N$10;0;COLUMNAS($C:C)-1); "")

Para la segunda fórmula (con A y B):
=SI(Y(CONTAR.SI(DESREF($N$2:$N$9;0;COLUMNAS($C:C)-1); A19)>0; CONTAR.SI(DESREF($N$2:$N$9;0;COLUMNAS($C:C)-1); B19)>0); DESREF($N$10;0;COLUMNAS($C:C)-1); "")

Para la tercera fórmula:
=SI(CONTAR.SI(DESREF($N$2:$N$9;0;COLUMNAS($C:C)-1); B124)>0; DESREF($N$10;0;COLUMNAS($C:C)-1); "")

Cómo usar:
1) Pega la fórmula en la primera columna donde quieras empezar (ajusta $C:C a tu columna inicial).
2) Arrastra hacia abajo: A/B/Bx cambian de fila; los rangos 2:9 y 10 quedan fijos en filas.
3) Copia hacia la derecha: el DESREF moverá N→O→P… y también N10→O10→P10.

Si en vez de N→O→P necesitas M→N→O (empezar en M), cambia el offset:
- Usa COLUMNAS($B:C)-1 si la primera columna de pegado es C pero quieres que el desplazamiento empiece ya en +1 (es decir, M cuando offset = -1). Más claro es anclar una columna “origen”:
  DESREF($M$2:$M$9;0;COLUMNAS($C:C)-1)
  y
  DESREF($M$10;0;COLUMNAS($C:C)-1)
Así la primera columna usa M; a la derecha será N, luego O, etc.

Alternativa sin DESREF (más “segura” por volatilidad) usando INDICE:
- Rango variable 2:9:
  INDICE($N:$Z; FILA($2:$9); COINCIDIR(COLUMNAS($C:C)+COLUMNA($N:$N)-COLUMNA($N:$N); COLUMNA($N:$Z); 0))
Esto es más enrevesado; en la práctica DESREF es suficiente y más legible.

Consejo final:
- Evita $ en la letra de A y B si quieres que cambien de fila al arrastrar.
- Usa $ en los números 2:9 y 10 para fijar esas filas.
- Controla el cambio de N→O→P con DESREF y COLUMNAS ancladas a la primera columna de pegado.

Si me indicas:
- En qué columna empiezas a pegar,
- Si quieres iniciar en M o en N,
- Y el patrón exacto de columnas,
te devuelvo las tres fórmulas ya ajustadas listas para copiar-pegar.

Para empezar debo pegar esto:
=SI(CONTAR.SI(DESREF($N$2:$N$9;0;COLUMNAS($C:C)-1); B12)>1; DESREF($N$10;0;COLUMNAS($C:C)-1); "")

Nah, está muy raro.

A ver, vamos paso a paso.
En C12 tengo: =SI(CONTAR.SI($C$2:$C$9;B12)>1; $C$10; "")
En C13: =SI(CONTAR.SI($C$2:$C$9;B13)>1; $C$10; "")
O sea, cambia el número al lado de B, está bien.

En D12 tengo: =SI(CONTAR.SI($D$2:$D$9;B12)>1; $D$10; "")
ven que, todo C cambió a D.

Entonces, supongamos que sólo quisiera que cambie la última letra. Que el 10 se mantenga, pèro que cuando arrastro la fórmula a otra columna, C cambie a la columna en cuestión.

¿Cómo se hace? Eso para empezar, el resto lo intentaré entender luego.

Fórmula original:
=SI(CONTAR.SI($C$2:$C$9;B12)>1; $C$10; "")
GPT dijo:
=SI(CONTAR.SI($C$2:$C$9;$B$12)>1; DESREF($C$10; 0; COLUMNA()-COLUMNA($C$10)); "")
puso $ en B porque le dije. No entiendo esto:
DESREF($C$10; 0; COLUMNA()-COLUMNA($C$10))
y no tengo más puntos, pregunto a Deepseek.

En cierto punto le planteé el problema desde 0 y me dijo:
¡Entiendo perfectamente! Es un escenario muy común. Necesitas **fijar la fila (10)** pero **dejar la columna relativa** para que se ajuste al arrastrar. La solución es correcta y simple usando **referencias mixtas**.

### Solución Correcta y Simplificada:

**`=SI(CONTAR.SI($C$2:$C$9; $B$12)>1; C$10; "")`**

---

### 🔐 Explicación de la Referencia Mixta: `C$10`

*   **`C`** (sin `$`): La **columna es relativa**. Se ajustará automáticamente al arrastrar la fórmula a la derecha o izquierda (se convertirá en D, E, F...).
*   **`$10`** (con `$`): La **fila es absoluta**. No cambiará nunca, sin importar si arrastras la fórmula hacia arriba o hacia abajo. El número **10 se mantendrá fijo**.

### 📍 Comportamiento al Arrastrar:

| Si la fórmula está en: | La referencia se convierte en: | Resultado |
| :--- | :--- | :--- |
| **Celda C15** | `C$10` | Valor de **C10** |
| **Celda D15** | `D$10` | Valor de **D10** |
| **Celda E20** | `E$10` | Valor de **E10** |
| **Celda F5** | `F$10` | Valor de **F10** |

### ✅ Por qué esta es la mejor solución:

1.  **Muy Simple:** Solo usas una referencia de celda normal (`C$10`) en lugar de una función compleja.
2.  **Más Fácil de Entender:** Cualquiera que vea la fórmula sabe instantáneamente que apunta a la fila 10.
3.  **Más Eficiente:** Excel calcula referencias directas mucho más rápido que funciones como `DESREF` o `INDIRECTO`.
4.  **Cumple tu Requisito:** La fila 10 nunca cambia, la columna sí se ajusta.

**En resumen:** Reemplaza el `DESREF` complejo por la referencia mixta **`C$10`**.

Tu fórmula final, optimizada y fácil de leer, queda así:
```excel
=SI(CONTAR.SI($C$2:$C$9; $B$12)>1; C$10; "")
```
Puede que ya me hayan dicho eso y yo lo haya olvidado, de momento no puedo probarlo, luego sigo.