문자열을 입력으로 사용하고 문자열의 모든 숫자를 더하기 / 빼기를 ​​수행하여 해당 연산의 합계를 결과로 출력하십시오.

규칙

• 문자열의 숫자는 왼쪽에서 오른쪽으로 읽습니다.
• 숫자 (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

노트

• 기능 또는 전체 프로그램이 허용됩니다
• 최대 입력 길이는 문자열 입력에 대한 언어 제한에 따라 다릅니다.
• 문자 입력에는 제한이 없지만 반 자릿수 만 출력에 포함됩니다.
• 가장 적은 바이트가 승리

젤리 , 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.

K (oK) , 47 43 40 31 바이트

해결책:

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

온라인으로 사용해보십시오!

설명:

숫자가 아닌 문자열에서 모든 모듈을 제거하고 모듈로 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 (/)

순진한 솔루션 :

숫자가 아닌 문자열에서 모든 것을 제거하고 (변환하는 동안) 2 항목 슬라이딩 창을 가져 와서 홀수인지 짝수인지 파악하고 적절하게 더하기 / 빼기를 ​​적용한 다음 요약하십시오.

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

온라인으로 사용해보십시오!

노트:

• -4 바이트더 똑똑한 입력 필터링 방식으로 인해 @ngn 덕분에
• -3 바이트모양을 바꾸는 대신 슬라이딩 윈도우를 사용하여
• ngn 솔루션을 이식하는 -9 바이트 (순진하지 않은 접근 방식)

파이썬 2 , 86 바이트

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

온라인으로 사용해보십시오!

펄 6 , 41 바이트

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

온라인으로 사용해보십시오!

dylnan의 Jelly answer 와 동일한 논리를 사용합니다 . 홀수 뒤에 오는 숫자 만 합한 다음 2를 곱합니다.

Powershell, 80 78 76 바이트

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

-2 바이트 덕분에 Neil 망막 솔루션

-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

MATL , 18 17 바이트

t4Y2m)!Ut1YSof)sE

온라인으로 사용해보십시오!

(Luis Mendo / Giuseppe / both 덕분에 1 바이트!)

설명:

     % 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은 o논리 배열로서의 0과 1의 배열을 논리 배열로 보지 않고 대신 숫자 인덱스와 인덱스로 위치 1와로 가져 end갑니다.

K (ngn / k) , 33 바이트

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

온라인으로 사용해보십시오!

{ } 인수가있는 함수입니다 x

!10 목록입니다 0 1 ... 9

$ 문자열로 변환

,/ 사슬 같이 잇다

x^x오른쪽에없는 것을 의미

x^x^수단 x오른쪽에 무엇이와 교차는, 즉에서만 숫자를 유지x

-48+빼기 ( 48의 ASCII 코드)"0"

x: 할당하다 x

2! 모드 2

2* 2 곱하기

1_x,*xx다음 중 하나의 드롭 입니다 x. 즉x 한 단계 씩 왼쪽으로 회전

+/ 합집합

apt (v2.0a0), 25 19 바이트

^{-6 덕분에 바이트 얽히고 설킨 .}

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

여기 사용해보십시오 .

이번에는 숫자없이 작동합니다! 입력은 문자 목록입니다.

05AB1E , 12 9 바이트

Dylnan의 패리티 트릭 을 활용하여 순진한 방법보다 1 바이트 절약 Xcoder
덕분에 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

망막 , 37 바이트

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

온라인으로 사용해보십시오! 설명:

(\d).*
$&$1

첫 번째 숫자의 사본을 추가하십시오.

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

첫 번째 이전 자릿수가 홀수 인 모든 항목을 찾습니다.

2**

모든 일치 항목을 단항으로 변환하고 두 배로 만듭니다. 숫자가 아닌 숫자는 0으로 처리됩니다.

_

합계를 가져옵니다. 일치하는 항목이 없으면 필요한만큼 0을 생성합니다.

Retina 0.8.2에서 할 수있는 최선은 44 바이트였습니다.

[^\d]

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

.
$*
.
..
.

온라인으로 사용해보십시오! 설명:

[^\d]

숫자가 아닌 숫자를 삭제하십시오.

(.).*
$&$1

첫 번째 숫자의 사본을 추가하십시오.

(?<![13579]).

홀수 자릿수를 따르지 않는 자릿수를 삭제하십시오.

.
$*

단항으로 변환합니다.

.
..

두 배로

.

합계를 가져옵니다.

젤리 , 15 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 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

자바 스크립트 (Node.js) , 85 84 83 82 바이트

ovs 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

문자열 입력을 취하고 숫자를 문자 배열로 찾거나없는 경우 빈 배열을 반환 한 다음 유형 강제 변환을 사용하여 값을 올바르게 더하거나 뺍니다. 정방향 조회는 색인을 미리 증가시키고 간결성을 위해 널 검사를 사용한 다음 마지막 부분은 숫자가 홀수인지 또는 더하기 또는 빼기 (+ 및-는-등)인지 확인합니다.

R , 58 바이트

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

온라인으로 사용해보십시오!

• 사용 dylnan의 패리티 트릭을
• 문자열 대신 문자 벡터를 허용하는 -8 바이트
• @Giuseppe 덕분에 -3 바이트

펄 5 , 48 바이트

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

온라인으로 사용해보십시오!

나는 이것이 암호처럼 보이는 것을 좋아하지만 문자열의 모든 숫자 주위에 매우 간단한 루프입니다.

줄리아 0.6 , 77 69 바이트

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

온라인으로 사용해보십시오!

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

Stax , 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

이것을 실행

자바 스크립트 (ES6), 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)