স্বেচ্ছাসেবী যথার্থ পূর্ণসংখ্যা বিভাগ

আমরা নির্বিচারে বড় পূর্ণসংখ্যার জন্য বিভাগ বাস্তবায়ন করব।

কাজটি হ'ল একটি প্রোগ্রাম বা ফাংশন লিখুন যা তাদের উপর নির্বিচারে নির্ভুলতা পূর্ণসংখ্যা এবং বিভাগ প্রয়োগ করে।

মনে রাখবেন যে এটিকে খুব সহজ করে তুলতে পারে এমন অনেকগুলি জিনিসকে নিষিদ্ধ করা হয়েছে, অনুগ্রহ করে অনুমানের মাধ্যমে পড়তে ভুলবেন না ।

ইনপুট

আপনাকে ইনপুট হিসাবে দুটি জিনিস দেওয়া হবে:

বেস 10 সংখ্যার একটি স্ট্রিং, এটিকে কল করুন n।
বেস 10 ডিজিটের আর একটি স্ট্রিং, এটি কল করুন m

এরn>m>0 অর্থ ধরুন যে আপনাকে কখনই শূন্য দ্বারা ভাগ করতে বলা হবে না ।

আউটপুট

আপনি দুটি সংখ্যা আউটপুট পাবেন Qএবং Rযেখানে এম * কিউ + আর = এন এবং 0 <= আর <মি

বিশেষ উল্লেখ

আপনার জমা দিতে ইচ্ছামত বৃহত পূর্ণসংখ্যার (উপলব্ধ মেমরি দ্বারা সীমাবদ্ধ) কাজ করা উচিত।
আপনি বহিঃস্থ গ্রন্থাগার ব্যবহার নাও করতে পারেন। আপনার যদি i / o এর জন্য একটি বাহ্যিক গ্রন্থাগার প্রয়োজন হয় তবে আপনি এটি একটি অন্তর্নির্মিত হিসাবে বিবেচনা করতে পারেন। (iostream ইত্যাদির মতো জিনিসগুলির দিকে তাকানো)।
আপনার ভাষার যদি অন্তর্নির্মিত অন্তর্ভুক্ত থাকে যা এটিকে তুচ্ছ করে তোলে, আপনি এটি ব্যবহার করতে পারবেন না । এর মধ্যে অন্তর্নির্মিত নির্ভুলতা পূর্ণসংখ্যাকে পরিচালনা করতে পারে এমন বিল্ট-ইন প্রকারগুলি (তবে সীমাবদ্ধ নয়) includes
কোনও কারণে যদি কোনও ভাষা ডিফল্টরূপে নির্বিচারে নির্ভুলতা পূর্ণসংখ্যার ব্যবহার করে, তবে এই কার্যকারিতাটি পূর্ণসংখ্যার প্রতিনিধিত্ব করতে ব্যবহার করা যাবে না যা সাধারণত b৪ বিটে সংরক্ষণ করা যায় না।
ইনপুট এবং আউটপুট 10 বেসে থাকা আবশ্যক । আপনি কীভাবে সংখ্যাগুলিকে মেমরিতে সঞ্চয় করেন বা কীভাবে আপনি গাণিতিক সম্পাদন করেন তা বিবেচ্য নয়, তবে i / o বেস 10 হবে।
ফলাফল আউটপুট করার জন্য আপনার 15 সেকেন্ড রয়েছে । এটি পুনরাবৃত্ত বিয়োগফল নিষিদ্ধ করা।
এখানে লক্ষ্যটি হ'ল স্বেচ্ছাচারিত নির্ভুলতা পূর্ণসংখ্যার বাস্তবায়ন করা। যদি কোনও কারণে আপনি চ্যালেঞ্জের চশমাগুলিকে মেনে চলতে সক্ষম হন এবং সেগুলি বাস্তবায়ন না করে সফলভাবে এটি করতে পারেন, তবে আমি আপনার পক্ষে ভাল অনুমান করি, এটি বৈধ বলে মনে হচ্ছে।

পরীক্ষার কেস

এই ক্ষেত্রে, ইনপুট 39! এবং 30!

ইনপুট

n = 20397882081197443358640281739902897356800000000 
m = 265252859812191058636308480000000

আউটপুট

Q = 76899763100160
R = 0

n50 পর্যন্ত সমস্ত ফ্যাকটোরিয়ালগুলির যোগফল, এবং 1 টি m20 অবধি সংক্ষিপ্ত সংখ্যা হয়।

ইনপুট

n = 31035053229546199656252032972759319953190362094566672920420940313
m = 1234567891011121314151617181920

আউটপুট

q = 25138393324103249083146424239449429
r = 62459510197626865203087816633

n205 হয়! + 200 !. mস্যান্ডবক্সে পোস্ট করা জিনিস ছিঁড়ে ফেলে পিটারটেলর আমাকে কত অশ্রু বর্ষণ করেছে।

ইনপুট

n = 271841734957981007420619769446411009306983931324177095509044302452019682761900886307931759877838550251114468516268739270368160832305944024022562873534438165159941045492295721222833276717171713647977188671055774220331117951120982666270758190446133158400369433755555593913760141099290463039666313245735358982466993720002701605636609796997120000000000000000000000000000000000000000000000000
m = 247

আউটপুট

q = 1100573825740813795225181252819477770473619155158611722708681386445423816849801159141424129060075102231232666057768175183676764503262931271346408394876267875141461722640873365274628650676808557279259873162169126398101692109801549256156915750794061370041981513180387019893765753438422927286098434193260562682052606153857091520795991080960000000000000000000000000000000000000000000000000
r = 0;

আমি সম্ভবত এক পর্যায়ে আরও পরীক্ষার কেস যুক্ত করব।

সম্পর্কিত

সম্পর্কিত শব্দগুলি, কিন্তু আসলে তা নয়

code-golf arithmetic

— লিয়াম
সূত্র

আইও লাইব্রেরিগুলি কি বাহ্যিক গ্রন্থাগার হিসাবে গণনা করে?

— জনসন স্টুয়ার্ড

@ জনসনস্টওয়ার্ড আমি নিশ্চিত না যে আপনি এর দ্বারা কী বোঝাতে চেয়েছেন? আমি ডিফল্ট "হ্যাঁ" করতে চাই, তবে আপনি কি স্পষ্ট করে বলতে পারেন?

— লিয়াম

@ জনসনস্টওয়ার্ড ভালভাবে অনুমান করুন আপনি এটি যা করছেন তার উপর নির্ভর করে? এটি কি কোড / কোডের একটি লাইব্রেরী?

— আশ্বিন গুপ্ত

নেতিবাচক সংখ্যা অনুমোদিত?

— দ্য কনস্ট্রাক্টর

@ দ্য কনস্ট্রাক্টর: নিয়ম থেকে: "ধরে নিন যে এন> এম> 0", সুতরাং না, নেতিবাচক সংখ্যার অনুমতি নেই।

— নিমি

উত্তর:

পাইথন 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

STDIN এর মাধ্যমে ইনপুট পড়বে, প্রতিটি সংখ্যা পৃথক লাইনে, এবং ফলাফলটি STDOUT এ মুদ্রণ করে।

ব্যাখ্যা

সংখ্যার অ্যারে হিসাবে পূর্ণসংখ্যাকে উপস্থাপন করার পরিবর্তে, আমরা প্রতিটি পূর্ণসংখ্যাকে এর বাইনারি উপস্থাপনায় "অন" বিটের সেট হিসাবে প্রতিনিধিত্ব করি। অর্থাৎ, একটি পূর্ণসংখ্যা n বিটের সূচকগুলির সেট হিসাবে প্রতিনিধিত্ব করে যা এন এর বাইনারি উপস্থাপনায় 1 সমান । উদাহরণস্বরূপ, বাইনারিতে 10, 1010 সংখ্যাটি সেট {1, 3 as হিসাবে উপস্থাপিত হয়} এই উপস্থাপনাটি পাইথনের সেট ক্রিয়াকলাপগুলি ব্যবহার করে সংক্ষেপে কিছু গাণিতিক ক্রিয়াকলাপগুলি প্রকাশ করার অনুমতি দেয়।

দুটি সেট যুক্ত করার জন্য, আমরা (পুনরাবৃত্তভাবে) তাদের প্রতিসাম্যগত পার্থক্যের যোগফল এবং তাদের আন্তঃসংযোগে উত্তরসূরি পূর্ণসংখ্যার সেটটি গ্রহণ করি (যা সমষ্টিগত বাহনের সাথে মিলিত হয় এবং ফলস্বরূপ খালি সেট হয়ে যায়, যার শেষে আমাদের চূড়ান্ত যোগফল থাকে) ।) একইভাবে, দুটি সেট বিয়োগ করতে, আমরা (পুনরাবৃত্ত্বে) তাদের প্রতিসাম্য পার্থক্য এবং তাদের (সেট) পার্থক্যটির উত্তরসূরি পূর্ণসংখ্যার সেটটি গ্রহণ করি (যা সমষ্টিগত orrowণের সাথে সামঞ্জস্য করে এবং অবশেষে খালি সেট হয়ে যায়) আমাদের চূড়ান্ত পার্থক্যের কোন বিন্দু রয়েছে)) এই দুটি অপারেশনের সাদৃশ্য আমাদের এগুলিকে একক ফাংশন হিসাবে প্রয়োগ করতে পারে ( A)।

গুণন ( M) কেবল সংযোজন বিতরণ করা হয়: দুটি সেট A এবং B দেওয়া হলে , আমরা সমস্ত সেটগুলির উপরে বর্ণিত হিসাবে যোগফল গ্রহণ করি { A + b | b ∈ B } (যেখানে A + b সেট { a + b | a ∈ A })।

পূর্ণসংখ্যার তুলনা দুটি সেটের ডিক্সিকোগ্রাফিক তুলনা হয়ে ওঠে, অবতরণ অনুসারে সাজানো।

বিভক্ত করা ( D) দুটি সেট, একটি এবং বি , আমরা ভাগফল হিসেবে খালি সেট দিয়ে শুরু, এবং বারবার বৃহত্তম পূর্ণসংখ্যা এটি এন , যেমন যে বি + N কম বা সমান একটি (যা কেবল ম্যাক্সিমা মধ্যে পার্থক্য এর একটি এবং বি , সম্ভবত বিয়োগ-1), অ্যাড এন ভাগফল একটি উপাদান হিসেবে এবং বিয়োগ বি + N থেকে একজন , যেমন উপরে বর্ণিত পর্যন্ত একজন কম হয়ে বি , অর্থাত পর্যন্ত এটি বাকি হয়ে যায়।

অবশ্যই নিখরচায় দুপুরের খাবার নেই। আমরা দশমিক থেকে এবং, থেকে রূপান্তর করে কর প্রদান করি। আসলে, দশমিক রূপান্তরটি হ'ল বেশিরভাগ রান সময় লাগে। আমরা সাধারণ গাণিতিকের পরিবর্তে কেবল উপরের ক্রিয়াকলাপগুলি ব্যবহার করে "সাধারণ উপায়" রূপান্তর করি।

— উপগৃহ
সূত্র

কৌতূহলের বাইরে: s=`sum(2**i for i in d)`+sরূপান্তরকালে অভ্যন্তরীণ স্বেচ্ছাচারিত নির্ভুলতা গাণিতিক ব্যবহার করে না ?

— দ্য কনস্ট্রাক্টর

@TheConstructor সংখ্যা dএকটি একক দশমিক অঙ্ক, তাই i0 এবং 3 এর মধ্যে, এবং পুরো সমষ্টি 0 এবং 9. মধ্যে

— Ell

জাভা 8, 485 বাইট

ফাংশনটির নামকরণ করে আরও 5 টি বাইট হ্রাস করতে পারে d পরিবর্তে divideবা অন্য 16 বাইট বেড়ে চলেছে শ্রেণী-সংজ্ঞা না পারেন।

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

আমি m1 থেকে 9 বারের সাথে কোনও অ্যারের প্রাক্কলকুলেশন না করে এবং এর b=0পরিবর্তে শুরু করে কিছুটা গতি ত্যাগ করেছিb=l(m) , তবে প্রচুর বাইট সংরক্ষণ করে। আপনি যদি স্বেচ্ছাচারিত নির্ভুল সংযোজন করতে আগ্রহী হন তবে পূর্ববর্তী সংস্করণটি দেখুন ।

আমার ধারণা এটি সবচেয়ে সংক্ষিপ্ত সমাধান হবে না তবে সম্ভবত এটি একটি ভাল সূচনা দেয়।

— TheConstructor
সূত্র

আপনি যদি এর জন্য যোগ, গুণ এবং বিয়োগফলও প্রয়োগ করেন তবে আমি এটির জন্য 500 রেপ বন্টি করব। : ডিআই স্ট্রিংয়ের নির্ভুলতার ধারণা পছন্দ করে।

— অ্যাডিসন ক্রম্প

@ ভোটটোক্লোজ আগামীকাল এটি দেখতে পাবে। অনুমান করুন যে হার্ড অংশটি সম্পন্ন হয়েছে।

— দ্য কনস্ট্রাক্টর

গণিত, 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।

— njpipeorgan
সূত্র