W Rosji mamy coś w rodzaju tradycji: lubimy szukać szczęśliwych biletów.

Oto jak wygląda zwykły bilet:

Jak widać, bilet ma sześciocyfrowy numer.

Sześciocyfrowa liczba jest uważana za szczęśliwą, jeśli suma pierwszych trzech cyfr jest równa sumie trzech ostatnich.

Numer na zdjęciu nie jest szczęśliwy:

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

Wyzwanie

Biorąc pod uwagę ograniczenia zakresu (włącznie), zwróć liczbę szczęśliwych numerów w nim zawartych.

Parametry

• Dane wejściowe: 2 liczby całkowite: pierwsza i ostatnia liczba całkowita z zakresu
• Dane wejściowe będą wynosić od 0 do 999999 włącznie
• Wyjście: 1 liczba całkowita: ile szczęśliwych liczb znajduje się w zakresie
• Możesz pobrać dane wejściowe i zwrócić dane wyjściowe w dowolnym dopuszczalnym formacie
• Przyjmij początkowe zera dla liczb mniejszych niż 100000.

Przykłady

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

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach w każdym języku.

Aktualizacja: oto szczęśliwy

05AB1E , 8 (lub 10?) 11 (lub 13?) Bajtów

Ÿʒ₄n+¦S3ôOË

Wypróbuj online lub sprawdź kilka innych przypadków testowych .

UWAGA: W 05AB1E ciągi i liczby całkowite są wymienne, więc liczby wyjściowe nie zawierają zer wiodących. Można to jednak naprawić za pomocą 1 dodatkowego bajtu ( 12 bajtów ):

Ÿ₄n+€¦ʒS3ôOË

Wypróbuj online lub sprawdź kilka innych przypadków testowych .

+3 bajty do numerów poprawiających błędy o długości 3 lub mniejszej (zakres [000000, 000999]).

Wyjaśnienie:

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

EDYCJA: Wydaje się, że I (i większość innych odpowiedzi) nieco źle odczytałem wyzwanie, a zamiast liczb w samym zakresie pytana jest liczba liczb. W takim przypadku }gmożna dodać znak końca (zamknij filtr i uzyskaj liczbę liczb pozostałych na filtrowanej liście), więc zamiast tego jest to 10 13 bajtów :

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

Wypróbuj online lub sprawdź kilka innych przypadków testowych .

C # (.NET Core) , 93 + 18 = 111 bajtów

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

Wypróbuj online!

18 bajtów dla using System.Linq;. Przypuszczałem, że formaty wejściowe i wyjściowe mogą być elastyczne. Biorę więc dwie liczby całkowite jako dane wejściowe (zakres włącznie).

Niektóre wyniki testu:

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 bajtów

Pobiera dane wejściowe w składni curry (m)(n), gdzie m jest wyłączną obejmującą górną granicą, a n jest włączającą dolną granicą.

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

Wypróbuj online!

W jaki sposób?

Testujemy każdą liczbę , przechodząc przez jej cyfry d i aktualizując całkowitą t :$n$$d_i$$t$

• jeśli po tym są jeszcze co najmniej 3 cyfry$t \gets t - d_i$
• inaczej$t \gets t + d_i$

Jeśli na końcu procesu mamy , to n jest liczbą szczęśliwą.$t=0$$n$

JavaScript (ES6), 67 bajtów

Ten sam format wejściowy.

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

Wypróbuj online!

W jaki sposób?

$n$

• $1000$38937 --> 38.937
• przymus na ciąg i podziel: ['3','8','.','9','3','7']
• dołącz do +:"3+8+.+9+3+7"
• wymienić +.z ^:"3+8^+9+3+7"
• $0$24$11$$19$

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

Rubin , 56 54 bajtów

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

Wypróbuj online!

Metoda:

1. Dla każdej liczby tworzy tablicę cyfr (która jest odwrócona)
2. Porównuje sumę pierwszych 3 cyfr w tablicy (ostatnie 3 w liczbie) pomnożoną przez 2 do sumy całej tablicy
3. Liczy liczby, dla których dwie sumy są równe

Japt , 38 15 bajtów

õV Ëì ò3n)mx r¥

-23 dzięki Shaggy!

Moje pierwsze poddanie się Japt; dzięki Shaggy za wszelką pomoc!

Wypróbuj online!

Python 3, 117 113 106 135 bajtów

To moja pierwsza odpowiedź, więc jestem pewien, że jest miejsce na ulepszenia.

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 bajty dzięki WW
• -7 bajtów dzięki Asone Tuhid
• +29 bajtów, aby utworzyć funkcję

Pobiera pierwsze trzy cyfry przez dzielenie liczb całkowitych, a ostatnie trzy cyfry przez modulo. Pierwsza i ostatnia liczba całkowita w zakresie są wprowadzane jako argumenty xfunkcji odpowiednio jako ai b. Wyjście jest nwydrukowane.

Nie golfowany:

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 bajtów

Krótsza logika na końcu komplementy @ Giuseppe /

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

Wypróbuj online!

Wejścia całkowite. Wypełnij je 0. Konwertuj na sześć punktów kodu ASCII. Nadużywaj Fwbudowanego.

Łuska , 12 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Węgiel drzewny , 15 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Edycja: Początkowo myślałem, że potrzebna jest lista szczęśliwych liczb. Można to zrobić w 14 bajtach (usuwając Ｌ, który zajmuje długość listy) lub w 20 bajtach, jeśli chcesz ładnego formatowania:

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

    ＮＮ                  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 bajtów

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

Wypróbuj online!

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

Aby zamiast tego wyświetlić każdy bilet, należy podać +1 bajt:

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

Wypróbuj online!

Python 3 , 89 86 bajtów

-2 dzięki Mr. Xcoder.

-3 inspirujące z odpowiedzi 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))

Wyniki testów:

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 

Wypróbuj online!

MATL , 24 bajty

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

Wypróbuj online!

(-2 bajty dzięki Luisowi Mendo.)

&: - Zrób przedział obejmujący dwie podane liczby

1e3&\ - „divrem” - podziel przez 1000 i uzyskaj przypomnienia i zmienne ilorazy w dwóch tablicach.

, - zrobić dwa razy

!'03d'&V - transponować i przekonwertować każdą wartość na wyściełany zerami ciąg o trzech szerokościach

&s - zsumuj wartości każdego wiersza

w - przełącz się, by przywołać tablicę przypomnień i zrób to jeszcze raz

] - pętla końcowa

= - sprawdź równość (zwraca 1s w miejscach, w których tablice są równe)

s - zsumuj je, aby uzyskać liczbę (wynik niejawny)

Kotlin , 152 119 bajtów

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

Wypróbuj online!

Biorąc dwie liczby całkowite, niż przeliczamy na sześć ciągów znaków i liczymy.

Zoptymalizowany dzięki mazzy i jego rozwiązaniu do 119 bajtów.

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

Wypróbuj online!

dc , 44 bajty

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

Pobiera dwa argumenty z innego pustego stosu, dane wyjściowe na górę stosu.

Wypróbuj online!

Sprytnym bitem jest tutaj użycie nienazwanego (tzn. Niezapisanego) makra, które jest powielane przed wykonaniem, aby uruchomić swoją kopię na drugiej trzycyfrowej części.

Wyjaśnienie

Wewnętrzne makro [rA~rA~++rx]ma efekt „oblicz sumę cyfr trzycyfrowej liczby, która znajduje się na górze stosu, a następnie wykonaj pierwotną górę stosu jako makro”.

Główny 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) , 163 153 bajty

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.

Wypróbuj online!

Wyjaśnienie

Oto najpierw trochę normalnie wyglądającego kodu:

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.

Wypróbuj online!

Następnie nadużyłem zachowania pętli for:

• wartości pętli są ustawiane wcześniej (od ado b), więc amożna je ponownie wykorzystać jako zmienną pętli, upuszczając i;
• na końcu pętli for zmienna pętli pozostawia wartość końcową (wartość bprzed pętlą). Użyłem bjako kontenera, zwiększając go, gdy znaleziono szczęśliwą liczbę, a na końcu pętli bjest daleko od jej starej wartości o liczbę szczęśliwych liczb, więc b-adaje poprawny wynik. To spadło s.

Zastąpienie doperacji bezpośrednio na askraca pętlę. Wymiana cz operacji bezpośrednio na adawki nie skrócić pętlę, ale po spadku d, pętla użytkownika begini endsą niepotrzebne i skończyło się przy użyciu tylko 2 zmienne :)

$uruchamia stałe szesnastkowe w kodzie golfowym. Chociaż nie zapisują bajtów, eliminują spacje potrzebne przed stałymi dziesiętnymi.

Java (OpenJDK 8) , 162 bajty

... pożycza z powyższego przykładu 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();

Wypróbuj online!

Porównywanie sumy bajtów ciągu jest tak samo dobre, jak sumowanie rzeczywistych cyfr.

PHP , 131 bajtów

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

Aby uruchomić:

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

Przykład:

php -n lucky_tickets.php 100 100000

Lub wypróbuj online!

Perl 6 , 51 49 bajtów

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

Wypróbuj online!

Anonimowy blok kodu, który przyjmuje dwie liczby i zwraca liczbę szczęśliwych. Przekracza limit czasu dla większych nakładów

Galaretka ,  9  8 bajtów

-1 dzięki Dennisowi ( rµ...E)S->, r...E€Sponieważ wszystko wektoryzuje.)

rdȷD§E€S

Dyadyczny link akceptujący dwa punkty końcowe zakresu (w obie strony), który daje liczbę szczęśliwych biletów.

Wypróbuj online! Lub zobacz zestaw testowy

W jaki sposób?

$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 bajtów

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

Skrypt testowy:

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

Wynik:

      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 bajtów

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

.kt dla testu:

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
}

Wyjaśnienie

Policz liczby z zakresu, w którym suma wszystkich cyfr jest równa podwójnej sumie pierwszych 3 cyfr.

Stax , 14 bajtów

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

Uruchom i debuguj , ale bądź cierpliwy!

Python 2 ,  83  80 bajtów

-3 wykorzystując obserwację Asone Tuhid - idź przyznać!

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

Wypróbuj online!

Podobnie jak moja odpowiedź Jelly (ale dane wejściowe należy tutaj posortować, tj. a<=b)

75 bajtów na wejście a, b+1(tzn. Zakres wyklucza prawą granicę):

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

Spróbuj tego

Clojure, 102 bajty

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

Mieszanie łańcuchów i matematyki nie jest zbyt zabawne.

J , 35 bajtów

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

Wypróbuj online!

C (gcc), 90 88 bajtów

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

Port mojej odpowiedzi Java . Wypróbuj online tutaj . Dzięki pułapowi do gry w golfa dwa bajty.

Nie golfowany:

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 bajtów

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

Inne podejście niż inna odpowiedź Java . Zamiast używać strumieni i ciągów, wykorzystuje pętlę i ocenia liczby bezpośrednio. Wypróbuj online tutaj .

Dzięki pułapowi do gry w golfa dwa bajty.

Nie golfowany:

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 bajtów

Używanie natychmiastowego okna i komórek [A1] [A2]jako danych wejściowych.

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 bajtów

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

Wypróbuj online!

tkonwertuje ciąg na liczby i sumuje je. rbierze zakres liczb od sdo ei odfiltrowuje liczby, które mają pecha. Pierwsze trzy cyfry są zbierane przez n/1000. Pozostałe trzy cyfry są obliczane przez n-(n/1000)*1000.