Jump to content
Sign in to follow this  
power

Prog para gerar chaves em C#

Recommended Posts

power

Boa tarde

1 - tenho um programa em C# para gerar desdobramentos  e disseram-me que funciona.

2 - Não percebo  nada de C#

3 - Queria pedir o favor de alguem me implementar este codigo fonte em VB o mais simples possivél

porque é a linguaguem que percebo umas coisas.......

o que está em bold já consegui implementar em VB

using System;

namespace combinatorica

{

    /// <summary>

    /// Classe estática com ferramentas auxiliares para combinações.

    /// </summary>

    /// <remarks>© 2008 </remarks>

    public static class combTools

    {

        /// <summary>

        /// Função para calcular o número de combinações de n, k a k.

        /// </summary>

        /// <remarks>Baseado no algoritmo ACM #160 de M. L. Wolfson e H. V. Wright (1963)</remarks>

        /// <param name="n">Tamanho do set</param>

        /// <param name="k">Tamanho do subset</param>

        /// <returns>Número de combinações</returns>

        public static int numCombin(int n, int k)

        {

            int dif = n - k;

            if (k < dif)

            {

                dif = k;

                k = n - dif;

            }

            int combs = k + 1;

            if (dif == 0)

                combs = 1;

            else if (dif >= 2)

                for (int i = 2; i <= dif; i++)

                {

                    combs = (combs * (k + i)) / i;

                    /*

                     * Pequeno controle de erros - o C# é bastante tolerante com as operação envolvendo

                     * inteiros, deixando passar em silêncio o overflow, mas colocando o sinal negativo (o

                     * 1º bit fica a 1). Na operação seguinte, como é lógico, volta a ficar positivo

                     */

                    if (combs < 0)

                        throw new OverflowException("As combinações pedidas são superiores ao limite dos números inteiros - " + int.MaxValue);

                    /*

                     * A título de curiosidade, podíamos usar, em vez de int, uint, que dobrava a capacidade.

                     * No entanto, isso representaria um crescimento de, apenas, 2 a 5 lugares no tamanho dos

                     * sets. Muito melhor, seria usar long ou ulong. No entanto, para sistemas operativos de

                     * 32 bits, a função ficaria significativamente mais lenta. Por outro lado, ficaria

                     * bastante mais rápida em sistemas operativos de 64 bits.

                     */

                }

            return combs;

        }        /// <summary>

        /// Método para converter uma combinação em algo mais agradável á vista

        /// </summary>

        /// <param name="comb">Combinação a converter</param>

        /// <returns>Combinação em texto</returns>

        public static string combToString(int[] comb)

        {

            return combToString(comb, " ");

        }

       

        /// <summary>

        /// Método para converter uma combinação em algo mais agradável á vista

        /// </summary>

        /// <param name="comb">Combinação a converter</param>

        /// <param name="separador">Separador (ex.: " ", "-", ", ", etc.)</param>

        /// <returns>Combinação em texto</returns>

        public static string combToString(int[] comb, string separador)

        {

            string res = "";

            int tam = comb.Length;

           

            for (int i = 0; i < tam; i++)

            {

                if (i > 0)

                    res += separador;

                res += comb.ToString();

            }

            return res;

        }

        /// <summary>

        /// Método para converter um Número de Sequência de Combinação (CSN) para uma combinação

        /// </summary>

        /// <remarks>Baseado no algoritmo ACM #515 de B. P. Buckles e M. Lyabanon (1974)</remarks>

        /// <param name="csn">Número de Sequência de Combinação</param>

        /// <param name="n">Tamanho do set</param>

        /// <param name="k">Tamanho do subset</param>

        /// <returns>Combinação em array</returns>

        public static int[] csnToComb(int csn, int n, int k)

        {

            int lbound = 0;

            int r = 0;

            int[] comb = new int[k];

            for (int i = 0; i < (k - 1); i++)

            {

                // colocar sempre o valor a 0

                comb = 0;

                // se a posição não for a 0, podemos copiar o valor de trás

                // se for... bem, atrás não está nada e, não sei porquê, os computadores gostam pouco disso...

                if (i != 0) comb = comb;

                // fazer isto pelo menos uma vez (porque o valor ou está a 0 ou está igual ao precedente)

                do

                {

                    // incrementar o bitxo

                    comb++;

/*

* E aqui é melhor dar um exemplo prático...

* Imaginemos que estamos na chave 1-2-3-4-5 e o nosso número máximo é o 10

* Queremos a chave seguinte, isto é, CSN = 2, já estivemos em i=0, 1 e 2, vamos no 3;

* chegamos aqui assim: 1-2-3-4-5 (o valor 4 mantém-se porque causa ali do ++);

* então, numCombin(10 - 3, (5 - 1) - 3) = 21

* depois disto tudo, o lbound ainda está a zero (ver mais abaixo porquê)

* aumentamos o lbound para em mais 21 e, como é superior ao pedido (2) seguimos viagem

* (continua abaixo)

*/

                    r = combTools.numCombin(n - comb, (k - 1) - i);

                    lbound += r;

                } while (lbound < csn);

                // (porquê aqui) ao lbound actual, tiramos a última combinação parcial, do exemplo, 21

                lbound -= r;

            }

            // e agora, depois das posições 0, 1, 2 e 3, vamos tratar da última posição

            // que vai ser igual à posição anterior + o CSN pedido - o lbound actual

            // logo, do exemplo, 4 + 2 - 0 = 6

            comb[k - 1] = comb[k - 2] + csn - lbound;

return (int[])comb.Clone();

        }

        /// <summary>

        /// Método para converter uma combinação num CSN

        /// </summary>

        /// <param name="comb">Combinação</param>

        /// <param name="n">Tamanho do set</param>

        /// <returns>CSN (inteiro)</returns>

        public static int combToCsn(int[] comb, int n)

        {

            int k = comb.Length;

            int lbound = 0;

            int r = 0;

            // pormenor importante: estritamente, deveria ser (int i = 0; i < k; i++), mas como vamos usar i sozinho várias vezes abaixo, podemos "esquecer" isso...

            for (int i = 1; i <= k; i++)

            {

                r = n - comb[k - i];

                if (r >= i)

                    lbound += combTools.numCombin(r, i);

            }

            return combTools.numCombin(n, k) - lbound;

        }

    }

}

Cumprimentos

Power

Share this post


Link to post
Share on other sites
power

Boa noite

Qual é o codigo que eu preciso de escrever na função static void Main(string[] args)

para que apresente na console o nr de combinações (de 10 a 5)  e os respectivos desdobramentos .

Estou a falar da 1ª mensagem.

Obrigado

Power

Share this post


Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Sign in to follow this  

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.