जावास्क्रिप्ट में शेष के साथ पूर्णांक विभाजन?

Question

में जावास्क्रिप्ट , मैं कैसे मिलता है:

1. किसी दिए गए पूर्णांक की पूरी संख्या कितनी बार दूसरे में जाती है?
2. शेष?

Answer 1

कुछ संख्या yऔर कुछ भाजक के xलिए भागफल ( quotient) और शेष ( remainder) की गणना करें :

var quotient = Math.floor(y/x);
var remainder = y % x;

Comments

% जावास्क्रिप्ट में फ्लोट पर काम करता है (यह कई अन्य भाषाओं से अलग है), जो शायद वांछित नहीं है: 3.5 % 21.5 का मूल्यांकन करता है। आवश्यकतानुसार संभालना (पार्सइंट, फ्लोर इत्यादि) सुनिश्चित करें

गणित में -4.5 का अभिन्न अंग -5 है, क्योंकि -5 "उच्चतम संभव अभिन्न संख्या है जो अभी भी -4.5 से कम है"।

— कठिन

हालांकि, जो भी आप नकारात्मक संख्याओं के बारे में करने का निर्णय लेते हैं, यह भागफल और शेष के अनुरूप होना चाहिए। का उपयोग करना floorऔर %एक साथ उस तरह से संगत नहीं है। या तो उपयोग ( truncइसके बजाय floorनकारात्मक अवशेषों को अनुमति देने के लिए) या शेष ( rem = y - div * x) पाने के लिए घटाव का उपयोग करें ।

— मार्क रीड

1. यदि आप remवैसे भी शेष की गणना करने जा रहे हैं , तो आप divबिना फर्श के तेजी से भागफल प्राप्त कर सकते हैं (y - rem) / x:। 2. जिस तरह से डोनाल्ड नूथ की अनुशंसित परिभाषा (साइन-मैच-डिवाइडर, न कि शेष यानी यूक्लिडियन मापांक, और न ही जावास्क्रिप्ट साइन-मैच-डिविडेंड) द्वारा मॉडुलो ऑपरेशन, जिसे हम जावास्क्रिप्ट के रूप में कोड कर सकते हैं function mod (a, n) { return a % n + (Math.sign(a) !== Math.sign(n) ? n : 0); }।

— हारून मैंसिम

-9 / 2 = -4.5। आप फिर -4.5 की मंजिल लेते हैं, जो कि -5 है। याद रखें कि -5, -4.5 से कम है, और फर्श का संचालन किसी दिए गए मूल्य से कम के सबसे बड़े पूर्णांक के रूप में परिभाषित किया गया है।

— मार्क रीड

Answer 2

मैं बिटवाइज़ ऑपरेटरों में कोई विशेषज्ञ नहीं हूँ, लेकिन यहाँ पूरी संख्या पाने का एक और तरीका है:

var num = ~~(a / b);

यह नकारात्मक संख्याओं के लिए ठीक से काम करेगा, जबकि Math.floor()गलत दिशा में गोल होगा।

यह सही लगता है:

var num = (a / b) >> 0;

Comments

एक और, जिसका उद्देश्य मैंने केवल अंतिम 20 मिनट बिताए, यह जानने की कोशिश कर रहा है, यह स्पष्ट रूप से हैa/b | 0

— ब्लूराजा - डैनी पफ्लुगुएफ्ट

@ user113716 @BlueRaja बिटवाइज ऑपरेशन केवल पूर्णांक-प्रकारों पर ही समझ में आता है और JS (बेशक) यह जानता है। ~~int, int | 0और int >> 0प्रारंभिक तर्क को संशोधित नहीं करता है, लेकिन दुभाषिया पास ऑपरेटर को अभिन्न अंग बनाते हैं।

— अलेक्सी ज़ब्रोद्सकी

floorशायद ही कभी गलत दिशा में गोल किया जाता है, इसका नाम दिया गया है - बस वह दिशा नहीं जो लोग आमतौर पर चाहते हैं!

— मार्क के कोवान

वह बु बु है। a = 12447132275286670000; b = 128 Math.floor(a/b)-> 97243220900677100और ~~(a/b)-> -1231452688।

— मिरेक रुसिन

पूर्वता से सावधान रहें। ~~(5/2) --> 2जैसा करता है (5/2)>>0 --> 2, लेकिन ~~(5/2) + 1 --> 3, जबकि ~~(5/2)>>0 + 1 --> 1। ~~एक अच्छा विकल्प है क्योंकि पूर्वता अधिक उपयुक्त है।

— टाइमके

Answer 3

मैंने फ़ायरफ़ॉक्स पर कुछ स्पीड टेस्ट किए।

-100/3             // -33.33..., 0.3663 millisec
Math.floor(-100/3) // -34,       0.5016 millisec
~~(-100/3)         // -33,       0.3619 millisec
(-100/3>>0)        // -33,       0.3632 millisec
(-100/3|0)         // -33,       0.3856 millisec
(-100-(-100%3))/3  // -33,       0.3591 millisec

/* a=-100, b=3 */
a/b                // -33.33..., 0.4863 millisec
Math.floor(a/b)    // -34,       0.6019 millisec
~~(a/b)            // -33,       0.5148 millisec
(a/b>>0)           // -33,       0.5048 millisec
(a/b|0)            // -33,       0.5078 millisec
(a-(a%b))/b        // -33,       0.6649 millisec

उपरोक्त प्रत्येक के लिए 10 मिलियन परीक्षणों पर आधारित है।

निष्कर्ष: उपयोग (a/b>>0)(या (~~(a/b))या (a/b|0)) दक्षता में% लाभ 20 के बारे में प्राप्त करने के लिए। यह भी ध्यान रखें कि वे सभी असंगत हैं Math.floor, जब a/b<0 && a%b!=0।

Comments

ध्यान दें कि गति के लिए पूर्णांक विभाजन का अनुकूलन केवल तभी समझ में आएगा जब आप इसे बहुत अधिक कर रहे हों । किसी भी अन्य मामले में मैं सबसे सरल एक (जो भी आपको और आपके सहकर्मियों को सबसे सरल लगता है) चुनने की सलाह देगा।

— मिकूज

@ m01 पूरी तरह से सहमत हैं - इस तरह से ऑनलाइन सामान पर बहुत अधिक ध्यान देने का तरीका है

— जॉनी राए

@ m01 लेकिन जो कठिन है: सीखने के बारे में Math.floorऔर जो जानता है कि कैसे-कैसे कई अन्य एपीआई कार्य करता है, या ~( बिट-वाइज नहीं) ऑपरेटर और कैसे बिटवाइज़ संचालन जेएस में काम करता है और फिर डबल टिल्ड के प्रभाव को समझ रहा है?

— स्टिजेन डी विट २

ठीक है, अगर आपके सहकर्मी कोडांतरक में चिप्स को प्रोग्रामिंग नहीं कर रहे हैं, तो वे संभवतः Math.floorबेहतर समझ पाएंगे । और अगर नहीं भी है, तो भी यह एक देखने योग्य है।

— मिकूज

@MarkGreen हाँ, लेकिन सिर्फ यह करना चाहते हैं कि इसका मतलब यह नहीं है कि आपको इसे एक अजीब रूप में लिखना चाहिए, क्योंकि यह सबसे तेज़ होता है, बिना अच्छे कारण के - कोड स्पष्टता सामान्य रूप से आपकी पहली चिंता होनी चाहिए। भाषा परिवर्तन और विभिन्न ब्राउज़रों के बाद भी ये परीक्षण पूरी तरह से निरर्थक हो सकते हैं - आपको यह जानने के लिए प्रोफ़ाइल की आवश्यकता होगी कि आपके आवेदन में क्या धीमा है। जब तक आप पहले से ही किसी अन्य चीज को अनुकूलित नहीं करते हैं, तब तक यह आपके पूर्णांक विभाजन की विधि होने की संभावना नहीं है!

— जोनिरा सेप

Answer 4

ईएस 6 नई Math.truncविधि का परिचय देता है । यह @ MarkElliot के उत्तर को ठीक करने की अनुमति देता है ताकि वह नकारात्मक संख्याओं के लिए भी काम कर सके:

var div = Math.trunc(y/x);
var rem = y % x;

ध्यान दें कि Mathबिटवाइज़ ऑपरेटर्स के पास तरीकों का फायदा है कि वे 2 ³¹ से अधिक की संख्या के साथ काम करते हैं ।

Comments

var y = 18014398509481984; var x = 5; div =? - बग?

— 4esn0k

@ 4esn0k यह बग नहीं है। आपके नंबर में बहुत अधिक अंक हैं, आप 64-बिट बाइनरी प्रारूप IEEE 754 नंबर में इतना सटीक नहीं हो सकते। उदाहरण के लिए, 18014398509481984 == 18014398509481985।

— ओरिऑल

18014398509481984 == 2 ** 54, और मैंने विशेष रूप से इस संख्या का उपयोग किया, क्योंकि यह बाइनरी 64 प्रारूप में बिल्कुल प्रतिनिधित्व किया गया है। और इसका उत्तर ठीक-ठीक दर्शाया गया है

— 4esn0k

मुझे लगता है कि विकल्प सरल है: आपको हस्ताक्षर किए गए 32 बिट्स तक की संख्या के लिए समर्थन की आवश्यकता है? का उपयोग करें ~~(x/y)। हस्ताक्षर किए गए 54 बिट तक बड़ी संख्या का समर्थन करने की आवश्यकता है? उपयोग Math.truncतुम्हारे पास है, या अगर Math.floorनहीं तो (ऋणात्मक संख्याओं के लिए सही)। और भी बड़ी संख्या में समर्थन की आवश्यकता है? कुछ बड़ी संख्या में पुस्तकालय का उपयोग करें।

— Stijn de Witt

रूबीवादियों की तलाश में यहाँ से divmod, आप इसे इस प्रकार लागू कर सकते हैं:function divmod(x, y) { var div = Math.trunc(x/y); var rem = x % y; return [div, rem]; }

— एलेक्स मूर-नीमी

Answer 5

var remainder = x % y;
return (x - remainder) / y;

Comments

यह संस्करण दुर्भाग्य से परीक्षण में विफल रहता है जब x = -100 क्योंकि यह -33 के बजाय -34 देता है।

— सैमुअल

"var x = 0.3; var y = 0.01?" के बारे में क्या ? ( github.com/JuliaLang/julia/issues/4156#issuecomment-23324163 पर धन्यवाद )

— 4esn0k

दरअसल, @ शमूएल, नकारात्मक मूल्यों के साथ, यह विधि सही परिणाम लौटाती है, या कम से कम यह उसी मान को लौटाती है जो विधि Math.trunc:) का उपयोग कर रही है । मैंने 100,3 के साथ जाँच की; -100,3; 100, -3 और -100, -3। बेशक, आपकी टिप्पणी और चीजें बदलने में बहुत समय बीत चुका है।

— मार्जन वेनेमा

Answer 6

मैं सामान्य रूप से उपयोग करता हूं:

const quotient =  (a - a % b) / b;
const remainder = a % b;

यह शायद सबसे सुरुचिपूर्ण नहीं है, लेकिन यह काम करता है।

Comments

अच्छा समाधान क्योंकि यह एक फ्लोट को पार्स या ट्रंकिंग की बदसूरती से बचाता है।

— डेम पिलाफियन

यदि आपको भागफल और शेष दोनों की आवश्यकता है, तो पहले शेष की गणना करें और फिर भागफल के लिए अभिव्यक्ति में उस मूल्य का पुन: उपयोग करें, अर्थात भागफल = (a - शेष) / b;

— gb96

शेष = एक% बी; भागफल = (a - शेष) / b;

— Zv_oDD

Answer 7

आप parseIntफटे हुए परिणाम प्राप्त करने के लिए फ़ंक्शन का उपयोग कर सकते हैं ।

parseInt(a/b)

एक शेष पाने के लिए, मॉड ऑपरेटर का उपयोग करें:

a%b

parseInt में स्ट्रिंग्स के साथ कुछ नुकसान हैं, बेस 10 के साथ रेडिक्स पैरामीटर का उपयोग करने से बचें

parseInt("09", 10)

कुछ मामलों में संख्या का स्ट्रिंग प्रतिनिधित्व एक वैज्ञानिक संकेतन हो सकता है, इस मामले में, parseInt गलत परिणाम देगा।

parseInt(100000000000000000000000000000000, 10) // 1e+32

यह कॉल परिणाम के रूप में 1 का उत्पादन करेगा।

Comments

parseIntजब संभव हो तो बचना चाहिए। यहां डगलस क्रॉफोर्ड की चेतावनी है: "यदि स्ट्रिंग का पहला वर्ण 0 है, तो स्ट्रिंग का आधार 8 के बजाय बेस 8 में मूल्यांकन किया जाता है। बेस 8, 8 और 9 में अंक नहीं हैं, इसलिए parseInt (" 08 ") और parseInt ("09") उनके परिणाम के रूप में 0 का उत्पादन करता है। यह त्रुटि उन कार्यक्रमों में समस्याओं का कारण बनती है जो दिनांक और समय को पार्स करते हैं। सौभाग्य से, parseInt एक मूलांक पैरामीटर ले सकता है, जिससे कि parseInt ("08", 10) 8 का उत्पादन करता है। मैं अनुशंसा करता हूं कि हमेशा मूलांक पैरामीटर प्रदान करें। " आर्काइव .oreilly.com

— शक्तियां

एक विभाजन में, मैं एक स्ट्रिंग नहीं, बल्कि एक संख्या प्राप्त करने की अपेक्षा करता हूं, लेकिन यह एक अच्छा बिंदु है।

— दिपो कोस्टा रेबुकास

@ पॉवर्स तो मूलांक जोड़ते हैं। वह कहता है कि parseIntइससे बचना चाहिए; बस इतना है कि वहाँ कुछ getchas के बारे में पता कर रहे हैं। आपको इन बातों के बारे में पता होना चाहिए और सामना करने के लिए तैयार रहना चाहिए।

— कोई नहीं

कभी भी parseIntएक नंबर की दलील के साथ फोन न करें । parseIntआंशिक रूप से संख्यात्मक स्ट्रिंग को पार्स करने के लिए माना जाता है, न कि संख्याओं को कम करने के लिए।

— उड़ियाल

सिर्फ इसलिए कि चीजें मूल रूप से एक निश्चित तरीके से उपयोग नहीं की जाती हैं, इसका मतलब यह नहीं है कि आपको नहीं करना चाहिए। यह उत्तर काम करता है।

— फ्रीगर्ल

Answer 8

जावास्क्रिप्ट उनके लिए गणितीय परिभाषाओं का पालन करते हुए, नकारात्मक संख्याओं के तल और गैर-पूर्णांक संख्याओं के शेष की सही गणना करता है।

FLOOR को "पैरामीटर से छोटा सबसे बड़ा पूर्णांक संख्या" के रूप में परिभाषित किया गया है, इस प्रकार:

• सकारात्मक संख्या: FLOOR (X) = X का पूर्णांक भाग;
• ऋणात्मक संख्या: FLOOR (X) = X ऋण 1 का पूर्णांक भाग (क्योंकि यह पैरामीटर की तुलना में छोटा होना चाहिए, अर्थात अधिक नकारात्मक!)

रिमाइंडर को एक डिवीजन (यूक्लिडियन अंकगणित) के "बाएं ओवर" के रूप में परिभाषित किया गया है। जब लाभांश पूर्णांक नहीं होता है, तो भागफल आमतौर पर पूर्णांक भी नहीं होता है, अर्थात, शेष नहीं है, लेकिन यदि भागफल को पूर्णांक बनने के लिए मजबूर किया जाता है (और ऐसा तब होता है जब कोई व्यक्ति शेष या मापांक प्राप्त करने की कोशिश करता है। फ्लोटिंग-पॉइंट नंबर), एक गैर-पूर्णांक "बचे हुए ओवर" होगा, जाहिर है।

जावास्क्रिप्ट उम्मीद के अनुसार सब कुछ की गणना करता है, इसलिए प्रोग्रामर को उचित प्रश्न पूछने के लिए सावधान रहना चाहिए (और लोगों को जवाब देने के लिए सावधानी बरतनी चाहिए!) यारिन का पहला सवाल "वाई द्वारा एक्स का पूर्णांक विभाजन नहीं था", लेकिन, इसके बजाय, "किसी दिए गए पूर्णांक की दूसरी संख्या कितनी बार होती है"। सकारात्मक संख्याओं के लिए, उत्तर दोनों के लिए समान है, लेकिन नकारात्मक संख्याओं के लिए नहीं, क्योंकि पूर्णांक विभाजन (भाजक द्वारा लाभांश) संख्या (भाजक) की तुलना में -1 छोटा होगा "जो" दूसरे (लाभांश) में जाता है। दूसरे शब्दों में, FLOOR एक ऋणात्मक संख्या के पूर्णांक विभाजन के लिए सही उत्तर देगा, लेकिन यारिन ने यह नहीं पूछा!

गैमैक्स ने सही उत्तर दिया, वह कोड यारिन द्वारा पूछे गए अनुसार काम करता है। दूसरी ओर, शमूएल गलत है, उसने गणित नहीं किया, मुझे लगता है, या उसने देखा होगा कि यह काम करता है (यह भी, उसने यह नहीं कहा कि उसके उदाहरण का विभाजक क्या था, लेकिन मुझे उम्मीद है कि यह होगा) 3):

शेष = X% Y = -100% 3 = -1

GoesInto = (X - शेष) / Y = (-100 - -1) / 3 = -99 / 3 = -33

वैसे, मैंने फ़ायरफ़ॉक्स 27.0.1 पर कोड का परीक्षण किया, यह उम्मीद के मुताबिक काम किया, सकारात्मक और नकारात्मक संख्याओं के साथ और गैर-पूर्णांक मानों के साथ, लाभांश और विभाजक दोनों के लिए। उदाहरण:

-100.34 / 3.57: GoesInto = -28, शेष = -0.30000000000000079

हां, मैंने देखा, वहां एक सटीक समस्या है, लेकिन मेरे पास इसे जांचने का समय नहीं था (मुझे नहीं पता कि यह फ़ायरफ़ॉक्स, विंडोज 7 या मेरे सीपीयू के एफपीयू के साथ कोई समस्या है)। यारिन के प्रश्न के लिए, हालांकि, जिसमें केवल पूर्णांक शामिल हैं, गैमैक्स का कोड पूरी तरह से काम करता है।

Answer 9

Math.floor(operation) ऑपरेशन के राउंड डाउन मान को लौटाता है।

1 ^सेंट प्रश्न का उदाहरण :

var x = 5;
var y = 10.4;
var z = Math.floor(x + y);

console.log(z);

कंसोल:

15

2 ^{एन डी} सवाल का उदाहरण :

var x = 14;
var y = 5;
var z = Math.floor(x%y);

console.log(x);

कंसोल:

4

Answer 10

पृष्ठों की संख्या की गणना एक चरण में की जा सकती है: Math.ceil (x / y)

Comments

मैं यह नहीं देखता कि यह शेष कैसे प्रदान करता है।

— पॉल रूनी

Answer 11

एलेक्स मूर-नीमी की टिप्पणी एक जवाब के रूप में:

रूबिस्टों के लिए यहाँ Google से divmod, आप इसे इस तरह से लागू कर सकते हैं:

function divmod(x, y) {
  var div = Math.trunc(x/y);
  var rem = x % y;
  return [div, rem];
}

परिणाम:

// [2, 33]

Comments

आमतौर पर, divmodफ्लोर्ड डिवीजन ( Math.floor) का उपयोग करता है , जो कि ट्रंकेटेड डिवीजन ( ) से भिन्न होता है Math.truncजब नकारात्मक संख्याएं शामिल होती हैं। यह एनपीएम divmodपैकेज , रूबीdivmod , एसडब्ल्यूआई-प्रोलॉगdivmod और शायद कई अन्य कार्यान्वयनों के लिए भी मामला है।

— पेलेक

काटे गए विभाजन फ्लोर्ड डिवीजन की तुलना में अधिक स्वाभाविक रूप से दिखने वाले परिणाम देता है, लेकिन संगतता ट्रम्प कि, आई.एम.ओ. हो सकता है, फ्लोर्ड डिवीज़न का उपयोग करने के गणितीय या प्रदर्शन कारण भी हों। ध्यान दें कि आम तौर पर divmodमौजूद है , क्योंकि यह दो ऑपरेशनों को अलग से कंप्यूटिंग के रूप में दो बार तेजी से करता है। इस प्रदर्शन लाभ के बिना इस तरह के एक समारोह प्रदान करना भ्रामक हो सकता है।

— पेलेक

Answer 12

यदि आप केवल दो की शक्तियों के साथ विभाजित कर रहे हैं, तो आप बिटवाइज़ ऑपरेटरों का उपयोग कर सकते हैं:

export function divideBy2(num) {
  return [num >> 1, num & 1];
}

export function divideBy4(num) {
  return [num >> 2, num & 3];
}

export function divideBy8(num) {
  return [num >> 3, num & 7];
}

(पहला भागफल है, दूसरा शेष)

Comments

आम तौर पर, function divideByPowerOf2(num, exponent) { return [num >> exponent, num & ((1 << exponent) - 1)]; }।

— पालक

Answer 13

आप सकारात्मक और नकारात्मक पूर्णांक मानों को कैसे संभालें, यह तय करने के लिए आप टर्नरी का उपयोग कर सकते हैं।

var myInt = (y > 0) ? Math.floor(y/x) : Math.floor(y/x) + 1

यदि संख्या एक सकारात्मक है, तो सब ठीक है। यदि संख्या एक ऋणात्मक है, तो यह 1 जोड़ देगा क्योंकि Math.floor नकारात्मक को कैसे संभालता है।

Answer 14

यह हमेशा शून्य की ओर बढ़ता जाएगा। यकीन नहीं तो बहुत देर हो जाएगी, लेकिन यहाँ यह हो जाता है:

function intdiv(dividend, divisor) { 
    divisor = divisor - divisor % 1;
    if (divisor == 0) throw new Error("division by zero");
    dividend = dividend - dividend % 1;
    var rem = dividend % divisor;
    return { 
        remainder: rem, 
        quotient: (dividend - rem) / divisor
    };
}

Answer 15

यदि आपको बहुत बड़े पूर्णांकों के लिए शेष की गणना करने की आवश्यकता है, जिसे जेएस रनटाइम इस तरह के रूप में प्रस्तुत नहीं कर सकता है (2 ^ 32 से अधिक पूर्णांक एक फ्लोट के रूप में दर्शाया गया है और इसलिए यह सटीक खो देता है), आपको कुछ चाल करने की आवश्यकता है।

यह चेक अंकों के कई मामलों की जाँच के लिए विशेष रूप से महत्वपूर्ण है जो हमारे दैनिक जीवन के कई उदाहरणों में मौजूद हैं (बैंक खाता संख्या, क्रेडिट कार्ड, ...)

सबसे पहले आपको एक स्ट्रिंग के रूप में अपना नंबर चाहिए (अन्यथा आप पहले ही सटीक खो चुके हैं और शेष का कोई मतलब नहीं है)।

str = '123456789123456789123456789'

अब आपको अपने स्ट्रिंग को छोटे भागों में विभाजित करने की आवश्यकता है, छोटे पर्याप्त ताकि किसी भी शेष का संयोजन और स्ट्रिंग का एक टुकड़ा 9 इंच में फिट हो सके।

digits = 9 - String(divisor).length

स्ट्रिंग को विभाजित करने के लिए एक नियमित अभिव्यक्ति तैयार करें

splitter = new RegExp(`.{1,${digits}}(?=(.{${digits}})+$)`, 'g')

उदाहरण के लिए, यदि digits7 है, तो रेगेक्सप है

/.{1,7}(?=(.{7})+$)/g

यह अधिकतम लंबाई 7 के एक गैर-रिक्त विकल्प से मेल खाता है, जिसका अनुसरण ( (?=...)एक सकारात्मक रूपांतर है) कई वर्णों द्वारा किया जाता है जो 7. से अधिक है। 'g' का अर्थ है कि सभी स्ट्रिंग के माध्यम से रन बनाना, पहले मैच में नहीं रुकना।

अब प्रत्येक भाग को पूर्णांक में बदलें, और reduceपिछले ( शेष को वापस जोड़ते हुए - 10 की सही शक्ति से गुणा करके) की गणना करें :

reducer = (rem, piece) => (rem * Math.pow(10, digits) + piece) % divisor

शेष एल्गोरिथम "घटाव" के कारण यह काम करेगा:

n mod d = (n - kd) mod d

जो अंतिम शेष को प्रभावित किए बिना, संख्या के दशमलव प्रतिनिधित्व के किसी भी 'प्रारंभिक भाग' को उसके शेष के साथ बदलने की अनुमति देता है।

अंतिम कोड इस तरह दिखेगा:

function remainder(num, div) {
  const digits = 9 - String(div).length;
  const splitter = new RegExp(`.{1,${digits}}(?=(.{${digits}})+$)`, 'g');
  const mult = Math.pow(10, digits);
  const reducer = (rem, piece) => (rem * mult + piece) % div;

  return str.match(splitter).map(Number).reduce(reducer, 0);
}