• Revista PROGRAMAR: Já está disponível a edição #53 da revista programar. Faz já o download aqui!

power

Prog para gerar chaves em C#

4 mensagens neste tópico

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

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

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

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!


Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.


Entrar Agora