查找a在b | Swift中作为子字符串出现的位置的索引值

当传递两个整数时，我试图编写一个函数。当a出现在b中时，函数返回最左边的位置，这是关于a从0开始出现在b中的十进制表示，因此66出现在22331166的位置4

所以我把两个整数转换成两个字符串，然后签入b常量a，但是我怎么才能找到b中最左边的位置a呢

public func solution(_ A : Int, _ B : Int) -> Int {

let a = String(A)
let b = String(B)


if b.contains(a) {


} else {
    return 0
}

return 1
}

solution(33, 88553344)

---

函数应该返回3，因为88应该是1，55是2，33是3

将字符串b转换为字符数组，并迭代并将其与字符串a进行比较

  public func solution(_ A : Int, _ B : Int) -> Int {

        let a = String(A)
        let b = String(B)


        if b.contains(a) {
        let characters = Array(b)

        for i in 0..< characters.count-1{
        let cont = "\(characters[i])+\(characters[i+1])"
        if cont == a{
        print("the index is \(i)")

        return i
        } 
         return 0   
        } else {
            return 0
        }

        }

---

以下是实现此目标的方法：

public func solution(_ A : Int, _ B : Int) -> Int {

    let a = String(A)
    let b = String(B)

    if b.contains(a) {

        let range = b.range(of: "\(a.first!)")!
        return b.distance(from: b.startIndex, to: range.lowerBound) / 2 + 1

    } else {
        return 0
    }
}

solution(88, 88553344) // 1
solution(55, 88553344) // 2
solution(33, 88553344) // 3
solution(44, 88553344) // 4

即使你给出一位整数

solution(3, 88553344) // 3

---

注意：这个解决方案只有当你的b是一对像88553344这样的两位数字时才有效。看起来你试图把这个长数字88553344看作一个值数组[88，55，33，44]。也就是说，如果搜索53，我假设您不想返回任何值。如果是这样，我会对数组进行转换，然后搜索：

public func solution(_ value1 : Int, _ value2 : Int) -> Int? {
    var array: [Int] = []
    var remainder = value2
    while remainder != 0 {
        array.insert(remainder % 100, at: 0)
        remainder /= 100
    }

    return array.firstIndex { $0 == value1 }
        .flatMap { $0 + 1 }
}

或者，如果您不需要可选项，并且希望将“未找到”表示为（例如）零，则可以执行以下操作：

public func solution(_ value1 : Int, _ value2 : Int) -> Int {
    var array: [Int] = []
    var remainder = value2
    while remainder != 0 {
        array.insert(remainder % 100, at: 0)
        remainder /= 100
    }

    return array.firstIndex { $0 == value1 }
        .flatMap { $0 + 1 } ?? 0
}

注意，一般不建议使用0作为神奇的哨兵值，但我从基于1的索引推断，这可能是需要的。在nil合并运算符，？之后使用所需的任意值。就我个人而言，我会选择optionals

就个人而言，由于我们生活在一个指数为零的世界，我建议88应该是0，55应该是1，等等：

public func solution(_ value1 : Int, _ value2 : Int) -> Int? {
    var array: [Int] = []
    var remainder = value2
    while remainder != 0 {
        array.insert(remainder % 100, at: 0)
        remainder /= 100
    }

    return array.firstIndex { $0 == value1 }
}

---

你可以这样做：

public func solution(_ A : Int, _ B : Int) -> Int {

    guard A <= B, A > 0 else {
        return 0
    }

    let numberOfDigitsA = Int(log10(Double(A)) + 1)
    let tenthPowerA = Int(pow(10.0, Double(numberOfDigitsA)))
    let numberOfDigitsB = Int(log10(Double(B)) + 1)

    var b = B
    var result = 0

    while b > 0 {
        let remainder = b % tenthPowerA
        if remainder == A {
            result = numberOfDigitsB / numberOfDigitsA - result
            break
        }
        b = b / tenthPowerA
        result += 1
    }

    return result
}

---

如果你在寻找一个指数，88553344中的33个位置将是5而不是3你期望的结果是什么？@LeoDabus我想他的意思是88-1，55-2，33-3，44-4所以位置取决于A的长度？这个问题完全不清楚。如果A等于3怎么办？你应该**真正整理一下缩进。

solution(55, 2233556677)    //3
solution(4, 9431)           //2
solution(123, 195000678123) //4
solution(111, 11)           //0