कोड-गोल्फर के रूप में, हम ( निश्चित रूप से ) जारी करने के लिए उपयोग नहीं किए जाते हैं । हमें ऐसा करने में मदद करने के लिए कुछ उपकरणों की आवश्यकता होगी।

बेशक, एक नई रिलीज के विपणन में मदद करने के लिए, हमें एक अच्छा और चमकदार रिलीज संस्करण की आवश्यकता है। संस्करण 3.0.0 के बारे में सुनकर कौन उत्तेजित नहीं होता है?

कार्य

आपका कार्य एक संस्करण संख्या बढ़ाने के लिए एक कार्यक्रम / दिनचर्या / ... लिखना होगा।

आपको संस्करण संख्या बढ़ाने और "कम महत्वपूर्ण" वाले (यानी पैच संस्करण) को रीसेट करने की आवश्यकता है।

आपको दो तर्क मिलते हैं: वर्तमान संस्करण (उदाहरण के लिए "1.0.3") एक स्ट्रिंग के रूप में, और यह जानने के लिए कि कौन सा इंडेक्स (0 या 1-इंडेक्स किया गया है)।

उदाहरण, 0-अनुक्रमित:

next-version("1.0.3", 0) # 2.0.0
next-version("1.2.3.4.5", 2) # 1.2.4.0.0
next-version("10.0", 0) # 11.0
next-version("3", 0) # 4
next-version("1", 7) # ERROR
next-version("01", 0) # ERROR

संस्करण एक स्ट्रिंग है, प्रत्येक भाग एक संख्या है, जिसे डॉट के साथ अलग किया जाता है। कोई अग्रणी, कोई अनुगामी या कोई निरंतर डॉट्स नहीं हो सकता है (और संख्याओं / डॉट्स के बाहर कुछ भी नहीं)। संस्करण स्ट्रिंग के आकार की कोई सीमा नहीं है।

^[1-9]\d*(\.[1-9]\d*)*$

त्रुटि मामला (अंतिम दो उदाहरण) अपरिभाषित व्यवहार है। गलत इनपुट के मामले में क्या होता है, इस चुनौती की कोई प्रासंगिकता नहीं है।

हमेशा की तरह, मानक कमियां निषिद्ध हैं। आपको स्ट्रिंग को प्रिंट या वापस करने की अनुमति है।

code-golf string parsing

— Ven
स्रोत

1

क्या हम इनपुट को पहले सूचकांक और फिर संस्करण संख्या के रूप में प्राप्त करने के लिए कह सकते हैं?

— सिंह

@Leo हाँ, आदेश एक मुद्दा नहीं है।

— शुक्र

मैं स्ट्रिंग में अंतिम संख्या बढ़ाने के लिए एक परीक्षण मामला जोड़ सकता हूं, या एक उदाहरण या परीक्षण के लिए कुछ कर सकता हूं।

— nmjcman101

@ nmjcman101 एक विशेष मामला कैसे है?

— Ven

3

काश मैं जीत की स्थिति के साथ "सबसे पठनीय" के रूप में एक ही चुनौती दे सकता था, इसलिए कोई मुझे वास्तविक काम में उपयोग करने के लिए लिखेगा। =)

— jpmc26

12

जाप, 16 11 बाइट्स

¡V«´V+ÂX}'.

इसे ऑनलाइन टेस्ट करें! इनपुट नंबर 1-अनुक्रमित है।

मेरे जावास्क्रिप्ट उत्तर के आधार पर। यह जाप की सबसे उपयोगी विशेषताओं में से एक का लाभ उठाता है: प्रत्येक आइटम को मैप करने से पहले एक स्ट्रिंग को दूसरे पर विभाजित करना, फिर मैपिंग के बाद उस स्ट्रिंग पर फिर से जुड़ना।

अपुष्ट और व्याख्या

¡  V«  ´ V+Â X}'.
Um@V&&!--V+~~X}'.
                   Implicit: U = input string, V = input number
Um@           }'.  Split U at periods, then map each item X by this function:
   V&&               If V is 0, return V.
      !--V+~~X       Otherwise, decrement V and return X + !V (increments X iff V was 1).
               '.  Re-join the result with periods.
                   Implicit: output last expression

— ETHproductions
स्रोत

2

एक प्यारी सुविधा वास्तव में!

— जोनाथन एलन

1

अच्छी तरह से drat, मुझे लगा कि मेरे पास बैग में है। मुझे माफ करना, मैं अपने वी उत्तर पर जुनूनी जा रहा हूं और हर आखिरी छोटी बाइट को निचोड़ दूंगा। : पी

— DJMcMayhem

11

विम 20 25 बाइट्स

मुझे दुर्भाग्य से एहसास हुआ कि यह अंतिम संख्या को अपडेट करने के मामले को संभाल नहीं पाया, इसलिए मुझे बाइट्स जोड़ना पड़ा। यह 1-अनुक्रमित है।

DJA.0@"t.qq2wcw0@qq@qx

TryItOnline

Unprintables:

DJA.^[0@"t.^Aqq2wcw0^[@qq@qx

यह अलग-अलग लाइनों के रूप में तर्कों को उल्टे क्रम में लेता है:

3
1.2.3.4.5

स्पष्टीकरण:

DJ                           # Delete the input argument, and join lines
  A.^[0                      # Add a period to the end
       @"t.                  # Move to the "Copy register"th period
           ^A                # Increment the number under the cursor
             qq       @qq@q  # Until an error
               2w            # Move the cursor forward to the next number
                 cw0^[       # Change the number to 0
                           x # Delete the last '.'

— nmjcman101
स्रोत

1

अच्छा! एक स्पष्टीकरण सहायक होगा

— क्रिस्सी लिथोस

@KritiiLithos जोड़ा गया। दुर्भाग्य से मुझे अंतिम संस्करण संख्या बढ़ाने के लिए कुछ बाइट्स भी जोड़ने पड़े, लेकिन ऐसा होता है।

— nmjcman101

मुझे लगता है कि अगर आप 0 अनुक्रमित चला गया, तो आप सिर्फ कर सकता है DJ@"t.<C-a>qq2wcw0<esc>@qq@qजो वापस बीस करने के लिए नीचे है

— DJMcMayhem

@DJMcMayhem मुझे नहीं लगता कि मैं ऐसा कर सकता हूं क्योंकि तब मैं 0 और 1. को अलग नहीं कर

— पाऊंगा

1

अरे हाँ, अच्छी बात है। कैसे के बारे में DJ@"f.@"<esc><C-a>qq2wcw0<esc>@qq@q?

— DJMcMayhem

11

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

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

x=>i=>x.replace(/\d+/g,n=>i&&+n+!--i)

इनपुट नंबर 1-अनुक्रमित है।

टेस्ट स्निपेट

f = x=>i=>x.replace(/\d+/g,n=>i&&+n+!--i)

console.log(f("1.0.3")(1))
console.log(f("1.2.3.4.5")(3))
console.log(f("10.0")(1))
console.log(f("1")(8))

स्निपेट का विस्तार करें

— ETHproductions
स्रोत

2

44 पार किया अभी भी 44 है :)

— कृति लिथोस

1

@KritiiLithos मेरे ब्राउज़र में क्या गलत है? cubeupload.com/im/ofJySU.png

— गुस्तावो रॉड्रिक्स

n=>i&&+n+!--i

— नील

@ नील धन्यवाद! मैं अभी यह पता नहीं लगा सका कि उस अभिव्यक्ति को और कैसे आगे बढ़ाया जाए ...

— ETHproductions

10

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

Àñf.ñò2wcw0

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

यह 0-अनुक्रमित है।

वहाँ एक ctrl-a(ASCII 0x01) है, इसलिए यहाँ एक पठनीय संस्करण है:

Àñf.ñ<C-a>ò2wcw0

स्पष्टीकरण:

À                   " 'arg1' times
 ñ  ñ               " Repeat the following:
  f.                "   Move to the next '.' character
     <C-a>          " Increment the next number
          ò         " Recursively:
           2w       "   Move two words forward
              cw    "   Change this word
                0   "   to a '0'

— DJMcMayhem
स्रोत

7

पर्ल, 40 37 34 + 1 = 35 बाइट्स

-2 बाइट्स @ दादा को धन्यवाद। -3 बाइट्स एक विचार के लिए धन्यवाद, मुझे @ ETHproductions के Japt कोड को पढ़ने से मिला।

-pझंडे के साथ भागो ।

$a=<>;s/\d+/$a--<0?0:$&+!($a+1)/ge

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

कोड का टूटना

-p          #Wraps the program in a while(<>){ ... print$_} statement.
            #Input is read into the $_ variable
$a=<>;s/\d+/$a--<0?0:$&+!($a+1)/ge
$a=<>;                              #Reads the version update into $a
      s/   /                   /ge  #Substitution regex:
                                g   #Repeats the substitution after first match
                                 e  #Interprets replacement as Perl code
       \d+                          #Matches 1 or more digits, and stores match in $&
                  ? :               #Ternary operation
            $a--<0                  #Checks if $a is negative and then decrements $a
                  ?0                #If negative, we've passed our match; print 0 instead
                    :$&+!($a+1)     #Otherwise, we're either printing $& + 0 (if $a was positive) or $& + 1 (if $a was 0).
#Since substitution implicitly modifies $_, and -p prints $_, it prints our answer

— गेब्रियल बेनामी
स्रोत

उन सभी कोष्ठक को दोनों तरफ से हटा दें! (और $&के बजाय $1तो)

— दादा

मुझे पता था कि मुझे कुछ याद आ रहा है! धन्यवाद!

— गैब्रियल बेनामी

1-अनुक्रमित संख्याओं का उपयोग करके 4 बाइट्स बचा सकते हैं: इसे ऑनलाइन आज़माएं!

— 20

5

जेली , 19 17 बाइट्स

ṣ”.V€‘⁹¦µJ’<⁹×j”.

1 अनुक्रमित।

TryItOnline!

कैसे?

ṣ”.V€‘⁹¦µJ’<⁹×j”. - Main link: currentVersion, theIndex
ṣ”.               - ṣplit left (currentVersion) at occurences of '.'
   V€             - eVal €ach (creates a list of integers)
      ⁹           - right argument (theIndex)
       ¦          - apply to given index(es)
     ‘            -    increment
        µ         - monadic chain separation (call the above result z)
         J        - range(length(z))  i.e. ([1,2,3,...,length])
          ’       - decrement         i.e. ([0,1,2,...,length-1])
            ⁹     - right argument (theIndex)
           <      - less than?        i.e. ([1,1,...,(1 at theIndex),0...,0,0,0]
             ×    - multiply by z (vectortises) - zeros out all of z after theIndex
              j”. - join with '.'

— जोनाथन एलन
स्रोत

3

10k पर बधाई !!

— लुइस मेंडो

जेली 2.0 के लिए इंतजार नहीं कर सकते ताकि आप उस से छुटकारा पा सकें V€:)।

— शुक्र

@LuisMendo - धन्यवाद! मैं बहुत बेकार हूं (इससे पहले कि मैं भी ऐसा करता डेनिस ने मेरा 1K मील का पत्थर देखा)।

— जोनाथन एलन

5

MATLAB, 85 बाइट्स

function f(s,j);a=split(s,'.');a(j)=string(double(a(j))+1);a(j+1:end)='0';join(a,'.')

एक आधारित, और गोल्फ में पहला प्रयास!

— MattWH
स्रोत

बहुत बढ़िया! पहली बार मैं नए stringप्रकार के एक्शन में दिख रहा हूं :-)

— लुइस मेंडू

5

सी # 116 104 बाइट्स

using System.Linq;(v,i)=>string.Join(".",v.Split('.').Select(int.Parse).Select((x,n)=>n==i?x+1:n>i?0:x));

व्याख्या

using System.Linq;(v,i)=>   //Anonymous function and mandatory using
    string.Join(".",                    //Recreate the version string with the new values
        v.Split('.')                    //Get individual pieces
            .Select(int.Parse)          //Convert to integers
                .Select(            
                    (x,n)=>             //Lambda with x being the part of the version and n being the index in the collection
                        n==i                    
                            ?x+1        //If n is the index to update increment x
                            :n>i        //Else if n is greater than index to update
                                ?0      //Set to zero
                                :x));   //Otherwise return x

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

— जस्टिनएम - मोनिका को बहाल करें
स्रोत

अनाम फ़ंक्शन हस्ताक्षरstringint

— TheLethalCoder

@TheLethalCoder आह, हां, धन्यवाद।

— जस्टिनएम -

4

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

मुझे लगता है कि यह वास्तव में छोटा हो सकता है .. एक गैर-एन्यूमरेट विकल्प के लिए एक तरीके की आवश्यकता हो सकती है।

lambda s,n:'.'.join(str([-~int(x)*(i==n),x][i<n])for i,x in enumerate(s.split('.')))

यदि हम संस्करण को स्ट्रिंग्स की सूची के रूप में लेने में सक्षम थे, तो 75-बाइट समाधान है:

g=lambda s,n:(str(-~int(s[0]))+'.0'*~-len(s))*(n<1)or s[0]+'.'+g(s[1:],n-1)

इसके अलावा, यदि इनपुट और आउटपुट दोनों संख्याओं की सूची थे, तो 64-बाइट समाधान है:

g=lambda s,n:([-~s[0]]+[0]*~-len(s))*(n<1)or [s[0]]+g(s[1:],n-1)

— Kade
स्रोत

4

वी 14 20 बाइट्स

फिर से, मुझे अंतिम अंक को बढ़ाने के कोने के मामले के लिए कोड जोड़ना होगा। (1 अनुक्रमित)

DJA.0@"t.ò2wcw0òx

TryItOnline

Unprintables:

DJA.^[0@"t.^Aò2wcw0^[òx

यह अलग-अलग लाइनों के रूप में तर्कों को उल्टे क्रम में लेता है:

3
1.2.3.4.5

— nmjcman101
स्रोत

1

अच्छा जवाब! मैं हमेशा किसी और को V का उपयोग करते हुए देखकर खुश हूँ! बस इतना पता है, अगर आप पहला इनपुट 'आर्ग्स' में रखते हैं, तो यह उस नंबर पर 'ए' को पूर्वनिर्धारित करेगा, जिससे आप कर सकते हैं @a(या इससे भी कम À) , जो आपको बाइट्स का एक गुच्छा बचाए।

— DJMcMayhem

4

बैच, 119 बाइट्स

@set s=%1
@set i=%2
@set t=
@for %%i in (%s:.=,%)do @set/an=!!i*(%%i+!(i-=!!i))&call set t=%%t%%.%%n%%
@echo %t:~1%

1 अनुक्रमित।

— नील
स्रोत

4

पर्ल 6, 67 बाइट्स, 0-अनुक्रमित

->$v,$i {$v.split('.').map({++$>$i??($++??0!!$_+1)!!$_}).join: '.'}

स्पष्टीकरण:

->$v,$i {$v.split('.').map({++$>$i??($++??0!!$_+1)!!$_}).join: '.'}
->$v,$i {                                                         } # function taking version/index to increment
         $v.split('.')                                              # split by dot
                      .map({                          })            # for each version number
                            ++$>$i??                                # if an anonymous variable ($), incremented,
                                                                    #  is greater than $i (index to increment)
                                    ($++??       )                  # if it's not the first time we've been over $i
                                                                    # (using another anonymous value, which gets default-init'd to 0)
                                          0                         # then 0 (reset lower version numbers)
                                           !!$_+1                   # otherwise, increment the number at $i
                                                  !!$_              # otherwise return the number part
                                                        .join: '.'  # join with a dot

— Ven
स्रोत

3

बस फी, स्व उत्तर पूरी तरह से पात्र हैं। वास्तव में, वे भी कर रहे हैं के लिए प्रोत्साहित किया

— DJMcMayhem

@DJMcMayhem मुझे इस बारे में पता था, लेकिन मुझे लगा कि वे

— Ven

3

पावरशेल 3+, 75 74 बाइट्स

($args[0]-split'\.'|%{$m=!$b;$b=$b-or$args[1]-eq$i++;(+$b+$_)*$m})-join'.'

Ungolfed

(
    $args[0] -split '\.' | 
        ForEach-Object -Process {
            $m= -not $b
            $b = $b -or ($args[1] -eq $i++)
            (([int]$b) + $_) * $m
        }
) -join '.'

व्याख्या

$argsसरणी का उपयोग करके पैरामीटर स्वीकार किए जाते हैं ।

संस्करण स्ट्रिंग को विभाजित करें ., फिर प्रत्येक तत्व के लिए:
1. $mहोना तय है -not $b। पहले चलाने पर, $bअपरिभाषित हो जाएगा , जो करने के लिए coalesced किया जाएगा $false, इसलिए के $mरूप में शुरू होगा $true। $mएक ऐसा गुणक होने का इरादा है जो हमेशा से है 0या 1इसका बाद में उपयोग किया जाएगा। $mयहां मूल्यांकन किया जाना चाहिए क्योंकि हम चाहते हैं कि यह अंतिम चलना के $bमूल्य पर आधारित हो ।
2. $b(इंडेक्स पैरामीटर) के साथ -orएक पुनरावृत्त की तुलना करने का परिणाम स्वयं निर्धारित होता है । इसका मतलब यह है कि एक बार जब हम उस तत्व पर सेट हो जाएंगे जो कि बढ़ाना है। इसके अतिरिक्त, यह प्रत्येक बाद के पुनरावृत्ति में होगा क्योंकि सशर्त 'अपने वर्तमान मूल्य के साथ है।$i$args[1]$b$true$true-or
3. $bको यूरीरी +( $false=> 0, $true=> 1) का उपयोग करके एक संख्या में परिवर्तित किया जाता है , फिर वर्तमान संस्करण तत्व में जोड़ा जाता है $_जो कि एक है [string], लेकिन पावरशेल हमेशा बाईं तरफ के प्रकार पर दायीं ओर तर्क को समेटने की कोशिश करता है, इसलिए अंकगणितीय प्रदर्शन किया जाएगा। स्ट्रिंग संघनन नहीं। फिर इस मूल्य से गुणा किया जाएगा $m, जो कि अभी भी है, [bool]लेकिन इसका अनुमान लगाया जाएगा।
परिणामस्वरूप सरणी के साथ फिर से जुड़ें .।

तो, पहला पुनरावृत्ति जहां $bबन जाता है $true, मूल्यांकन $bकिया गया था, $falseजब समान होगा, जो गुणक को बनाए रखेगा ।$m$m$true1

उस दौरान रन $bबन जाता है $trueऔर संस्करण तत्व (के रूप में 1) में जोड़ दिया जाता है , जिससे इसमें वृद्धि होती है, और चूंकि गुणक अभी भी है 1, इसलिए यह अंतिम परिणाम होगा।

तो अगले पुनरावृत्ति पर, $bपहले से ही होगा $true, $mसमान $falseबनाना, जो गुणक बना देगा 0। चूंकि अब $bहमेशा के लिए होगा $true, गुणक हमेशा रहेगा 0, इसलिए लौटाया गया प्रत्येक तत्व 0भी होगा ।

— briantist
स्रोत

2

आर, 100 95 92 86 बाइट्स

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

function(v,i)cat((x=scan(t=el(strsplit(v,"\\."))))+c(rep(0,i),1,-x[-(0:i+1)]),sep=".")

— rturnbull
स्रोत

2

05AB1E , 22 बाइट्स

'.¡vy²N‹i0*}²NQi>})'.ý

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

मुझे नहीं पता कि कैसे करना है अगर-और 05AB1E में है, तो यह होने की तुलना में अधिक लंबा है।

— जादू ऑक्टोपस Urn
स्रोत

1

अगर मुझे गलतफहमी नहीं है, तो मुझे नहीं लगता कि यह काम करता है। सवाल कहता है कि आपको मामूली संस्करणों को 0-आउट 1.0.0.0.3, 3करना है , इसलिए उत्पादन 1.0.0.1.0नहीं करना चाहिए 1.0.0.1.3।

— लैंबडाबेटा

@LambdaBeta गलत, निश्चित।

— मैजिक ऑक्टोपस Urn

2

कॉफी-स्क्रिप्ट: 77 67 बाइट्स

f=(p,i)->((z<i&&v||z==i&&~~v+1||0)for v,z in p.split '.').join '.'

यहाँ प्रारंभ करें बीटा रिलीज के लिए केक और कॉफी का समय।

@Ven और @Cyoce की बदौलत मैंने 10 बाइट शेव की!

— भगवान रटे
स्रोत

अच्छा! यकीन नहीं कि आप यहाँ parseInt की जरूरत है?

— शुक्र

Btw आप (यानी parenless कॉल का उपयोग करके दो बाइट्स बचा सकता है .join '.'या .split '.')

— Ven

+इसके बजाय का उपयोग करें parseInt( ~~यदि आपको इसे पूर्णांक में डालने की आवश्यकता है तो उपयोग करें )

— Cyoce

2

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

lambda v,c:'.'.join((str((int(x)+1)*(i==c)),x)[i<c]for i,x in enumerate(v.split('.')))

चीजों को प्राप्त करने का बहुत भोला तरीका

संपादित करें: @kade का उल्लेख करके सशर्त को फिर से लिखा

— Jeffrey04
स्रोत

2

PHP, 81 बाइट्स

बहुत देर तक। कम से कम: हाथी का बच्चा अभी भी अजगर को पीट रहा है।

foreach(explode(".",$argv[1])as$i=>$v)echo"."[!$i],($i<=$n=$argv[2])*$v+($i==$n);

छोरों डॉट्स द्वारा पहला तर्क विभाजन के माध्यम से: "."[!$i]पहले और हर दूसरे तत्व के लिए एक बिंदु के लिए खाली है; ($i<=$n)और ($i==$n)संक्षेप में पूर्णांक 0या 1पूर्णांक अंकगणित के लिए डाले जाते हैं ।

— टाइटस
स्रोत

2

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

(s,x)=>s.split`.`.map((j,i)=>i==x?+j+1:i>x?0:j).join`.`

उदाहरण:

n=(s,x)=>s.split`.`.map((j,i)=>i==x?+j+1:i>x?0:j).join`.`

console.log(n('1.0.3', 0))
console.log(n('1.2.3.4.5', 2))
console.log(n('10.0', 0))
console.log(n('3', 0))
console.log(n('1', 7))

स्निपेट का विस्तार करें

सर्वोत्तम जेएस कार्यान्वयन नहीं है लेकिन यह काफी सरल है और उस तर्क का अनुसरण करता है जिसकी आपको अपेक्षा थी।

— फ्लोरी
स्रोत

ठीक है, यह बहुत स्पष्ट नहीं था, धन्यवाद।

— फ्लोरी डे

1

पायथ - 21 बाइट्स

j\.++<Kcz\.Qhs@KQmZ>K

परीक्षण सूट

— Maltysen
स्रोत

3

नहीं, यह बिल्कुल सही नहीं है। आपका 10.0परीक्षण मामला देता है 11.0.0, यह एक बहुत अधिक हिस्सा है!

— Ven

1

पॉवर्सशेल, 80 100 95 92 बाइट्स

के लिए एक का उपयोग करके 5 बाइट्स सहेजे गए -1..if

के !$bबजाय का उपयोग करके 3 बाइट्स बचाता है$b-eq0

filter x($a,$b){[int[]]$y=$a.Split('.');-1..((-$b,-1)[!$b])|%{$y[$_]=0};$y[$b]++;$y-join'.'}

स्पष्टीकरण:

filter x($a,$b){
    [int[]]$y=$a.Split('.') #Split input into integer array
    $y[$b]++ #Increment 'major' version no. ($b) by one
    -1..((-$b,-1)[!$b])|%{$y[$_]=0} #Set all trailing numbers to 0, now also checks for $b=0 cases.
    $y-join'.' #Join back into '.' seperated Array
}

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

x "1.0.3" 0
x "1.2.3.4.5" 2
x "10.0" 0
x "1" 7
2.0.0
1.2.4.0.0
11.0
Index was outside the bounds of the array.

— colsw
स्रोत

अच्छा! मुझे यहां अधिक शक्तियां देखना बहुत पसंद है।

— रिश्वतखोर

@briantist ईमानदारी से C # का एक हल्का अनलिमिटेड वर्जन है जो हर चीज के साथ इंटरफेस कर सकता है, एक गॉडसेंड है, मैं काम के दौरान बहुत सारे Microsoft सामानों से निपटता हूं और बिल्कुल प्यार करता हूं।

— colsw

ओह बिल्कुल; PowerShell मेरा जाम है, लेकिन बहुत से लोग इसे गोल्फ के लिए उपयोग करने के लिए नहीं सोचते हैं। इसमें कुछ विशेषताएं हैं जो गोल्फ के लिए महान हैं, और अन्य जो इसे गोल्फ के लिए चूसते हैं, लेकिन कुल मिलाकर यह एक ठोस विकल्प है! मैं अपने अगले PSUG में PowerShell में गोल्फ के बारे में एक प्रस्तुति करने के विचार के साथ कर रहा हूँ।

— रिश्वतखोर

@briantist डिफ़ॉल्ट उपनाम सुंदर हैं, लेकिन मैं कुछ सामान्य आदेशों के पूर्व-निर्धारित सेट का उपयोग करने में सक्षम होना पसंद करूंगा, जैसे कि गोल्फिंग के लिए एकल चार एलियरेस च rइसके बजायrandom

— Colsw

अजीब बात है random, यह एक उपनाम नहीं है! यह PowerShell के कमांड मूल्यांकन का परिणाम है। जैसा कि यह उपनाम, फ़ंक्शंस, cmdlets, मूल अनुप्रयोगों, आदि में एक कमांड को खोजने के लिए लगता है, बहुत आखिरी चीज जो यह करने की कोशिश करती है Get-वह जो कुछ भी है, उसके लिए पूर्व-निर्धारित है। तो आप वास्तव में बुला रहे हैं Get-Random, लेकिन तकनीकी रूप से एक उपनाम के रूप में नहीं। आप चलाकर इस काम कर देख सकते हैं service, या childitem, या अधिकतम विडंबना के लिए, alias।

— रिश्वतखोर

1

उद्देश्य-सी 531 बाइट्स

#import<Foundation/Foundation.h>
int main(int argc,const char *argv[]){@autoreleasepool{NSString *s=[NSString stringWithUTF8String:argv[1]];NSInteger n=strtol(argv[2],NULL,0);NSArray *c=[s componentsSeparatedByString:@"."];if(c.count<=n)NSLog(@"ERROR");else{int i=0;NSMutableString *v=[[NSMutableString alloc]init];for(;i<n;++i)[v appendFormat:@"%@.",[c objectAtIndex:i]];[v appendFormat:@"%li", strtol(((NSString *)[c objectAtIndex:i++]).UTF8String,NULL,0)+1l];for(;i<c.count;++i)[v appendString:@".0"];NSLog(@"%@",v);}}return 0;}

संकलन:

clang -fobjc-arc -Os main.m -o main

उपयोग:

./main 1.2.3 1

— झींगंग एक
स्रोत

CodeGolf में आपका स्वागत है। शीर्षक में, आपको स्रोत कोड का आकार बताना चाहिए, न कि बाइट कोड। और स्रोत, ज़ाहिर है, जितना संभव हो उतना छोटा होना चाहिए (कोई अनावश्यक व्हाट्सएप, एकल चरित्र चर नाम आदि)। शुभ लाभ।

— टाइटस

संभवतः मुख्य के अंत में 0इसके बजाय उपयोग कर सकते हैं NULLऔर निकाल सकते हैं return 0;। NSString *sशायद अंतरिक्ष को हटा दिया जाए। **argv1 बाइट से छोटा है *argv[]। @autoreleasepool{}शायद अनावश्यक है।

— शुक्र

1

जावास्क्रिप्ट ईएस 6: 60 बाइट्स

n.split(".").map((n,r)=>{return r>i?n=0:n}).join("."),n[i]++}

— जैक
स्रोत

2

PPCG में आपका स्वागत है! यह मान्य नहीं लगता है, क्योंकि यह किसी भी तरह से इनपुट नहीं लेता है, और }अंत में एक अतिरिक्त है । गोल्फ पर: तीर कार्यों की विशेषताओं में से एक, अंतर्निहित वापसी है, इसलिए आप की जगह ले सकता (n,r)=>{return r>i?n=0:n}से (n,r)=>r>i?n=0:nकुछ बाइट्स को बचाने के लिए।

— ETHproductions

1

आर, 75 बाइट्स

f=function(a,b){n=scan(t=a,se=".");m=-n;m[b]=1;m[1:b-1]=0;cat(n+m,sep=".")}

इंडेक्सिंग 1-आधारित है। आप इसके साथ यहां ऑनलाइन खेल सकते हैं ।

— plannapus
स्रोत

1

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

आवश्यकता है ⎕IO←0( I ndex O rigin 0), जो कई प्रणालियों पर डिफ़ॉल्ट है। पूर्ण कार्यक्रम निकाय; पाठ इनपुट (संस्करण) और फिर संख्यात्मक इनपुट (सूचकांक) के लिए संकेत।

' '⎕R'.'⍕⎕(⊢∘≢↑↑,1+⊃)⊃⌽'.'⎕VFI⍞

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

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

'.'⎕VFI V erify और F ix I क्षेत्र विभाजक (फ़ील्ड की वैधता, फ़ील्ड के मान) के रूप में अवधि का उपयोग करते हुए

⌽ रिवर्स (मूल्यों को सामने रखने के लिए)

⊃ पहले उठाओ (मान)

⎕(... ) निम्न तर्क फ़ंक्शन को उस पर लागू करें, मूल्यांकन किए गए इनपुट को बाएं तर्क के रूप में उपयोग करते हुए:

_{प्रत्येक फ़ंक्शन एप्लिकेशन के गैर-टैसिट समकक्षों को समझाने के लिए अब हम ⍺बाएं तर्क (सूचकांक) ⍵को इंगित करने के लिए और सही तर्क (मूल रूप से इनपुट किए गए वर्तमान संस्करण संख्या की व्यक्तिगत संख्या की सूची ) को इंगित करने के लिए उपयोग करेंगे ।}

⊃से एक तत्व लेने के लिए (⍺⊃⍵) उपयोग ⍺करने के लिए बराबर ⍵

1+ उसमें एक जोड़ें

↑, से लिए गए (⍺↑⍵), प्रीपेंड ⍺संख्या के बराबर ⍵

⊢∘≢↑यदि आवश्यक हो तो शून्य से पैडिंग के रूप में उस से कई संख्याओं के बराबर, (⍺⊢∘≢⍵)↑ बराबर (≢⍵)↑हैं⍵

⍕ प्रारूप (प्रत्येक संख्या के बीच एक स्थान के साथ कठोर)

' '⎕R'.' PCRE आर अवधि के साथ रिक्त स्थान ग्रहण करता है

— एडम
स्रोत

1

जावा 8, 130 बाइट्स

s->n->{String r="",a[]=s.split("\\.");for(int l=a.length,i=-1;++i<l;)r+=(i>n?0:new Long(a[i])+(i<n?0:1))+(i<l-1?".":"");return r;}

स्पष्टीकरण:

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

s->n->{                 // Method with String and Integer parameters and String return-type
  String r="",          //  Result-String
  a[]=s.split("\\.");   //  String-array split by the dots
  for(int l=a.length,   //  Length of the array
      i=-1;++i<l;)      //  Loop from 0 to `l` (exclusive)
    r+=                 //   Append the result-String with:
       (i>n?            //    If index `i` is beyond input `n`:
        0               //     Append a zero
       :                //    Else:
        new Long(a[i])  //     Convert the current String to a number
        +(i<n?          //     If index `i` is before input `n`
           0            //      Leave the number the same by adding 0
          :             //     Else:
           1))          //      Add 1 to raise the version at index `n`
       +(i<l-1?         //    If we've haven't reached the last iteration yet:
          "."           //     Append a dot
         :              //    Else:
          ""            //     Append nothing
   );                   //  End of loop
   return r;            //  Return the result-String
}                       // End of method

— केविन क्रूज़सेन
स्रोत

1

लाइवस्क्रिप्ट, 53 52 बाइट्स

->(for e,i in it/\.
 [+e+1;0;e][(i>&1)+2*(i<&1)])*\.

-1 बाइट @ ASCII-only को धन्यवाद!

पुरानी व्याख्या:

(a,b)->x=a/\.;x[b]++;(x[to b] ++ [0]*(x.length-1-b))*\.
(a,b)->                                                 # a function taking a and b (version and index)
       x=a/\.;                                          # split a on dot, store in x
              x[b]++;                                   # increment at the given index
                     (x[to b]                           # slice be from 0 to the index
                              ++                        # concat (both spaces are necessary so it's not interpreted as an increment operator
                                 [0]*(x.length-1-b))    # with enough zeros to fill the array back to its original size (x's size)
                                                    *\. # join on dot

एक और स्व-उत्तर ... ऐसा नहीं है कि किसी को भी लाइवस्क्रिप्ट में गोल्फ। : पी

मैं दूसरे संस्करण पर काम कर रहा था:

(a,b)->(a/\.=>..[b]++;..[b to *]=0)*\.

लेकिन *एक स्पाइसलिंग इंडेक्स में पहचाने जाने के लिए बहुत अधिक भार है, इस प्रकार =0उपयोग करने का प्रयास करेंगे 0[0]। इसलिए आपको कुछ लिखने की जरूरत है ..[b to ..length- b]=[0]*(..length-1-b)और यह अंत में लंबा है।

— Ven
स्रोत

1

दुख f=(a,b)->(for e,i in a/\.<newline> if i<b then e else if i>b then 0 else+e+1)*\.की बात यह है कि रास्ता लंबा है :(

— ASCII- केवल

@ ASCII- केवल मुझे लगता है कि उन पंक्तियों के साथ if i<b then e else if i>b then 0 else+e+1यानी [+e+1;0;e;e][i>b+(2*i<b)]कुछ और में संपीड़ित करना संभव है , यहां तक कि([+e;-1][i>b+(2*i<b)]||e-1)+1

— वेन

(a,b)->(for e,i in a/\.<newline> [+e+1;0;e][(i>b)+2*(i<b)])*\., 54

— एएससीआईआई-केवल

फिर चलो हस्ताक्षर हटाएं: ->(for e,i in it/\.<newline> [+e+1;0;e][(i>&1)+2*(i<&1)])*\.52 के लिए

— वें

btw आप ;अंतरिक्ष के साथ बदल सकते हैं । यह भी ... ऐसा लगता है कि मूल रूप से यह नीचे के रूप में दूर के रूप में इस दृष्टिकोण के साथ जाना होगा

— ASCII- केवल

1

हास्केल , 136 129 बाइट्स

import Data.List.Split
import Data.List
f s n|(x,z:y)<-splitAt n(splitOn "."s)=intercalate "."(x++[show$read z+1]++map(\_->"0")y)

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

मूल

— कीड़े
स्रोत

128

— एएससीआईआई-केवल

कृपया मुझे छोड़ दें!

कार्य

जाप, 16 11 बाइट्स

अपुष्ट और व्याख्या

विम 20 25 बाइट्स

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

टेस्ट स्निपेट

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

पर्ल, 40 37 34 + 1 = 35 बाइट्स

कोड का टूटना

जेली , 19 17 बाइट्स

कैसे?

MATLAB, 85 बाइट्स

सी # 116 104 बाइट्स

व्याख्या

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

वी 14 20 बाइट्स

बैच, 119 बाइट्स

पर्ल 6, 67 बाइट्स, 0-अनुक्रमित

पावरशेल 3+, 75 74 बाइट्स

Ungolfed

व्याख्या

आर, 100 95 92 86 बाइट्स

05AB1E , 22 बाइट्स

कॉफी-स्क्रिप्ट: 77 67 बाइट्स

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

PHP, 81 बाइट्स

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

पायथ - 21 बाइट्स

पॉवर्सशेल, 80 100 95 92 बाइट्स

जावास्क्रिप्ट ईएस 6: 60 बाइट्स

आर, 75 बाइट्स

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

जावा 8, 130 बाइट्स

लाइवस्क्रिप्ट, 53 52 बाइट्स

हास्केल , 136 129 बाइट्स