Indexing 戈朗反向

如何将

12345

更改为

54321

？ 对于字符串，可以将字符串更改为

符文

，并将其反转，但不能对整数执行相同操作。我搜索了一下，发现没有人在谈论这件事。示例

131415

>>

514131

1357

>

7531

123a

>错误
-编辑-
我在想，为什么不创建一个

切片

并为其编制索引？
然后我意识到你不能索引

int

（）
我的新问题是
如何对int进行索引？ 或

---

如何反转int？

这里有一个解决方案，它不使用索引

int

package main

import (
    "fmt"
)

func reverse_int(n int) int {
    new_int := 0
    for n > 0 {
        remainder := n % 10
        new_int *= 10
        new_int += remainder 
        n /= 10
    }
    return new_int 
}

func main() {
    fmt.Println(reverse_int(123456))
    fmt.Println(reverse_int(100))
    fmt.Println(reverse_int(1001))
    fmt.Println(reverse_int(131415))
    fmt.Println(reverse_int(1357))
}

结果:

654321
1
1001
514131
7531

---

这里有一个解决方案，它不使用索引

int

package main

import (
    "fmt"
)

func reverse_int(n int) int {
    new_int := 0
    for n > 0 {
        remainder := n % 10
        new_int *= 10
        new_int += remainder 
        n /= 10
    }
    return new_int 
}

func main() {
    fmt.Println(reverse_int(123456))
    fmt.Println(reverse_int(100))
    fmt.Println(reverse_int(1001))
    fmt.Println(reverse_int(131415))
    fmt.Println(reverse_int(1357))
}

结果:

654321
1
1001
514131
7531

---

我将整数转换为字符串，反转字符串，然后将结果转换回字符串

package main

import (
    "fmt"
    "strconv"
)

func main() {

    fmt.Println(reverse_int(123456))
        fmt.Println(reverse_int(100))
        fmt.Println(reverse_int(1001))
        fmt.Println(reverse_int(131415))
        fmt.Println(reverse_int(1357))

}

func reverse_int(value int) int {

    intString := strconv.Itoa(value)

    newString := ""

    for x := len(intString); x > 0; x-- {
        newString += string(intString[x - 1])
    }

    newInt, err := strconv.Atoi(newString)

    if(err != nil){
        fmt.Println("Error converting string to int")
    }

    return newInt
}

---

我将整数转换为字符串，反转字符串，然后将结果转换回字符串

package main

import (
    "fmt"
    "strconv"
)

func main() {

    fmt.Println(reverse_int(123456))
        fmt.Println(reverse_int(100))
        fmt.Println(reverse_int(1001))
        fmt.Println(reverse_int(131415))
        fmt.Println(reverse_int(1357))

}

func reverse_int(value int) int {

    intString := strconv.Itoa(value)

    newString := ""

    for x := len(intString); x > 0; x-- {
        newString += string(intString[x - 1])
    }

    newInt, err := strconv.Atoi(newString)

    if(err != nil){
        fmt.Println("Error converting string to int")
    }

    return newInt
}

---

与第一个答案非常相似，但这会检查以确保您没有超出类型的界限

func reverse(x int) int {    
    rev := 0
    for x != 0 {
        pop := x % 10
        x /=  10
        if rev > math.MaxInt32/10 || (rev == math.MaxInt32 /10 && pop > 7) {
            return 0
        }
        if rev < math.MinInt32/10 || (rev == math.MinInt32/10 && pop < -8) {
            return 0
        }
        rev = rev * 10 + pop
    }

    return rev
}

func reverse（x int）int{
修订版：=0
对于x！=0{
流行音乐：=x%10
x/=10
如果rev>math.MaxInt32/10 | |（rev==math.MaxInt32/10&&pop>7）{
返回0
}
如果rev

与第一个答案非常相似，但这会检查以确保您没有超出类型的界限

func reverse(x int) int {    
    rev := 0
    for x != 0 {
        pop := x % 10
        x /=  10
        if rev > math.MaxInt32/10 || (rev == math.MaxInt32 /10 && pop > 7) {
            return 0
        }
        if rev < math.MinInt32/10 || (rev == math.MinInt32/10 && pop < -8) {
            return 0
        }
        rev = rev * 10 + pop
    }

    return rev
}

func reverse（x int）int{
修订版：=0
对于x！=0{
流行音乐：=x%10
x/=10
如果rev>math.MaxInt32/10 | |（rev==math.MaxInt32/10&&pop>7）{
返回0
}
如果rev

也翻转负数int

func Abs(x int) int {
  if x < 0 {
    return -x
  }
   return x
}

func reverse_int(n int) int {
  newInt := 0
  sign := 1
   if n < 0 {
    sign = -1
   }
   n = Abs(n)
  for n > 0 {
    remainder := n % 10
    newInt = newInt*10 + remainder
    n /= 10
  }
  return newInt * sign 
}

func main() {
  fmt.Println(reverse_int(-100))
  fmt.Println(reverse_int(-1001))
  fmt.Println(reverse_int(131415))
  fmt.Println(reverse_int(1357))
}

func Abs（x int）int{
如果x<0{
返回-x
}
返回x
}
func reverse_int（n int）int{
newInt:=0
符号：=1
如果n<0{
符号=-1
}
n=Abs（n）
对于n>0{
余数：=n%10
newInt=newInt*10+余数
n/=10
}
返回newInt*符号
}
func main（）{
格式打印（反向打印（-100））
格式打印（反向打印（-1001））
格式打印（反向打印（131415））
格式打印（反向打印（1357））
}

也翻转负数int

func Abs(x int) int {
  if x < 0 {
    return -x
  }
   return x
}

func reverse_int(n int) int {
  newInt := 0
  sign := 1
   if n < 0 {
    sign = -1
   }
   n = Abs(n)
  for n > 0 {
    remainder := n % 10
    newInt = newInt*10 + remainder
    n /= 10
  }
  return newInt * sign 
}

func main() {
  fmt.Println(reverse_int(-100))
  fmt.Println(reverse_int(-1001))
  fmt.Println(reverse_int(131415))
  fmt.Println(reverse_int(1357))
}

func Abs（x int）int{
如果x<0{
返回-x
}
返回x
}
func reverse_int（n int）int{
newInt:=0
符号：=1
如果n<0{
符号=-1
}
n=Abs（n）
对于n>0{
余数：=n%10
newInt=newInt*10+余数
n/=10
}
返回newInt*符号
}
func main（）{
格式打印（反向打印（-100））
格式打印（反向打印（-1001））
格式打印（反向打印（131415））
格式打印（反向打印（1357））
}

与Fokiruna的回答类似，但也检查32位溢出

func reverse(x int) int {
    result, sign := 0, 1
 
    if(x < 0) {
        sign = -1
        x = -x     
    }

    for x > 0 {
        remainder := x % 10;
        result = result * 10 + remainder
        x = x/10
    }
    
    var checkInt int = int(int32(result))

    if checkInt != result {
        return 0
    }

    return result * sign
}

func反向（x int）int{
结果，符号：=0，1
if（x<0）{
符号=-1
x=-x
}
对于x>0{
余数：=x%10；
结果=结果*10+余数
x=x/10
}
var checkInt=int（int32（结果））
如果checkInt！=结果{
返回0
}
返回结果*符号
}

与Fokiruna的回答类似，但也检查32位溢出

func reverse(x int) int {
    result, sign := 0, 1
 
    if(x < 0) {
        sign = -1
        x = -x     
    }

    for x > 0 {
        remainder := x % 10;
        result = result * 10 + remainder
        x = x/10
    }
    
    var checkInt int = int(int32(result))

    if checkInt != result {
        return 0
    }

    return result * sign
}

func反向（x int）int{
结果，符号：=0，1
if（x<0）{
符号=-1
x=-x
}
对于x>0{
余数：=x%10；
结果=结果*10+余数
x=x/10
}
var checkInt=int（int32（结果））
如果checkInt！=结果{
返回0
}
返回结果*符号
}

索引是一项

int

要求吗？因为你可以在没有索引的情况下反转一个

int

，在我看来，它更直截了当。事实并非如此。请分享您的非复杂方式索引

int

a需求？因为你可以在没有索引的情况下反转一个

int

，在我看来，它更直截了当。事实并非如此。请分享您的非复杂方式有没有理由不将整数转换为字符串，然后将其反转？我想出了一个不同的解决方案，但作为一个新手，我想我可能错过了一些东西，与你的做法相比。地鼠喜欢避免拉进过多的包或使用过多的内存。如果代码运行频繁，导致cpu时间或功耗成为问题，他们会选择将解决方案保留在整数域中，也会减少需要覆盖的错误案例。大多数从整数到字符串的转换都将使用一个循环，该循环在每次迭代中都会执行自己的模10。然后是反转字符串的循环。然后是一个循环，通过乘以10生成一个整数。要求计算机做太多繁忙的工作。那么负整数呢？如果数字以0结尾，这将无法正常工作。例如，19100变为191。也不能很好地处理负整数。如果将n>0的

更改为n！=0的
，则修复了负整数问题（已测试）。有没有理由不把整数转换成字符串，然后再将其反转？我想出了一个不同的解决方案，但作为一个新手，我认为与你的做法相比，我可能遗漏了一些东西。地鼠喜欢避免拉入过多的包或使用过多的内存。如果代码运行得如此频繁，那么cpu时间或功耗是一个问题，他们会选择将解决方案保留在整数域中，也会减少要覆盖的错误案例。大多数从整数到字符串的转换将使用一个循环，该循环在每次迭代中执行自己的模10