काम

यह एक सरल चुनौती है। आपका इनपुट एक एकल गैर-रिक्त स्ट्रिंग है, जिसमें केवल अंक 0123456789और हैश शामिल हैं #। इसमें अंकों का एक रन होगा, जो एक नॉनवेजेटिव पूर्णांक को एन्कोड करता है और स्ट्रिंग के अंत में और कम से कम एक के आसपास लपेट सकता है #। पूर्णांक में अग्रणी शून्य हो सकते हैं। उदाहरण के लिए, ##44##, 013####और 23###1मान्य इनपुट हैं, जबकि ###, 0099और #4#4नहीं कर रहे हैं।

आपका कार्य nस्ट्रिंग से पूर्णांक निकालना है , और स्ट्रिंग घुमाए गए nचरणों को दाईं ओर आउटपुट करना है ।

उदाहरण

इनपुट #1##को दाईं ओर 1 कदम घुमाया जाना चाहिए, इसलिए सही आउटपुट है ##1#।
इनपुट #026###को दाईं ओर 26 चरणों को घुमाया जाना चाहिए, क्योंकि अग्रणी 0 को अनदेखा किया गया है। सही आउटपुट है 26####0।
इनपुट 1####2में अंत में लिपटे पूर्णांक 21 होते हैं, इसलिए इसे दाईं ओर 21 कदम घुमाया जाना चाहिए। सही आउटपुट है ##21##।

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

आप मान सकते हैं कि संख्या आपकी भाषा nके मानक intप्रकार में फिट होती है । इसके विपरीत, यदि वह मानक intप्रकार मनमाना-सटीक पूर्णांक लागू करता है, तो आपको (सिद्धांत रूप में) एक मनमाने ढंग से बड़े का समर्थन करना चाहिए n।

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

#1## -> ##1#
##4## -> #4###
1####1 -> ####11
1####2 -> ##21##
#026### -> 26####0
#000### -> #000###
###82399 -> ##82399#
51379#97 -> #9751379
#98##### -> ###98###
#######4## -> #4########
60752#1183 -> 8360752#11
####99366800## -> 366800######99
########9##### -> ###9##########
91#####515694837 -> 1#####5156948379
###6114558###### -> #6114558########
######219088736090042#### -> 9088736090042##########21
#46055080150577874656291186550000138168########### -> 0138168############4605508015057787465629118655000
568375993099127531613012513406622393034741346840434468680494753262730615610086255892915828812820699971764142551702608639695081452206500085233149468399533981039485419872101852######################3680 -> 99533981039485419872101852######################36805683759930991275316130125134066223930347413468404344686804947532627306156100862558929158288128206999717641425517026086396950814522065000852331494683

code-golf string parsing

— Zgarb
स्रोत

7

क्या हमें सभी परीक्षण मामलों का समर्थन करना है? उन संख्याओं में से कुछ बहुत बड़ी हैं ... क्या 8-बिट पूर्णांक वाली भाषा का उपयोग करना स्वीकार्य होगा?

— डेनिस

@ डेनिस वास्तव में पूर्णांक को मेमोरी में लोड किए बिना मॉड्यूलर अंकगणित के साथ चुनौती को हल करना संभव है ... लेकिन आप सही हैं, यह कई भाषाओं में परेशानी है। मान लें कि आपको केवल उन परीक्षण मामलों को संभालने की आवश्यकता है जो आपकी भाषा nके मूल intप्रकार (जो कि मनमाना-सटीक हो सकता है) में फिट बैठता है । मैं बाद में चुनौती पाठ को अपडेट करूंगा।

— ज़गारब

इनपुट = होने पर हमें क्या करना चाहिए 1234?

— कैलक्यूलेटर

2

@CatsAreFluffy "और कम से कम एक #"

— FryAmTheEggman

10

सीजेएम, 11 बाइट्स

q_'#%W%sim>

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

ध्यान दें कि यह पिछले दो परीक्षण मामलों के लिए काम नहीं करेगा, क्योंकि शामिल संख्या 64 बिट्स में फिट नहीं होती है।

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

q_          e# Read all input and push it twice.
  '#%       e# Split at runs of '#'.
     W%     e# Reverse the resulting array.
       si   e# Cast to string, then to int.
         m> e# Rotate the original input that many places to the right.

— डेनिस
स्रोत

ऊह ... इतना आसान!

— लुइस मेंडो

7

जूलिया, 71 65 बाइट्स

s->join(circshift([s...],maximum(parse,split(s*s,"#",keep=1<0))))

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

हम स्वयं इनपुट को जोड़ते हैं, इसे #विभाजक के रूप में एक सरणी में विभाजित करते हैं , प्रत्येक पूर्णांक को पार्स करते हैं, और अधिकतम लेते हैं। यह स्ट्रिंग को दाईं ओर शिफ्ट करने की संख्या को परिभाषित करता है। हम स्ट्रिंग को एक Charऐरे, शिफ्ट में विभाजित करते हैं , और joinयह वापस एक साथ होता है।

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

7

पायथन, 66 बाइट्स

lambda l:(2*l)[-int(''.join(l.split('#')[::-1]))%len(l):][:len(l)]

— लिन
स्रोत

5

रेटिना, 65 57 49

(\ घ *) # * (\ d +)
$ 2 $ 1 $ 0
^ \ D +
$ *
+ `1 (। *) (।)
 $ 2 $ 1
<अंतरिक्ष>

मार्टिन को धन्यवाद दिया 8 बाइट्स बचाए!

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

ध्यान दें कि यह बहुत बड़े परीक्षण मामलों के लिए स्मृति से बाहर / बाहर चला जाएगा, और अधिकांश साने मशीनों पर, कुछ बड़े लोगों के लिए।

यह स्ट्रिंग में अंतिम संख्या और स्ट्रिंग में पहली या कोई संख्या लेता है और उन्हें स्ट्रिंग के सामने रखता है। फिर यह उस संयुक्त संख्या को यूनरी में रूपांतरित करता है और बार-बार एक अंक को छोड़ते हुए घूमता है।

— FryAmTheEggman
स्रोत

3

जेली, 12 10 बाइट्स

ẋ2~ṣ0‘ḌṂṙ@

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

पृष्ठभूमि

कहो इनपुट है 51379#97।

दो बार स्ट्रिंग को दोहराकर ( 51379#9751379#97), हम यह सुनिश्चित कर सकते हैं कि इसमें संख्या का एक सन्निहित प्रतिनिधित्व होगा।

अगला, हम सभी वर्णों पर बिटवाइज़ लागू नहीं करते हैं। यह इंट कास्ट करने का प्रयास करता है, इसलिए '1' का मूल्यांकन 1 तक हो जाता है , फिर ~ 1 = -2 पर मैप किया जाता है । विफलता ( #) पर, यह 0 देता है ।

हमारे उदाहरण के लिए, यह देता है

[-6, -2, -4, -8, -10, 0, -10, -8, -6, -2, -4, -8, -10, 0, -10, -8]

अगला, हम उस हिस्से को अलग करने के लिए शून्य पर विभाजित होते हैं जो बाकी से संख्या को एन्कोड करता है।

[[-6, -2, -4, -8, -10], [-10, -8, -6, -2, -4, -8, -10], [-10, -8]]

बिटवाइज़ नहीं नक्शे n करने के लिए -n - 1 , ताकि हम एक बढ़ाने के प्राप्त करने के लिए -n ।

[[-5, -1, -3, -7, -9], [-9, -7, -5, -1, -3, -7, -9], [-9, -7]]

अगला, हम प्रत्येक सूची को आधार 10 से पूर्णांक में परिवर्तित करते हैं।

[-51379, -9751379, -97]

सबसे कम संख्या उस नकारात्मक की है जिसे हम खोज रहे हैं। चूंकि जेली सूची रोटेशन परमाणु बाईं ओरṙ घूमती है , यह दाईं ओर घूमने के लिए -1 से गुणा करने से बचती है ।

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

ẋ2~ṣ0‘ḌṂṙ@  Main link. Input: S (string)

ẋ2          Repeat the string twice.
  ~         Apply bitwise NOT to all characters.
            This maps 'n' to ~n = -(n+1) and '# to 0.
   ṣ0       Split at occurrences of zeroes.
     ‘      Increment all single-digit numbers.
      Ḍ     Convert each list from base 10 to integer.
       Ṃ    Take the minimum.
        ṙ@  Rotate S that many places to the left.

— डेनिस
स्रोत

3

MATL , 28 25 17 16 बाइट्स

!G1Y4XXPZcXvUYS!

8 बाइट्स डेनिस के सरणी को विभाजित करने और टुकड़ों के क्रम को उलटने के विचार से कम उधार लेते हैं

दो अंतिम परीक्षण मामले काम नहीं करते क्योंकि संख्या बहुत बड़ी है।

EDIT (20 मई, 2016) लिंक में कोड भाषा के हालिया परिवर्तनों के कारण, के Xzबजाय उपयोग करता है Xv।

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

!         % take implicit input: string. Transpose into column char array
G         % push input string again
1Y4       % predefined literal '\d' (for regexp)
XX        % match regexp. Gives cell array with 1 or 2 strings
P         % flip that array
ZcXv      % join the strings in that array, without spaces
U         % convert to number
YS        % rotate the transposed input that many times
!         % put back into row form (string). Implicitly display

— लुइस मेंडो
स्रोत

2

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

_{(लेकिन नीचे अतिरिक्त क्रेडिट अनुभाग देखें)}

param($a)$d=[System.collections.arraylist][char[]]$a;for($b=+("$a$a"-split"#"-ne'')[1];$b;$b--){$r=$d[-1];$d.removeAt($d.Count-1);$d.insert(0,$r)}-join$d

PowerShell के पास एक सरणी "शिफ्टिंग" की अवधारणा नहीं है, इसलिए मुझे अपना समाधान रोल करना पड़ा। बड़ी संख्या के लिए एक लंबा समय लगेगा , लेकिन इसे अंततः 32-बिट इंट में फिट होने वाली किसी भी चीज़ को पूरा करना चाहिए।

इनपुट लेता है $a, और [System.Collections.ArrayList] ऑब्जेक्ट के $dरूप में एक नया चर सेट करता है । ऐसा इसलिए किया जाता है, क्योंकि तकनीकी रूप से, PowerShell में सरणियाँ अपरिवर्तनीय हैं _{(अतिरिक्त क्रेडिट में नीचे समझाया गया है)} , और इस प्रकार मनमाने सम्मिलन या निष्कासन का समर्थन नहीं करते हैं, जो स्थानांतरण के लिए आवश्यक है। फिर, हम एक लूप में प्रवेश करते हैं ।for

प्रारंभिक स्थिति एक ऐसी चाल है जो मुझे मिली - अगर हम इनपुट को एक साथ जोड़ते हैं, विभाजित करते हैं #, और खाली कर देते हैं, तो परिणामी सरणी का दूसरा तत्व रैपिंग की परवाह किए बिना, हमारी संख्या के बराबर होगा। जब तक यह शून्य न हो जाए हम इसे सेट करते हैं $bऔर $bहर बार घटाते हैं ।

प्रत्येक पुनरावृत्ति, हम सहायक $rको अंतिम सूची में अंतिम तत्व के रूप में सेट करते हैं, उस अंतिम तत्व को हटाते हैं, और फिर सामने वाले तत्व को सम्मिलित करते हैं ... सरणी को एक तत्व द्वारा सही ढंग से "शिफ्टिंग" करते हैं।

अंत में, हम बस इसके साथ आउटपुट करते हैं -join$dताकि यह एक स्ट्रिंग में समाप्‍त हो जाए।

अतिरिक्त श्रेय

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

संक्षेप में, इसका मतलब कुछ ऐसा है $c=@(1,2,3)और $a,$b=$c
इसमें $a=1एक इंट और $b=@(2,3)एक सरणी होगी।

पॉवरशेल, 90 बाइट्स, दाएं शिफ्ट के बजाय लेफ्ट शिफ्ट करता है

param($a)$b=+("$a$a"-split"#"-ne'')[1];$a=[char[]]$a;for(;$b;$b--){$r,$a=$a;$a+=$r}-join$a

यहां हम एक बार फिर से इनपुट लेते हैं, और $bऊपर के रूप में सेट करते हैं। हम $aचार-सरणी के रूप में फिर से कास्ट करते हैं, और फिर forऊपर के रूप में एक ही लूप दर्ज करते हैं। इस बार, हालांकि, हमें मनमाने ढंग से हटाने / सम्मिलन का समर्थन करने की आवश्यकता नहीं है, इसलिए हमें महंगी [System.Collections.ArrayList]वस्तु का उपयोग करने की आवश्यकता नहीं है , न ही महंगी विधि कॉल का। इसके बजाय हम केवल $rपहले तत्व के रूप में सेट होते हैं $a, और शेष तत्व फिर से सहेजे जाते हैं $a। फिर हम +=इसे अंत तक वापस निपटने के लिए।

(जैसा कि मैंने कहा, PowerShell +=सरणियां तकनीकी रूप से अपरिवर्तनीय हैं, लेकिन यहां ऑपरेटर अतिभारित है - यह एक सरणी और दूसरी वस्तु लेता है, उन्हें एक साथ (तकनीकी शब्द) एक नए सरणी में रखता है, जो रिटर्न करता है और इसे चर नाम के रूप में सहेजता है, और नष्ट कर देता है मूल सरणी। कार्यात्मक रूप से, हमने अभी सरणी के अंत में एक तत्व जोड़ा है, लेकिन तकनीकी रूप से (और एक मेमोरी / कचरा-सफाई के दृष्टिकोण से, आदि) यह एक नया-नया सरणी है। यह स्पष्ट रूप से एक महंगा ऑपरेशन बन सकता है। यदि सरणी बड़ी या जटिल है। फ़्लिपसाइड वह है, चूंकि सरणियाँ अपरिवर्तनीय हैं, उनमें अनुक्रमण करना या उन पर पुनरावृत्ति करना बहुत सस्ता है।)

आउटपुट एक ही क्रिया रहता है, एक -joinस्टेटमेंट के साथ इसे एक स्ट्रिंग में बदल देता है।

— AdmBorkBork
स्रोत

1

गंभीरता से, 21 बाइट्स

,;;+'#@s`≈`MM@#@`/`nΣ

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

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

स्पष्टीकरण:

,;;+'#@s`≈`MM@#@`/`nΣ
,;;+                   make 3 copies of input, and concatenate two of them
    '#@s               split on #s
        `≈`MM          convert strings to ints, take maximum
             @#@       explode final copy of input
                `/`n   rotate to the right n times
                    Σ  join

— मेगो
स्रोत

कॉनकैट और अधिकतम लें: महान विचार!

— लुइस मेंडो

@LuisMendo मैं एलेक्स के जवाब को एक ही रणनीति के साथ पॉप अप करते हुए देख रहा था, जबकि मैं यहाँ स्पष्टीकरण लिख रहा था।

— मेगो

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

— लुइस मेंडो

1

गणितज्ञ, 69 बाइट्स

#~StringRotateRight~ToExpression[""<>Reverse@TextCases[#,"Number"]]&

में संख्याओं के क्रम का पता लगाएं, यदि 2 हैं तो उनके क्रम को उलटने की आवश्यकता है। स्ट्रिंग्स को मिलाएं (यदि यह केवल एक है तो यह केवल संख्या स्ट्रिंग लौटाता है)। स्ट्रिंग को न्यूमेरिक में बदलें और उस स्ट्रिंग को कई बार घुमाएं।

— IPoiler
स्रोत

FromDigitsके बजाय काम करता है ToExpression।

— कैलक्यूलेटरफैनलाइन

1

पायथ, 22 14 बाइट्स

.>zs-.<zxz\#\#

यहाँ कोशिश करो!

व्याख्या

।> zs -। <zxz \ # # # # z = इनपुट

     । <z # रोटेट z बाएँ से
        xz \ # # हैश की पहली घटना का सूचकांक
                  # यह सुनिश्चित करता है कि पूर्णांक अंत के चारों ओर लपेटा नहीं गया है
    - \ # # सभी हैश को फ़िल्टर करें
   s # एक पूर्णांक के लिए डाली, भी अग्रणी शून्य हटाता है
।> z # इनपुट स्ट्रिंग का अंतिम रोशन करें और इसे प्रिंट करें

यह सभी टेस्टकेस के लिए काम करता है और बहुत बड़ी संख्या के लिए भी लगभग तुरंत खत्म हो जाता है।

— Denker
स्रोत

आप क्या कर सकते हैं -...\#के बजाय h:..."\d+"1। इसके अलावा, zचर की सूची में बदलने की कोई जरूरत नहीं है , .>यह भी एक स्ट्रिंग पर काम करता है।

— जकुबे

@Jakube संकेत के लिए धन्यवाद, जब मैंने ऐसा किया तो बहुत थका हुआ था। ^ ^

— डेन्कर

1

जावास्क्रिप्ट (ईएस 6) 66

एक बार के लिए, %नकारात्मक संख्याओं के लिए जावास्क्रिप्ट के बेवकूफ नकारात्मक उपयोगी होते हैं

z=>(z+z).substr(-(l=z.length,[a,b]=z.match(/\d+/g),b?b+a:a)%l-l,l)

— edc65
स्रोत

1

@WashingtonGuedes नहीं, राशि b+aएक समवर्ती संघटन है। a='32',b='1', (b?b+a:a)=='132', (b|0+a)==33

— edc65

1

अजगर, 10 बाइट्स

.>zss_cz\#

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

यह डेनिस के सीजम उत्तर का अनुवाद है । जब से मैं इसके साथ नहीं आया, मैं इसे एक सामुदायिक विकि बना रहा हूँ।

व्याख्या

      cz\#   split input at #
     _       reverse
    s        join
   s         cast to integer
.>z          rotate input right

— Pietu1998 को संशोधित किया
स्रोत

1

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

s=>(l=s.length,s+s).substr(l-s.split(/#+/).reverse().join``%l,l)

डेनिस के सीजम के जवाब का एक और बंदरगाह।

संपादित करें: edc65 के उत्तर के उस भाग को विनियोजित करके 3 बाइट्स सहेजे गए, जिन पर उन्होंने ध्यान नहीं दिया।

— नील
स्रोत

रिवर्स के बजाय एक टर्नरी और एक राशि का उपयोग करना। (शामिल होना), आपको मेरा स्कोर हरा देना चाहिए

— edc65

@Downgoat क्षमा करें, मैंने उन्हें हाल ही में सही पाया है, लेकिन मैंने देर रात एक किया और इसलिए मैं सीधे नहीं सोच रहा था।

— नील

@ edc65 नहीं, इससे मेरा स्कोर और ऊंचा हो गया। इसलिए मैंने s+sइसके बजाय ट्रिक को कॉपी किया । (मैं वास्तव में उस पिछली रात के बारे में सोचता था लेकिन उस समय इसे आज़माने के लिए मैं बहुत थका हुआ था।)

— नील

1

पर्ल 5, 41 बाइट्स

-lFझंडे के लिए 39 बाइट्स प्लस दो ( -M5.01निशुल्क है):perl -lF -M5.01 script.pl

/#+/;map{unshift@F,pop@F}1..$'.$`;say@F

स्पष्टीकरण:

-lFइनपुट पढ़ता है, अनुगामी न्यूलाइन निकालता है, शेष को स्ट्रिंग में डालता है $_, इसे वर्णों में विभाजित करता है, और उस विभाजन को सरणी में डालता है @F।
/#+/#s के पहले तार को खोजता है और उसके पहले सामान के बराबर $_सेट करता $`है और $'उसके बाद के सामान के बराबर होता है। यदि $`खाली है तो $'अधिक #एस हो सकते हैं । हालाँकि, $'.$`एक स्ट्रिंग है जिसका आरंभिक विकल्प सरणी को घुमाने के लिए कई बार होता है।
अब हम सूची का निर्माण करते हैं 1..$'.$`, जो $'.$`एक पूर्णांक के रूप में व्यवहार करता है और इस प्रकार इसे संख्यात्मक करता है, जो किसी भी अंतिम #s को स्ट्रिप्स करता है , इसलिए सूची 1सरणी को घुमाने के लिए कई बार होती है।
उस सूची के प्रत्येक तत्व के लिए, हम सरणी ( popअंतिम तत्व और unshiftइसे शुरुआत में) को घुमाते हैं ।
फिर sayघुमाए गए सरणी के सभी तत्व।

— msh210
स्रोत

1

रूबी - 68 72 70 बाइट्स

s=ARGV[0]
p s.split(//).rotate(-(s+s).scan(/\d+/).map(&:to_i).max)*""

split एक सरणी में स्ट्रिंग धर्मान्तरित
(s+s).scan(/\d+/) स्ट्रिंग को अपने आप में बदलना और संख्याओं की एक सरणी प्राप्त करना (स्ट्रिंग के रूप में)
map(&:to_i) किलों को स्ट्रिंग में बदलें
max सबसे बड़ा int चुनें
rotate max बार
*""सरणी को वापस स्ट्रिंग में बदलें (आशुलिपि के लिए join)

उपयोग: ruby scriptname.rb "[string]"

— FuzzyTree
स्रोत

मैं यहाँ नया हूँ। विभिन्न भाषाओं में कई उत्तर पोस्ट करने पर शिष्टाचार क्या है? मैंने गलत होने पर एक अलग उत्तर दिया। यदि कई उत्तर जोड़ना ठीक नहीं है, तो मुझे बताएं और मैं इसे नीचे ले

— जाऊंगा

1

विभिन्न भाषाओं में कई उत्तर ठीक हैं, यहां तक कि प्रोत्साहित किया गया है (बशर्ते कि वे सभी सही हों)।

— जर्बद

0

05AB1E , 14 13 बाइट्स

ठीक है, 100000 से बड़ी संख्या के लिए कोड को समाप्त करने की बहुत संभावना नहीं है, लेकिन यदि आप पर्याप्त धैर्य रखते हैं, तो आउटपुट होगा :)। कोड:

'#¡rJ¹sF¤rS\J

स्पष्टीकरण:

'#¡             # Split the input on '#'
   r            # Reverse the stack
    J           # Join the stack
     ¹          # Take the first input
      s         # Swap with the number
       F        # For N in range(0, number), do...
        ¤       #   Obtain the last character
         r      #   Reverse the stack
          S     #   Split everything to individual characters
           \    #   Delete the last character
            J   #   Join the stack

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

CP-1252 एन्कोडिंग का उपयोग करता है

— अदनान
स्रोत

0

VBSCRIPT, 82 99 BYTES

पिछले कोड ने मामलों को अंत में लिपटे संख्या के साथ हैंडल नहीं किया

b=len(a):f=replace(a,"#","/",1,1):c=replace(split(f&f,"/")(1),"#",d) mod b:d=right(a,c)&left(a,b-c)

UNGOLFED

b=len(a)                                 -a->implicit input, get its length 
f=replace(a,"#","/",1,1)  -replace first instance of # so we can split later
c=replace(split(f&f,"/")(1),"#",d) mod b    -get the number and calc the mod
d=right(a,c)&left(a,b-c)                    -d->implicit output

इस थोड़े बेकार है ... वहाँ शायद यह करने के लिए एक बेहतर तरीका है, यहां तक कि VBscript में भी

— Traceur
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है। यह जवाब आपके गोल्फ कोड के नीचे एक कोड ब्रेकडाउन और स्पष्टीकरण जोड़कर सुधार किया जा सकता है। इसके अलावा, क्या आप प्रोग्राम के बजाय फ़ंक्शन बनाकर बाइट्स बचा सकते हैं, aफ़ंक्शन इनपुट कहां है, और यह आउटपुट देता है? इस तरह, आपको कॉल inputboxऔर msgboxकॉल की आवश्यकता नहीं होगी ।

— wizzwizz4 17

आपको आवश्यकता क्यों है b?

— कैलक्यूलेटर

0

मेथेमेटिका, 73 58 बाइट्स

#~StringRotateRight~Max[FromDigits/@StringSplit[#<>#,"#"]]&

बहुत बाइट। 15 बाइट्स IPoiler के लिए धन्यवाद बचा लिया

— CalculatorFeline
स्रोत

StringRotateRightयहाँ कुछ बाइट्स बचाता है।

— IPoiler

0

मैटलैब (73)

  @(a)regexprep(a,'(\d*)#*(\d*)#*','${circshift($0,[0 str2num([$2 $1])])}')

यह एक अन्य दृष्टिकोण का उपयोग कर रहा है जो मुझे आश्चर्य होता है अगर @luis ने इसका इस्तेमाल किया, क्योंकि उनके विवरण का संदर्भ देते हुए आम (संयुक्त राष्ट्र) में कुछ बिंदु हैं; सौभाग्य से मैं फसली मैटल भाषा को नहीं समझता।

— Abr001am
स्रोत

0

मतलाब (86) 72

 @(n)circshift(n,[0 str2num(circshift(n(n~='#'),[0,-find(n=='#',1)+1]))])

फ़ंक्शन स्ट्रिंग को दो बार, पूर्णांक निष्कर्षण के लिए एक बार, वांछित कार्य के लिए दूसरा टैग करता है, इसमें बहुत अधिक समय नहीं लगता है क्योंकि matlab (Dim)modulus(Length)उस अपवाद को घुमाने के लिए आगे बढ़ता है जो बड़ी श्रेणियों के लिए विभाजन विफलता में गिरता है।
संघर्ष करेंगे कि इसे और अधिक कैसे बढ़ाया जाए ...।

(86)

  @(n)circshift(n,[0 str2num([strtok(n(find(n=='#',1,'last'):end),'#') strtok(n,'#')])])

इस फ़ंक्शन और पिछले के बीच का अंतर, यह एक पूर्णांक के दो दूरवर्ती घटनाओं को पीछे की ओर ले जाता है, जबकि पहला इसे घुमाता है।

— Abr001am
स्रोत

पता लगाएँ और घुमाएँ

काम

उदाहरण

नियम और स्कोरिंग

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

सीजेएम, 11 बाइट्स

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

जूलिया, 71 65 बाइट्स

पायथन, 66 बाइट्स

रेटिना, 65 57 49

जेली, 12 10 बाइट्स

पृष्ठभूमि

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

MATL , 28 25 17 16 बाइट्स

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

अतिरिक्त श्रेय

पॉवरशेल, 90 बाइट्स, दाएं शिफ्ट के बजाय लेफ्ट शिफ्ट करता है

गंभीरता से, 21 बाइट्स

गणितज्ञ, 69 बाइट्स

पायथ, 22 14 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6) 66

अजगर, 10 बाइट्स

व्याख्या

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

पर्ल 5, 41 बाइट्स

रूबी - 68 72 70 बाइट्स

05AB1E , 14 13 बाइट्स

मेथेमेटिका, 73 58 बाइट्स

मैटलैब (73)

मतलाब (86) 72

(86)