字符串范围斯卡拉

在Ruby中，我们可以这样做：字符串范围斯卡拉

$ irb 
>> ("aa".."bb").map { |x| x } 
=> ["aa", "ab", "ac", "ad", "ae", "af", "ag", "ah", "ai", "aj", "ak", "al", "am", "an", "ao", "ap", "aq", "ar", "as", "at", "au", "av", "aw", "ax", "ay", "az", "ba", "bb"]

在Scala中，如果我尝试同样的，我得到的错误：

$ scala 
Welcome to Scala version 2.9.1 (OpenJDK 64-Bit Server VM, Java 1.7.0_51). 

scala> ("aa" to "bb").map(x => x) 
<console>:8: error: value to is not a member of java.lang.String 
       ("aa" to "bb").map(x => x) 
        ^

如何获得一定范围内的字符串在Scala呢？

来源

2014-04-02 tuxdna

一个相当奇怪的行为。 Ruby如何确定你想停留在字符'z'？ –

Infact'（“aB”..“bZ”）。map {| x | x}知道它必须停在'Z'处。 '（ “A0” .. “B9”）地图{|。X | x}知道它必须停在'9'处。所以必须有一些能够提供这种逻辑的字母和数字范围。 – tuxdna

在这个例子中，你可以做（斯卡拉2.10）

val atoz = 'a' to 'z' 
for {c1 <- atoz if c1 <= 'b'; c2 <- atoz if (c1 == 'a' || (c1 == 'b' && c2 < 'c'))} yield s"$c1$c2"

市价修改意见，感谢（但变得有点难看！）

来源

2014-04-02 12:42:38 Gavin

我想补充的限制像'C1 < - ATOZ如果c1 <=“b''它配不配的问题 – n1ckolas

的初始条件，您会考虑以下一个‘干净’的解决方案？ 'def charval（x：Char，y：Char）= x * 1000 + y'和'for {c1 < - atoz; C2 < - ATOZ如果（charval（C1，C2）<= charval（ 'B'， 'B'））}产量的 “$ $ C1 C2”'。更像数学，但用另一个结尾字符串“bk”替换“bb”变得更容易。更具可读性 – mesutozer

('a' to 'z').map("a" + _) :+ "ba" :+ "bb"

来源

2014-04-02 13:18:25 ZhekaKozlov

这就是为什么我在代码后面微笑的原因 – ZhekaKozlov

-1

这里一种可能性，假设你的角色应该在'a'到'z'的范围内。该intToAlpha功能不是很漂亮，不是对称alphaToInt，所以人们可能会拿出一个更好的实现。

// "a" -> 0, "b" -> 1, "ba" -> 26, "bb" -> 27 etc. 
def alphaToInt(s: String) = (0 /: s) { (res, c) => res * 26 + c - 'a' } 

// reverse function to `alphaToInt` 
def intToAlpha(len: Int)(i: Int) = { 
    val sb = new StringBuilder 
    var j = i 
    while (sb.length < len) { 
    sb append ((j % 26) + 'a').toChar 
    j /= 26 
    } 
    sb.reverse.toString 
} 

def range(from: String, to: String) = 
    alphaToInt(from) to alphaToInt(to) map intToAlpha(from.length)

测试：

range("aa", "bb")

另一种版本：

import annotation.tailrec 

@tailrec def intToAlpha(len: Int, res: String = "")(i: Int): String = 
    if (len <= 0) res 
    else { 
    val c = ((i % 26) + 'a').toChar 
    intToAlpha(len - 1, s"$c$res")(i/26) 
    }

来源

2014-04-02 15:54:36

-1

它像一个26 * 26矩阵，每2字符组合，IMAGIN我们有一个矩阵（AZ * AZ）：

def scan(start:String, end:String) = { 

    val row_start     = start.toCharArray.head 
    val column_start_of_first_row = start.toCharArray.last 
    val row_end     = end.toCharArray.head 
    val column_end_of_last_row = end.toCharArray.last 

    val printRow = 
    (current_row:String, current_row_start_col:Char, current_row_end_col:Char) => 
     (current_row_start_col to current_row_end_col).map(current_row + _) 

    (row_start to row_end).map { current_row=> 
     current_row match { 
     case `row_start` => printRow(current_row.toString, column_start_of_first_row, 'z') 
     case `row_end` => printRow(current_row.toString, 'a'      , column_end_of_last_row) 
     case _   => printRow(current_row.toString, 'a'      , 'z')                      
     } 
    }.reduce(_ ++: _) 

} 

println(scan("aa", "bb")) 
println(scan("af", "bb"))

来源

2014-04-02 17:18:22 Brian

A理解会做很好：

val abc = 'a' to 'z' 
for (c1 <- abc; c2 <- abc) yield (s"$c1$c2")

这将产生一个序列/矢量[字符串]的所有排列你期望

来源

2016-09-26 10:33:31 klogd

字符串范围斯卡拉

回答

相关问题