내가 어렸을 때 저축에서 달러 지폐를 세고 싶을 때 나는 크게 소리를 세었습니다.

일이 삼 사 오 육 칠 팔 구 십;
11, 12, 13, 14, 15, 16, 17, 18, 19, 20;
스물 하나, 스물 둘, 스물셋, 스물 넷, 스물 다섯 ...

결국 나는이 여러 음절을 발음하는 데 지쳤습니다. 수학적으로 생각하기 때문에 훨씬 효율적인 계산 방법을 만들었습니다.

일이 삼 사 오 육 칠 팔 구 십;
하나, 둘, 셋, 넷, 다섯, 여섯, 일곱, 여덟, 아홉, 이십;
하나, 둘, 셋, 넷, 다섯, 여섯, 일곱, 여덟, 아홉, 삼십 ...

보시다시피, 이전 숫자에서 변경된 숫자 만 발음합니다. 이것은 숫자에 대한 영어 이름보다 상당히 반복적이므로 계산하는 데 적은 두뇌 능력이 필요하다는 이점이 있습니다.

도전

양의 정수를 가져 와서 계산 방법을 출력 / 반환하는 프로그램 / 함수를 작성하십시오 (즉, 가장 오른쪽이 아닌 숫자와 모든 후행 0).

예

   1    1
   2    2
  10   10
  11    1
  29    9
  30   30
  99    9
 100  100
 119    9
 120   20
 200  200
 409    9
1020   20

테스트 사례의 전체 목록은 필요하지 않습니다. 이다 A274206 OEIS합니다.

규칙

• 정밀도와 메모리 문제를 무시하고 모든 양의 정수에 이론적으로 입력해야합니다.
• 입력과 출력은 10 진수 여야합니다.
• 입력 및 / 또는 출력을 숫자, 문자열 또는 숫자 배열로 선택할 수 있습니다.
• 입력은 양의 정수 여야합니다. 입력이 유효하지 않은 입력에 대해 무엇이든 할 수 있습니다.

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

파이썬 2 , 28 바이트

f=lambda n:n%10or 10*f(n/10)

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

재귀 수식은 매우 깨끗하게 작동합니다. 마지막 숫자가 0이 아닌 경우 출력하십시오. 그렇지 않으면 마지막 0을 제거하고 출력을 계산 한 다음 10을 곱하십시오.

젤리 , 6 3 바이트

소수 자릿수 목록 으로 I / O를 사용하여 -3 바이트 .

ṫTṪ

온라인 사용해보기 테스트 스위트 !

어떻게?

ṫTṪ - Main link: listOfDigits  e.g.  [1,    0,    2,    0]  or [1,      1,    9  ]
 T  - truthy indexes                 [1,          3      ]     [1,      2,    3  ]
ṫ   - tail (vectorises)              [[1,0,2,0],  [2,0]  ]     [[1,1,9],[1,9],[9]]
  Ṫ - tail pop                                    [2,0]                       [9]

우리가 10 진수 목록을 가져올 수 없다면 6 바이트는 다음과 같습니다.

DµṫTṪḌ

여기서 볼 수 있습니다 .

이것은 똑같은 일을하지만 정수를 미리 소수 목록으로 변환하고 나중에 정수로 다시 변환합니다.

C, 30 29 27 바이트

이것을 골프화하기 위해 두 개의 C 익스플로잇을 남용 할 때이 점을 자랑스럽게 생각합니다 (포스트 끝에서 설명). 이것은 특히 C (GCC)를위한 것입니다

3) b=10;f(a){a=a%b?:b*f(a/b);}// 27 바이트

2) b;f(a){b=a=a%10?:10*f(a/10);}// 29 바이트

1) f(i){return i%10?:10*f(i/10);}// 30 바이트

온라인으로 사용해보십시오 (27 바이트 버전)

첫 번째 시도 (30 바이트) : GCC에서 3 진수로 값이 선언되지 않으면 조건부 값이 반환된다는 사실을 남용합니다. 그러므로 왜 제 삼항 연산자가 진실 반환 값을 위해 비어 있습니까?

두 번째 시도 (29 바이트) : 내가 이해하는 한 함수에 반환 값이 없으면 두 개 이상의 변수가 함수에 의미있게 사용 된 경우 첫 번째 인수 변수의 마지막 설정 값인 GCC의 메모리 버그 가 남습니다. 반환됩니다.
   (편집 : 그러나이 "설정 값"은 ​​특정 방식으로 설정해야합니다 (예 : 변수 설정 =또는 +=작동하지만 설정 %=하지 않음)

세 번째 시도 (27 바이트) : 위에서 언급 한 메모리 버그를 올바르게 악용하기 위해 두 번째 변수 (b)를 의미있게 사용해야하므로 대체를 위해 "10"에 대한 실제 변수로 사용할 수도 있습니다.
   (참고 : 나는 스왑 할 수 있어야 a=a%b로 a%=b, 다른 바이트를 저장할하지만 불행히도이 메모리 버그는 "작업"정지 위 악용 원인이 그럴 수)

망막 , 7 6 바이트

!`.0*$

온라인으로 사용해보십시오 (모든 테스트 사례)

입력 문자열 끝에 숫자와 그 뒤에 0이 출력됩니다. 필수는 아니지만이 기능도 작동합니다 0.

Cubix , 18 32 바이트

나는 나중에 이것에 대해 시간을 보내고 그것을 조금 압축 할 수 있는지보아야한다고 생각합니다. 그러나 지금 여기 있습니다.
내가 이것에 대해 완전히 잘못 생각하고있는 것으로 나타났습니다. 이제 프로세스는 입력 정수에 mod (1,10,100,1000, ...)를 점진적으로 적용하고 0이 아닌 첫 번째를 인쇄합니다. 조금 더 지루하지만 짧습니다.

!N%*I1^\.u;u@O\;;r

여기 사용해보십시오

    ! N
    % *
I 1 ^ \ . u ; u
@ O \ ; ; r . .
    . .
    . .

자바 스크립트, 21 바이트

f=n=>n%10||10*f(n/10)

테스트 사례

f=n=>n%10||10*f(n/10)

console.log(f(1   )); //  1
console.log(f(2   )); //  2
console.log(f(10  )); //  10
console.log(f(29  )); //  9
console.log(f(99  )); //  9
console.log(f(1020)); //  20

자바 스크립트 19 18 바이트

1 바이트 골프를위한 ETHproductions와 2 바이트 골프를위한 Patrick Roberts 덕분에

x=>x.match`.0*$`

입력 문자열의 끝에있는 정규식과 일치하는 문자열 배열을 반환합니다. 그 뒤에는 가능한 많은 수의 0이 오는 문자가 있습니다.

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

배쉬 + coreutils, 12

grep -o .0*$

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

Grime , 5 바이트

d\0*e

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

설명

       Find the longest substring of the input matching this pattern:
d      a digit, then
 \0*   zero or more 0s, then
    e  edge of input (which is handled as an Nx1 rectangle of characters).

Brachylog , 2 바이트

a₁

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

a₁정수의 경우 붙박이 내장 은 다음과 같이 구현됩니다.

brachylog_adfix('integer':1, 'integer':0, 'integer':0).
brachylog_adfix('integer':1, 'integer':I, 'integer':P) :-
    H #\= 0,
    H2 #\= 0,
    abs(P) #=< abs(I),
    integer_value('integer':Sign:[H|T], I),
    integer_value('integer':Sign:[H2|T2], P),
    brachylog_adfix('integer':1, [H|T], [H2|T2]).

Brachylog는 정수를 자릿수 목록으로 취급 할 수 있기를 원하며,이를 위해 사용자 정의 유틸리티 술어를 사용합니다 integer_value/2. 여기서 흥미로운 점은 integer_value/2앞에 오는 0으로 숫자 목록을 올바르게 번역 할 수 있어야하기 때문에 정수를 앞에 0이있는 숫자 목록으로 변환 할 수 있다는 것입니다. (대부분의 경우, 특히 와 같은 다른 것들은 a) 숫자 목록의 머리가 0이되는 것을 금지합니다. 따라서 a₁목록과 문자열에 대해 가장 짧은 접미사 를 생성 하는 동안 앞에 0 이있는 정수의 접미사를 건너 뜁니다. 중복을 제거하는 것 외에도 생성 된 첫 번째 접미사는 모든 후행 0이있는 가장 오른쪽이 아닌 숫자입니다.

Brain-Flak , 74 바이트

{({}<>)<>}(()){{}<>(({}<>)[((((()()()){}){}){}){}]<(())>){((<{}{}>))}{}}{}

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

마지막 0이 아닌 모든 후행 0 만 인쇄합니다.

설명:

{({}<>)<>}                    # Move everything to the other stack (reverse the input)
(())                          # Push a 1 to get started
{                             # do...
  {}<>                        #   pop the result of the equals check (or initial 1)
  (                           #   push...
    ({}<>)                    #     the top value from the other stack (also put this on the stack)
    [((((()()()){}){}){}){}]  #     minus the ASCII value of 0
    <(())>                    #     on top of a 1
  )                           #   close the push   
  {                           #   if not zero (ie. if not equal)
    ((<{}{}>))                #     replace the 1 from 3 lines back with a 0
  }{}                         #   end if and pop the extra 0
}                             # while the copied value != "0"
{}                            # pop the result of the equals check

Vim, 19 바이트

두 가지 버전 모두 19 바이트 :

:s/\v.*([^0]0*)/\1
:s/.*\([^0]0*\)/\1

그리고 각각에 후행 캐리지 리턴.

모든 테스트 사례를 온라인으로 확인하십시오! (여러 줄에서 테스트하기 위해 1 바이트 추가)

TI 기본, 18 바이트

If fPart(.1Ans
Return
Ans.1
prgmA
10Ans

R, 33 바이트

명명되지 않은 함수로 구현

function(x)rle(x%%10^(0:99))$v[2]

이것은 10 ^ 0에서 10 ^ 99까지의 모드를 적용합니다. rle두 번째 항목이 항상 원하는 결과가되도록 결과를 줄이는 데 사용됩니다.
온라인으로 사용해보십시오!

Zsh , 18 16 바이트

<<<${(M)1%[^0]*}

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

배쉬 , 25 바이트

r=${1%[^0]*}
echo ${1#$r}

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

쉘은 정규식을 사용하기 위해 외부 프로그램을 호출해야하므로 globbing과 관련이 있습니다.

${1%[^0]*}확장 0이 아닌 문자로 시작하는 짧은 접미사와 일치하고 제거합니다.

• Zsh에서 (M)플래그를 추가하면 일치하는 접미사가 제거되지 않고 유지됩니다.
• Bash에서 ${1% }확장은 남아있는 것을 접두사로 제거합니다.

GNU sed , 17 14 + 1 (r 플래그) = 15 바이트

편집 : Riley 덕분에 2 바이트 감소

s:.*([^0]):\1:

0이 아닌 가장 오른쪽 자리까지 모든 것을 삭제 한 다음 기존의 후행 0과 함께 인쇄합니다. 이 스크립트는 한 번의 실행으로 각각 별도의 줄에 여러 테스트를 처리 할 수 ​​있습니다.

온라인으로 사용해보십시오! (모든 테스트 예)

Mathematica, 26 바이트

자릿수 목록을 가져와 자릿수 목록을 출력하는 순수 함수 :

#/.{___,x_,y:0...}:>{x,y}&

설명

#                           First argument
 /.                           Replace
   {                              start of list followed by
    ___,                          zero or more elements followed by
        x_,                       an element (referred to later as x) followed by
           y:0...                 a sequence of zero or more 0s (referred to later as y) followed by
                 }                end of list
                  :>            with
                    {x,y}         {x,y}
                         &   End of function.

이것은에 대한 가장 왼쪽 일치 항목을 찾으므로 작동 x합니다. 목록의 가장 오른쪽에 0이 아닌 요소가 있어야합니다. 그 뒤에는 0 이상의 시퀀스 0가 있고 목록의 끝이옵니다.

자바 8, 47 바이트

이것은 다음에 할당 할 수있는 람다 식입니다 IntUnaryOperator.

x->{int m=1;for(;x%m<1;m*=10);return x%m*m/10;}

설명 : x%m0 return x%m*m/10이 될 때까지 m에 10을 곱 합니다. m은 원하는 결과보다 10 배 더 크기 때문에 나눗셈이 필요합니다.

펄 6 , 10 바이트

{+m/.0*$/}

사소한 정규식 솔루션. 숫자를 입력하고 출력합니다.

MATL , 10 7 바이트

@B 덕분에 3 바이트가 절약되었습니다 . 메타!

tfX>Jh)

입력과 출력은 숫자 배열입니다.

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

또는 모든 테스트 사례를 확인하십시오. .

설명

t     % Input string implicitly. Duplicate
f     % Push indices of non-zero digits
X>    % Keep maximum, say k
Jh    % Attach 1j to give [k, 1j]. This is interpreted as an index "k:end"
)     % Index into original string. Display implcitly

C #, 30 28 바이트

이 JavaScript 답변을 기반으로 하므로 모든 크레딧이 그에게 가까워집니다.

골프

i=a=>a%10<1?10*i(a/10):a%10;

• Emigna 덕분에 ()주변 을 제거하여 -2 바이트a

J, 27 바이트

10&|`(10*(p%&10))@.(0=10&|)

그것은 xnor의 공식을 기반으로하므로 그에게 신용합니다.

코 틀린, 49 바이트

람다 (List<Int>) -> List<Int>

{a->a.slice(a.indexOfLast{it in 1..9}..a.size-1)}

• 암시 적 매개 변수 이름 it에indexOfLast
• .. 건물 범위

펄 5, 12 바이트

11 -nE대신 1을 더한 값-e

say/(.0*$)/

05AB1E , 9 바이트

RD0Ê1k>£R

온라인으로 사용해보십시오! 또는 테스트 스위트

설명

R          # reverse input
 D         # duplicate
  0Ê       # check each for inequality with 0
    1k     # get the index of the first 1
      >    # increment
       £   # take that many digits from the input
        R  # reverse

Japt , 6 바이트

f".0*$

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

Stax , 5 바이트

æΩ$3╚

실행 및 디버깅

순서:

1. "다중성 (multiplicity)"을 10으로 계산하십시오.
2. 1을 더하십시오.
3. 오른쪽에서 많은 문자를 입력하십시오 (문자열로 입력).

05AB1E , 4 바이트

ĀÅ¡θ

숫자 목록으로서의 I / O.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 (테스트 스위트에는 가독성을 높이기위한 조인이 포함되어 있습니다).

설명:

Ā     # Python-style truthify each digit in the (implicit) input-list (0 if 0; 1 if [1-9])
      #  i.e. [9,0,4,0,3,0,0] → [1,0,1,0,1,0,0]
 Å¡   # Split the (implicit) input-list on truthy values (1s)
      #  i.e. [9,0,4,0,3,0,0] and [1,0,1,0,1,0,0] → [[],[9,0],[4,0],[3,0,0]]
   θ  # And only leave the last inner list
      #  i.e. [[],[9,0],[4,0],[3,0,0]] → [3,0,0]
      # (after which it is output implicitly as result)

파이크, 13 11 10 바이트

`1QY0mN%e>

여기 사용해보십시오!

  QY       -     digits(input)
    0mN    -    map(^, i != 0)
 1     %   -   indecies(^, i == 1)
        e  -  ^[-1]
`        > - str(input)[^:]

11 바이트 :

`D\0mN1R%e>

여기 사용해보십시오!

13 바이트 :

`D\0mN_1R@_t>

여기 사용해보십시오!

하스켈 57 바이트

f(x:s)a|x=='0'=f s$'0':a|1>0=x:a
t x=f(reverse.show$x)[]

Input    -> Output
t 120    -> "20"
t 30200  -> "200"