Scala小算法

1.JewelsAndStones 宝石和石头

package com.csm.test_Sort

object JewelsAndStones {
  /** *
   * 给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
   *
   * J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。
   *
   * @param args
   */
  def main(args: Array[String]): Unit = {

    var J = Array("a", "A");
    var S = Array("s", "a", "d", "a", "f", "A", "g", "A", "g", "A", "A", "a");

    var sum = 0
    var a, b = 0
    for (a <- 0 until J.size; b <- 0 until S.size) {
      if (S(b).equals(J(a))) {
        sum = sum + 1
      }
    }
    println(sum)
  }

}

2.MoveZeroes  移动0到末尾

package com.csm.test_Sort

object MoveZeroes {

  /** *
   * 排序 并把0移到最后
   *
   * @param args
   */
  def main(args: Array[String]): Unit = {
    val arr1 = Array(1, 0, 3, 4, 0)

    //排序
    var a = 0
    var a1 = 0
    var b = 0
    for (a <- 0 until arr1.size - 1; a1 <- 0 until arr1.size - 1) {
      if (arr1(a1) > arr1(a1 + 1)) {
        b = arr1(a1)
        arr1(a1) = arr1(a1 + 1)
        arr1(a1 + 1) = b
      }
    }
    println("排序结果--" + arr1.toBuffer)


    //查询0的个数
    a = 0
    var c = 0

    var flag = true
    for (a <- 0 until arr1.size if flag == true) { //为了跳出for循环
      if (arr1(a) > 0) {
        c = a
        flag = false
      }
    }
    //移动0到末尾

    a = 0
    for (a <- 0 until arr1.size - c) {
      arr1(a) = arr1(a + c)
    }

    a = 0
    for (a <- 0 until c) {
      arr1(arr1.size - 1 - a) = 0
    }
    println("移动零后排序结果--" + arr1.toBuffer)

  }

}

3.RemoveDuplicatesFromSortedArray 移除重复元素

package com.csm.test_Sort

import scala.collection.mutable.ArrayBuffer

object RemoveDuplicatesFromSortedArray {

  /** *
   * 移除数组重复元素
   *
   * @param args
   */
  def main(args: Array[String]): Unit = {
    var arr1 = ArrayBuffer(11, 3, 4, 3, 4, 11, 5, 3, 7, 11);
    println(arr1.toBuffer)
    //排序
    var a = 0
    var a1 = 0
    var b = 0
    for (a <- 0 until arr1.size - 1; a1 <- 0 until arr1.size - 1) {
      if (arr1(a1) > arr1(a1 + 1)) {
        b = arr1(a1)
        arr1(a1) = arr1(a1 + 1)
        arr1(a1 + 1) = b
      }
    }
    println(arr1.toBuffer)
    //记录重复元数
    var arr2 = new Array[Int](arr1.size);
    a = 0
    for (a <- 0 until arr1.size - 1) {
      if (arr1(a) == arr1(a + 1)) {
        arr2(a + 1) = 1;
      }
    }
    println(arr2.toBuffer)
    a = 0
    for (a <- 0 until arr2.size) {
      if (arr2(arr2.size - 1 - a) == 1) {
        arr1.remove(arr2.size - 1 - a)
      }
    }
    println(arr1.toBuffer)
  }
}

4.ReversingString 反转字符串

package com.csm.test_Sort

object ReversingString {
  /** *
   * 反转字符串 (Reversing a string)
   * Logically, reversing is swapping the values from index 1 with index n, index 2 with index n-1, and so on.
   *
   * 从逻辑上讲，反向是将索引1中的值与索引n交换，将索引2中的值与索引n-1交换，依此类推。
   *
   * So, if the string is "IncludeHelp", then the reverse will be "pleHedulcnI".
   *
   * 因此，如果字符串为“ IncludeHelp” ，则反向为“ pleHedulcnI”
   *
   * @param args
   */


  def main(args: Array[String]): Unit = {
    var newString = "IncludeHelp"

    var revString = ""
    val n = newString.length()
    for (i <- 0 to n - 1) {
      revString = revString.concat(newString.charAt(n - i - 1).toString)
    }
    println(revString)
  }

}

5.SearchInsertPosition 查询元素在数组中的位置位置

package com.csm.test_Sort

object SearchInsertPosition {

  /** *
   * 寻找给定元素在数组中的位置，如果没有此元素的话给出插入的位置(数据应该是顺序的)
   *
   * @param args
   */
  def main(argSs: Array[String]): Unit = {


    var arry1 = Array(3, 4, 5, 7, 11)

    var a = 6

    var b = 0;
    var c = 0
    var flag = true
    for (b <- 0 until arry1.size if flag == true) {
      if (arry1(b) >= a) {
        c = b
        flag = false;
      }

    }

    println(c)

  }

}

6.Sort_age 固定列数据排序

package com.csm.test_Sort

import scala.collection.mutable.ArrayBuffer

object Sort_age {


  /** **
   * 集合中固定列的数据排序
   *
   * @param args
   */
  def main(args: Array[String]): Unit = {

    val array1 = Array("zhu", "yingyu", 98)
    val array2 = Array("zhu", "yuwen", 96)
    val array3 = Array("zhu", "shuxue", 99)

    val array4 = Array(array1, array2, array3)

    var array5 = new ArrayBuffer[Int];
    var a = 0
    for (a <- 0 until array4.size) {
      array5.append(array4(a)(2).toString.toInt)
    }
    println(array5.toBuffer)

    a = 0
    var a1 = 0
    var b = 0
    for (a <- 0 until array5.size - 1; a1 <- 0 until array5.size - 1) {
      if (array5(a1) > array5(a1 + 1)) {
        b = array5(a1)
        array5(a1) = array5(a1 + 1)
        array5(a1 + 1) = b
      }
    }
    println(array5.toBuffer)

  }

}

7.ToLowerCase 准化大小写

package com.csm.test_Sort

object ToLowerCase {


  /** *
   * 转为小写
   *
   * @param args
   */
  def main(args: Array[String]) {

    val result = "NIDHI".toLowerCase() //小写
    println(result)
    val result1 = "gEEKs".toUpperCase() //大写
    println(result1)
  }

}

8.ValidParentheses 括号匹配

package com.csm.test_Sort

import scala.collection.mutable.ArrayBuffer

object ValidParentheses {

  /** *
   * ([[]()])  括号的匹配
  * 给定一个只包括 ‘(‘，’)’，'{‘，’}’，'[‘，’]’ 的字符串，判断字符串是否有效。
   *
   * 有效字符串需满足：
   *
   * 左括号必须用相同类型的右括号闭合。
   * 左括号必须以正确的顺序闭合。
   * 注意空字符串可被认为是有效字符串。
   *
   * @param args
   */
  def main(args: Array[String]): Unit = {

    println(getValid())
  }

  def getValid(): Boolean = {
    var arry1 = Array("(", ")", "{", "}", "[", "]")

    var arry2 = Array("(", "{", "[")
    var arry3 = Array(")", "}", "]")
    var arry4 = new ArrayBuffer[String];
    var returnFlag = true;
    if (arry1.size == 0) {
      return returnFlag;
    }
    var a = 0;
    var b = 0;
    for (a <- 0 until arry1.size; b <- 0 until arry2.size) {
      if (arry1(a).equals(arry2(b))) {
        arry4.append(arry1(a))
      }
      if (arry1(a).equals(arry3(b))) {
        if (arry4(arry4.size - 1).equals(arry2(b))) {
          arry4.remove(arry4.size - 1)
        } else {
          returnFlag = false
          return returnFlag;
        }
      }

    }
    if (arry4.size > 0) {
      returnFlag = false
    }
    return returnFlag
  }
}