महत्वाकांक्षी सटीक इंटेगर डिवीजन

Question

हम मनमाने ढंग से बड़े पूर्णांकों के लिए विभाजन लागू करेंगे।

यह कोड-गोल्फ है ।

कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो मनमाने ढंग से सटीक पूर्णांकों और उन पर विभाजन लागू करता है।

ध्यान दें कि कई चीजें जो इसे बहुत आसान बना सकती हैं, वे अस्वीकृत हैं, कृपया कल्पना के माध्यम से पढ़ना सुनिश्चित करें ।

इनपुट

आपको इनपुट के रूप में 2 चीजें दी जाएंगी:

1. बेस 10 अंकों की एक स्ट्रिंग, इसे कॉल करें n।
2. बेस 10 अंकों का एक और स्ट्रिंग, इसे कॉल करें m

उसn>m>0 अर्थ को मान लें कि आपको कभी भी शून्य से विभाजित करने के लिए नहीं कहा जाएगा ।

उत्पादन

आप दो नंबर आउटपुट करेंगे, Qऔर Rजहाँ m * Q + R = n और 0 <= R <m

विशेष विवरण

• आपका सबमिशन बड़े पैमाने पर बड़े पूर्णांकों (उपलब्ध मेमोरी द्वारा सीमित) के लिए काम करना चाहिए।

• आप बाहरी पुस्तकालयों का उपयोग नहीं कर सकते हैं। यदि आपको i / o के लिए बाहरी लाइब्रेरी की आवश्यकता है, तो आप इसे बिल्ट-इन के रूप में मान सकते हैं। (iostream, आदि जैसी चीजों को देखते हुए)।

• यदि आपकी भाषा में एक अंतर्निहित है जो इसे तुच्छ बनाता है, तो आप इसका उपयोग नहीं कर सकते हैं । इसमें शामिल हैं (लेकिन यह सीमित नहीं हो सकता है) अंतर्निहित प्रकार जो मनमाने ढंग से सटीक पूर्णांकों को संभाल सकते हैं।

• यदि किसी कारण से कोई भाषा डिफ़ॉल्ट रूप से मनमाने ढंग से सटीक पूर्णांक का उपयोग करती है, तो यह कार्यक्षमता पूर्णांक को दर्शाने के लिए उपयोग नहीं की जा सकती है जो आमतौर पर 64 बिट में संग्रहीत नहीं की जा सकती।

• इनपुट और आउटपुट MUST बेस 10 में होना चाहिए । इससे कोई फर्क नहीं पड़ता कि आप संख्याओं को मेमोरी में कैसे स्टोर करते हैं या आप उन पर अंकगणित कैसे करते हैं, लेकिन मैं / ओ बेस 10 होगा।

• आप एक परिणाम के उत्पादन के लिए 15 सेकंड है। यह पुनरावृत्त घटाव को रोकना है।

• यहाँ लक्ष्य वास्तव में मनमाने ढंग से सटीक पूर्णांकों को लागू करना है। यदि किसी कारण से आप चुनौती के चश्मे का पालन करने में सक्षम हैं और उन्हें लागू किए बिना सफलतापूर्वक ऐसा करते हैं, तो मुझे लगता है कि आपके लिए अच्छा है, मान्य लगता है।

परीक्षण के मामलों

1. इस मामले में, इनपुट 39 हैं! और 30!

इनपुट

n = 20397882081197443358640281739902897356800000000 
m = 265252859812191058636308480000000

उत्पादन

Q = 76899763100160
R = 0

2. n50 तक के सभी भाज्य का योग है, प्लस 1 m20 तक की संख्या है।

इनपुट

n = 31035053229546199656252032972759319953190362094566672920420940313
m = 1234567891011121314151617181920

उत्पादन

q = 25138393324103249083146424239449429
r = 62459510197626865203087816633

3. n205 है! + 200 !. mकितने आँसू पीटरटायलर ने मुझे सैंडबॉक्स में पोस्ट की जाने वाली चीजों को फाड़कर मुझे बहा दिया है।

इनपुट

n = 271841734957981007420619769446411009306983931324177095509044302452019682761900886307931759877838550251114468516268739270368160832305944024022562873534438165159941045492295721222833276717171713647977188671055774220331117951120982666270758190446133158400369433755555593913760141099290463039666313245735358982466993720002701605636609796997120000000000000000000000000000000000000000000000000
m = 247

उत्पादन

q = 1100573825740813795225181252819477770473619155158611722708681386445423816849801159141424129060075102231232666057768175183676764503262931271346408394876267875141461722640873365274628650676808557279259873162169126398101692109801549256156915750794061370041981513180387019893765753438422927286098434193260562682052606153857091520795991080960000000000000000000000000000000000000000000000000
r = 0;

मैं शायद कुछ बिंदु पर अधिक परीक्षण मामलों को जोड़ दूंगा।

सम्बंधित

संबंधित लगता है, लेकिन वास्तव में नहीं है

Comments

क्या IO पुस्तकालयों को बाहरी पुस्तकालयों के रूप में गिना जाता है?

— जॉनसन स्टीवर्ड

@ जॉनसनस्टवर्ड मुझे यकीन नहीं है कि आपका क्या मतलब है? मैं "हाँ" के लिए डिफ़ॉल्ट होगा, लेकिन क्या आप स्पष्ट कर सकते हैं?

— लियाम

@ जॉनसनस्टवर्ड अच्छी तरह से मुझे लगता है कि यह इस पर निर्भर करता है कि आप क्या कर रहे हैं IOing? क्या यह कोड / कोड की एक लाइब्रेरी है?

— अश्विन गुप्ता

क्या नकारात्मक संख्या की अनुमति है?

— TheConstructor

@ नियमक: नियमों से: "मान लें कि n> m> 0", इसलिए नहीं, नकारात्मक संख्याओं की अनुमति नहीं है।

— nimi

Answer 1

पायथन 2, 427 बाइट्स

b=S=lambda l:sorted(l)[::-1]
A=lambda a,b,o=0:A(a^b,{n+1for n in[b&a,b-a][o]},o)if b else a
M=lambda a,*b:reduce(A,({n+m for n in a}for m in b))
def D(a,b):
 q=a-a
 while b<=S(a):n=max(a)-b[0];n-=S(M(b,n))>S(a);q|={n};a=A(a,M(b,n),1)
 return q,a
exec"a=b;b=[]\nfor d in raw_input():b=A(M(b,3,1),{i for i in range(4)if int(d)>>i&1})\n"*2
for n in D(a,S(b)):
 s=''
 while n:n,d=D(n,[3,1]);s=`sum(2**i for i in d)`+s
 print s or 0

एसटीडीआईएन के माध्यम से इनपुट को पढ़ता है, प्रत्येक संख्या एक अलग लाइन पर होती है, और परिणाम को STDOUT में प्रिंट करता है।

व्याख्या

पूर्णांक को अंकों के सरणियों के रूप में दर्शाने के बजाय, हम प्रत्येक पूर्णांक को उसके द्विआधारी प्रतिनिधित्व में "ऑन" बिट्स के सेट के रूप में दर्शाते हैं। यही है, एक पूर्णांक n को बिट्स के सूचकांकों के सेट के रूप में दर्शाया जाता है जो n के बाइनरी प्रतिनिधित्व में 1 के बराबर है । उदाहरण के लिए, बाइनरी में संख्या 10, 1010 को {1, 3} सेट के रूप में दर्शाया गया है। यह प्रतिनिधित्व हमें पायथन के सेट संचालन का उपयोग करते हुए, अंकगणित के कुछ कार्यों को व्यक्त करने की अनुमति देता है।

दो सेटों को जोड़ने के लिए, हम (पुनरावर्ती) उनके सममित अंतर का योग लेते हैं, और पूर्णांक के उत्तराधिकारियों को उनके चौराहे पर ले जाते हैं (जो सामूहिक कैरी से मेल खाता है, और इसलिए अंततः खाली सेट बन जाता है, जिस बिंदु पर हमारे पास अंतिम योग है ।) इसी तरह, दो सेटों को घटाने के लिए, हम (पुनरावर्ती) उनके सममित अंतर का अंतर लेते हैं, और पूर्णांक के सफल होने का सेट उनके (सेट) अंतर (जो सामूहिक उधार से मेल खाता है, और इसलिए अंततः खाली सेट बन जाता है, पर) कौन सा बिंदु हमारे पास अंतिम अंतर है।) इन दो कार्यों की समानता हमें उन्हें एक फ़ंक्शन ( A) के रूप में लागू करने की अनुमति देती है ।

गुणन ( M) बस इसके अलावा वितरित किया जाता है: दो सेट A और B दिए गए , हम योग लेते हैं, जैसा कि ऊपर वर्णित है, सभी सेट { A + b | ख ∈ बी } (जहां एक + ख सेट {है एक + ख | एक ∈ ए })।

अवरोही तुलना दो सेटों की क्रमबद्ध तुलना बन जाती है, जो अवरोही क्रम में क्रमबद्ध होती है।

विभाजित करने के लिए ( D) दो सेट, ए और बी , हम खाली सेट के साथ भागफल के रूप में शुरू करते हैं, और बार-बार सबसे बड़ा पूर्णांक एन पाते हैं , जैसे कि बी + एन ए से कम या बराबर है (जो कि केवल मैक्सिमा के बीच अंतर है) की एक और बी , संभवतः शून्य -1), जोड़ने n भागफल के एक तत्व के रूप में, और घटाना बी + n से एक के रूप में ऊपर वर्णित है, जब तक, एक से भी कम समय हो जाता है बी , अर्थात जब तक यह शेष हो जाता है।

नि: शुल्क दोपहर का भोजन नहीं है, बिल्कुल। हम, और, से, दशमलव में रूपांतरित करके कर का भुगतान करते हैं। वास्तव में, दशमलव में रूपांतरण वह होता है जो अधिकांश रन समय लेता है। हम रूपांतरण "सामान्य तरीका" करते हैं, केवल साधारण अंकगणित के बजाय उपरोक्त संचालन का उपयोग करते हैं।

Comments

जिज्ञासा से बाहर: s=`sum(2**i for i in d)`+sरूपांतरण के दौरान अंतर्निहित मनमाना परिशुद्धता अंकगणित का उपयोग नहीं करता है ?

— TheConstructor

@TheConstructor No. dएक एकल दशमलव अंक है, इसलिए i0 और 3 के बीच है, और पूरी राशि 0 और 9. के बीच है

— Ell

Answer 2

जावा 8, 485 बाइट्स

यदि क्लास-डेफिनिशन को नहीं गिना जा रहा है, तो एक या 16 बाइट्स के dबजाय फ़ंक्शन का नामकरण करने वाले अन्य 5 बाइट्स को कम कर सकते हैं divide।

public class G{int l(String a){return a.length();}String s(String n,String m){while(l(n)>l(m))m=0+m;String a="";for(int c=1,i=l(n);i>0;c=c/10){c=n.charAt(--i)+c-m.charAt(i)+9;a=c%10+a;}return e(a);}String e(String a){return a.replaceAll("^0+(?=[0-9])","");}String divide(String n,String m){String q="",p=q,y;for(int b=0,i=0;b<=l(n);i--){y=n.substring(0,b);if(l(y)==l(p)&&p.compareTo(y)<=0||l(y)>l(p)){y=s(y,p);n=y+n.substring(b);q+=i;b=l(y)+1;i=10;p=m+0;}p=s(p,m);}return e(q)+","+n;}}

इस तरह इस्तेमाल किया जा सकता है:

public static void main(String[] args) {
    G devision = new G();
    System.out.println(devision.divide("20397882081197443358640281739902897356800000000",
            "265252859812191058636308480000000"));
    System.out.println(devision.divide("31035053229546199656252032972759319953190362094566672920420940313",
            "1234567891011121314151617181920"));
    System.out.println(devision.divide(
            "271841734957981007420619769446411009306983931324177095509044302452019682761900886307931759877838550251114468516268739270368160832305944024022562873534438165159941045492295721222833276717171713647977188671055774220331117951120982666270758190446133158400369433755555593913760141099290463039666313245735358982466993720002701605636609796997120000000000000000000000000000000000000000000000000",
            "247"));
}

उपज

76899763100160,0
25138393324103249083146424239449429,62459510197626865203087816633
1100573825740813795225181252819477770473619155158611722708681386445423816849801159141424129060075102231232666057768175183676764503262931271346408394876267875141461722640873365274628650676808557279259873162169126398101692109801549256156915750794061370041981513180387019893765753438422927286098434193260562682052606153857091520795991080960000000000000000000000000000000000000000000000000,0

Ungolfed:

public class ArbitraryPrecisionDivision {

    /**
     * Length of String
     */
    int l(String a) {
        return a.length();
    }

    /**
     * substract m of n; n >= m
     */
    String s(String n, String m) {
        while (l(n) > l(m))
            m = 0 + m;
        String a = "";
        for (int c = 1, i = l(n); i > 0; c = c / 10) {
            c = n.charAt(--i) + c - m.charAt(i) + 9;
            a = c % 10 + a;
        }
        return e(a);
    }

    /**
     * trim all leading 0s
     */
    String e(String a) {
        return a.replaceAll("^0+(?=[0-9])", "");
    }

    /**
     * divide n by m returning n/m,n%m; m may not start with a 0!
     */
    String divide(String n, String m) {
        // q stores the quotient, p stores m*i, y are the b leading digits of n
        String q = "", p = q, y;
        for (int b = 0, i = 0; b <= l(n); i--) {
            y = n.substring(0, b);
            if (l(y) == l(p) && p.compareTo(y) <= 0 || l(y) > l(p)) {
                y = s(y, p);
                n = y + n.substring(b);
                q += i;
                b = l(y) + 1;
                i = 10;
                p = m + 0;
            }
            p = s(p, m);
        }
        return e(q) + "," + n;
    }

    public static void main(String[] args) {
        ArbitraryPrecisionDivision division = new ArbitraryPrecisionDivision();
        System.out.println(division.divide("20397882081197443358640281739902897356800000000",
                "265252859812191058636308480000000"));
        System.out.println(division.divide("31035053229546199656252032972759319953190362094566672920420940313",
                "1234567891011121314151617181920"));
        System.out.println(division.divide(
                "271841734957981007420619769446411009306983931324177095509044302452019682761900886307931759877838550251114468516268739270368160832305944024022562873534438165159941045492295721222833276717171713647977188671055774220331117951120982666270758190446133158400369433755555593913760141099290463039666313245735358982466993720002701605636609796997120000000000000000000000000000000000000000000000000",
                "247"));
    }
}

मैंने m9 के माध्यम से 1 बार के साथ एक सरणी का पूर्वसूचक न करके और b=0इसके बजाय के साथ शुरू करके थोड़ा गति का त्याग किया b=l(m), लेकिन बहुत सारे बाइट्स को ऐसा करने से बचाया। यदि आप मनमाना सटीक जोड़ में रुचि रखते हैं तो पिछला संस्करण देखें ।

मुझे लगता है कि यह सबसे छोटा समाधान नहीं होगा, लेकिन शायद यह एक अच्छी शुरुआत देता है।

Comments

यदि आप इसके अलावा इसके लिए गुणा, गुणा और घटाव लागू करते हैं, तो मैं इसके लिए एक 500 प्रतिनिधि इनाम दूंगा। : DI को स्ट्रींग प्रिसिजन के विचार से प्यार है।

— Addison Crump

@VoteToClose इसे कल देखेगी। लगता है सबसे कठिन हिस्सा किया जाता है।

— theConstructor

Answer 3

गणितज्ञ, 251 बाइट्स

r=Reverse;f=FoldPairList;s={0}~Join~#&;
p[a_,b_]:={First@#,#[[2,1,-1,2]]}/.{Longest[0..],x__}:>{x}&@Reap@f[Sow@{Length@#-1,Last@#}&@NestWhileList[r@f[{#~Mod~10,⌊#/10⌋}&[#+Subtract@@#2]&,0,r@Thread@{#,s@b}]&,Rest@#~Join~{#2},Order[#,s@b]<=0&]&,0s@b,s@a]

---

व्याख्या

दशमलव संख्याओं पर अंकगणित आसानी से लागू किया जा सकता है FoldPairList। उदाहरण के लिए,

times[lint_,m_]:=Reverse@FoldPairList[{#~Mod~10,⌊#/10⌋}&[m #2+#]&,0,Reverse@lint]

सिर्फ हाथ से गुणा करने की प्रक्रिया की नकल करता है।

times[{1,2,3,4,5},8]
(* {9,8,7,6,0} *)

---

परीक्षण का मामला

p[{1,2,3,4,5,6,7,8,9},{5,4,3,2,1}] 
(* {{2,2,7,2},{3,9,4,7,7}} *)

का मतलब है 123456789 / 54321= 2272...39477।