Advertisement
Guest User

Untitled

a guest
Nov 23rd, 2014
139
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 7.78 KB | None | 0 0
  1.  /// Uppgift 1
  2.         /// <summary>
  3.         /// Metod som tar emot ett heltal (1-10) och beräknar dess multiplikationstabell (upp till *10).
  4.         /// </summary>
  5.         /// <param name="siffra">Det heltal vars multiplikationstabell man vill få uträknad.</param>
  6.         /// <returns>Returnerar en array med 10 platser med de 10 tal som finns med i den uträknade multiplikationstabellen.</returns>
  7.         static public int[] CalculateMultTable(int siffra)
  8.         {
  9.             int[] tabell = new int[10];
  10.             for (int i = 0; i < 10; i++)
  11.             {
  12.                 tabell[i] = (siffra * (i + 1));
  13.             }
  14.             return tabell;
  15.         }
  16.  
  17.         /// <summary>
  18.         /// Metod som tar emot en array av heltal och skriver ut dess värden.
  19.         /// </summary>
  20.         /// <param name="array">Den arrayen av heltal som man vill få utskriven.</param>
  21.         static void PrettyPrint(int[] array)
  22.         {
  23.             for (int i = 0; i < 10; i++)
  24.             {
  25.                 Console.Write(array[i]);
  26.                    
  27.                 if (i < 9)
  28.                 {
  29.                     Console.Write(", "); //If-satsen innehållandes detta ser till att inte skriva ut kommatecken efter det sista talet.
  30.                 }
  31.             }
  32.         }
  33.  
  34.         /// <summary>
  35.         /// Metod som returnerar en tvådimensionell array som innehåller ettan till tians multiplikationstabell.
  36.         /// </summary>
  37.         /// <returns>Returnerar en tvådimensionell array med ettan till tians multiplikationstabell på varsin rad.</returns>
  38.         public static int[,] CalculateMultMatrix()
  39.         {
  40.             int[,] tabell = new int[10, 10];
  41.  
  42.             for (int i = 0; i < 10; i++)
  43.             {
  44.                 for (int y = 0; y < 10; y++)
  45.                 {
  46.                     tabell[i, y] = ((i + 1) * (y + 1));
  47.                 }
  48.                 Console.WriteLine(); // För att skapa en ny rad efter varje multiplikationstabell.
  49.             }
  50.             return tabell;
  51.         }
  52.  
  53.         /// <summary>
  54.         /// Metod som tar emot två arrayer i form av heltal, samt ett heltal (utan array) där samtliga värden i första arrayen
  55.         /// flyttas över till den andra arrayen, där det arraylösa heltalet pekar på var i den andra arrayens index värdena från den
  56.         /// första arrayen ska kopieras in.
  57.         /// </summary>
  58.         /// <param name="arr1">Den första arrayen med ett antal heltal. Det är heltalen i denna array som sedan ska kopieras in i den andra arrayen.</param>
  59.         /// <param name="arr2">Den andra arrayen med ett antal heltal. Det är i denna array heltalen från den första arrayen ska kopieras in till.</param>
  60.         /// <param name="start">Det heltal som pekar på var någonstans i den andra arrayens index som värdena från den första arrayen ska kopieras in.</param>
  61.         static void CopyTo(int[] arr1, int[] arr2, int start)
  62.         {
  63.             for (int i = 0; i < arr2.Length; i++)
  64.             {
  65.                 if (i >= start && (i - start) < arr1.Length)
  66.                 {
  67.                     arr2[i] = arr1[i - start];
  68.                 }
  69.             }
  70.         }
  71.  
  72.         /// <summary>
  73.         /// Metod som tar en emot array av heltal och ett heltal (utan array) där det arraylösa talet läggs in i en ny array
  74.         /// tillsamans med alla värden i den ursprungliga arrayen.
  75.         /// </summary>
  76.         /// <param name="originalArray">Den array man vill lägga till ett ytterliggare värde i.</param>
  77.         /// <param name="number">Det värde man vill lägga till i arrayen.</param>
  78.         /// <returns>Returnerar en ny array med alla värden från den ursprungliga arrayen tillsammans med det nya värdet.</returns>
  79.         static public int[] Push(int[] originalArray, int number)
  80.         {
  81.             int[] finalArray = new int[originalArray.Length + 1];
  82.             CopyTo(originalArray, finalArray, 0);
  83.             finalArray[finalArray.Length - 1] = number; //>--- Behövs detta då number inte ens returneras?
  84.  
  85.             return finalArray;
  86.         }
  87.  
  88.         /// <summary>
  89.         /// Metod för att slå ihop två arrayer och få ut en ny array där alla värden från de ursprungliga arrayerna finns med.
  90.         /// </summary>
  91.         /// <param name="left">Den första arrayen vars värden man vill ha med i den nya arrayen. Denna arrays värden är de
  92.         /// som kommer vara först i den nya arrayen.</param>
  93.         /// <param name="right">Den andra arrayen vars värden man vill ha med i den nya arrayen. Denna arrays värden kommer
  94.         /// placeras efter den första arrayens värden.</param>
  95.         /// <returns>Returnerar en ny array där samtliga värden från de två ursprungliga arrayerna finns med.</returns>
  96.         static public int[] Concat(int[] left, int[] right)
  97.         {
  98.             int[] all = new int[left.Length + right.Length];
  99.             CopyTo(left, all, 0);
  100.             CopyTo(right, all, left.Length);
  101.  
  102.             return all;
  103.         }
  104.  
  105.         /// <summary>
  106.         /// Metod som tar emot en array med heltal och returnerar alla dess jämna eller udda tal, med hjälp av en boolean som indikerar
  107.         /// vilket som ska returneras.
  108.         /// </summary>
  109.         /// <param name="numbers">En array av heltal som man vill få ut alla jämna eller udda tal ifrån.</param>
  110.         /// <param name="even">En boolean som indikerar om det är de jämna eller udda talen i arrayen som ska returneras,
  111.         /// är värdet på booleanen true returneras alla jämna tal, är värdet false returneras alla udda tal.</param>
  112.         /// <returns>Returnerar arrayens alla jämna eller udda tal, beroende på värdet i booleanen.</returns>
  113.         static public int[] TakeNumbers(int[] numbers, bool even)
  114.         {
  115.             int[] array = new int[0];
  116.             for (int i = 0; i < numbers.Length; i++)
  117.             {
  118.                 if (even)
  119.                 {
  120.                     if (numbers[i] % 2 == 0)
  121.                     {
  122.                         array = Push(array, numbers[i]);    
  123.                     }
  124.  
  125.                 }
  126.                 else
  127.                 {
  128.                     if ((numbers[i] % 2) > 0)
  129.                     {
  130.                         array = Push(array, numbers[i]);
  131.                     }
  132.                 }
  133.             }
  134.             return array;    
  135.         }
  136.  
  137.         /// <summary>
  138.         /// Metod för att räkna ut hur många ord som finns i en angiven textsträng.
  139.         /// </summary>
  140.         /// <param name="text">Den textsträng man vill beräkna antal ord i.</param>
  141.         /// <returns>Returnerar ett heltal med antalet ord i den angivna textsträngen.</returns>
  142.         static public int WordCount(string text)
  143.         {
  144.             string[] lista = text.Split(' ');
  145.             int words = lista.Length;
  146.             return words;
  147.         }
  148.  
  149.         /// <summary>
  150.         /// Metod för att se om ett angivet ord är ett palindrom eller inte.
  151.         /// </summary>
  152.         /// <param name="word">Det ord man vill se om det är ett palindrom eller inte.</param>
  153.         /// <returns>Returnerar true om ordet är ett palindrom, och false om ordet inte är ett palindrom.</returns>
  154.         static public bool IsPalindrome(string word)
  155.         {
  156.             word = word.ToUpper();
  157.             char[] reversedWord = new char[word.Length];
  158.             int lastChar = word.Length - 1;
  159.  
  160.             for (int i = 0; i <= word.Length - 1; i++)
  161.             {
  162.                 reversedWord[lastChar] = word[i];
  163.                 lastChar = lastChar - 1;
  164.             }
  165.             string word2 = new string(reversedWord);
  166.  
  167.             if (word == word2)
  168.             {
  169.                 return true;
  170.             }
  171.             else
  172.             {
  173.                 return false;
  174.             }
  175.         }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement