Реалізуйте алгоритм ділення на улюбленій мові, який обробляє ціле ділення. Потрібно обробляти тільки позитивні цифри, але бонусні бали, якщо він також обробляє негативний та змішаний знаки. Результати округляються до дробових результатів.

Програма не може містити /, \, 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

JavaScript, 61

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

Це робить рядок довжиною дивіденду ,,,,,,(6) і розбивається на дільник ,,,(3), в результаті чого виникає масив довжиною 3:, ['', '', '']довжину якого я потім віднімаю. Однозначно не найшвидший, але, сподіваємось, цікавий все-таки!

JavaScript - 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функцію можна скинути.

Ябасич - 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 - але це ділення на нуль - недійсне введення

Переформатування та пояснення:

$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

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 символів

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 не знає кращого при виконанні фільтра, тому він продовжує фільтрувати нескінченно.

Звичайний Лісп, 42 символи

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

Приймає простір або розділений рядком вхід

Bash, 72 64 символи

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

Виведіть нескінченну кількість нових рядків, візьміть перший x, помістіть їх у файл під назвою f, а потім отримайте розмір f в блоки розміром y. Скористався порадою манатурки, щоб поголити вісім персонажів.

Пітон - 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
друк i

Smalltalk , Squeak 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.

-> 127 мс на моєму скромному mac mini (8 МОп / с)

Порівняно з регулярним поділом:

[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

Я визнаю, що це не найшвидше рішення.

Пітон 54

Займає введення з комою.

1. Створює рядок з точок довжиною x
2. Замінює відрізки точок довжиною y однією комою
3. Розраховує коми.

Слова, оскільки розмітка вмирає зі списком, а потім кодом ?:

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

Довідка: 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 байти (не конкурує)

Мова новітня, ніж виклик. Спершу бере вхід, розділений пробілом, дільником. Ділення на нуль не визначене.

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

Спробуйте в Інтернеті