In Russland haben wir so etwas wie eine Tradition: Wir suchen gerne nach Glückstickets.

So sieht ein reguläres Ticket aus:

Wie Sie sehen, hat das Ticket eine sechsstellige Nummer.

Eine sechsstellige Zahl gilt als glücklich, wenn die Summe der ersten drei Ziffern der Summe der letzten drei Ziffern entspricht.

Die Nummer auf dem Foto hat kein Glück:

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

Herausforderung

Geben Sie unter Berücksichtigung der Grenzen eines Bereichs (einschließlich) die Anzahl der darin enthaltenen Glücksscheinnummern zurück.

Parameter

• Eingabe: 2 Ganzzahlen: die erste und letzte Ganzzahl im Bereich
• Die Eingaben liegen zwischen 0 und 999999 einschließlich
• Ausgabe: 1 Ganzzahl: wie viele Glückszahlen im Bereich sind
• Sie können die Eingaben übernehmen und die Ausgabe in einem beliebigen akzeptablen Format zurückgeben
• Nehmen Sie führende Nullen für Zahlen unter 100000 an.

Beispiele

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

Dies ist Codegolf, daher gewinnt die kürzeste Antwort in Bytes in jeder Sprache.

Update: Hier ist der Glückliche

05AB1E , 8 (oder 10?) 11 (oder 13?) Bytes

Ÿʒ₄n+¦S3ôOË

Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle .

HINWEIS: In 05AB1E sind Zeichenfolgen und Ganzzahlen austauschbar, sodass die Ausgabenummern keine führenden Nullen enthalten. Dies könnte jedoch mit 1 zusätzlichen Byte ( 12 Byte ) behoben werden :

Ÿ₄n+€¦ʒS3ôOË

Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle .

+3 Bytes zur Fehlerbehebung von Zahlen mit einer Länge von 3 oder weniger (Bereich [000000, 000999]).

Erläuterung:

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

BEARBEITEN: Scheint, dass ich (und die meisten anderen Antworten) die Herausforderung leicht falsch verstanden habe und die Anzahl der Zahlen anstelle der Zahlen selbst innerhalb des Bereichs abgefragt wird. In diesem Fall kann ein Trailing }ghinzugefügt werden (schließen Sie den Filter und ermitteln Sie die Anzahl der in der gefilterten Liste verbleibenden Zahlen). Stattdessen sind es 10 13 Bytes :

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

Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle .

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

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

Probieren Sie es online!

18 Bytes für using System.Linq;. Ich nahm an, dass die Eingabe- und Ausgabeformate flexibel sein könnten. Ich nehme also zwei ganze Zahlen als Eingabe (den Bereich, einschließlich).

Einige Testergebnisse:

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

Nimmt Eingaben in Curry-Syntax vor (m)(n), wobei m die exklusive inklusive Obergrenze und n die inklusive Untergrenze ist.

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

Probieren Sie es online!

Wie?

Wir testen jede Zahl zu Fuß durch seine Ziffern d i und insgesamt Aktualisierung t :$n$$d_i$$t$

• wenn nach dieser Ziffer noch mindestens 3 Stellen übrig sind$t \gets t - d_i$
• sonst$t \gets t + d_i$

Wenn wir am Ende des Prozesses haben , ist n eine Glückszahl.$t=0$$n$

JavaScript (ES6), 67 Byte

Gleiches Eingabeformat.

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

Probieren Sie es online!

Wie?

Für jede Nummer :$n$

• dividiere es durch : zB$1000$38937 --> 38.937
• zu einer Zeichenfolge zwingen und aufteilen: ['3','8','.','9','3','7']
• mitmachen bei +:"3+8+.+9+3+7"
• ersetzen +.durch ^:"3+8^+9+3+7"
• als JS-Code auswerten und testen, ob das Ergebnis : ( 11 XOR 19 )$0$24$11$$19$

Wenn wird kein Dezimalpunkt generiert und der ausgewertete Ausdruck ist nur eine positive Summe (falsch), es sei denn, n = 0 (wahr). Dies ist in beiden Fällen das erwartete Ergebnis.$n \equiv 0 \pmod{1000}$$n=0$

Ruby , 56 54 Bytes

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

Probieren Sie es online!

Methode:

1. Erstellt für jede Zahl ein Ziffernfeld (das umgekehrt ausgegeben wird)
2. Vergleicht die Summe der ersten drei Ziffern des Arrays (die letzten drei der Zahl) multipliziert mit 2 mit der Summe des gesamten Arrays
3. Zählt die Zahlen, für die die beiden Summen gleich sind

Japt , 38 15 Bytes

õV Ëì ò3n)mx r¥

-23 danke an Shaggy!

Meine erste Japt-Einreichung; Danke an Shaggy für die Hilfe!

Probieren Sie es online!

Python 3, 117 113 106 135 Bytes

Dies ist meine allererste Antwort, daher bin ich mir sicher, dass es Raum für Verbesserungen gibt.

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 Bytes dank WW
• -7 Bytes dank Asone Tuhid
• +29 Bytes, um eine Funktion zu erstellen

Ruft die ersten drei Ziffern durch Ganzzahldivision und die letzten drei durch Modulo ab. Die ersten und letzten Ganzzahlen in dem Bereich werden als Argumente der xFunktion as abzw. as eingegeben b. Die Ausgabe erfolgt ngedruckt.

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 Bytes

Kürzere Logik am Ende Komplimente von @ Giuseppe /

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

Probieren Sie es online!

Integer-Eingänge. Pad sie mit 0. Konvertieren Sie in die sechs ASCII-Codepunkte. Missbrauch der Feingebauten.

Schale , 12 Bytes

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

Probieren Sie es online!

Erläuterung

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

Kohle , 15 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: Ich dachte ursprünglich, dass es die Liste der Glückszahlen war, die erforderlich war. Dies kann in 14 Bytes (durch Entfernen von Ｌ, was die Länge der Liste einnimmt) oder in 20 Bytes erfolgen, wenn Sie eine schöne Formatierung wünschen:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

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

Probieren Sie es online!

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

Die Ausgabe jedes Tickets erfolgt stattdessen mit +1 Byte:

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

Probieren Sie es online!

Python 3 , 89 86 Bytes

-2 Dank an Herrn Xcoder.

-3 inspirierend von Asone Tuhid Antwort.

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

Testergebnisse:

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 

Probieren Sie es online!

MATL , 24 Bytes

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

Probieren Sie es online!

(-2 Bytes dank Luis Mendo.)

&: - Machen Sie einen inklusiven Bereich zwischen den beiden angegebenen Zahlen

1e3&\ - 'divrem' - Dividieren Sie durch 1000 und erhalten Sie die Erinnerungen und Floored-Quotienten in zwei Arrays.

, - zweimal tun

!'03d'&V - transponieren und konvertieren Sie jeden Wert in eine mit Nullen aufgefüllte Zeichenfolge mit drei Breiten

&s - Summiere die Werte jeder Zeile

w - Schalten Sie um, um das Erinnerungsarray wieder freizugeben, und wiederholen Sie dies

] - Schleife beenden

= - auf Gleichheit prüfen (gibt 1s an Stellen zurück, an denen die Arrays gleich sind)

s - Summiere diese, um die Anzahl zu erhalten (implizite Ausgabe)

Kotlin , 152 119 Bytes

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

Probieren Sie es online!

Wenn Sie zwei Ganzzahlen nehmen, konvertieren Sie sie in sechs Zeichenfolgen und zählen.

Optimierte es dank mazzy und seiner Lösung auf 119 Bytes.

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

Probieren Sie es online!

Gleichstrom , 44 Bytes

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

Nimmt zwei Argumente von einem ansonsten leeren Stapel und gibt sie an den Anfang des Stapels aus.

Probieren Sie es online!

Das Schlaue dabei ist die Verwendung eines unbenannten (dh nicht gespeicherten) Makros, das vor der Ausführung dupliziert wird, um eine Kopie von sich selbst auf dem anderen dreistelligen Teil auszuführen.

Erläuterung

Das innere Makro [rA~rA~++rx]hat den Effekt "Berechne die Ziffernsumme der dreistelligen Zahl, die auf dem Stapel an zweiter Stelle steht, und führe dann die ursprüngliche Oberseite des Stapels als Makro aus".

Hauptprogramm:

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.

Probieren Sie es online!

Erläuterung

Hier ist ein normal aussehender Code:

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.

Probieren Sie es online!

Dann habe ich das Verhalten der for-Schleife missbraucht:

• Die Schleifenwerte werden vorher eingestellt (von abis b), akönnen also als Schleifenvariable wiederverwendet werden i.
• Am Ende der for-Schleife bleibt die Variable loop auf dem Endwert (Wert bvor der Schleife). Ich habe es bals Container verwendet, indem ich es inkrementiert habe, wenn eine Glückszahl gefunden wurde und am Ende der Schleife bum die Anzahl der Glückszahlen von ihrem alten Wert abweicht, um b-adas richtige Ergebnis zu erhalten. Das ist gefallen s.

Das Ersetzen ddurch Operationen direkt auf averkürzt die Schleife. Das Ersetzen cdurch Operationen direkt nach der aDosis verkürzt nicht die Schleife, sondern nach dem Fallenlassen die dSchleifen beginundend unnötig und ich endete mit der Verwendung von nur 2 Variablen :)

$Startet hexadezimale Konstanten im Golf Code. Während sie keine Bytes speichern, eliminieren sie Leerzeichen, die vor den Dezimalkonstanten benötigt werden.

Java (OpenJDK 8) , 162 Byte

... leiht sich aus dem obigen Kotlin-Beispiel.

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

Probieren Sie es online!

Das Vergleichen der Summe der Bytes des Strings ist genauso gut wie das Aufsummieren der tatsächlichen Ziffern.

PHP , 131 Bytes

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

Um es auszuführen:

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

Beispiel:

php -n lucky_tickets.php 100 100000

Oder versuchen Sie es online!

Perl 6 , 51 49 Bytes

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

Probieren Sie es online!

Anonymer Codeblock, der zwei Zahlen nimmt und die Anzahl der glücklichen zurückgibt. Zeitüberschreitung bei größeren Eingaben

Gelee ,  9  8 Bytes

-1 danke an Dennis ( rµ...E)S->r...E€S da alles vektorisiert.)

rdȷD§E€S

Ein dyadischer Link, der die beiden Endpunkte der Reichweite akzeptiert (oder umgekehrt) und die Anzahl der Glücksscheine angibt.

Probieren Sie es online! Oder sehen Sie ein Testsuite an

Wie?

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

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

Testskript:

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

Ausgabe:

      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 Bytes

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

.kt zum Test:

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
}

Erläuterung

Zählen Sie die Zahlen aus dem Bereich, in dem die Summe aller Ziffern der doppelten Summe der ersten drei Ziffern entspricht.

Stax , 14 Bytes

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

Führen Sie es aus und debuggen Sie es , aber seien Sie geduldig!

Python 2 ,  83  80 Bytes

-3 unter Verwendung von Asone Tuhids Beobachtung - gib Kredit!

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

Probieren Sie es online!

Ähnlich wie meine Gelee-Antwort (aber die Eingaben müssen hier zB sortiert werden a<=b)

75 Bytes für die Eingabe a, b+1(dh der Bereich schließt die rechte Grenze aus):

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

Probier diese

Clojure, 102 Bytes

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

Das Mischen von Saiten und Mathe macht keinen Spaß.

J , 35 Bytes

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

Probieren Sie es online!

C (gcc) 90 88 Bytes

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 meiner Java- Antwort . Probieren Sie es hier online aus . Vielen Dank an Ceilingcat für das Golfen von zwei Bytes.

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 Bytes

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

Ein anderer Ansatz als die andere Java-Antwort . Anstatt Streams und Strings zu verwenden, wird eine Schleife verwendet und die Zahlen direkt ausgewertet. Probieren Sie es hier online aus .

Vielen Dank an Ceilingcat für das Golfen von zwei Bytes.

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 Byte

Verwenden von Direktfenster und Zellen [A1] [A2]als Eingabe.

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 Bytes

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

Probieren Sie es online!

twandelt die Zeichenkette in Zahlen um und summiert sie auf. rnimmt den Zahlenbereich von sbis eund filtert die unglücklichen Zahlen heraus. Die ersten drei Ziffern werden von gesammelt n/1000. Die zweiten drei Ziffern werden von berechnet n-(n/1000)*1000.