25

यह जांचने के लिए कि क्या दशमलव संख्या 7 से विभाज्य है:

अंतिम अंक मिटाएं। इसे 2 से गुणा करें और जो बचा है उससे घटाएं। यदि परिणाम 7 से विभाज्य है, तो मूल संख्या 7 से विभाज्य है।

(यह भी जैसे वर्णित यहाँ )

यह नियम मैनुअल डिविजिबिलिटी चेक के लिए अच्छा है। उदाहरण के लिए:

क्या 2016 7 से विभाज्य है?

6*2201 से घटाना ; हम 189 प्राप्त करते हैं। क्या यह 7 से विभाज्य है? इसे जांचने के लिए, आइए फिर से नियम लागू करें।

9*218 से घटाना ; हमें 0. इसलिए, 2016 7 से विभाज्य है।

इस चुनौती में, आपको इस नियम को तब तक लागू करना चाहिए जब तक कि विभाज्यता की स्थिति स्पष्ट न हो , अर्थात संख्या 70 से अधिक न हो (हालाँकि, विवरण के लिए नीचे देखें)। एक समारोह या एक पूर्ण कार्यक्रम बनाओ।

इनपुट : एक सकारात्मक पूर्णांक; आपके कोड को 32767 तक इनपुट का समर्थन करना चाहिए (मनमाने ढंग से सटीक पूर्णांक का समर्थन करना एक बोनस है; नीचे देखें)।

आउटपुट : एक पूर्णांक (संभवतः नकारात्मक), 70 से अधिक नहीं, यह विभाजन-दर -7 नियम को शून्य या अधिक बार लागू करने का एक परिणाम है।

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

Input                   Output      Alternative output

1                       1
10                      10          1
100                     10          1
13                      13          -5
42                      42          0
2016                    0
9                       9
99                      -9
9999                    -3
12345                   3
32767                   28          -14

---------- Values below are only relevant for the bonus

700168844221            70          7
36893488147419103232    32          -1
231584178474632390847141970017375815706539969331281128078915168015826259279872    8

जहां दो संभावित आउटपुट निर्दिष्ट हैं, या तो परिणाम सही है: दूसरा एक नियम को एक बार और लागू करने से मेल खाता है। नियम को एक-अंकों की संख्या पर लागू करने के लिए मना किया जाता है: यदि आप अंक को मिटाते हैं, तो कुछ भी नहीं (0 नहीं) बचा है।

बोनस : यदि आपका एल्गोरिथ्म

मनमाना-सटीक पूर्णांक का समर्थन करता है
इनपुट पर केवल एक पास करता है
अंतरिक्ष जटिलता है o(n)(यानी की तुलना में कम O(n)); तथा
समय जटिलता है O(n),

nदशमलव अंकों की संख्या कहां है:

अपने कोड के बाइट काउंट से 50% घटाएं।

असली बोनस :

इसके अलावा, यदि आपका एल्गोरिदम सामान्य दिशा में इनपुट को पढ़ता है, तो सबसे महत्वपूर्ण अंक से शुरू करके, एक बार फिर 50% घटाएं - आपका स्कोर आपके बाइट काउंट का 25% है (यह संभव प्रतीत होता है, लेकिन मैं बिल्कुल निश्चित नहीं हूं)।

code-golf number-theory division

— anatolyg
स्रोत

1

@DenkerAffe के रूप में इनपुट लौटना स्वीकार्य है। मैंने इसे दर्शाने के लिए इनपुट = 10 के परीक्षण-मामले को अद्यतन किया; यह शुरू से ही विचार था।

— एनाटॉलीग

4

मैं उस नियम का उपयोग नहीं करना चाहूंगा 1000000000000000000001।

— नील

1

लेकिन क्या होगा अगर आपकी भाषा में long longया कुछ समान प्रकार का निर्माण किया गया है?

— SuperJedi224 22

1

मैं जो कह रहा था, कुछ कार्यान्वयनों में, वह १२--बिट पूर्णांक है, जो उस अंतिम परीक्षण मामले के लिए पर्याप्त से अधिक है।

— SuperJedi224

7

-1। सभी भाषाएं मनमानी परिशुद्धता का समर्थन नहीं करती हैं।

— मार्च हो

23

गोल्फस्क्रिप्ट, 27 22 बाइट्स

{.9>{.10/\10%2*-f}*}:f

आप इसे इस तरह से उपयोग कर सकते हैं:

1000f

व्याख्या

{.9>{.10/\10%2*-f}*}:f
{                  }:f    # Define block 'f' (similar to a function)
 .                        # Duplicate the first value of the stack
  9>{            }*       # If the value on top of the stack is greater than 9 then the block is executed
     .10/\10%2*-          # Same as nb/10 - (nb%10 * 2) with some stack manipulations '.' to duplicate the top of the stack and '\' to swap the the first and second element of the stack
                f         # Execute block 'f'

5 बाइट्स ने डेनिस को धन्यवाद दिया!

— डी आई सी ए
स्रोत

1

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

— wizzwizz4 22

1

@ wizzwizz4 बेहतर? मुझे यकीन नहीं है कि मैं समझता हूं कि 'कोड ब्रेकडाउन' से आपका क्या मतलब है (देशी वक्ता खेद नहीं)

— Dica

8

मुझे विश्वास है कि "कोड ब्रेकडाउन" से उनका मतलब एक स्पष्टीकरण है, जिसे आपने जोड़ा है। यह वास्तव में एक बहुत अच्छा पहला जवाब है। साइट पर आपका स्वागत है!

— एलेक्स ए।

1

आप उस {...}{}ifभाग को फिर से लिख सकते हैं {...}*, जो केवल एक बार के कोड ब्लॉक शून्य को लागू करेगा, जो धकेल दिए गए मूल्य पर निर्भर करता है >। इसके अलावा, हमें एक और पुनरावृत्ति (इसलिए बाइट को बदलने के 70साथ 9) करने की अनुमति है, और मुझे नहीं लगता कि आपको ब्लॉक को पॉप करने की आवश्यकता है ;।

— डेनिस

3

@ डिका, यह एक पहला उत्तर है जो केवल 624 विचारों के साथ एक प्रश्न पर 12+ उत्थान प्राप्त करने के लिए, और दो मध्यस्थों से प्रशंसा पाने के लिए पर्याप्त है। यदि आप इसे बनाए रखते हैं, तो आप जल्द ही डेनिस से आगे निकल जाएंगे!

— wizzwizz4

13

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

until(<71)(\n->div n 10-2*mod n 10)

प्रयोग उदाहरण: until(<71)(\n->div n 10-2*mod n 10) 36893488147419103232-> 32।

समझाने के लिए ज्यादा कुछ नहीं है, यह एल्गोरिथ्म का प्रत्यक्ष कार्यान्वयन है।

— nimi
स्रोत

9

जेली, 11 बाइट्स

d⁵Uḅ-2µ>9$¿

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

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

d⁵Uḅ-2µ>9$¿  Main link. Input: n

d⁵           Divmod; return [n : 10, n % 10].
  U          Upend; yield [n % 10, n : 10].
   ḅ-2       Convert from base -2 to integer, i.e., yield -2 × (n % 10) + (n : 10).

      µ      Push the previous chain as a link and begin a new, monadic chain.
          ¿  Apply the previous chain while...
       >9$     its return value is greater than 9.

— डेनिस
स्रोत

और हमेशा की तरह, जेली जीतती है। डेनिस, जेली में एक जेली दुभाषिया को लागू करने के लिए कितना बाइट लेगा?

— बैलिंट

6

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

f=lambda x:f(x/10-x%10*2)if x>70else x

यहाँ कोशिश करो !

सरल पुनरावर्ती दृष्टिकोण। प्रिंट्स x यदि इसका <70 अन्यथा विभाजन नियम लागू करता है और परिणाम के साथ खुद को कॉल करता है।

— Denker
स्रोत

आप के बाद अंतरिक्ष की जरूरत नहीं है)

— माल्टीसेन

@ माल्टीसेन ट्रू। कॉपी गलत एक चिपकाया, संकेत के लिए धन्यवाद!

— डेनकर

2

यदि बहुत अधिक क्रिया है। f=lambda x:x*(x<70)or f(x/10-x%10*2)

— seequ

1

@Seeq अच्छी चाल, धन्यवाद! इसे सिद्धांत रूप में काम करना चाहिए, लेकिन यह इनपुट के रूप में 2016 के साथ अधिकतम पुनरावृत्ति की गहराई तक पहुंचता है, जबकि मेरा संस्करण नहीं है। कोई विचार क्यों?

— डेनकर

आह, ठीक है, कि विचार नहीं किया। इस ट्रिक x*(x<70) != 0को अंतिम स्थिति मानते हैं। यदि x 0 पर मिलता है - जैसे कि यह 2016 के साथ होता है - अंतिम स्थिति कभी नहीं होती है।

— seequ

6

पायथ, 13 बाइट्स

.W>H9-/ZTyeZQ

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

यह सभी वैकल्पिक उत्तरों को प्रिंट करेगा।

स्पष्टीकरण:

.W>H9-/ZTyeZQ   
            Q   read a number from input
.W              while
  >H9              the number is greater than 9
                do the following with the number:
      /ZT          divide it by 10
     -             and subtract
         yeZ       2*(number%10)

— Jakube
स्रोत

5

जूलिया, 27 26 बाइट्स

f(x)=x>9?f(x÷10-x%10*2):x

यह एक पुनरावर्ती कार्य है जो एक पूर्णांक को स्वीकार करता है और एक रिटर्न देता है BigInt। यदि इनपुट पिछले उदाहरण की तरह एक बड़ी संख्या है, तो जूलिया इसे एक के रूप में पार्स करता है BigInt, इसलिए कोई मैन्युअल रूपांतरण आवश्यक नहीं है।

दृष्टिकोण एल्गोरिदम का सिर्फ एक सीधा कार्यान्वयन है। यह वैकल्पिक आउटपुट का उत्पादन करेगा। 10 अंक से विभाजित करने पर मापांक लेने से अंतिम अंक और पूर्णांक विभाजन से भागफल 10 पैदावार लेकिन सब कुछ अंतिम अंक होता है।

डेनिस के लिए एक बाइट धन्यवाद बचा लिया!

— एलेक्स ए।
स्रोत

हमें एक और पुनरावृत्ति करने की अनुमति है, इसलिए एक बाइट के 70साथ प्रतिस्थापित किया 9जाता है।

— डेनिस

@ डेनिस गुड कॉल, धन्यवाद!

— एलेक्स ए।

4

पायथ, 17 बाइट्स

L?<b70by-/bT*%bT2

यहाँ यह कोशिश करो!

मेरे अजगर जवाब के रूप में एक ही पुनरावर्ती दृष्टिकोण । एक मेमने को परिभाषित करता yहै जिसे इस तरह कहा जाता है y12345:।
ऑनलाइन इंटरप्रेटर में बाइट काउंटर 19 बाइट्स दिखाता है क्योंकि मैंने इसमें लैम्बडा कॉल जोड़ा है, इसलिए आप रन-बटन दबाकर इसे आज़मा सकते हैं।

व्याख्या

L?<b70by-/bT*%bT2

L                  # Defines the lambda y with the parameter b
 ?<b70             # if b < 70:
      b            # return b, else:
       -/bT*%bT2   # calculate b/10 - b%10*2 and return it

— Denker
स्रोत

आपके पास अपने स्पष्टीकरण में एक टाइपो है, 17 में 70 होना चाहिए: P

— FryAmTheEggman

4

सीजाम - 19 बाइट्स

संस्करण करते समय:

r~A*{`)]:~~Y*-_9>}g

इसे ऑनलाइन आज़माएं या संस्करण # 1:

r~{_9>}{`)]:~~Y*-}w

इसे ऑनलाइन आज़माएं या संस्करण # 2:

r~{_9>}{_A/\A%Y*-}w

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

r~                     | Read and convert input
  A*                   | Multiply by 10 to get around "if" rule
     `                 | Stringify
      )                | Split last character off
       ]               | Convert stack to array
        :~             | Foreach in array convert to value
          ~            | Dump array
           Y*          | Multiply by 2
             -         | Subtract
              _        | Duplicate
               9>      | Greater than 9?
    {            }g    | do-while

— सीजे डेनिस
स्रोत

3

Oracle SQL 11.2, 116 बाइट्स

WITH v(i)AS(SELECT:1 FROM DUAL UNION ALL SELECT TRUNC(i/10)-(i-TRUNC(i,-1))*2 FROM v WHERE i>70)SELECT MIN(i)FROM v;

संयुक्त राष्ट्र के golfed

WITH v(i) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
  SELECT TRUNC(i/10)-(i-TRUNC(i,-1))*2 FROM v WHERE i>70
)
SELECT MIN(i) FROM v;

— Jeto
स्रोत

3

हास्केल, 157 192 184 167 159 147 138 + 5 बाइट्स - 50% = 71.5 बाइट्स

O (1) स्थान, O (n) समय, एकल-पास!

h d=d%mod d 10
d%r=(quot(r-d)10,r)
p![d]=d-p*10
p![d,e]=d#(e-p)
p!(d:e:f)|(b,a)<-quotRem(2*d)10,(q,r)<-h$e-a-p=(b+q)!(r:f)
m#0=m
m#n=n-2*m
(0!)

0![6,1,0,2]नियम को 2016 तक लागू करने के लिए उपयोग करें , अर्थात इसे स्ट्रीम फॉर्म में एक संख्या दें जिसमें पहले कम से कम महत्वपूर्ण आंकड़ा हो। इस तरह, यह O (1) स्थान की जटिलता के साथ नियम को लागू करते हुए, अंकों की संख्या से अधिक होगा।

अनलॉक्ड कोड यहां है:

import Data.Char

{- sub a b = sub2 0 a b
  where
    sub2 borrow (a:as) (b:bs) = res : sub2 borrow2 as bs
      where
        (borrow2, res) = subDig borrow a b
    sub2 borrow (a:as) [] = sub2 borrow (a:as) (0:[])
    sub2 _ [] _ = [] -}

--subDig :: Int -> Int -> Int -> (Int, Int)
subDig borrow a b = subDig2 (a - b - borrow)
  where
    subDig2 d = subDig3 d (d `mod` 10)
    subDig3 d r = ((r-d) `quot` 10, r)

seven ds = seven2 0 ds
seven2 borrow (d:e:f:gs) = seven2 (b + borrow2) (res:f:gs)
  where
    (a, b) = double d
    (borrow2, res) = subDig borrow e a
seven2 borrow (d:e:[]) = finalApp d (e-borrow)
seven2 borrow (d:[]) = d - borrow*10

double d = ((2*d) `mod` 10, (2*d) `quot` 10)

finalApp m 0 = m
finalApp m n = n - 2*m

num2stream :: Int -> [Int]
num2stream = reverse . map digitToInt . show
sev = seven . num2stream

यह कैसे काम करता है इसका सार यह है कि यह डिजिट-बाय-डिजिट घटाव एल्गोरिथ्म को लागू करता है , लेकिन इस तथ्य का लाभ उठाता है कि घटाया जाने वाला प्रत्येक नंबर अधिकांश 2-अंकों में है, और इसलिए हम इन 1 की एक मनमाना राशि घटा सकते हैं। या मुख्य एक से -2 अंकों की संख्या (साथ ही कम से कम महत्वपूर्ण अंक खाने)।

घटाव एल्गोरिथ्म हे (1) है और केवल वर्तमान 'उधार' मूल्य संग्रहीत करता है। मैंने इसे अतिरिक्त अंक (या तो 0 या 1) में जोड़ने के लिए बदल दिया, और हम ध्यान दें कि यह उधार मूल्य बंधा हुआ है (सीमा के भीतर [-2,2] इसलिए हमें इसे स्टोर करने के लिए केवल 3 बिट्स की आवश्यकता है)।

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

अंत में अंत में यह धारा में अंतिम दो अंकों को संसाधित करता है एक बार में अंकों की सूची के बजाय एकल-अंक संख्या वापस करने के लिए।

NB sevungolfed संस्करण में फ़ंक्शन एक पर काम करेगा Integer, इसे उलट धारा के रूप में परिवर्तित करेगा।

— नाइट्रोजनवाला
स्रोत

मेरा इरादा बोनस अंकों के सामान्य क्रम के लिए था। लेकिन मैंने इसे कभी नहीं कहा, इसलिए उलटे क्रम के लिए बोनस प्राप्त करना उचित है, भले ही यह कम मज़ेदार हो। वैसे भी, उलटा क्रम भी जितना मैंने सोचा था उससे कहीं ज्यादा कठिन है, इसलिए यह काफी मजेदार है!

— एनाटॉलीग

@anatolyg: धन्यवाद! मुझे यकीन नहीं है कि सामान्य आदेश के एक पास ओ (1) को लागू करना संभव है ... नियम कम से कम महत्वपूर्ण आंकड़ों पर निर्भर करता है, इसलिए सिद्धांत में नियम का सीधा आवेदन उलट क्रम को छोड़कर असंभव है। केवल एक और चीज जो मैं सोच सकता हूं वह है गणितीय रूप से समतुल्य रूप ढूंढना - उदाहरण के Mod[18 - Quotient[n, 10] - 2*n, 21] - 18 + Quotient[n, 10]लिए 10 और 99 के बीच n के लिए आनुभविक रूप से काम करता है, लेकिन अधिक अंक n को जटिल बनाता है ...

— नाइट्रस

हम्म मैं इसके बारे में सोचता था और ऐसा लगता था कि सामने के 2 अंकों को रखने और प्रत्येक बाद के अंक को लागू करने का एक तरीका हो सकता है, लेकिन (-2) ^ द्वारा गुणा करके इसे 'फ़िल्टरिंग' के रूप में लेने के लिए ... जहाँ तक मैं यह बता सकते हैं कि स्मृति में सभी अंकों को रखे बिना और ओ (1) 'नेस या यहां तक कि ओ (एन)' नेस के बिना इस काम को करने का कोई तरीका नहीं है ... मुझे लगता है कि सामान्य आदेश निश्चित रूप से असंभव है :(

— नाइट्रस

1

मुझे डर है कि आपको 0कॉल करते समय शुरुआती के बाइट्स की गणना करनी होगी !, जैसे, एक सेक्शन (0!)(+ एक नई पंक्ति), यानी +5 बाइट्स के रूप में। दूसरी तरफ आप पहले !से p![d]=और के मैच के पैटर्न को छोटा कर सकते हैं p![d,e]=। इसके अलावा, के उपयोग की पद्धति के बजाय रक्षा करता है let: p!(d:e:f)|(b,a)<-quotRem(2*d)10,(q,r)<-h$e-a-p=(b+q)!(r:f)।

— निम्मी

1

@nitrous: ओह मैं (0!)इसे खुद की एक लाइन पर उल्लेख करता हूं । (0!)वह फ़ंक्शन है जिसे आप अपने उत्तर के रूप में देते हैं। की 0आवश्यकता है, लेकिन इनपुट से कोई लेना-देना नहीं है, इसलिए आप इसे कॉल करने वाले को आउटसोर्स नहीं कर सकते। बेशक आप भी इस्तेमाल कर सकते हैं f x=0!x, लेकिन यह लंबा है।

— निम्मी

3

जीएनयू डीसी, 20 15 बाइट्स

[10~2*-d70<F]sF

यह मेरी पहली (कभी) डीसी फ़ंक्शन को परिभाषित करता है, F । यह स्टैक के शीर्ष पर इनपुट लेता है, और स्टैक के शीर्ष पर अपना आउटपुट छोड़ता है। उदाहरण का उपयोग:

36893488147419103232
lFxp
32

— टोबी स्पाईट
स्रोत

2

मेथेमेटिका, 47 44 बाइट्स

If[#>70,#0[{1,-2}.{⌊#/10⌋,#~Mod~10}],#]&

सरल पुनरावर्ती दृष्टिकोण। शायद आगे गोल्फ हो सकता है।

— LegionMammal978
स्रोत

#0[{1,-2}.QuotientRemainder[#,10]]एक बाइट बचाता है।

— njpipeorgan

2

आर, 43 बाइट्स

x=scan();while(x>70)x=floor(x/10)-x%%10*2;x

स्पष्टीकरण:

x=scan()                                      # Takes input as a double
        ;                                     # Next line
         while(x>70)                          # While-loop that runs as long x > 70
                      floor(x/10)             # Divide x by 10 and round that down
                                 -x%%10*2     # Substract twice the last integer
                    x=                        # Update x
                                         ;    # Next line once x <= 70
                                          x   # Print x

नमूना चलता है:

> x=scan();while(x>70)x=floor(x/10)-x%%10*2;x
1: 9999
2: 
Read 1 item
[1] -3

> x=scan();while(x>70)x=floor(x/10)-x%%10*2;x
1: 32767
2: 
Read 1 item
[1] 28

— Laterow
स्रोत

1

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

a=i=>i>70?a(Math.floor(i/10)-i%10*2):i

के साथ 36893488147419103232और का उपयोग कर विफल रहता है~~(1/10) विफल भी के लिए विफल हो जाएगा700168844221

परीक्षा:

a=i=>i>70?a(Math.floor(i/10)-i%10*2):i
O.textContent = O.textContent.replace(/(-?\d+) +(-?\d+)/g, (_,i,o) =>
  _+": "+(a(+i)==o?"OK":"Fail")
);

<pre id=O>1                       1
10                      10
100                     10
13                      13
42                      42
2016                    0
9                       9
99                      -9
9999                    -3
12345                   3
700168844221            70
36893488147419103232    32</pre>

स्निपेट का विस्तार करें

— andlrc
स्रोत

मुझे दो Failएस ... 70 और 32

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ Yea me to, मैं अभी भी सोच रहा हूँ क्यों ...

— andlrc

क्योंकि जावास्क्रिप्ट का प्रकार अंतिम मामले को नहीं संभालता है, कम से कम।

— कॉनर ओ'ब्रायन

1

f=n=>n>70?f((n-n%10*21)/10):nएक छोटा संस्करण है लेकिन फिर भी केवल उसी के लिए काम करता है 2**56।

— नील

@ नील ने मनमानी परिशुद्धता के लिए मेरा जवाब देखा, और कृपया गोल्फ के लिए स्वतंत्र महसूस करें, बहुत सराहना की।

— पैट्रिक रॉबर्ट्स

1

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

#//.a_/;a>70:>⌊a/10⌋-2a~Mod~10&

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

%[9999]
(* -3 *)

— njpipeorgan
स्रोत

1

पर्ल 5, 47 46 बाइट्स

bigintअंतिम परीक्षण मामले के लिए उपयोग करना था । (यह 20 के बिना देता है)

use bigint;$_=<>;while($_>9){$_-=2*chop;}print

वास्तव में यह सुनिश्चित नहीं है कि यह बोनस के लिए एक उम्मीदवार है, इसलिए मैंने इसे ध्यान में नहीं रखा। (मुझे लगता है कि यह करता है, लेकिन मैं वास्तव में अवधारणाओं का आदी नहीं हूं)

यहाँ यह कोशिश करो!

— पॉल पिकार्ड
स्रोत

1

ईएस 6, 108 बाइट्स

f=(s,n=0)=>s>1e9?f(s.slice(0,-1),((1+s.slice(-1)-n%10)%10*21+n-s.slice(-1))/10):s>9?f(((s-=n)-s%10*21)/10):s

2 but और 1000000000000000000001 के लिए काम करता है, लेकिन आगे गोल्फ का उपयोग कर सकता है।

— नील
स्रोत

@PatrickRoberts ओह, सबमिशन के लिए रिफॉर्मेटिंग करते समय ओवरसाइट।

— नील

1

जावास्क्रिप्ट ईएस 6, 140 142 बाइट्स

f=s=>s>9?eval("t=s.replace(/.$/,'-$&*2');for(i=-1;0>(n=eval(u=t[c='slice'](i-4)))&&u!=t;i--);n<0?n:f(t[c](0,i-4)+('0'.repeat(-i)+n)[c](i))"):s

यह सच मनमाना-सटीक गणित है, यहां तक कि सबसे बड़े परीक्षण-मामले पर भी काम करता है।

यह फ़ंक्शन स्ट्रिंग से अंतिम अंक को पुन: हटाता है, फिर अंतर को सकारात्मक रूप से लागू करने के लिए अंकों को लागू करने के लिए अंकों की मात्रा में वृद्धि द्वारा शेष संख्यात्मक स्ट्रिंग से 2 * अंतिम अंक घटाता है। फिर यह उस अंतर को उचित रूप से गद्देदार 0एस के साथ स्ट्रिंग के अंत तक जोड़ता है और अपने आप को पुनरावर्ती रूप से कहता है जब तक कि इसके संख्यात्मक मान से कम या बराबर नहीं हो 9।

@Neil के लिए 7 बाइट्स के लिए धन्यवाद गोल्फर (हाँ मुझे पता है कि मुझे 2 बाइट्स प्राप्त हुए हैं, लेकिन मैंने कुछ बग्स तय किए हैं जो फ़ंक्शन को फ्रीज़ करने या कुछ मामलों के लिए गलत आउटपुट देने का कारण बने)।

f=s=>s>9?eval("t=s.replace(/.$/,'-$&*2');for(i=-1;0>(n=eval(u=t[c='slice'](i-4)))&&u!=t;i--);n<0?n:f(t[c](0,i-4)+('0'.repeat(-i)+n)[c](i))"):s;[['1',1],['10',1],['100',1],['13',-5],['42',0],['2016',0],['9',9],['99',-9],['9999',-3],['12345',3],['700168844221',7],['36893488147419103232',-1],['231584178474632390847141970017375815706539969331281128078915168015826259279872',8]].map(a=>document.write(`<pre>${f(a[0])==a[1]?'PASS':'FAIL'} ${a[0]}=>${a[1]}</pre>`))

स्निपेट का विस्तार करें

— पैट्रिक रॉबर्ट्स
स्रोत

अच्छा लगा, लेकिन यह काम नहीं कर सकता 1000000000000000000001।

— नील

1

कोशिश करो s.replace(/.$/,'-$&*2')। हालांकि मुझे खेद है बाकी के लिए मेरे पास कोई स्पष्ट विचार नहीं है।

— नील

1

सी #, 111 104 बाइट्स

int d(int n){var s=""+n;return n<71?n:d(int.Parse(s.Remove(s.Length-1))-int.Parse(""+s[s.Length-1])*2);}

— TheLethalCoder
स्रोत

1

ब्रेन-फ्लैक , 368 360 बाइट्स

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

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

व्याख्या

सभी कोड को बंद करने के लिए एक लूप में है जो तब तक चलता है जब तक कि स्टैक के शीर्ष शून्य से कम न हो:

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

लूप के अंदर हम सात एल्गोरिथम द्वारा विभाज्य चलाते हैं:

ढेर के ऊपर डुप्लिकेट

(({}))

स्टैक के शीर्ष 10 का मॉड 10 (अंतिम अंक) लें

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

यह एक गड़बड़ है, लेकिन यह बाकी एल्गोरिथ्म मैं इसे बाद में समझा सकता है, लेकिन मुझे पूरी तरह से याद नहीं है कि यह कैसे काम करता है:

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

— गेहूं का जादूगर
स्रोत

1

सी, 56 बाइट्स - 75% = 14

यद्यपि यह परीक्षण के मामलों के समान सटीक संख्या नहीं देता है, यह प्रश्न की भावना को संतुष्ट करता है (और यकीनन अधिक)। यह 7 के सटीक गुणकों की सही पहचान करता है, और अन्य संख्याओं के लिए सटीक शेष देता है (क्योंकि यह कभी नकारात्मक संख्याओं का उपयोग नहीं करता है)।

n;f(char*c){for(n=0;*c;)n-=n>6?7:'0'-n-n-*c++;return n;}

एल्गोरिथ्म में कोई गुणन या विभाजन नहीं है, केवल जोड़ और घटाव, और अंकों को बाएं से दाएं एक ही पास में संसाधित किया जाता है। यह निम्नानुसार काम करता है, संचायक में 0 से शुरू होता है:

यदि आवश्यक हो तो 7 घटाएं, और फिर भी यदि आवश्यक हो
चल रहे कुल को तीन से गुणा करें, और अगला अंक जोड़ें

"तीन से गुणा करें" कदम को n-=-n-nएक बाइट को बचाने और मल्टीपल ऑपरेटर से बचने के लिए लिखा जाता है।

जब हम अंत को मारते हैं, तो हम सेविंग्स को घटाते नहीं हैं, इसलिए परिणाम 0-24 की सीमा में होगा; यदि आप एक सख्त मापांक (4-7) चाहते हैं, तो इसके *cसाथ स्थानापन्न *c||n>6करेंfor लूप स्थिति ।

यह बढ़ाया बोनस के लिए योग्य है, क्योंकि यह

मनमाना-सटीक पूर्णांक का समर्थन करता है
इनपुट पर केवल एक पास करता है, बाएं से दाएं क्रम में
अंतरिक्ष जटिलता हे (1)
समय जटिलता O (n) है।

परीक्षण कार्यक्रम और परिणाम

#include <stdio.h>
int main(int argc, char **argv) {
    while (*++argv)
        printf("%s -> %d\n", *argv, f(*argv));
    return 0;
}

540 -> 15
541 -> 16
542 -> 17
543 -> 18
544 -> 19
545 -> 20
546 -> 21
547 -> 22
548 -> 23
549 -> 24
550 -> 18
99 -> 15
999 -> 12
12345 -> 11
32767 -> 7
700168844221 -> 7
36893488147419103232 -> 11
231584178474632390847141970017375815706539969331281128078915168015826259279872 -> 11

वैकल्पिक संस्करण

यहाँ एक है कि पुनरावृत्ति होती है (आप संकलक अनुकूलन को टेल-कॉल परिवर्तन करने में सक्षम करना चाहते हैं या आप अपने स्टैक को ओवरफ्लो कर सकते हैं; उपयोग किया जाता है gcc -std=c89 -O3::

f(c,n)char*c;{return n>6?f(c,n-7):*c?f(c+1,n+n+n+*c-'0'):n;}

इसे दूसरे तर्क के रूप में '0' के साथ कहें।

दोनों संस्करण मेरी मशीन पर 50 मिलीसेकंड से कम में 60,000 अंकों की संख्या के शेष-मॉडुलो-सात की गणना करते हैं।

— टोबी स्पाईट
स्रोत

बोनस के लिए धन्यवाद - यह सी के लिए एक वास्तविक परिवर्तन बनाता है ताकि प्रतिस्पर्धा समाप्त हो सके! वर्तमान में केवल जेली (11) और पायथ (13) से हराया । :-)

— टोबी स्पाइट

1

PHP, 50 बाइट्स

for($n=$argv[1];$n>9;)$n=$n/10|0-2*($n%10);echo$n;

वैकल्पिक आउटपुट का उपयोग करता है; तक काम करता हैPHP_INT_MAX

स्ट्रिंग संस्करण, किसी भी (सकारात्मक) संख्या (64 बाइट्स) के लिए काम करता है:

for($n=$argv[1];$n>9;)$n=substr($n,0,-1)-2*substr($n,-1);echo$n;

— टाइटस
स्रोत

0

जावा, 133 बाइट्स

int d(int n){String s=""+n;return n<71?n:d(Integer.parseInt(s.replaceFirst(".$",""))-Integer.parseInt(""+s.charAt(s.length()-1))*2);}

मुझे नफरत है कि कैसे क्रिया Integer.parseIntहै। Ungolfed:

static int div(int n) {
    if (n <= 70) {
        return n;
    } else {
        String num = ("" + n);
        int last = Integer.parseInt("" + num.charAt(num.length() - 1));
        int k = Integer.parseInt(num.replaceFirst(".$", "")) - last * 2;
        return div(k);
    }
}

— जस्टिन
स्रोत

विभाज्यता-दर -7 नियम को लागू करें

गोल्फस्क्रिप्ट, 27 22 बाइट्स

व्याख्या

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

जेली, 11 बाइट्स

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

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

पायथ, 13 बाइट्स

स्पष्टीकरण:

जूलिया, 27 26 बाइट्स

पायथ, 17 बाइट्स

व्याख्या

सीजाम - 19 बाइट्स

Oracle SQL 11.2, 116 बाइट्स

हास्केल, 157 192 184 167 159 147 138 + 5 बाइट्स - 50% = 71.5 बाइट्स

जीएनयू डीसी, 20 15 बाइट्स

मेथेमेटिका, 47 44 बाइट्स

आर, 43 बाइट्स

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

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

पर्ल 5, 47 46 बाइट्स

ईएस 6, 108 बाइट्स

जावास्क्रिप्ट ईएस 6, 140 142 बाइट्स

सी #, 111 104 बाइट्स

ब्रेन-फ्लैक , 368 360 बाइट्स

व्याख्या

सी, 56 बाइट्स - 75% = 14

परीक्षण कार्यक्रम और परिणाम

वैकल्पिक संस्करण

PHP, 50 बाइट्स

जावा, 133 बाइट्स