Thực hiện một thuật toán phân chia trong ngôn ngữ yêu thích của bạn để xử lý phân chia số nguyên. Nó chỉ cần xử lý các số dương - nhưng điểm thưởng nếu nó cũng xử lý phân chia dấu âm và hỗn hợp. Kết quả được làm tròn xuống cho kết quả phân đoạn.

Chương trình này có thể không chứa /, \, divhoặc tương tự khai thác. Nó phải là một thói quen không sử dụng khả năng phân chia riêng của ngôn ngữ.

Bạn chỉ cần xử lý phân chia tối đa 32 bit. Sử dụng phép trừ lặp đi lặp lại không được phép.

Đầu vào

Lấy hai đầu vào trên stdin cách nhau bởi các dòng hoặc dấu cách mới (lựa chọn của bạn)

740 
2

Đầu ra

Trong trường hợp này, đầu ra sẽ là 370.

Giải pháp nào là chiến thắng ngắn nhất.

Python - 73 ký tự

Có đầu vào được phân tách bằng dấu phẩy, ví dụ: 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)

Điều này tạo ra một chuỗi có độ dài của cổ tức ,,,,,,(6) và chia trên số chia ,,,(3), dẫn đến một mảng có độ dài 3 : ['', '', ''], có độ dài I sau đó trừ đi một phần. Chắc chắn không phải là nhanh nhất, nhưng hy vọng dù sao cũng thú vị!

JavaScript - 36 ký tự

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

Toán học: 34 ký tự

Giải phương trình một cách tượng trưng (xa == b)

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

Python - 72 ký tự

Có đầu vào được phân tách bằng dấu phẩy, ví dụ 740,2

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

Con trăn, 37

Bước 1. Chuyển đổi sang unary.

Bước 2. Thuật toán chia đơn vị.

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

Python - 41 ký tự

Có đầu vào được phân tách bằng dấu phẩy, ví dụ: 740,2

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

Con trăn, 70

Một cái gì đó điên rồ tôi chỉ nghĩ (sử dụng đầu vào được phân tách bằng dấu phẩy):

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

Nếu bạn chấp nhận các lỗi chính xác float nhỏ, roundchức năng có thể bị loại bỏ.

Yabasic - 17 ký tự

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

PHP - 82 ký tự (lỗi)

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

Tuy nhiên, đây là một giải pháp rất đơn giản - nó không xử lý các phân số hoặc các dấu hiệu khác nhau (sẽ nhảy vào một vòng lặp vô hạn). Tôi sẽ không đi vào chi tiết trong phần này, nó khá đơn giản.

Đầu vào là trong stdin, cách nhau bởi một dòng mới.

PHP - 141 ký tự (đầy đủ)

$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;

Đầu vào và đầu ra giống như trước đây.

Vâng, cái này gần gấp đôi kích thước của cái trước, nhưng nó:

• xử lý các phân số chính xác
• xử lý các dấu hiệu chính xác
• sẽ không bao giờ đi vào một vòng lặp vô hạn, UNLESS tham số thứ hai là 0 - nhưng đó là chia cho 0 - đầu vào không hợp lệ

Định dạng lại và giải thích:

$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 ký tự

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

Phần còn lại của phân chia, 21 ký tự

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

Mẫu vật:

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

Đối với 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)

⌊*-/⍟⎕

/không phải là phân chia ở đây, nhưng foldr. tức là, F/a b clà a F (b F c). Nếu tôi không thể sử dụng foldrvì nó được gọi /, nó có thể được thực hiện trong 9 ký tự:

⌊*(⍟⎕)-⍟⎕

Giải trình:

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

PHP, 55 ký tự

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

Đầu ra (740/2): http://codepad.viper-7.com/ucTlcq

Scala 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 ký tự

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

Đầu vào là trên một dòng duy nhất.

Mã chỉ tìm kiếm câu trả lời bằng cách lấy ước số dvà nhân nó với tất cả các số nguyên n >= 0. Hãy mlà cổ tức. Lớn nhất nnhư vậy n * d <= mđược chọn là câu trả lời. Mã thực sự chọn ít nhất nnhư vậy n * d > mvà trừ 1 từ nó bởi vì tôi có thể lấy phần tử đầu tiên từ danh sách đó. Trong trường hợp khác, tôi sẽ phải lấy cái cuối cùng, nhưng thật khó để lấy phần tử cuối cùng từ một danh sách vô hạn. Chà, danh sách có thể được chứng minh là hữu hạn, nhưng Haskell không biết rõ hơn khi thực hiện bộ lọc, vì vậy nó tiếp tục lọc vô thời hạn.

Lisp thông thường, 42 ký tự

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

Chấp nhận đầu vào không gian hoặc phân tách dòng

Bash, 72 64 ký tự

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

Xuất ra vô số dòng mới, lấy x đầu tiên, đặt tất cả chúng vào một tệp có tên f, sau đó lấy kích thước của f trong các khối có kích thước của y. Lấy lời khuyên của manatwork để cạo sạch tám nhân vật.

Python - 45 ký tự

Có đầu vào được phân tách bằng dấu phẩy, ví dụ 740,2

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

Con trăn, 94 ký tự

Một tìm kiếm nhị phân đệ quy:

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)

Con trăn, 148

Các giải pháp khác có thể ngắn, nhưng chúng có quy mô web ?

Đây là một giải pháp thanh lịch, liên tục , tận dụng sức mạnh của CLOUD.

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

Tôi đã đề cập đến nó cũng sử dụng Haskell?

Python, 46 byte

Không ai đã đăng giải pháp trừ nhàm chán, vì vậy tôi không thể cưỡng lại việc đó.

a, b = đầu vào ()
i = 0
trong khi a> = b: a- = b; i + = 1
in tôi

Smalltalk , Squeak 4.x hương vị

xác định thông điệp nhị phân này trong 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)

Khi đã chơi gôn, thương số này vẫn còn dài (88 ký tự):

%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)

Nhưng nó rất nhanh:

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

-> 127 ms trên máy mac mini khiêm tốn của tôi (8 MOp / s)

So với phân chia thông thường:

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

-> 31 ms, nó chỉ chậm hơn 4 lần

Tôi không đếm số ký tự để đọc stdin hoặc viết stdout, Squeak không được thiết kế để viết kịch bản.

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

Tất nhiên, phép trừ lặp đi lặp lại ngu ngốc hơn

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

hoặc liệt kê ngu ngốc

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

cũng có thể làm việc, nhưng không thực sự thú vị

#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 ký tự

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

Tôi thừa nhận rằng nó không phải là giải pháp nhanh nhất xung quanh.

Con trăn 54

Đưa đầu vào được phân cách bằng dấu phẩy.

1. Tạo một chuỗi các chấm có độ dài x
2. Thay thế các đoạn của các chấm có độ dài y bằng một dấu phẩy
3. Đếm dấu phẩy.

Các từ vì markdown chết với một danh sách theo sau là mã?:

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

Q, 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; 
}

Tham khảo: http://www.forums.hscripts.com/viewtopic.php?f=13&t=1353

Con trăn, 40 ký tự

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

Con trăn, 37

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

Xây dựng một chuỗi độ dài x( '0'*x) và sử dụng lát cắt mở rộng để chọn mọi yký tự thứ, bắt đầu từ chỉ mụcy-1 . In độ dài của chuỗi kết quả.

Giống như Gnibbler, điều này có đầu vào được phân tách bằng dấu phẩy. Loại bỏ chi phí 9ký tự:

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

Retina 0.7.3, 33 byte (không cạnh tranh)

Ngôn ngữ mới hơn thách thức. Đưa đầu vào được phân tách bằng dấu cách với ước số trước. Chia cho số 0 là không xác định.

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

Dùng thử trực tuyến