Question

当我尝试将索引+1处的一个数组的值复制到一个新数组时（我试图简单地执行oldArray [index] + = 1但我收到了一个无法调用的错误），我得到代码EX_I386_INVOP它跑了两次。代码包含在下面，欢迎任何见解。如果你对目的感到好奇，我正在为一个需要解密字符串的网站进行练习。一种方法是假设空格是最常见的字符，找到最常见的加密字符，假设它是一个空格，并从中减去32以找到加密密钥。我想要做的只是增加加密的字符，直到我得到一个可理解的消息，因为我想看到写一个值频率函数与增量所需的工作量差异。如果你有一个更容易的方法在Swift中将数组中的每个值递增1，请告诉我，我还是很新。该问题出现在第newArray[index] = value + 1行

let str = ".296.294.255.268.313.278.311.270.290.305.322.252.276.286.301.305.264.301.251.269.274.311.304.230.280.264.327.301.301.265.287.285.306.265.282.319.235.262.278.249.239.284.237.249.289.250.282.240.256.287.303.310.314.242.302.289.268.315.264.293.261.298.310.242.253.299.278.272.333.272.295.306.276.317.286.250.272.272.274.282.308.262.285.326.321.285.270.270.241.283.305.319.246.263.311.299.295.315.263.304.279.286.286.299.282.285.289.298.277.292.296.282.267.245.304.322.252.265.313.288.310.281.272.266.243.285.309.295.269.295.308.275.316.267.283.311.300.252.270.318.288.266.276.252.313.280.288.258.272.329.321.291.271.279.250.265.261.293.319.309.303.260.266.291.237.299.286.293.279.267.320.290.265.308.278.239.277.314.300.253.274.309.289.280.279.302.307.317.252.261.291.311.268.262.329.312.271.294.291.291.281.282.292.288.240.248.306.277.298.295.267.312.284.265.294.321.260.293.310.300.307.263.304.297.276.262.291.241.284.312.277.276.265.323.280.257.257.303.320.255.291.292.290.270.267.345.264.291.312.295.269.297.280.290.224.308.313.240.308.311.247.284.311.268.289.266.316.299.269.299.298.265.298.262.260.337.320.285.265.273.307.297.282.287.225.302.277.288.284.310.278.255.263.276.283.322.273.300.264.302.312.289.262.236.278.280.286.292.298.296.313.258.300.280.300.260.274.329.288.272.316.256.259.279.297.296.283.273.286.320.287.313.272.301.311.260.302.261.304.280.264.328.259.259.347.245.291.258.289.270.300.301.318.251.305.278.290.311.280.281.293.313.259.300.262.315.263.319.285.282.297.283.290.293.280.237.234.323.289.305.279.314.274.291.309.273.294.249.283.262.271.286.310.305.306.261.298.282.282.307.287.285.305.297.275.306.280.292.291.284.301.278.293.296.277.301.281.274.315.281.254.251.289.313.307.244.256.302.301.317.305.239.316.274.277.296.269.305.301.279.287.317.284.277.305.298.264.304.286.273.275.293.309.286.282.240.287.239.268.269.267.315.311.292.270.271.272.336.282.237.275.316.306.239.305.314.240.296.306.270.247.245.302.317.316.241.291.310.266.274.274.313.288.262.319.280.276.238.297.295.287.285.288.301.272.275.247.305.292.286.272.310.291.301.322.256.315.298.263.281.276.237.294.284.296.284.302.273.298.287.298.301.265.305.270.315.278.283.302.287.263.270.345.258.270.266.302.309.262.260.277.327.263.277.254.283.276.239.272.264.276.279.264.267.298.264.244.245.273.292.289.273.248.259.263.288.290.294.210.288.268.311.318.312.242.285.293.216.262.276.340.292.299.275.259.293.311.234.266.294.278.307.286.267.307.285.269.310.288.274.270.326.273.276.311.304.267.302.318.265.299.263.283.248.257.314.288.321.321.236.284.283.227.320.312.246.261.289.316.288.263.312.241.265.288.298.286.287.274.306.279.276.289.307.303.293.281.298.317.252.312.283.278.263.304.305.258.266.270.294.286.293.290.291.291.258.254.282.282.283.313.268.282.316.310.299.254.264.234.296.270.265.326.288.292.293.321.305.250.320.299.253.270.296.297.298.266.312.234.273.287.309.286.278.269.279.316.284.276.234.293.255.267.242.253.318.270.246.278.292.285.282.314.266.292.286.263.313.249.290.255.289.264.292.301.299.278.291.292.225.250.261.283.303.262.264.264.303.299.297.274.288.267.293.316.320.317.233.303.258.302.271.283.323.247.279.268.312.269.297.313.280.280.273.266.332.276.313.284.281.316.279.290.273.313.308.305.260.302.306.273.234.279.281.284.298.278.259.290.314.275.264.339.293.322.266.261.296.306.277.275.311.284.270.318.259.249.286.292.301.285.280.303.283.287.299.277.273.293.228.311.283.272.304.292.277.271.306.302.278.298.300.287.281.309.243.272.279.282.300.291.295.284.285.252.291.251.285.283.245.250.252.318.298.277.235.288.259.263.278.274.307.261.260.350.250.288.256.282.316.261.285.295.292.300.298.264.245.241.308.301.261.253.289.264.267.300.262.248.287.257.266.275.287.297.320.287.264.279.297.232.231.256.288.243.252.277.274.245.256.253.229.290.263.305.278.260.294.312.283.301.275.276.299.297.312.275.282.294.272.228.302.324.257.261.286.326.280.283.316.294.254.258.275.264.236.240.277.255.231.258.286.242.277.253.296.290.250.314.320.239.292.313.261.294.261.317.273.285.236.292.282.271.264.297.300.272.308.299.300.269.301.269.317.284.286.262.315.276.279.328.269.254.252.232.272.268.309.273.264.296.305.272.267.291.324.302.297.268.268.263.298.300.261.312.241.254.299.280.263.292.260.301.311.317.297.248.314.272.293.298.281.298.276.311.291.297.318.261.274.300.293.297.267.295.261.275.334.289.238.267.289.283.257.300.262.304.311.278.274.265.261.345.301.296.270.273.299.289.274.272.313.282.268.320.287.320.270"

countElements(str)

let chars = Array(str)

func buildArray(startArr: [Character]) -> [String]{
    var endArray: [String] = []
    var tempInt = 0

    for (index, character) in enumerate(startArr)
    {
        if character == "."{
            var tempString: String = ""
            tempString.append(startArr[index+1])
            tempString.append(startArr[index+2])
            tempString.append(startArr[index+3])

            endArray.append(tempString)
        }
    }
    return endArray
}

var parsedArray = buildArray(chars)

func getEncryptedCharArray(pieceArray: [String]) -> [Int]
{
    var returnArray: [Int] = []
    var i: Int = 0

    while i < pieceArray.count
    {
        var encryptedVal: Int = pieceArray[i].toInt()!
        i++
        encryptedVal += pieceArray[i].toInt()!
        i++
        encryptedVal += pieceArray[i].toInt()!
        returnArray.append(encryptedVal)
        i++
    }

    return returnArray
}

var encryptedValueArray = getEncryptedCharArray(parsedArray)
var min: Int = (encryptedValueArray as AnyObject).valueForKeyPath("@min.self") as Int

func createArraySansKeyValue (encryptedValArray: [Int], key: Int) -> [Int]{
    var minimizedArray: [Int] = []

    for encryptedVal in encryptedValArray{
        minimizedArray.append(encryptedVal - min)
    }
    return minimizedArray
}



var reducedArray = createArraySansKeyValue(encryptedValueArray, min)

func increaseArrayValByOne( startArray: [Int]) -> [Int]{
    var newArray: [Int] = []
    for (index, value) in enumerate(startArray){
        newArray[index] = value + 1
    }
    return newArray
}

func getStringFromASCIIValArray( asciiArray: [Int]) ->String{
    var returnString: String = ""

    for val in asciiArray{
        var s = String(UnicodeScalar(val))
        returnString += s
    }

    return returnString
}


var decryptedStringArray: [String] = []

func increaseArrayAndDecrypt(reducedValArray: [Int]) -> [String]{
    var finalArray: [String] = []

    var i = 0

    while i < 256
    {
        var increasedArray = increaseArrayValByOne(reducedValArray)
        var attemptedDecryptArray = getStringFromASCIIValArray(increasedArray)
        finalArray.append(attemptedDecryptArray)
        i++
    }

    return finalArray
}

var finalAttemptArray = increaseArrayAndDecrypt(reducedArray)

Answer 1

您的问题是newArray中没有任何条目，所以当您这样做时：

newArray[index] = value + 1

index实际上超出了数组的范围，并且您创建了致命错误。

使用当前的增量方法有两种方法可以解决此问题：

使用与newArray匹配的初始容量创建startArray：

var newArray = [Int](count: startArray.count, repeatedValue: 0)

使用newArray.append()代替尝试直接设置index：
```
newArray.append(value + 1)
```

话虽如此，实际上使用increaseArrayValByOne编写map()函数的方法更简单：

func increaseArrayValByOne( startArray: [Int] ) -> [Int] {
    return startArray.map { $0 + 1 }
}

注意：我不建议您在Playground中运行代码。你在那里有相当数量的数据循环很多，Playground很可能会在它完成代码运行之前停止运行。

EXC_I386_INVOP尝试复制递增的数组值时

1 个答案: