विभाजन और शेष


36

यह चुनौती, जबकि अधिकांश "मानक" भाषाओं में संभवतः तुच्छ है, उन भाषाओं को संबोधित किया जाता है जो इतनी गूढ़, निम्न-स्तरीय और / या उपयोग करने में कठिन हैं जो इस साइट पर बहुत कम ही देखी जाती हैं। इसे हल करने के लिए एक दिलचस्प समस्या प्रदान करनी चाहिए, इसलिए यह आपके लिए उस अजीब भाषा की कोशिश करने का अवसर है जिसके बारे में आपने पढ़ा है!

काम

दो प्राकृतिक संख्याएं aऔर bइनपुट के रूप में, और दो अन्य संख्याओं को आउटपुट करें: पूर्णांक विभाजन का परिणाम a/b, और ऐसे विभाजन के शेष ( a%b)।

यह : सबसे छोटा उत्तर (बाइट्स में), प्रत्येक भाषा के लिए, जीतता है!

इनपुट आउटपुट

  • 0 <= a<= 255, 1 <= b<= 255। आपके प्रत्येक इनपुट (और आउटपुट भी) एक ही बाइट में फिट होंगे।
  • आप इनपुट और आउटपुट दोनों के लिए कोई भी प्रारूप चुन सकते हैं, जब तक कि दो नंबर स्पष्ट रूप से अलग-अलग न हों (उदाहरण के लिए दो परिणामों को एक सीमांकक के बिना एक साथ प्रिंट करना)

उदाहरण

a,b->division,remainder
5,7->0,5
5,1->5,0
18,4->4,2
255,25->10,5

नोट: वे विभाजन जो विभाजन के परिणाम दोनों को वापस करते हैं और शेष निषिद्ध हैं । कम से कम हमें दिखाएँ कि आपकी भाषा एक ही तर्कों पर दो कार्यों को लागू करने से संबंधित है।

नोट 2: हमेशा की तरह, इस बात की व्याख्या कि आपका कोड कैसे काम करता है, आपका बहुत स्वागत है, भले ही यह आपके लिए पठनीय लगे, लेकिन यह किसी और के लिए ऐसा नहीं हो सकता है!


लीडरबोर्ड

यहां भाषा द्वारा विजेताओं का अवलोकन उत्पन्न करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes


क्या मैं तर्कों को उलटा कर सकता हूं, अर्थात इसके बदले प्रदान a bकरने के b aबजाय?
आउटगोल्फर

@EriktheOutgolfer:You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishable
एमिग्ना

@Emigna हाँ, मुझे यकीन नहीं था कि अगर पलट कर उन्हें अप्रभेद्य नहीं बनाया गया था।
एर्ग आउटफोलर

@EriktheOutgolfer यदि आप जानते हैं कि उन्हें उलटने की आवश्यकता है तो आपको उन्हें अलग करने में कोई समस्या नहीं है :)
Leo

दुर्भाग्य से, बीएफ एल्गोरिथ्म काम नहीं करता है अगर भाजक है 1
mbomb007

जवाबों:


23

BitCycle , 146 79 64 बाइट्स

बस एहसास हुआ कि मेरे मूल कोड का एक पूरा अनुभाग अस्वाभाविक था। भारी कमी!

v  <>!
A\B^^=
? D^>^<
 >\v^~ D@
 >/ C/
  > C ^
A/B v
^   <
?  D^

कार्यक्रम कमांड लाइन से यूनिरी में इनपुट लेता है, पहले विभाजक के साथ। यह भागफल को अलग कर देता है और एक में अलग रहकर एकात्मक में शेष रह जाता है 0। उदाहरण के लिए, यहाँ है a=11, b=4, a/b=2, a%b=3:

C:\>python bitcycle.py divmod.btc 1111 11111111111
110111

अनगढ़, कार्रवाई में

यहाँ मेरा ungolfed संस्करण कंप्यूटिंग है a=3, b=5एनीमेशन चालू ( ग्लिचनेस के बारे में खेद):

BitCycle में Divmod चल रहा है

एक स्पष्टीकरण पर प्रयास करें

यह स्पष्टीकरण अनलॉक्ड संस्करण पर लागू होता है। इससे पहले कि आप इसे निपटाएं , मैं अत्यधिक अनुशंसा करता हूं कि भाषा के काम करने के तरीके के बारे में जानने के लिए आप Esolangs पृष्ठ पढ़ें ।

एल्गोरिथ्म इस प्रकार है:

  • प्रोग्राम समाप्त होने तक एक बाहरी लूप चलाएं।
    • भाजक के बिट्स पर एक आंतरिक लूप चलाएं, उन्हें लाभांश से बिट्स के साथ जोड़ दें।
      • यदि भाजक के सभी बिट्स में लाभांश बिट्स हैं, तो एक ही बिट आउटपुट होता है।
      • यदि भाजक के सभी बिट्स में डिविडेंड बिट्स का मिलान नहीं होता है, तो विभाजक 0द्वारा आउटपुट किया जाता है और उसके बाद डिवाइडर बिट्स क्या हैं, तब समाप्त हो जाते हैं।

कोड का दिल कलेक्टरों (अपरकेस अक्षर) के बीच के रिश्ते हैं। चूंकि प्रत्येक अक्षर के साथ कई अलग कलेक्टरों कर रहे हैं, के रूप में उन्हें का उल्लेख करते हैं A1, A2, B1, B2, आदि, ऊपर से नीचे तक नंबर।

  • A1और A2मुख्य लूप की शुरुआत में क्रमशः डिवाइडर और डिविडेंड रखें।
  • आंतरिक लूप डिविज़र और डिविडेंड से एक बार में एक सा छीलता है।
    • शेष भाजक, यदि कोई हो, हमेशा जाता है B1
    • यदि भाजक और लाभांश दोनों गैर-रिक्त थे, तो एक बिट में जाता है C1और एक में C3। बाकी लाभांश में चला जाता है B2
    • यदि केवल भाजक गैर-रिक्त था, तो हम लाभांश के अंत तक पहुँच चुके हैं, और शेष को प्रिंट करने का समय आ गया है। भाजक से बिट जाता है C2
    • यदि केवल लाभांश गैर-रिक्त था, तो हम भाजक के अंत तक पहुँच चुके हैं; यह बिट्स में C3या C2आउटपुट के लिए प्रोसेस करने का समय है । बाकी लाभांश में चला जाता है C4
  • यदि Bकलेक्टरों में कोई बिट्स हैं , तो वे अपनी सामग्री को वापस Aकलेक्टरों के पास भेजते हैं और आंतरिक लूप में जारी रखते हैं।
  • एक बार Aऔर Bकलेक्टरों सभी खाली हैं, Cकलेक्टरों खोलने के लिए और हम संसाधन चरण के लिए आगे बढ़ें:
    • C1और C4उनकी सामग्री (क्रमशः भाजक और शेष लाभांश) में D1और D3
    • यदि C2खाली है, तो हम अभी भी भागफल छाप रहे हैं।
      • C3शीर्ष दाएं =स्विच पर जाने की सामग्री । पहला 1बिट सीधे होकर गुजरता है !और आउटपुट होता है।
      • जब 1बिट के माध्यम से गुजरता है, तो यह सही बिंदु पर स्विच करने के लिए सक्रिय करता है, जो बोर्ड के बाद के सभी बिट्स को भेजता है।
    • यदि C2खाली नहीं है, तो हम शेष प्रिंट कर रहे हैं।
      • पहले बिट को स्विच के माध्यम C2से ए 0और पास किया जाता है। 0पर चला जाता है !और उत्पादन होता है।
      • जब 0बिट से गुजरता है, तो यह स्विच को बाईं ओर इंगित करने के लिए सक्रिय करता है। अब सभी बिट्स C3स्विच से बाईं ओर जाते हैं और !पूरे शेष को आउटपुट करते हुए चारों ओर पुनर्निर्देशित कर दिए जाते हैं ।
      • से पहली बिट की एक प्रति C2भी भेजी जाती है D2
  • अब Dकलेक्टर खोलते हैं।
    • अगर इसमें कुछ भी है D2, तो इसका मतलब है कि हमने अभी शेष प्रिंट किया है। D2हिट से बिट @, जो कार्यक्रम को समाप्त करता है।
    • अन्यथा, D1और D3लूप की सामग्री वापस A1और A2क्रमशः, और मुख्य लूप खत्म होने लगती है।

यह भयानक है
इवान कार्सलेक

"प्रोग्राम कमांड लाइन से एकतरफा इनपुट लेता है": यह मेरे लिए द्विआधारी जैसा दिखता है?
उपचारित

ओह। क्योंकि आउटपुट बाइनरी जैसा दिखता था, हालांकि मैं इनपुट भी होना चाहिए। फिर मैंने पाठ पढ़ा। कोई बात नहीं। : P
therealfarfetchd

15

ब्रेनफक , 43 41 बाइट्स

,<,[>->+<[>]>>>>+<<<[<+>-]<<[<]>-]>>.>>>.

यह Esolangs पर मेरे विनाशकारी मापांक एल्गोरिथ्म के एक संशोधित संस्करण का उपयोग करता है ।

कार्यक्रम दो बाइट्स पढ़ता है - डी और एन , उस क्रम में - एसटीडीआईएन से और दो बाइट्स - एन% डी और एन / डी , उस क्रम में - एसटीडीटी के लिए प्रिंट करता है । यह एक डबल अनंत या परिपत्र टेप के साथ एक brainfuck दुभाषिया की आवश्यकता है, जैसे कि TIO पर एक।

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

यह काम किस प्रकार करता है

कार्यक्रम शुरू होने से पहले, सभी कोशिकाएं मान 0 रखती हैं । STDIN ( ) से d पढ़ने के बाद ,, एक कदम बाएं ( <) और STDIN ( ) से n पढ़ने के बाद ,, टेप इस प्रकार दिखता है।

       v
A      B      C      D      E      F      G      H      J
0      n      d      0      0      0      0      0      0

अगला, यह मानते हुए कि n> 0 , हम लूप में प्रवेश करते हैं

[>->+<[>]>>>>+<<<[<+>-]<<[<]>-]

जो टेप को इस प्रकार रूपांतरित करता है।

सबसे पहले, >->+<सेल सी को अग्रिम और इसे घटाता है, फिर सेल डी को अग्रिम करता है और इसे बढ़ाता है, और अंत में सेल सी पर वापस जाता है । आगे क्या होता है यह इस बात पर निर्भर करता है कि सेल C का मान शून्य है या नहीं।

  • यदि सेल C पॉजिटिव वैल्यू रखता है, [>](सेल नॉन-जीरो होने पर दाएं जाएं) सेल E को एडवांस करेगा ।

    >>>>+<<<सेल जे को इसे बढ़ाने के लिए आगे बढ़ता है, फिर सेल एफ पर वापस जाता है ।

    चूंकि सेल एफ हमेशा 0 धारण करेगा , जबकि लूप [<+>-]पूरी तरह से छोड़ दिया <<जाता है , और सेल डी पर वापस चला जाता है ।

    अंत में, चूंकि न तो डी और न ही सी 0 पकड़ते हैं , [<](सेल गैर-शून्य होने पर छोड़ दिया जाता है) सेल को पीछे ले जाएगा ।

  • यदि सेल सी 0 रखता है , तो लूप [>]पूरी तरह से छोड़ दिया जाता है; >>>>+<<<सेल G को आगे बढ़ाने के लिए आगे बढ़ाता है, फिर सेल D पर वापस जाता है ।

    इस बिंदु पर, डी का आयोजन करेगा (वास्तव में, में मानों का योग सी और डी हमेशा रहेंगे ), तो [<+>-](जबकि डी सकारात्मक, वेतन वृद्धि है सी और घटती विकास सेट हो जाएगा) सी के लिए और डी के लिए 0

    अंत में, <<सेल बी के लिए प्रतिगामी , [<](सेल गैर-शून्य होने पर छोड़ दिया जाता है) आगे सेल ए पर छोड़ दिया जाता है ।

दोनों मामलों में, >-सेल बी को अग्रिम करता है और इसे घटाता है, और लूप शुरू होता है जब तक कि यह इसे बाहर नहीं करता है।

K पुनरावृत्तियों के बाद , टेप निम्नानुसार दिखता है।

       v
A      B      C      D      E      F      G      H      J
0      n-k    d-k%d  k%d    0      0      k/d    0      k-k/d

N पुनरावृत्तियों के बाद B को शून्य किया जाता है और हम लूप से बाहर हो जाते हैं। वांछित मान ( एन% डी और एन / डी ) कोशिकाओं डी और जी में संग्रहीत किया जाएगा , इसलिए >>.>>>.उन्हें प्रिंट करता है।


12

फंकिटॉन , 224 108 बाइट्स

बाइट काउंट यूटीएफ -16 को बीओएम के साथ एन्कोडिंग मानता है।

 ┌──┬───┐
┌┴╖╓┴╖ ┌┴╖
│%╟║f╟┐│÷╟┘
╘╤╝╙─╜│╘╤╝
 └────┴─┘

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

उपरोक्त एक फ़ंक्शन को परिभाषित करता है f, जो दो पूर्णांकों को लेता है और उनके विभाजन और उनके उत्पाद दोनों को लौटाता है (फ़ंक्सन में फ़ंक्शन कई आउटपुट हो सकते हैं जब तक कि इनपुट और आउटपुट का योग 4 से अधिक न हो)।

कई उद्देश्यों के लिए दो इनपुट मूल्यों का उपयोग करना वास्तव में काफी तुच्छ है: आप बस कनेक्टर को एक टी-जंक्शन के साथ विभाजित करते हैं मूल्य पर दोनों शाखाओं के साथ डुप्लिकेट किया जाएगा, जिसे हम विभाजन और मॉडुलो के लिए अंतर्निहित इंसु को अलग से खिला सकते हैं।

यह वास्तव में मुझे दो बार लगा कि यह पता लगाना है कि समाधान को लागू करने की तुलना में उपयोगकर्ता को परिणाम कैसे प्रदर्शित किया जाए।

इसके अलावा, Funciton में एक अंतर्निर्मित divmod है, ÷%और मनोरंजक रूप से निर्मित-इन्स ÷और %कि मेरे समाधान का उपयोग करने के संदर्भ में लागू किया गया है÷% । हालाँकि, fऊपर मेरा कार्य काफी हद तक समान नहीं है ÷%: मुझे इनपुट के क्रम को स्वैप करना था और हालांकि ऐसा लगता है कि इसे बदलना आसान होना चाहिए, अब तक मैं बाइट की गिनती बढ़ाए बिना ऐसा नहीं कर पाया। ।


10

जावास्क्रिप्ट (ईएस 6), 17 बाइट्स

एक बाइट को बंद करने के लिए @Arnauld को धन्यवाद

x=>y=>[x/y|0,x%y]

प्रारूप (x) (y) में इनपुट प्राप्त करता है

बिट वाइज प्रदर्शन करके x / y का फर्श मिलता है या
x% y द्वारा शेष हो जाता है
दोनों सरणी में मान डालता है ताकि वे दोनों वापस आ सकें

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


10

APL (Dyalog) , 5 बाइट्स

-2 बाइट्स @ngn की बदौलत

⌊÷,|⍨

यह एक कांटा (2-ट्रेन) एक फोर्क (3-ट्रेन) है, जहां एटॉप का दाहिना टाइन एक व्युत्पन्न फ़ंक्शन (एक फ़ंक्शन पर लागू एक ऑपरेटर का परिणाम) है:

       result 
         ↑┌──────────┐
         ││    ┌────┐│┌──────┐ (derived function)
         │↓        ↓│↓      │╱
       ┌───┐ ┌───┐ ┌───┐ ╔═══╤═══╗
           ÷   ,   |    
       └───┘ └───┘ └───┘ ╚═══╧═══╝
                              
left argument ┴─────────────────┘  (operator)
                └─────────┴ right argument

 की मंजिल

÷ विभाजन

, को दिया गया

| विभाजन
 बदली हुई दलीलों के साथ शेष (APL मापांक "पीछे की ओर" है)

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


आपने उस शांत चित्र को कैसे बनाया?
एमिलेक

2
@WolfgangTS दर्दभरा। डायलॉग एपीएल बेसिक ट्री डायग्राम ऑफ़ टैसिट फ़ंक्शंस बनाने की क्षमता के साथ आता है। इसे ऑनलाइन आज़माएं! मैंने उसी के साथ शुरुआत की ...
Adám

आउच, बहुत मुश्किल लग रहा है। मुझे इस बात का धीरज नहीं है कि मैं डरता हूँ, हाहा
एमिफ़्लेक

छोटा:⌊÷,|⍨
ngn

@ ओंग, आप मुझे मिल गए। यह देखकर खुशी हुई कि आप अभी भी यहां हैं।
आदम

7

ब्रेकीलॉग , 6 बाइट्स

{÷|%}ᶠ

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

व्याख्या

हम ᶠ findallदो तर्कों की इनपुट सूची में दो अलग-अलग विधेयकों को लागू करने के लिए रूपक का दुरुपयोग करते हैं :

{   }ᶠ         Findall for the Input [A,B] :
 ÷               Integer division
  |              Or…
   %             Modulo

7

MATL , 12 10 बाइट्स

Qt:ie=&fhq

इनपुट है aतो, b। आउटपुट शेष है, फिर भागफल।

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

व्याख्या

यह मोडुलो और डिवीजन दोनों से बचा जाता है। इसके बजाय यह सरणी पुनर्वसन का उपयोग करता है :

  1. a+1नॉनज़रो तत्वों की एक सरणी बनाएँ ।
  2. bपंक्तियों के 2 डी सरणी के रूप में रीसेट करें। यदि जरूरत हो तो यह स्वचालित रूप से शून्य के साथ पैड करता है।
  3. अंतिम नॉनज़ेरो प्रविष्टि, माइनस की पंक्ति और स्तंभ सूचकांक 1क्रमशः शेष और भागफल हैं।

उदाहरण के लिए विचार करें a=7, b=3

Q    % Input a implicitly. Push a+1
     % STACK: 8
t:   % Duplicate. Range from 1 to that
     % STACK: 8, [1 2 3 4 5 6 7 8]
ie   % Input b. Reshape as a matrix with b rows (in column major order)
     % STACK: 8, [1 4 7;
                  2 5 8]
                  3 6 0]
=    % Compare for equality
     % STACK: [0 0 0;
               0 0 1;
               0 0 0]
&f   % Row and column indices (1-based) of nonzero element
     % STACK: 2, 3
hq   % Concatenate. Subtract 1. Implicitly display
     % STACK: [1 2]

2
यह पार्श्व सोच, अच्छा काम का एक अच्छा उदाहरण है!
लियो

6

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

⌊#/#2⌋@Mod@##&

लचीले आउटपुट नियमों का मामूली दुरुपयोग: परिणाम के रूप में दिया गया है div[mod], जो कि अविकसित रहेगा। अलग-अलग नंबरों के साथ result[[0]]और निकाला जा सकता है result[[1]]

और हे, यह केवल एक बाइट है जिसका नाम हास्यास्पद रूप से निर्मित है QuotientRemainder

गणितज्ञ, वास्तव में एक ही इनपुट के लिए कई कार्यों को लागू करने के लिए एक साफ तरीका है, लेकिन यह तीन बाइट्स लंबा है:

Through@*{Quotient,Mod}

1
आप जानते हैं कि यह बुरा है जब आप भाषा निर्मित-इन्स बनाते हैं जो कि केवल बिल्ट-इन को जोड़ती है ...
13

1
@ घातक है? मुझे लगता है कि डीमोड बिल्ट-इन काफी उपयोगी है, और मैथमैटिक अब तक केवल एक ही भाषा नहीं है।
मार्टिन एंडर

8
@ निर्धारित करें, बहुत से समान काम के लिए कोटर्स की गणना करना आवश्यक है क्योंकि अवशेषों की गणना करना आवश्यक है। यदि दोनों परिणामों का उपयोग किया जाना है, तो एक उचित रूप से इंजीनियर quotRemनिर्मित कॉलिंग quotऔर remअलग से महत्वपूर्ण समय बचा सकता है ।
जूलियन वुल्फ

6

05AB1E , 5 बाइट्स

÷²¹%‚

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

05AB1E में एक बग है, इसलिए निहित इनपुट काम नहीं करता है :( Emigna ने कहा कि इनपुट को अक्सर रिवर्स में धकेल दिया जाता है।


आप 5 बाइट्स के लिए ÷)%) कर सकते हैं ।
एमिग्ना

@Emigna I dunno अगर यह मान्य है। रुको, यह कैसे काम किया?
आउटगोल्फर

1
मैं यह नहीं देखता कि यह मान्य क्यों नहीं होगा। यह काम करता है क्योंकि अंतर्निहित इनपुट को इस तरह से मामलों में उल्टा क्रम में धकेल दिया जाता है।
Emigna

@Emigna मैंने ओपी से पूछा है कि क्या मैं तर्कों को पलट सकता हूं।
एर्ग आउटफोलर

2
मेरा You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishableमतलब है कि आप तय कर सकते हैं कि इनपुट के रूप में लिया जाता है divisor, dividend। आप केवल divisor, dividendउत्तर में "इनपुट के रूप में लिया जाता है " निर्दिष्ट कर सकते हैं और वे स्पष्ट रूप से अलग होंगे :)
एमिग्ना

6

जेलिफ़िश , 14 बाइट्स

p
m
,|S
% i
Ei

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

व्याख्या

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

दो iकार्यक्रम में दो इनपुट मानों से बदल जाता है जब कार्यक्रम शुरू होता है। अब %विभाजन है। यह पूर्व से सीधे एक इनपुट लेता है, और दक्षिण में जाने पर यह Eउन पुर्ननिर्देशों से टकराता है जो पूर्व की तरह खोजते हैं। इसलिए दोनों इनपुट %को तर्क के रूप में खिलाया जाता है।

| बिल्ट-इन मोडुलो के लिए है, जो मूल रूप से एक ही काम करता है, लेकिन पुट में दोनों के लिए दक्षिण की ओर देखता है।

हम दोनों परिणामों को एक जोड़ी में बदल देते हैं ,। फिर mमंजिल समारोह है (जिसकी हमें आवश्यकता है क्योंकि %फ्लोटिंग-पॉइंट डिवीजन है) और अंत में हम परिणाम को प्रिंट करते हैं p


6

क्यूबिक्स , 12 13 बाइट्स

;W@o,I|\S%;O

निम्नलिखित घन पर कौन से नक्शे

    ; W
    @ o
, I | \ S % ; O
. . . . . . . .
    . .
    . .

इसे यहाँ आज़माएँ

निष्पादित के रूप में चरणों के साथ स्पष्टीकरण
,I|I,- एक शानदार पूर्णांक विभाजन से शुरू होता है, इनपुट से पहला पूर्णांक प्राप्त करता है, वापस प्रतिबिंबित करता है और इनपुट से अगला पूर्णांक प्राप्त करता है, फिर फिर से विभाजित होता है
O;- पूर्णांक विभाजन का परिणाम और इसे पॉप
%- मॉड करें। यह बाद में किया जा सकता है, लेकिन यहां समाप्त हो गया
S\o- स्टैक से रिडायरेक्ट अप और आउटपुट स्पेस में स्पेस कैरेक्टर जोड़ें
W;- शिफ्ट बाएं और स्टैक से स्पेस पॉप करें
O|@- पहले से गणना की गई मॉड को आउटपुट करें, क्षैतिज रिफ्लेक्टर और हाल्ट से गुजरें।


मुझे दो मिनट से हराया। अच्छा जवाब!
ल्यूक

@ ल्यूक धन्यवाद, सोचा कि मैं एक और एक मिल सकता है, लेकिन मायावी साबित
मिकी

6

ब्रेन-फ्लैक , 56 54 बाइट्स

({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

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

गेहूं के जादूगर को -2 बाइट्स धन्यवाद

व्याख्या

वर्तमान सबसे अच्छा ज्ञात पूर्णांक विभाजन और सापेक्ष ब्रेन-आलोचना में समान (वास्तव में वर्तमान में उपयोग किया पूर्णांक विभाजन सिर्फ एक संशोधन मैं पर किया है feersum के सापेक्ष)।

मोडुलो और पूर्णांक विभाजन की तुलना:
Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

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

मोदुलो और पूर्णांक विभाजन का संयोजन:
Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

Combined: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><([{}()]{})>)

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

यह हमें अंतिम कार्यक्रम देता है:
({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

पूर्णांक विभाजन कार्यक्रम के लिए स्पष्टीकरण के लिए feersum का उत्तर देखें

इंटीजर डिवीजन स्पष्टीकरण जल्द ही आ रहा है ...


5

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

(a,b)->a/b+","+a%b

यह प्रकार का एक लंबोदर अभिव्यक्ति है BiFunction<Integer, Integer, String>

मुझे आश्चर्य है ... यह वास्तव में जावा के लिए एक काफी संक्षिप्त समाधान है। जाओ लंबोदर भाव!


5

ब्रेन-फ्लैक , 168 148 110 बाइट्स

मुझे लगता है कि मुझे पहले विकी को जांचना चाहिए था

(({})(<({}(<(({})<>)>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<>)

प्रारूप:

Input:    Output:
A (18)    remainder (2)
B (4)     division  (4)

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

(({})(<           # Copy A
({}(<             # Pick up A
(({})<>)          # Copy B to the other stack
>))               # Put A on top of a 0 on the second stack
                  # At this point the stacks look like this:   A
                                                               0
                                                             B B
                                                               ^

<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>) # Positive division from the wiki
>))                                          # Put down A on top of a 0
                                             # The stack now: A
                                                              0
                                                            Div B
                                                              ^

<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<>)     # Modulo from the wiki


5

सीड, 36 बाइट्स

-rध्वज के लिए कोड के 35 बाइट्स, +1 ।

:a;s/^(1+)( 1*)\1/\1\2x/;ta;s/.* //

पहले छोटे नंबर के साथ अंतरिक्ष, अलग-अलग में इनपुट लेता है। आउटपुट के रूप में एकरी, भागफल में पहले 1और शेष दूसरे के साथ है x। (यदि यह स्वीकार्य नहीं है, तो मुझे बताएं और मैं इसे 1इनपुट की तरह अंतरिक्ष-पृथक एस में बदल दूंगा ।)

व्याख्या

:a;                                  Define label a
   s/            /     /;            Perform this substitution:
     ^(1+)                           Match the first unary number...
          ( 1*)                      ... followed by a space and 0 or more 1s...
               \1                    ... followed by the the first group again
                  \1\2x              Keep the first two parts unchanged; replace the third
                                     with an x
                         ta;         If the substitution succeeded, goto a
                            s/.* //  After the loop is over, remove the first number

5

एक्सेल 2013, 31 30 26 बाइट्स

=INT(A1/B1)&","&MOD(A1;B1)

व्याख्या

इनपुट सेल में है A1और B1। यह बस FLOORऔर MODफंक्शन के रिटर्न मानों को लौटाता है , जो विभाजन को फर्श पर और शेष के लिए हैं। इन मानों को अल्पविराम द्वारा अलग किया जाता है।


मुझे लगता है कि आपका मतलब सेल A1 और B1 नहीं A1 और A2 है
fɛnɪt Mark

हाँ धन्यवाद। अब ठीक है
ल्यूक

1 बाइट के साथ सहेजें FLOOR(A1/B1;1)इसके बजायQUOTIENT(A1;B1)
इंजीनियर टोस्ट

क्योंकि इनपुट हमेशा एक प्राकृतिक संख्या है, मुझे लगता है कि आप FLOOR(A1/B1;1)4 INT बाइट बचाने के लिए `INT (A1 / B1) 'से बदल सकते हैं
Wernisch


4

डारन, मैं बस इसे पोस्ट करने जा रहा था, मैंने इसे कुछ अतिरिक्त समय का परीक्षण किया और निंजा लिया :( अच्छी नौकरी!
हाइपरन्यूट्रीनो

4

OIL , 134 106 103 102 बाइट्स

स्टड से इनपुट लेता है, दो संख्याओं को एक नई रेखा द्वारा अलग किया जाता है। पूर्णांक विभाजन के परिणाम को आउटपुट करता है, फिर एक नई रेखा, और फिर शेष।

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

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

5  # read input into lines 0 and 2

5
2
0  # the zero to compare to (nops)
1  # make a backup of the second input at line 3
2
3
10 # check if the second input is 0. %
4
2
24 # if so, jump to 24 (marked with §)
13 # else, go on
10 # check if the first input is zero &
4

31 # if so, jump to 31 (marked with $)
18 # else, go on
9  # decrement both numbers

9
2
6  # jump to line 8 (marked with %)
8
8  # increment the value in line 1 (initially a zero) §
1
1  # "restore the backup"
3
2
6  # jump to line 13 (marked with &)
13
10 # is the second number zero? $
4
2
42 # if so, jump to 42 (marked with +)
36 # else go on
9  # decrement both the second number and the backup
2
9
3
6  # jump to 31 (marked with $)
31
4  # print the division +
1
11 # a newline
4
3  # and the remainder (from the backup)

संपादित करें: एक "-अंक" को एक-अंक स्थान (संदर्भ के लिए कम बाइट्स) पर ले जाकर 3 और बाइट्स को शेव किया गया, और फिर 2 शून्य-स्थानों को प्रत्यारोपित किया गया (इसके बजाय एक खाली लाइन का उपयोग करके। उनमें से एक मैं कर सकता था। से पहले)।

संपादित करें: और प्रारंभिक शून्य अंतर्निहित करके एक और बाइट। हमें वास्तव में केवल एकल शाब्दिक शून्य की आवश्यकता है।


अच्छा कार्य! ठीक इसी तरह का जवाब मुझे उम्मीद है कि मुझे यह चुनौती मिलेगी :) बस एक नोट: आपको गारंटी दी जाती है कि विभाजक हमेशा सख्ती से सकारात्मक रहेगा, इसलिए आपको 0 से विभाजन की जांच करने की आवश्यकता नहीं है;)
लियो

@ मुझे यह गारंटी है कि शुरुआत में विभाजक हमेशा सख्ती से सकारात्मक रहेगा । यह काम नहीं करेगा यदि मैं शून्य भाग से विभाजन लेता हूं, तो यह मामला तब भी हो सकता है जब "वास्तविक" विभाजन सामान्य हो। अगर मुझे सही से याद है तो यह तब होता है जब शेष शून्य होता है।
L3viathan

मैं लाइन 4 पर चेक के बारे में बात कर रहा हूं, लाइन 12 पर एक नहीं ... क्या यह कार्यक्रम की शुरुआत में सिर्फ एक बार निष्पादित नहीं होता है?
सिंह

@ लियो हो गया, लगभग 30 अक्षर कम, धन्यवाद!
L3viathan

4

रेटिना , 14 बाइट्स

चलो इनपुट / आउटपुट स्वरूपों का दुरुपयोग करते हैं!

(.*)¶(\1)*
$#2

इनपुट के रूप में b\na, एकतरफा में, एकल अंक के लिए, किसी भी गैर-अंक, गैर-न्यूलाइन वर्ण के लिए उपयोग करता है। दशमलव में भागफल को आउटपुट करता है, इनपुट के समान वर्ण का उपयोग करते हुए, तुरंत शेष को यूनरी में रखता है।

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

(.*) ¶(\1)*पहली संख्या से मेल खाता है, फिर एक नई पंक्ति () के लिए रेटिना की शॉर्टहैंड है), फिर संभव के रूप में कई बार फिर से पहली संख्या। दूसरे समूह के मैचों की संख्या विभाजन का परिणाम होगी, और मिलान नहीं किया गया हिस्सा शेष होगा।

इसके साथ $#2, हम हर उस चीज़ को प्रतिस्थापित करते हैं जिसका मिलान पिछली पंक्ति में दूसरे समूह के कैप्चर की संख्या के साथ किया गया था, और तब हमारा परिणाम मिलता है।


हाहा, बिलकुल सही, मुझे स्पष्ट रूप से देर शाम के कार्यक्रम नहीं लिखने चाहिए।
FryAmTheEggman

4

अर्नोल्ड , 286 283 बाइट्स

HEY CHRISTMAS TREE c
YOU SET US UP 0
HEY CHRISTMAS TREE d
YOU SET US UP 0 
GET TO THE CHOPPER c
HERE IS MY INVITATION a
HE HAD TO SPLIT b
ENOUGH TALK
GET TO THE CHOPPER d
HERE IS MY INVITATION a
I LET HIM GO b
ENOUGH TALK
TALK TO THE HAND c
TALK TO THE HAND d
YOU HAVE BEEN TERMINATED

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

यह काम किस प्रकार करता है

HEY CHRISTMAS TREE c      //DECLARE VARIABLE c = 0
YOU SET US UP 0
HEY CHRISTMAS TREE d      //DECLARE VARIABLE d = 0
YOU SET US UP 0

GET TO THE CHOPPER c      /*
HERE IS MY INVITATION a      SET c = a/b
HE HAD TO SPLIT b         
ENOUGH TALK                */

GET TO THE CHOPPER d      /*
HERE IS MY INVITATION a      SET d = a mod b
I LET HIM GO b
ENOUGH TALK                */

TALK TO THE HAND c        // PRINT c
TALK TO THE HAND d        // PRINT d
YOU HAVE BEEN TERMINATED  //END

आउटपुट स्वरूप

a/b
a mod b

3

भूलभुलैया , 11 बाइट्स

?:?:}/!\{%!

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

व्याख्या

?:   Read a and duplicate.
?:   Read b and duplicate.
}    Move a copy of b over to the auxiliary stage.
/    Compute a/b.
!    Print it.
\    Print a linefeed.
{    Get back the other copy of b.
%    Compute a%b.
!    Print it.

आईपी ​​फिर एक मृत अंत मारता है, चारों ओर मुड़ता है और %फिर से निष्पादित होने पर शून्य से प्रयास किए गए विभाजन के कारण कार्यक्रम समाप्त हो जाता है।



3

> <> , 27 26 16 + 1 = 17 बाइट्स

:r:{%:n','o-$,n;

ध्यान दें

  • -vझंडे का उपयोग करने वाला इनपुट , TIO को एक उदाहरण के लिए देखें।
  • यह शेष पहले, फिर अल्पविराम और अंत में पूर्णांक विभाजन को आउटपुट करता है।

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

व्याख्या

ध्यान दें कि ढेर के रूप में शुरू होता है A, B, जहां Aऔर Bपहले और दूसरे इनपुट प्रतिनिधित्व करते हैं, क्योंकि के -vध्वज का इस्तेमाल किया।

:r:{%:n','o-$,n; # Explanation
:r:{             # Do some stack modifications to prepare it for
                 #    next part
                 #    (Stack: B, A, A, B)
    %            # Take the modulo of the top two items
                 #    (Stack: B, A, A%B)
     :           # Duplicate it
                 #    (Stack: B, A, A%B, A%B)
      n          # Pop once and output as number
                 #    (Stack: B, A, A%B)
       ','o      # Print separator
                 #    (Stack: B, A, A%B)
           -     # Subtract the modulo from the first input
                 #    (Stack: B, A-A%B)
            $,   # Swap the two inputs so they are back in order
                 #     and divide, so we get an integer
                 #    (Stack: floor(A/B))
              n; # Output that as a number and finish.

आप 255 तक इनपुट मान कैसे प्रदान कर सकते हैं?
लियो

बस उच्च ASCII / यूनिकोड मूल्यों का उपयोग करें। इस तरह, į255 हो जाता है।
ल्यूक

ठीक है, अच्छा :) वैसे, यह कमांड लाइन से इनपुट नंबर सीधे लेने के लिए छोटा नहीं होगा -v झंडा के साथ?
लियो

यह होगा, लेकिन मुझे टीआईओ पर काम करने के लिए नहीं मिला, इसलिए मैं इस समाधान के साथ बस गया। यह 8 बाइट्स - 1 ( -vध्वज के लिए) बचाएगा ।
ल्यूक


3

सी, 21 बाइट्स

#define f(a,b)a/b,a%b

एक मैक्रो जो 2 शब्दों अल्पविराम के साथ f (a, b) को अलग करता है। हालाँकि आप बेहतर तरीके से इसे फंक्शन में पास करेंगे या फिर 2 को अलग करने का कोई तरीका नहीं है।

यह ऑनलाइन की कोशिश करो


3

हास्केल , 21 बाइट्स

a#b=(div a b,mod a b)

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: 13#2रिटर्न (6,1)। हां, यह बहुत उबाऊ है, हालांकि थोड़ा अधिक दिलचस्प हैdivMod बिल्ड-इन की जो समान काम करता है।

जब हम उस पर होते हैं, तो वहाँ भी है quot, remऔर quotRemजो प्राकृतिक संख्याओं के समान व्यवहार करता है div, modऔर divMod। हालांकि, नकारात्मक आदानों के लिए परिणामी के modपास भाजक के समान चिन्ह होते हैं, जबकि परिणाम में remलाभांश के समान संकेत होते हैं। या, जैसा कि यह प्रस्तावना प्रलेखन में रखा गया है , quotपूर्णांक विभाजन शून्य की ओर छोटा है और divपूर्णांक विभाजन नकारात्मक अनंत की ओर छोटा है।


कैसे के बारे में divया नहीं modबिल्ड?

कोई बिल्ड-इन, 36 32 31 बाइट्स नहीं

a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: 13#2रिटर्न (1,6), वह modपरिणाम पहले और divपरिणाम दूसरा है। यदि aछोटा है b, तो a mod bहै aऔर a div bहै 0, इसलिए (a,0)लौटा है। अन्यथा रिकर्सिवली गणना modऔर divकी a-bऔर b, ऐड1 विभाजन परिणाम के लिए और शेष रहते हैं।

विभाजन में 1 जोड़ने से परिणाम प्राप्त होता है <$>, जिसे आमतौर पर उपयोग किया जाता हैmap पर सूचियों के अनुसार कार्यों को मैप करने के लिए है, लेकिन ट्यूपल्स पर भी काम करता है, हालांकि फ़ंक्शन को केवल दूसरे ट्यूपल तत्व पर लागू किया जाता है।

संपादित करें: xnor के लिए एक बाइट धन्यवाद सहेजा गया!


2
आपका दूसरा समाधान <$>अपने दूसरे तत्व पर कार्य करने के लिए एक टपल पर बाइट का उपयोग करके दाढ़ी बना सकता है a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b:।
xnor

3

एसडब्ल्यूआई प्रोलॉग, 109 बाइट्स

p(A):-print(A).
d(F,S,0,F):-S>F.
d(F,S,D,R):-G is F-S,d(G,S,E,R),D is E+1.
d(F,S):-d(F,S,D,R),p(D),p(-),p(R).

आउटपुट:

?- d(255,25).
10-5
true .
?- d(5,7).
0-5
true .

विवरण:

बिलिन डिवीजन या मोडुलो के बिना सरल पुनरावर्ती एल्गोरिदम। यह बस मायने रखता है "कितनी बार पहली बार में दूसरी संख्या फिट बैठता है?" और शेष (आर) के साथ परिणाम (डी के लिए एकीकृत) की रिपोर्ट करता है।

// संपादित करें: अनावश्यक स्थानों को हटा दिया


PPCG में आपका स्वागत है! मैंने पहले कभी प्रोलॉग का उपयोग नहीं किया है, लेकिन देखा :-कि अंतिम पंक्ति में चारों ओर रिक्त स्थान हैं लेकिन दूसरों पर नहीं। क्या उन्हें किसी कारण से वहां आवश्यक है? यह वही है E + 1जबकि F-Sसुझाव है कि कोई रिक्त स्थान की जरूरत है।
लैकोनी

Laikoni: आप निश्चित रूप से सही हैं! मैंने अभी-अभी रिक्त स्थान निकाले हैं और अंतिम बाइट गणना को अद्यतन किया है।
जन ड्रोजेन


2

MATL, 5 बाइट्स

/k&G\

MATL ऑनलाइन पर इसे आज़माएं !

व्याख्या

        % Implicitly grab the two inputs as numbers
/       % Divide them
k       % Round down the result
&G      % Grab the two inputs again
\       % Compute the remainder

2

ऑरोबोरोस , 15 बाइट्स

r.r.@/Inao\%n1(

संख्याओं को रिवर्स ऑर्डर (जैसे 10 42) में ले जाता है । इसे यहाँ आज़माएँ।

व्याख्या

r.r.             Read a number, duplicate, read a number, duplicate
    @            Rotate a copy of the first number to the top of the stack
     /I          Divide and truncate to integer
       n         Output as number
        ao       Push 10 and output as character (newline)
          \%     Swap the remaining two values and take the mod
            n    Output as number
             1(  Push 1 and swallow that many characters from the end of the program,
                 halting execution
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.