러시아에는 전통과 같은 것이 있습니다. 행운의 티켓을 찾는 것을 좋아합니다.

일반 항공권은 다음과 같습니다.

보시다시피 티켓에는 6 자리 숫자가 있습니다.

처음 세 자리의 합이 마지막 세 자리의 합과 같은 경우 6 자리 숫자는 운이 좋은 것으로 간주됩니다 .

사진의 숫자는 운이 좋지 않습니다.

038937
038 937
0 + 3 + 8 = 11
9 + 3 + 7 = 19
11 != 19

도전

범위 제한을 포함하여 (범위 포함) 그 안에 포함 된 행운의 티켓 번호 수를 반환합니다.

매개 변수

• 입력 : 2 개의 정수 : 범위의 첫 번째 정수와 마지막 정수
• 입력 값은 0에서 999999 사이입니다.
• 출력 : 1 정수 : 범위에있는 행운의 숫자 수
• 입력을 받아 허용되는 형식으로 출력을 반환 할 수 있습니다
• 100000보다 작은 숫자의 앞에 0을 가정하십시오.

예

0, 1 => 1
100000, 200000 => 5280
123456, 654321 => 31607
0, 999999 => 55252

이것은 코드 골프 이므로 모든 언어에서 가장 짧은 바이트 단위의 대답이 이깁니다.

업데이트 : 여기 행운의 것이 있습니다.

05AB1E , 8 (또는 10?) 11 (또는 13?) 바이트

Ÿʒ₄n+¦S3ôOË

온라인으로 시도 하거나 더 많은 테스트 사례를 확인 하십시오 .

참고 : 05AB1E에서 문자열과 정수는 서로 바꿔서 사용할 수 있으므로 출력 숫자에 선행 0이 포함되지 않습니다. 그러나 이것은 1 추가 바이트 ( 12 바이트) 로 고정 될 수 있습니다 ) .

Ÿ₄n+€¦ʒS3ôOË

온라인으로 사용해보십시오 하거나 더 많은 테스트 사례를 확인 .

길이가 3 이하인 버그 수정 번호에 +3 바이트 (범위) [000000, 000999] ).

설명:

Ÿ          # Create an inclusive (on both sides) range from the two inputs
           #  i.e. 038920 and 038910 → 
           #   [38910,38911,38912,38913,38914,38915,38916,38917,38918,38919,38920]
 ʒ         # Filter this list by:
  ₄n+      #  Add 1,000,000 to the number
     |     #  And remove the leading 1
           #   i.e. 38910 → 1038910 → '038910'
  S        #  Transform it to a list of digits
           #   i.e. '038910' → ['0','3','8','9','1','0']
   3ô      #  Split it into chunks of length 3
           #   i.e. ['0','3','8','9','1','0'] → [['0','3','8'],['9','1','0']]
     O     #  Sum the digits in both parts
           #   i.e. [['0','3','8'],['9','1','0']] → [11,10]
      Ë    #  Check if they are equal (if they are, they remain in the filtered list)
           #   i.e. [11,10] → 0

편집 : 나 (그리고 대부분의 다른 답변)가 도전을 약간 잘못 읽은 것으로 보이며 범위 내의 숫자 자체 대신 숫자의 양을 묻는 것입니다. 이 경우 후행 }g을 추가 할 수 있습니다 (필터를 닫고 필터링 된 목록에 남아있는 숫자의 양을 얻음). 대신 10 13 바이트입니다 .

Ÿʒ₄n+¦S3ôOË}g

온라인으로 시도 하거나 더 많은 테스트 사례를 확인 하십시오 .

C # (. NET 코어) , 93 + 18 = 111 바이트

a=>b=>Enumerable.Range(a,b-a+1).Select(e=>$"{e:D6}").Count(e=>e[0]+e[1]+e[2]==e[3]+e[4]+e[5])

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

18 바이트 using System.Linq;. 입력 및 출력 형식이 유연 할 수 있다고 가정했습니다. 그래서 두 개의 정수를 입력으로 사용합니다 (범위 포함).

일부 테스트 결과 :

a=1000
b=1100

Lucky numbers = 3 [001001, 001010, 001100]

a=2000
b=2100

Lucky numbers = 3 [002002, 002011, 002020]

a=222000
b=222100

Lucky numbers = 7 [222006, 222015, 222024, 222033, 222042, 222051, 222060]

a=0
b=999999

Lucky numbers = 55252 (that's 5.5% of the total numbers)

자바 스크립트 (ES6), 66 바이트

currying 구문에서 입력을 받습니다. (m)(n)여기서 m 은 배타적 상한값이고 n 은 배타적 인 하한값입니다.

m=>g=n=>n<=m&&![...n+=''].reduce((t,d,i)=>t-=n[i+3]?d:-d,0)+g(-~n)

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

어떻게?

우리 는 숫자 d i 를 걷고 총 t를 업데이트하여 각 숫자 을 테스트합니다 .$n$$d_i$$t$

• 이 뒤에 3 자리 이상의 숫자가 남아 있으면$t \gets t - d_i$
• 달리$t \gets t + d_i$

프로세스의 끝에 이 있으면 n 은 행운의 숫자입니다.$t=0$$n$

자바 스크립트 (ES6), 67 바이트

동일한 입력 형식.

m=>g=n=>n<=m&&!eval([...n/1e3+''].join`+`.split`+.`.join`^`)+g(n+1)

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

어떻게?

각 숫자 :$n$

• 나눕니다 : 예$1000$38937 --> 38.937
• 줄로 강제하고 분열 : ['3','8','.','9','3','7']
• 와 함께 +:"3+8+.+9+3+7"
• 대체 +.와 함께 ^:"3+8^+9+3+7"
• JS 코드로 평가하고 결과가 인지 테스트하십시오 . ( 11 XOR 19 )$0$24$11$$19$

n ≡ 0 인 경우 이면 소수점이 생성되지 않으며 n = 0 (truthy)이아닌 한 평가 된 표현식은 양의 합(거짓)입니다. 두 경우 모두 예상되는 결과입니다.$n \equiv 0 \pmod{1000}$$n=0$

루비 , 56 54 바이트

->a,b{(a..b).count{|i|j=i.digits;j[0,3].sum*2==j.sum}}

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

방법:

1. 모든 숫자에 대해 숫자의 배열을 만듭니다 (반대 됨)
2. 배열의 처음 3 자리 숫자 (숫자의 마지막 3)에 2를 곱한 값을 전체 배열의 합계와 비교합니다.
3. 두 합이 같은 수를 센다

apt , 38 15 바이트

õV Ëì ò3n)mx r¥

Shaggy에게 -23 감사합니다!

나의 첫번째 Japt 제출; 모든 도움을 주신 Shaggy에게 감사드립니다!

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

파이썬 3 117 113 106 135 바이트

이것은 나의 첫 번째 대답이므로 개선의 여지가 있다고 확신합니다.

def x(a,b):
    n=0
    for i in range(a,b+1):
        if sum(map(int,str(i//1000)))==sum(map(int,str(i%1000))):n+=1
    print(n)

• WW 덕분에 -4 바이트
• Asone Tuhid 덕분에 -7 바이트
• 함수를 생성하기위한 +29 바이트

정수 나누기를 통해 처음 세 자리를 가져오고 마지막 세 자리를 모듈로 통해 가져옵니다. 범위의 첫 번째 정수와 마지막 정수는 각각 xas a및 로 함수의 인수로 입력됩니다 b. 출력이 n인쇄됩니다.

언 골프 드 :

def x(a, b):
    n = 0
    for i in range(a, b + 1):
        if sum(map(int, str(i // 1000))) == sum(map(int, str(i % 1000))):
            n += 1
    print(n)

R , 93 86 바이트

@ Giuseppe /의 최종 칭찬에 더 짧은 논리

function(a,b){for(i in sprintf("%06d",a:b)){x=utf8ToInt(i);F=F+!sum(x[1:3]-x[4:6])}
F}

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

정수 입력. 로 채 웁니다 0. 6 개의 ASCII 코드 포인트로 변환하십시오. F내장을 남용하십시오 .

껍질 , 12 바이트

#ȯ§¤=Σ↓↑3↔d…

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

설명

#(§¤=Σ↓↑3↔d)…  -- example input: 100000 101000
            …  -- inclusive range: [100000,100001..100999,101000]
#(         )   -- count elements where (example with 100010)
          d    -- | digits: [1,0,0,0,1,0]
         ↔     -- | reversed: [0,1,0,0,0,1]
  §     3      -- | fork elements (3 and [0,1,0,0,0,1])
       ↑       -- | | take: [0,1,0]
      ↓        -- | | drop: [0,0,1]
   ¤=          -- | > compare the results by equality of their
     Σ         -- | | sums 1 == 1
               -- | : 1
               -- : 3

숯 , 15 바이트

ＩＬΦ…·ＮＮ⁼Σι⊗Σ÷ιφ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 : 나는 원래 그것이 필요한 행운의 숫자 목록이라고 생각했습니다. 이것은 14 바이트 ( Ｌ목록의 길이를 취하는를 제거하여 ) 또는 멋진 포맷을 원한다면 20 바이트로 수행 할 수 있습니다.

ＥΦ…·ＮＮ⁼Σι⊗Σ÷ιφ﹪%06dι

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

    ＮＮ                  Input the range endpoints
  …·                    Inclusive range
 Φ                      Filter
        ι               Current value
       Σ                Sum of digits
            ι           Current value
             φ          Predefined variable 1000
           ÷            Integer divide
          Σ             Sum of digits
         ⊗              Doubled
      ⁼                 Equals
Ｅ                       Map over results
                   ι    Current value
               %06d     Literal string
              ﹪         Format value
                        Implicitly print each result on its own line

펄 5 + -pl -MList::Util+(sum), 49 바이트

@F=/./g,$\+=sum@F[5,4,3]==sum@F[2,1,0]for$_..<>}{

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

펄 5 + -nl -MList::Util+(sum) -M5.010, 50 바이트

각 티켓을 대신 출력하는 것은 +1 바이트입니다.

@F=/./g,sum@F[5,4,3]-sum(@F[2,1,0])||say for$_..<>

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

파이썬 3 , 89 86 바이트

Xcoder 씨에게 -2 감사합니다.

Asone Tuhid의 답변에서 -3 영감.

lambda a,b:sum(sum(map(int,str(i)))==2*sum(map(int,str(i)[-3:]))for i in range(a,b+1))

테스트 결과 :

Example 1 : 
a = 0
b = 1
Lucky numbers : 1 

Example 2 : 
a = 100000
b = 200000
Lucky numbers : 5280 

Example 3 : 
a = 123456
b = 654321
Lucky numbers : 31607 

Example 3 : 
a = 0
b = 999999
Lucky numbers : 55252 

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

MATL , 24 바이트

&:1e3&\,!'%03d'&V2&sw]=s

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

(Luis Mendo 덕분에 2 바이트)

&: -주어진 두 숫자 사이에 포함 범위를 만듭니다.

1e3&\ - 'divrem'-1000으로 나누고 미리 알림과 바닥 몫을 두 배열로 가져옵니다.

, -두 번 해

!'03d'&V -각 값을 0으로 채워진 3 너비 문자열로 바꾸고 변환하십시오.

&s -각 행의 값을 합산

w -리마인더 배열을 꺼내고 다시 시도하십시오.

] -엔드 루프

= -평등을 확인하십시오 (배열이 같은 곳에서 1을 반환합니다)

s -개수를 구할 수있는 합계 (암시 적 출력)

코 틀린 , 152 119 바이트

{a:Int,b:Int->(a..b).map{String.format("%06d",it)}.filter{it[0].toInt()+it[1].toInt()+it[2].toInt()==it[3].toInt()+it[4].toInt()+it[5].toInt()}.count()}

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

6 개의 기호 문자열로 변환하고 카운트하는 것보다 2 개의 정수를 사용합니다.

mazzy와 119 바이트에 대한 그의 솔루션 덕분에 최적화되었습니다 .

{a:Int,b:Int->(a..b).count{val d="%06d".format(it);(d[0]-'0')+(d[1]-'0')+(d[2]-'0')==(d[3]-'0')+(d[4]-'0')+(d[5]-'0')}}

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

dc , 44 바이트

sb[d]sD[dA00~[rA~rA~++rx]dx=D1+dlb!<L]dsLxkz

비어있는 스택에서 두 개의 인수를 가져 와서 스택 맨 위에 출력합니다.

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

여기서 영리한 비트는 다른 세 자리 부분에서 자체 복사본을 실행하기 위해 실행 전에 복제되는 명명되지 않은 (즉, 저장되지 않은) 매크로를 사용하는 것입니다.

설명

내부 매크로 [rA~rA~++rx] 는 "스택에서 2 위에있는 3 자리 숫자의 자릿수를 계산 한 다음 스택의 원래 맨 위를 매크로로 실행"하는 효과가 있습니다.

메인 프로그램 :

sb             Saves the upper bound as b so we'll know when to quit
[d]sD          Defines the macro D, which contextually is "increment stack depth"
[              Start the main loop - the next number to test is on top 
  d              Make a copy to increment later for loop purposes
  A00            The literal "1000"
  ~              Quotient and remainder, so "123456" is now "123 456"
  [rA~rA~++rx]d  Stack is now "123 456 M M", where M is the anonymous macro
  x              Run M on the stack "123 456 M", which (see definition 
                 above) ends up running M on the stack "123 15", which
                 leaves "15 6" (and executes the 6, which is a no-op)
  =D             If the two sums were equal, increment the stack depth
  1+             Increment the current test number
  dlb!<L         Loop unless the test number is now larger than b
]dsLx          Name and start the loop
kz             Current depth is 1+answer, so throw away top and return

파스칼 (FPC) , 163153 바이트

var a,b:Int32;begin read(a,b);for a:=a to b do if a div$186A0+a div$2710mod$A+a div$3E8mod$A=a div$64mod$A+a div$Amod$A+a mod$Athen b:=b+1;write(b-a)end.

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

설명

다음은 정상적으로 보이는 코드입니다.

var a,b,i,s,c,d:Int32;
begin
  read(a,b);
  s:=0;
  for i:=a to b do begin
    c:=i div 1000;
    d:=i mod 1000;
    if c div 100+(c div 10) mod 10+c mod 10=d div 100+(d div 10) mod 10+d mod 10 then begin s:=s+1; {writeln(i)} end;
  end;
  write('There are ',s,' numbers');
end.

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

그런 다음 for 루프의 동작을 남용했습니다.

• 루프 값은 미리 설정 되어 있으므로 (에서 a~까지 b) a루프 변수로 재사용 할 수 있습니다.i .
• for 루프의 끝에서 루프 변수는 최종 값 ( b루프 이전의 값 )으로 유지됩니다. b컨테이너로 사용 하여 운이 좋은 숫자가 발견되고 루프의 끝 b에서 운이 좋은 숫자의 양으로 이전 값에서 멀어지면 증가하므로 b-a올바른 결과를 제공합니다. 이것은 떨어졌다 s.

d직접 작동으로 교체 a하면 루프가 단축됩니다. 선량으로 c직접 작업을 교체 a하면 루프가 단축되지는 않지만 떨어 뜨린 후 d루프 begin및end 필요하고 나는 단지이 변수를 사용하여 종료 :)

$골프 코드에서 16 진 상수를 시작합니다. 바이트를 저장하지 않지만 10 진 상수 앞에 필요한 공백을 제거합니다.

자바 (OpenJDK 8) , 162 바이트

... 위의 Kotlin 예제에서 빌립니다.

import java.util.stream.IntStream;

(a,b)->IntStream.range(a,b+1).mapToObj(i->String.format("%06d",i).getBytes()).filter(c->c[0]+c[1]+c[2]==c[3]+c[4]+c[5]).count();

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

문자열의 바이트 합계를 비교하는 것은 실제 숫자를 합산하는 것만 큼 좋습니다.

PHP , 131 바이트

<?$f='array_sum(str_split(str_split(sprintf("%06d",$i),3)[';for($i=$argv[1]-1;$i++<$argv[2];)eval("\$a+=$f 0]))==$f 1]));");echo$a;

그것을 실행하려면 :

php -n <filename> <from> <to>

예:

php -n lucky_tickets.php 100 100000

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

펄 6 , 51 49 바이트

{+grep {[==] .flip.comb[^3,3..*]>>.sum},$^a..$^b}

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

두 개의 숫자를 사용하고 행운의 숫자를 반환하는 익명 코드 블록. 더 큰 입력 시간 초과

젤리 ,  9  8 바이트

Dennis 덕분에 -1 ( 모든 것이 벡터화되었으므로 rµ...E)S-> r...E€S)

rdȷD§E€S

운이 좋은 티켓의 수를 산출하는 범위의 두 끝점 (둘 중 어느 쪽이든)을 허용하는 2 진 링크.

온라인으로 사용해보십시오! 아니면 참조 테스트 스위트를

어떻게?

음이 아닌 정수보다 작은 $1000000$, $N$정수 나누기를 사용하여 확인하는 데 필요한 값을 합한 숫자가있는 두 개의 숫자를 얻을 수 있습니다. $1000$
(수확, 말하기, $X=\lfloor\frac{N}{1000}\rfloor$)
및 나머지
(예 :$Y=N\mod{1000}$)
... 즉,$N=1000\times X+Y$

자릿수의 합을 비교하고 싶습니다 $X$ 과 $Y$ 각각 $N$ 범위 내에서 동일한 것을 계산하십시오.

rdȷD§E€S - Link: integer a; integer b
r        - inclusive range [a,b] (either [a,a+1,a+2,...,b] or [a,a-1,a-2,...,b])
         -                              e.g.: 0       or 78        or 7241
  ȷ      - literal 1000
 d       - divmod (vectorises)                [0,0]      [0,78]       [7,241]
   D     - to decimal lists (vectorises)      [[0],[0]]  [[0],[7,8]]  [[7],[2,4,1]]
    §    - sum each (vectorises)              [0,0]      [0,15]       [7,7]
     E€  - for €ach: all equal?               1          0            1
       S - sum (counts the 1s in the resulting list)

파워 쉘, 85 바이트

($args[0]..$args[1]|%{'{0:D6}'-f$_}|?{+$_[0]+$_[1]+$_[2]-eq+$_[3]+$_[4]+$_[5]}).count

테스트 스크립트 :

$f = {

($args[0]..$args[1]|%{'{0:D6}'-f$_}|?{+$_[0]+$_[1]+$_[2]-eq+$_[3]+$_[4]+$_[5]}).count

}

@(
    ,((0,1), 1)
    ,((1000,2000), 3)
    ,((2000,3000), 6)
    ,((10000, 20000), 282)
    ,((101000, 102000), 6)
    ,((201000, 202000), 10)
    ,((901000, 902000), 63)
    ,((100000, 200000), 5280)
    ,((123456, 654321), 31607)
    #,((0, 999999), 55252)
) | % {
    $c, $e = $_
    "      $c"
    $r = &$f $c[0] $c[1]
    "$($e-eq$r): actual=$r expected=$e"
}

산출:

      0 1
True: actual=1 expected=1
      1000 2000
True: actual=3 expected=3
      2000 3000
True: actual=6 expected=6
      10000 20000
True: actual=282 expected=282
      101000 102000
True: actual=6 expected=6
      201000 202000
True: actual=10 expected=10
      901000 902000
True: actual=63 expected=63
      100000 200000
True: actual=5280 expected=5280
      123456 654321
True: actual=31607 expected=31607

코 틀린, 95 바이트

{a:Int,b:Int->(a..b).count{val d="%06d".format(it);d.chars().sum()==2*d.take(3).chars().sum()}}

.kt 테스트를 위해 :

var  f = {a:Int,b:Int->(a..b).count{val d="%06d".format(it);d.chars().sum()==2*d.take(3).chars().sum()}}

fun main(args: Array<String>) {
    println(f(0,1))             // 1
    println(f(1000,2000))       // 3
    println(f(2000,3000))       // 6
    println(f(101000, 102000))  // 6
    println(f(201000, 202000))  // 10
    println(f(901000, 902000))  // 63
    println(f(10000, 20000))    // 282
    println(f(100000, 200000))  // 5280
    println(f(123456, 654321))  // 31607
    println(f(0, 999999))       // 55252
}

설명

모든 숫자 자릿수의 합이 처음 3 자릿수의 두 배 합과 같은 범위에서 숫자를 계산합니다.

Stax , 14 바이트

ît║l`Yµß╖vYü╢^

실행하고 디버그 하지만 인내심을 가지십시오!

파이썬 2 ,  83  80 바이트

Asone Tuhid의 관찰을 사용하여 -3- 가자!

lambda a,b:sum(sum(map(int,`v/1000`))*2==sum(map(int,`v`))for v in range(a,b+1))

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

내 젤리 대답 같은 많은 (하지만 입력은 즉, 여기에 분류되어야한다 a<=b)

입력을위한 75 바이트a, b+1 (즉, 범위는 오른쪽 경계를 제외 함) :

lambda*r:sum(sum(map(int,`v/1000`))*2==sum(map(int,`v`))for v in range(*r))

이걸로 해봐

클로저, 102 바이트

#(count(for[i(range %(inc %2)):when(=(let[d(map int(format"%06d"i))](apply +(map -(drop 3 d)d)))0)]i))

문자열과 수학을 혼합하는 것은 그리 재미 있지 않습니다.

J , 35 바이트

[:+/(6#10)([:=/_3+/\])@#:[+i.@>:@-~

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

C (gcc), 90 88 바이트

l=10;u(c,k,y){for(y=0;c<=k;)c++%l+c/l%l+c/100%l-c/1000%l-c/10000%l-c/100000%l?:++y;c=y;}

내 자바 답변 포트 . 여기에서 온라인으로 사용해보십시오 . 2 바이트 골프를위한 실링 캣 덕분 입니다.

언 골프 드 :

l=10; // constant, we will be using the number 10 rather a lot
u(c, k, // function returning an integer and taking two integer arguments: lower and upper bound
  y) { // abusing the argument list to declare a variable of type integer: the number of lucky tickets found in the range
    for(y = 0; c <= k; ) // set count to 0 and loop through the range
        c++ %l + c/l %l + c/100 %l // if the digit sum of the second half of the ticket number ...
        - c/1000 %l - c/10000 %l - c/100000 %l // ... is the same as the digit sum of the first half ...
        ?: ++y; // ... it's a lucky ticket: increment the count
    c = y; // return the count
}

자바 8, 101 99 바이트

u->l->{int n=0,d=10;for(;l<=u;)if(l++%d+l/d%d+l/100%d==l/1000%d+l/10000%d+l/100000%d)++n;return n;}

다른 Java 답변과 다른 접근 방식 . 스트림과 문자열을 사용하는 대신 루프를 사용하여 숫자를 직접 평가합니다. 온라인으로 사용해보십시오여기에서 .

2 바이트 골프를위한 실링 캣 덕분 입니다.

언 골프 드 :

u -> l -> { // lambda taking two integer arguments in currying syntax and returning an integer
    int n = 0, // the counter
        d = 10; // auxiliary constant, we will be using the number 10 rather a lot
    for(; l <=u ; ) // loop over all ticket numbers in the range
        if(l++ %d + l/d %d + l/100 %d // if the digit sum of the second half of the number ...
           == l/1000 %d + l/10000 %d + l/100000 %d) // ... is the same as the digit sum of the first half ...
            ++n; // ... it's a lucky ticket, add 1 to the counter
    return n; // return the count
}

VBA (Excel), 159 바이트

직접 창 및 셀 [A1] [A2]을 입력으로 사용

c=[A1]-[A2]:d=IIf(c<0,[A1],[A2]):For x=d To d+Abs(c):e=String(6-Len(x),"0")&x:For y=1To 3:i=i+Mid(e,y,1):j=j+Mid(e,7-y,1):Next:z=IIf(i=j,z+1,z):i=0:j=0:Next:?z

F #, 110 바이트

let t=string>>Seq.sumBy(int>>(-)48)
let r s e=Seq.where(fun n->t(n/1000)=t(n-(n/1000)*1000)){s..e}|>Seq.length

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

t문자열을 숫자로 변환하고 합산합니다. r에서 s~ 사이 의 숫자 범위를 취하고 e불행한 숫자를 필터링합니다. 처음 세 자리 숫자는에 의해 수집됩니다 n/1000. 두 번째 세 자리는로 계산됩니다 n-(n/1000)*1000.