Reverse A String And Find Word In String

In this blog, you will learn how to reverse a string and find a word in string using C#.

I will demonstrate how to reverse a string in a simple way and how to find a specfic word in the given string using C#. Here is the code sample that shows you  how to reverse a string in C# and find the desired word in a given string.
 
Reverse a string in simple steps using C#.
  1. public string ReverseString(string input)  
  2. {  
  3.     if (string.IsNullOrEmpty(input))  
  4.     {  
  5.         throw new ArgumentNullException();  
  6.     }  
  7.   
  8.     var output = input.Reverse();  
  9.     return new string(output.ToArray());  
  10. }  
Find a word in given string. We assume the separator of word is space (' ');
  1. /// Example 1: GetWordFromText("one two three", 2) should return "two"    
  2. /// Example 2: GetWordFromText("one;two three", 2) should return "three"    
  3. /// Example 3: GetWordFromText("one", 1) should return "one"    
  4. /// When input parameter wordNumberToFind is less than 1, method should throw    
  5. /// ArgumentOutOfRangeException. When input text does not have enough words    
  6. /// (GetWordFromText("one", 2)), method should throw ArgumentException.     
  7. /// When input is null method should throw `ArgumentNullException`.    
  8. /// Method should ignore all spaces in the beginning and in the end of input text.    
  9. /// </returns>    
  10. public string GetWordFromText(string input, int wordNumberToFind)    
  11. {    
  12.   
  13.     // TODO: Implement logic HERE    
  14.     if (wordNumberToFind < 1)    
  15.     {    
  16.         throw new ArgumentOutOfRangeException();    
  17.     }    
  18.   
  19.     if (string.IsNullOrWhiteSpace(input))    
  20.     {    
  21.         throw new ArgumentNullException();    
  22.     }    
  23.   
  24.     var words = input.Split(' ');    
  25.   
  26.     if (wordNumberToFind > words.Length)    
  27.     {    
  28.         throw new ArgumentException();    
  29.     }    
  30.   
  31.     while (string.IsNullOrWhiteSpace(words[wordNumberToFind - 1]))    
  32.     {    
  33.         wordNumberToFind++;    
  34.     }    
  35.   
  36.     return words[wordNumberToFind - 1];    
  37. }   
Let's have some unit tests to verify the above code.
  1. namespace TaskLib.Tests  
  2. {  
  3.     using System;  
  4.   
  5.     using FluentAssertions;  
  6.     using NUnit.Framework;  
  7.   
  8.     [TestFixture]  
  9.     public class StringTests  
  10.     {  
  11.         [Test]  
  12.         public void When_WordToFindIsNotInTheInput_Then_ArgumentExceptionIsThrown()  
  13.         {  
  14.             // Arrange  
  15.             var tested = new StringHelpers();  
  16.   
  17.             // Act  
  18.             Assert.Throws<ArgumentException>(() => { var word = tested.GetWordFromText("two words", 3); });  
  19.         }  
  20.   
  21.         [Test]  
  22.         public void When_InputTextContainsFewWords_Then_ProperOneIsReturned()  
  23.         {  
  24.             // Arrange  
  25.             var tested = new StringHelpers();  
  26.   
  27.             // Act  
  28.             var word = tested.GetWordFromText("one;two  three", 2);  
  29.   
  30.             // Assert  
  31.             word.Should().Be("three");  
  32.         }  
  33.   
  34.         [Test]  
  35.         public void When_InputTextIsSymmetrical_Then_ItIsReturned()  
  36.         {  
  37.             // Arrange  
  38.             var tested = new StringHelpers();  
  39.   
  40.             // Act  
  41.             var reversed = tested.Reverse("evil live");  
  42.   
  43.             // Assert  
  44.             reversed.Should().Be("evil live");  
  45.         }  
  46.   
  47.         [Test]  
  48.         public void When_InputTextIsPassed_Then_ItIsReversed()  
  49.         {  
  50.             // Arrange  
  51.             var tested = new StringHelpers();  
  52.   
  53.             // Act  
  54.             var reversed = tested.Reverse("abcd efgh");  
  55.   
  56.             // Assert  
  57.             reversed.Should().Be("hgfe dcba");  
  58.         }  
  59.     }  
  60. }  
Thanks. I hope you liked this simple approach of reversing a string and finding a word in the string.