स्ट्रिंग के भीतर संख्याओं का जोड़-घटाव

14

एक स्ट्रिंग को इनपुट के रूप में लें, और स्ट्रिंग में सभी अंकों के जोड़ / घटाव को करें और परिणाम के रूप में उन ऑपरेशनों के योग को आउटपुट करें।

नियम

  • स्ट्रिंग के अंक बाएं से दाएं पढ़े जाते हैं
  • यदि कोई अंक (n) विषम है, तो अगले अंक (n + n1) के साथ अतिरिक्त प्रदर्शन करें
  • यदि एक अंक (n) सम है, तो अगले अंक (n - n1) के साथ घटाव करें
  • यदि आप स्ट्रिंग में अंतिम अंक पर पहुंच गए हैं, तो स्ट्रिंग में पहले अंक के साथ ऑपरेशन करें
  • आउटपुट सभी परिणामी मूल्यों का योग होगा
  • यदि स्ट्रिंग में केवल एक अंक है, तो ऑपरेशन को स्वयं (n + n या nn) के साथ करें
  • यदि स्ट्रिंग में कोई अंक नहीं हैं, तो आउटपुट 0 है

उदाहरण

Input: r5e6o9mm!/3708dvc    
Process: (5+6) + (6-9) + (9+3) + (3+7) + (7+0) + (0-8) + (8-5)
Output: 32

टिप्पणियाँ

  • या तो फ़ंक्शन या पूर्ण कार्यक्रम स्वीकार किया जाता है
  • अधिकतम इनपुट लंबाई एक स्ट्रिंग इनपुट के लिए आपकी भाषा की सीमा पर निर्भर करेगी
  • चरित्र इनपुट पर कोई प्रतिबंध नहीं है, लेकिन केवल आधा-चौड़ाई अंक आउटपुट की ओर गिना जाता है
  • सबसे कम बाइट्स जीतता है
code-golf  string 
— Noir Antares
स्रोत
4
कुछ और उदाहरण भी अच्छे होंगे
— dylnan
2
मैं एक विषम अंक के साथ समाप्त होने वाले एक परीक्षण मामले को जोड़ना चाहता हूं।
— अरनुलद
3
सुझाए गए testcase: "", "0","1"
— TSH
1
क्या हम एक स्ट्रिंग के बजाय वर्णों के एक सरणी के रूप में इनपुट ले सकते हैं? (जूलिया उन दोनों के बीच अंतर करता है।)
— सूंदर - मोनिका
4
@sundar वर्तमान आम सहमति यह है कि एक स्ट्रिंग को वर्णों के अनुक्रम के रूप में परिभाषित किया गया है। मेरी समझ यह है कि वर्णों के सरणियों को डिफ़ॉल्ट रूप से अनुमति दी जाती है, भले ही आपकी भाषा में एक मूल स्ट्रिंग प्रकार हो।
— अरनुलद

जवाबों:

6

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

fØDV€ḂT‘ịƲSḤ

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

परीक्षण मामलों की कोशिश करो।

कार्यक्रम केवल अंकों को रखता है जो एक विषम अंक का अनुसरण करते हैं और फिर दो बार योग की गणना करते हैं।

fØDV€ḂT‘ịƲSḤ   
f                   Remove anything that isn't...
 ØD                 a digit.
   V€               Cast each digit to an integer
         Ʋ          Monad:
     Ḃ              Parity of each digit.
      T             Indices of truthy elements (odd digits).
       ‘            Increment.
        ị           Index into list of digits.
                    Wraps to beginning and if there are no digits this returns 0.
          S         Sum.
           Ḥ        Double.
— dylnan
स्रोत
3

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

समाधान:

{+/(1_x,*x)*2*2!x^:(x-:48)^!10}

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

स्पष्टीकरण:

स्ट्रिंग से सब कुछ निकालें जो संख्या नहीं है (जबकि परिवर्तित भी हो रही है), modulo 2, 2 से गुणा करें, x से 1 से गुणा करें और योग करें।

{+/(1_x,*x)*2*2!x^:(x-:48)^!10} / solution
{                             } / lambda taking implicit x
                           !10  / range 0..10
                          ^     / except
                   (     )      / do this together
                    x-:48       / subtract 48 from x (type fudging char ascii value -> ints), save back into x
                x^:             / x except right, and save back to x
              2!                / modulo 2
            2*                  / multiply by 2
           *                    / multiply by
   (      )                     / do this together
        *x                      / first element of x
       ,                        / append to
      x                         / x
    1_                          / drop first (ie rotate everything by 1)
 +/                             / sum, add (+) over (/)

Naive solution:

स्ट्रिंग से सब कुछ निकालें जो एक नंबर नहीं है (जबकि परिवर्तित भी हो रहा है), 2-आइटम स्लाइडिंग विंडो लें, यह पता करें कि क्या वे विषम हैं या यहां तक ​​कि, उपयुक्त के रूप में जोड़ / घटाना लागू करें, फिर योग करें।

{+/((-;+)2!x).'2':(1+#x)#x^:(x-:48)^!10}

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

टिप्पणियाँ:

  • इनपुट को छानने के एक होशियार तरीके के कारण -4 बाइट्स @ धन्यवाद का धन्यवाद
  • -3 बाइट्स रेज़ैप के बजाय स्लाइडिंग विंडो का उपयोग करके
  • -9 बाइट्स ngn के समाधान को पोर्ट करना (गैर-भोले दृष्टिकोण)
— streetster
स्रोत
1
x:48!x@&x in,/$!10->x^:(x-:48)^!10
— ngn
मैंने q / kdb + में समाधान लिखा था, फिर oK पर पोर्ट किया गया ... इस से कुछ और बाइट्स निचोड़ने में सक्षम हो सकता है!
— स्ट्रीटस्टर
1
मैंने ngn / k में एक अलग उत्तर पोस्ट किया , वहां से विचारों को लाने के लिए स्वतंत्र महसूस करें। मुझे लगता है कि ओके सबसे छोटा होगा, क्योंकि मेरा पार्सर इस समय बकवास है - यह संशोधित असाइनमेंट को ठीक से पार्स नहीं करता है। वैसे, मुझे ':"स्लाइडिंग विंडो" के रूप में पता नहीं था - दिलचस्प।
— ngn
आप k से भलीभांति परिचित हैं। यदि आपको कभी भी समान विचारधारा वाले लोगों के साथ वेक्टर प्रोग्रामिंग सामान पर चर्चा करने का अनुभव होता है या बस हम बाकी लोगों को बहस करते हुए देखते हैं - हमें यह चैट रूम मिल गया है । अधिकांश नोटबंदी एपीएल के बारे में है, लेकिन के और जे विषय पर भी हैं।
— ngn
2

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

{2*sum rotate($!=.comb(/\d/))Z*(@$! X%2)}

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

डायलन के जेली उत्तर के समान तर्क का उपयोग करता है । यह केवल अंकों को दर्शाता है जो एक विषम संख्या का अनुसरण करते हैं और फिर 2 से गुणा करते हैं।

— मजाक कर रहा है
स्रोत
2

पॉवरशेल, 80 78 76 बाइट्स

($d="$args"-split'\D*'-ne'')+$d[0]|?{$p-match'[13579]';$p=$_}|%{$s+=2*$_};$s

रेटिना समाधान के साथ -2 बाइट्स धन्यवाद नील

-2 बाइट्स AdmBorkBork धन्यवाद

टेस्ट स्क्रिप्ट:

$f = {
($d="$args"-split'\D*'-ne'')+$d[0]|?{$p-match'[13579]';$p=$_}|%{$s+=2*$_};$s
}

&$f 'r5e6o9mm!/3708dvc'

व्याख्या

सबसे पहले: यह 2 * n जोड़ते हैं यदि पिछले अंक विषम है, और 0 यदि एक पिछला अंक सम है।

($d="$args"-split'\D*'-ne'')+ # let $d is array contains digits only, each element is a digit
$d[0]|                        # apend first digit to the end of the array
?{                            # where for each digit
    $p-match'[13579]'         # predicate is 'previous digit is odd' (it is false on the first iteration because $p is null)
    $p=$_                     # let previous digit is current
}|
%{                            # for each digit matched to the predicate
    $s+=2*$_                  # add current digit multiply 2 to $s. 
}
$s                            # return sum

अतिरिक्त, 99 बाइट्स

@Neil से प्रेरित है। केवल पिछले अंक के साथ रेग्ज अंक अंक विषम है। Matchesएक स्वचालित चर है ।

param($d)$d+($d-match'\d')+$Matches[0]|sls '(?<=[13579]\D*)\d'-a|%{$_.Matches.Value|%{$s+=2*$_}};$s
— Mazzy
स्रोत
1
एक बाइट अदला-बदली के |?{$_}लिए बचाएं -ne''और दूसरे $d="$args"-split'\D*'-ne''जैसे परों में घुमाकर ($d="$args"-split'\D*'-ne'')+$d[0]।
— AdmBorkBork
2

MATL , 18 17 बाइट्स

t4Y2m)!Ut1YSof)sE

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

(लुइस मेंडू / ग्यूसेप / दोनों को धन्यवाद!)

स्पष्टीकरण:

     % Implicit input
 t   % duplicate input
     % stack: ['r5e6o9mm!/3708dvc' 'r5e6o9mm!/3708dvc']
 4Y2 % push inbuilt literal, characters '0':'9'
     % stack: ['r5e6o9mm!/3708dvc' 'r5e6o9mm!/3708dvc' '0123456789']
 m)  % extract only characters from input that belong to '0':'9'
     % stack: ['5693708']
 !U  % transpose and convert each value from string to number
     % stack: [5 6 9 3 7 0 8]
 t   % duplicate that
 1YS % circular shift by 1
     % stack: [[5 6 9 3 7 0 8] [8 5 6 9 3 7 0]]
 o   % parity check - 1 for odd, 0 for even
     % stack: [[5 6 9 3 7 0 8] [0 1 0 1 1 1 0]]
 f   % find non-zero value indices in last array
     % stack: [[5 6 9 3 7 0 8] [2 4 5 6]]
 )   % index at those places in the first array
 s   % sum
 E   % multiply by 2
     % (implicit) convert to string and display

मूल विचार यह है कि संख्याओं का अनुसरण करने वाली संख्याओं को अनदेखा किया जा सकता है, जबकि विषम संख्याओं का अनुसरण करने वालों को दोगुना - और अंतिम परिणाम उन दोगुने मूल्यों का योग है।

मुझे नहीं लगता था fके बाद समता जांच oआवश्यक होगा, लेकिन किसी कारण के लिए Matl 0 और 1 का है कि परिणाम से की सरणी नहीं देखता oएक तार्किक सरणी के रूप में, के बजाय उन्हें स्थिति में संख्यात्मक सूचकांक और अनुक्रमित के रूप में लेता है 1और end।

— sundar - मोनिका को बहाल करना
स्रोत
मुझे लगता है कि आप !Uइसके बजाय उपयोग कर सकते हैं 48-। संक्रमण यहां कोई नुकसान नहीं करता है। oके लिए doubleइनपुट बस है mod(...,2), इसलिए उत्पादन होता है double। अच्छा NaNइनपुट ट्रिक! अगर यह STDOUT में बाहरी उत्पादन को हल करने के लिए है, तो डेनिस को एक विचार था और शायद वह जल्द ही ठीक कर देगा
— लुइस मेंडू
!Uइसके बजाय48-
— Giuseppe
@LuisMendo वेल्ड, आप मुझे पंच करने के लिए हरा!
— Giuseppe
@ गिउप्प्पे :
— लुइस
धन्यवाद, संपादित दोनों। @LuisMendo जब oएक तार्किक सरणी आउटपुट देता है - या यह नहीं है? (मुझे स्वीकार करना चाहिए कि मैंने वास्तव में MATLAB के संख्यात्मक प्रकार प्रणाली में कभी नहीं देखा है।) और हाँ, मैंने सोचा NaNकि यह एक अच्छा प्रहरी के लिए बना देगा क्योंकि यह वास्तविक इनपुट कहीं भी होने की संभावना नहीं है, लेकिन यह जानने के लिए अच्छा है कि इसे बहुत लंबे समय तक की आवश्यकता नहीं होगी। !
— सूंदर -
2

के (ngn / k) , 33 बाइट्स

{+/(1_x,*x)*2*2!x:-48+x^x^,/$!10}

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

{ } तर्क के साथ एक समारोह है x

!10 सूची है 0 1 ... 9

$ तार में बदलना

,/ CONCATENATE

x^xबिना किसी अधिकार के मतलब है

x^x^इसका मतलब यह xहै कि जो दाईं ओर है, उसी से जुड़ा हुआ है, यानी केवल अंकों को रखेंx

-48+घटाना 48, जो की ASCII कोड है"0"

x: को आवंटित x

2! mod २

2* 2 से गुणा किया

1_x,*xकी एक बूंद है: xकी पहली के बाद x; यानी xएक कदम से बाईं ओर घुमाया गया

+/ योग

— NGN
स्रोत
2

जाप (v2.0a0), 25 19 बाइट्स

-6 बाइट्स शैगी को धन्यवाद ।

kè\D
íÈ°*2*Y°u}Ué)x

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

यह इस समय कोई अंक के साथ काम करता है! इनपुट पात्रों की एक सूची है।

— LegionMammal978
स्रोत
19 बाइट्स , जिसमें Japt v2 पर स्विच करना शामिल है। xसमारोह में सरणी से खुश नहीं हैं , हालांकि। यदि आपको कोई प्रश्न है तो मुझे चैट में पिंग करें ।
— झबरा
प्रतीक्षा करें, बस ध्यान दिया कि यदि इनपुट में कोई अंक नहीं है तो यह बिल्कुल भी काम नहीं करेगा।
— झबरा
इसके अलावा, जहां v2.0a0, @ शैगी के लिए स्रोत है? मैं इसे रेपो में नहीं ढूंढ सकता।
— लीजियनममाल 978
यह v1 है और यह v2 है।
— झबरा
यदि आपने इसे चैट में मिस कर दिया है, तो मुझे आपके लिए यह 12 बाइट्स मिल गई।
— झबरा
2

05AB1E , 12 9 बाइट्स

डायलेन की समता चाल का उपयोग करके भोले विधि से 1 बाइट बचाता
है । श्री एक्सकोडर के लिए 3 बाइट धन्यवाद

þDÁ€ÉÏSO·

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

व्याख्या

þ              # push only digits of input
 D             # duplicate
  Á            # rotate right
   ۃ          # get the parity of each
     Ï         # keep only true items
      SO       # calculate digit-sum
        ·      # double
— Emigna
स्रोत
हम्म, हैं þÀIþ€ÉÏSO·, þÀDÁ€ÉÏSO·, þÀ¹þ€ÉÏSO·या þÀsþ€ÉÏSO·-2 बाइट्स के लिए सभी प्रकार के परीक्षण पारित?
— मिस्टर एक्सकोडर
@ Mr.Xcoder: आह, हाँ। अच्छा! हम भी कर सकते हैं þDÁ€ÉÏSO·-3 के लिए :)
— Emigna
1

रेटिना , 37 बाइट्स

(\d).*
$&$1
L$`(?<=[13579]\D*).
2**
_

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

(\d).*
$&$1

पहले अंक के एक डुप्लिकेट जोड़ें।

L$`(?<=[13579]\D*).

किसी भी चीज का मिलान करें जिसका पहला पिछला अंक विषम है।

2**

सभी मैचों को एकजुट होकर उन्हें डबल करें। (गैर-अंकों को शून्य माना जाता है।)

_

राशि लीजिए। यदि मैच नहीं होते थे, तो यह आवश्यकतानुसार शून्य पैदा करता है।

रेटिना 0.8.2 में सबसे अच्छा मैं कर सकता था 44 बाइट्स:

[^\d]

(.).*
$&$1
(?<![13579]).

.
$*
.
..
.

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

[^\d]

गैर-अंक हटाएं।

(.).*
$&$1

पहले अंक की एक प्रति संलग्न करें।

(?<![13579]).

वे अंक हटाएं जो एक विषम अंक का पालन नहीं करते हैं।

.
$*

यूनीरी में बदलें।

.
..

उन्हें डबल करें।

.

राशि लीजिए।

— नील
स्रोत
मुझे डर है कि यदि अंतिम अंक विषम नहीं है तो परिणाम गलत होगा
— mazzy
1
@mazzy जब आप अंतिम अंक कहते हैं, तो क्या आप पहले अंक को अंत तक कॉपी करने से पहले या बाद में मतलब रखते हैं?
— नील
'अंत की ओर'। चरण 'पहले अंक का एक डुप्लिकेट जोड़ें' अंत में नकल कर रहा है? ठीक। ठंडा। धन्यवाद
— mazzy
1

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

वर्णों के एक सरणी के रूप में इनपुट लेता है।

s=>s.map(c=>1/c?r+=p*(p=c*2&2,n=n||c,c):0,n=p=r=0)|r+p*n

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

टिप्पणी की गई

s =>                     // given the input array s[]
  s.map(c =>             // for each character c in s[]:
    1 / c ?              //   if c is a digit:
      r +=               //     update r:
        p * (            //       p = either 0 or 2 (always 0 on the 1st iteration)
          p = c * 2 & 2, //       p = 0 if c is even, 2 if c is odd
          n = n || c,    //       if n is still equal to 0 (as an integer), set it to c
          c              //       compute p * c
        )                //     add the result to r
    :                    //   else:
      0,                 //     do nothing
    n = p = r = 0        //   n = first digit, p = previous digit, r = result
  )                      // end of map()
  | r + p * n            // compute the last operation with the 1st digit and add it to r
— Arnauld
स्रोत
1

जावास्क्रिप्ट (Node.js) , 85 84 83 82 बाइट्स

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

s=>(s.match(/\d/g)||[]).reduce((r,n,i,a)=>r+(+n)+a[a[++i]!=null?i:0]*-(1-n%2*2),0)

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

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

— bluefinger
स्रोत
n-0हो सकता है+n
— जूल
PPCG में आपका स्वागत है!
— कॉनर ओ'ब्रायन
1

आर , 58 बाइट्स

function(x,y=strtoi(x[x%in%0:9]))sum(c(y[-1],y[1])*y%%2*2)

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

— digEmAll
स्रोत
67 बाइट्स यदि आप arrayआउटपुट को बुरा नहीं मानते हैं ।
— Giuseppe
1
हम्म वास्तव में आप डॉट उत्पाद का उपयोग खाली सरणी के कारण नहीं कर सकते हैं, xxxइसलिए यह 68 बाइट्स में है ताकि इंडेक्सिंग में परिवर्तन का उपयोग करके aउत्पन्न किया जा सके y।
— Giuseppe
@Giuseppe: संशोधित, धन्यवाद :)
— DigEmAll
@Giuseppe: मैं आपसे आपकी राय पूछता हूं क्योंकि आप एक समझदार कोड-गोल्फर हैं ... टिप्पणियों से ऐसा लगता है कि हम पात्रों के वेक्टर का उपयोग कर सकते हैं, इस मामले में 61 बाइट संभव हैं: इसे ऑनलाइन आज़माएं! तुम क्या सोचते हो ?
— digEmAll
strtoiइसके बजाय का उपयोग करें as.double, लेकिन हाँ, यह ठीक होना चाहिए।
— Giuseppe
0

C तीव्र 180 बाइट्स

यह बहुत अच्छा गोल्फ नहीं है, योग्य।

s=>{var q=new Queue<int>(s.Where(Char.IsNumber).Select(n=>n-48));q.Enqueue(q.First());int t,o=0;o=q.Dequeue();try{while(true){t+=o+(o%2==0?-1:1)*(o=q.Dequeue());}}catch{return t;}}

अधूरा:

var q = new Queue<int>(s.Where(Char.IsNumber).Select(n=>n-48));
int t,o=0;

q.Enqueue(q.First());    
o=q.Dequeue();

try{
    while(true){
        t += o + (o%2==0?-1:1) * (o=q.Dequeue());
    }
}
catch {
    return t;
}
— IEatBagels
स्रोत
0

स्टैक्स , 14 बाइट्स

ÿ←«4é■≥B▬ê→█T♥

इसे चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह ऐसा दिखता है।

Vd|&    filter out non-digits
c|(\    zip into pairs after rotating right
F       for each digit pair
  B2%s  first-of-pair % 2, then swap top two stack elements
  eH*   eval digit as integer, double, then multiply
  +     add to running total

इसको चलाओ

— पुनरावर्ती
स्रोत
0

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

s=>s.filter(t=>1/t&&~(a+=u*t,u=t%2),a=u=0)[0]*u+a<<1

वर्णों के एक सरणी के रूप में इनपुट की अपेक्षा करता है। कैविएट: बिट-शिफ्टिंग के उपयोग के कारण आउटपुट में ऊपरी सीमा होती है2^31-1

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

व्याख्या

अनिवार्य रूप से विषम मानों के बाद अंकों का योग दोगुना हो जाता है।

s => s.filter(             // filter to preserve the first digit
    t =>
        1/t &&             // short-circuits if NaN
        ~(                 // coerce to truthy value
            a += u * t,    // adds value only if previous digit is odd
            u = t%2        // store parity of current digit
        ),
    a = u = 0
)[0]                       // first digit
* u + a
<< 1                       // bit-shift to multiply by 2 (also coerces a NaN resulting from a string devoid of digits to 0)
— फालतूपन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.