15

अपनी पसंदीदा भाषा में एक डिवीजन एल्गोरिथ्म को लागू करें जो पूर्णांक विभाजन को संभालता है। इसे केवल सकारात्मक संख्याओं को संभालने की आवश्यकता है - लेकिन बोनस अंक यदि यह नकारात्मक और मिश्रित-संकेत विभाजन को संभालता है, तो भी। आंशिक परिणामों के लिए परिणाम नीचे दिए गए हैं।

कार्यक्रम शामिल नहीं हो सकता /, \, divया इसी तरह के ऑपरेटरों। यह एक दिनचर्या होनी चाहिए जो भाषा के मूल विभाजन क्षमताओं का उपयोग नहीं करती है।

आपको केवल 32-बिट डिवीजन को संभालने की आवश्यकता है। दोहराया घटाव का उपयोग करने की अनुमति नहीं है।

इनपुट

नई लाइनों या रिक्त स्थान (आपकी पसंद) से अलग स्टड पर दो इनपुट लें

740 
2

उत्पादन

इस मामले में, आउटपुट होगा 370।

हल जो सबसे कम जीतता है।

code-golf arithmetic division

— थॉमस ओ
स्रोत

है 740,2इनपुट के लिए भी अनुमति? यानी अल्पविराम अलग हो गया?

— gnibbler

"परिणाम भिन्नात्मक परिणामों के लिए गोल किए जाते हैं" - ठीक है, इसलिए जाहिरा तौर पर इनपुट एक गैर-पूर्णांक संख्या में परिणाम कर सकते हैं ... लेकिन भाजक के विभाजन से बड़ा होने के बारे में क्या (कहते हैं, 5 और 10) - क्या इसकी अनुमति है या नहीं?

— ऑरेल बिएल

@gnibber यह ठीक होगा, लेकिन कार्यक्रम विवरण में इसे स्पष्ट करें।

— थॉमस ओ

2

क्या घातीय और अन्य गणित कार्यों का उपयोग करना वास्तव में अनुमति है? वे पर्दे के पीछे विभाजन का उपयोग करते हैं, क्योंकि कई समाधान ab

— Ming

2

यह सबसे कम समय है, लेकिन मैंने किसी को भी कोड

— phuclv

27

पायथन - 73 वर्ण

अल्पविराम से अलग इनपुट लेता है, जैसे 740,2

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

— gnibbler
स्रोत

5

यह, मेरे दोस्त,

— Aamir

"740,2" के लिए आउटपुट 369 है। क्या यह सही है?

— 12

@ इक्सेक्स, होना चाहिए <=, इसे ठीक कर दिया और इसे छोटा कर दिया :)

— gnibbler

14

जावास्क्रिप्ट, 61

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

यह एक स्ट्रिंग को लाभांश ,,,,,,(6) की लंबाई बनाता है और भाजक ,,,(3) पर विभाजित होता है , जिसके परिणामस्वरूप लंबाई 3 की एक सरणी होती है: ['', '', '']जिसकी लंबाई मैं फिर एक से घटाता हूं। निश्चित रूप से सबसे तेज नहीं है, लेकिन उम्मीद है कि दिलचस्प फिर भी!

— केसी चु
स्रोत

2

मेरा पसंदीदा कार्यान्वयन यहाँ अब तक। कूल कोड के लिए बधाई!

— थॉमस एडिंग

मैंने इसे थोड़ा छोटा करने की कोशिश की। A=Array,P=prompt,P((''+A(+P())).split(','+A(+P())).length)

— पिमवेदब ३०'११ को १

10

जावास्क्रिप्ट - 36 वर्ण

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

— कृपया उठो
स्रोत

5

के alertसाथ प्रतिस्थापित करने pसे आपको कुछ अतिरिक्त वर्ण मिलेंगे। :)

— केसी चू

9

गणित: 34 वर्ण

प्रतीकात्मक रूप से समीकरण (xa == b) हल करता है

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

— डॉ। बेलिसरियस
स्रोत

2

23 Solve[x#==#2]&@@Input[]

— चरस

8

पायथन - 72 वर्ण

कॉमा को अलग इनपुट देता है, उदाहरण के लिए 740,2

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

— gnibbler
स्रोत

8

अजगर, ३ 37

चरण 1. यूनीरी में कनवर्ट करें।

चरण 2. यूनिरी विभाजन एल्गोरिथ्म।

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

— boothby
स्रोत

7

पायथन - 41 वर्ण

अल्पविराम से अलग इनपुट लेता है, जैसे 740,2

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

— gnibbler
स्रोत

1

यह, कुछ मामलों में, लगातार घटाना से भी बदतर है। उदाहरण के लिए, इनपुट 5,4 है। जबकि लूप घटाव के मामले में 4 बार चलेगा, हमें केवल एक बार घटाना होगा।

— आमिर

6

अजगर, 70०

कुछ पागल मैं सिर्फ सोचा था (अल्पविराम से अलग इनपुट का उपयोग करके):

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

यदि आप छोटी फ्लोट सटीक त्रुटियों को स्वीकार करते हैं, तो roundफ़ंक्शन को गिराया जा सकता है।

— JBernardo
स्रोत

4

याबसिक - 17 वर्ण

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

— कृपया उठो
स्रोत

3

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;

इनपुट और आउटपुट पिछले एक के समान है।

हां, यह पिछले वाले के आकार से लगभग दोगुना है, लेकिन यह:

भिन्नों को सही ढंग से संभालता है
संकेतों को सही ढंग से संभालता है
कभी भी अनंत लूप में नहीं जाएंगे, UNLESS दूसरा पैरामीटर 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.

— ऑरेल बेली
स्रोत

आपने इसमें एक डिवीजन ऑपरेटर का उपयोग किया है, आप हालांकि थोड़ी बदलाव के साथ दूर हो सकते हैं। ;)

— थॉमस ओ

@ थोमस ओ हां ... मैंने इसे अब देखा ... मैं वास्तव में एक बिट बदलाव के बारे में सोच रहा था (जब मैंने इसे / = 10 के बजाय / = 2 में बदल दिया) - लेकिन यह एक और चार था ... मुझे लगता है ' वैसे भी इसका इस्तेमाल करना होगा ... Btw कि विभाजन बिल्कुल नहीं है: डी।

— ऑरेल बिअल

सवाल कहता है कि आपको स्टड का उपयोग करने की आवश्यकता है, जिसके लिए PHP का समर्थन है।

— केविन ब्राउन

@ बैस 5098 आआह्ह्ह ... ओह वेल, 4 चरस प्राप्त की ... फिक्स्ड।

— ऑरेल बेली

3

रूबी 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

रूबी 1.8 के लिए:

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

— LBG
स्रोत

NoMethodError: निजी पद्धति `विभाजन '69938 के लिए कहा जाता है: Fixnum

— rkj

@rkj, क्षमा करें, रूबी केवल 1.9। रूबी 1.8 पर चलने के लिए आपको ('a'*a+'b').split('a'*b).size-13 अक्षर बड़े करने होंगे।

— एलबग

3

एपीएल (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()))))

— मारीनस
स्रोत

2

PHP, 55 वर्ण

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

आउटपुट (740/2): http://codepad.viper-7.com/ucTlcq

— केविन ब्राउन
स्रोत

44 वर्ण: <?$a=fgetcsv(STDIN);echo$a[0]*pow($a[1],-1);बस संख्याओं को अलग करने के लिए स्थान के बजाय अल्पविराम का उपयोग करें।

— jdstankosky

2

स्काला 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)

— अज्ञात उपयोगकर्ता
स्रोत

2

हास्केल, 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 घटाता है क्योंकि मैं इस तरह की सूची से पहला तत्व ले सकता हूं। अन्य मामले में, मुझे अंतिम लेना होगा, लेकिन अंतिम तत्व को अनंत सूची से लेना कठिन काम है। ठीक है, सूची को परिमित साबित किया जा सकता है, लेकिन फ़िल्टर करते समय हास्केल बेहतर नहीं जानता है, इसलिए यह अनिश्चित काल तक फ़िल्टर करना जारी रखता है।

— थॉमस ईडिंग
स्रोत

2

आम लिस्प, 42 चरखा

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

स्थान या लाइन-पृथक इनपुट स्वीकार करता है

— Strigoides
स्रोत

2

दे घुमा के, 72 64 अक्षर

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

नई संख्याओं की एक अनंत संख्या में आउटपुट करें, पहला x लें, उन सभी को f नामक फ़ाइल में डालें, फिर y के आकार को ब्लॉक में f का आकार प्राप्त करें। आठ पात्रों का मुंडन करने की मैनटवर्क की सलाह ली।

— Hovercouch
स्रोत

के रूप में "नई लाइनों या रिक्त स्थान (अपनी पसंद) द्वारा अलग स्टड पर दो इनपुट ले लो", बेहतर बाद में चुनें, अंतरिक्ष अलग मूल्यों। जिस स्थिति में आप लिख सकते हैं read x y। हटाए गए कुछ और स्थान 64 वर्णों तक कम किए जा सकते हैं: pastebin.com/Y3SfSXWk

— manatwork

1

पायथन - 45 वर्ण

कॉमा को अलग इनपुट देता है, उदाहरण के लिए 740,2

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

— gnibbler
स्रोत

1

पायथन, 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)

— ज्ञापन
स्रोत

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']

क्या मैंने उल्लेख किया कि यह हास्केल का भी उपयोग करता है?

— लंबोदर परी
स्रोत

0

पायथन, 46 बाइट्स

किसी ने उबाऊ घटाव समाधान पोस्ट नहीं किया था, इसलिए मैं इसे करने का विरोध नहीं कर सका।

ए, बी = इनपुट ()
मैं = 0
जबकि a = = b: a- = b; i + = 1
प्रिंट करो मैं

— cemper93
स्रोत

0

स्मॉलटाक , स्क्वीक 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 एमएस मेरे मामूली मैक मिनी पर (8 MOp / s)

नियमित विभाजन की तुलना में:

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

-> 31 एमएस, यह सिर्फ 4 गुना धीमा है

मैं स्टड को पढ़ने या स्टडआउट लिखने के लिए वर्णों की गिनती नहीं करता हूं, स्क्वीक को स्क्रिप्टिंग के लिए डिज़ाइन नहीं किया गया था।

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]

काम भी कर सकता है, लेकिन वास्तव में दिलचस्प नहीं हैं

— aka.nice
स्रोत

0

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

— Jithin
स्रोत

0

डीसी: 26 अक्षर

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

मैं मानता हूं कि यह सबसे तेज समाधान नहीं है।

— Fors
स्रोत

0

अजगर ५४

कॉमा सीमांकित इनपुट लेता है।

लंबाई x के डॉट्स की एक स्ट्रिंग बनाता है
एकल कॉमा के साथ लंबाई y के डॉट्स के खंडों को बदलता है
अल्पविराम गिनता है।

शब्द क्योंकि मार्कडाउन एक सूची के साथ कोड के बाद मर जाता है ?:

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

0

क्यू, ४६

{-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

— tmartin
स्रोत

0

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

— परवेज सोलकर
स्रोत

0

पायथन, 40 अक्षर

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

— fdvfcges
स्रोत

0

अजगर, ३ 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

रेटिना 0.7.3, 33 बाइट्स (प्रतिस्पर्धा नहीं)

भाषा चुनौती से नई है। पहले विभाजक के साथ अंतरिक्ष-पृथक इनपुट लेता है। शून्य से विभाजित अपरिभाषित है।

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

इसे ऑनलाइन आज़माएं

— mbomb007
स्रोत

आप इसे 25 बाइट कैसे गिनेंगे? यदि आप एकात्मक I / O की अपेक्षा करते हैं तो आपको ऐसा कहना चाहिए (और मुझे लगता है कि यह 24 बाइट्स है)। निश्चित नहीं है कि आप 0 केस का अलग से इलाज क्यों करते हैं: retina.tryitonline.net/…

— मार्टिन

इसकी नकल की गई

— mbomb007

विभाजन को लागू करें

पायथन - 73 वर्ण

जावास्क्रिप्ट, 61

जावास्क्रिप्ट - 36 वर्ण

गणित: 34 वर्ण

पायथन - 72 वर्ण

अजगर, ३ 37

पायथन - 41 वर्ण

अजगर, 70०

याबसिक - 17 वर्ण

PHP - 82 अक्षर (छोटी गाड़ी)

PHP - 141 अक्षर (पूर्ण)

रूबी 1.9, 28 वर्ण

एपीएल (6)

PHP, 55 वर्ण

स्काला 77

हास्केल, 96 वर्ण

आम लिस्प, 42 चरखा

दे घुमा के, 72 64 अक्षर

पायथन - 45 वर्ण

पायथन, 94 वर्ण

अजगर, 148

पायथन, 46 बाइट्स

डीसी: 26 अक्षर

अजगर ५४

क्यू, ४६

पायथन, 40 अक्षर

अजगर, ३ 37

रेटिना 0.7.3, 33 बाइट्स (प्रतिस्पर्धा नहीं)