Lấy một chuỗi làm đầu vào và thực hiện phép cộng / trừ tất cả các chữ số trong chuỗi và xuất tổng của các hoạt động đó làm kết quả.

Quy tắc

• Các chữ số trong chuỗi được đọc từ trái sang phải
• Nếu một chữ số (n) là số lẻ, hãy thực hiện phép cộng với chữ số tiếp theo (n + n1)
• Nếu một chữ số (n) chẵn, thực hiện phép trừ với chữ số tiếp theo (n - n1)
• Nếu bạn đã đạt đến chữ số cuối cùng trong chuỗi, hãy thực hiện thao tác với chữ số đầu tiên trong chuỗi
• Đầu ra sẽ là tổng của tất cả các giá trị kết quả
• Nếu chỉ có một chữ số trong chuỗi, hãy thực hiện thao tác với chính nó (n + n hoặc nn)
• Nếu không có chữ số trong chuỗi, đầu ra là 0

Thí dụ

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

Ghi chú

• Chức năng hoặc chương trình đầy đủ được chấp nhận
• Độ dài đầu vào tối đa sẽ phụ thuộc vào giới hạn ngôn ngữ của bạn cho đầu vào chuỗi
• Không có giới hạn đối với đầu vào ký tự, nhưng chỉ các chữ số nửa chiều rộng được tính vào đầu ra
• Ít byte nhất sẽ thắng

Thạch , 17 15 12 byte

fØDV€ḂT‘ịƲSḤ

Hãy thử trực tuyến!

Hãy thử các trường hợp thử nghiệm.

Chương trình chỉ giữ các chữ số theo sau một chữ số lẻ sau đó tính hai lần tổng.

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.

K (oK) , 47 43 40 31 byte

Giải pháp:

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

Hãy thử trực tuyến!

Giải trình:

Xóa mọi thứ khỏi chuỗi không phải là số (đồng thời chuyển đổi), modulo 2, nhân với 2, nhân với x được xoay bởi 1 và tổng hợp.

{+/(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 (/)

Giải pháp ngây thơ:

Xóa mọi thứ khỏi chuỗi không phải là số (đồng thời chuyển đổi), lấy cửa sổ trượt 2 mục, tìm hiểu xem chúng là số lẻ hay chẵn, áp dụng cộng / trừ khi thích hợp, sau đó tổng hợp.

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

Hãy thử trực tuyến!

Ghi chú:

• -4 byte nhờ @ngn do cách lọc đầu vào thông minh hơn
• -3 byte bằng cách sử dụng cửa sổ trượt thay vì định hình lại
• -9 byte chuyển giải pháp của ngn (cách tiếp cận không ngây thơ)

Python 2 , 86 byte

k=[int(a)for a in input()if'/'<a<':']
print sum(a-(-1)**a*b for a,b in zip(k,k[1:]+k))

Hãy thử trực tuyến!

Perl 6 , 41 byte

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

Hãy thử trực tuyến!

Sử dụng logic tương tự như câu trả lời Jelly của dylnan . Tổng này chỉ các chữ số theo sau một số lẻ và sau đó nhân với 2.

Powershell, 80 78 76 byte

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

-2 byte cảm ơn Neil với giải pháp Retina

-2 byte cảm ơn admBorkBork

Kịch bản thử nghiệm:

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

&$f 'r5e6o9mm!/3708dvc'

Giải trình

Trước hết: phải thêm 2 * n nếu chữ số trước là số lẻ và 0 nếu chữ số trước là số chẵn.

($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

Thêm, 99 byte

Lấy cảm hứng từ @Neil. Regex khớp các chữ số với 'chữ số trước là số lẻ'. Matcheslà một biến tự động .

param($d)$d+($d-match'\d')+$Matches[0]|sls '(?<=[13579]\D*)\d'-a|%{$_.Matches.Value|%{$s+=2*$_}};$s

MATL , 18 17 byte

t4Y2m)!Ut1YSof)sE

Hãy thử trực tuyến!

(-1 byte nhờ Luis Mendo / Giuseppe / cả hai!)

Giải trình:

     % 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

Ý tưởng cơ bản là các số theo số chẵn có thể bị bỏ qua, trong khi những số theo số lẻ được nhân đôi - và kết quả cuối cùng là tổng của các giá trị nhân đôi đó.

Tôi đã không nghĩ rằng fsau khi kiểm tra chẵn lẻ olà cần thiết, nhưng vì một số lý do, MATL không thấy mảng 0 và 1 là kết quả của omảng logic, thay vào đó lấy chúng làm chỉ số và chỉ mục số vào vị trí 1và end.

K (ngn / k) , 33 byte

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

Hãy thử trực tuyến!

{ } là một hàm với đối số x

!10 là danh sách 0 1 ... 9

$ chuyển đổi thành chuỗi

,/ ghép

x^có nghĩa là xkhông có những gì bên phải

x^x^có nghĩa là xgiao nhau với những gì ở bên phải, tức là chỉ giữ các chữ số từx

-48+trừ 48, là mã ASCII của"0"

x: giao cho x

2! mod 2

2* nhân với 2

1_x,*xlà một giọt của: xtiếp theo là đầu tiên của x; tức là xquay sang trái một bước

+/ Tổng

Japt (v2.0a0), 25 19 byte

^{-6 byte nhờ Shaggy .}

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

Hãy thử nó ở đây .

Nó hoạt động không có chữ số lần này! Đầu vào là một danh sách các ký tự.

05AB1E , 12 9 byte

Lưu 1 byte qua phương thức ngây thơ bằng cách sử dụng thủ thuật chẵn lẻ của dylnan
Lưu 3 byte nhờ vào ông Xcoder

þDÁ€ÉÏSO·

Hãy thử trực tuyến!

Giải trình

þ              # push only digits of input
 D             # duplicate
  Á            # rotate right
   ۃ          # get the parity of each
     Ï         # keep only true items
      SO       # calculate digit-sum
        ·      # double

Võng mạc , 37 byte

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

Hãy thử trực tuyến! Giải trình:

(\d).*
$&$1

Nối một bản sao của chữ số đầu tiên.

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

Khớp bất cứ thứ gì có chữ số đầu tiên là số lẻ.

2**

Chuyển đổi tất cả các trận đấu để unary và nhân đôi chúng. (Không phải chữ số được coi là số không.)

_

Lấy tổng. Nếu không có kết quả khớp, thì điều này tạo ra số 0 theo yêu cầu.

Điều tốt nhất tôi có thể làm trong Retina 0.8.2 là 44 byte:

[^\d]

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

.
$*
.
..
.

Hãy thử trực tuyến! Giải trình:

[^\d]

Xóa các chữ số không.

(.).*
$&$1

Nối một bản sao của chữ số đầu tiên.

(?<![13579]).

Xóa các chữ số không theo một chữ số lẻ.

.
$*

Chuyển đổi sang unary.

.
..

Nhân đôi chúng.

.

Lấy tổng.

Thạch , 15 byte

fØDV€1ịṭƊ+_Ḃ?ƝS

Hãy thử trực tuyến!

JavaScript (ES6), 56 byte

Đưa đầu vào như một mảng các ký tự.

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

Hãy thử trực tuyến!

Đã bình luậ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

JavaScript (Node.js) , 85 84 83 82 byte

-1 byte nhờ vào lò nướng

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

Hãy thử trực tuyến!

Lấy đầu vào chuỗi, tìm các chữ số dưới dạng một mảng các ký tự hoặc trả về mảng trống nếu không tìm thấy, sau đó sử dụng kiểu ép buộc để đảm bảo các giá trị được thêm / bớt một cách chính xác. Tra cứu về phía trước tạo ra chỉ số và sử dụng kiểm tra null cho phép ngắn gọn, và sau đó phần cuối cùng kiểm tra xem số đó là số lẻ hay thậm chí để buộc cộng hoặc trừ (+ và - là -, v.v.)

R , 58 byte

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

Hãy thử trực tuyến!

• sử dụng thủ thuật chẵn lẻ của dylnan
• -8 byte chấp nhận vectơ ký tự thay vì chuỗi
• -3 byte nhờ @Giuseppe

Perl 5 , 48 byte

$;=$;[++$-%@;],$\+=$_%2?$_+$;:$_-$;for@;=/\d/g}{

Hãy thử trực tuyến!

Tôi khá thích cách mã hóa này trông như thế nào, nhưng đó là một vòng lặp khá đơn giản xung quanh tất cả các số trong chuỗi.

Julia 0,6 , 77 69 byte

s->(s=s.-'0';s=s[0.<=s.<=9];endof(s)>0?sum(2(s%2).*[s[2:end];s[]]):0)

Hãy thử trực tuyến!

C sắc nét 180 byte

Đây không phải là chơi golf rất tốt, lol.

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;}}

Ung dung:

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;
}

Stax , 14 byte

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

Chạy và gỡ lỗi nó

Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

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

Chạy cái này

JavaScript (ES6), 52 byte

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

Mong đợi đầu vào như một mảng các ký tự. Hãy cẩn thận: Do sử dụng dịch chuyển bit, đầu ra có giới hạn trên là2^31-1

Hãy thử trực tuyến!

Giải trình

Về cơ bản nhân đôi tổng các chữ số sau các giá trị lẻ.

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)