정수 나누기를 처리하는 자주 사용하는 언어로 나누기 알고리즘을 구현하십시오. 양수 만 처리하면되지만 음수와 혼합 부호 나누기를 처리하는 경우 보너스 포인트도 필요합니다. 분수 결과의 경우 결과가 반올림됩니다.

프로그램 /에 \, div또는 유사한 연산자가 포함되어 있지 않을 수 있습니다 . 언어의 고유 분할 기능을 사용하지 않는 루틴이어야합니다.

최대 32 비트 나누기 만 처리하면됩니다. 뺄셈을 반복해서 사용할 수 없습니다.

입력

새로운 줄이나 공백으로 구분 된 stdin에 두 개의 입력을 취하십시오 (선택)

740 
2

산출

이 경우 출력은입니다 370.

가장 짧은 솔루션이 이깁니다.

파이썬-73 자

쉼표로 구분 된 입력을받습니다. 예 : 740,2

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

자바 스크립트, 61

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

이것은 문자열을 피제수 ,,,,,,(6) 의 길이로 만들고 제수 ,,,(3) 에서 쪼개서 길이 3의 배열을 낳습니다 ['', '', '']. 확실히 가장 빠르지는 않지만 그럼에도 불구하고 희망적으로 흥미 롭습니다!

자바 스크립트-36 자

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

매스 매 티카 : 34 자

방정식을 상징적으로 풀기 (xa == b)

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

파이썬-72 자

쉼표로 구분 된 입력을받습니다 (예 : 740,2).

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

파이썬, 37

1 단계. 단항으로 변환합니다.

단계 2. 단항 나누기 알고리즘.

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

파이썬-41 자

쉼표로 구분 된 입력을받습니다. 예 : 740,2

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

파이썬, 70

방금 생각한 미친 짓 (쉼표로 구분 된 입력 사용) :

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

작은 부동 소수점 오차를 허용하면 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);

그러나 이것은 매우 간단한 해결책입니다-분수 또는 다른 부호를 처리하지 않습니다 (무한 루프로 뛰어들 것입니다). 나는 이것에 대해 자세히 설명하지 않을 것입니다. 그것은 매우 간단합니다.

입력이 stdin에 있으며 새 줄로 구분됩니다.

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이 아니라면 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.

루비 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

APL (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)

하스켈, 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 > mI는 목록에서 첫 번째 요소를 취할 수 있기 때문에로부터 감산 1. 다른 경우에는 마지막을 가져야하지만 무한 요소 목록에서 마지막 요소를 가져 오는 것은 어렵습니다. 글쎄, 그 목록은 유한 한 것으로 증명 될 수 있지만, Haskell은 필터를 수행 할 때 더 잘 알지 못하므로 계속해서 불필요하게 필터링합니다.

공통 리스프, 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라는 파일에 넣은 다음 블록 크기로 f의 크기를 y의 크기로 가져옵니다. 8 명의 캐릭터를 깎아 내도록 Manatwork의 조언을 받았습니다.

파이썬-45 자

쉼표로 구분 된 입력을받습니다 (예 : 740,2).

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

파이썬, 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)

파이썬, 148

다른 솔루션은 짧을 수 있지만 웹 확장 입니까?

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도 사용한다고 언급 했습니까?

파이썬, 46 바이트

아무도 지루한 뺄셈 솔루션을 게시하지 않았으므로 그 일을 거부 할 수 없었습니다.

a, b = 입력 ()
i = 0
a> = b : a- = b; i + = 1 인 동안
내가 인쇄

스몰 토크 , 스 que 4.x 맛

이 바이너리 메시지를 정수로 정의하십시오.

% 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에서 127ms (8 MOp / s)

정규 부서와 비교 :

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

-> 31ms, 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

나는 그것이 가장 빠른 해결책이 아니라는 것을 인정한다.

파이썬 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

파이썬, 40 자

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

파이썬, 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 바이트 (경쟁 불가)

언어는 도전보다 새로운 것입니다. 제수를 사용하여 공백으로 구분 된 입력을 먼저받습니다. 0으로 나누는 것은 정의되어 있지 않습니다.

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

온라인으로 사용해보십시오