SoloCodigo

HOLA:
Esto sigue siendo Vbscript (mientras aprendo algo de ASM)
Tal vez sea redundante y hasta trivial pero tal vez por lo mismo es sencillo o simple ( Yo creo que no puede haber nada mas simple)
Me comprometo a que cuando sepa lo suficiente de ASM posteare el codigo en este lenguaje.
XOR - AND

' Script
'=====================================================
'Guardar como COLN.vbs
' Ejecutar en Consola (cmd.exe)
' Invocandolo con cscript.exe clon.vbs
'=================================================
dim a()
dim b()
wscript.echo vbtab & vbtab & "ALGORITMO CL.O.N. ( CLasificacion por Orden Natural)" & vbcrlf
wscript.echo  "Redundante y trivial, pero rapido, exacto y estable - O(n) "
wscript.echo "Desarrollado por TOMAS XORDAN (Xor -And)"
wscript.echo "Informes : xordan_co@yahoo.com"

wscript.stdout.write vbcrlf & vbcrlf & "Cuantos numeros desea ordenar ?  "

q= wscript.stdin.readline
wscript.echo vbcrlf & "Se estan generando al azar " & q & " numeros positivos enteros " & vbcrlf
redim a(q)

Randomize
For n = 0 To q
a(n)= Int(q*Rnd)
wscript.stdout.write a(n) & "-"
Next


Wscript.echo "Estos son los mismos " & q & " numeros ya clasificados en orden natural : " & vbcrlf

For x= 0 to ubound(
u= b(x)
If u > 0  Then
For y = 1 To u
wscript.stdout.write   x & "-"
Next
End if
u=0
Next

wscript.stdout.write vbcrlf

dim a()
dim b()
dim C()
'===================================================================
wscript.echo vbtab & "ALGORITMO  GOGOL desarrollado por TOMAS JORDAN (xor and )" &  vbcrlf
wscript.echo vbtab  & "informacion : xordan_co@yahoo.com " & vbcrlf & vbcrlf
wscript.echo vbtab & vbtab & " INSTRUCCIONES : "
wscript.echo "INTRODUZCA PRIMER FACTOR, NO DEJE ESPACIOS " & vbcrlf
wscript.echo "Puede usar signos separadores  de miles o millones como punto (.) coma (,) y/o apostrofe (')" & vbcrlf
wscript.echo "En esta version de prueba solo se manejan numeros enteros,si introduce fracciones decimales" & vbcrlf
wscript.echo "El algoritmo los tratara como numeros enteros. " & vbcrlf  
wscript.echo "Debido a limitaciones del buffer de teclado, " & vbcrlf
wscript.echo "cuando la cantidad de cifras llegue a 255 (este dato puede variar en cada maquina)" & vbcrlf
wscript.echo "debera teclear <ENTER> para continuar introduciendo el numero." & vbcrlf
wscript.echo "Ese salto de linea no afectara para nada la operacion." & vbcrlf
wscript.echo "CUANDO TERMINE DE INTRODUCIR EL PRIMER FACTOR TECLEE  ASTERISCO (*) & <enter> " & vbcrlf
wscript.echo "TAMBIEN PUEDE  INTRODUCIR LOS FACTORES CON ESTE FORMATO : primerfactor * segundofactor = & <enter> " & vbcrlf
wscript.echo  "ejemplo:9999*8888= <enter> " & vbcrlf

DO

wscript.stdout.write  " PRIMER FACTOR  ? " & vbcrlf

while num1 <> "*"

num1 = wscript.stdin.read(1)
num2= cstr(num1)
if asc(num2) > 47 and asc(num2) < 58 then
num= num & num2
end if
wend

num = cstr(num)
lnum= len(num)
wscript.echo "Se ha tomado el siguiente numero de " & lnum  & " cifras como primer factor : " & vbcrlf
wscript.echo num
redim A(lnum)

For ax= 1 To ubound(a)
cif1= mid(num,ax,1)
a(ax-1)= cint(cif1)
next


'==================================================================


wscript.echo "INTRODUZCA MULTIPLICADOR " & VBCRLF
wscript.echo "CUANDO TERMINE DE INTRODUCIR EL NUMERO TECLEE IGUAL (=) <enter> " & vbcrlf
while por1 <> "="

por1 = wscript.stdin.read(1)
por2=cstr(por1)
if asc(por2) > 47   and asc(por2) < 58 then
por = por & por2
end if


wend

lpor = len(por)
wscript.echo "Se ha tomado el siguiente numero de  " & lpor & " cifras como segundo factor " & vbcrlf
wscript.echo por
redim b (lpor)
For bx = 1 To ubound(
cif2= mid (por,bx,1)
b(bx-1)= cint(cif2)
next

wscript.echo vbcrlf &  "resultado :" & vbcrlf & vbcrlf

if c(0)= 0 then result = 1


for n =   result to ubound( c )

wscript.stdout.write c(n)

Next
wscript.echo VBCRLF & VBCRLF & "RESULTADO CON  " & LRES-RESULT & " CIFRAS" & VBCRLF
'=======================================================

redim a(0)
redim b(0)
redim c(0)
num1=""
por1=""
num=""
por=""
lnum=0
lpor=0
lres=0
LOOP

Hola, soy totalmente nuevo en este foro; no soy programador profesional sino solo un aficionado que se quedo en el siglo pasado (inicie con basic y sigo pensando en basic).

Hace bastantes años desarrolle un programa en basic que hacia exactamente lo que esta pidiendo "chinho"; podia por ejemplo multiplicar un numero de  1000 (mil) cifras por otro de otras tantas. En aquella epoca basic me limitaba a “solamente”  numeros de 32000 (treinta y dos mil) cifras.

 Desarrolle la suma la resta, la multiplicacion pero quede estancado en la division.

Y esto lo hacia sin mayor demanda de memoria y en tiempo real.

Cuando lo presente a algunas personas que estaban en la industria de la programacion la sola respuesta que obtuve (ademas de un ligero meneo de cabeza y una seña con el dedo apuntando a la sien ) fue:  " .... Y para
Que diablos sirve ....?"

Ademas , para comprobar los resultados en grandes cifras haria falta un mainframe.

Esto lo hacia en un viejo ( para aquella epoca no tanto )  “XT” CON 64 kb  en RAM con sistema operativo DOS  no recuerdo que versión y creo que gwbasic (si no era basica) como lenguaje de programación.

De casualidad entre a este foro de assembler porque he querido aprender algo de asm y he venido pensando que seria una buena cosa portar varios algoritmos que dearrolle en aquella epoca ( sin ningun uso practico real)  del  antiguo basic a assembler como una forma de entrenamiento y aprendizaje.
 
Y he aqui que me encuentro con esta solicitud de "chinho" ( Te pido, chinho, por favor que aclares que no somos la misma persona en busca de publicidad ).

Esto me ha hecho  reconstruir el algoritmo  ( de memoria pues  no tengo ningun archivo de aquella epoca) y pasarlo a VBSCRIPT que es lo mas parecido al antiguo basic  que pueda uno encontrar en estos tiempos.

El script GOGOL.vbs que anexo es un ejemplo de la operación de multiplicación , de el  se puede deducir como se haria la suma y la resta.
La division -como ya dije - nunca la desarrolle totalmente aunque tengo varias ideas acerca de cómo podria hacerse.

Ejecutese en una ventana de consola (cmd) invocándolo con “ cscript.exe gogol.vbs ”  

El script solo alcanza a manejar numeros (multiplicando y multiplicador) de hasta 254 cifras debido a las limitaciones del tamaño de  los strings que se pueden introducir por via de consola ( orden “wscript.stdin.readline”) , Si se quieren manejar numeros mayores podria hacerse  - por ejemplo  - que el script los leyera de un archivo.  

Si en assembler se puede hacer cualquier cosa que se pueda hacer con un lenguaje de alto nivel, entonces este algoritmo es portable a assembler.  

Y en assembler no habria necesidad de declarar matrices bastaria con reservar determinada cantidad de memoria teniendo en cuenta que con este algoritmo cada cifra ( 0 – 9 ) ocuparia un byte por lo tanto un numero de 1000 cifras
(multiplicando ) no utilizaria mas que un kb,  el multiplicador de 1000 cifras otro kb y el resultado algo mas de 2 kb:  en total 4 kb.
Si quiere hacerlo con tamaño  de megas tambien se puede. (Creo ....)

El script que anexo tiene varias fallas como por ejemplo  un molesto punto al final que no logro quitar. Lo reconstrui en unas pocas horas despues de leer el post de chinho.

Quien haya conocido el antiguo basic vera claramente la programacion lineal ( no estructurada como se estila ahora).
 
Se que los verdaderos profesionales en esta materia hallaran la solucion “trivial” o falta de elegancia ; por eso cuando lo   pongo a disposición del publico, tengo perfecta conciencia de que actuo como  si abandonara a un hijo paralitico en la selva; solo pido que si alguien le encuentra un uso practico no deje de recordar donde lo hallo y mantenga el nombre que le he puesto:  GOGOL.

TOMAS XORDAN
XOR AND