조부모님의 날에는 다음과 같이 로터리 다이얼 로 전화 번호를 다이얼링했습니다 .

각 자리에 전화를 걸려면 손가락을 해당 구멍에 넣고 손가락 멈춤 쇠 위로 당겨 분리하십시오. 메커니즘을 사용하면 다이얼이 정지 위치로 돌아가고 전화기가 지정된 횟수만큼 회로를 분리했다가 다시 연결하여 딸깍 소리가납니다.

디지트 다이얼링 N은 요구 N N = 용 펄스 열 0를 제외하고, 그러한 "펄스".

로타리 전화는 큰 숫자 (8, 9, 0)가 작은 숫자 (1, 2, 3)보다 전화 걸기 시간이 더 오래 걸립니다. 이것은 초기 지역 코드 맵을 작성하는 데 중요한 고려 사항이었으며 인구 및 전화선 밀도가 높은 뉴욕시가 212 (5 펄스 만 )를 얻었고 907 (26 펄스)이 알래스카에 드문 드문 이유는 무엇입니까 ? 물론, 터치 톤 다이얼링이 대중화되었을 때이 모든 것이 무의미 해졌습니다.

도전

전화 번호가 포함 된 문자열 (또는 문자 시퀀스)을 입력으로 사용하고 로터리 다이얼 펄스 수를 출력하는 프로그램 또는 함수를 가능한 한 적은 바이트로 작성하십시오. 이들은 다음과 같이 계산됩니다.

숫자

• 숫자 1-9는 해당 펄스 수로 계산됩니다.
• 숫자 0은 10 펄스로 계산됩니다.

편지

다이얼의 숫자 2-9에는 연관된 라틴 알파벳 문자가 있습니다. 이것들은 원래 명명 된 교환을 위한 것이 었지만 후자는 전화 번호 및 문자 메시지 입력 시스템에 다시 적합했습니다 .

E.161 문자를 숫자로 할당 하여 전화 번호에 문자를 지원해야합니다 .

• A, B, C = 2
• D, E, F = 3
• G, H, I = 4
• J, K, L = 5
• M, N, O = 6
• P, Q, R, S = 7
• T, U, V = 8
• W, X, Y, Z = 9

입력이 대소 문자로 이미 접혀 있다고 가정 할 수 있습니다.

다른 캐릭터

문자 및 공백을 서식 구분 기호로 임의로 사용할 수 있어야합니다()+-./ . 당신은 할 수 있도록하기로 결정했습니다 모든 것이 구현하기가 쉽다 경우,이 목적을 위해 영숫자가 아닌 문자를.

이 문자는 펄스 수에 영향을 미치지 않습니다.

예제 코드

파이썬에서 골프가 아닌 조회 테이블 및 함수 :

PULSES = {
    '1': 1,
    '2': 2, 'A': 2, 'B': 2, 'C': 2,
    '3': 3, 'D': 3, 'E': 3, 'F': 3,
    '4': 4, 'G': 4, 'H': 4, 'I': 4,
    '5': 5, 'J': 5, 'K': 5, 'L': 5,
    '6': 6, 'M': 6, 'N': 6, 'O': 6,
    '7': 7, 'P': 7, 'Q': 7, 'R': 7, 'S': 7,
    '8': 8, 'T': 8, 'U': 8, 'V': 8,
    '9': 9, 'W': 9, 'X': 9, 'Y': 9, 'Z': 9,
    '0': 10
}

def pulse_count(phone_num):
    return sum(PULSES.get(digit, 0) for digit in phone_num)

입력 및 출력 예

• 911 → 11
• 867-5309 → 48
• 713 555 0123 → 42
• +1 (212) PE6-5000 → 57
• 1-800-FLOWERS → 69
• PUZZLES → 48

05AB1E , 19 18 17 15 바이트

AÁ0ªā6+žq÷9š‡þO

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

이것은 π를 사용하는 첫 번째 답변입니다. π를 사용하는 이유는 무엇입니까? 글씨는 순서대로 22233344455566677778889999와 관련이 있습니다. 대부분의 숫자는 3 번 반복되지만 7은 4 번 반복됩니다. 각 숫자는 평균적으로 (3 + 1 / 7) 번 반복된다고 말할 수 있습니다. 대략 3 + 1 / 7의 숫자가 22/7보다 적은 바이트가 있는지 궁금합니다.

이것은 4 9가 아닌 4 7 만 제공하므로 Z를 특수한 경우로 처리해야합니다.

A               # alphabet (abcdefghijklmnopqrstuvwxyz)
 Á              # rotate right (zabcdefghijklmnopqrstuvwxy)
  0ª            # append 0 (zabcdefghijklmnopqrstuvwxy0)

ā6+             # range [7..33]
   žq÷          # divide by π (22233344455566677778889991010)
      9š        # prepend 9 (922233344455566677778889991010)

‡               # transliterate the implicit input with the two lists above
                # this replaces z → 9, a → 2, … y → 9, 0 → 10
 þ              # remove all non-digits
  O             # sum

C # (Visual C # Interactive Compiler) , 51 바이트

n=>n.Sum(x=>x>64?(x-59-x/83-x/90)/3:x>47?1-~x%~9:0)

@recursive 덕분에 1 바이트 절약

@ExpiredData의 관찰 덕분에 10 바이트를 절약 () +-/.하여 입력 에만 있음

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

n =>                     // Function taking input as string
  n.Sum(x =>             // Map each value 'x' through the following
    x>64 ?               //   If 'x' is an uppercase letter
      (x-59-x/83-x/90)/3 //     Take each char's ASCII value subtracted by 59, and subtract
                         //     one if the char is 'S' and one if the char is 'Z'
    : x>47 ?             //   Else if the char is a digit
      1-~x%~9            //   Take 1 - (-x - 1) % -10 (Maps 0 to 10, and 1-9 to themselves
    : 0                  //   Else, 0
  )                      // And sum it all up, then return it

APL (Dyalog Unicode) , 27 바이트 ^SBCS

익명의 암묵적 접두사 기능.

+/'@ADGJMPTW'∘⍸+11|(1⌽⎕D)∘⍳

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

(… 다음 문자열에서 각 문자 )∘⍳ 의 ɩ ndex *를 찾으십시오 .
  ^{* 찾을 수없는 요소는 인덱스 1+ 최대 인덱스를 가져옵니다 (예 : 11}
 ⎕D  자리)."0123456789"

 1⌽ 한 단계 왼쪽으로 주기적으로 회전합니다. "1234567890"

11| 분할 나머지 * 11로 나누었을 때
  ^{*이 아닌 모든 숫자 0을 제공합니다}
... + 다음에 그 추가 :

 '@ADGJMPTW'∘⍸ɩ nterval ɩ ndex * 각 문자
  ^{* 그래서 [-∞ "@")가 0 준다 [ "@", "A")는 1 준다 [ "A"는 "D")는 등이 제공}
+/  합 그

파이썬 2 , 74 바이트

lambda s:sum([(n-59-n/83-n/90)/3,1-~n%~9][n<58]for n in map(ord,s)if n>47)

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

각 문자의 ASCII 값에 대한 산술을 수행합니다. 첫 번째 옵션은 문자를 확인하고 두 번째 옵션은 숫자를 확인합니다. 입력에 허용 된 모든 문장 부호 문자가 48보다 작은 ASCII 값을 갖는 문자임을 명확히하면 논리를 단순화 할 수 있지만 새로운 방법이 더 나을 수 있습니다.

파이썬 2 , 84 바이트

lambda s:sum(1+'1xxxx2ABCx3DEFx4GHIx5JKLx6MNOx7PQRS8TUVx9WXYZ0'.find(c)/5for c in s)

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

하드 코딩 된 조회 문자열을 사용합니다. 각 문자는 5 자로 구성되며 각 값은 1로 시작하는 문자에 해당합니다. 공백은으로 채워지며 x대문자로 입력 할 수 없습니다. 우연히, 문자는 문자열 생산에 표시되지 -1에 대한 .find0의 피가수를 제공합니다.

자바 스크립트 (Node.js) , ... 76 69 바이트

s=>s.replace(/\w/g,q=>w+=1/q?+q||10:parseInt(q,35)*.32-1|0||9,w=0)&&w

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

-7 감사합니다 @Arnauld!

설명

 q |     1/q     |  +q  | parseInt(q,35)*.32 | parseInt(q,35)*.32-1|0 | Output
---+-------------+------+--------------------+------------------------+--------
 0 | Infinity(T) | 0(F) |         N/A        |           N/A          |   10
 1 |  1.0000(T)  | 1(T) |         N/A        |           N/A          |    1
 2 |  0.5000(T)  | 2(T) |         N/A        |           N/A          |    2
 3 |  0.3333(T)  | 3(T) |         N/A        |           N/A          |    3
 4 |  0.2500(T)  | 4(T) |         N/A        |           N/A          |    4
 5 |  0.2000(T)  | 5(T) |         N/A        |           N/A          |    5
 6 |  0.1666(T)  | 6(T) |         N/A        |           N/A          |    6
 7 |  0.1428(T)  | 7(T) |         N/A        |           N/A          |    7
 8 |  0.1250(T)  | 8(T) |         N/A        |           N/A          |    8
 9 |  0.1111(T)  | 9(T) |         N/A        |           N/A          |    9
 A |    NaN(F)   |  N/A |        3.20        |          2(T)          |    2
 B |    NaN(F)   |  N/A |        3.52        |          2(T)          |    2
 C |    NaN(F)   |  N/A |        3.84        |          2(T)          |    2
 D |    NaN(F)   |  N/A |        4.16        |          3(T)          |    3
 E |    NaN(F)   |  N/A |        4.48        |          3(T)          |    3
 F |    NaN(F)   |  N/A |        4.80        |          3(T)          |    3
 G |    NaN(F)   |  N/A |        5.12        |          4(T)          |    4
 H |    NaN(F)   |  N/A |        5.44        |          4(T)          |    4
 I |    NaN(F)   |  N/A |        5.76        |          4(T)          |    4
 J |    NaN(F)   |  N/A |        6.08        |          5(T)          |    5
 K |    NaN(F)   |  N/A |        6.40        |          5(T)          |    5
 L |    NaN(F)   |  N/A |        6.72        |          5(T)          |    5
 M |    NaN(F)   |  N/A |        7.04        |          6(T)          |    6
 N |    NaN(F)   |  N/A |        7.36        |          6(T)          |    6
 O |    NaN(F)   |  N/A |        7.68        |          6(T)          |    6
 P |    NaN(F)   |  N/A |        8.00        |          7(T)          |    7
 Q |    NaN(F)   |  N/A |        8.32        |          7(T)          |    7
 R |    NaN(F)   |  N/A |        8.64        |          7(T)          |    7
 S |    NaN(F)   |  N/A |        8.96        |          7(T)          |    7
 T |    NaN(F)   |  N/A |        9.28        |          8(T)          |    8
 U |    NaN(F)   |  N/A |        9.60        |          8(T)          |    8
 V |    NaN(F)   |  N/A |        9.92        |          8(T)          |    8
 W |    NaN(F)   |  N/A |       10.24        |          9(T)          |    9
 X |    NaN(F)   |  N/A |       10.56        |          9(T)          |    9
 Y |    NaN(F)   |  N/A |       10.88        |          9(T)          |    9
 Z |    NaN(F)   |  N/A |         NaN        |          0(F)          |    9

모두에 [space]().+-/의해 캡처 /\w/g되지 않으므로 총계에 영향을 미치지 않습니다.

펄 5 -p , 52 51 바이트

@Grimy는 -1의 크레딧을 얻습니다

y/A-Z/22233344455566677778889/;map$\+=$_||10,/./g}{

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

J , 39 바이트

1#.'?@CFILOSVZ'&I.+11|1+'1234567890'i.]

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

Adám의 APL 솔루션 포트

레티 나 0.8.2 , 34 바이트

T`WTPMJGDA`Rd
}T`L`2L
0
55
\d
$*
1

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 설명:

T`WTPMJGDA`Rd

문자 WTPMJGDA를 숫자로 변환하십시오 9..0.

}T`L`2L

나머지 모든 문자를 1 씩 섞고 모든 문자가 숫자로 변환 될 때까지 반복하십시오.

0
55

교체 0와 함께 55그들이 전화를하는 펄스의 같은 번호를 가지고있다.

\d
$*
1

디지털 합계를 가져옵니다.

K4 , 44 바이트

해결책:

+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?

예 :

q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"911"
11
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"867-5309"
48
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"+1 (212) PE6-5000"
57
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"1-800-FLOWERS"
69

설명:

순진한 접근 방식, 아마도 골프를 칠 가능성이 높습니다. 문자 색인 조회, 조회 점수, 합계

+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")? / the solution
                                           ? / lookup
                          (               )  / do this together
                                       "0"   / string "0"
                                      ,      / join with
                                  .Q.n       / string "0123456789"
                                1_           / drop first
                               ,             / join with
                           .Q.A              / "A..Z"
  (                      )                   / do this together
                      !10                    / range 0..9
                     ,                       / join with
     (              )                        / do this together
               4 3 4                         / list (4;3;4)
              ,                              / join with
         (5#3)                               / list (3;3;3;3;3)
        &                                    / where, creates list 0 0 0 1 1 1 2 2 etc
      1+                                     / add 1
   1+                                        / add 1
+/                                           / sum up

펄 6 , 53 바이트

{sum +<<m:g/\d/X||10}o{S:g[<:L>]=$/.ord*.313-28+|0+9}

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

ASCII 코드에 1/3 대신 0.313을 곱하고 비트 OR을 사용하여 0으로 반올림 하여 올바른 바이어스 를 얻 습니다 .

C (gcc) , 94 89 86 80 바이트

ceilingcat, nwellnhof 및 Rogem에게 제안 해 주셔서 감사합니다.

c;f(char*s){c=*s-48;s=*s?(c<10U?c?c:10:c-17<26U?(c-11-c/35-c/42)/3:0)+f(s+1):0;}

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

배쉬 , 256 바이트

동일한 바이트 수로 (( … ))구성을 바꿀 수 있습니다 let. 사례 문장을 줄이는 데 유용한 알고리즘이 있지만 지금까지는 찾지 못했습니다. 약간의 재 작업으로 기능을 만들 수도 있습니다 (그러나 function fname { … }상단과 꼬리를 할인 할 수 없다면 바이트가 같거나 적지 않습니다 ).

read p;while ((${#p}>0));do case ${p:0:1} in ([1-9]) ((d+=${p:0:1}));; ([0]) ((d+=10));; ([ABC) ((d+=2));; ([P-S]) ((d+=7));; ([W-Z]) ((d+=9));;([DEF]) ((d+=3));; ([GHI]) ((d+=4));; ([JKL]) ((d+=5));; ([MNO]) ((d+=6));; (?) d=$d; esac;p=${p#?};done;echo $d

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

맵 캐릭터 기법을 사용하는 더 나은 솔루션은 다음 tr도구를 사용합니다 .

[tr을 사용한 배쉬], 173 바이트

read p;p=$(echo $p|tr A-Z 22233344455566677778889999);while ((${#p}>0));do case ${p:0:1} in ([1-9]) ((d+=${p:0:1}));; ([0]) ((d+=10));; (?) d=$d; esac;p=${p#?}; done;echo $d

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

젤리 , 33 24 바이트

7r32:ØP«9Ṿ€ØAżFyfØDV€o⁵S

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

문자열을 인수로 사용하고 펄스 수를 반환하는 모나드 링크. @Grimy의 05AB1E 답변에서 영감을 받아 다시 작성 되었으므로 투표 하십시오.

PowerShell을 , 109 (102) 87 바이트

$(switch -r($args|% t*y){\d{$_}[A-Y]{("{0}"-f(.313*$_-18))[0]}[Z]{9}0{10}})-join'+'|iex

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

편집 : char-> int-> 문자열을 캐스팅하고 첫 번째 '숫자'만 가져 오기 위해 일부 문자열 형식의 정규식 스위치에 @mazzy의 아이디어를 사용했습니다.

기발한:

[char[]]"$args"|%{$a+=(48,(('22233344455566677778889999')[$_-65],(58,$_)[$_-ne48])[$_-lt64])[$_-gt47]-=48};$a

나는 <100 바이트를 얻기를 바 랐기 때문에 내가 할 수있는 것이 있는지 계속 살펴볼 것입니다. 숫자 문자열을 제거하는 방법이있을 것입니다

부울 인덱싱 문으로 배열을 중첩하여 혼란 스럽지만 죄송합니다.

설명:

[char[]]"$args"|%{문자열로 주조 입력을 판독하고, 그 다음 문자 배열로 폭발 및이 피 각 검사와 루프 시작 ()[$_-gt47]라도 있는지 ()+-./입력 된 (모든 ASCII 문자 값이 <48)
주 : PowerShell을 허용 $true하고 $false으로 1하고 0배열 인덱스의 각각에

그런 다음 48기호를 얻거나 다음을 얻습니다 .
('22233344455566677778889999'[$_-65],(58,$_)[$_-ne48])[$_-lt64]

[$_-lt64]숫자 나 문자 (여기 모든 가정 된 자본)를 확인합니다. 문자 인 경우 '22233344455566677778889999'[$_-65]0-25로 변경하여 배열을 색인화하고 펄스 값을 문자로 출력합니다. 문자가 숫자이면 대신 (58,$_)[$_-ne48]확인 0하고 출력 58하거나 숫자 문자 자체를 봅니다.

모든 주변 $a+= ... -=48에서 숫자 변수 $ a를 초기화 한 0다음 출력을 추가합니다. 출력은 숫자의 ASCII 문자 값이므로을 뺍니다 48.

참고 : 입력이 기호 $a+=48-48이면 효과적으로 무시합니다. 그것이 경우에 0, 우리가 얻을 $a+=58-48우리의 열을 얻기 위해

마지막으로, ;$a각 루프에 대한 최종 값 포스트를 출력합니다.

PowerShell , 95 85 79 바이트

nwellnhof의 답변에서 영감을 얻었습니다 .

Sinusoid의 답변[0] 에서 영감을 얻었습니다 .

$(switch -r($args|% t*y){\d{$_}0{10}[A-Y]{"$(.313*$_-18)"[0]}Z{9}})-join'+'|iex

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

풀린 버전 :

$(
    switch -r($args|% toCharArray){
        \d    {$_}
        0     {10}
        [A-Y] {"$(.313*$_-18)"[0]}
        Z     {9}
    }
)-join '+'|Invoke-Expression

key .313*$_-18 "$(...)"[0]
--- ---------- -----------
  A      2.345 2
  B      2.658 2
  C      2.971 2
  D      3.284 3
  E      3.597 3
  F      3.910 3
  G      4.223 4
  H      4.536 4
  I      4.849 4
  J      5.162 5
  K      5.475 5
  L      5.788 5
  M      6.101 6
  N      6.414 6
  O      6.727 6
  P      7.040 7
  Q      7.353 7
  R      7.666 7
  S      7.979 7
  T      8.292 8
  U      8.605 8
  V      8.918 8
  W      9.231 9
  X      9.544 9
  Y      9.857 9

Stax , 21 바이트

éT6T&\²|└t5φ╛│█♪√┘↑▓^

실행 및 디버깅

코 틀린 , 113 바이트

{s:String->var t=0
for(c in s){val v=c-'0'
t+=when(v){0->10
in 1..9->v
in 17..42->(v-11-v/35-v/42)/3
else->0}}
t}

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

파이썬 3 , 134123 바이트

f=lambda n:sum(map(int,n.translate(n.maketrans('ADGJMPTWBEHKNQUXCFILORVYSZ','23456789'*3+'79','()+-./ '))))+10*n.count('0')

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

@ dan04 덕분에 -11 바이트