Hej,

Jag håller på med en liten applikation och jag vill ta ut varje bokstav i en sträng.

<code>
public string Ord(string strOrd)
{
int intOrdLength = strOrd.Length;
int ctr = 0;

for(ctr = 0; ctr <=intOrdLength; ctr++)
{
int intBokstav = strOrd[ctr];
}

return intBokstav.ToString();
}
</code>

Sådär har jag gjort, jag undrar lite över hur kan man göra så att intBokstav får ett nytt namn för varje gång det repeatas, en tanke är att man gör så att den får intBokstav + ctr så att det blir intBokstav0, intBokstav1, etc. Går det på nått sätt?

Meningen med applikationen är att den ska ta ut alla bokstäver ur en sträng för att sedan slumpa fram vilka av bokstäverna i ordet som ska visas.

Finns det någon annan metod för att lösa det här på som är bättre?

Hej!

Du kan väl göra precis som du säger:
<code>
public string Ord(string strOrd, int antalBokstaver)
{
int intOrdLength = strOrd.Length;
char[] wordChars = strOrd.ToCharArray(); // Strängen som char-arr
char[] resultChars = new char[antalBokstaver]; // De bokstäver som ska returneras
for (int i=0;i<antalBokstaver;i++)
{
Random r = new Random();
// Välj slumpvis ut en bokstav att sätta in på plats i i strängen vi ska returnera
resultChars[i] = wordChars[r.Next(wordLength)];
}
string s = new string(resultChars);
return s;
}


</code>

Om du vill ha bokstäverna i en följd (som i ordet) kan du ju köra två for loopar, först generera upp så många slumptal du vill ha, sedan sortera dem i storleksordning och sedan hämta de bokstäverna ifrån originalsträngen.

Lycka till!
/Henke

Okej,

Har testat den där koden nu och försökt få det att fungera utan att ha lyckats.
Det blir samma bokstav som slumpas fram tex. om strOrd är tjena blir det ttttt.

Skulle vilja slumpa så att det blir jtnea eller någon annan ordning utav bokstäverna.

Hej Magnus,

Jag har nog inte heller riktigt fattat exakt vad du är ute efter, men här kommer en liten klass som möjligen kan vara till lite hjälp:

public class StringScrambler
{
    Random seedRandomizer;

    public StringScrambler()
    {
        seedRandomizer = new Random();
    }

    public string ScrambleString(string unscrambledString)
    {
        int length = unscrambledString.Length;
        char[] scrambledChars = new char[length];
        Random randomizer = new Random(seedRandomizer.Next(int.MaxValue));

        foreach (char chr in unscrambledString)
        {
            int index;

            do
            {
                index = randomizer.Next(length);
            } 
            while (scrambledChars[index] != 0);

            scrambledChars[index] = chr;                
        }

        return new string(scrambledChars);
    }
}

Tack,

Det där fungerade fint!

Jag har en fråga om en sak i koden.

Random randomizer = new Random(seedRandomizer.Next(int.MaxValue));

Det är seedRandomizer.Next(int.MaxValue) som jag undrar över om vad den gör.

Tja, det finns kanske smartare sätt att göra det på, men min tanke var att säkerställa att randomizer baseras på ett nytt seed-värde varje gång den skapas. Om man skippar argumentet till konstruktorn baseras seed-värdet på systemklockan och anropar man ScrambleString flera gånger kan man få samma seed-värde om klockan inte hunnit räknats upp.

(Jag ser också att jag kodade lite slarvigt. Dels hanterar jag inte när unscrambledString innehåller null-tecken och dels förutsätter jag att scrambledChars instansieras med null-tecken.)

Okej,

Jag kom på att tänka en grej, även fast chansen inte är stor att det inträffar me. Det jag tänker på är att ordet slumpas fram till det "rätta ordet", att tex. hejsan slumpas till hejsan, chansen är ju inte stor som sagt men den finns ju.

scrambledChars == unscrambledString

Operator '==' cannot be applied to operands of type 'char[]' and 'string'

Hur ska man jämföra dom och se om dom är lika?

Här är en variant på StringScrambler som inte kräver att scrambledChars initieras med null-tecken samt att man aldrig behöver loopa fler varv än vad längden på unscrambledString är.

<code>
using System;

namespace StringScrambler
{
/// <summary>
/// Summary description for StringScrambler.
/// </summary>
public class StringScrambler
{
Random seedRandomizer;

public StringScrambler()
{
seedRandomizer = new Random();
}

public string ScrambleString(string unscrambledString)
{
int length = unscrambledString.Length;
char[] scrambledChars = unscrambledString.ToCharArray();
Random randomizer = new Random(seedRandomizer.Next(int.MaxValue));

for(int index = 0; index < length; index++)
{
swap(ref scrambledChars[index], ref scrambledChars[randomizer.Next(length)]);
}
return new string(scrambledChars);
}

private void swap(ref char c1, ref char c2)
{
char tmp = c1;
c1 = c2;
c2 = tmp;
}
}
}
</code>

//
Janne

Hej Magnus,

Visst är det så att man kan få tillbaks samma sträng som man skickar in i metoden. I följande version försöker jag att undvika detta:

    public class StringScrambler
    {
        Random seedRandomizer;

        public StringScrambler()
        {
            seedRandomizer = new Random();
        }

        public string ScrambleString(string unscrambledString)
        {
            if (NumberOfUniqueCharacters(unscrambledString) < 2)
            {
                return unscrambledString;
            }

            int length = unscrambledString.Length;
            char[] unscrambledChars = unscrambledString.ToCharArray();
            char[] scrambledChars = unscrambledString.ToCharArray();
            Random randomizer = new Random(seedRandomizer.Next(int.MaxValue));
            string scrambledString;

            do
            {
                for(int index = 0; index < length; index++)
                {
                    Swap(ref scrambledChars[index], ref scrambledChars[randomizer.Next(length)]);
                }

                scrambledString = new string(scrambledChars);
            }
            while (scrambledString == unscrambledString);

            return scrambledString;
        }

        private void Swap(ref char c1, ref char c2)
        {
            char tmp = c1;
            c1 = c2;
            c2 = tmp;
        }

        private int NumberOfUniqueCharacters(string unscrambledString)
        {
            int count = 0;

            if (unscrambledString != null && unscrambledString.Length > 0)
            {
                bool[] usedChars = new bool[char.MaxValue];

                foreach (char chr in unscrambledString)
                {
                    if (!usedChars[chr])
                    {
                        usedChars[chr] = true;
                        count++;
                    }
                }
            }

            return count;
        }
    }

Notera att jag ugått från Jans optimerade lösning. Notera även att man i retur fortfarande kan få långa strängar där bara två tecken har bytt plats. Det vore naturligtvis bättre om graden av olikhet baserades på antal unika tecken i orginalsträngen. Och appropå unika tecken så misstänker jag att metoden NumberOfUniqueCharacters kan optimeras.

Okej, tack!

Jag har en liten fråga :)

Vad fyller den här koden för funktion?

		private void Swap(ref char c1, ref char c2)
		{
			char tmp = c1;
			c1 = c2;
			c2 = tmp;
		}

Den byter plats på värdena i de två variabler som skickas till den.

Om t.ex. x = 3 och y = 7 före anropet Swap(x, y), så är x = 7 och y = 3 efter anropet.

Okej, används den till för att det ska bli en större "mix"?

Den används helt enkelt för att utföra mixningen.

for(int index = 0; index < length; index++)
{
    Swap(ref scrambledChars[index], ref scrambledChars[randomizer.Next(length)]);
}

Koden byter plats på tecknet i position index och tecknet på en slumpvis vald position.

Aha, okej. Nu hajar jag.

Tack för all hjälp!