Combien d'entiers contiennent un nombre dans une plage spécifique

19

Le programme doit prendre en entrée le nombre, le début de la plage et la fin de la plage et afficher le nombre d'entiers que le nombre apparaît entre le début et la fin de la plage, inclus . Les programmes et les fonctions sont autorisés.

Exemples d'entrées

Par exemple:

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

Les quatre exemples de saisie ci-dessus sont valides et signifient tous que 3c'est le nombre en question, 1le début de la plage et 100la fin de la plage.

Et puis le programme devrait sortir combien de fois 3apparaît dans la plage de 1à 100 inclusif . 3apparaît dans les entiers 3, 13, 23, 30, 31, 32, 33, ..., 93à un total de 19 fois. Ainsi, le programme doit sortir 19en sortie car c'est le nombre de fois qui 3apparaît dans la plage de 1à 100.

Règles

  • Les programmes et les fonctions sont autorisés.
  • Tous les numéros seront entiers, ce qui signifie qu'il n'y aura pas y avoir de floats ou doubles.
  • Remarque: le nombre recherché sera toujours dans la plage 0≤x≤127. Il n'y aura aucun cas où il sera en dehors de cette 0≤x≤127plage.
  • Comme dans le premier exemple, avec le cas comme 33, le nombre 3sera compté comme n'apparaissant qu'une fois , pas deux.
  • Les valeurs de début et de fin de la plage seront comprises entre -65536et 65535inclusives.
  • La valeur du début de la plage ne sera jamais supérieure ou égale à la fin de la plage. start < end
  • La gamme est également incluse. Par exemple, si l'entrée était 8 8 10, la plage serait 8≤x≤10et donc la sortie sera 1.
  • La saisie peut être effectuée de l'une des manières indiquées dans les exemples. L'entrée peut être prise sous la forme d'une chaîne ou d'un nombre, comme vous le souhaitez.

Cas de 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

Snack Snippet

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les rayant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Afficher l'extrait de code

code-golf  math  sequence 
— Kritixi Lithos
source

Réponses:

8

05AB1E , 6 octets

Entrée sous la forme: limite supérieure , la limite inférieure , le numéro .

Ÿvy³åO

Explication:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne!

— Adnan
source
4
Choisit Groovy {a,b,c->} Aww ... dangit, j'ai perdu avant de recommencer.
— Urne de poulpe magique
Félicitations pour avoir remporté ce défi!
— Kritixi Lithos
@KritixiLithos Merci! :)
— Adnan
Alternative à 6 octets:Ÿʒ³å}g
— Kevin Cruijssen
9

Bash, 20 octets

la réponse évidente

seq $2 $3|grep -c $1

exemple

$ bash golf 3 1 100
19
— ardnew
source
6

Perl, 20 octets

Enregistré 2 octets en utilisant grepcomme dans la réponse de @ ardnew .

Bytecount comprend 18 octets de code et d' -apindicateurs.

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

Donnez les 3 nombres sur trois lignes distinctes:

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

Python 2, 47 43 octets

Relativement simple, utilisant la reprforme courte de Python 2 .

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

Sortie:

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
source
Pourquoi avez-vous dû être fantaisiste et utiliser à la -~aplace a+1?
— Artyer
1
@Artyer pour le plaisir!
— Kade
4

JavaScript (ES6), 46 45 octets

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

(Ma meilleure version non récursive était de 61 octets.) Edit: sauvé 1 octet grâce à @ edc65.

— Neil
source
!!matchau lieu de includes.
— edc65
4

Gelée , 7 octets

rAẇ@€⁵S

TryItOnline!

Entrée: Début, Fin, ToFind

Comment?

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

La conversion par défaut d'un entier en un itérable pour le contrôle d'existence de la sous-liste est convertie en une liste décimale (pas une liste de caractères), donc les nombres négatifs ont une valeur négative de tête (par exemple -122-> [-1,2,2]qui ne trouvera pas de sous-liste [1,2]), donc en prenant la la valeur absolue semble d'abord être la solution la plus golfique.

— Jonathan Allan
source
4

PowerShell v2 +, 64 62 56 octets

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

-6 octets grâce à mazzy

Saisie via des arguments de ligne de commande du numéro de formulaire borne inférieure borne supérieure . Un peu maladroit sur la notation, à cause des points-virgules à l'intérieur des forerreurs d'analyse qui se produisent s'il n'est pas entouré $(...)pour créer un bloc de script. Nous bouclons essentiellement vers le haut $ajusqu'à ce que nous frappions $b, en utilisant Where-Object(le |?{...}) pour extraire les nombres -matchcontre lesquels regex $c. C'est encapsulé entre parenthèses, nous prenons .countcelui - ci, et cela reste sur le pipeline et la sortie est implicite.

Si, toutefois, nous garantissons que la plage ne dépassera pas 50 000 éléments, nous pouvons ignorer la boucle et utiliser ..directement l' opérateur de plage , pour 45 43 octets . Comme cela ne fait pas partie des spécifications du défi, cela n'est pas valide. Bummer.

param($c,$a,$b)($a..$b|?{$_-match$c}).count
— AdmBorkBork
source
Génial! Merci pour les informations sur les éléments 50K. Quelques suggestionsparam($c,$a,$b)$(for(;$a-le$b){1|?{$a++-match$c}}).count
— mazzy
Les param($c,$a,$b)($a..$b|?{$_-match$c}).counttravaux avec la gamme -65536..65535 lePowershell 5.1
— mazzy
3

Vim, 46 , 41 octets

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

L'entrée est dans ce format:

1, 100
3
— DJMcMayhem
source
2

Haskell, 65 octets

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

Les importruines du score. Exemple d'utilisation: ((-200)#200)12-> 24.

— nimi
source
L'exemple d'utilisation devrait afficher 24 car 12 apparaît 24 fois entre -200 et 200
— Kritixi Lithos
@KritixiLithos: Oh désolé! Bien sûr, c'est juste une erreur de copier-coller.
— nimi
2

Java 7 85 octets

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

Swift 3, 96 93 octets

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

Modifier 1:

Enregistré 3 octets en utilisant des paramètres abrégés

— Otávio
source
2

Scala, 50 octets

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

prend la première entrée au curry; appelez-le comme ceci: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
source
2

R, 32 octets

Assez simple:

function(a,b,c)sum(grepl(a,b:c))
— Nutle
source
1
Bienvenue chez PPCG! Bonne réponse, mais en supposant que l'entrée est déjà spécifiée n'est généralement pas acceptée. Pour qualifier votre réponse, vous devez soit lire les entrées de stdin telles que: a=scan();sum(grepl(a,a[2]:a[3]))ou les arguments d'une fonction:, function(a,b,c)sum(grepl(a,b:c))tous deux équivalents dans ce cas.
— Billywob
@Billywob merci, gardez cela à l'esprit! modifié la réponse en conséquence.
— Nutle
1

C #, 71 octets

Battre ma réponse Java grâce à lambdas

(t,l,u)=>{int d=0;for(;l<=u;)if((l+++"").Contains(t+""))d++;return d;};
— Yodle
source
Java a aussi des lambdas
— Kritixi Lithos
Ouais, je viens de commencer à lire à ce sujet, mais ne nécessitent-ils pas des trucs standard qui augmenteraient le nombre de bytec, ou je ne peux pas le compter
— Yodle
La réponse javascript de @Grax sans vergogne (n,s,e)=>s>e?0:((""+s).Contains(n+"")?1:0)+f(n,++s,e);est bien plus courte
— hstde
1

Ruby 44 octets

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

Cas de 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
source
1

PHP, 62 octets

Approche assez simple:

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

Essayez-le en ligne

— insertusernamehere
source
Enregistrez 4 octets avec un trait de soulignement ou n'importe quelle lettre comme délimiteur d'expression régulière. (n'a pas besoin de guillemets)
— Titus
Vous pouvez enregistrer 3 octets<?=count(preg_grep("/$argv[1]/",range($argv[2],$argv[3])));
— Jörg Hülsermann
1

C, 143 135 octets

Merci à @Kritixi Lithos pour avoir aidé à économiser 8 octets

Certes, cela peut être mieux fait, mais c'est le meilleur que j'ai pour le moment. C ne gère pas les chaînes très gracieusement, donc naturellement cela prend pas mal d'opérations.

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

Programme non golfé +

#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
source
Je pense que vous pouvez supprimer le int i=lde la boucle for et l'initialiser à la place avec int t=0comme tel int t=0,i=lpour économiser quelques octets.
— Kritixi Lithos
Cela ne compile pas? C (N, l, h) {char b [99], n [99]; int t = 0, i = l; sprintf (n, "% d", N); for (; i <= h; i ++ ) {sprintf (b, "% d", i); if (strstr (b, n)) ++ t;} return t;} Je pense que compiler même sans inclure ...
— RosLuP
93 octetsb[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;}
— plafond du
1

JavaScript, 46 45 octets

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

Comptez récursivement jusqu'à début> fin

Modifier: passer au test RegExp pour enregistrer un octet

— Grax32
source
1

PHP, 68 63 octets

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

utiliser comme:

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

edit: 5 octets enregistrés grâce à Titus

— user59178
source
strstr($a[2]++,$a[1])>""au lieu d' strpos($a[2]++,$a[1])!==falseenregistrer 5 octets.
— Titus
1

Powershell, 48 octets

Selon la règle, la plage peut contenir plus de 50 000 éléments. Nous ne pouvons donc pas utiliser ..directement l' opérateur de plage . Merci AdmBorkBork .

Simple:

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

Script de test:

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

Production:

True: 19
True: 19
True: 24
True: 0
True: 2
True: 1
True: 0
True: 44175
— mazzy
source
1

Japt , 14 8 octets

Prend l'entier à trouver comme dernière valeur d'entrée.

õV èÈsøW

Essayez-le en ligne

Explication

             :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
— Hirsute
source
Comme les versions précédentes manquent d'explication, je n'en suis pas sûr, mais votre solution actuelle à 6 octets est incorrecte, je le crains. Voir cette règle: " Comme dans le premier exemple, avec le cas comme 33, le nombre 3sera compté comme n'apparaissant qu'une fois, pas deux. " Votre nombre d'occurrences pour Wcompterait les 3deux fois.
— Kevin Cruijssen
Merci, @KevinCruijssen, y est revenu ~ un mois plus tard et se demandait pourquoi je le faisais comme je l'étais alors qu'il y avait un moyen plus court - aurait dû relire le défi avant la mise à jour! Je l'ai annulé maintenant.
— Shaggy
J'ai eu la même chose à plusieurs reprises. Je vois ma réponse, pense: cela peut être beaucoup plus facile, je la change. Et juste avant d'appuyer sur Enregistrer les modifications, je vois que j'interprète mal le défi. Btw, je suis toujours curieux de savoir l'explication de la solution à 8 octets. :)
— Kevin Cruijssen
1
@KevinCruijssen: explication ajoutée.
— Shaggy
0

Java, 92 89 71 octets

Maintenant avec les lambdas!

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

Ancienne solution de fonction à 89 octets:

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

Hourra pour la fonction super incrément!

— Yodle
source
Vous pouvez supprimer int i=lde la boucle for et le déclarer à la place avec alike int a=0,i=l;pour économiser quelques octets
— Kritixi Lithos
Ah je savais que j'avais raté quelque chose, merci!
— Yodle
1
Fondamentalement, la même chose que cette réponse .
— Kritixi Lithos
0

GolfSharp (hors compétition), 41 octets

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

en concurrence avec 45 octets

(w,q,e)=>r(q,1+e-q).w(n=>n.T().I(w.T())).L();
— downrep_nation
source
1
Le dernier commit était il y a 8 minutes, donc pour que cela soit une réponse concurrente, cela devait fonctionner avant le début du défi. Pouvez-vous vérifier cela?
— Kade
Je pense que si ce n'est pas le cas, je le changerai en non concurrent, éditer les bugs corrigés est nécessaire. va changer maintenant (j'utilise des défis pour améliorer la langue)
— downrep_nation
2
Le code commit il y a 8 minutes a changé la Ifonction pour convertir l'élément en chaîne avant de vérifier s'il en contient.
— Kade
0

Raquette 91 octets

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

Non golfé: 

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

Essai: 

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

Production: 

19
19
24
0
2
1
— rnso
source
0

Octets d'axiome 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)

résultats

(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
source
0

Mathematica, 70 octets

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

contribution

[12, -200.200]

production

24

— J42161217
source
0

Clojure, 65 octets

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

PHP, 56 octets

run as pipe Essayez-le en ligne

Contribution

$argv = [number_to_find, range_start, range_end];

Code

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

Explication

#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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.