In Russia abbiamo qualcosa come una tradizione: ci piace cercare biglietti fortunati.

Ecco come appare un biglietto normale:

Come puoi vedere, il biglietto ha un numero di sei cifre.

Un numero di sei cifre è considerato fortunato se la somma delle prime tre cifre è uguale alla somma delle ultime tre.

Il numero sulla foto non è fortunato:

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

Sfida

Dati i limiti di un intervallo (incluso), restituisci il numero di numeri di biglietto fortunato contenuti al suo interno.

parametri

• Input: 2 numeri interi: il primo e l'ultimo numero intero nell'intervallo
• Gli input saranno compresi tra 0 e 999999 inclusi
• Output: 1 intero: quanti numeri fortunati ci sono nell'intervallo
• È possibile prendere gli input e restituire l'output in qualsiasi formato accettabile
• Assumi zeri iniziali per numeri inferiori a 100000.

Esempi

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

Questo è code-golf, quindi vince la risposta più breve in byte in ogni lingua.

Aggiornamento: ecco il fortunato

05AB1E , 8 (o 10?) 11 (o 13?) Byte

Ÿʒ₄n+¦S3ôOË

Provalo online o verifica alcuni altri casi di test .

NOTA: in 05AB1E stringhe e numeri interi sono intercambiabili, quindi i numeri di output non contengono zero iniziali. Questo potrebbe tuttavia essere risolto con 1 byte aggiuntivo ( 12 byte ):

Ÿ₄n+€¦ʒS3ôOË

Provalo online o verifica alcuni altri casi di test .

+3 byte per correggere i bug con una lunghezza di 3 o meno (intervallo [000000, 000999]).

Spiegazione:

Ÿ          # 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: sembra che io (e la maggior parte delle altre risposte) abbia letto male la sfida e viene chiesto il numero di numeri invece dei numeri stessi all'interno dell'intervallo. In tal caso è }gpossibile aggiungere un trailing (chiudere il filtro; e ottenere la quantità di numeri rimasti nell'elenco filtrato), quindi invece sono 10 13 byte :

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

Provalo online o verifica alcuni altri casi di test .

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

Provalo online!

18 byte per using System.Linq;. Supponevo che i formati di input e output potessero essere flessibili. Quindi prendo due numeri interi come input (l'intervallo, compreso).

Alcuni risultati del test:

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

Accetta input nella sintassi del curry (m)(n), dove m è il limite superiore inclusivo esclusivo e n è il limite inferiore inclusivo.

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

Provalo online!

Come?

Testiamo ogni numero camminando attraverso le sue cifre d i e aggiornando un totale t :$n$$d_i$$t$

• se sono rimaste almeno 3 cifre dopo questa$t \gets t - d_i$
• diversamente$t \gets t + d_i$

Se abbiamo alla fine del processo, allora è un numero fortunato.$t=0$$n$

JavaScript (ES6), 67 byte

Stesso formato di input.

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

Provalo online!

Come?

Per ogni numero :$n$

• dividerlo per : ad es$1000$38937 --> 38.937
• forzare in una stringa e dividere: ['3','8','.','9','3','7']
• unisciti a +:"3+8+.+9+3+7"
• sostituire +.con ^:"3+8^+9+3+7"
• valuta come codice JS e verifica se il risultato è : ( XOR )11 $0$24$11$$19$

Se , non viene generato alcun punto decimale e l'espressione valutata è solo una somma positiva (falsa), a meno che (verità). Questo è il risultato atteso in entrambi i casi.$n \equiv 0 \pmod{1000}$$n=0$

Rubino , 56 54 byte

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

Provalo online!

Metodo:

1. Per ogni numero, crea una matrice di cifre (che viene invertita)
2. Confronta la somma delle prime 3 cifre nell'array (ultime 3 nel numero) moltiplicata per 2 con la somma dell'intero array
3. Conta i numeri per i quali le due somme sono uguali

Japt , 38 15 byte

õV Ëì ò3n)mx r¥

-23 grazie a Shaggy!

La mia prima presentazione di Japt; grazie a Shaggy per tutto l'aiuto!

Provalo online!

Python 3, 117 113 106 135 135 byte

Questa è la mia prima risposta in assoluto, quindi sono sicuro che ci sia spazio per miglioramenti.

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 grazie a WW
• -7 byte grazie a Asone Tuhid
• +29 byte per creare una funzione

Ottiene le prime tre cifre tramite la divisione dei numeri interi e le ultime tre tramite il modulo. Il primo e l'ultimo numero intero nell'intervallo vengono immessi come argomenti della xfunzione , rispettivamente come ae b. L'output è n, stampato.

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 byte

Logica più breve alla fine complimenti di @ Giuseppe /

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

Provalo online!

Ingressi interi. Pad con 0. Converti in sei punti di codice ASCII. Abusa dell'integrato F.

Buccia , 12 byte

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

Provalo online!

Spiegazione

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

Carbone , 15 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: inizialmente pensavo che fosse richiesto l'elenco dei numeri fortunati. Questo può essere fatto in 14 byte (rimuovendo il Ｌ, che occupa la lunghezza dell'elenco) o in 20 byte se si desidera una buona formattazione:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

    ＮＮ                  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$_..<>}{

Provalo online!

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

Per emettere ogni ticket invece è +1 byte:

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

Provalo online!

Python 3 , 89 86 byte

-2 grazie a Mr. Xcoder.

-3 ispirato dalla risposta di 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))

Risultati dei test:

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 

Provalo online!

MATL , 24 byte

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

Provalo online!

(-2 byte grazie a Luis Mendo.)

&: - Crea un intervallo inclusivo tra i due numeri indicati

1e3&\ - 'divrem': dividere per 1000 e ottenere i promemoria e i quozienti pavimentati in due matrici.

, - fare due volte

!'03d'&V - trasporre e convertire ciascun valore in una stringa di tre larghezze con riempimento zero

&s - somma i valori di ogni riga

w - passa a far uscire l'array di promemoria e ripeti l'operazione

] - fine loop

= - verifica l'uguaglianza (restituisce 1s nei punti in cui le matrici sono uguali)

s - somma quelli per ottenere il conteggio (output implicito)

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

Provalo online!

Prendendo due numeri interi che convertirli in sei stringhe di simboli e contare.

Ottimizzato grazie a mazzy e alla sua soluzione a 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')}}

Provalo online!

dc , 44 byte

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

Prende due argomenti da uno stack altrimenti vuoto, genera in cima allo stack.

Provalo online!

Il bit intelligente qui è l'uso di una macro senza nome (cioè non memorizzata) che viene duplicata prima dell'esecuzione per eseguire una copia di se stessa sull'altra parte a tre cifre.

Spiegazione

La macro interna [rA~rA~++rx]ha l'effetto "calcola la somma delle cifre del numero di tre cifre che va dal secondo in cima allo stack, quindi esegui la parte superiore originale dello stack come macro".

Programma principale:

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.

Provalo online!

Spiegazione

Ecco prima un codice dall'aspetto normale:

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.

Provalo online!

Quindi ho abusato del comportamento del ciclo for:

• i valori del loop sono precedentemente impostati (da aa b), quindi apossono essere riutilizzati come variabile del loop, rilasciando i;
• alla fine del ciclo for, la variabile del ciclo viene lasciata al valore finale (valore bprima del ciclo). Ho usato bcome contenitore, incrementandolo quando viene trovato un numero fortunato e alla fine del ciclo bè lontano dal suo vecchio valore dalla quantità di numeri fortunati, quindi b-adà il risultato corretto. Questo è caduto s.

La sostituzione dcon operazioni direttamente su aaccorcia il loop. La sostituzione ccon le operazioni direttamente alla adose non riduce il ciclo, ma, dopo la caduta d, i cicli begine endnon sono necessari e ho finito con l'uso di solo 2 variabili :)

$avvia costanti esadecimali nel codice golfizzato. Sebbene non salvino byte, eliminano gli spazi necessari prima delle costanti decimali.

Java (OpenJDK 8) , 162 byte

... prende in prestito dall'esempio di Kotlin sopra.

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

Provalo online!

Il confronto della somma dei byte della stringa è altrettanto efficace della somma delle cifre effettive.

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;

Per eseguirlo:

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

Esempio:

php -n lucky_tickets.php 100 100000

Oppure provalo online!

Perl 6 , 51 49 byte

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

Provalo online!

Blocco di codice anonimo che accetta due numeri e restituisce il numero di quelli fortunati. Timeout per input più grandi

Gelatina ,  9  8 byte

-1 grazie a Dennis ( rµ...E)S-> r...E€Spoiché tutto vettorializza.)

rdȷD§E€S

Un collegamento diadico che accetta i due punti finali dell'intervallo (in entrambi i casi) che fornisce il conteggio dei biglietti fortunati.

Provalo online! O vedi una suite di test

Come?

$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

Script di prova:

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

Produzione:

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

Spiegazione

Contare i numeri dall'intervallo in cui la somma di tutte le cifre dei numeri è uguale alla doppia somma delle prime 3 cifre.

Stax , 14 byte

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

Esegui ed esegui il debug , ma sii paziente!

Python 2 ,  83  80 byte

-3 usando l'osservazione di Asone Tuhid - vai a dare credito!

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

Provalo online!

Proprio come la mia risposta Jelly (ma gli input devono essere ordinati qui cioè a<=b)

75 byte per l'input a, b+1(ovvero l'intervallo esclude il limite destro):

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

Prova questo

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

Mischiare stringhe e matematica non è troppo divertente.

J , 35 byte

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

Provalo online!

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

Porta della mia risposta Java . Provalo online qui . Grazie a ceilingcat per giocare a golf a due byte.

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

Un approccio diverso rispetto all'altra risposta Java . Invece di utilizzare stream e stringhe, utilizza un loop e valuta direttamente i numeri. Provalo online qui .

Grazie a ceilingcat per giocare a golf a due byte.

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

Utilizzo di finestre e celle immediate [A1] [A2]come input.

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

Provalo online!

tconverte la stringa in numeri e li somma. rprende l'intervallo di numeri da sa ee filtra i numeri che sono sfortunati. Le prime tre cifre vengono raccolte da n/1000. Le seconde tre cifre sono calcolate da n-(n/1000)*1000.