blocks|key|4610306|text|除了您的变量声明有语法错误之外，它完全按照您预期的方式工作。您所要做的就是将a和b转换为Double并将值传递给pow。然后，如果您正在处理2个Int，并且希望在操作的另一边返回Int，则只需将其强制转换为Int即可。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4610307|import+Darwin+

let+a:+Int+=+3
let+b:+Int+=+3

let+x:+Int+=+Int(pow(Double(a),Double(b)))|code-block|syntax|javascript|4610308|entityMap^0|12|1|14|1|1K|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

Other than that your variable declarations have syntax errors, this works exactly how you expected it to. All you have to do is cast <code>a</code> and <code>b</code> to Double and pass the values to <code>pow</code>. Then, if you're working with 2 Ints and you want an Int back on the other side of the operation, just cast back to Int.

<pre><code>import Darwin 

let a: Int = 3
let b: Int = 3

let x: Int = Int(pow(Double(a),Double(b)))
</code></pre>

blocks|key|4610417|text|如果您不倾向于操作符重载(尽管阅读您的代码的人可能对%5E%5E解决方案很清楚)，您可以快速实现：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4610418|let+pwrInt:(Int,Int)->Int+=+{+a,b+in+return+Int(pow(Double(a),Double(b)))+}
pwrInt(3,4)+//+81|code-block|syntax|javascript|4610419|entityMap^0|Q|2|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

If you're disinclined towards operator overloading (although the <code>^^</code> solution is probably clear to someone reading your code) you can do a quick implementation:

<pre><code>let pwrInt:(Int,Int)-&gt;Int = { a,b in return Int(pow(Double(a),Double(b))) }
pwrInt(3,4) // 81
</code></pre>

blocks|key|103792|text|更多细节|type|unstyled|depth|inlineStyleRanges|entityRanges|data|103793|+++infix+operator+%5E%5E+{+associativity+left+precedence+160+}
+++func+%5E%5E+(radix:+Int,+power:+Int)+->+Int+{
+++++++return+Int(pow(CGFloat(radix),+CGFloat(power)))
+++}|code-block|syntax|javascript|103794|swift+-+Binary+Expressions|offset|length|103795|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.apple.com/library/prerelease/mac/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/doc/uid/TP40014097-CH32-XID_720^0|0|0|0|Q|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

little detail more 

<pre><code> infix operator ^^ { associativity left precedence 160 }
 func ^^ (radix: Int, power: Int) -&gt; Int {
 return Int(pow(CGFloat(radix), CGFloat(power)))
 }
</code></pre>

<a href="https://developer.apple.com/library/prerelease/mac/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/doc/uid/TP40014097-CH32-XID_720" rel="nofollow">swift - Binary Expressions</a>

blocks|key|104023|text|mklbtz关于通过平方求幂是计算整数幂的标准算法是正确的，但该算法的尾递归实现似乎有点混乱。参见http://www.programminglogic.com/fast-exponentiation-algorithms/，了解C语言中平方求幂的非递归实现。我尝试在这里将其转换为Swift：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|104024|func+expo(_+base:+Int,+_+power:+Int)+->+Int+{
++++var+result+=+1

++++while+(power+!=+0){
++++++++if+(power%252+==+1){
++++++++++++result+*=+base
++++++++}
++++++++power+/=+2
++++++++base+*=+base
++++}
++++return+result
}|code-block|syntax|javascript|104025|当然，这可以通过创建一个重载操作符来调用它来实现，并且可以重写它，使它更通用，这样它就可以在实现IntegerType协议的任何东西上工作。为了让它更通用，我可能会从下面这样的东西开始|style|CODE|104026|++++func+expo<T:IntegerType>(_+base:+T,+_+power:+T)+->+T+{
++++var+result+:+T+=+1|104027|但是，这可能有点过头了。|104028|entityMap|0|LINK|mutability|MUTABLE|url|http://www.programminglogic.com/fast-exponentiation-algorithms/^0|1D|1R|0|0|0|1C|B|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@$A|14|B|15|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|O|3|P|5|6|7|17|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

mklbtz is correct about exponentiation by squaring being the standard algorithm for computing integer powers, but the tail-recursive implementation of the algorithm seems a bit confusing. See <a href="http://www.programminglogic.com/fast-exponentiation-algorithms/" rel="noreferrer">http://www.programminglogic.com/fast-exponentiation-algorithms/</a> for a non-recursive implementation of exponentiation by squaring in C. I've attempted to translate it to Swift here:

<pre><code>func expo(_ base: Int, _ power: Int) -&gt; Int {
 var result = 1

 while (power != 0){
 if (power%2 == 1){
 result *= base
 }
 power /= 2
 base *= base
 }
 return result
}
</code></pre>

Of course, this could be fancied up by creating an overloaded operator to call it and it could be re-written to make it more generic so it worked on anything that implemented the <code>IntegerType</code> protocol. To make it generic, I'd probably start with something like

<pre><code> func expo&lt;T:IntegerType&gt;(_ base: T, _ power: T) -&gt; T {
 var result : T = 1
</code></pre>

But, that is probably getting carried away.

blocks|key|104201|text|其他答案都很好，但如果您愿意，只要指数为正，您也可以使用Int扩展。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|104202|extension+Int+{+++
++++func+pow(toPower:+Int)+->+Int+{
++++++++guard+toPower+>+0+else+{+return+0+}
++++++++return+Array(repeating:+self,+count:+toPower).reduce(1,+*)
++++}
}

2.pow(toPower:+8)+//+returns+256|code-block|syntax|javascript|104203|entityMap^0|S|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

The other answers are great but if preferred, you can also do it with an <code>Int</code> extension so long as the exponent is positive.
<pre><code>extension Int { 
 func pow(toPower: Int) -&gt; Int {
 guard toPower &gt; 0 else { return 0 }
 return Array(repeating: self, count: toPower).reduce(1, *)
 }
}

2.pow(toPower: 8) // returns 256
</code></pre>

blocks|key|103811|text|或者只是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|103812|var+a:Int+=+3
var+b:Int+=+3
println(pow(Double(a),Double(b)))|code-block|syntax|javascript|103813|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Or just : 

<pre><code>var a:Int = 3
var b:Int = 3
println(pow(Double(a),Double(b)))
</code></pre>

blocks|key|103931|text|将答案组合成一个重载的函数集(并使用"**“而不是其他一些语言使用的"%5E%5E”-对我来说更清楚)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|103932|//+http://stackoverflow.com/questions/24196689/how-to-get-the-power-of-some-integer-in-swift-language
//+Put+this+at+file+level+anywhere+in+your+project
infix+operator+**+{+associativity+left+precedence+160+}
func+**+(radix:+Double,+power:+Double)+->+Double+{+return+pow(radix,+power)+}
func+**+(radix:+Int,++++power:+Int+++)+->+Double+{+return+pow(Double(radix),+Double(power))+}
func+**+(radix:+Float,++power:+Float+)+->+Double+{+return+pow(Double(radix),+Double(power))+}|code-block|syntax|javascript|103933|使用Float时，可能会丢失精度。如果使用数字字面量以及整数和非整数的混合，则默认情况下将以Double结尾。出于风格/可读性的原因，我个人喜欢使用数学表达式而不是像pow(a，b)这样的函数，但这只是我个人的想法。|103934|任何会导致pow()抛出错误的操作符也会导致这些函数抛出错误，所以错误检查的重担仍然在于使用power函数的代码。接吻，我的天。|103935|使用原生的pow()函数允许例如取平方根(2+**+0.5)或倒数(2+**+-3+=+1/8)。因为可以使用倒数或分数指数，所以我编写了所有的代码来返回默认的双精度类型的pow()函数，它应该返回最高的精度(如果我没记错文档的话)。如果需要，可以将其类型转换为Int或Float或其他类型，但可能会损失精度。|103936|2+**+-3++=+0.125
2+**+0.5+=+1.4142135623731
2+**+3+++=+8|103937|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Combining the answers into an overloaded set of functions (and using "**" instead of "^^" as some other languages use - clearer to me):

<pre><code>// http://stackoverflow.com/questions/24196689/how-to-get-the-power-of-some-integer-in-swift-language
// Put this at file level anywhere in your project
infix operator ** { associativity left precedence 160 }
func ** (radix: Double, power: Double) -&gt; Double { return pow(radix, power) }
func ** (radix: Int, power: Int ) -&gt; Double { return pow(Double(radix), Double(power)) }
func ** (radix: Float, power: Float ) -&gt; Double { return pow(Double(radix), Double(power)) }
</code></pre>

When using Float, you may lose precision. If using numeric literals and a mix of integers and non-integers, you will end up with Double by default. I personally like the ability to use a mathematical expression instead of a function like pow(a, b) for stylistic/readability reasons, but that's just me.

Any operators that would cause pow() to throw an error will also cause these functions to throw an error, so the burden of error checking still lies with the code using the power function anyway. KISS, IMHO.

Using the native pow() function allows to eg take square roots (2 ** 0.5) or inverse (2 ** -3 = 1/8). Because of the possibility to use inverse or fractional exponents, I wrote all my code to return the default Double type of the pow() function, which should return the most precision (if I remember the documentation correctly). If needed, this can be type-casted down to Int or Float or whatever, possibly with the loss of precision.

<pre><code>2 ** -3 = 0.125
2 ** 0.5 = 1.4142135623731
2 ** 3 = 8
</code></pre>

blocks|key|104062|text|事实证明，您也可以使用pow()。例如，您可以使用下面的表达式来表示10到9。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|104063|pow(10,+9)|code-block|syntax|javascript|104064|与pow一起，powf()返回一个float而不是double。我只在Swift+4和macOS+10.13上测试过。|104065|entityMap^0|B|5|0|0|1|3|7|6|H|5|P|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

It turns out you can also use <code>pow()</code>. For example, you can use the following to express 10 to the 9th.

<pre><code>pow(10, 9)
</code></pre>

Along with <code>pow</code>, <code>powf()</code> returns a <code>float</code> instead of a <code>double</code>. I have only tested this on Swift 4 and macOS 10.13.

blocks|key|4610639|text|要计算power(2,+n)，只需使用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4610640|let+result+=+2+<<+(n-1)|code-block|syntax|javascript|4610641|entityMap^0|3|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

To calculate <code>power(2, n)</code>, simply use:

<pre><code>let result = 2 &lt;&lt; (n-1)
</code></pre>

blocks|key|4610718|text|在Swift+5中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4610719|extension+Int{
++++func+expo(_+power:+Int)+->+Int+{
++++++++var+result+=+1
++++++++var+powerNum+=+power
++++++++var+tempExpo+=+self
++++++++while+(powerNum+!=+0){
++++++++if+(powerNum%252+==+1){
++++++++++++result+*=+tempExpo
++++++++}
++++++++powerNum+/=+2
++++++++tempExpo+*=+tempExpo
++++++++}
++++++++return+result
++++}
}|code-block|syntax|javascript|4610720|像这样使用|4610721|2.expo(5)+//+pow(2,+5)|4610722|感谢@Paul+Buis的回答。|4610723|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In Swift 5:

<pre><code>extension Int{
 func expo(_ power: Int) -&gt; Int {
 var result = 1
 var powerNum = power
 var tempExpo = self
 while (powerNum != 0){
 if (powerNum%2 == 1){
 result *= tempExpo
 }
 powerNum /= 2
 tempExpo *= tempExpo
 }
 return result
 }
}

</code></pre>

Use like this 

<pre><code>2.expo(5) // pow(2, 5)
</code></pre>

Thanks to @Paul Buis's answer.

blocks|key|104115|text|数组(重复:+a，计数:+b).reduce(1，*)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|104116|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Array(repeating: a, count: b).reduce(1, *)

blocks|key|104146|text|一个基于Int的幂函数，它直接通过Swift+5中基数2的位移位来计算值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|104147|func+pow(base:+Int,+power:+UInt)+->+Int+{
++++if+power+==+0+{+return+1+}
++++//+for+base+2,+use+a+bit+shift+to+compute+the+value+directly
++++if+base+==+2+{+return+2+<<+Int(power+-+1)+}
++++//+otherwise+multiply+base+repeatedly+to+compute+the+value
++++return+repeatElement(base,+count:+Int(power)).reduce(1,+*)
}|code-block|syntax|javascript|104148|(确保结果在Int的范围内-这不会检查越界情况)|104149|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

An Int-based pow function that computes the value directly via bit shift for base 2 in Swift 5:

<pre class="lang-swift prettyprint-override"><code>func pow(base: Int, power: UInt) -&gt; Int {
 if power == 0 { return 1 }
 // for base 2, use a bit shift to compute the value directly
 if base == 2 { return 2 &lt;&lt; Int(power - 1) }
 // otherwise multiply base repeatedly to compute the value
 return repeatElement(base, count: Int(power)).reduce(1, *)
}
</code></pre>

(Make sure the result is within the range of Int - this does not check for the out of bounds case)

blocks|key|4610550|text|尝试组合重载，我尝试使用泛型，但无法使其工作。我最终决定使用NSNumber，而不是尝试重载或使用泛型。这可以简化为以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4610551|typealias+Dbl+=+Double+//+Shorter+form
infix+operator+**+{associativity+left+precedence+160}
func+**+(lhs:+NSNumber,+rhs:+NSNumber)+->+Dbl+{return+pow(Dbl(lhs),+Dbl(rhs))}|code-block|syntax|javascript|4610552|以下代码与上面的功能相同，但实现了错误检查，以查看参数是否可以成功转换为Double。|4610553|func+**+(lhs:+NSNumber,+rhs:+NSNumber)+->+Dbl+{
++++//+Added+(probably+unnecessary)+check+that+the+numbers+converted+to+Doubles
++++if+(Dbl(lhs)+??+Dbl.NaN)+!=+Dbl.NaN+&&+(Dbl(rhs)+??+Dbl.NaN)+!=+Dbl.NaN+{
++++++++return+pow(Dbl(lhs),+Dbl(rhs))
++++}+else+{
++++++++return+Double.NaN
++++}
}|4610554|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Trying to combine the overloading, I tried to use generics but couldn't make it work. I finally figured to use NSNumber instead of trying to overload or use generics. This simplifies to the following:

<pre><code>typealias Dbl = Double // Shorter form
infix operator ** {associativity left precedence 160}
func ** (lhs: NSNumber, rhs: NSNumber) -&gt; Dbl {return pow(Dbl(lhs), Dbl(rhs))}
</code></pre>

The following code is the same function as above but implements error checking to see if the parameters can be converted to Doubles successfully.

<pre><code>func ** (lhs: NSNumber, rhs: NSNumber) -&gt; Dbl {
 // Added (probably unnecessary) check that the numbers converted to Doubles
 if (Dbl(lhs) ?? Dbl.NaN) != Dbl.NaN &amp;&amp; (Dbl(rhs) ?? Dbl.NaN) != Dbl.NaN {
 return pow(Dbl(lhs), Dbl(rhs))
 } else {
 return Double.NaN
 }
}
</code></pre>

blocks|key|103757|text|我更喜欢这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|103758|func+%5E+(left:NSNumber,+right:+NSNumber)+->+NSNumber+{
++++return+pow(left.doubleValue,right.doubleValue)
}
var+a:NSNumber+=+3
var+b:NSNumber+=+3+
println(+a%5Eb+)+//+27|code-block|syntax|javascript|103759|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I like this better

<pre><code>func ^ (left:NSNumber, right: NSNumber) -&gt; NSNumber {
 return pow(left.doubleValue,right.doubleValue)
}
var a:NSNumber = 3
var b:NSNumber = 3 
println( a^b ) // 27
</code></pre>

blocks|key|4610325|text|func+calc+(base:Int,+number:Int)+->+Int+{
++++var+answer+:+Int+=+base
++++for+_+in+2...number+{answer+*=+base+}+
++++return+answer
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4610326|示例：|unstyled|4610327|calc+(2,2)|4610328|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>func calc (base:Int, number:Int) -&gt; Int {
 var answer : Int = base
 for _ in 2...number {answer *= base } 
 return answer
}
</code></pre>

Example:

<pre><code>calc (2,2)
</code></pre>

I'm learning swift recently, but I have a basic problem that can't find an answer

I want to get something like 

<pre><code>var a:Int = 3
var b:Int = 3 
println( pow(a,b) ) // 27
</code></pre>

but the pow function can work with double number only, it doesn't work with integer, and I can't even cast the int to double by something like Double(a) or a.double()...

Why it doesn't supply the power of integer? it will definitely return an integer without ambiguity !
and Why I can't cast a integer to a double? it just change 3 to 3.0 (or 3.00000... whatever)

if I got two integer and I want to do the power operation, how can I do it smoothly?

Thanks!

How to get the Power of some Integer in Swift language?

我最近在学习swift，但我有一个基本的问题找不到答案我想要像这样的东西var a:Int = 3var b:Int = 3 println( pow(a,b) ) // 27但是pow函数只能处理双精度数，它不能处理整数，我甚至不能通过Double(a)或a.double()将整型转换为双精度。为什么它不提供整数的幂呢？它肯定会返回一个没有歧义的整数！为什么我不能将一个整数转换为双精度？它只是将

问如何在Swift语言中获得一些整数的幂？
EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Swift语言中获得一些整数的幂？EN

回答 15

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Swift语言中获得一些整数的幂？
EN