स्प्लिट मार्क के निशान

21

चुनौती

मार्क एक छात्र है जो Nएक एकल पंक्ति में एक संक्षिप्त तरीके से अपने अंक प्राप्त करता है ।

चुनौती अपने निशान अलग करने के लिए, जानते हुए भी कि प्रत्येक चिह्न केवल किया जा सकता है 0या 1या 2या 3या 4या 5या 6या 7या 8या9 या 10।

इनपुट

N प्राकृतिक संख्या और एक पंक्ति।

उत्पादन

प्राकृतिक संख्याओं का एक समूह।

उदाहरण

N, One line------------------> Set of marks
3, '843'---------------------> [8, 4, 3]
1, '0'-----------------------> [0]
2, '1010'--------------------> [10,10]
3, '1010'--------------------> [1,0,10] or [10,1,0] 
4, '1010'--------------------> [1,0,1,0]
9, '23104441070'-------------> [2, 3, 10, 4, 4, 4, 10, 7, 0]
12,'499102102121103'---------> [4, 9, 9, 10, 2, 10, 2, 1, 2, 1, 10, 3]
5, '71061'-------------------> [7, 1, 0, 6, 1]
11,'476565010684'------------> [4, 7, 6, 5, 6, 5, 0, 10, 6, 8, 4]
4, '1306'--------------------> [1, 3, 0, 6]
9, '51026221084'-------------> [5, 10, 2, 6, 2, 2, 10, 8, 4]
14,'851089085685524'---------> [8, 5, 10, 8, 9, 0, 8, 5, 6, 8, 5, 5, 2, 4]
11,'110840867780'------------> [1, 10, 8, 4, 0, 8, 6, 7, 7, 8, 0]
9, '4359893510'--------------> [4, 3, 5, 9, 8, 9, 3, 5, 10]
7, '99153710'----------------> [9, 9, 1, 5, 3, 7, 10]
14,'886171092313495'---------> [8, 8, 6, 1, 7, 10, 9, 2, 3, 1, 3, 4, 9, 5]
2, '44'----------------------> [4, 4]
4, '9386'--------------------> [9, 3, 8, 6]

नियम

  • जब कई आउटपुट संभव होते हैं तो केवल एक आउटपुट देते हैं।
  • केवल मूल्य 10का चिह्न दो दशमलव पर है, अन्य एक दशमलव पर हैं।
  • इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में दिए जा सकते हैं
  • अमान्य इनपुट को संभालने की आवश्यकता नहीं है
  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
  • यदि संभव हो, तो कृपया ऑनलाइन परीक्षण वातावरण का लिंक शामिल करें ताकि अन्य लोग आपके कोड को आज़मा सकें!
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।
code-golf  string  array-manipulation 
— mdahmoune
स्रोत
यहाँ एक अजगर स्निपेट है जिसका उपयोग मैंने n, 'string'spl = [item.split('-')[0] for item in text.split('\n')]
— कोपिपेटेटेड
3
नीचे वोट के लिए कुछ टिप्पणी plz ...
— mdahmoune
डाउनवोट्स को एक कारण के लिए टिप्पणियों को छोड़ने की आवश्यकता नहीं है। ऐसा कुछ भी नहीं है जिसे इस चुनौती के बारे में बेहतर बनाया जा सके।
— 14:20 पर user202729
तो इसके बारे में चिंता मत करो।
— 15:20 बजे user202729
क्या आउटपुट को इनपुट के समान क्रम में होना आवश्यक है?

जवाबों:

6

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

-2 बाइट्स के लिए धन्यवाद घातक

h~c.{ịℕ≤10&ịṫ?∧}ᵛ&t~l

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

इनपुट एक जोड़ी है [Line, N]।

यह मेरा पहला ब्रेकीलॉग कार्यक्रम है, इसलिए इसमें सुधार की बहुत गुंजाइश है।

लाइन की लंबाई> 7 होने पर यह बहुत धीमी होती है।

स्पष्टीकरण:

h~c.{ịℕ≤10&ịṫ?∧}ᵛ&t~l
h                         The first element in the input
 ~c                       is formed by concatenating
   .                      the elements in the output array
   .{         ∧}ᵛ     AND For every element in the output array holds that
     ị                      The element converted to an integer
      ℕ                       is a natural number
       ≤10                    and less than or equal to 10
          &ịṫ?              and it has no leading zeroes (*)
                 &t   AND The second element of the input
                   ~l     is the length of the output

(*) ịṫ?जाँच करता है कि कोई अग्रणी शून्य नहीं हैं। यह स्ट्रिंग को पूर्णांक में परिवर्तित करता है और फिर वापस स्ट्रिंग में और मूल स्ट्रिंग की तुलना करता है।

— fergusq
स्रोत
आपको एक स्ट्रिंग के रूप में संख्या को इनपुट करने की आवश्यकता नहीं है, बस एक पूर्णांक का उपयोग करें। यह उन सभी के ịलिए और अग्रणी शून्य चेक की आवश्यकता को कम करता है h~c.{ℕ≤10}ᵛ&t~l:। यह संभवतया धीमा है, क्योंकि पूर्णांकों पर विघटन अज्ञात बाधाओं के लिए भी काम करना चाहिए, जो इसे अक्षम बनाता है।
— घातक
(यह भी ध्यान रखें कि का उपयोग करते हुए hऔर tप्रथम / अंतिम तत्व प्राप्त करने के लिए उपयोग करने की तुलना में अधिक कुशल है ∋दोनों के लिए (जो ज्यादातर कार्यक्रमों में भी काम नहीं करेगा))।
— घातक
@ जानिए मैंने समझा कि इनपुट लाइन में अग्रणी शून्य हो सकते हैं, इसलिए इनपुट के रूप में पूर्णांक का उपयोग करना संभव नहीं होगा।
— फर्ग्यूसक
ठीक है, यह कष्टप्रद है ...
— घातक
5

पर्ल 6 , 25 बाइट्स

->\a,\b{b~~/(10|.)**{a}/}

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

अनाम कोड ब्लॉक जो एक संख्या और एक स्ट्रिंग लेता है और एक मैच ऑब्जेक्ट के रूप में लौटता है।

स्पष्टीकरण:

->\a,\b{                }  # Anonymous code block taking params a and b
        b~~/           /   # Match using b
            (10|.)           # 10 or a single digit
                  **{a}      # Exactly a times, being greedy
— मजाक कर रहा है
स्रोत
5

पायथन 3 , 47 बाइट्स

lambda s,n:[*s.replace(b'\1\0',b'\n',len(s)-n)]

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

कच्चे बाइट्स के साथ एक बाइटस्ट्रिंग के रूप में "एक लाइन" लेता है \x00 - \x09 । यदि यह स्वीकार्य नहीं है:

पायथन 3 , 56 बाइट्स

lambda s,n:[x-48for x in s.replace(b'10',b':',len(s)-n)]

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

"एक पंक्ति" को बाइटस्ट्रिंग के रूप में लेता है।

— bubbler
स्रोत
5

वी , 17 , 12 बाइट्स

\ÓòÀGjí1“î…0

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

मैं 17 बाइट्स के साथ संतुष्ट था, लेकिन 05AB1E 13 के साथ आया था, और मैं एक चुनौती को अनुत्तरित नहीं होने दे सकता था। : डी

\Ó                      " Put each character on it's own line
  ò                     " Recursively (repeat until an error happens)...
   ÀG                   "   Go to the "n"th line
     j                  "   Move down a line (this will error if there are exactly "n" lines)
      í                 "   Remove...
       1                "     a '1'
        <0x93>          "     START THE MATCH HERE
              î         "     a newline
               <0x85>   "     END THE MATCH HERE
                   0    "     a '0'

Hexdump:

00000000: 5cd3 f2c0 476a ed31 93ee 8530            \...Gj.1...0

वैकल्पिक समाधान:

\ÓòÀGjç1î0/J

दुर्भाग्य से, यह 10साथ बदल देता है1 0

— DJMcMayhem
स्रोत
4

रूबी , 57 बाइट्स

->n,m{m.sub!"10",?A while m[n];m.chars.map{|c|c.to_i 16}}

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

यह गोल्फ दृष्टिकोण नहीं हो सकता है, लेकिन यह 10एक हेक्स के लिए अस्थायी रूप से स्थानापन्न करने के लिए एक मजेदार विचार की तरह दिखता है A, जो संयोगवश एक उच्च निशान भी है (यदि हम वायुसेना ग्रेडिंग प्रणाली पर विचार करते हैं :))

— किरिल एल।
स्रोत
4

पायथन 3 , 71 68 59 बाइट्स

एक और 9 बाइट्स ओव्स के लिए धन्यवाद।

lambda n,s:[int(c,11)for c in s.replace('10','a',len(s)-n)]

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

मैं अमानवीय रूप से str.partition()पुनरावर्ती उपयोग करने की कोशिश कर रहा था , लेकिन replaceचेहरे पर स्मैकडाउन का उपयोग करना बहुत लंबे समय बाद नहीं था। क्या कोई इस पर सुधार कर सकता है?

इसके अलावा, यहां एक TIO लिंक है जिसका उपयोग मैं परीक्षण के मामलों को कुछ और कॉपी / पेस्ट करने योग्य बनाने में करता हूं

— Gigaflop
स्रोत
1
-3 बाइट्स: ड्रॉप अंतरिक्ष के बीच : [cऔर 'x' elseऔर10 for
— mdahmoune
@mdahmoune ध्यान देने के लिए धन्यवाद, मेरे पास यह याद करने में मुश्किल समय है कि एक साथ क्या किया जा सकता है।
— गिगाफ्लॉप
8
अंगूठे का सामान्य नियम: मूल रूप से दो अक्षरों को छोड़कर कुछ भी एक साथ निचोड़ा जा सकता है। यदि आपको एक सिंटैक्स त्रुटि मिलती है, तो यादृच्छिक रिक्त स्थान जोड़ें जब तक कि यह काम न हो :)
— क्विंटेक
वहाँ इस तरह के रूप कुछ अपवाद हैं <number>e, <letter><number>, f'।
— user202729
3
59 बाइट्स को 10 के साथ बदलकर प्रत्येक अक्षर को 11 इंट के रूप में पढ़ा जाता है lambda n,s:[int(c,11)for c in s.replace('10','a',len(s)-n)]:।
— अंडा
3

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

n!x=[y|y<-s x,y==take n y]!!0
s('1':'0':x)=do y<-s x;[1:0:y,10:y]
s(x:y)=(read[x]:)<$>s y
s _=[[]]

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

व्याख्या

फ़ंक्शन sसभी संभव विभाजन करता है, उदाहरण के लिए: "1010"बन जाता है [[1,0,1,0],[10,1,0],[1,0,10],[10,10]], ध्यान दें कि शुरुआत में सबसे लंबा विभाजन कैसे समाप्त होता है (क्योंकि 1:0:yपहले आता है10:y )।

इसके साथ ही मन में, हम इन सभी मानों को लेकर फ़िल्टर कर सकते हैं yबाहर यहीं से y == take n yजो भी विभाजन है कि आवश्यक की तुलना में कम कर रहे हैं रहता है। उदाहरण के लिए, 4हम सूची को समान छोड़ते हैं[[1,0,1,0],[10,1,0],[1,0,10],[10,10]] ।

अब हम उस सूची में पहला तत्व प्राप्त कर सकते हैं क्योंकि इनपुट हमेशा मान्य होंगे (उदाहरण के 5!"1010"लिए [1,0,1,0]भी देंगे , लेकिन हमें इसे संभालने की आवश्यकता नहीं है)।

नोट: मैं किसी भी तरह उपहास कर रहा हूँ .. y==take n yकी लंबाई समान है length y==n: S

— ბიმო
स्रोत
2

05AB1E , 13 बाइट्स

.œsù.ΔïTÝÃJ¹Q

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

.œ              # partitions of the first input
  sù            # of a length equal to the second input
    .Δ          # find the first partition that returns true when:
      ï         # each element is converted to integer
       TÝÃ      # and only numbers in [0 ... 10] are kept
          J     # then join it together
           ¹Q   # and compare it to the first input for equality
— Emigna
स्रोत
2

जावास्क्रिप्ट (बैबेल नोड) ,  70 69  59 बाइट्स

के रूप में इनपुट लेता है (n)(line)।

n=>s=>(a=s.match(/10|./g)).flatMap(x=>x>9&&!a[--n]?[1,0]:x)

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

टिप्पणी की गई

n => s =>                       // given n and s
  (a = s.match(/10|./g))        // split s into marks; a '1' followed by a '0' is always
                                // interpreted as '10'
  .flatMap(x =>                 // for each mark x:
    x > 9 &&                    //   if x = '10',
    !a[--n] ?                   //   then decrement n; if a[n] is undefined:
      [1, 0]                    //     yield [1, 0]
    :                           //   else:
      x                         //     yield the mark unchanged
  )                             // end of flatMap()

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

सहेजे गए 5 बाइट्स @ guest271314 की बदौलत

के रूप में इनपुट लेता है (n)(line)।

n=>g=([...s])=>1/s[n]?g(eval(`[${s}]`.replace('1,0',10))):s

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

टिप्पणी की गई

n =>                            // main function, taking n
  g = ([...s]) =>               // g = recursive function, taking s
                                //     (which is either a string or an array)
    1 / s[n] ?                  // if s[n] is defined (i.e. we have too many marks):
      g(                        //   do a recursive call to g:
        eval(                   //     build a new array by evaluating ...
          `[${s}]`              //       ... the string representation of s[] where the
          .replace('1,0', 10)   //       first occurrence of '1,0' is replaced with '10'
        )                       //     end of eval()
      )                         //   end of recursive call
    :                           // else:
      s                         //   return s
— Arnauld
स्रोत
एन = 3 और लाइन = '1010' के लिए आउटपुट मिश्रित प्रकार [1, 0, '10'] के साथ क्यों है?
— mdahmoune
s.match()स्ट्रिंग्स की एक सरणी देता है, लेकिन कॉलबैक फ़ंक्शन "10"में [1,0](2 पूर्णांकों) में विभाजित किया जा सकता है flatMap()।
— Arnauld
1
हम +1 बाइट के लिए पूर्णांक के लिए सब कुछ कर सकते हैं ।
— Arnauld
59 बाइट्सeval(`[${s}]`.replace('1,0',10))
— 271314
@ guest271314 धन्यवाद! अच्छा पकड़ा।
— अरनौलद
2

जावा (ओपनजेडके 8) , 78 बाइट्स

स्ट्रीम API का उपयोग करके एक अच्छा वन-लाइनर।

(n,l)->l.join(":",l.split("10",l.length()-n+1)).chars().map(i->i-48).toArray()

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

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

(n,l)->                     // Lambda function taking int and string
  l.join(":",               // Join the following array with colons
    l.split("10",           // Split the original string on "10"...
      l.length()-n+1))      // But limit the parts to the difference between the length
                            // and expected length, to only remove  required number of 10s              
  .chars()                  // Convert to an intstream of codepoints
  .map(i->i-48)             // Remove 48 to get the numeric value of each codepoint
  .toArray()                // Return an int array
— ल्यूक स्टीवंस
स्रोत
2

आर , 63 बाइट्स

जबकि स्ट्रिंग की लंबाई की तुलना में बड़ा है n, अगले 10 को आप एक ":"(ASCII वर्ण 9 के बाद) के लिए पहुँचते हैं । फिर स्ट्रिंग में प्रत्येक चार का ASCII मान लेकर संख्याओं में विभाजित करें।

function(n,x){while(nchar(x)>n)x=sub(10,":",x);utf8ToInt(x)-48}

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

— J.Doe
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.