Rusya'da bir gelenek gibi bir şeyimiz var: şanslı biletler aramayı seviyoruz.

Normal bir bilet şöyle görünür:

Gördüğünüz gibi, biletin altı haneli bir numarası var.

İlk üç basamağın toplamı son üç basamağın toplamına eşitse, altı basamaklı bir sayı şanslı sayılır .

Fotoğraftaki numara şanslı değil:

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

Meydan okuma

Bir aralığın (dahil) sınırları göz önüne alındığında, içerdiği şanslı bilet numaralarının sayısını döndürün.

Parametreler

• Girdi: 2 tamsayı: aralıktaki ilk ve son tamsayılar
• Girişler 0 ile 999999 arasında olacaktır
• Çıktı: 1 tam sayı: aralıkta kaç şanslı sayı var
• Girdileri alabilir ve çıktıyı kabul edilebilir herhangi bir biçimde döndürebilirsiniz
• 100000'den küçük sayılar için önde gelen sıfırları varsayalım.

Örnekler

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

Bu kod golf yani her dilde bayt en kısa cevap kazanır.

Güncelleme: İşte şanslı olan

05AB1E , 8 (veya 10?) 11 (veya 13?) Bayt

Ÿʒ₄n+¦S3ôOË

Çevrimiçi deneyin veya daha fazla test vakası doğrulayın .

NOT: 05AB1E'de dizeler ve tamsayılar birbiriyle değiştirilebilir, bu nedenle çıkış numaraları önde gelen sıfırlar içermez. Ancak bu 1 ek bayt ( 12 bayt ) ile düzeltilebilir :

Ÿ₄n+€¦ʒS3ôOË

Çevrimiçi deneyin veya daha fazla test vakası doğrulayın .

3 veya daha az uzunlukta (aralık [000000, 000999]) sayıları düzeltmek için +3 bayt .

Açıklama:

Ÿ          # 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: Ben (ve diğer birçok cevap) meydan okumayı biraz yanlış okuyor ve aralıktaki sayıların yerine sayıların sayısı soruluyor. Bu durumda bir iz }geklenebilir (filtreyi kapatın; ve filtrelenen listede kalan sayı miktarını alın), bu yüzden bunun yerine 10 13 bayt olur :

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

Çevrimiçi deneyin veya daha fazla test vakası doğrulayın .

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

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

Çevrimiçi deneyin!

İçin 18 bayt using System.Linq;. Giriş ve çıkış biçimlerinin esnek olabileceğini düşündüm. Bu yüzden girdi olarak iki tamsayı alıyorum (aralık, dahil).

Bazı test sonuçları:

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 bayt

Sözdizimini tımar olarak girişi alır (m)(n), m olan özel dahil üst sınırı ve n, dahil düşük bağlanır.

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

Çevrimiçi deneyin!

Nasıl?

Her sayısını , d i basamaklarından geçerek ve toplam t'yi güncelleyerek test ederiz :$n$$d_i$$t$

• bundan sonra en az 3 basamak varsa$t \gets t - d_i$
• aksi$t \gets t + d_i$

İşlemin sonunda varsa , n şanslı bir sayıdır.$t=0$$n$

JavaScript (ES6), 67 bayt

Aynı giriş biçimi.

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

Çevrimiçi deneyin!

Nasıl?

Her sayısı için :$n$

• böl : ör.$1000$38937 --> 38.937
• bir dizge ve bölünmeye zorlama: ['3','8','.','9','3','7']
• katılmak +:"3+8+.+9+3+7"
• yerine +.sahip ^:"3+8^+9+3+7"
• JS kodu olarak değerlendirin ve sonucun olup olmadığını test edin : ( $0$24$11$ XOR )$19$

Eğer , ondalık nokta oluşturulmaz ve n = 0 olmadıkça, değerlendirilen ifade yalnızca pozitif bir toplamdır (yanlış).$n \equiv 0 \pmod{1000}$$n=0$ (doğruluk) (yanlış). Her iki durumda da beklenen sonuç budur.

Yakut , 56 54 bayt

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

Çevrimiçi deneyin!

Yöntem:

1. Her sayı için, bir dizi basamak oluşturur (ters çevrilmiş olarak gelir)
2. Dizideki ilk 3 basamağın toplamını (sayıdaki son 3) 2 ile çarparak tüm dizinin toplamıyla karşılaştırır
3. İki toplamın eşit olduğu sayıları sayar

Japt , 38 15 bayt

õV Ëì ò3n)mx r¥

-23 Shaggy sayesinde!

İlk Japt sunumum; tüm yardım için Shaggy teşekkürler!

Çevrimiçi deneyin!

Python 3, 117 113 106 135 bayt

Bu benim ilk cevabım, bu yüzden iyileşme için yer olduğuna eminim.

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 sayesinde -4 bayt
• Asone Tuhid sayesinde -7 bayt
• Bir işlev oluşturmak için +29 bayt

İlk üç basamağı tamsayı bölme ve son üç basamağı modulo ile alır. Aralıktaki ilk ve son tamsayılar, xişlevin bağımsız değişkenleri olarak sırasıyla ave olarak bgirilir. Çıktın yazdırılır.

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 bayt

@ Giuseppe'nın sonunda daha kısa mantık /

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

Çevrimiçi deneyin!

Tamsayı girişleri. Onları doldurun 0. Altı ASCII kod noktasına dönüştürün. FYerleşik istismarı .

Kabuk , 12 bayt

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

Çevrimiçi deneyin!

açıklama

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

Odun kömürü , 15 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Düzenleme: Aslında gerekli şanslı numaralar listesi olduğunu düşündüm. Bu, 14 baytta ( Ｌlistenin uzunluğunu alan , kaldırılarak ) veya güzel bir biçimlendirme istiyorsanız 20 baytta yapılabilir:

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

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

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

Çevrimiçi deneyin!

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

Bunun yerine her bir biletin çıktısını +1 bayt alır:

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

Çevrimiçi deneyin!

Python 3 , 89 86 bayt

-2 Bay Xcoder sayesinde.

-3 Asone Tuhid cevaplayan ilham verici.

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

Test sonuçları:

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 

Çevrimiçi deneyin!

MATL , 24 bayt

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

Çevrimiçi deneyin!

(Luis Mendo sayesinde -2 bayt.)

&: - Verilen iki sayı arasında kapsayıcı bir aralık oluşturun

1e3&\ - 'divrem' - 1000'e bölün ve iki dizide hatırlatıcıları ve katlanmış bölümleri alın.

, - iki kere yap

!'03d'&V - her değeri sıfır dolgulu üç genişlikli bir dizeye aktarın ve dönüştürün

&s - her satırın değerlerini topla

w - hatırlatma dizisini dışarı çıkarmak için değiştirin ve bunu tekrar yapın

] - son döngü

= - eşitliği kontrol edin (dizilerin eşit olduğu yerlerde 1 sn döndürür)

s - sayımı elde etmek için bunları toplama (örtük çıktı)

Kotlin , 152 119 bayt

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

Çevrimiçi deneyin!

Altı sembol dizesine dönüştürmekten iki tamsayı almak ve saymak.

Mazzy ve 119 bayta çözümü sayesinde optimize edildi .

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

Çevrimiçi deneyin!

dc , 44 bayt

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

Aksi takdirde boş bir yığından iki argüman alır, yığının üstüne çıkar.

Çevrimiçi deneyin!

Buradaki akıllı bit, diğer üç basamaklı kısımda kendisinin bir kopyasını çalıştırmak için yürütmeden önce çoğaltılan adlandırılmamış (yani, kaydedilmemiş) bir makronun kullanılmasıdır.

açıklama

İç makronun [rA~rA~++rx], "yığında üst üste üç basamaklı sayının toplamını hesapla ve ardından yığının orijinal üstünü makro olarak yürüt" etkisi vardır.

Ana program:

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) , 163153 bayt

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.

Çevrimiçi deneyin!

açıklama

İlk önce normal görünümlü bazı kodlar:

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.

Çevrimiçi deneyin!

Sonra for döngüsü davranışını kötüye:

• döngü değerleri (daha öncesinde ayarlanır aiçin b, bu yüzden) abırakarak, döngü değişken olarak yeniden kullanılabiliri ;
• for döngüsünün sonunda, döngü değişkeni son değerde ( b döngüden önceki ) kalır. bBir kap olarak kullandım , şanslı bir sayı bulunduğunda ve döngünün sonunda bşanslı sayılarla eski değerinden uzak olduğunda onu arttırır, böylece b-adoğru sonucu verir. Bu düştü s.

dDoğrudan işlemlerle değiştirmek adöngüyü kısaltır. DeğiştirmecaDoz üzerindeki operasyonlarla doğrudan , döngüyü kısaltmaz, ancak düştükten sonra d, döngüdür beginve endgereksizdir ve sadece 2 değişken kullanarak sona erdi :)

$golfed kodunda onaltılık sabitleri başlatır. Baytları kaydetmezken, ondalık sabitlerden önce gereken boşlukları ortadan kaldırırlar.

Java (OpenJDK 8) , 162 bayt

... yukarıdaki Kotlin örneğinden ödünç alır.

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

Çevrimiçi deneyin!

String'in baytlarının toplamını karşılaştırmak, gerçek rakamları toplamak kadar iyidir.

PHP , 131 bayt

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

Çalıştırmak için:

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

Misal:

php -n lucky_tickets.php 100 100000

Veya çevrimiçi deneyin!

Perl 6 , 51 49 bayt

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

Çevrimiçi deneyin!

İki sayı alan ve şanslı olanların sayısını döndüren anonim kod bloğu. Daha büyük girişler için zaman aşımı

Jöle ,  9  8 bayt

-1 sayesinde Dennis ( rµ...E)S-> r...E€Sçünkü her şey vektörleşir.)

rdȷD§E€S

Şanslı biletlerin sayısını veren aralığın iki uç noktasını (her iki şekilde) kabul eden ikili bir bağlantı.

Çevrimiçi deneyin! Veya bir test takımına bakın

Nasıl?

Negatif olmayan bir tam sayı için $1000000$, $N$, tarafından tamsayı bölünmesini kullanarak kontrol etmek için gerekli değerlerin toplamını içeren basamaklı iki sayı alabiliriz $1000$
(diyelim ki, $X=\lfloor\frac{N}{1000}\rfloor$)
Ve geri kalan
(örneğin$Y=N\mod{1000}$)
... yani,$N=1000\times X+Y$

Şimdi rakamların toplamlarını karşılaştırmak istiyoruz. $X$ ve $Y$ her biri için $N$ ve eşit olanları sayı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 bayt

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

Test komut dosyası:

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

Çıktı:

      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 bayt

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

.kt test için:

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
}

açıklama

Tüm sayı basamaklarının toplamının ilk 3 basamağın iki katına eşit olduğu aralıktaki sayıları sayın.

Stax , 14 bayt

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

Çalıştırın ve hata ayıklayın , ancak sabırlı olun!

Python 2 ,  83  80 bayt

-3 Asone Tuhid'in gözlemini kullanarak - git kredi ver!

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

Çevrimiçi deneyin!

Benim Jelly cevabım gibi (ama girişler burada sıralanmalıdır yani a<=b)

Giriş için 75 bayta, b+1 (yani aralık sağ sınırı hariç tutar):

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

Bunu dene

Clojure, 102 bayt

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

Dizeleri ve matematiği karıştırmak çok eğlenceli değil.

J , 35 bayt

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

Çevrimiçi deneyin!

C (gcc), 90 88 bayt

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 yanıtımın bağlantı noktası . Burada çevrimiçi deneyin . İki bayt golf için ceilingcat sayesinde .

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 bayt

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

Diğer Java cevabından farklı bir yaklaşım . Akışları ve Dizeleri kullanmak yerine, bu bir döngü kullanır ve sayıları doğrudan değerlendirir. Burada çevrimiçi deneyin .

İki bayt golf için ceilingcat sayesinde .

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 bayt

Anlık Pencere ve Hücreleri [A1] [A2]giriş olarak kullanma .

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 bayt

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

Çevrimiçi deneyin!

tdizeyi sayılara dönüştürür ve toplar. rdan sayı aralığını alır setmek eve şanssız numaraları filtreler. İlk üç hane tarafından toplanır n/1000. İkinci üç basamak hesaplanır n-(n/1000)*1000.