USA compró California a España, "Por un puñado de dólares."

Creo que hay dos cosas distintas entremezcladas...

- Una cosa es que te confundan con otra procedencia... lo cual no tiene ninguna importancia. Quién puede acertar a ojo sin confusión, si un tipo es chino, coreano, japonés, o noruego, finlandés, sueco... o gambiano, etíope, nigeriano... o... es razonable confundirse a menudo.
- Y otra cosa distinta es el desprecio con que te traten (producto o no, de dicha confusión).

Supongo que es esto último  y no la 'mera confusión', lo que molesta a cualquiera.
Por lo demás como dice #!drvy, generalizar en cosas como 'por qué los españoles se enojan...' es absurdo...

No es tan complicado...

En primer lugar puesto que se quiere devolver en un array hay que precalcular el tamaño que él mismo tendrá.

Dado que cada carácter tiene 2 variaciones (mayúscula minúscula), que no hay permutaciones de lugar y el tamaño del string...
cantidad = 2^size(delString)
Siendo la cadena: 'string' size=6; 2^6=64. Luego el array tendrá 64 ítems.

La segunda parte, se resuelve en un bucle recursivo... usando grafos. Básicamente es un árbol binario. Nota que no es preciso usar ni construir ninguna estructura especial, más allá del array. Aunque tirando por un árbol binario, te sería más sencillo.

La palabra tendrá un nodo raíz (pongamos '*'), que accede a la primera letra, es decir 's' y 'S' son sus dos nodos hijo.
A su vez cada una de ellas tiene como nodos hijos a la siguiente letra en las dos versiones (mayúscula y minúscula).
Te pongo la jerarquía, de nodos, el de la izquierda es un nodo ya añadido al árbol, los de la derecha son los hijos que se le añaden como hijos:

Nota que los dos últimos nodos no tienen hijos...

Ahora si se recorre todas las posibilidades del árbol obtendrás las 64 combinaciones distintas (desprecia el nodo raíz para formar la combinación a la hora de pasarlo al array de destino).
El problema de usar una estructura de árbol, es que empleará más espacio del strictamente necesario, ya que por ejemplo, al llegar al último nodo, n y N, cada uno de ellos tendrán por nodos finales 'g' y 'G', es decir se habrá añadido 32 nodos 'g' y 32 nodos 'G'.
Estrictamente basta un array de una estructura simple con cada uno de esos nodos:

Luego se puede pasar como una cadena de texto, o un array de texto, el contenido de más arriba '*= s|S, s= t|T, S= t|T ..." , el caso es una función recibe y parsea dicho contenido al array Nodos() que se compone de la estructura nodo.
Rellenando dicho array quedaría así:

Ahora con dciho array una función recorre recursivamente, tomando en cada ciclo el 'nombre' del nodo visitado, que se usa para ir concatenando la variación adecuada. La recursión finaliza cuando el nodo es terminal...
Como cada nodo tiene 2 hijos (podrían tener 1 o más), se precisa tambén un bucle interno para dicho recorrido de hijos.

La función de recorrido se invoca desde la que parsea la entrada,  sería más o menos así:

Esta función (así de simple), recorre todas las combinaciones posibles.

La función que parsea el texto de entrada, lo dejo a tu esfuezo, pués se trata de 'desguazar' dicha cadena en sus nodos, y cada nodos en sus elementos, para generar el array de nodos. Se requieren dos bucles, en el primero se crea el array con los 13 nodos (0 a 12, el 0 es el raíz), aplicando nombre, indice (el mismo del contador del bucle), número de hijos y si es o no terminal. Es terminal si no tiene hijos (caso de 'g' y 'G'). En el segundo bucle, se rellenan los datos que no se conocían , esto es, los hijos, requiere una búsqueda. Por ejemplo: Sabiendo que 't' tiene como hijos a 'r' y a 'R', precisa buscar que posicón ocupan esos nodos 'r' y 'R', para terminar de rellenar los datos (es decir busca rel índice de ?????:

La funcion principal, invoca a dos, una para generar los nodos y luego para realizar el recorrido.


La función que construye el array de la estructura 'nodo'...
Nota que aquí tomamos la palabra entrada, sin generar las producciones comentadas al principio (dada la simplicidad de dichas producciones, es todo muy deducible).

Una captura:
(nota que yo he dejado el 'nombre' de la raíz  '*', con cada uno)




La salida completa sería:
La opción de resolverlo con un árbol, es también adecuada, como te describí más arriba... pero elige el modelo que mejor veas factible de entender e implementar...

Esto es muy ineficiente...
Estás leyendo secuencialmente un fichero para localizar un valor...
Cuando es posible, es más óptimo el acceso aleatorio a la posición deseada del fichero.

Si el valor está ordenado, y por tanto 'identificación' es el enésimo registro, puedes calcular la posición y saltar directamente a ella.
Viendo que 'identificador' aumenta 1 a 1, es deducible que el contenido en el fichero está ordenado...

Si no está ordenado, todavía puedes ir saltando... y leer en cada ciclo, solo 'identificación' hasta que lo encuentras, y acto seguido lees lo que se precisa.




1 - Abrir, para luego cerrar, qué sentido tiene????.
2 - Esa línea es redundante... sobra.
3 - Nuevamente es muy ineficiente... estás accediendo al último registro.... calcula: del tamaño del fichero, resta el tamaño de 1 regsto, posicionas el cursor ahí.. Basta leer solo el último registro.
En ficheros pequeños la ineficiencia no se aprecia, cuando operes con ficheros de muchos Mb... (pongamos 1Gb.... se hará intolerable la espera).

---

Y por favor, ya llevas tiempo en el foro, acostumbra a usar la etiquetas del 'código GESHI', ...las encuentras cuando editas el mensaje entre las opciones de edición de dicha ventana...

En primer lugar el código, siempre que sea posible y haya en el listado de etiquetas Geshi, el lenguaje para el mismo, procede colocarlo dentro de tales etiquetas... para que resulte cómodo leer y mantenga al menos el formato de la indentación.
O manualmente... (quitando los espacios se convierte en las etiquetas BBcode)
[ code = vb ] tu código aquí [ / code ]

Line input, lee una linea entera es decir hasta que encuentre un salto d elínea, sea la cantidad de bytes que sea. Por lo que solo resulta indicado en ciertas situaciones:
- Se pretende leer texto, por tanto leer cada vez una línes es adecuado, porque a priori, nos e conoce el tamaño de cada línea.
- Los datos están fuertemente formateados. En tal caso, el usuario se supone conocer correctamente la estructura y la forma de 'desguazar' (parse), dicha línea en las variables que proceda.
- Cualquier otra situación, pero solo cuando hay un único dato en cada línea (que no requiere un parsingm ás allá de la asignación).

Luego, Line input, lee 'string', cadenas de texto... de ahí el error que te arroja, puesto que tu (seguramente) intentas volcarlo en un tipo integer.

---

Antes de eso, con input es más procedente cuando se conoce muy bien el formato que compone el fichero y éste tiene (o puede tener) distintos tipos...
Así algo como:

 Dim numVertices as byte
 Dim Vertices() as single
 dim canal as integer 
 dim Ruta as string 
 
    ' Abrir el fichero... 
    ruta = "tu ruta al fichero deseado..."
    canal = Freefile
    open ruta for input as #canal
 
    ' leer datos
    input #canal,,numVertices
    if (numVertices >0)
        redim vertices(0 to numVertices-1) 
         input #canal,, vertices
    else
        '... algún mensaje de error si procede...
    end if
 
   close #canal
 

   
Que viene a decir... primero se lee la cantidad de vertices que es un byte (es decir un valor entre 1 y 255) y la siguiente lectura leerá, tantos valores de tipo single como indique...
Esto es porque hay un formato reconocido para el fichero que se conoce, y por tanto se aplicó al escribir y eél mismo es adecuado para leer.

No puedes escribir 10 bytes y luego pretender leer 12.
Las variables Azar, Azar1... y 'contador' están declarados como 'integer', luego por cada uno se leen 2 bytes.
EOF, detectará correctamente el final del fichero, siempre que una lectura cumpla una de estas dos condiciones:
A - se lee 1 único byte cada vez en el bucle.
B - Se leen los bytes que sean, pero congruentes al tamaño. Esto es, si se guardaron 60 bytes, puedo leer en cada ciclo, 2, o en cada ciclo 3, o en cada ciclo, 4 o en cada ciclo, 5, 10, 12, 15, 20, 30, 60... porque todos ellos son submúltiplos de 60
Si el fichero tiene 60 bytes y en cada ciclo se leen 7 bytes, al llegar al 8º ciclo, he leído 56 bytes (7*8), luego en el siguiente ciclo, al intentar leer 7 bytes, puésto que solo restan 60-56 = 4, saltará el error...

En el caso 'A', solo interesa cuando se sepa que es precisamente así como se quiere leer byte a byte, porque el tipo de datos de destino son bytes, o bien cuando es uno mismo quien procederá a componer el tipo que proceda. Ahora leer byte a byte es lento.
En el caso 'B', interesa cuando uno tiene que leer datos de forma más o menos compleja, aunque si hay un 'patrón' sería mejor crear una estrcutura (type), y leer con una sola variable todo el contenido d ela estructura, es decir 'record a record'...

Cierto problema con 'input' es que es 'exigente, es decir requiere que la lista de variables leída estén en el mismo orden y sean del mismo tipo que se escribieron, es decir si fueras a leer un entero donde se escribió una cadena, el entero devolvería 0.

Es más conveniente, para evitar ciertas complejidades para quienes no se leen nada de documentación leer y escribir en 'binary' mode... ya que lee y escribe bytes al tipo que lee, no guarda ninguna info del tipo que se guarda, luego es perfectamente sencillo guardar un tipo long (4 bytes) y luego leerlo como bytes, como integer como byte e integer, como long, incluso como cadena.

 '....
    dim k as long, j as integer, i as byte, b as boolean, s as string, ib() as byte  
 
    ' Escribimos un valor de tipo long = 4 bytes.
    Open ruta for binary as #canal 
    k = 1145323841
    put #canal,,k
    debug.print "Escrito el tipo long con valor: " & cstr(k)
    close #canal
 
    ' Leemos un tipo long = 4 bytes.
    k= 0
    canal = freefile
    open ruta for binary as #canal
    get #canal,, k
    debug.print "Leido el tipo long con valor: " & cstr(k)
    close #canal
    debug.print
 
    ' Leemos un tipo integer 2 veces (2+2)=4 bytes.
    canal = freefile
    open ruta for binary as #canal
    get #canal,, j
    debug.print "Leido el tipo integer con valor: " & cstr(j)
    get #canal,, j
    debug.print "Leido otrol tipo integer con valor: " & cstr(j)
    close #canal
    debug.print
 
    ' Leemos un tipo integer y byte 2 veces (2+1+1)=4 bytes.
    canal = freefile
    open ruta for binary as #canal
    get #canal,, j
    debug.print "Leido el tipo integer con valor: " & cstr(j)
    get #canal,, i
    debug.print "Leido el tipo byte con valor: " & cstr(i)
    get #canal,, i
    debug.print "Leido otro tipo byte con valor: " & cstr(i)
    close #canal
    debug.print
 
    ' Leemos un tipo integer y byte 2 veces (2+1+1)=4 bytes.
    canal = freefile
    open ruta for binary as #canal
    get #canal,, j
    debug.print "Leido el tipo integer con valor: " & cstr(j)
    get #canal,, i
    debug.print "Leido el tipo byte con valor: " & cstr(i)
    get #canal,, i
    debug.print "Leido otro tipo byte con valor: " & cstr(i)
    close #canal   
    debug.print
 
    ' Leemos un tipo integer y boolean (2+2)=4 bytes.
    canal = freefile
    open ruta for binary as #canal
    get #canal,, j
    debug.print "Leido el tipo integer con valor: " & cstr(j)
    get #canal,, b
    debug.print "Leido el tipo boolean con valor: " & cstr(b)
    close #canal
    debug.print
 
    ' Leemos los mismos, al revés tipo boolean e integer (2+2)=4 bytes.
    canal = freefile
    open ruta for binary as #canal
    get #canal,, b
    debug.print "Leido el tipo boolean con valor: " & cstr(b)
    get #canal,, j
    debug.print "Leido el tipo integer con valor: " & cstr(j)
    close #canal
    debug.print
 
    ' Leemos un tipo byte a byte, 4 veces (1+1+1+1)=4 bytes.
    canal = freefile
    open ruta for binary as #canal
    get #canal,, i
    debug.print "Leido el tipo byte con valor: " & cstr(i)
    get #canal,, i
    debug.print "Leido otro byte con valor: " & cstr(i)
    get #canal,, i
    debug.print "Leido otro byte con valor: " & cstr(i)
    get #canal,, i
    debug.print "Leido otro byte con valor: " & cstr(i)
    close #canal 
    debug.print
 
    ' Leemos un tipo byte y 3 más en un array (1+1+1+1)=4 bytes.
    canal = freefile
    open ruta for binary as #canal
    get #canal,, i
    debug.print "Leido el tipo byte con valor: " & cstr(i)
    redim ib(0 to 2) ' dimensionar el array a un tamaño igual o menor a lo que reste en el fichero.
    get #canal,, ib
    debug.print "Leido un array de 3 bytes con valores: ",  cstr(ib(0)),  cstr(ib(1)),  cstr(ib(2))
    close #canal 
    debug.print
 
    ' Leemos un tipo string de 3 caracteres (1+1+1+1)=4 bytes.
    canal = freefile
    open ruta for binary as #canal
    s= space$(4)  ' dimensionar el string... si no es un string nulo ""
    get #canal,, i
    debug.print "Leido el tipo byte con valor: " & cstr(i)
    redim ib(0 to 2)
    get #canal,, ib
    debug.print "Leido un array de 3 bytes con valores: ",  cstr(ib(0)),  cstr(ib(1)),  cstr(ib(2))
    close #canal 
    debug.print
 

Nota que cada vez hemos abierto y cerrado el fichero... no es estrictamente necesario, bastaría con reposicionar el curso de lectura al comienzo:

el acceso aleatorio a un fichero en modo binario, es reposicionando el cursor donde convenga

    Seek(canal), 1  ' reposiciona el curso al comienzo del fichero.
 
   Seek(canal),( lof(canal) -20) ' reposiciona el curso al final del fichero, -20 bytes, dará error si esa posición sale negativa (el fichero tiene menos de 20 bytes)
 

También se puede preguntar por la posición actual... por ejemplo para guardarla, leer datos y volver a ese mismo punto por segunda vez.

    k = Seek(canal)
 

Es posible tener más de un cursor apuntando al mismo fichero... uno podría estar leyendo de una cabecera de datos, mientras el otro canal apunta a los datos que el registor leído en la cebecera indicare (probablemente previo cálculo)

   canal1 = freefile
   open ruta for binary as #canal1
   canal2 = freefile
   open ruta for binary as #canal2
 

Nota también que es preferible usar la sentencia 'freefile' para obtener un canal libre, que usar una constante directamente... cuando peres con proyectos de cierta complejidad, no puedes tener control de 'números', Freefile devuelve siempre un canal no usado que se asigna a una variable, que identifica únivocamente al fichero concreto... si además la variable tiene un nombre más específico, mejor: canalPrecios (por ejemplo, para un fichero cuyo contenido son precios), canalClientes (por ejemplo para un fichero cuyo contenido son registros con los datos de clientes)

Nota que en modo binario, se lee un solo dato (variable) cada vez... input, permite leer una lista, es parte de lo que determina si usar un modo u otro, pero es muy dependiente del modo en que se escribió.

... en cualquier caso, acude a la documentación de VB6, que es muy completa, lleva el cursor al keyword del lenguaje de tu interés y pulsa 'F1', la ayuda aparece siempre pulsando la tecla de función: 'F1', pero si está encima de un keyword, busca el mismo... y la propia documentación suele contener ejemplos.

Hay que practicar, pero lo correcto es aprender documentándose. Practicar sin documentación, supone emplear 20 veces más de tiempo para aprender, algo que leyendo unos párrafos, se aprende en 15 minutos y se practca en 1 hora... con solo práctica puedes dedicarle días, y todavía surgirán errores y dudas que uno no termina de comprender y es seguro, que quedarán lagunas...(detalles que jamás se llega a conocer).

Es probable que las estadísticas salgan un poco elevadas en ciertas preguntas... en un foro de programación, va a ser que todo el mundo que participa activamente del mismo, responda 'sí' a varias preguntas...

Para ser más neutral (o por lo menos tener otro horizonte comparativo), tendrías que insistir en un foro o red social completamente ajeno a la programación...

Yo creo que el gordito, ha muerto...
No se le ha vuelto a ver el pelo, en los últimos meses, algo imposible, inaceptable para cualquier 'líder' comunista, cuyos egos les llevan a estar en todos los noticieros del país y de cuando en cuando en los mundiales... (aunque solo sea para amenazar).

Que sea su hermana quien venga a dar respuesta, no hace sino refrendar la cuestión.

La esclavitud y el racismo son dos conceptos distintos, no tienen porqué ir juntos.
Y sí, en América, tampoco había santos... Hay crónicas brutales y no solo de sacrificios humanos, muchas tribus, se la pasaban guerreando contra los vecinos. El hombre para bien o para mal, suele ser igual en todas partes.

La esclavitud no entiende de colores... Un esclavo, es un esclavo.
Si se quiere afirmar que a causa del descubrimiento de América, la esclavitud de los negros se acentuó, la esclavitud en América del sur y otros horrores de America acabaron.
Aunque la Historia siempre guarda más capítulos trágicos...

No se sabe bien como era Colón en su día a día, supongo que ni mejor ni peor que tú o yo. Y mientras no haya pruebas o crónicas que digan lo contrario, en efecto era un inocente navegante.
Y... como sule decirse, si no hubiera sido Colón, con el tiempo habría sido otro...

Hay otros individuos (sobretodo en el norte de América), de los que si se sabe que eran C48R0N35 a más no poder... de los innumerables tratados que hicieorn con los nativos de norteamérica, los hoy habitantes de esa zona, no respetaron casi ninguno.  Persecuciones hasta la casi extinción, pero ahí siguen esas estatuas dedicados a tales generalillos... por poner alguno alguien que todo el mundo conoce de las películas: "el general Custer"... Para los norteamericanos es un 'héroe', pero exterminó a nativos, sin fin... todas las estatuas de esos, sí que podrían derribarlas, los muertos que cada uno asestó seguro que son miles... que se sepa, Colón no mató a nadie, ni persiguió, ni nada de nada a nadie...

...márcale a un bobo una silueta y ya tiene contra qué disparar, poco le importará el resto.

No. La esclavitud (moderna, porque siempre existió), nace curiosamente de un capítulo de bondad...

América fue descubierta por Colón en 1492, arribando a las islas de Cuba, ya en 1503 (solo 11 años después, cuando apenas había penetración en el continente). creo recordar que fue fray Antonio Montesinos, quien escribía una carta al Rey de España entonces Carlos I, para acusar a los terratenientes que se habían establecido en la isla por el maltrato dado a los nativos. El rey exigió pesquisas y se excusaron así como: "...claro como vamos a cultivar la tierra si no hay mano de obra y ..." y ahí quedó la cosa de momento.

Luego en 1520, el fraile tuvo que viajar a España, pidió audiencia con el rey y expuso nuevamente el problema de forma más explícita. El rey por supuesto escuchó otras voces, la máxima contradicción era: cómo o quién atendería los trabajos... en algún momento (según narra la Historia) el fraile atinó a decir que los africanos como ya lo venían siendo. Es de constatar que ya la reina Isabel había prohibido la esclavitud en las tierras conquistadas (15 años antes siquiera del descubrimiento de América), pués los conquistados debían ser súbditos, no esclavos.
Tanto es así, después de algunos años en 1528 (creo) se logró que el rey promulgara un edicto prohibiendo todo tipo de esclavitud y trabajos forzados, es decir todo trabajo debía estar remunerado.
Fray Bartolomé de las Casas, se hizo eco y encabezó la misma lucha llegando finalmente al Papa, quien acabó declarando para todo el Imperio Cristiano que: "Se considera a los nativos americanos son también hijos de dios y por tanto hermanos de sangre", lo que a efectos legales quería decir que tenían los mismos derechos que cualquier otro.

Esa imprudente frase de de fray Antonio de Montesinos, cuya única intención era liberar a los nativo americanos de ser maltratados, es la que se considera y atribuye al inicio de la esclavitud moderna de los negros. Aunque Carlos I, prohibiera la esclavitud, muchos ávidos terratenientes a sabiendas de la dificultad de verificar, exigir y obligar a cumplir edictos promulgados en España en tierras perdidas de América, inicialmente hicieron caso omiiso y utilizaban a los nativo americanos como mano de obra barata, como si fueran ganado.

Aunque la esclavitud 'renaciera' en esas circunstancias es de aclarar que los negociantes de los barcos negreros, fueron masivamente los holandeses. De hecho hasta Portugal fue masivamente más traficante de esclavos de lo que nunca fue España.

También hay que aclarar que la esclavitud ya existía en América antes de que Colón llegara. Y la esclavitud de los negros, también existía previamente, pero no era tan masivo. Prácticamente ha existido la esclavitud a lo largo de toda la historia humana, la diferencia crucial entre culturas (más bien entre períodos históricos) ha sido siempre el trato que se les daba y los derechos que tenían.

Es muy probable que si no hubiera existido la esclavitud de negros, la población de nativos en latino América se habría extinguido o languidecido como pasó con la población nativa de América del norte (ahí incluso a pesar de la masiva introducción de esclavos).

Y por último, leches, Colón era un navegante. No tiene nada que ver, con la esclavitud. es como culpar a los esposos Curie, de que USA lanzara 2 bombas atomícas en Japón...

Impreciso, y falto de documentación y detalles, pero puede leerse en wikipedia el artículo:
https://es.wikipedia.org/wiki/Esclavitud_en_Am%C3%A9rica

---

En efecto, 1492... se ha colado un 8.

El pasado es la Historia, guste a quien le guste, odie quien lo odie, es la que es. Borrarlo, no cambia ni un pelo de los hechos del pasado.
Así que me temo que la única intención es (intentar) cambiar el presente, para intereses partidarios en asuntos políticos.

Los actuales pobladores de latinoamérica, no son nativos de América al 100%, (sin mirar cifras), diría que entre el 90-99% son descendientes de españoles y nativos... "fifty-fifty". Es decir, los actuales pobladores de América son los descendientes directos de esos a los que desprecian, los que robaron o violaron...

En cambio, los actuales pobladores de España, tienen a esos como ancestros lejanos, no son descendientes directos. Se pierde en 15-20 generaciones arriba, para encontrar ese lazo de sangre y luego bajar en su descendencia... Los españoles que fueron a América, se quedaron allí a vivir, tuvieron descendencia allí y por supuesto murieron allí. Son vuestros antepasados tanto como lo son los nativo americanos.

Resulta torpe, que se culpe al resto de españoles que nunca fue a América a nada, de lo que hicieron los tata...rabuelos de esos que hoy se quejan de su pasado.

Es como si yo quisiera hoy culpar a los italianos actuales de lo que haya pasado o esté pasando en España, solo porque Roma invadió España hace 2.000 años...

Para colmo... los auténticos nativos (digamos así a aquellos que no tienen o apenas "tienen ADN español"), están siendo reducidos o eliminados... ahí vemos como Brasil, sigue sangrando el Amazonas y destruye todas esas aldeas de nativos, los insultan, desprecian, apalean... Bolivia... en fin, no hace falta poner más ejemplos... ya que no es ese el tema...

Es tan sencillo de entender, que da pena que se dejen manipular de esa forma.

Entiendo que, hay movimientos políticos 8no importa el signo) que para afiliar a tontos e incultos en sus listas recurran a culpar a cualquiera de sus problemas actuales... en vez de asumir el 'es nuestra culpa' (j0d3r, que ya ha llovido alrededor de 200 años... desde que los países latinoamericanos lucharon por su independencia... lo que son hoy no tiene cabida ya acusar a nadie del pasado para pretender 'explicar' los problemas actuales).

Cuando Napoléon invadió Europa y se metió también en España, es cuando los pueblos de América aprovecharon para sus luchas de independencia... era la ocasión perfecta.

Pero... la Independencia lleva aparejado la responsabilidad de tu futuro, no procede desde entonces culpar a nadie.

Hay que asumir la responsabilidad en vez de estar quejándose de todo y culpar a los demás. Ahí estuvo Chávez su etapa de gobernante se resume en 2 frases:
- 1 Llevó al país a la ruina, y lejos de responsabilizarse, lo que siempre hizo fue
- 2 Culpar a los gringos, a Rajoy, a quien sea... de todo.
...y Maduro lo mismo. Mientras culpen a otros, los tontos, no se darán cuenta que la culpa real es de esos que no paran de acusar a los demás (y están en el poder).