Mensajes

Yo personalmente programo en VB6 dia y noche desde hace mucho tiempo, considero que es un lenguaje viejo y posiblemente tiene limitaciones pero para el uso que le doy en este momento es el mas "adecuado".
Si alguien se esta iniciando y quiere vivir de la programacion posiblemente no sea el lenguaje adecuado, por algo no se ensena mas en ninguna carrera universitaria (por lo menos que yo sepa).

Si alguien se esta iniciando y quiere vivir de esto yo recomendaria cualquier otro lenguaje (mas comercial), ahora si es por entretenimiento... en mi opinion es a gusto del consumidor.

A mi VB6 me dio y me da de comer hasta el dia de hoy, me llevo a viajar y vivir en diferentes paises etc. etc. con esto quiero decir que en mi caso particular es una herramienta invaluable.

Conclusion, el mejor lenguaje es que te sirva a vos dependiendo del uso que le quieras dar y el hambito en el que lo utilices.

Bien, ya ni me molesto Karcrack, la unica idea que se me habia ocurrido despues de leer un poco era utilizar el mmx para calcular la aproximacion de la raiz cuadrada....cosa que ya hiciste

mmmmm no es justo ;(

No me dejen afuera!!!!! no tengo mucho tiempo ahora pero quiero darle una probada.

Algo que vi en algunos algoritmos

6 = 2*(2+1) no es lo mismo que 2 * 2+1

Simplemente para mostrar otra manera, no es mas veloz pero me parecio interesante mostrar la parte donde se reduce el numero a 1 byte.

Código [Seleccionar] Expandir


Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (pDst As Any, pSrc As Any, ByVal ByteLen As Long)


Private Type Dummy_Byte
    b1 As Byte
    b2 As Byte
    b3 As Byte
    b4 As Byte
End Type

Private Function IsOdiousNumber(ByVal lVal As Long) As Boolean
    Dim b As Dummy_Byte

    CopyMemory b.b1, lVal, 4
    lVal = b.b1
    lVal = lVal Xor b.b2
    lVal = lVal Xor b.b3
    lVal = lVal Xor b.b4
   
    Dim l As Long

    l = l + ((lVal And &H80) \ &H80)
    l = l + ((lVal And &H40) \ &H40)
    l = l + ((lVal And &H20) \ &H20)
    l = l + ((lVal And &H10) \ &H10)
    l = l + ((lVal And &H8) \ &H8)
    l = l + ((lVal And &H4) \ &H4)
    l = l + ((lVal And &H2) \ &H2)
    l = l + ((lVal And &H1) \ &H1)

    IsOdiousNumber = (l And 1)
   
End Function

Nada mal por ahora, hice unas modificaciones al codigo que postie pero no vi ninguna diferencia realmente significativa. No creo que se pueda hacer mucho mas rapido que el de leandro aunque vi cosas que se podrian optimizar posiblemente pero no creo que haga mucha diferencia.

Con respecto al code que postie por si alguno le interesa, es lo mas simple que se me ocurrio. Simplemente verifica si el numero tiene un uno si lo tiene invierte el valor del flag y hace un shift right y vuelta a lo mismo hasta que llega al ultimo valor.

Código [Seleccionar] Expandir

Private Function IsOdiousNumber(ByVal lVal As Long) As Boolean
    Do
        If lVal And 1 Then IsOdiousNumber = Not IsOdiousNumber
        lVal = lVal \ 2
        If lVal = 0 Then Exit Function
        If lVal = 1 Then IsOdiousNumber = Not IsOdiousNumber: Exit Function
    Loop
End Function

Ahi va mi aporte, perdon por la descarga pero es un poco grande para pegar aca.
Posiblemente no sea tan rapido como otros que vi por aca porque priorice el uso de memoria (simplemente por gusto) en vez de utilizar un array de longs como vi que usaban muchos me parecio mas entretenido hacer algo diferente, asi que utilice un array de bytes que a su vez los utilizo como array de bits para guardar 8 valores por byte, lo malo de hacerlo de esta manera es que hay que recorrer el array para encontrar los indices pero trate de optimizarlo un poco, por ejemplo el loop principal utiliza un tercio de las iteraciones que vi que los demas utilizan y otras cositas mas.

[http://cobein.com/shares/LuckyNumbs.rar]

Edit: Me olvide de quitar un pedazo de codigo que estaba utilizando... nada importante pero aca pego uno mas limpio.

Código [Seleccionar] Expandir

Private Function TestNum(ByVal lVal As Long) As Boolean
   
   If lVal < 1 Then Exit Function
   If Not lVal And 1 Then Exit Function
   
   mBitArray.AllocateBuffer lVal
   
   Dim i As Long
   For i = 1 To lVal Step 6
       mBitArray.SetValue i, True
       mBitArray.SetValue i + 2, True
   Next
   
   Dim lIncrement As Long
   Dim lPos As Long
   
   lPos = 3
   Dim lRet As Long
   
   Do
       lIncrement = mBitArray.FindPositive(lPos)
       If lIncrement = -1 Then Exit Do
       lRet = 1
       Do
           lRet = mBitArray.FindPositive(lIncrement, lRet) 'Save the last pos to not loop from start
           If lRet = -1 Then Exit Do
           mBitArray.SetValue lRet, False
       Loop
       If Not FindPositiveRev(1) = lVal Then Exit Function
       lPos = lPos + 1
   Loop
   If FindPositiveRev(1) = lVal Then TestNum = True
       
End Function

Leandro, me parece que esto es lo que buscas [http://msdn.microsoft.com/en-us/library/aa446639(VS.85).aspx]

Hay otra manera de hacer esto, se llama link spoofing y se puede compilar con ASM inline o cualquier otra cosa, pero obviamente requiere interceptar la llamada al linker y reemplazar el code en vb por asm.