ในรัสเซียเรามีประเพณี: เราชอบมองหาตั๋วนำโชค

นี่คือลักษณะของตั๋วทั่วไป:

อย่างที่คุณเห็นตั๋วมีตัวเลขหกหลัก

ตัวเลขหกหลักถือว่าโชคดีถ้าผลรวมของสามหลักแรกเท่ากับผลรวมของสามหลักสุดท้าย

หมายเลขในรูปภาพไม่ได้โชคดี:

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

ท้าทาย

เมื่อได้รับข้อ จำกัด ของช่วง (รวม) แล้วส่งคืนหมายเลขของหมายเลขบัตรโชคดีที่อยู่ภายใน

พารามิเตอร์

• อินพุต: 2 จำนวนเต็ม: จำนวนเต็มแรกและสุดท้ายในช่วง
• อินพุตจะอยู่ระหว่าง 0 ถึง 999999
• เอาท์พุท: 1 จำนวนเต็ม: จำนวนโชคดีอยู่ในช่วง
• คุณสามารถรับอินพุตและส่งคืนเอาต์พุตในรูปแบบที่ยอมรับได้
• สมมติว่าเลขศูนย์นำหน้าสำหรับตัวเลขที่น้อยกว่า 100,000

ตัวอย่าง

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

นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดเป็นไบต์ในทุกภาษาที่ชนะ

Update: นี่คือสิ่งที่โชคดี

05AB1E , 8 (หรือ 10?) 11 (หรือ 13?) ไบต์

Ÿʒ₄n+¦S3ôOË

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบบางมากขึ้น

หมายเหตุ: ในสตริง 05AB1E และจำนวนเต็มสามารถใช้แทนกันได้ดังนั้นตัวเลขเอาต์พุตจึงไม่มีเลขศูนย์นำหน้า อย่างไรก็ตามสามารถแก้ไขได้ด้วย 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 Core) , 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)

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

ลองออนไลน์!

อย่างไร?

เราทดสอบแต่ละหมายเลขโดยเดินผ่านตัวเลขของวันที่ฉันและการปรับปรุงรวมเสื้อ :$n$$d_i$$t$

• ถ้ามีอย่างน้อย 3 หลักที่เหลือหลังจากนี้$t \gets t - d_i$
• อย่างอื่น$t \gets t + d_i$

หากเรามีในตอนท้ายของกระบวนการดังนั้นnคือเลขนำโชค$t=0$$n$

JavaScript (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 = $n \equiv 0 \pmod{1000}$$n=0$

Ruby , 56 54 ไบต์

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

ลองออนไลน์!

วิธี:

1. สำหรับทุกหมายเลขสร้างอาร์เรย์ของตัวเลข (ซึ่งออกมาตรงกันข้าม)
2. เปรียบเทียบผลรวมของ 3 หลักแรกในอาร์เรย์ (3 สุดท้ายในจำนวน) คูณด้วย 2 กับผลรวมของทั้งอาร์เรย์
3. นับจำนวนที่ผลบวกทั้งสองเท่ากัน

Japtap , 38 15 ไบต์

õV Ëì ò3n)mx r¥

-23 ขอบคุณ Shaggy!

การส่ง Japt ครั้งแรกของฉัน; ขอบคุณ Shaggy สำหรับความช่วยเหลือทั้งหมด!

ลองออนไลน์!

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

• -4 ไบต์ขอบคุณ WW
• -7 ไบต์ขอบคุณ Asone Tuhid
• +29 ไบต์เพื่อสร้างฟังก์ชั่น

รับตัวเลขสามหลักแรกผ่านการหารจำนวนเต็มและสามหลักสุดท้ายผ่าน modulo จำนวนเต็มแรกและสุดท้ายในช่วงจะถูกป้อนเป็นอาร์กิวเมนต์ของxฟังก์ชันตามaและbตามลำดับ เอาท์พุทเป็นnพิมพ์

Ungolfed:

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}

ลองออนไลน์!

อินพุตแบบเต็ม Pad 0พวกเขาด้วย แปลงเป็นรหัส ASCII หกจุด ละเมิดFbuiltin

Huskขนาด 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

Perl 5 + -pl -MList::Util+(sum), 49 ไบต์

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

ลองออนไลน์!

Perl 5 + -nl -MList::Util+(sum) -M5.010, 50 ไบต์

หากต้องการส่งออกแต่ละตั๋วแทน +1 ไบต์:

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

ลองออนไลน์!

Python 3 , 89 86 ไบต์

-2 ขอบคุณ Mr. Xcoder

-3 เป็นแรงบันดาลใจจากคำตอบของ 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))

ผลการทดสอบ:

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

ลองออนไลน์!

(-2 ไบต์ขอบคุณ Luis Mendo)

&: - สร้างช่วงรวมระหว่างตัวเลขทั้งสองที่ได้รับ

1e3&\ - 'divrem' - หารด้วย 1,000 และรับการเตือนความจำและผลหารที่ได้รับการปูพื้นในสองอาร์เรย์

, - ทำสองครั้ง

!'03d'&V - แปลงและแปลงค่าแต่ละค่าเป็นสตริงสามความกว้างศูนย์

&s - รวมค่าของแต่ละแถว

w - สลับเพื่อนำอาร์เรย์ตัวเตือนออกมาและทำเช่นนี้อีกครั้ง

] - ลูปสิ้นสุด

= - ตรวจสอบความเสมอภาค (คืนค่า 1s ในตำแหน่งที่อาร์เรย์มีค่าเท่ากัน)

s - รวมสิ่งที่จะได้รับการนับ (เอาท์พุทโดยนัย)

Kotlin , 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()}

ลองออนไลน์!

การสองจำนวนเต็มกว่าแปลงเป็นหกสายสัญลักษณ์และนับ

ปรับให้เหมาะสมด้วยความยุ่งเหยิงและวิธีแก้ปัญหาของเขาที่ 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]มีเอฟเฟกต์ "คำนวณผลรวมหลักของตัวเลขสามหลักที่สองขึ้นไปด้านบนของสแต็กจากนั้นดำเนินการด้านบนดั้งเดิมของสแต็กเป็นมาโคร"

โปรแกรมหลัก:

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 bytes

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 for

• ค่าลูปถูกตั้งค่าไว้ล่วงหน้า (จากaถึงb) ดังนั้นaสามารถนำกลับมาใช้ใหม่เป็นตัวแปรลูปปล่อยi;
• ที่ส่วนท้ายของ for for ลูปตัวแปร loop จะถูกปล่อยทิ้งไว้ที่ค่าสุดท้าย (ค่าbก่อนลูป) ฉันใช้bเป็นที่เก็บเพิ่มขึ้นเมื่อพบเลขนำโชคและท้ายวงวนbนั้นอยู่ห่างจากค่าเดิมด้วยจำนวนเลขนำโชคจึงb-aให้ผลลัพธ์ที่ถูกต้อง sนี้ปรับตัวลดลง

การแทนที่dด้วยการดำเนินการโดยตรงaทำให้การวนซ้ำสั้นลง การแทนที่cด้วยการดำเนินการโดยตรงกับaขนาดยาไม่ทำให้วงสั้นลง แต่หลังจากหยดลงdห่วงbeginและendไม่จำเป็นและฉันสิ้นสุดลงด้วยการใช้ตัวแปร 2 ตัวเท่านั้น :)

$เริ่มค่าคงที่เลขฐานสิบหกในรหัส golfed ในขณะที่พวกเขาไม่ได้บันทึกไบต์พวกเขากำจัดช่องว่างที่จำเป็นก่อนค่าคงที่ทศนิยม

Java (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

หรือลองออนไลน์!

Perl 6 , 51 49 ไบต์

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

ลองออนไลน์!

บล็อกโค้ดแบบไม่ระบุชื่อที่ใช้ตัวเลขสองตัวและส่งกลับจำนวนของผู้โชคดี หมดเวลาสำหรับอินพุตที่มากขึ้น

เยลลี่ ,  9  8 ไบต์

-1 ต้องขอบคุณเดนนิส ( rµ...E)S-> r...E€Sตั้งแต่เวกเตอร์ทุกอย่าง)

rdȷD§E€S

ลิงก์ dyadic ยอมรับจุดปลายทั้งสองของช่วง (ทั้งสองทาง) ซึ่งให้ผลนับจำนวนของตั๋วนำโชค

ลองออนไลน์! หรือดูชุดทดสอบ

อย่างไร?

$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 ไบต์

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

Kotlin, 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ü╢^

เรียกใช้และแก้ปัญหาแต่ต้องอดทน!

Python 2 ,  83  80 ไบต์

-3 โดยใช้การสังเกตของ Asone Tuhid - ไปให้เครดิต!

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

ลองออนไลน์!

เหมือนคำตอบ Jelly ของฉัน (แต่อินพุตต้องเรียงลำดับที่นี่เช่นa<=b)

75 ไบต์สำหรับอินพุตa, b+1(เช่นช่วงไม่รวมขอบเขตขวา):

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

ลองอันนี้

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

ท่าเรือ Java ของฉันคำตอบ ลองออนไลน์ได้ที่นี่ ต้องขอบคุณแมวป่าสำหรับการเล่นกอล์ฟสองไบต์

Ungolfed:

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 ไบต์

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 อื่น ๆ แทนที่จะใช้สตรีมและสตริงสิ่งนี้ใช้การวนซ้ำและประเมินตัวเลขโดยตรง ลองออนไลน์ได้ที่นี่

ต้องขอบคุณแมวป่าสำหรับการเล่นกอล์ฟสองไบต์

Ungolfed:

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ที่สองสามหลักคำนวณโดย