Ở Nga, chúng tôi có một cái gì đó giống như một truyền thống: chúng tôi muốn tìm kiếm vé may mắn.

Đây là một vé thông thường trông như thế nào:

Như bạn có thể thấy, vé có một số có sáu chữ số.

Một số có sáu chữ số được coi là may mắn nếu tổng của ba chữ số đầu tiên bằng tổng của ba chữ số cuối.

Con số trên bức ảnh không may mắn:

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

Thử thách

Đưa ra các giới hạn của một phạm vi (đã bao gồm), trả về số lượng vé may mắn có trong đó.

Thông số

• Đầu vào: 2 số nguyên: số nguyên đầu tiên và số nguyên cuối cùng trong phạm vi
• Các đầu vào sẽ nằm trong khoảng từ 0 đến 999999
• Đầu ra: 1 số nguyên: có bao nhiêu số may mắn trong phạm vi
• Bạn có thể lấy đầu vào và trả lại đầu ra ở bất kỳ định dạng nào được chấp nhận
• Giả sử các số 0 đứng đầu cho các số nhỏ hơn 100000.

Ví dụ

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

Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất tính bằng byte trong mọi ngôn ngữ sẽ thắng.

Cập nhật: đây là người may mắn

05AB1E , 8 (hoặc 10?) 11 (hoặc 13?) Byte

Ÿʒ₄n+¦S3ôOË

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

LƯU Ý: Trong các chuỗi và số nguyên 05AB1E có thể hoán đổi cho nhau, vì vậy các số đầu ra không chứa các số 0 đứng đầu. Tuy nhiên, điều này có thể được sửa với 1 byte bổ sung ( 12 byte ):

Ÿ₄n+€¦ʒS3ôOË

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

+3 byte cho các số sửa lỗi với độ dài từ 3 trở xuống (phạm vi [000000, 000999]).

Giải trình:

Ÿ          # 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

EDIT: Có vẻ như tôi (và hầu hết các câu trả lời khác) hơi hiểu sai về thách thức và số lượng số đang được hỏi thay vì chính các số trong phạm vi. Trong trường hợp đó, }gcó thể thêm một dấu vết (đóng bộ lọc và lấy số lượng còn lại trong danh sách được lọc), vì vậy, thay vào đó là 10 13 byte :

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

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

C # (.NET Core) , 93 + 18 = 111 byte

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])

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

18 byte cho using System.Linq;. Tôi cho rằng các định dạng đầu vào và đầu ra có thể linh hoạt. Vì vậy, tôi lấy hai số nguyên làm đầu vào (phạm vi, bao gồm).

Một số kết quả kiểm tra:

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)

JavaScript (ES6), 66 byte

Đưa đầu vào theo cú pháp currying (m)(n), trong đó m là giới hạn trên bao gồm độc quyền và n là giới hạn dưới bao gồm.

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

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

Làm sao?

Chúng tôi kiểm tra từng số bằng cách duyệt qua các chữ số của nó d i và cập nhật tổng số t :$n$$d_i$$t$

• nếu có ít nhất 3 chữ số còn lại sau chữ số này$t \gets t - d_i$
• khác$t \gets t + d_i$

Nếu chúng ta có ở cuối quá trình, thì n là một con số may mắn.$t=0$$n$

JavaScript (ES6), 67 byte

Định dạng đầu vào giống nhau.

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

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

Làm sao?

$n$

• $1000$38937 --> 38.937
• ép buộc thành một chuỗi và phân chia: ['3','8','.','9','3','7']
• tham gia với +:"3+8+.+9+3+7"
• thay thế +.bằng ^:"3+8^+9+3+7"
• $0$24$11$$19$

$n \equiv 0 \pmod{1000}$$n=0$

Ruby , 56 54 byte

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

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

Phương pháp:

1. Đối với mỗi số, tạo một mảng các chữ số (đi ra đảo ngược)
2. So sánh tổng của 3 chữ số đầu tiên trong mảng (3 chữ số cuối cùng) nhân với 2 với tổng của toàn bộ mảng
3. Đếm các số mà hai tổng bằng nhau

Japt , 38 15 byte

õV Ëì ò3n)mx r¥

-23 cảm ơn Shaggy!

Trình Japt đầu tiên của tôi; cảm ơn Shaggy vì tất cả sự giúp đỡ!

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

Python 3, 117 113 106 135 byte

Đây là câu trả lời đầu tiên của tôi từ trước đến giờ nên tôi chắc chắn có chỗ để cải thiệ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)

• -4 byte nhờ WW
• -7 byte nhờ Asone Tuhid
• +29 byte để tạo hàm

Lấy ba chữ số đầu tiên thông qua phép chia số nguyên và ba chữ số cuối thông qua modulo. Các số nguyên đầu tiên và cuối cùng trong phạm vi được nhập như các đối số của xhàm, như avà b, tương ứng. Đầu ra là n, in.

Ung dung:

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 byte

Logic ngắn hơn ở phần cuối lời khen của @ Giuseppe /

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

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

Đầu vào số nguyên. Pad chúng với 0. Chuyển đổi sang sáu điểm mã ASCII. Lạm dụng Fnội dung.

Husk , 12 byte

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

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

Giải trình

#(§¤=Σ↓↑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

Than , 15 byte

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

Hãy thử trực tuyến!Liên kết là phiên bản dài dòng của mã. Chỉnh sửa: Ban đầu tôi nghĩ rằng đó là danh sách các số may mắn được yêu cầu. Điều này có thể được thực hiện trong 14 byte (bằng cách loại bỏ Ｌ, mất độ dài của danh sách) hoặc 20 byte nếu bạn muốn một số định dạng đẹp:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

    ＮＮ                  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

Perl 5 +-pl -MList::Util+(sum) , 49 byte

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

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

Perl 5 + -nl -MList::Util+(sum) -M5.010, 50 byte

Để xuất ra mỗi vé thay vì là 1 byte:

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

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

Con trăn 3 , 89 86 byte

-2 cảm ơn ông Xcoder.

-3 truyền cảm hứng từ câu trả lời của Asone Tuhid.

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

Kết quả xét nghiệm:

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 

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

MATL , 24 byte

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

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

(-2 byte nhờ Luis Mendo.)

&: - Tạo một phạm vi bao gồm giữa hai số đã cho

1e3&\ - 'divrem' - chia cho 1000 và nhận các lời nhắc và chỉ tiêu nổi trong hai mảng.

, - làm hai lần

!'03d'&V - hoán chuyển và chuyển đổi từng giá trị thành chuỗi ba chiều rộng không đệm

&s - tổng các giá trị của mỗi hàng

w - chuyển sang đưa mảng nhắc nhở ra và làm lại từ đó

] - vòng lặp kết thúc

= - kiểm tra sự bằng nhau (trả về 1s ở những nơi mà các mảng bằng nhau)

s - tổng hợp những thứ đó để có được số đếm (đầu ra ngầm định)

Kotlin , 152 119 byte

{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()}

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

Lấy hai số nguyên hơn chuyển đổi nó thành sáu chuỗi ký hiệu và đếm.

Tối ưu hóa nó nhờ mazzy và giải pháp của anh ấy đến 119 byte.

{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')}}

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

dc , 44 byte

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

Đưa hai đối số từ ngăn xếp trống khác, xuất ra đầu ngăn xếp.

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

Một chút thông minh ở đây là việc sử dụng một macro không tên (nghĩa là chưa được bảo vệ) được sao chép trước khi thực hiện để chạy một bản sao của chính nó trên phần ba chữ số khác.

Giải trình

Macro bên trong [rA~rA~++rx]có tác dụng "tính tổng chữ số của số có ba chữ số đứng đầu trên ngăn xếp, sau đó thực hiện đỉnh ban đầu của ngăn xếp dưới dạng macro".

Chương trình chính:

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

Pascal (FPC) , 163 153 byte

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.

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

Giải trình

Đây là một số mã trông bình thường đầu tiên:

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.

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

Sau đó, tôi lạm dụng hành vi của vòng lặp for:

• các giá trị vòng lặp được đặt trước (từ ađến b), do đó acó thể được sử dụng lại làm biến vòng lặp, thả i;
• ở cuối vòng lặp for, biến vòng lặp được để lại ở giá trị cuối cùng (giá trị btrước vòng lặp). Tôi đã sử dụng blàm vật chứa, tăng nó khi tìm thấy số may mắn và ở cuối vòng lặp bcách xa giá trị cũ của nó bằng số lượng số may mắn, do đó b-acho kết quả chính xác. Điều này đã giảm s.

Thay thế dbằng các hoạt động trực tiếp trên arút ngắn vòng lặp. Thay thế cbằng các thao tác trực tiếp với aliều lượng không rút ngắn vòng lặp, nhưng, sau khi thả d, vòng lặpbegin và endkhông cần thiết và tôi đã kết thúc bằng cách chỉ sử dụng 2 biến :)

$bắt đầu hằng thập lục phân trong mã đánh gôn. Mặc dù chúng không lưu byte, nhưng chúng loại bỏ khoảng trắng cần thiết trước các hằng số thập phân.

Java (OpenJDK 8) , 162 byte

... mượn từ ví dụ về Kotlin ở trên.

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();

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

So sánh tổng số byte của Chuỗi cũng tốt như tổng các chữ số thực.

PHP , 131 byte

<?$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;

Để chạy nó:

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

Thí dụ:

php -n lucky_tickets.php 100 100000

Hoặc dùng thử trực tuyến!

Perl 6 , 51 49 byte

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

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

Khối mã ẩn danh lấy hai số và trả về số người may mắn. Hết thời gian cho đầu vào lớn hơn

Thạch ,  9  8 byte

-1 cảm ơn Dennis ( rµ...E)S-> r...E€Svì mọi thứ đều tăng.)

rdȷD§E€S

Một liên kết dyadic chấp nhận hai điểm cuối của phạm vi (một trong hai cách) mang lại số lượng vé may mắn.

Hãy thử trực tuyến! Hoặc xem một thử nghiệm

Làm sao?

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

Powershell, 85 byte

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

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

$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"
}

Đầu ra:

      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

Kotlin, 95 byte

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

.kt cho thử nghiệm:

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
}

Giải trình

Đếm các số từ phạm vi trong đó tổng của tất cả các chữ số bằng tổng hai lần của 3 chữ số đầu tiên.

Stax , 14 byte

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

Chạy và gỡ lỗi nó , nhưng hãy kiên nhẫn!

Python 2 ,  83  80 byte

-3 bằng cách sử dụng quan sát của Asone Tuhid - hãy ghi nhận!

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

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

Giống như câu trả lời Jelly của tôi (nhưng các đầu vào phải được sắp xếp ở đây tức là a<=b)

75 byte cho đầu vào a, b+1(tức là phạm vi loại trừ giới hạn bên phải):

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

Hãy thử cái này

Clojure, 102 byte

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

Trộn chuỗi và toán học không quá vui.

J , 35 byte

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

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

C (gcc), 90 88 byte

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

Cổng câu trả lời Java của tôi . Hãy thử trực tuyến tại đây . Nhờ trần nhà để chơi golf hai byte.

Ung dung:

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
}

Java 8, 101 99 byte

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

Một cách tiếp cận khác với câu trả lời Java khác . Thay vì sử dụng luồng và Chuỗi, điều này sử dụng một vòng lặp và đánh giá các con số trực tiếp. Dùng thử trực tuyến tại đây .

Nhờ vào trần nhà để chơi golf hai byte.

Ung dung:

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 byte

Sử dụng Cửa sổ ngay lập tức và các ô [A1] [A2]làm đầu vào.

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 byte

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

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

tchuyển đổi chuỗi thành số và tính tổng chúng. rlấy phạm vi các số từ sđến evà lọc ra các số không may mắn. Ba chữ số đầu tiên được thu thập bởi n/1000. Ba chữ số thứ hai được tính bằng n-(n/1000)*1000.