संपादित करें: यदि आप लिस्प का उपयोग कर रहे हैं, तो मैंने बाइट्स गिनने में नीचे कुछ दिशानिर्देश दिए हैं।

उद्देश्य: किसी भी नियमित अभिव्यक्तियों के उपयोग के बिना, प्रत्येक स्ट्रिंग में गैर-अंकों पर एक स्ट्रिंग को विभाजित करने वाला सबसे छोटा फ़ंक्शन बनाएं और प्रत्येक स्ट्रिंग में केवल अंकों से मिलकर एक सरणी देता है। प्रत्येक स्ट्रिंग में अग्रणी शून्य शामिल किए जाने हैं।

वर्तमान स्टैंडिंग (श्रेणियों में अलग):

C / C ++ / C # / Java: 68 (C) ....
गोल्फस्क्रिप्ट / एपीएल / जे: 13 (एपीएल)
अन्य सभी: 17 (बैश, उपयोग tr), 24 (रूबी)

नियम:

(मैं लंबाई के लिए माफी माँगता हूँ)

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

प्राथमिक फ़ंक्शन घोषणा की गिनती नहीं है, और न ही अन्य मानक पुस्तकालयों का आयात करता है। `# शामिल करें`, `आयात`, और` का उपयोग `गिनती नहीं है। बाकी सब करता है। इसमें `# डिफाइन` और हेल्पर फ़ंक्शंस शामिल हैं। गलतफहमी के लिए खेद है। इसे एक सहायक मार्गदर्शिका के रूप में देखें जो गिनती नहीं करता है (सी-स्टाइल सिंटैक्स में लिखा गया है)

// कुल की ओर नहीं गिना जाता है, जब तक छोड़ा नहीं जा सकता है
// गैर-स्पष्ट, जावा के मानक पुस्तकालय के आधे हिस्से की तरह।
# किंकर्तव्यविमूढ़ <stdio.h>

कुछ आयात करें ।builtin.Class // गिनती नहीं करता है, ऊपर देखें

#define printf p // कुल की ओर गिना जाता है

/ * कोई अन्य प्रीप्रोसेसर निर्देश इत्यादि गिनते हैं। * /

int i = 0; // मायने रखता है

someFunction (); // मायने रखता है

char [] [] myMainSplitFunction (चार [] [] सरणी) {// की गिनती नहीं है
  // यहाँ सब कुछ मायने रखता है
  वापसी returnArray; // यह भी मायने रखता है।
} // गिनती नहीं है

/ * यहाँ सब कुछ मायने रखता है, घोषणा सहित * /
char [] [] someHelperFunction (चार [] स्ट्रिंग) {
  // सामान
} // यह भी मायने रखता है

आउटपुट एक स्ट्रिंग सरणी या समान होना चाहिए (जावा में सरणी सूचियां और स्वीकार्य हैं)। स्वीकार किए जाते हैं उत्पादन के उदाहरण हैं: String[], char[][], Array, List, और Array(वस्तु)।
सरणी में केवल चर-लंबाई स्ट्रिंग प्राइमेटीज़ या स्ट्रिंग ऑब्जेक्ट्स होने चाहिए। नीचे दिए गए अपवाद के साथ, कोई भी खाली तार रिटर्न में मौजूद नहीं होना चाहिए। नोट: स्ट्रिंग्स में लगातार मिलानों की एक स्ट्रिंग होती है, जैसे नीचे उदाहरण इनपुट और आउटपुट।
यदि कोई मिलान नहीं हैं, तो फ़ंक्शन बॉडी को वापस आना चाहिए null, एक खाली सरणी / सूची, या एक सरणी / सूची जिसमें एक खाली स्ट्रिंग है।
किसी भी बाहरी पुस्तकालय की अनुमति नहीं है।
डॉस लाइन एंडिंग की गिनती एक बाइट के रूप में होती है, दो नहीं (पहले से ही मेटा में कवर की जाती है, लेकिन इस पर जोर दिया जाता है)
और यहां सबसे बड़ा नियम: कोई नियमित अभिव्यक्ति की अनुमति नहीं है।

यह एक कोड-गोल्फ प्रश्न है, इसलिए सबसे छोटा आकार जीतता है। सौभाग्य!

और यहां कुछ उदाहरण इनपुट और आउटपुट (सी-स्टाइल से बच गए) हैं:

इनपुट: "abc123def456"
आउटपुट: ["123", "456"]

इनपुट: "aitew034snk582: 3c"
आउटपुट: ["034", "582", "3"]

इनपुट: "as5493tax54 \\ 430-52@g9.fc"
आउटपुट: ["5493", "54", "430", "52", "9"]

इनपुट: "sasprs] tore \" re \\ forz "
आउटपुट: अशक्त, [], [""], या समान

कृपया अपने उत्तरों द्वारा कितने बाइट्स का उपयोग करें, और हमेशा की तरह, खुश गोल्फ!

लिस्प के लिए दिशानिर्देश

यहाँ क्या है और लिस्प बोलियों में गिनती नहीं है:

;;; विकल्प 1

(अशुद्ध निकालने के तार (ab); गिनती नहीं है
  (सामान) ;;; यहाँ सब कुछ मायने रखता है
); गिनती नहीं है

;;; विकल्प 2

(अशुद्ध निकालने के तार (स्ट्रिंग और ऑक्स (शुरू 0) (अंत 0)); गिनती नहीं है)
  (सामान) ;;; यहाँ सब कुछ मायने रखता है
); गिनती नहीं है।

अन्य सभी लंबोदर पूरी तरह से बाइट की गिनती की ओर बढ़ते हैं।

code-golf string

— इसियाह मीडोज
स्रोत

क्या यह पहले नहीं पूछा गया था?

— इस्माईल मिगुएल

1

हां, लेकिन मैंने इसे मेटा पर फिर से पूछा और इसे फिर से यहां पोस्ट करने से पहले इसे पर्याप्त संपादन किया। इस वजह से, इसे एक डुप्लिकेट के रूप में वर्गीकृत नहीं किया जाना चाहिए (अन्य संबंधित एक को बंद कर दिया जाना चाहिए अगर पहले से ही नहीं)।

— इसियाह

2

क्या आपके "गोल्फ" को उत्तर के रूप में पोस्ट नहीं किया जाना चाहिए?

— MrWhite

4

क्षमा करें, लेकिन गोल्फस्क्रिप्ट को बंद करने के लिए -1। सभी भाषाओं को अनुमति दी जानी चाहिए।

— दरवाज़े

1

@Doorknob यह सच है, लेकिन मैं भी ओपी की भावनाओं को समझता हूं। लोगों को प्रतिस्पर्धा करने का मौका होना चाहिए, भले ही वे गोल्फस्क्रिप्ट, जे, या एपीएल न बोलते हों (और मैं इन प्रतियोगिताओं में उत्तरार्द्ध को मना करने का दोषी हूं।) क्या आप उस धागे में मेरे प्रस्ताव पर एक नज़र डाल सकते हैं जिसे उन्होंने जोड़ा था?

— तोबिया

10

एपीएल, 13 वर्ण

(या 28/30 बाइट्स, नीचे पढ़ें)

{⍵⊂⍨⍵∊∊⍕¨⍳10}

मुझे लगता है कि आपने अपने प्रश्न से गोल्फस्क्रिप्ट प्रतिबंधित कर दिया है। मैं आपकी भावना को समझता हूं, लेकिन मुझे उम्मीद है कि यह समुदाय अंततः एपीएल पर प्रतिबंध नहीं लगाएगा, क्योंकि यह एक लंबे इतिहास के साथ वास्तव में उल्लेखनीय प्रोग्रामिंग भाषा है, कोड में बहुत मज़ा करने का उल्लेख नहीं करना है। हो सकता है कि यह सिर्फ अलग तरीके से बनाया जा सकता है, अगर लोग। लगता है कि यह गलत तरीके से प्रतिस्पर्धा कर रहा है। मैं इस बात पर अपने विचार उस थ्रेड पर पोस्ट करूँगा जो आपने लिंक किया है।

उसी टोकन पर, मैंने हमेशा अपने एपीएल पदों में एक फुटनोट जोड़ा है, यह दावा करते हुए कि एपीएल को 1 चार = 1 बाइट के रूप में स्कोर किया जा सकता है। मेरा दावा इस तथ्य पर टिका है कि कुछ (ज्यादातर वाणिज्यिक) एपीएल कार्यान्वयन अभी भी अपने स्वयं के विरासत सिंगल-बाइट एन्कोडिंग का समर्थन करते हैं, एपीएल प्रतीकों के साथ ऊपरी 128 बाइट मूल्यों के लिए मैप किया गया है। लेकिन शायद यह बहुत अधिक खिंचाव है, इस स्थिति में आप UTF-16 में इस प्रविष्टि को 28 बाइट्स या UTF-8 में 30 बाइट्स के रूप में स्कोर करना चाहते हैं।

व्याख्या

{        ⍳10}  make an array of naturals from 1 to 10
       ⍕¨      convert each number into a string
      ∊        concatenate the strings into one (it doesn't matter that there are two 1s)
    ⍵∊         test which chars from the argument are contained in the digit string
 ⍵⊂⍨           use it to perform a partitioned enclose, which splits the string as needed

उदाहरण

      {⍵⊂⍨⍵∊∊⍕¨⍳10} 'ab5c0x'
 5  0 
      {⍵⊂⍨⍵∊∊⍕¨⍳10}  'z526ks4f.;8]\p'
 526  4  8

स्ट्रिंग के एक सरणी के लिए डिफ़ॉल्ट आउटपुट स्वरूप यह स्पष्ट नहीं करता है कि सरणी में कितने तार हैं, और न ही कितने रिक्त हैं। लेकिन उद्धरण जोड़ने के लिए एक त्वरित हेरफेर यह स्पष्ट करना चाहिए:

      {q,⍵,q←'"'}¨ {⍵⊂⍨⍵∊∊⍕¨⍳10} 'ab5c0x'
 "5"  "0" 
      {q,⍵,q←'"'}¨ {⍵⊂⍨⍵∊∊⍕¨⍳10}  'z526ks4f.;8]\p'
 "526"  "4"  "8"

— Tobia
स्रोत

आपकी टिप्पणी के बारे में, मुझे लगता है कि अन्य भाषाओं के लिए "शॉर्टहैंड" के साथ काफी प्रतिस्पर्धा होती है, लोगों को प्रत्येक भाषा को एक चर के रूप में अन्य भाषाओं में गिनना चाहिए। उदाहरण के लिए, यहां पोस्ट किए गए मेरे गणितज्ञ समाधान को 7 (अधिक या कम) के रूप में गिना जाना चाहिए। मुझे लगता है कि संपीड़ित टोकन के साथ एक भाषा डिजाइन करना योग्यता नहीं है।

— डॉ। बेलिसियस

क्या आप अपने गोल्फ का एक हेक्स डंप प्रदान कर सकते हैं? मैं कुछ पात्रों को नहीं पढ़ सकता।

— ईशाय मीडोज

@impinball हेक्सडंप आपकी मदद कैसे करेगा? यह ऐसा नहीं है कि आप देखेंगे कि क्या किया जा रहा है।

— मनिएप

@impinball APL कोड {omega enlose commute omega epsilon epsilon format प्रत्येक iota 10} है। यदि आपको यूनिकोड मूल्यों की आवश्यकता है, तो आप इसे किसी भी ऑनलाइन टूल पर कॉपी और पेस्ट कर सकते हैं, भले ही आप वर्णों को नहीं देख सकते हैं (जो कि अजीब है, क्योंकि अधिकांश आधुनिक यूनिकोड फोंट में एपीएल प्रतीक हैं) किसी भी मामले में आपको जो मिलता है वह यह है। {[u2375 \ u2282 \ u2368 \ u2375 \ u220a \ u220a \ u2355 \ u00a8 \ u237310} (अंतिम "10" जो भागने के क्रम का हिस्सा नहीं है

— टोबिया

1

इसके बजाय ∊⍕¨⍳10, तुम सिर्फ इस्तेमाल नहीं कर सकते थे ⎕D? वह स्थिर होना चाहिए '0123456789'। Dyalog APL बहुत कम समर्थन करता है, और ऐसा NARS2000 करता है।

— मारिनस

5

अजगर ४on

कार्यान्वयन

f=lambda s:"".join([' ',e][e.isdigit()]for e in s).split()

डेमो

>>> sample=["abc123def456","aitew034snk582:3c","as5493tax54\\430-52@g9.fc","sasprs]tore\"re\\forz"]
>>> [f(data) for data in sample]
[['123', '456'], ['034', '582', '3'], ['5493', '54', '430', '52', '9'], []]

कलन विधि

प्रत्येक गैर-अंकीय वर्ण को अंतरिक्ष में बदलें और फिर परिणामी स्ट्रिंग को विभाजित करें। एक सरल और स्पष्ट दृष्टिकोण।

और itertools के साथ एक मजेदार समाधान (71 अक्षर)

f1=lambda s:[''.join(v)for k,v in __import__("itertools").groupby(s,key=str.isdigit)][::2]

— अभिजीत
स्रोत

4

रूबी, 70

f=->(s){s.chars.chunk{|c|c.to_i.to_s==c}.select{|e|e[0]}.transpose[1]}

परीक्षण के लिए ऑनलाइन संस्करण

रूबी (to_i) में किसी भी गैर-अंक वाले चरित्र को एक इंट रिटर्न में परिवर्तित करने के बाद से, प्रत्येक char को int और back to char में परिवर्तित करना गैर-रेगेक्स तरीके से अंक की जांच करने का तरीका है ...

— डेविड हेरमैन
स्रोत

आप एक ('0' .. '9') भी कर सकते हैं। सदस्य? हर चार के लिए, लेकिन आपने जो किया वह पहले से ही छोटा है

— fgp

आप निश्चित रूप से सही हैं - मुझे कहना चाहिए: "ए" तरीका;)

— डेविड हेरमैन

4

बैश, 26 (फ़ंक्शन सामग्री: 22 + सरणी असाइनमेंट ओवरहेड 4)

यह दूसरे bashउत्तर को हरा नहीं सकता है , लेकिन इसका दिलचस्प है क्योंकि यह आपको दोतरफा बना सकता है:

f()(echo ${1//+([!0-9])/ })

उपयोग है:

$ a=(`f "ab5c0x"`); echo ${a[@]}
5 0
$ a=(`f "z526ks4f.;8]\p"`); echo ${a[@]}
526 4 8
$

पहली त्वरित नज़र में, //+([!0-9])/एक रेगेक्सपी प्रतिस्थापन की तरह दिखता है, लेकिन ऐसा नहीं है। यह बैश पैरामीटर विस्तार है , जो नियमित अभिव्यक्ति नियमों के बजाय पैटर्न-मिलान नियमों का पालन करता है।

बैश फ़ंक्शंस से सही बैश सरणी प्रकारों को वापस करना एक दर्द है, इसलिए मैंने इसके बजाय एक अंतरिक्ष-सीमांकित सूची को वापस करने के लिए चुना, फिर फ़ंक्शन कॉल के बाहर एक सरणी असाइनमेंट में एक सरणी में कनवर्ट करें। इसलिए निष्पक्षता के हित में, मुझे लगता है (` `)कि फ़ंक्शन कॉल को मेरे स्कोर में शामिल किया जाना चाहिए।

— डिजिटल आघात
स्रोत

3

गणितज्ञ ३२

StringCases[#,DigitCharacter..]&

प्रयोग

inps ={"abc123def456", "aitew034snk582:3c", "as5493tax54\\430-52@g9.fc", 
        "sasprs]tore\"re\\forz"}  
StringCases[#,DigitCharacter..]&/@inps

{{"123", "456"}, 
 {"034", "582", "3"}, 
 {"5493", "54", "430", "52", "9"}, 
 {}
}

Regexes का उपयोग करने के बराबर है!

StringCases[#, RegularExpression["[0-9]+"]] &

— डॉ। बेलिसरियस
स्रोत

मैथमेटिका रीगेक्स में बेकार है।

— कैलकुलेटरफैनलाइन

3

बैश, 21 बाइट्स 17/21 बाइट्स ( DigitalTrauma द्वारा सुधार )

के साथ एक अंतरिक्ष से अलग सूची का निर्माण tr

function split() {
tr -c 0-9 \ <<E
$1
E
}

किसी भी गैर अंक को एक स्थान से बदल देता है

प्रयोग

$ for N in $(split 'abc123def456'); do echo $N; done
123
456

संपादित करें

जैसा कि नीचे टिप्पणी द्वारा बताया गया है, कोड को 17 बाइट्स से नीचे ले जाया जा सकता है:

function split() (tr -c 0-9 \ <<<$1)

और जैसा कि परिणाम सख्ती से बैश सरणी नहीं बोल रहा है, उपयोग होना चाहिए

a=(`split "abc123def456"`); echo ${a[@]}

और अतिरिक्त (``)को गिना जाना चाहिए

— Coaumdio
स्रोत

1

गाह तुम मुझे हरा दो! लेकिन यहाँ एक दस्तावेज़ के बजाय यहाँ एक स्ट्रिंग का उपयोग क्यों नहीं किया जाता है? इसके अलावा, आप समारोह सामग्री आप उपयोग के अंत में एक नई पंक्ति को बचा सकता है (blah)के बजाय {blah;}: split()(tr -c 0-9 \ <<<$1)। इस तरह आपका फंक्शन बॉडी केवल 17 वर्णों का है।

— डिजिटल ट्रामा

1

आपका फ़ंक्शन किसी सरणी के बजाय "अंतरिक्ष-पृथक सूची" देता है। निश्चित रूप से बैश फ़ंक्शन से सही सरणियाँ अजीब है, लेकिन आप कम से कम अपने फ़ंक्शन के परिणाम को अपने उपयोग में एक सरणी में असाइन कर सकते हैं a=($(split "12 3a bc123")); echo ${a[@]}:। यह तर्क दिया जा सकता है कि "($ ())" को आपके स्कोर में गिना जाता है

— डिजिटल ट्रॉमा

trदृष्टिकोण की खोज करने से पहले , मैंने एक पैरामीटर विस्तार के साथ ऐसा करने की कोशिश की । trनिश्चित रूप से गोल्फ उद्देश्यों के लिए बेहतर दृष्टिकोण है।

— डिजिटल ट्रामा

क्या आपने trविस्तार ऑपरेटर के साथ घेरने की कोशिश की है ? यह कुछ इस तरह सामने आएगा ($(tr...)), और जहां फ़ंक्शन घोषणा की गणना नहीं करता है, बाहरी कोष्ठक आपके खिलाफ नहीं गिनेंगे। यह केवल कमांड प्रतिस्थापन भाग होगा।

— इशीआ मीडोज

मैं यह नहीं देखता कि यह कैसे काम करना चाहिए, लेकिन मैं बैश सरणियों में धाराप्रवाह नहीं हूं। वैसे भी, (``)निर्माण 1-चार से बेहतर है ($())और इसे प्राथमिकता दी जाएगी।

— Coaumdio

2

स्मॉलटॉक (स्मॉलटाक / एक्स), 81

f := [:s|s asCollectionOfSubCollectionsSeparatedByAnyForWhich:[:ch|ch isDigit not]]

f मान: 'abc123def456' -> ऑर्डरेडकॉलक्शन ('123' '456')

f मान: 'aitew034snk582: 3c' -> ऑर्डरेडकॉलेक्शन ('034' '582' '3')

f मान: 'as5493tax54 \ 430-52@g9.fc' -> ऑर्डरेडकॉलक्शन ('5493' '54' '430' '52' '9')

f मान: 'sasprs] tore \ "re \ forz' -> ऑर्डरडॉलकशन ()

sigh - स्मॉलटॉक में veeeery लंबे फ़ंक्शन नाम का उपयोग करने की प्रवृत्ति है ...

— blabla999
स्रोत

2

क्या यह एक फ़ंक्शन नाम है? o__O

— Tobia

@ टोबिया स्पष्ट रूप से ...

— मीडोज

asCollectionOfSubCollectionsSeparatedByAnyForWhich

— ಠ_C

1

आर, 81

f=function(x){
s=strsplit(x,"",T)[[1]]
i=s%in%0:9
split(s,c(0,cumsum(!!diff(i))))[c(i[1],!i[1])]
}

फ़ंक्शन एक स्ट्रिंग को स्वीकार करता है और स्ट्रिंग्स की एक सूची देता है।

उदाहरण:

> f("abc123def456")
$`1`
[1] "1" "2" "3"

$`3`
[1] "4" "5" "6"

-

> f("aitew034snk582:3c")
$`1`
[1] "0" "3" "4"

$`3`
[1] "5" "8" "2"

$`5`
[1] "3"

-

> f("as5493tax54\\430-52@g9.fc")
$`1`
[1] "5" "4" "9" "3"

$`3`
[1] "5" "4"

$`5`
[1] "4" "3" "0"

$`7`
[1] "5" "2"

$`9`
[1] "9"

-

> f("sasprs]tore\"re\\forz")
$<NA>
NULL

नोट: $xसूची तत्व का नाम है।

— स्वेन होहेंस्टीन
स्रोत

1

पर्ल, 53

संपादित करें: कोई मिलान नहीं होने पर, उप-सूची आवश्यकतानुसार खाली स्ट्रिंग (खाली सूची के बजाय) के साथ सूची लौटाती है।

यह एकल अंतरिक्ष चरित्र पर विभाजन से भी बचता है, क्योंकि यह किसी भी श्वेत-स्थान के व्यवहार पर 'विभाजन को ट्रिगर करता है, जो संभवतः नियमों का उल्लंघन करता है। मैं / /सीमांकक का उपयोग कर सकता हूं , जो एकल स्थान पर विभाजित होगा, लेकिन विरोधाभासी रूप से यह रेग्जिप पैटर्न का उपयोग करने जैसा लगेगा । मैं unpackकुछ अतिरिक्त पात्रों की कीमत पर उपयोग कर सकता हूं और इसलिए splitविवादों से पूरी तरह छुटकारा पा सकता हूं, लेकिन मुझे लगता है कि, जो मैं खत्म करता हूं, वह एक शाब्दिक चरित्र (अंतरिक्ष के अलावा) पर विभाजित करना ठीक है।

sub f{shift if(@_=split a,pop=~y/0-9/a/csr)[0]eq''and$#_;@_}

और, नहीं, पर्ल के लिप्यंतरण ऑपरेटर नियमित अभिव्यक्ति नहीं करते हैं। 0123456789अगर समस्या है तो मैं 0-9 की रेंज को अनियंत्रित कर सकता हूं ।

— user2846289
स्रोत

जब तक यह नियमित अभिव्यक्ति का उपयोग नहीं करता है, यह वैध है।

— ईशाय मीडोज

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

— टिम सेगिन

1

@TimSeguine: बिल्कुल नहीं। गैर-अंकों को प्रतिस्थापित किया जाता है और एक ही चरित्र को स्क्वीज़ किया जाता है, जिस पर विभाजित होने से रिक्त स्ट्रिंग उत्पन्न होती है यदि यह सीमांकक शुरुआत में होता है। यदि सूची में अन्य प्रविष्टियाँ हैं तो इसे हटा दिया जाता है।

— user2846289

खाली सूची ठीक है।

— इसियाह मीडोज

1

सी, 68 बाइट्स (केवल फ़ंक्शन का शरीर)

void split (char *s, char **a) {
int c=1;for(;*s;s++)if(isdigit(*s))c?*a++=s:0,c=0;else*s=0,c=1;*a=0;
}

पहला तर्क इनपुट स्ट्रिंग है, दूसरा आउटपुट आउटपुट ऐरे है, जो NULL-टर्मिनेटेड स्ट्रिंग ऐरे है। aफ़ंक्शन को कॉल करने से पहले पर्याप्त मेमोरी आरक्षित होनी चाहिए (सबसे खराब स्थिति:) sizeof(char*)*((strlen(s)+1)/2)।

इनपुट स्ट्रिंग को फ़ंक्शन द्वारा संशोधित किया जाता है (प्रत्येक गैर-अंकीय वर्ण द्वारा प्रतिस्थापित किया जाता है '\0')

उदाहरण का उपयोग करें

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

void split (char *s, char **a) {
int c=1;for(;*s;s++)if(isdigit(*s))c?*a++=s:0,c=0;else*s=0,c=1;*a=0;
}   

void dump(char **t) {
    printf("[ ");for(;*t;t++)printf("%s ", *t);printf("]\n");
}   

int main() {
    char **r = malloc(1024);
    char test1[] = "abc123def456";
    char test2[] = "aitew034snk582:3c";
    char test3[] = "as5493tax54\\430-52@g9.fc";
    char test4[] = "sasprs]tore\"re\\forz";
    split(test1,r); 
    dump(r);
    split(test2,r); 
    dump(r);
    split(test3,r); 
    dump(r);
    split(test4,r); 
    dump(r);
    return 0;
}

उत्पादन

[ 123 456 ]
[ 034 582 3 ]
[ 5493 54 430 52 9 ]
[ ]

अन-गोल्फ संस्करण:

void split (char *s, char **a) {
    int c=1; // boolean: the latest examined character is not a digit
    for(;*s;s++) {
        if(isdigit(*s)) {
            if(c) *a++ = s; // stores the address of the beginning of a digit sequence
            c=0;
        } else {
            *s=0; // NULL-terminate the digit sequence
            c=1;
        }   
    }   
    *a = 0; // NULL-terminate the result array
}

— Coaumdio
स्रोत

1

VBScript, 190 (कार्य घोषणा के बिना 164)

Function f(i)
For x=1 To Len(i)
c=Mid(i,x,1)
If Not IsNumeric(c) Then
Mid(i,x,1)=" "
End If
Next
Do
l=Len(i)
i=Replace(i,"  "," ")
l=l-Len(i)
Loop Until l=0
f=Split(Trim(i)," ")
End Function

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

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

Input: "ab5c0x"
Output: 5,0

Input: "z526ks4f.;8]\p"
Output: 526,4,8

— Comintern
स्रोत

DOS लाइन एंडिंग्स की गिनती एक चरित्र के रूप में जहाँ तक मैंने मेटा पर पढ़ा है।

— इसियाह मीडोज

मैंने आपके लिए एक संपादन का सुझाव दिया।

— इसियाह

गिनती पहले से ही लिनक्स शैली 1 बाइट लाइन एंडिंग्स मानती है। मुझे मेरी गिनती के द्वारा 190 अक्षर मिलते हैं (बस फिर से सत्यापित)।

— कॉमिंटर

ठीक है। मेरा गर्भपात हो गया होगा।

— इशीया मीडोज

1

आम लिस्प (पत्र के अनुसार 1; according173 भावना के अनुसार)

यहाँ एक पठनीय संस्करण है। बाइट गिनती क्योंकि जैसी चीजों में लंबे नामों में से काफी अधिक है digit-char-pऔर position-ifऔर vector-push-extend।

(defun extract-numeric-substrings (string &aux (start 0) (end 0) (result (make-array 0 :adjustable t :fill-pointer 0)))
  (loop 
     (unless (and end (setq start (position-if #'digit-char-p string :start end)))
       (return result))
     (setq end (position-if (complement #'digit-char-p) string :start (1+ start)))
     (vector-push-extend (subseq string start end) result)))

(extract-numeric-substrings "abc123def456")
#("123" "456")

(extract-numeric-substrings "aitew034snk582:3c")
#("034" "582" "3")

(extract-numeric-substrings "as5493tax54\\430-52@g9.fc")
#("5493" "54" "430" "52" "9")

(extract-numeric-substrings "sasprs]tore\"re\\forz")
#()

"फ़ंक्शन डिक्लेरेशन" की अवधारणा अस्पष्ट है। यहां एक संस्करण है जिसमें केवल एक बाइट ( xफ़ंक्शन बॉडी में वर्ण ) है; फ़ंक्शन की लांबा सूची (फ़ंक्शन की घोषणा का हिस्सा) के सहायक चर में सब कुछ बंडल है:

(defun extract-numeric-substrings (string 
                                   &aux (start 0) (end 0) 
                                   (result (make-array 0 :adjustable t :fill-pointer 0))
                                   (x (loop 
                                         (unless (and end (setq start (position-if #'digit-char-p string :start end)))
                                           (return result))
                                         (setq end (position-if (complement #'digit-char-p) string :start (1+ start)))
                                         (vector-push-extend (subseq string start end) result))))
  x)

वास्तविक बाइट काउंट इस बात पर निर्भर करेगा कि स्वीकार्य होने के लिए कितने सहायक घोषणाओं को शरीर में स्थानांतरित करना होगा। कुछ स्थानीय फ़ंक्शन का नाम बदलने में मदद मिलेगी, भी (जैसे, छोटाposition-if दो बार प्रकट होने के बाद से , एकल अक्षर चर का उपयोग करें, आदि)।

कार्यक्रम के इस प्रतिपादन में 220 वर्ण हैं:

(LOOP(UNLESS(AND END(SETQ START(POSITION-IF #'DIGIT-CHAR-P STRING :START END)))(RETURN RESULT))(SETQ END(POSITION-IF(COMPLEMENT #'DIGIT-CHAR-P)STRING :START(1+ START)))(VECTOR-PUSH-EXTEND(SUBSEQ STRING START END)RESULT))

अगर और कुछ नहीं, तो यह कॉमन लिस्प के & aux वेरिएबल्स को बढ़ावा देना चाहिए ।

यह निश्चित रूप से अधिक स्पष्ट रूप से लिखा जा सकता है loop:

(defun extract-numeric-substrings (s &aux (b 0) (e 0) (r (make-array 0 :fill-pointer 0)))
  (loop 
     with d = #'digit-char-p 
     while (and e (setq b (position-if d s :start e)))
     finally (return r)
     do 
       (setq e (position-if-not d s :start (1+ b)))
       (vector-push-extend (subseq s b e) r)))

loopफार्म, अतिरिक्त स्थान के साथ हटा दिया, 173 कैरेक्टर हैं:

(LOOP WITH D = #'DIGIT-CHAR-P WHILE(AND E(SETQ B(POSITION-IF D S :START E)))FINALLY(RETURN R)DO(SETQ E(POSITION-IF-NOT D S :START(1+ B)))(VECTOR-PUSH-EXTEND(SUBSEQ S B E)R))

— जोशुआ टेलर
स्रोत

मैं (resultशरीर को अंतिम कोष्ठक पर शुरू से गिनती होगी । नाम और मापदंडों को परिभाषित करने वाला हिस्सा घोषणा है।

— इसियाह मीडोज

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

— इशिआ मीडोज

@impinball हाँ, "1" गिनती एक मजाक की तरह है, लेकिन यहाँ महत्वपूर्ण हिस्सा यह है कि यहाँ एक पैरामीटर के रूप result में घोषित किया गया है; यह सिर्फ एक बहुत ही गैर तुच्छ प्रारंभिक रूप है। यह एक ही बात है, सिद्धांत रूप में, कुछ जटिल अभिव्यक्ति द्वारा गणना की गई डिफ़ॉल्ट मान के साथ एक वैकल्पिक तर्क के रूप में। (सरल मामलों में, char* substring( char *str, int begin, int end(0) )कुछ भाषा में सी-जैसे सिंटैक्स के साथ कुछ कल्पना करना आसान है, यह निर्दिष्ट करने के लिए कि endवैकल्पिक है और यदि यह प्रदान नहीं किया गया है, तो इसका मूल्य है 0। मैं सिर्फ इस तथ्य पर प्रकाश डाल रहा हूं कि इनमें से कुछ शब्द हैं

— जोशुआ टेलर

@impinball कुछ ठोस बाइट काउंट को रोकने के लिए पर्याप्त ठोस और भाषा अज्ञेय नहीं हैं। :)

— जोशुआ टेलर

पहला भाग जो मापदंडों को निर्दिष्ट नहीं कर रहा है, वह वह जगह है जहाँ मैं गणना करूँगा (जैसे (defun fn (string &aux (start 0) (end 0)कि गिनती नहीं होगी, लेकिन लैम्ब्डा में शेष सब कुछ होगा)।

— इसियाह मीडोज

0

जावास्क्रिप्ट, 240 बाइट्स

और आप में से जो उत्सुक हैं, उनके लिए यहाँ मेरा शायद बड़ा गोल्फ है:

function split(a) { // begin function
function f(c){for(var a=-1,d=9;d--;){var e=c.indexOf(d+"");0
>e||e<a&&(a=e)}return 0<a?a:null}var c=f(a);if(null==c)retur
n null;var d=[];for(i=0;;){a=a.substring(c);d[i]||(d[i]="");
c=f(a);if(null==c)break;d[i]+=a.charAt(c);0<c&&i++}return d;
} // end function

सुंदर प्रिंट में ऊपर:

function split(a) {
    function f(c) {
        for (var a = -1, d = 9;d--;) {
            var e = c.indexOf(d + "");
            0 > e || e < a && (a = e);
        }
        return 0 < a ? a : null;
    }
    var c = f(a);
    if (null == c) return null;
    var d = [];
    for (i = 0;;) {
        a = a.substring(c);
        d[i] || (d[i] = "");
        c = f(a);
        if (null == c) break;
        d[i] += a.charAt(c);
        0 < c && i++;
    }
    return d;
}

ऊपर सामान्य वर्णनात्मक कोड में

function split(a) {
    function findLoop(string) {
        var lowest = -1;
        var i = 9;
        while (i--) {
            var index = string.indexOf(i + '');
            if (index < 0) continue;
            if (index < lowest) lowest = index;
        }
        return (lowest > 0) ? lowest : null;
    }
    var index = findLoop(a);
    if (index == null) return null;
    var ret = [];
    i = 0;
    for ( ; ; ) {
        a = a.substring(index);
        if (!ret[i]) ret[i] = '';
        index = findLoop(a);
        if (index == null) break;
        ret[i] += a.charAt(index);
        if (index > 0) i++;
    }
    return ret;
}

— इसियाह
स्रोत

0

PHP 134

function f($a){
$i=0;while($i<strlen($a)){!is_numeric($a[$i])&&$a[$i]='-';$i++;}return array_filter(explode('-',$a),function($v){return!empty($v);});
}

— Einacio
स्रोत

आप कॉलबैक से बाहर जाकर इसे छोटा कर सकते हैं array_filter। यह स्वचालित रूप से सभी प्रविष्टियों को हटा देगा जो कि falseजब वे बूलियन के लिए डाली जाती हैं।

— kelunik

@kelunik जो 0s को भी फ़िल्टर करेगा

— Einacio

0

सी, 158

#define p printf
char s[100],c;int z,i;int main(){while(c=getchar())s[z++]=(c>47&&c<58)*c;p("[");for(;i<z;i++)if(s[i]){p("\"");while(s[i])p("%c",s[i++]);p("\",");}p("]");}

चूंकि C does not में सरणी प्रिंट फ़ंक्शंस अंतर्निहित हैं, मुझे यह काम अपने दम पर करना था इसलिए मैं माफी माँगता हूँ कि हर आउटपुट में एक अंतिम अल्पविराम होता है। अनिवार्य रूप से वह कोड क्या करता है यह स्ट्रिंग को पढ़ता है यदि यह एक अंक नहीं है तो यह इसे '\ 0' से बदल देता है और फिर मैं कोड के माध्यम से लूप करता हूं और अंकों की सभी जंजीरों को प्रिंट करता हूं। (EOF = 0)

इनपुट: ab5c0x
आउटपुट: ["5", "0",]

इनपुट: z526ks4f; 8] \ p
आउटपुट: ["526", "4", "8"]]

— ASKASK
स्रोत

प्रश्न के नियम (नियम 2) के अनुसार, आपको केवल फ़ंक्शन बॉडी में वर्णों को गिनना होगा। तो आपका समाधान वास्तव में 170 बाइट्स से कम होगा। मुझे यकीन नहीं है कि गिनती में फ़ंक्शन बॉडी के बाहर चर प्रोटोटाइप शामिल हैं, हालांकि।

— ग्रोसविएनएल

मैं इस पर नियमों में संशोधन करूंगा: #defines, परिवर्तनीय घोषणाएं आदि की गणना होगी, लेकिन फ़ंक्शन घोषणा नहीं करेगा।

— इशीह

साथ ही, पिछली बार जब मैंने जाँच की थी, तब C नोटेड में एक प्रकार था char[][]जो कानूनी है। यदि आप उस (याchar** ) के , तो आप ठीक हो जाएंगे।

— इसियाह मीडोज

यह पाठ उत्पादन करने के लिए नहीं है? हालांकि मैं कार्यक्रम को एक स्ट्रिंग प्रारूप में सरणी का उत्पादन करने वाला था

— ASKASK

0

सी #, 98

static string[] SplitAtNonDigits(string s)
{
    return new string(s.Select(c=>47<c&c<58?c:',').ToArray()).Split(new[]{','},(StringSplitOptions)1);
}

सबसे पहले, यह .Select()सभी गैर-अंकों को कॉमा में बदलने के लिए LINQ एक्सटेंशन विधि का उपयोग करता है । string.Replace()बेहतर होगा, क्योंकि यह एक के stringबजाय एक रिटर्न देता है IEnumerable<char>, लेकिनstring.Replace() केवल एक ही चार्ट या स्ट्रिंग ले सकता है और एक विधेय का उपयोग नहीं कर सकताchar.IsDigit() या47<c&c<58 ।

जैसा कि उल्लेख किया गया है, .Select()एक स्ट्रिंग पर लागू किया गया रिटर्न एIEnumerable<char> , इसलिए हमें इसे एक सरणी में बदलकर और सरणी को में पास करके इसे वापस स्ट्रिंग में बदलने की आवश्यकता है।string कंस्ट्रक्टर ।

अंत में, हम स्ट्रिंग को कॉमा का उपयोग करके विभाजित करते हैं string.Split()। (StringSplitOptions)1कहने का एक छोटा तरीका है StringSplitOptions.RemoveEmptyEntries, जो स्वचालित रूप से स्ट्रिंग के शुरू / अंत में कई लगातार कॉमा और कॉमा का ध्यान रखता है।

— BenM
स्रोत

1

इसके बजाय char.IsDigit(c), आप का उपयोग कर सकते हैं'/'<c&&c<':'

— grovesNL

1

अच्छा बिंदु ... या इससे भी बेहतर 47<c&&c<58,। (स्पष्ट रूप से, मुझे आश्चर्य है कि यह संख्याओं के साथ काम करता है, लेकिन स्पष्ट रूप से यह करता है)।

— BenM

1

और मैं एक डबल और && के बजाय एकल '&' का उपयोग करके एक अतिरिक्त मूल्यवान चरित्र को बचा सकता हूं। C # में, यह अभी भी तार्किक है और जब दोनों ऑपरेंड बूलियन होते हैं - यह केवल एक बिटवाइज़ करता है और जब वे पूर्णांक होते हैं।

— बेनएम

अच्छा है। मुझे नहीं पता था कि वह ऐसा करने में सक्षम था।

— ग्रूव्सएनएल

थोड़ा छोटा संस्करण इसके बजाय सफेद स्थान पर विभाजित करने के लिए है ,, और फिर मैन्युअल रूप से खाली वस्तुओं को हटा देंreturn new string(s.Select(c=>47<c&c<58?c:' ').ToArray()).Split().Where(a=>a!="").ToArray();

— विज़ुअलमेल

0

JS / Node: ~~168~~ ~~162~~ ~~147~~ 138 शुल्क

function n(s){
var r=[];s.split('').reduce(function(p,c){if(!isNaN(parseInt(c))){if(p)r.push([]);r[r.length-1].push(c);return 0;}return 1;},1);return r;
}

सुशोभित संस्करण:

function n(s) {
  var r = [];
  s.split('').reduce(function (p, c) {
    if (!isNaN(parseInt(c))) {
      if (p) {
        r.push([]);
      }
      r[r.length - 1].push(c);
      return 0;
    }
    return 1;
  }, 1);
  return r;
}

— Palanik
स्रोत

यह प्रश्न केवल सरणी वापस चाहता है, इसलिए आप निकाल सकते हैं console.log(r)और कुछ अन्य चीजें

— नहीं कि चार्ल्स

फ़ंक्शन की घोषणा स्कोर की ओर नहीं गिना जाती है (कारण खेल के मैदान को समतल करने में मदद करना है)

— इशीया मीडोज

ठीक है। @ इंपीबॉल की टिप्पणी के अनुसार स्कोर समायोजित किया। (वास्तव में यहां दो कार्य

— बताए गए

यह होना चाहिए। मैंने इसे बेहतर तरीके से समझाने में मदद करने के लिए नियमों को अपडेट किया।

— इसियाह

इस बीच, कुछ बेहतर के साथ आया ...

— palanik

0

रूबी, २४

f=->s{s.tr("
-/:-~",' ').split}

प्रिंट करने योग्य ascii रेंज के भीतर नकारात्मक स्थान का उपयोग करके अंकों को परिभाषित करता है।

— histocrat
स्रोत

समारोह घोषणा की गिनती नहीं है।

— इशीया मीडोज

0

php , 204

function s($x){$a=str_split($x);$c=-1;$o=array();
for($i= 0;$i<count($a);$i++){if(ord($a[$i])>=48&&ord($a[$i])<=57)
{$c++;$o[$c]=array();}while(ord($a[$i])>=48&&ord($a[$i])<=57)
{array_push($o[$c],$a[$i]);$i++;}}return $o;}

वर्णनात्मक कोड:

function splitdigits($input){

    $arr = str_split($input);
    $count = -1;
    $output = array();
    for($i = 0; $i < count($arr); $i++){


    if(ord($arr[$i]) >= 48 && ord($arr[$i]) <= 57){
        $count++;
        $output[$count] = array();
    }

    while(ord($arr[$i]) >= 48 && ord($arr[$i]) <= 57){
        array_push($output[$count], $arr[$i]);
        $i++;
    } 

}

return $output;
}

यह बहुत लंबा कोड है और मुझे यकीन है कि इस कोड गोल्फ के लिए बहुत छोटा php संस्करण होगा। यह वही है जो मैं php में आ सकता हूं।

— palerdot
स्रोत

आप बदल सकते हैं: वहाँ कुछ सुधार कर रहे हैं array()के साथ [], array_push($output[$count], $arr[$i]);के साथ $output[$count][]=$arr[$i];, और ord()साथ की जाँच करता is_numeric()। और आपको इसके वर्णों पर स्ट्रिंग को विभाजित करने की भी आवश्यकता नहीं है। इसके अलावा, केवल फ़ंक्शन का आंतरिक कोड मायने रखता है, इसलिए जैसे ही आप चार गिनती करते हैं, वह 204 होता है।

— Einacio

फ़ंक्शन की घोषणा की गणना नहीं है। क्या मायने रखता है और क्या नहीं पर एक गाइड के रूप में नियम 2 का संदर्भ लें।

— इशीआ मीडोज

0

अजगर

def find_digits(_input_):
    a,b = [], ""
    for i in list(_input_):
        if i.isdigit(): b += i
        else:
            if b != "": a.append(b)
            b = ""
    if b != "": a.append(b)
    return a

— मैंने StackExchange को छोड़ दिया
स्रोत

0

पायथन 104 83

def f(s, o=[], c=""):
    for i in s:
        try:int(i);c+=i
        except:o+=[c];c=""
    return [i for i in o+[c] if i]

@ अभिजीत का जवाब बहुत चालाक है, यह मेरे दिमाग में सिर्फ एक "छोटा" संस्करण है।

assert f("abc123def456") == ["123", "456"]
assert f("aitew034snk582:3c") == ["034", "582", "3"]
assert f("as5493tax54\\430-52@g9.fc") == ["5493", "54", "430", "52", "9"]
assert f("sasprs]tore\"re\\forz") == []

यह कोई आउटपुट नहीं देता है, इसलिए कोड काम कर रहा है, अगर एक-एक करके चलाया जाता है, क्योंकि कुछ चर को घोषणा में परिभाषित किया जाता है।

— gcq
स्रोत

यदि आपने किया है तो आपको फ़ंक्शन की घोषणा की गणना करने की आवश्यकता नहीं है। बस एक सिर के रूप में

— Isiah Meadows

0

पीएचपी 98 89

DigitalTrauma के मार जवाब के रूप में, यह एक regex का उपयोग नहीं करता है।

function f($x) {
// Only the following line counts:
for($h=$i=0;sscanf(substr("a$x",$h+=$i),"%[^0-9]%[0-9]%n",$j,$s,$i)>1;)$a[]=$s;return@$a;
}

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

php > echo json_encode(f("abc123def456")), "\n";
["123","456"]
php > echo json_encode(f("aitew034snk582:3c")), "\n";
["034","582","3"]
php > echo json_encode(f("as5493tax54\\430-52@g9.fc")), "\n";
["5493","54","430","52","9"]
php > echo json_encode(f("sasprs]tore\"re\\forz")), "\n";
null

— कृपया उठो
स्रोत

0

हास्केल 31

{-# LANGUAGE OverloadedStrings #-}
import Data.Char (isDigit)
import Data.Text (split)

f=filter(/="").split(not.isDigit)

यह सभी गैर-संख्यात्मक वर्णों पर स्ट्रिंग को विभाजित करता है और लगातार सीमांकक द्वारा उत्पन्न खाली तारों को हटा देता है।

— lortabac
स्रोत

0

VBA 210, 181 बिना फ़ंक्शन घोषणा के

Function t(s)
Dim o()
For Each c In Split(StrConv(s,64),Chr(0))
d=IsNumeric(c)
If b And d Then
n=n&c
ElseIf d Then:ReDim Preserve o(l):b=1:n=c
ElseIf b Then:b=0:o(l)=n:l=l+1:End If:Next:t=o
End Function

— Gaffi
स्रोत

0

Rebol (66 वर्ण)

remove-each n s: split s complement charset"0123456789"[empty? n]s

Ungolfed और लिपटे समारोह में घोषणा:

f: func [s] [
    remove-each n s: split s complement charset "0123456789" [empty? n]
    s
]

Rebol कंसोल में उदाहरण कोड:

>> f "abc123def456"
== ["123" "456"]

>> f "aitew035snk582:3c"
== ["035" "582" "3"]

>> f "as5493tax54\\430-52@g9.fc"
== ["5493" "54" "430" "52" "9"]

>> f {sasprs]torer"re\\forz}
== []

— draegtun
स्रोत

0

जावास्क्रिप्ट, 104 97 89

golfed:

संपादित करें: जब छोरों सरणी के अंत से चलता है, cहैundefined जो falsy है, और लूप समाप्त हो जाता है।

2/27: का उपयोग करने की पवित्रता?: बचाता है if/else।

function nums(s) {
s+=l='length';r=[''];for(k=i=0;c=s[i];i++)r[k]+=+c+1?c:r[k+=!!r[k][l]]='';
r[l]--;return r
}

शरीर में कैरिज वापसी पठनीयता के लिए है और समाधान का हिस्सा नहीं है।

Ungolfed:

विचार यह है कि प्रत्येक वर्ण को सरणी में अंतिम प्रविष्टि के लिए जोड़ा जाए यदि यह एक अंक है और यह सुनिश्चित करना है कि अंतिम सरणी प्रविष्टि एक स्ट्रिंग है अन्यथा।

function nums(s) {
    var i, e, r, c, k;
    k = 0;
    s+='x'; // ensure the input does not end with a digit
    r=[''];
    for (i=0;i<s.length;i++) {
        c=s[i];
        if (+c+1) { // if the current character is a digit, append it to the last entry
            r[k] += c;
        }
        else { // otherwise, add a new entry if the last entry is not blank
            k+=!!r[k].length;
            r[k] = '';
        }
    }
    r.length--; // strip the last entry, known to be blank
    return r;
}

— DocMax
स्रोत

0

जावास्क्रिप्ट, 72

function f(a){
 a+=".",b="",c=[];for(i in a)b=+a[i]+1?b+a[i]:b?(c.push(b),""):b;return c
}

Ungolfed

a+=".",b="",c=[];        //add '.' to input so we dont have to check if it ends in a digit
for(i in a)
    b=+a[i]+1?           //check if digit, add to string if it is
        b+a[i]:         
    b?                   //if it wasnt a digit and b contains digits push it
        (c.push(b),""):  //into the array c and clear b
    b;                   //else give me b back
return c

नमूना इनपुट / आउटपुट

console.log(f("abc123def456"));
console.log(f("aitew034snk582:3c"));
console.log(f("as5493tax54\\430-52@g9.fc"));
console.log(f("sasprs]tore\"re\\forz"));

["123", "456"]
["034", "582", "3"]
["5493", "54", "430", "52", "9"]
[]

JSFiddle

— डैनी
स्रोत

1

मुझें यह पसंद है! अपने से बहुत सरल। आप के if(+a[i]+1)b+=a[i];else if(b)c.push(b),b=""साथ बदलकर एक और 8 अक्षर ड्रॉप कर सकते हैं b=+a[i]+1?b+a[i]:b?(c.push(b),""):b।

— 19

@DocMax thx, मैंने आपके सुझाव को शामिल करने के लिए संपादन किया :)। जो (c.push(b),"")चालाक लग रहा था, वह कभी नहीं देखा।

— डैनी

मैं इसके बारे में भूल गया था जब तक कि मैंने इसे पहले बड़े पैमाने पर इस्तेमाल नहीं किया था आज codegolf.stackexchange.com/questions/22268#22279

— DocMax

यह मान्य नहीं है, '' 0 के लिए गलत है और यह एक जावास्क्रिप्ट क्विक है जिसे प्रबंधित करना मुश्किल है। कोशिश '12 34 56 '

— edc65

0

आर 52

यह फ़ंक्शन वर्ण वर्ग द्वारा स्ट्रिंग्स को विभाजित करता है (यह regex नहीं है! :)) वर्ग N - संख्यात्मक वर्ण है और P {N} का अर्थ है इस वर्ग की उपेक्षा। o = T का अर्थ है खाली पदार्थ को छोड़ना।

x
## [1] "wNEKbS0q7hAXRVCF6I4S" "DpqW50YfaDMURB8micYd" "gwSuYstMGi8H7gDAoHJu"
require(stringi)
stri_split_charclass(x,"\\P{N}",o=T)
## [[1]]
## [1] "0" "7" "6" "4"

## [[2]]
## [1] "50" "8" 

## [[3]]
## [1] "8" "7"

— bartektartanus
स्रोत

0

PHP 99

<?php

$a = function($s) {
foreach(str_split($s)as$c)$b[]=is_numeric($c)?$c:".";return array_filter(explode('.',implode($b)));
};

var_dump($a("abc123def456"));
var_dump($a("aitew034snk582:3c"));
var_dump($a("as5493tax54\\430-52@g9.fc"));
var_dump($a("sasprs]tore\"re\\forz"));

उत्पादन

array(2) {
  [3]=>
  string(3) "123"
  [6]=>
  string(3) "456"
}
array(3) {
  [5]=>
  string(3) "034"
  [8]=>
  string(3) "582"
  [9]=>
  string(1) "3"
}
array(5) {
  [2]=>
  string(4) "5493"
  [5]=>
  string(2) "54"
  [6]=>
  string(3) "430"
  [7]=>
  string(2) "52"
  [9]=>
  string(1) "9"
}
array(0) {
}

— kelunik
स्रोत

0

जावास्क्रिप्ट 88

88 वर्ण जब गिनती नहीं करते हैं तो n (x) {}

function n(x){
y=[],i=0,z=t=''
while(z=x[i++])t=!isNaN(z)?t+z:t&&y.push(t)?'':t
if(t)y.push(t)
return y
}

— wolfhammer
स्रोत

RegExps के बिना गैर-अंकों में एक स्ट्रिंग को विभाजित करने का सबसे छोटा कार्यक्रम

वर्तमान स्टैंडिंग (श्रेणियों में अलग):

नियम:

लिस्प के लिए दिशानिर्देश

एपीएल, 13 वर्ण

अजगर ४on

रूबी, 70

बैश, 26 (फ़ंक्शन सामग्री: 22 + सरणी असाइनमेंट ओवरहेड 4)

गणितज्ञ ३२

बैश, 21 बाइट्स 17/21 बाइट्स ( DigitalTrauma द्वारा सुधार )

प्रयोग

संपादित करें

स्मॉलटॉक (स्मॉलटाक / एक्स), 81

आर, 81

पर्ल, 53

सी, 68 बाइट्स (केवल फ़ंक्शन का शरीर)

उदाहरण का उपयोग करें

उत्पादन

अन-गोल्फ संस्करण:

VBScript, 190 (कार्य घोषणा के बिना 164)

आम लिस्प (पत्र के अनुसार 1; according173 भावना के अनुसार)

जावास्क्रिप्ट, 240 बाइट्स

सुंदर प्रिंट में ऊपर:

ऊपर सामान्य वर्णनात्मक कोड में

PHP 134

सी, 158

सी #, 98

रूबी, २४

पायथन 104 83

पीएचपी 98 89

हास्केल 31

VBA 210, 181 बिना फ़ंक्शन घोषणा के

Rebol (66 वर्ण)

जावास्क्रिप्ट, 104 97 89

जावास्क्रिप्ट, 72

आर 52

PHP 99

उत्पादन

जावास्क्रिप्ट 88