Question

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

所以我将两个整数都转换为两个字符串，然后在b中包含a，但是如何找到a出现在b中最左边的位置？

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。

Answer 1

将字符串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
        }

        }

Answer 2

这是实现它的方法：

   for(i=0; i<business1.length;i++){

    var features = []
    var feature = [i]
        feature.dataPosition = i;
 var clickedNameClicked = names[this.dataPosition]
 console.log(clickedNameClicked)

  features.push(business1[i]);

  }

即使您给出一位整数

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

注意：仅当您的b是2位数字对，例如solution(3, 88553344) // 3

时，此解决方案才有效

Answer 3

您似乎想将这个长数字useCallback视为一组值88553344。也就是说，如果您搜索[88, 55, 33, 44]，则假定您不想返回任何值。如果是这样，我会将其转换为数组，然后进行搜索：

或者，如果您不想使用可选参数，并且希望将“未找到”表示为零，则可以执行以下操作：

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 }作为神奇的前哨值，但是我从您的基于1的索引中推断出这可能是理想的。在0-联合运算符nil之后使用所需的任何值。就个人而言，我会坚持使用可选项。

就我们个人而言，由于我们生活在一个从零开始的索引世界中，因此我建议??应该是88，0应该是1，依此类推：

Answer 4

你可以这样：公共功能解决方案（_ A：Int，_ B：Int）-> Int { 守卫A <= B，A> 0其他{ 返回0 } 让numberOfDigitsA = Int（log10（Double（A））+1）让tenthPowerA = Int（pow（10.0，Double（numberOfDigitsA）））让numberOfDigitsB = Int（log10（Double（B））+1） var b = B var结果= 0 而b> 0 { 让余数= b％tenthPowerA 如果余数== A { 结果= numberOfDigitsB / numberOfDigitsA-结果打破 } b = b /十分之一结果+ = 1 } 返回结果 } 此解决方案假定B由数字组组成，每组数字与A的位数相同。如果没有B都不包含A的数字，则返回0。数字位置基于1。这是一些测试用例：解决方案（55，2233556677）// 3 solution（4，9431）// 2 solution（123，195000678123）// 4 solution（111，11）// 0

查找a在b |中显示为子字符串的索引值迅速

4 个答案: