用您喜欢的语言实现除法算法，该算法可以处理整数除法。它只需要处理正数-但是如果处理负数和混合符号除法，也需要加分。结果四舍五入为分数结果。

该程序可能不包含/，\，div或类似的运营商。它必须是不使用语言的本机除法功能的例程。

您只需要处理32位除法。不允许使用重复减法。

输入值

在stdin上输入两个输入，并用新行或空格分隔（您的选择）

740 
2

输出量

在这种情况下，输出为370。

最短的解决方案就是胜利。

Python-73个字符

接受逗号分隔的输入，例如 740,2

from math import*
x,y=input()
z=int(exp(log(x)-log(y)))
print(z*y+y<=x)+z

JavaScript的，61

A=Array,P=prompt,P((','+A(+P())).split(','+A(+P())).length-1)

这将使一个字符串成为被除数,,,,,,（6）的长度，并在除数,,,（3）上分割，从而得到一个长度为3：的数组，['', '', '']然后将其长度减去1。绝对不是最快的，但还是很有意思！

JavaScript-36个字符

p=prompt;alert(p()*Math.pow(p(),-1))

Mathematica：34个字符

象征性地求解方程（xa == b）

Solve[x#[[1]]==#[[2]],x]&@Input[]

Python-72个字符

接受逗号分隔的输入，例如740,2

x,y=input();z=0
for i in range(32)[::-1]:z+=(1<<i)*(y<<i<=x-z*y)
print z

Python，37岁

步骤1.转换为一元。

步骤2.一元除法算法。

print('1'*input()).count('1'*input())

Python-41个字符

接受逗号分隔的输入，例如 740,2

x,y=input();z=x
while y*z>x:z-=1 
print z

Python，70岁

我刚刚想到的疯狂事情（使用逗号分隔的输入）：

from cmath import*
x,y=input()
print round(tan(polar(y+x*1j)[1]).real)

如果您接受小的float精度错误，则round可以删除该函数。

Yabasic-17个字符

input a,b:?a*b^-1

PHP-82个字符（儿童车）

$i=fgets(STDIN);$j=fgets(STDIN);$k=1;while(($a=$j*$k)<$i)$k++;echo($a>$i?--$k:$k);

但是，这是一个非常简单的解决方案-它不处理分数或不同的符号（会跳入无限循环）。我不会在这本书中详细介绍，这很简单。

输入在标准输入中，用新行分隔。

PHP-141个字符（完整）

$i*=$r=($i=fgets(STDIN))<0?-1:1;$j*=$s=($j=fgets(STDIN))<0?-1:1;$k=0;$l=1;while(($a=$j*$k)!=$i){if($a>$i)$k-=($l>>=2)*2;$k+=$l;}echo$k*$r*$s;

输入和输出与上一个相同。

是的，这几乎是上一个的两倍，但是：

• 正确处理分数
• 正确处理标志
• 永远不会进入无限循环，除非第二个参数为0-但这被零除-无效输入

重新格式化并说明：

$i *= $r = ($i = fgets(STDIN)) < 0 ? -1 : 1;
$j *= $s = ($j = fgets(STDIN)) < 0 ? -1 : 1;
                                    // First, in the parentheses, $i is set to
                                    // GET variable i, then $r is set to -1 or
                                    // 1, depending whether $i is negative or
                                    // not - finally, $i multiplied by $r ef-
                                    // fectively resulting in $i being the ab-
                                    // solute value of itself, but keeping the
                                    // sign in $r.
                                    // The same is then done to $j, the sign
                                    // is kept in $s.

$k = 0;                             // $k will be the result in the end.

$l = 1;                             // $l is used in the loop - it is added to
                                    // $k as long as $j*$k (the divisor times
                                    // the result so far) is less than $i (the
                                    // divided number).

while(($a = $j * $k) != $i){        // Main loop - it is executed until $j*$k
                                    // equals $i - that is, until a result is
                                    // found. Because a/b=c, c*b=a.
                                    // At the same time, $a is set to $j*$k,
                                    // to conserve space and time.

    if($a > $i)                     // If $a is greater than $i, last step
        $k -= ($l >>= 2) * 2;       // (add $l) is undone by subtracting $l
                                    // from $k, and then dividing $l by two
                                    // (by a bitwise right shift by 1) for
                                    // handling fractional results.
                                    // It might seem that using ($l>>=2)*2 here
                                    // is unnecessary - but by compressing the
                                    // two commands ($k-=$l and $l>>=2) into 1
                                    // means that curly braces are not needed:
                                    //
                                    // if($a>$i)$k-=($l>>=2)*2;
                                    //
                                    // vs.
                                    //
                                    // if($a>$i){$k-=$l;$l>>=2;}

    $k += $l;                       // Finally, $k is incremented by $l and
                                    // the while loop loops again.
}

echo $k * $r * $s;                  // To get the correct result, $k has to be
                                    // multiplied by $r and $s, keeping signs
                                    // that were removed in the beginning.

Ruby 1.9，28个字符

(?a*a+?b).split(?a*b).size-1

其余部分，21个字符

?a*a=~/(#{?a*b})\1*$/  

样品：

a = 756
b = 20
print (?a*a+?b).split(?a*b).size-1  # => 37
print ?a*a=~/(#{?a*b})\1*$/         # => 16

对于Ruby 1.8：

a = 756
b = 20
print ('a'*a+'b').split('a'*b).size-1  # => 37
print 'a'*a=~/(#{'a'*b})\1*$/          # => 16

杀伤人员地雷（6）

⌊*-/⍟⎕

/在这里不是除法，而是foldr。即F/a b c是a F (b F c)。如果我foldr叫不能使用/，可以用9个字符完成：

⌊*(⍟⎕)-⍟⎕

说明：

• ⎕： input()
• ⍟⎕： map(log, input())
• -/⍟⎕： foldr1(sub, map(log, input()))
• *-/⍟⎕： exp(foldr1(sub, map(log, input())))
• ⌊*-/⍟⎕： floor(exp(foldr1(sub, map(log, input()))))

PHP，55个字符

<?$a=explode(" ",fgets(STDIN));echo$a[0]*pow($a[1],-1);

输出（740/2）：http ://codepad.viper-7.com/ucTlcq

斯卡拉77

def d(a:Int,b:Int,c:Int=0):Int=if(b<=a)d(a-b,b,c+1)else c
d(readInt,readInt)

Haskell，96个字符

main=getLine>>=print.d.map read.words
d[x,y]=pred.snd.head.filter((>x).fst)$map(\n->(n*y,n))[0..]

输入在一行上。

该代码只是通过采用除数d并将其乘以所有整数来搜索答案n >= 0。设m红利。n这样n * d <= m选择的最大答案就是答案。该代码实际上选择了最小的n那个，n * d > m并从中减去1，因为我可以从这样的列表中选取第一个元素。在另一种情况下，我必须采用最后一个元素，但是要从无限列表中选取最后一个元素是很困难的。好了，列表可以证明是有限的，但是Haskell在执行过滤器时并不了解，因此它继续不确定地过滤。

普通Lisp，42个字符

(1-(loop as x to(read)by(read)counting t))

接受空格或行分隔的输入

重击 72 64个字符

read x y;yes ''|head -n$x>f;ls -l --block-size=$y f|cut -d\  -f5

输出无限数量的换行符，取第一个x，将它们全部放入一个名为f的文件中，然后以y的大小为单位获取f的大小。采纳了manatwork的建议，以删除八个字符。

Python-45个字符

接受逗号分隔的输入，例如740,2

x,y=input()
print-1+len((x*'.').split('.'*y))

Python，94个字符

递归二进制搜索：

a,b=input()
def r(m,n):return r(m,m+n>>1)if n*b>a else n if n*b+b>a else r(n,2*n)
print r(0,1)

Python，148

其他解决方案可能很短，但它们是否可扩展Web？

这是一个优雅，固定时间的解决方案，它利用了CLOUD的功能。

from urllib import*
print eval(urlopen('http://tryhaskell.org/haskell.json?method=eval&expr=div%20'+raw_input()+'%20'+raw_input()).read())['result']

我是否提到过它也使用Haskell？

Python，46个字节

没有人发布无聊的减法解决方案，所以我无法抗拒。

a，b = input（）
i = 0
而a> = b：a- = b; i + = 1
打印我

Smalltalk，Squeak 4.x风味

在Integer中定义此二进制消息：

% d 
    | i |
    d <= self or: [^0].
    i := self highBit - d highBit.
    d << i <= self or: [i := i - 1].
    ^1 << i + (self - (d << i) % d)

打完高尔夫球后，该商仍然很长（88个字符）：

%d|i n|d<=(n:=self)or:[^0].i:=n highBit-d highBit.d<<i<=n or:[i:=i-1].^1<<i+(n-(d<<i)%d)

但这是合理的快速：

[0 to: 1000 do: [:n |
    1 to: 1000 do: [:d |
        self assert: (n//d) = (n%d)]].
] timeToRun.

->在我适度的Mac mini上为127毫秒（8 MOp / s）

与常规除法相比：

[0 to: 1000 do: [:n |
    1 to: 1000 do: [:d |
        self assert: (n//d) = (n//d)]].
] timeToRun.

-> 31毫秒，仅慢4倍

我不算读stdin或写stdout的字符，Squeak不是为脚本设计的。

FileStream stdout nextPutAll:
    FileStream stdin nextLine asNumber%FileStream stdin nextLine asNumber;
    cr

当然，更愚蠢的反复减法

%d self>d and:[^0].^self-d%d+1

或简单的愚蠢枚举

%d^(0to:self)findLast:[:q|q*d<=self]

也可以工作，但不是很有趣

#include <stdio.h>
#include <string.h>
#include <math.h>


main()
{
   int i,j,ans;
   i=740;
   j=2;

   ans = pow(10,log10(i) - log10(j));
   printf("\nThe answer is %d",ans);
}

DC：26个字符

?so?se0[1+dle*lo>i]dsix1-p

我承认这不是最快的解决方案。

Python 54

接受逗号分隔的输入。

1. 制作一串长度为x的点
2. 用单个逗号替换长度为y的点段
3. 计算逗号。

之所以这么说是因为markdown在列表后加上代码而死了？：

x,y=input()
print("."*x).replace("."*y,',').count(',')

问46

{-1+(#){x-y}[;y]\[{s[x-y]<>(s:signum)x}[y];x]}

。

q){-1+(#){x-y}[;y]\[{s[x-y]<>(s:signum)x}[y];x]}[740;2]
370
q){-1+(#){x-y}[;y]\[{s[x-y]<>(s:signum)x}[y];x]}[740;3]
246

int divide (int num, int divideBy)
{
    int sum = 0;
    int shift = divideBy -1;
    while (num > divideBy) {
        sum += num >> shift ;
        num = (num >> shift ) + (num & divideBy);
    }
    if (num == divideBy) ++sum;
    return sum; 
}

参考：http : //www.forums.hscripts.com/viewtopic.php?f=13& t= 1358

Python，40个字符

print(float(input())*float(input())**-1)

Python，37岁

x,y=input()
print len(('0'*x)[y-1::y])

构造一个长度为x（'0'*x）的字符串，并使用扩展切片y从索引处开始选择每个字符y-1。打印结果字符串的长度。

像Gnibbler一样，这需要逗号分隔的输入。删除它会消耗9字符：

i=input
x,y=i(),i()
print len(('0'*x)[y-1::y])

视网膜 0.7.3，33字节（不竞争）

语言比挑战要新。首先使用除数输入以空格分隔的输入。除以零是不确定的。

\d+
$*
^(.+) (\1)+.*$
$#+
.+ .*
0

在线尝试