Go语言程序检查字符串是否为两个不同字符串的有效混排

在 Go 编程语言中，字符串是一种内置的数据类型，表示字符序列。它们使用双引号 (") 定义，可以包含任何有效的 Unicode 字符。在本文中，我们将学习如何使用不同的示例集来检查字符串是否为两个字符串的有效混排。输出将是使用 fmt 包打印到控制台上的布尔值。

方法：使用带有 len 方法的 for 循环

在本方法中，我们将学习如何检查字符串是否为两个不同字符串的有效混排。此程序定义了一个名为 isShuffle(str1, str2, shuffle string) bool 的函数，该函数接受三个字符串作为参数：str1 和 str2 是两个单独的原始字符串，shuffle 是要检查的字符串，以查看它是否已成功与 str1 和 str2 混排。

算法

  • 步骤 1 − 创建一个包 main 并声明程序中的 fmt（格式包）包，其中 main 生成可执行示例，而 fmt 帮助格式化输入和输出。

  • 步骤 2 − 创建一个函数 isShuffle，并在该函数中将 mystr1、mystr2 和混排字符串作为输入。

  • 步骤 3 − i、j 和 k 都应初始化为 0。

  • 步骤 4 − 从 0 开始重复混排字符串的长度 k 次。

  • 步骤 5 − 每次检查 i 是否小于 mystr1 的长度，以及 mystr1 的第 i 个字符是否与混排字符串的第 k 个字符对应。如果是，则增加 i。

  • 步骤 6 − 如果上述条件为假，则检查 j 是否小于 mystr2 的长度，以及 mystr2 的第 j 个字符是否与混排字符串的第 k 个字符相同。如果是，则增加 j。

  • 步骤 7 − 如果上述语句均不正确，则返回 false，并且在循环完成后返回 true。

  • 步骤 8 − 通过将混排字符串的字符与原始字符串的字符进行比较，上述方法采用单指针方法 (i,j,k) 来确定混排字符串是否为两个单独字符串的有效混排。

示例

在本例中，我们将使用带有 len 函数的 for 循环来检查 Go 语言中字符串是否为两个不同字符串的有效混排。

package main
import "fmt"

func isShuffle(mystr1, mystr2, shuffle string) bool {
   if len(mystr1)+len(mystr2) != len(shuffle) {
      return false
   }
   i, j, k := 0, 0, 0
   for k < len(shuffle) {
      if i < len(mystr1) && mystr1[i] == shuffle[k] {
         i++
      } else if j < len(mystr2) && mystr2[j] == shuffle[k] {
         j++
      } else {
         return false
      }
      k++
   }
   return true
}

func main() {
   mystr1 := "abc"    //create a string1
   fmt.Println("The string1 given here is:", mystr1)
   mystr2 := "def"     //create string2
   fmt.Println("The string2 given here is:", mystr2)
   fmt.Println("Is the string a valid shuffle of two strings?")
   shuffle := "abcdef"
   fmt.Println(isShuffle(mystr1, mystr2, shuffle)) //check if the shuffle is valid
}

输出

The string1 given here is: abc
The string2 given here is: def
Is the string a valid shuffle of two strings?
true

方法 2：使用 rune 方法

在本方法中，我们将使用 for 循环检查字符串是否为两个不同字符串的有效混排。此程序定义的 isShuffle 函数接受三个字符串：mystr1、mystr2 和 shuffle。该函数使用两个指针遍历混排字符串中的每个字符，每个输入字符串一个。对于混排字符串中的每个字符，该函数检查当前字符和 mystr1 或 mystr2 的当前指针处的字符是否匹配。

算法

  • 步骤 1 − 创建一个包 main 并声明程序中的 fmt（格式包）包，其中 main 生成可执行示例，而 fmt 帮助格式化输入和输出。

  • 步骤 2 − 初始化两个指针 i 和 j，分别指向输入字符串 mystr1 和 mystr2 的开头。

  • 步骤 3 − 遍历混排字符串中的每个字符后。对于混排字符串中的每个字符，检查当前字符和 mystr1 或 mystr2 的当前指针处的字符是否匹配。

  • 步骤 4 − 如果当前字符与 mystr1 的当前指针处的字符匹配，则增加 mystr1 的指针。

  • 步骤 5 − 如果当前字符与 mystr2 的当前指针处的字符匹配，则增加 mystr2 的指针。

  • 步骤 6 − 如果任一输入字符串的当前字符与当前指针处的字符不匹配（表明混排字符串不是两个输入字符串的有效混排），则返回 false。

  • 步骤 7 − 如果两个输入字符串的指针都已到达其各自字符串的末尾（表明混排字符串是两个输入字符串的有效混排），则返回 true。

  • 步骤 8 − 输出将是使用 fmt.Println() 函数打印到控制台上的布尔值，其中 ln 表示换行符。

示例

在本例中，我们将使用 rune 方法来检查 Go 语言中字符串是否为两个不同字符串的有效混排。

package main
import "fmt"

func isShuffle(mystr1, mystr2, shuffle_val string) bool {

   i, j := 0, 0
   
   // Iterate over each character in the shuffle string
   for _, c := range shuffle_val {
      if i < len(mystr1) && c == rune(mystr1[i]) {
         i++
      } else if j < len(mystr2) && c == rune(mystr2[j]) {
         j++
      } else {
         return false
      }
   }
   return i == len(mystr1) && j == len(mystr2)
}

func main() {
   // Test cases
   fmt.Println("Whether the string is a valid shuffle of two distinct strings?")
   fmt.Println(isShuffle("abc", "def", "dabecf")) // true
}

输出

Whether the string is a valid shuffle of two distinct strings?
true

结论

我们使用两个示例执行了检查字符串是否为两个字符串的有效混排的程序。在第一个示例中，我们使用了带有 len 方法的 for 循环，在第二个示例中，我们使用了 rune 方法。

更新于： 2023年2月20日

浏览量 182 次

开启您的 职业生涯

通过完成课程获得认证

开始学习
广告