चुनौती

कार्यक्रम को संख्याओं के एक समूह (अल्पविराम और हाइफन अलग अनुक्रम) में शामिल सभी संख्याओं को वापस करना होगा।

नियम

s अनुक्रम स्ट्रिंग है;
सभी नंबरों में शामिल sकर रहे हैं सकारात्मक ;
संख्या हमेशा बढ़ेगी ;
नंबर कभी नहीं दोहराएंगे
जब आप जवाब देते हैं, तो इसके लिए आउटपुट दिखाएं s="1,3-5,9,16,18-23"

उदाहरण

input(s)    outputs
-----------------
1           1
1,2         1,2
1-4         1,2,3,4
1-4,6       1,2,3,4,6
1-4,8-11    1,2,3,4,8,9,10,11

सौभाग्य। =)

code-golf number sequence

— BernaMariano
स्रोत

1

क्या हमारे पास कभी इनपुट अनुक्रम होंगे जो लगातार नहीं बढ़ रहे हैं, उदाहरण के लिए: 4-9,1-2या 1-3,9-6?

— मैट

1

या ओवरलैपिंग? क्या आउटपुट को छाँटना पड़ता है और इसमें डुप्लिकेट नहीं होते हैं?

— पीटर टेलर

@ गैरेथ हां, यह एक कोड-गोल्फ है, तो कृपया सबसे कम उत्तर के लिए वोट-अप करें। मैट और पीटर, मैंने सवाल संपादित किया, कृपया इसे जांचें। धन्यवाद!

— बर्नारियो

क्या इसके लिए एक पूर्ण कार्यक्रम होना चाहिए, और क्या आउटपुट के प्रारूप पर प्रतिबंध है?

— ब्रैड गिल्बर्ट b2gills

1

नकल?

— 213 बजे 21

6

गोल्फस्क्रिप्ट (24 वर्ण)

','/{~.,!{~)),>~}*}%','*

उदाहरण के लिए

$ golfscript.rb expand.gs <<<"1,3-5,9,16,18-23"
1,3,4,5,9,16,18,19,20,21,22,23

मेरे पास वास्तव में चार 24-चार समाधान हैं, लेकिन मैंने इसे एक चुना क्योंकि इसमें कोई अल्फ़ान्यूमेरिक वर्ण नहीं है।

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

# On the stack: a string such as "1,3-5,9,16,18-23"
','/
# Split on commas to get ["1" "3-5" "9" "16" "18-23"]
{
    # This is executed for each of those strings in a map
    # So stack holds e.g. "1" or "3-5"

    # Evaluate the string.
    # If it's a single number, this puts the number on the stack.
    # Otherwise it's parsed as a positive number followed by a negative number.
    ~
    # Stack holds e.g. 1 or 3 -5
    # Duplicate the last element on the stack and make a list of that length.
    # If it's negative or zero, the list will be empty
    .,
    # Negate. An empty list => 1; a non-empty list => 0
    !
    # If the string was a single number "n", the stack now holds n 0
    # If the string was a range "m-n", the stack now holds m -n 1
    # The following block will be executed 0 times for "n" and once for "m-n"
    {
        # Here we rely on twos-complement numbers satisfying ~n = -n -1
        # Stack: m -n
        ~))
        # Stack: m -(-n)-1+2  =  m n+1
        ,
        # Stack: m [0 1 2 ... n]
        >
        # Stack: [m m+1 ... n]
        ~
        # Stack: m m+1 ... n
    }*
}%
# On the stack: e.g. [1 3 4 5 9 16 18 19 20 21 22 23]
','*
# Joined by , to give the desired output

— पीटर टेलर
स्रोत

एक पात्र का उपयोग किए बिना आप 3,4,5 में 3-5 का विस्तार कैसे कर सकते हैं -?

— बर्नमैरियनो

@BernaMariano, क्षमा करें, मैंने किसी तरह आपके प्रश्न को याद किया। मैं विस्तृत विवरण के साथ उत्तर का विस्तार करूंगा।

— पीटर टेलर

7

पर्ल 25 26 25

$_ अनुक्रम स्ट्रिंग है

s/-/../g;$_=join",",eval

नमूना सत्र:

[~/] $ perl -M5.010 -pe 's/-/../g;$_=join",",eval' <<< "1,3-5,9,16,18-23"
1,3,4,5,9,16,18,19,20,21,22,23

विकल्प के लिए वर्ण गणना में 1 वर्ण जोड़ा गया (धन्यवाद गैरेथ, ..किंडा)।~~-n~~-p

— ardnew
स्रोत

मैंने संभवतः वर्ण गणना गलत की है (कमांड लाइन विकल्प के साथ)। कृपया मेरी गिनती सही करने के लिए बेझिझक, कृपया

— ardnew

मेटा पर इस प्रश्न के उत्तर से जाने पर , आपको केवल nविकल्प के लिए 1 वर्ण जोड़ना होगा ।

— गारेथ

निकालें -M5.010और विनिमय -eके लिए-E

— ब्रैड गिल्बर्ट b2gills

4

गोल्फस्क्रिप्ट, 46 45

मेरा पहला गोल्फ स्क्रिप्ट कार्यक्रम, पूरा होने में घंटों लग गए।

{','/{'-'/{~}%.,1-{))+{,}/\-~}{~}if}%","*}:r; 

# call:
"1,3-5,9,16,18-23"r

# return:
1,3,4,5,9,16,18,19,20,21,22,23

आप इसे http://golfscript.apphb.com/ पर आज़मा सकते हैं

इस अत्याचार की व्याख्या करते हुए मेरी सर्वश्रेष्ठ फेंक:

{...}:r;     # makes a function block ... and names it r

','/         # slices the top element of stack from each ','
             # so we get ["1" "3-5" "9" "16" "18-23"]

{...}%       # makes a function block ... and calls it for 
             # each element in the list

'-'/{~}%     # slices the list by '-' and evals each element 
             # from string to int. ["1"] becomes [1], 
             # ["3-5"] becomes [3 5]

.,1-         # adds the length of the list -1 on top of the stack
             # so for [1] the stack becomes [1] 0, for [3 5]
             # it becomes [3 5] 1

# next we add two function blocks, they, like the 0/1 just before
# are used by an if clause a tiny bit later. First block is for 
# lists that have a 1 on top of them, the latter for ones with 0.

# First block, we have something like [3 5]

))+          # pops the top element of the array, increments 
             # it and puts back. [3 6]

## It seems {...}%~ is same as {...}/
## this is why these two are not in the code any more

{,}%         # , makes a list from 0 to n-1, where n is the parameter
             # so we get [[0 1 2] [0 1 2 3 4 5]]

~            # Dumps the outer array, [0 1 2] [0 1 2 3 4 5]

\            # swaps the two arrays

-            # set complement [3 4 5]

~            # dumps the array, so the elements are left in the stack

# Second block, we have something like [16]

~            # just dumps the array, 16

# Blocks end

if           # takes the top three elements of the stack, evaluates the 
             # first (0 or 1), runs second if true (anything but 
             # [], "", 0 or {} ), otherwise the third.

","*         # joins an array with ","

1 संपादित करें: अंतिम {}% ~ से {} / में बदल गया, यह भी कि मेरा विवरण गलत था।

— shiona
स्रोत

2

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

— गारेथ

@ गैरेथ धन्यवाद। मैंने पहले सोचा था कि मैं इसे केवल पर्ल तरीके से करूँगा: परिवर्तन - से .. और इसका मूल्यांकन करना। तब मैं किसी भी सरणियों का निर्माण करने के लिए कोई समझदार तरीका नहीं खोज सका, इसलिए मैंने ऐसा किया। मुझे यकीन है कि कोई व्यक्ति ~ 20 चार गोल्फ समाधान के साथ चार समाधान के साथ आएगा।

— शियोना

मेरे पास इस समय 24 हैं, इसलिए मैं 20 को चुनौती के रूप में लूंगा;) हालांकि, आप कुछ आसानी से बचा सकते हैं। समस्या एक कार्यक्रम के लिए पूछती है, एक फ़ंक्शन के लिए नहीं, इसलिए आप प्रारंभिक {और अंतिम को खो सकते हैं }:r;और आप के 1-साथ बदलकर भी बचा सकते हैं (। (संयोग से, IIRC वह एक चाल है जिसे मैंने अपने पहले गोल्फस्क्रिप्ट कार्यक्रम में भी याद किया था)

— पीटर टेलर

PS वहाँ {...}%~और के बीच एक सूक्ष्म अंतर है {...}/। यदि आप स्टैक का उपयोग करके आगे कुछ नीचे पहुंच रहे हैं, integer $तो पहला सरल है, क्योंकि स्टैक पर जो भी आप छोड़ रहे हैं उसकी भरपाई के लिए आपको पूर्णांक को हर बार समायोजित करने की आवश्यकता नहीं है।

— पीटर टेलर

4

आर , 44 बाइट्स

`-`=seq;eval(parse(t=c("c(",scan(,""),")")))

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

-मतलब seq(यानी :) को फिर से परिभाषित करें , इनपुट को चारों ओर से घेरें c()और संबंधित अभिव्यक्ति का मूल्यांकन करें।

— रॉबिन राइडर
स्रोत

3

के, ४

","/:,/${x+!1+y-x}.'2#'a,'a:"I"$'"-"\:'","\:0:0

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

k)","/:,/${x+!1+y-x}.'2#'a,'a:"I"$'"-"\:'","\:0:0
1,3-5,9,16,18-23
"1,3,4,5,9,16,18,19,20,21,22,23"

— tmartin
स्रोत

","/:$,/{{x+!1+y-x}. 2#"J"$"-"\:x}'","\:0:0के लिए 43 बाइट्स

— streetster

3

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

⁾-ryṣ”,VF

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

   y         Replace
⁾-r          hyphens with the letter r,
    ṣ”,      split on commas,
       V     evaluate every element,
        F    and flatten.

रेंज डेड इसके rदोनों ओर दो तर्क देता है और उनके बीच एक समावेशी रेंज पैदा करता है।

— असंबंधित स्ट्रिंग
स्रोत

2

जे, ५३ ४३ ४१ ३ ९ ३ characters अक्षर

;(}.[:i.1+])/&.>".'- ,;'charsub 1!:1[1

कीबोर्ड से इनपुट लेता है:

   ;(}.[:i.1+])/&.>".'- ,;'charsub 1!:1[1
1-4,8-11
1 2 3 4 8 9 10 11

अनुरोधित परीक्षण मामले के लिए आउटपुट:

   ;(}.[:i.1+])/&.>".'- ,;'charsub 1!:1[1
1,3-5,9,16,18-23
1 3 4 5 9 16 18 19 20 21 22 23

— गैरेथ
स्रोत

2

हासियम , 173 बाइट्स

यह बहुत लंबा था और प्रतिस्पर्धा नहीं हो सकती है क्योंकि अंत में एक अनुगामी है।

 func main(){p="1,2,3,5-8".split(",")for(c=0;c<p.length;c++){e=p[c]if(e.contains("-")){p=e.split("-")for(x=p[0].toInt();x<=p[1].toInt()print(x++ +",")){}}else print(e+",")}}

ऑनलाइन चलाएं और यहां विस्तारित देखें

— जैकब मिसिरियन
स्रोत

1

पर्ल (37)

$_=<>;s/^/say join',',/;s/-/../g;eval

— मारीनस
स्रोत

- जब आप उत्तर देते हैं, s="1,3-5,9,16,18-23"धन्यवाद के लिए आउटपुट दिखाते हैं

— बर्नमैरिएनो

कैसे say join",",eval<>=~s/-/../gr29 बाइट्स के बारे में

— ब्रैड गिल्बर्ट b2gills

1

पायथन 2.7, 147 138 बाइट्स

z, च = इनपुट ()। विभाजन ( ','), []
i in z:
 एक्स = i.split ( '-')
 अगर len (x)> 1: f + = रेंज (int (x [0]), int (x [1]) + 1)
 बाकी: च + = [पूर्णांक (एक्स [0])]
प्रिंट str (f) [1: -1]

उपयोग:

>>> अजगर सुन्न
"1,3-5,9,16,18-23"
1, 3, 4, 5, 9, 16, 18, 19, 20, 21, 22, 23

सबसे अच्छा कार्यक्रम नहीं ...

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

1

PPCG में आपका स्वागत है। मुझे लगता है कि आप इंडेंट के लिए 1 स्थान का उपयोग करके अपने उत्तर को छोटा बना सकते हैं।

— इंट्रेपिडकोडर

धन्यवाद @intrepidcoder, मुझे नहीं पता था कि आप सिंगल स्पेस इंडेंट का उपयोग कर सकते हैं।

— एलेक्स

1

MATLAB, 47 बाइट्स

disp(eval(['[',strrep(input(''),'-',':'),']']))

यह स्निपेट कमांड विंडो से एक स्ट्रिंग इनपुट पढ़ता है, '-' द्वारा ':' को प्रतिस्थापित करता है, स्ट्रिंग में स्क्वायर ब्रैकेट जोड़ता है और फिर इसका मूल्यांकन करता है, ताकि इनपुट को पूर्ण संख्या में विस्तारित किया जा सके।

उदाहरण इनपुट:

'1,3-5,9,16,18-23'

उदाहरण आउटपुट:

1     3     4     5     9    16    18    19    20    21    22    23

मेरा मानना है कि इस आउटपुट की अनुमति है, क्योंकि चुनौती केवल यह कहती है कि एक समूह में सभी संख्याओं को प्रदर्शित किया जाना चाहिए।

— slvrbld
स्रोत

अल्पविराम से अलग किया गया उत्पादन अच्छा होगा, हालांकि मैं 5-रिक्त स्थान-पृथक पैटर्न को देख सकता हूं, मेरे लिए यह बहुत अच्छा है :)

— बर्नमैरियनो

1

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

$_=get;say join ',',EVAL S:g/\-/../

1,3,4,5,9,16,18,19,20,21,22,23

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

पॉवरशेल, 79 71 बाइट्स

('('+($args[0]-replace'-','..'-replace',','),(')+')'|iex|%{$_})-join','

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

आंतरिक भाग "1,5-9,12" को "(1), (5..9), (12)" स्वरूप में बदलता है, जिसे पावरशेल समझता है, फिर इसका अर्थ इरेक्स के साथ निष्पादित करता है, जो एरे का एक सरणी बनाता है। फिर प्रत्येक आंतरिक सरणी के माध्यम से पुनरावृति करें, फिर अंत में सभी बाहरी सरणी तत्वों को एक साथ जोड़ दें

मेरे "हेल्प मी मैनेज माय टाइम" उत्तर से उधार कोड

प्रयोग

PS C:\Tools\Scripts\golfing> .\return-each-number-from-a-group-of-numbers.ps1 '1,3-5,9,16,18-23'
1,3,4,5,9,16,18,19,20,21,22,23

-8 बाइट्स Veskah के लिए धन्यवाद

— AdmBorkBork
स्रोत

आप निरर्थक कार्य कर रहे हैं, 71 बाइट्स

— Veskah

1

के (ओके) , 40 31 बाइट्स

समाधान

,/{{x+!1+y-x}. 2#.:'"-"\x}'","\

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

स्पष्टीकरण:

स्पष्टीकरण जोड़ते हुए अधिक गोल्फिंग का प्रबंधन किया ...

,/{{x+!1+y-x}. 2#.:'"-"\x}'","\ / the solution
                           ","\ / split input on ","
  {                      }'     / apply lambda to each
                    "-"\x       / split x on "-"
                 .:'            / value (.:) each (')
               2#               / 2 take (dupe if only 1 element)
   {        }.                  / diadic lambda, 2 args x and y
         y-x                    / y subtract x
       1+                       / add 1
      !                         / range 0..n
    x+                          / add x
,/                              / flatten

— streetster
स्रोत

0

क्लोजर, 110 बाइट्स

#(clojure.string/join","(for[s(.split %",")[a b][(map read-string(.split s"-"))]r(if b(range a(inc b))[a])]r))

तार के साथ काम करना ज्यादा मजेदार नहीं है :(

— NikoNyrh
स्रोत

0

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

बहुत सरल और सीधा जवाब।

L=[]
for s in input().split(','):
 if'-'in s:a,b=map(int,s.split('-'));L+=range(a,b+1)
 else:L+=[int(s)]
print L

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

— mbomb007
स्रोत

0

रूबी `-p` , 33 बाइट्स

gsub(/(\d+)-(\d+)/){[*$1..$2]*?,}

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

— मान स्याही
स्रोत

0

जाप , 12 बाइट्स

q, c@OvXr-'ò

कोशिश करो

— झबरा
स्रोत

आप के c@साथ बदल सकते हैं £?

— ओलिवर

@ ओलिवर, जैसा कि यह एक पुरानी चुनौती है जो इसके I / O प्रारूप को निर्दिष्ट नहीं करता है, मैंने सावधानी की तरफ मिटा दिया, इनपुट को अल्पविराम वाले स्ट्रिंग के रूप में लिया और एक चपटा सरणी के रूप में आउटपुट किया। आम तौर पर, हालांकि, हां, मैंने इनपुट को स्ट्रिंग्स की एक सरणी के रूप में निर्दिष्ट किया है, एक बहु-आयामी सरणी के रूप में आउटपुट और सिर्फ £पहले 5 बाइट्स के स्थान पर उपयोग किया जाता है ।

— झबरा

0

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

lambda s:sum((range(u[0],u[-1]+1)for u in[map(int,t.split('-'))for t in s.split(',')]),[])

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

— चास ब्राउन
स्रोत

संख्याओं के समूह से प्रत्येक संख्या लौटाएं

चुनौती

नियम

उदाहरण

गोल्फस्क्रिप्ट (24 वर्ण)

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

पर्ल 25 26 25

गोल्फस्क्रिप्ट, 46 45

आर , 44 बाइट्स

के, ४

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

जे, ५३ ४३ ४१ ३ ९ ३ characters अक्षर

हासियम , 173 बाइट्स

पर्ल (37)

पायथन 2.7, 147 138 बाइट्स

MATLAB, 47 बाइट्स

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

पॉवरशेल, 79 71 बाइट्स

प्रयोग

के (ओके) , 40 31 बाइट्स

क्लोजर, 110 बाइट्स

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

रूबी -p , 33 बाइट्स

जाप , 12 बाइट्स

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

रूबी `-p` , 33 बाइट्स