26

मुझे लगता है कि आसपास के अधिकांश लोग जानते हैं कि अंकों के लिए 7-खंड का प्रदर्शन क्या है:

 _         _   _         _    _    _    _    _ 
| |    |   _|  _|  |_|  |_   |_     |  |_|  |_|
|_|    |  |_   _|    |   _|  |_|    |  |_|   _|

हम परिभाषित कर सकते हैं 7-खंड अंतर दोनों के बीच (7SD) अंक खंडों अन्य एक से स्विच करने के लिए टॉगल किया जा करने की जरूरत है कि की संख्या होने के लिए। उदाहरण के बीच 7SD 1और 2है 5 (तीन क्षैतिज क्षेत्रों और कम दो ऊर्ध्वाधर क्षेत्रों टॉगल किया जा करने की जरूरत है), और के बीच 6 और 8 है 7SD 1 ।

इसके अलावा, हम उनके समान अंकों के बीच 7SD का योग होने के लिए दो संख्याओं के बीच 7SD को परिभाषित कर सकते हैं । यदि एक संख्या दूसरे से अधिक है, तो हम मानते हैं कि वे सही-संरेखित हैं और बड़ी संख्या के अतिरिक्त सबसे महत्वपूर्ण अंकों को प्रदर्शित करने के लिए आवश्यक सेगमेंट की संख्या को जोड़ते हैं। एक उदाहरण के रूप में, के बीच 7SD पर विचार करें 12345और 549:

  x:  1 2 3 4 5
  y:      5 4 9
7SD:  2+5+2+0+1 = 10

आपका काम करने के लिए है के बीच 7SD गणना n और n + 1 , यह देखते हुए एन ।

सुविधा के लिए, यहां व्यक्तिगत अंकों के बीच 7SD की पूरी तालिका है। पंक्ति _एक खाली स्थिति का प्रतिनिधित्व करती है।

   _ 0 1 2 3 4 5 6 7 8 9

_  0 6 2 5 5 4 5 6 3 7 6
0  6 0 4 3 3 4 3 2 3 1 2
1  2 4 0 5 3 2 5 6 1 5 4
2  5 3 5 0 2 5 4 3 4 2 3
3  5 3 3 2 0 3 2 3 2 2 1
4  4 4 2 5 3 0 3 4 3 3 2
5  5 3 5 4 2 3 0 1 4 2 1
6  6 2 6 3 3 4 1 0 5 1 2
7  3 3 1 4 2 3 4 5 0 4 3
8  7 1 5 2 2 3 2 1 4 0 1
9  6 2 4 3 1 2 1 2 3 1 0

इनपुट

इनपुट एकल धनात्मक पूर्णांक है n।
आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेते हुए एक प्रोग्राम या फ़ंक्शन लिख सकते हैं।
आप मान सकते हैं कि इनपुट सबसे बड़ी संख्या से कम से कम एक है जो आपकी भाषा के मानक पूर्णांक प्रकार द्वारा दर्शाया जा सकता है, जब तक कि वह प्रकार 127 तक और कम से कम मूल्यों का समर्थन करता है।

उत्पादन

आपको एक पूर्णांक, 7SD के बीच nऔर प्रिंट करना चाहिए n+1।
आप STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) तर्क के माध्यम से आउटपुट कर सकते हैं।

स्कोरिंग

मानक कोड-गोल्फ नियम लागू होते हैं, सबसे छोटा कोड (बाइट्स में) जीतता है।

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

कुछ अस्पष्ट कारणों के लिए, यह अनुक्रम अभी तक OEIS में नहीं है, हालांकि निकट संबंधी अनुक्रम A123587 है । यहां पहले 100 नंबर हैं (शुरुआत के साथ n = 1, 2, 3, ...):

5, 2, 3, 3, 1, 5, 4, 1, 4, 4, 5, 2, 3, 3, 1, 5, 4, 1, 7, 4, 5, 2, 3, 3, 1, 
5, 4, 1, 4, 4, 5, 2, 3, 3, 1, 5, 4, 1, 5, 4, 5, 2, 3, 3, 1, 5, 4, 1, 5, 4, 
5, 2, 3, 3, 1, 5, 4, 1, 3, 4, 5, 2, 3, 3, 1, 5, 4, 1, 7, 4, 5, 2, 3, 3, 1, 
5, 4, 1, 6, 4, 5, 2, 3, 3, 1, 5, 4, 1, 3, 4, 5, 2, 3, 3, 1, 5, 4, 1, 6, 4

पहला इनपुट जिसके लिए 7SD 9 से अधिक है, 1999जो 11 उपज चाहिए। यहां कुछ अन्य बड़े उदाहरण दिए गए हैं:

n          7SD
1999        11
12345        1
999999      14
5699999     15
8765210248   1

code-golf number counting

— मार्टिन एंडर
स्रोत

8

जेली , 25 22 21 20 बाइट्स

‘DṁDḟ"DFị9979482ḃ5¤S

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

हम पहले इनपुट n को बढ़ाते हैं और बदले गए n + 1 के सभी अंकों को छोड़ देते हैं।

उदाहरण के लिए, यदि n है 5699999 , हम निम्नलिखित मिलता है।

n     : 5700000
n + 1 : 5699999
Result:  700000

इस परिणाम के सभी अंकों में निश्चित सेगमेंट होते हैं जिन्हें टॉगल करना होता है। हम कुछ बाइट्स को बचाने के लिए टॉगल की सूची को विशेषण आधार 5 में बदल सकते हैं ।

digit:   1 2 3 4 5 6 7 8 9 0
toggles: 4 5 2 3 3 1 5 4 1 2

आउटपुट केवल व्यक्तिगत टॉगल का योग है।

यह n के अधिकांश मानों के लिए काम करता है , लेकिन विशेष ध्यान रखा जाना चाहिए यदि n + 1 में n से अधिक अंक हों । इस स्थिति में, सभी अंक 9 के होने चाहिए , और हम n + 1 से 0 से पीछे चल रहे इस समस्या को हल करते हैं ।

उदाहरण के लिए, यदि n है 999999 , हम निम्नलिखित मिलता है।

n     :  999999
n + 1 : 1000000
Result: 100000

यह काम करता है क्योंकि अग्रणी 1 4 टॉगल ( 0 और 1 के बीच की दूरी ) का मूल्यांकन करता है , जबकि टॉगल की वास्तविक राशि 2 ( 0 और 1 के बीच की दूरी ) है, और एक अनुगामी 0 को दबाने से इसके 2 टॉगल को हटा दिया जाता है ।

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

‘DṁDḟ"DFị9979482ḃ5¤S  Main link. Argument: n

‘                     Compute n+1.
 D                    Convert n+1 from integer to base 10.
   D                  Convert n from integer to base 10.
  ṁ                   Mold the left result as the right result.
                      This chops of a 0 if n+1 has more digits than n.
    ḟ"D               Vectorized filter-false with the base 10 digits of n.
                      This removes the digits from n+1 that are identical to
                      the corresponding digits of n.
       F              Flatten the resulting list of lists.
         9979482ḃ5¤   Convert 9979482 to bijective base 5.
                      This yields [4, 5, 2, 3, 3, 1, 5, 4, 1, 2].
        ị             Retrieve the digits at the right that correspond to the
                      indices at the left.
                   S  Compute the sum of the results.

— डेनिस
स्रोत

10

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

f=n=>n?+"452331541"[n%10]||f(n/10|0)+2:2

वैकल्पिक सूत्रीकरण, भी 46 40 बाइट्स:

f=n=>n?26523308>>n%10*3&7||f(n/10|0)+2:2

संपादित करें: @xsot के लिए 6 बाइट्स सहेजे गए।

— नील
स्रोत

यदि ईएस 6 में तार्किक या ऑपरेटर अजगर की तरह व्यवहार करता है तो आप अपने दूसरे कोड को छोटा कर सकते हैं। एक उदाहरण के लिए मेरे प्रस्तुत करने का संदर्भ लें।

— xsot

@xsot असल में मैं दोनों को छोटा कर सकता हूं! मुझे नहीं लगता कि यह मुझे शून्य विशेष-केस को बदलने में मदद करता है क्योंकि यह केवल 4 बाइट्स के रूप में है।

— नील

वाह, मुझे आश्चर्य है कि पहला काम करता है। मुझे एक त्रुटि की उम्मीद थी।

— xsot

@xsot जावास्क्रिप्ट बस त्रुटि नहीं करता है। यह सिर्फ उन दस दिनों के दौरान सबसे सही दृष्टिकोण की तरह लग रहा था कि जावास्क्रिप्ट का जन्म हुआ था। । बाद के संस्करणों ने आपको थोड़ा सख्त व्यवहार करने का विकल्प दिया, लेकिन यहां कोई ऐसा क्यों करेगा? तार्किक परिचालकों का शार्टसर्किटिंग व्यवहार बहुत आम है, हालांकि, केवल PHP हमेशा गलत तरीके से बूलियन वापस करके गलत काम करता है।

— जॉन ड्वोरक

@JDDvorak असल में, मैं इस तथ्य से हैरान था कि आप स्ट्रिंग की लंबाई से बड़े स्ट्रिंग के सूचकांक तक पहुंच सकते हैं।

— xsot

10

पायथन, 50 48 बाइट्स

f=lambda n:26523308-0**n*2>>n%10*3&7or f(n/10)+2

व्याख्या

यह फ़ंक्शन संख्या के कम से कम महत्वपूर्ण अंक पर काम करता है n, पहले गैर- 9अंक के बाद एक-एक करके बढ़ाए जाने पर अंकों के 7SD का योग करता है ।

26523308एक बिटमास्क है जो अंकों के लिए मैपिंग को एन्कोड करता है 0-8। जब n=0, जो केवल तब होता है जब nकेवल 9एस शामिल होता है , तो उत्तर दो से बंद हो जाएगा। इसकी अभिव्यक्ति द्वारा मुआवजा दिया जाता है 0**n*2। अंक के लिए 9, बिटमास्क शून्य का मूल्यांकन करता है जो 27SD में जोड़ते समय पुनरावर्ती कॉल को ट्रिगर करेगा ।

— xsot
स्रोत

क्या हम इस बात का कुछ स्पष्टीकरण दे सकते हैं कि यह परिवर्तन कैसे करता है? मेरा मतलब है, चतुरता के लिए +1 लेकिन मैं चतुर में खो गया।

— CAD97

8

05AB1E , 31 30 28 27 26 बाइट्स

कोड:

9Ü©T%•2X›ùì•sè¹g®g-·¹Ú9Q·O

स्पष्टीकरण ( पुराना ):

9Ü                              # Trim off trailing 9's
  ©                             # Copy this into the register
   T%                           # Get the last non-9 digit
     žh                         # Short for 0123456789
       •2X›ùì•§                 # Compressed version of 4523315412
               ‡                # Transliterate

हम निम्नलिखित को गैर-९ अंक में बदल रहे हैं:

0 -> 4
1 -> 5
2 -> 2
3 -> 3
4 -> 3
5 -> 1
6 -> 5
7 -> 4
8 -> 1
9 -> 2

विशेष मामलों के लिए:

                ¹g              # Get the length of the input
                  ®g            # Get the length of the input with all trailing 9 gone
                    -           # Substract, giving the number of 9's at the end of 
                                  the input
                     2*         # Multiply by two
                       O        # Sum everything up
                        ¹Ú      # Uniquify the input
                          9Qi   # If this is equal to 9 (only 9's in the input)
                             Ì  #   Increment by 2 (_ -> 1)

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

28 बाइट विकल्प D[¤©•2X›ùì•sès®9Ê#¨]\rÚ9Q4*O:।

— अदनान
स्रोत

5

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

दुनिया को सही माना जाता है क्योंकि अजगर एक बार फिर जावा से गुजरता है।

कारण, फिर पता है, जावा।

int f(int n){return n>0?n%10<9?26523308>>n%10*3&7:2+f(n/10):2;}

इसे आइडोन पर देखें

2147483647 पर मैक्स निकलता है, जैसा कि जावा का है Integer.MAX_VALUE।

यह मेरे पायथन उत्तर का एक बंदरगाह है जो ES6 उत्तर का एक बंदरगाह है ।

— CAD97
स्रोत

3

MATL , 61 39 36 बाइट्स

tQvV15\'3dAsMh818RG5'6Y27WZaw)Z}Z~Bz

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

व्याख्या

tQv            % Implicit input. Duplicate, add 1, concatenate vertically
V              % Convert to 2D char array: each number in a row, possibly left-padded 
               % with a space
15\            % Modulo 15. With modular indexing this corresponds to the order
               % '9', ' ', '0', '1', ..., '8'
'3dAsMh818RG5' % This string encodes active segments for each of the 11 chars
6Y2            % Source alphabet printable ASCII chars (predefined literal)
7W             % Target alphabet: [0 1 ... 127]
Za             % Base conversion: decode string into vector of 11 numbers, where each
               % number from 0 to 127 encodes the 7-segment representation of a digit,
               % in the order '9', ' ', '0', '1', ..., '8'
w              % Swap top two elements in stack
)              % Use as index. Gives 2-row array, where each column is a digit 
Z}             % Split into the two rows
Z~             % Bitwise XOR, elementwise
B              % Convert to binary. Each number gives a row
z              % Number of nonzero elements. Implicitly display

— लुइस मेंडो
स्रोत

3

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

!x=x<1?2:(t=x%10÷1)<9?3045058÷6^t%6:2+!.1x

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

डेनिस ने बाइट बचाई!

— लिन
स्रोत

1

जिज्ञासा से बाहर, क्यों न केवल संख्या का उपयोग करें?

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

मुझे विश्वास नहीं हो रहा है कि एक जूलिया टीआईओ है। वेल्ड, जूलिया को सीखने का समय ...

— मामा फन रोल

3

पायथन, 71 66 बाइट्स

Xsot द्वारा 48 बाइट्स । और भी अधिक जादू गणित!

f=lambda n:(2+f(n/10)if n%10==9else 26523308>>n%10*3&7)if n else 2

इसे आइडोन पर देखें

क्योंकि पहले पायथन जवाब काम नहीं करता है और इष्टतम से बहुत दूर है। पिछले ES6 संस्करण का एक सरल पोर्ट । अब एक कलाकारों को काटने के लिए बिट टिडलिंग (ES6 वैकल्पिक सूत्रीकरण से) का उपयोग कर रहे हैं!

+1 बाइट के लिए फ्लोर्डिव का उपयोग करके पायथन 3 के साथ काम करने के लिए बनाया जा सकता है।

— CAD97
स्रोत

आप बाद में अंतरिक्ष निकाल सकते हैं9

— माल्टसेन

@ मैलेटेन जाहिर है कि आप सही हैं। मुझे लगा कि इसमें त्रुटि होगी क्योंकि eएक अंक के बाद एक वैध पत्र है, उदाहरण के लिए 9e9,।

— सीएडी 97

यह मेरे जावा उत्तर से अधिक लंबा है ! हम इसका उपाय कैसे कर सकते हैं? ध्यान दें कि से तुलना पीछे n%10==9करने के लिए n%10<9करता है, तो इस क्रम में एक स्थान की जरूरत नहीं है के रूप में सहेज नहीं करता है।

— सीएडी 97

और मैं यह देखने के लिए वापस आया कि xsot ने बहुत कम पायथन संस्करण बनाया है। बहुत बढ़िया!

— CAD97

2

जोल्फ, 32 बाइट्स

Ώ?H?<γ%Ht9P."452331541"γ+2Ώc/Ht2

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

व्याख्या

यह नील के उत्तर का एक रूपांतरण है।

Ώ?H?<γ%Ht9P."452331541"γ+2Ώc/Ht2
Ώ                                 define a function Ώ of H
 ?H                            2  (when H is zero, return is 2)
      %Ht                         H mod 10
     γ                            γ = ^
   ?<    9                        is it less than 9?
                                  if so:
           ."452331541"γ           get the γth element of that string
          P                        as a number
                                  else
                        +2         add two to
                          Ώ        Ώ over
                           c/Ht    int(H / 10)

— कोनोर ओ ब्रायन
स्रोत

2

पायथ - 78 30 27 बाइट्स

वह पहले एक शर्मनाक था।

s@LjC"
(J"ThC{I#.tjRThBQT

टेस्ट सूट ।

— Maltysen
स्रोत

26 बाइट्स

— लीक नन

26 बाइट्स

— लीक नन

0

जे, 53 बाइट्स

2:`((2+10$:@<.@%~[)`(6|3045058<.@%6^])@.(9>])10&|)@.*

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

स्ट्रिंग पर आधारित 54 बाइट संस्करण है

2:`((2+10$:@<.@%~[)`('452331541'".@{~])@.(9>])10&|)@.*

प्रयोग

   f =: 2:`((2+10$:@<.@%~[)`(6|3045058<.@%6^])@.(9>])10&|)@.*
   f 1999
11
   f 1999 12345 999999 5699999 8765210248
11 1 14 15 1

— मील की दूरी पर
स्रोत

0

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

M!`.9*$
^9
0
T`d`4523315412
.
$*
.

इसे ऑनलाइन आज़माएं! (पहली पंक्ति सिर्फ एक बार में कई परीक्षण मामलों के प्रसंस्करण की अनुमति देती है।)

व्याख्या

अब तक खोजे गए अधिकांश उत्तरों की तरह, हमें पूर्ण तालिका का उपयोग करने की आवश्यकता नहीं है, क्योंकि 9वेतन वृद्धि के समय केवल कम से कम गैर- अंकीय परिवर्तन होते हैं। यह भी है कि यह उत्तर कैसे काम करता है।

M!`.9*$

यह मैच ( M) रेगेक्स .9*$यानी पहला अंक जो केवल 9अंत से s द्वारा अलग किया जाता है । !रेटिना बताता है इस मैच के साथ इनपुट को बदलने के लिए, सब कुछ है कि 7SD को प्रभावित नहीं करता त्यागकर।

^9
0

इनपुट अब एक साथ शुरू होता है 9कि इसका मतलब है, इनपुट ही शामिल केवल की 9, रों इसलिए 7-खंड प्रदर्शन की जरूरत है एक पहले जोड़ें करने के लिए 1जो लागत 2। इसे संभालने का सबसे सरल तरीका 9इस मामले में अग्रणी को ए से बदलना है 0, क्योंकि वेतन वृद्धि 9(से 0) 2की लागत है और वेतन वृद्धि 0(से 1) की लागत है 4, इसलिए यह 2आवश्यकता के अनुसार समग्र लागत को बढ़ाता है।

T`d`4523315412

अब हमारे पास एक लिप्यंतरण चरण है जो प्रत्येक अंक को इसे बढ़ाने के लिए इसकी लागत के साथ बदल देता है (जब से dविस्तार होता है 0123456789)। ध्यान दें कि यह 7SD टेबल का पहला सबडिऑंगल है।

.
$*

यह प्रत्येक अंक nको nप्रतियों के साथ बदल देता है 1, अर्थात यह प्रत्येक अंक को एकात्मक में बदल देता है, और चूंकि कोई विभाजक नहीं हैं, इसलिए तुरंत उन्हें एक साथ जोड़ देता है।

अंत में, हम .परिणाम में वर्णों की संख्या (अर्थात मिलानों की संख्या ) की गणना करते हैं , जो दशमलव में वापस आने वाली एकात्मक राशि को परिवर्तित करता है।

— मार्टिन एंडर
स्रोत

-खंड भेद

इनपुट

उत्पादन

स्कोरिंग

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

जेली , 25 22 21 20 बाइट्स

पृष्ठभूमि

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

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

पायथन, 50 48 बाइट्स

व्याख्या

05AB1E , 31 30 28 27 26 बाइट्स

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

MATL , 61 39 36 बाइट्स

व्याख्या

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

पायथन, 71 66 बाइट्स

जोल्फ, 32 बाइट्स

व्याख्या

पायथ - 78 30 27 बाइट्स

जे, 53 बाइट्स

प्रयोग

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

व्याख्या