Quanti numeri interi contengono un numero in un intervallo specifico

19

Il programma dovrebbe inserire input il numero, l'inizio dell'intervallo e la fine dell'intervallo e produrre quanti numeri interi il numero appare tra l'inizio e la fine dell'intervallo, inclusi . Sono consentiti sia programmi che funzioni.

Ingressi di esempio

Per esempio:

//Input example 1
3,1,100
//Input example 2
3
1
100
//Input example 3
3 1 100
//Input example 4
a(3, 1, 100);

Tutti i quattro esempi di input sopra riportati sono validi e tutti significano che 3è il numero in questione, 1è l'inizio dell'intervallo e 100la fine dell'intervallo.

E poi il programma dovrebbe uscita quante volte 3compare nel campo da 1al 100 inclusiva . 3appare nei numeri interi 3, 13, 23, 30, 31, 32, 33, ..., 93per un totale di 19 volte. Quindi il programma dovrebbe essere emesso 19come output perché è il numero di volte che 3appare nell'intervallo da 1a 100.

Regole

  • Sono consentiti sia programmi che funzioni.
  • Tutti i numeri saranno interi, il che significa che non ci sarà , non sarà alcun floats o doubles.
  • Nota: il numero cercato sarà sempre nell'intervallo 0≤x≤127. Non ci sarà alcun casi in cui sarà fuori di questo 0≤x≤127intervallo.
  • Come nel primo esempio, con il caso come 33, il numero 3verrà conteggiato come visualizzato una sola volta , non due volte.
  • I valori di inizio e fine dell'intervallo saranno compresi -65536e 65535compresi.
  • Il valore di inizio dell'intervallo non sarà mai superiore o uguale alla fine dell'intervallo. start < end
  • Anche la gamma è inclusiva. Ad esempio, se l'ingresso fosse 8 8 10, l'intervallo sarebbe 8≤x≤10e quindi l'uscita sarà 1.
  • L'input può essere preso in uno dei modi mostrati negli esempi. L'input può essere preso come una stringa o come un numero, come preferisci.

Casi test

3 1 100
19

3 3 93
19

12,-200,200
24          //This is because 12 appears in -129, -128, ..., -112, -12, 12, 112, 120, 121, 122, ...

123,1,3
0           //This is because all of 123's digits have to appear in the same order

3 33 34
2           //Because 3 appears in 2 numbers: 33 and 34

a(0,-1,1);
1

$ java NotVerbose 127 -12 27
0

Snippet di snack

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

# Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostra snippet di codice

code-golf  math  sequence 
— Kritixi Lithos
fonte

Risposte:

8

05AB1E , 6 byte

Inserire nella forma: limite superiore , limite inferiore , numero .

Ÿvy³åO

Spiegazione:

Ÿ       # Inclusive range, [a, ..., b]
 vy     # For each element...
   ³å   # Check if the third input is a substring of the number
     O  # Sum up the results

Utilizza la codifica CP-1252 . Provalo online!

— Adnan
fonte
4
Scegli Groovy {a,b,c->} Aww ... dannazione, ho perso prima di ricominciare.
— Magic Octopus Urn
Complimenti per aver vinto questa sfida!
— Kritixi Lithos,
@KritixiLithos Grazie! :)
— Adnan,
Alternativa a 6 byte:Ÿʒ³å}g
— Kevin Cruijssen,
9

Bash, 20 byte

la risposta ovvia

seq $2 $3|grep -c $1

esempio

$ bash golf 3 1 100
19
— ardnew
fonte
6

Perl, 20 byte

Salvato 2 byte usando grepcome nella risposta di @ ardnew .

Bytecount include 18 byte di codice e -apflag.

$_=grep/@F/,<>..<>

Dai i 3 numeri su tre righe separate:

perl -ape '$_=grep/@F/,<>..<>' <<< "3
1
100"
— Dada
fonte
5

Python 2, 47 43 byte

Relativamente semplice, usando la reprforma breve di Python 2 .

f=lambda n,a,b:a<b and(`n`in`a`)+f(n,-~a,b)

ouput:

f(  3,    1, 100) -> 19
f(  3,    3,  93) -> 19
f( 12, -200, 200) -> 24
f(123,    1,   3) -> 0
f(  3,   33,  34) -> 2
f(  0,   -1,   1) -> 1
f(127,   12,  27) -> 0
— Kade
fonte
Perché hai dovuto essere tutto di fantasia e usare al -~aposto di a+1?
— Artyer,
1
@Artyer per divertimento!
— Kade,
4

JavaScript (ES6), 46 45 byte

f=(n,s,e)=>s<=e&&!!`${s++}`.match(n)+f(n,s,e)

(La mia migliore versione non ricorsiva era di 61 byte.) Modifica: salvato 1 byte grazie a @ edc65.

— Neil
fonte
!!matchinvece di includes.
— edc65,
4

Gelatina , 7 byte

rAẇ@€⁵S

TryItOnline!

Input: Start, End, ToFind

Come?

rAẇ@€⁵S - Main link: Start, End, ToFind
r       - range: [Start, ..., End]
 A      - absolute values
     ⁵  - third input: ToFind
  ẇ@€   - sublist exists in with reversed @rguments for €ach
      S - sum

Il casting predefinito di un numero intero in un iterabile per il controllo dell'esistenza dell'elenco secondario viene lanciato in un elenco decimale (non un elenco di caratteri), quindi i numeri negativi hanno un valore negativo iniziale (ad es. -122-> [-1,2,2]che non troverà un elenco secondario di [1,2]) quindi prendendo il il valore assoluto per primo sembra la soluzione più golfistica.

— Jonathan Allan
fonte
4

PowerShell v2 +, 64 62 56 byte

param($c,$a,$b)$(for(;$a-le$b){1|?{$a++-match$c}}).count

-6 byte grazie a mazzy

Immissione tramite argomenti della riga di comando del numero di modulo lower_bound upper_bound . Un po 'sciocco sulla notazione, a causa dei punti e virgola all'interno degli forerrori di analisi che causano se non è circondato $(...)per creare un blocco di script. Fondamentalmente $aci muoviamo verso l'alto fino a quando non colpiamo $b, usando Where-Object(il |?{...}) per estrarre quei numeri che regex -matchcontro $c. È incapsulato in parentesi, ne prendiamo la .countstessa, che rimane sulla pipeline e l'output è implicito.

Se, tuttavia, garantiamo che l'intervallo non sarà superiore a 50.000 elementi, possiamo saltare il loop e utilizzare ..direttamente l' operatore di intervallo , per 45 43 byte . Dal momento che non è nelle specifiche della sfida, tuttavia, questo non è valido. Bummer.

param($c,$a,$b)($a..$b|?{$_-match$c}).count
— AdmBorkBork
fonte
Grande! Grazie per le informazioni sugli elementi 50K. Un paio di suggerimentiparam($c,$a,$b)$(for(;$a-le$b){1|?{$a++-match$c}}).count
— mazzy,
Le param($c,$a,$b)($a..$b|?{$_-match$c}).countopere con gamma -65536..65535 suPowershell 5.1
— Mazzy
3

Vim, 46 , 41 byte

C<C-r>=r<tab><C-r>")<cr><esc>jC0<esc>:g/<C-r>"/norm G<C-v><C-a>
kd{

L'input è in questo formato:

1, 100
3
— DJMcMayhem
fonte
2

Haskell, 65 byte

import Data.List
(s#e)i=sum[1|x<-[s..e],isInfixOf(show i)$show x]

Le importrovine del punteggio. Esempio di utilizzo: ((-200)#200)12-> 24.

— Nome del modello
fonte
L'esempio di utilizzo dovrebbe generare 24 perché 12 appare 24 volte tra -200 e 200
— Kritixi Lithos,
@KritixiLithos: Oh scusa! Ovviamente, è solo un errore di copia e pase.
— nimi,
2

Java 7 85 byte

int x(int a,int b,int c){int t=0;for(;b<=c;)if((b+++"").contains(a+""))t++;return t;}
— Numberknot
fonte
2

Swift 3, 96 93 byte

import Cocoa
func c(n:Int,s:Int,e:Int){print((s...e).filter{"\($0)".contains("\(n)")}.count)}

Modifica 1:

Salvato 3 byte utilizzando i parametri di stenografia

— Otávio
fonte
2

Scala, 50 byte

(c:String)=>(_:Int)to(_:Int)count(""+_ contains c)

prende il primo input al curry; chiamalo così:f("12")(-200,200)

explantion:

(c:String)=>  //define an anonymous function taking a string parameter
  (_:Int)     //create a range from an anonymous int parameter
  to          //to
  (_:Int)     //another anonymous int parameter
  count(      //and count how many...
   ""+_       //elements converted to a string
   contains c //contain c
  )
— corvus_192
fonte
2

R, 32 byte

Abbastanza semplice:

function(a,b,c)sum(grepl(a,b:c))
— Nutle
fonte
1
Benvenuti in PPCG! Bella risposta, ma supponendo che l'input sia già specificato non è generalmente accettato. Per qualificare la tua risposta dovresti o leggere l'input da stdin come: a=scan();sum(grepl(a,a[2]:a[3]))o come argomento di una funzione function(a,b,c)sum(grepl(a,b:c)):, entrambi equivalenti in questo caso.
— Billywob,
@Billywob grazie, lo terrò a mente! modificato la risposta di conseguenza.
— Nutle,
1

C #, 71 byte

Batti la mia risposta Java grazie a lambdas

(t,l,u)=>{int d=0;for(;l<=u;)if((l+++"").Contains(t+""))d++;return d;};
— Yodle
fonte
Java ha anche lambda
— Kritixi Lithos,
Sì, ho appena iniziato a leggerlo, ma non hanno bisogno di alcune cose sulla piastra di cottura che renderebbero più grande il contatore, o non posso contarlo
— Yodle
La risposta javascript di @Grax sfrontatamente spudoratamente (n,s,e)=>s>e?0:((""+s).Contains(n+"")?1:0)+f(n,++s,e);è molto più breve
— hstde
1

Ruby 44 byte

m=->(n,s,f){(s..f).count{|x|x.to_s[/#{n}/]}}

Casi test:

m.(3,1,100)     #=> 19
m.(3,3,93)      #=> 19
m.(12,-200,200) #=> 24
m.(123,1,3)     #=>  0
m.(3,33,34)     #=>  2
m.(0,-1,1)      #=>  1
m.(127,-12,27)  #=>  0
— Alexis Andersen
fonte
1

PHP, 62 byte

Approccio piuttosto diretto:

<?=count(preg_grep('/'.($a=$argv)[1].'/',range($a[2],$a[3])));

Provalo online

— insertusernamehere
fonte
Salva 4 byte con trattino basso o qualsiasi lettera come delimitatore regex. (non ha bisogno di virgolette)
— Tito
Puoi salvare 3 byte<?=count(preg_grep("/$argv[1]/",range($argv[2],$argv[3])));
— Jörg Hülsermann
1

C, 143 135 byte

Grazie a @Kritixi Lithos per aver contribuito a salvare 8 byte

Sicuramente questo può essere fatto meglio, ma è il migliore che ho per ora. C non gestisce le stringhe con molta grazia, quindi naturalmente ci vogliono parecchie operazioni.

int C(int N,int l,int h){char b[99],n[99];int t=0,i=1;sprintf(n,"%d",N);for(;i<=h;i++){sprintf(b,"%d",i);if(strstr(b,n))++t;}return t;}

Ungolfed + programma

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

int C(int N,int l,int h)
{
    char b[99], n[99];
    int t=0,i=1;
    sprintf(n,"%d",N);
    for(;i<=h;i++)
    {
        sprintf(b,"%d",i);
        if(strstr(b,n))
            ++t;
    }
    return t;
}

int main()
{
  printf("%d\n", C(3, 1, 100));
}
— Cody
fonte
Penso che sia possibile rimuovere il int i=ldal for-loop e invece inizializzarlo con int t=0un tale tipo int t=0,i=lper salvare qualche byte.
— Kritixi Lithos,
Questo non compilare? C (N, l, h) {char b [99], n [99]; int t = 0, i = l; sprintf (n, "% d", N); per (; i <= h; i ++ ) {sprintf (b, "% d", i); if (strstr (b, n)) ++ t;} return t;} Penso che compili anche senza includere ...
— RosLuP
93 byteb[9],n[9],t;C(N,l,h){for(t=!sprintf(n,"%d",N);l<=h;strstr(b,n)&&++t)sprintf(b,"%d",l++);N=t;}
— plafoniera
1

JavaScript, 46 45 byte

f=(i,s,e)=>s>e?0:RegExp(i).test(s)+f(i,++s,e)

Conteggio ricorsivo fino all'inizio> fine

Modifica: passa al test RegExp per salvare un byte

— Grax32
fonte
1

PHP, 68 63 byte

for($a=$argv;$a[2]<=$a[3];)$o+=strstr($a[2]++,$a[1])>'';echo$o;

usare come:

 php -r "for($a=$argv;$a[2]<=$a[3];)$o+=strstr($a[2]++,$a[1])>'';echo$o;" 3 1 100

modifica: 5 byte salvati grazie a Titus

— user59178
fonte
strstr($a[2]++,$a[1])>""invece di strpos($a[2]++,$a[1])!==falsesalvare 5 byte.
— Tito
1

Powershell, 48 byte

Secondo la regola, l'intervallo può contenere più di 50.000 elementi. Quindi non possiamo usare ..direttamente l' operatore di distanza . Grazie AdmBorkBork .

semplice:

param($c,$a,$b)for(;$a-le$b){$i+=$a++-match$c}$i

Script di prova:

$f = {

param($c,$a,$b)for(;$a-le$b){$i+=$a++-match$c}$i

}

@(
    ,(19, 3,1,100)
    ,(19, 3,3,93)
    ,(24, 12,-200,200)
    ,(0, 123,1,3)
    ,(2, 3,33,34)
    ,(1, 0,-1,1)
    ,(0, 127,-12,27)
    ,(44175, 0,-65536,65535)
) | % {
    $e,$a = $_
    $r = &$f @a
    "$($e-eq$r): $r"
}

Produzione:

True: 19
True: 19
True: 24
True: 0
True: 2
True: 1
True: 0
True: 44175
— Mazzy
fonte
1

Japt , 14 8 byte

Prende l'intero da trovare come ultimo valore di input.

õV èÈsøW

Provalo online

Spiegazione

             :Implicit input of integers U=start, V=end & W=number
õV           :Range [U,V]
    È        :Map
     s       :  Convert to string
      øW     :  Contains W?
   è         :Count truthy values
— ispido
fonte
Dal momento che le versioni precedenti mancano di una spiegazione, non ne sono sicuro, ma temo che la tua attuale soluzione a 6 byte non sia corretta. Vedi questa regola: " Come nel primo esempio, con il caso come 33, il numero 3verrà contato come visualizzato solo una volta, non due volte. " Il conteggio delle occorrenze per Wconterebbe il 3doppio.
— Kevin Cruijssen,
Grazie, @KevinCruijssen, ci sono tornato ~ un mese dopo e mi chiedevo perché lo stavo facendo come prima quando c'era un modo più breve - avrei dovuto rileggere la sfida prima di aggiornare! L'ho riavviato ora.
— Shaggy,
Ho fatto succedere la stessa cosa alcune volte. Vedo la mia risposta, penso: può essere molto più semplice, la sto cambiando. E proprio prima di premere Salva modifiche vedo che ora interpreto male la sfida. A proposito, sono ancora curioso della spiegazione per la soluzione a 8 byte. :)
— Kevin Cruijssen,
1
@KevinCruijssen: aggiunta spiegazione.
— Shaggy,
0

Java, 92 89 71 byte

Ora con lambdas!

(t,l,u)->{int z=0;for(;l<=u;)if((l+++"").contains(t+""))z++;return z;};

Vecchia soluzione con funzioni a 89 byte:

int d(int t,int l,int u){int a=0,i=l;for(;i<=u;)if((i+++"").contains(t+""))a++;return a;}

Evviva la funzione di super incremento!

— Yodle
fonte
È possibile rimuovere int i=ldal for-loop e invece dichiararlo con alike int a=0,i=l;per salvare pochi byte
— Kritixi Lithos,
Ah, sapevo di aver perso qualcosa, grazie!
— Yodle,
1
Sostanzialmente uguale a questa risposta .
— Kritixi Lithos,
0

GolfSharp (non concorrenziale), 41 byte

(w,q,e)=>r(q,1+e-q).w(n=>n.T().I(w)).L();

concorrenti di 45 byte

(w,q,e)=>r(q,1+e-q).w(n=>n.T().I(w.T())).L();
— downrep_nation
fonte
1
L'ultimo commit è stato effettuato 8 minuti fa, quindi per essere una risposta in competizione è necessario che funzionasse prima dell'inizio della sfida. Puoi verificarlo?
— Kade,
Penso di sì, se no lo cambierò in non concorrente, sono necessari i bug corretti. cambierà ora (utilizzo le sfide per migliorare la lingua)
— downrep_nation
2
Il commit del codice 8 minuti fa ha cambiato la Ifunzione per convertire l'elemento in una stringa prima di verificare se lo contiene.
— Kade,
0

Racchetta 91 byte

(for/sum((i(range s(+ 1 e))))(if(string-contains?(number->string i)(number->string d))1 0))

Ungolfed: 

(define(f d s e)
  (for/sum ((i (range s (+ 1 e))))
    (if(string-contains?
        (number->string i)
        (number->string d))
       1 0 )))

test: 

(f 3 1 100)
(f 3 3 93)
(f 12 -200 200)
(f 123 1 3)
(f 3 33 34)
(f 0 -1 1)

Produzione: 

19
19
24
0
2
1
— rnso
fonte
0

Byte Axiom 90

f(y,a,b)==(c:=0;for x in a..b repeat(if position(y::String,x::String,1)~=0 then c:=c+1);c)

risultati

(3) -> f(3,1,100)=19,f(3,3,93)=19,f(12,-200,200)=24,f(123,1,3)=0,f(3,33,34)=2
   (3)  [19= 19,19= 19,24= 24,0= 0,2= 2]
                                  Type: Tuple Equation NonNegativeInteger
(4) -> f(0,-1,1)=1, f(127,12,27)=0
   (4)  [1= 1,0= 0]
                                  Type: Tuple Equation NonNegativeInteger
— RosLuP
fonte
0

Mathematica, 70 byte

(w=ToString;t=0;Table[If[StringContainsQ[w@i,w@#1],t++],{i,#2,#3}];t)&

ingresso

[12, -200.200]

produzione

24

— J42161217
fonte
0

Clojure, 65 byte

#(count(for[i(range %2(inc %3)):when(some(set(str %))(str i))]i))
— NikoNyrh
fonte
0

PHP, 56 byte

esegui come pipe Provalo online

Ingresso

$argv = [number_to_find, range_start, range_end];

Codice

<?=substr_count(join(range(($a=$argv)[1],$a[2])),$a[0]);

Spiegazione

#substrcount, counts the aparitions of a subtring in a string
substr_count( 
           join( range(($a=$argv)[1],$a[2])), # String with the range
           $a[0]);                            # The number you are looking for
— Francisco Hahn
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.