एक संख्या का विस्तार करें

11

एक संख्या का विस्तार करें

आपका कार्य निम्नलिखित तरीके से 0 से अधिक पूर्णांक का विस्तार करना है:

दशमलव अंकों में संख्या को विभाजित करें और प्रत्येक अंक के लिए इन नियमों के अनुसार एक सूची बनाएं:

  • यदि अंक विषम है, तो सूची अंक से शुरू होती है और 1 से नीचे चली जाती है;
  • यदि अंक समान है, तो सूची अंक से शुरू होती है और 9 तक जाती है।
  • यदि अंक 0 है, तो सूची खाली है।

अंकों के नीचे विषम संख्याओं के लिए और नीचे वालों के लिए सूचियों को लिखें। फिर स्तंभों को शीर्ष-संरेखित करें और पूर्णांक बनाने के लिए प्रत्येक पंक्ति में अंक एकत्र करें। अंतिम चरण के रूप में संख्या के विस्तार को खोजने के लिए संख्याओं को जोड़ें।

यहां 34607 पर लागू उपरोक्त नियमों का एक उदाहरण दिया गया है:

 9          
 8          
 79         
 68         
 57         
346 7 ->  399 7 -> 3997 -> 9418
2   6     288 6    2886
1   5     177 5    1775
    4      66 4     664
    3      5  3      53
    2      4  2      42 
    1         1       1

यहाँ परीक्षण के मामले हैं:

1: 1
2: 44
3: 6
44: 429
217: 1270
911: 947
2345: 26114
20067: 3450
34875632: 70664504
9348765347634763: 18406119382875401

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत में बाइट्स में सबसे छोटा उत्तर है।

code-golf  number 
— गैलेन इवानोव
स्रोत
1
क्या हम एक स्ट्रिंग के रूप में इनपुट ले सकते हैं? या अंकों की एक सरणी के रूप में?
— Arnauld
@ अरनल्ड यह एक पूर्णांक होना चाहिए, और इसे अपने प्रोग्राम / फ़ंक्शन के साथ अंकों में विभाजित करने के लिए
— गैलेन इवानोव
@GalenIvanov लेकिन अगर इनपुट स्टड से है, तो मुझे लगता है कि यह ठीक है (भले ही तकनीकी रूप से एक स्ट्रिंग है), ठीक है?
— 22
@ Adám हां, तकनीकी रूप से यह एक स्ट्रिंग है, इसलिए यह ठीक है।
— गैलेन इवानोव
और यहां मैंने सोचा कि यह इस तरह का विस्तार होगा ।
— इंजीनियर टोस्ट

जवाबों:

8

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

Dḟ0RrḂ?€9UZḌS

सकारात्मक पूर्णांकों को लेने और वापस करने वाला एक विचित्र लिंक।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

कैसे?

Dḟ0RrḂ?€9UZḌS - Link: positive integer           e.g. 702
D             - cast to a decimal list                [7,0,2]
  0           - literal zero                          0
 ḟ            - filter discard                        [7,2]
        9     - literal nine
       €      - for each:
      ?       -   if:
     Ḃ        -   ...condition: bit (modulo by 2)      1              ,0
   R          -   ...then: range ([1,...n])            [1,2,3,4,5,6,7],n/a
    r         -   ...else: inclusive range ([n,...9])  n/a            ,[2,3,4,5,6,7,8,9]
         U    - upend                                 [[7,6,5,4,3,2,1],[9,8,7,6,5,4,3,2]]
          Z   - transpose                             [[7,9],[6,8],[5,7],[4,6],[3,5],[2,4],[1,3],2]
           Ḍ  - cast from decimal lists               [79,68,57,46,35,24,13,2]
            S - sum                                   324
— जोनाथन एलन
स्रोत
4

पर्ल 6 ,  68  66 बाइट्स

{sum roundrobin(.comb».&{$_%2??($_...1)!!(9...+$_) if +$_})».join}

कोशिश करो

{sum roundrobin(.comb».&{[R,] $_%2??1..$_!!$_..9 if +$_})».join}

कोशिश करो

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  sum

    roundrobin( # grab from the sub lists in a round robin fashion

      .comb\             # split the input into digits
      ».&{               # for each digit do this

        [R,]             # reduce with reversed &infix:«,» (shorter than reverse)

              $_ % 2     # is the digit not divisible by 2?
          ??  1  .. $_   # from 1 to the digit
          !!  $_ ..  9   # from the digit to 9

        if +$_           # only do the above if the current digit isn't 0
                         # (has the effect of removing 0 from the list)
     }

    )».join     # join each of the sub-lists from roundrobin
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
3

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

पूरा कार्यक्रम निकाय STDIN से इनपुट के लिए संकेत प्रिंट STDOUT का परिणाम है।

+/10⊥¨0~⍨¨↓⍉↑{2|⍵:⌽⍳⍵⋄×⍵:⌽⍵,⍵↓⍳9⋄⍬}¨⍎¨⍞

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

अंतिम परीक्षण मामले को सही ढंग से प्रदर्शित करने के लिए, ⎕FR( F loating-point R epretation ) को 128-बिट डेसीमल और ⎕PP( P rint P recision) को 34 अंकों में सेट किया गया है।

⍞ STDIN से पाठ इनपुट के लिए संकेत

⍎¨ प्रत्येक को निष्पादित करें (प्रत्येक अंक को एक संख्या के रूप में प्राप्त करें)

{... }¨ प्रत्येक तत्व के लिए, निम्नलिखित फ़ंक्शन को लागू करें जहां तर्क द्वारा दर्शाया गया है ⍵:

 2|⍵: अगर विषम (lit. "if" विभाजन शेष रहने पर 2 से विभाजित होता है), तो:

  ⌽ उलटना

  ⍳ɩ 1 से ntegers तक

  ⍵ बहस

 ⋄ अन्य

 ×⍵: यदि तर्क सकारात्मक है (lit. "if" signum), तो:

  ⌽ उलटना

  ⍵ बहस

  , के बाद

  ⍵ बहस

  ↓ तत्वों से गिरा दिया

  ⍳9 the ntegers 1 से 9 तक

 ⋄ अन्य

  ⍬ खाली सूची

↑ मिक्स (संयोजित) सूचियों की इस सूची को एक मैट्रिक्स में, दाईं ओर शून्य के साथ पैडिंग करें

⍉ पक्षांतरित

↓ इस मैट्रिक्स को सूचियों की सूची में विभाजित करें

0~⍨¨ प्रत्येक सूची से सभी शून्य हटा दें

10⊥¨ आधार -10 से प्रत्येक को सामान्य संख्या में परिवर्तित करें (यह अंक एकत्र करता है)

+/ संख्या का योग

— एडम
स्रोत
2
आपके विवरण के लिए धन्यवाद। बस आपको यह बताने के लिए कि मैंने एपीएल कोड गोल्फ वीडियो में आपको देखने के बाद कोड गोल्फ की खोज की।
— गैलेन इवानोव
3

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

f=(n,k=0)=>k<9&&+[...n+''].map(x=>+x&&(x=x&1?x:9-k<x||9)>k?x-k:'').join``+f(n,k+1)

ध्यान दें

9 - k < x || 9एक बाइट को बचाता है, 9 - k >= x && 9लेकिन अगर असमानता सत्यापित है 1, 0तो इसके बजाय उत्पन्न करता है। 1 > kबाहरी टर्नरी में गलत रास्ते को ट्रिगर करने के लिए अगर यह आगे बढ़ा , तो यह एक समस्या होगी । लेकिन इसका मतलब यह होगा k = 0और इसलिए 9 - k = 9, इसलिए हम संभवतः 9 - k < xएक ही समय में नहीं हो सकते ।

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

एनबी: पिछले परीक्षण मामले को हटा दिया जो जेएस संख्या परिशुद्धता से अधिक है।

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
3

जावा 11, 210 209 191 181 बाइट्स

n->{long r=0;var a="0".repeat(9).split("");for(int d:(n+"").getBytes())for(int k=0,x=d-48,y=9;x>0&(k<1||(d%2<1?y-->x:x-->1));a[k++]+=d%2<1?y:x);for(var q:a)r+=new Long(q);return r;}

ठीक है, इसमें काफी समय लगा (मुख्यतः क्योंकि मैंने पहली बार गलती की थी, इसलिए मुझे बेहतर समझने के लिए प्रत्येक चरण को लिखने के लिए नीचे लिखना पड़ा)। सबसे अधिक संभावना कुछ और गोल्फ हो सकती है।

-18 बाइट्स @ceilingcat की बदौलत ।

स्पष्टीकरण:

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

n->{                             // Method with long as both parameter and return-type
  long r=0;                      //  Result-long `r`, starting at 0
  var a="0".repeat(9).split(""); //  String array `a`, filled with nine String zeroes
  for(int d:(n+"").getBytes())   //  Cast the input to a String,
                                 //   and loop over its codepoints as integers:
    for(int k=0,                 //   Row-index `k`, starting at
        x=d-48,                  //   Temp integer `x`, set to the current digit
        y=9                      //   Temp integer `y`, set to 9
        ;                        //   Inner loop, if:
         x>0                     //     The current digit is not a 0,
          &(k<1                  //     and if this is the first iteration,
             ||(d%2<1?           //     or if the digit is even:
                 y-->x           //      And `y` is larger than the digit
                                 //      (and afterwards decrease `y` by 1 with `y--`)
                :                //     or if the digit is odd:
                 x-->1));        //      And `x` is larger than 1
                                 //      (and afterwards decrease `x` by 1 with `x--`)
      a[k++]+=                   //    Append the current row with:
                                 //    (and afterwards increase `k` by 1 with `k++`)
       d%2<1?                    //     If the digit is even:
        y                        //      Append the row with `y`
       :                         //     Else (the digit is odd):
        x);                      //      Append the row with `x`
  for(var q:a)                   //  Loop over the String rows in the array:
    r+=new Long(q);              //   Convert it to a long, and add it to the result-sum
  return r;}                     //  Return the result
— केविन क्रूज़सेन
स्रोत
2

पिप , 28 बाइट्स

J_MS(RV{a?a%2?\,aa,tl}Ma)ZDx

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

व्याख्या

                      Ma      Map this function to the digits of the 1st cmdline arg:
        a?                     If digit != 0:
          a%2?                  If digit is odd:
              \,a                Inclusive-range(digit)
                 a,t            Else (digit is even), range from digit to 10 (exclusive)
                    l          Else (digit is 0), empty list
     RV{             }         Apply reverse to the result before returning it
                              This gives us a list of lists like [9 8 7 6] or [3 2 1]
    (                   )ZDx  Zip, with a default value of empty string
J_MS                          Use map-sum to join each sublist and sum the results
                              Autoprint (implicit)

कैसे कदम 34607तर्क के साथ आगे बढ़ते हैं :

34607
[[1 2 3] [4 5 6 7 8 9] [6 7 8 9] [] [1 2 3 4 5 6 7]]
[[3 2 1] [9 8 7 6 5 4] [9 8 7 6] [] [7 6 5 4 3 2 1]]
[[3 9 9 "" 7] [2 8 8 "" 6] [1 7 7 "" 5] ["" 6 6 "" 4] ["" 5 "" "" 3] ["" 4 "" "" 2] ["" "" "" "" 1]]
[3997 2886 1775 664 53 42 1]
9418
— DLosc
स्रोत
2

आर , 153 146 बाइट्स

function(n,m=n%/%10^(nchar(n):0)%%10)sum(strtoi(apply(sapply(m[m>0],function(x)c(r<-"if"(x%%2,x:1,9:x),rep("",9-sum(r|1)))),1,paste,collapse="")))

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

कभी-कभी, मैं यह नहीं बता सकता कि क्या मैं केवल गोल्फ में कचरा कर रहा हूं, या यदि आर है .... यह निश्चित रूप से मुझे है, 723 बटर को धन्यवाद दिया गया user2390246, जिसने मुझे अंकों को निकालने का एक और तरीका याद दिलाया (जो मैंने खुद को सुझाया था) ।

आप की जगह ले सकती strtoiसाथ as.doubleपाने के लिए 18406718084351604अंतिम परीक्षण मामले के लिए (जो गलत है); केवल 32-बिट पूर्णांक हैं।

— ग्यूसेप
स्रोत
आप एक पूर्णांक के रूप में n ले कर और अपनी एक चाल का उपयोग करके अंकों में परिवर्तित करके थोड़ा बचा सकते हैं! 146 बाइट्स
— user2390246
@ user2390246 आप जानते हैं, मैंने कोशिश की थी, लेकिन मुझे लगता है कि character->intजब मुझे बुलाया गया था :और तब strtoiवैसे भी इस्तेमाल किया गया था, तब मुझे निहित रूपांतरण का उपयोग करने पर ठीक किया गया था !
— Giuseppe
1

05AB1E , 16 बाइट्स

0KεDÈi9ŸëL]íõζJO

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

या वैकल्पिक रूप से:

0KεDÈ8*>Ÿ{R}õζJO
0Kε9Ÿ¬L‚yèR}õζJO

स्पष्टीकरण:

0K        # Remove all 0s from the (implicit) input-integer
  ε       #  Map each digit to:
   D      #   Duplicate the digit
    Èi    #   If it's even:
      9Ÿ  #    Pop and push a list in the range [digit, 9]
     ë    #   Else (the digit is odd):
      L   #    Pop and push a list in the range [1, digit]
  ]       # Close both the if-else statement and map
   í      # Reverse each inner ranged list
     ζ    # Zip/transpose, swapping rows and columns,
    õ     # with an empty string as filler
      J   # Join each inner list together
       O  # And sum that list
          # (after which the result is output implicitly)
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.