Contribution

Un entier n (≥ 1) et un chiffre d (un entier tel que 0 ≤  d  ≤ 9).

Dans l'un ou l'autre ordre; de stdin ou des paramètres ou autre chose; à un programme ou une fonction; etc.

Sortie

Les entiers de 1 à n inclus (dans l’ordre) dont les représentations décimales contiennent un nombre pair de d s. (C'est-à-dire que les entiers dans la liste sont les entiers qui ont respectivement un nombre pair de d s.)

Dans tout format standard, etc. En particulier, la sortie ne doit pas être représentée en décimal.

En cas de sortie sous forme de chaîne unique, les entiers doivent être séparés d'une manière ou d'une autre (espaces, virgules, nouvelles lignes, octets nuls, peu importe).

Exemples

in(d,n) ↦ out
1,12    ↦ 2 3 4 5 6 7 8 9 11
0,111   ↦ 1,2,3,4,5,6,7,8,9,11,12,13,14,15,16,17,18,19,21,22,23,24,25,26,27,28,29,31,32,33,34,35,36,37,38,39,41,42,43,44,45,46,47,48,49,51,52,53,54,55,56,57,58,59,61,62,63,64,65,66,67,68,69,71,72,73,74,75,76,77,78,79,81,82,83,84,85,86,87,88,89,91,92,93,94,95,96,97,98,99,100,111

Merci

À quintopia pour le titre.

Gelée, 7 octets

RDċ€Ḃ¬T

Essayez-le en ligne!

Comment ça marche

RDċ€Ḃ¬T  Main link. Arguments: n, d

R        Range; yield [1, ..., n].
 D       Convert each integer in the range to base 10.
  ċ€     Count the occurrences of d in each array of decimal digits.
    Ḃ    Compute the parities.
     ¬   Negate, so even amounts evaluate to 1, odds to 0.
      T  Find all indices of truthy elements.

05AB1E , 11 à 10 octets

Code:

\>GN¹¢ÈiN,

Explication:

\           # Pop input, which saves the first input into ¹
 >          # Increment on second input
  G         # For N in range(1, input + 1)
   N        # Push N
    ¹       # Push the first input from the input register
     ¢      # Count the number of occurences of the digit in N
      È     # Is even?
       iN,  # If true, print N with a newline

Essayez-le en ligne

Utilise le codage CP-1252 .

Haskell, 69 63 52 50 octets

d#n=[i|i<-[1..n],even$sum[1|x<-show i,read[x]==d]]

La solution directe pour mon premier post ici. Il utilise showpour compter le nombre de d'. Je n'ai pas explicitement utilisé Charcomme entrée pour d, ce qui aurait permis de sauvegarder 12 6 octets (après l'édition de Damien).

EDIT: 11 octets en moins grâce à Damien! EDIT 2: encore 2 octets en moins grâce à nimi!

Befunge, 1080 945 octets

vd>"000">" "v
&0      ^              p21-1+*68<
62            >        v
8           >-|        >12g68*-:|
*             >11g1+11p^        $
+                      v  <
5                         |%2g11<
5                      v.:<          
+         v            <        
0         >268*+12p68*11p"000"40p50p60pv
p
           v                             -1<
             v-g01p06+1g06<
>&         >:>:10g1-`     |            >:0`|
             v            <                @
             v-+55p05+1g05<      
             >:54+`       |
   v               p04+g04<
  ^          <                <      <
   >60g68*-0`|      >50g68*-0`|
             >" "60p^         >" "50p^

Le score est donné que nous comptons tout le carré, y compris les nouvelles lignes, ce qui est logique. Vous pouvez copier coller le code dans l'interpètre . Fournissez deux entrées, d'abord d puis n . Cette solution ne fonctionne pas pour les valeurs supérieures à n > 999.

Ce ne sera évidemment pas un prétendant au grand prix, mais cela fait un moment que je veux implémenter un code-golf à Befunge, alors j'ai décidé de le faire. Je pense que cela ne sera même pas proche d'une solution optimale de Befunge, car c'est la première chose que j'ai faite à Befunge. Alors, les astuces sont les bienvenues, si vous avez besoin d'éclaircissements ou d'informations supplémentaires, merci de me le faire savoir dans les commentaires.

Tentative d'explication:

Dans la première colonne, nous lisons un entier à partir de l'entrée, ajoutez-y 48 (6 * 8, vous le verrez plus souvent) pour le convertir en valeur ASCII correspondante et le mettre à (10, 0).

& - lire l'entrée

68*+ - ajouter 48

55+0p - mettre la valeur à (10, 0)

Notez que le d at (1, 0)est un moyen simple d’obtenir le nombre 100 sur la pile.

Après cela, nous allons à l’est et lisons un autre entier et nous dirigeons vers ce que j’appelle le ASCIIfier. Cela transforme le numéro actuel en une série de caractères ASCII. ASCIIfier est la pièce rectangulaire de (13, 12)à (26, 17). Il consiste en deux boucles, qui comptent d’abord les centaines et les dizaines puis les placent dans les trois chiffres de (6, 0)et (5, 0). Après cela, le dernier chiffre est mis en(4, 0) . Les chiffres sont donc inversés.

v-g01p06+1g06< - increment the "hunderds counter" located at (0, 6) and decrease current value by 100
>:10g1-`     | - ASCIIfier entry; check if the current value is > 99, if so, go up, else go down
v            < - go to start of "tens counter"
v-+55p05+1g05< - increment the "tens counter" located at (0, 5) and decrease current value by 10
>:54+`       | - check if current value is > 9, if so, go up, else go down
      p04+g04< - put the final value into the "singles counter" located at (0, 4)

Après avoir placé l'entier actuel dans une série de caractères ASCII, nous allons un peu plus au sud pour supprimer les zéros ajoutés. Ainsi, par la suite, ce qui est initialement les trois zéros en haut, sera le nombre actuel, sans les zéros ajoutés.

Ensuite, nous remontons vers le nord, où nous mettons les trois chiffres sur la pile. Nous parcourons les trois chiffres de la boucle supérieure en incrémentant à chaque fois le compteur situé à (1, 1)si le chiffre actuel correspond à l'entrée d

Lorsque cela est fait, nous vérifions si le compteur situé à (1, 1)est impair ou pair. S'il est égal, nous émettons le nombre actuel et passons à la grande boucle externe pour décrémenter la valeur actuelle et recommencer.

Python 2, 50 octets

f=lambda d,n:n*[0]and f(d,n-1)+~`n`.count(d)%2*[n]

Une fonction récursive qui prend le chiffre en dtant que chaîne et la limite supérieuren sous forme de nombre.

Le nombre de chiffres ddans nest testé pour être pair en prenant son complément de bit modulo 2, ce qui donne 1pour pair et 0pour impair. Ce nombre nest ajouté à la liste et la fonction est renvoyée à n-1, s'arrêtant via un court-circuit logique sur la liste vide lorsquen==0 .

Si la sortie peut être donnée en ordre décroissant, un octet peut être sauvegardé, pour 49 octets:

f=lambda d,n:n*[0]and~`n`.count(d)%2*[n]+f(d,n-1)

Ancienne solution à 51 octets:

lambda d,n:[x+1for x in range(n)if~`~x`.count(d)&1]

Une fonction anonyme qui prend le chiffre en dtant que chaîne et la limite supérieuren sous forme de nombre.

Deux astuces sont utilisées:

• Python rangeétant indexé à zéro 0...n-1, nous en ajoutons un à chaque valeur potentielle x. Ensuite, compter d« s en x+1, il enregistre un caractère à utiliser sa négation~x à la place.
• Pour filtrer les valeurs paires, nous effectuons le ~_%2premier basculement de bit pour changer de parité, puis prenons le dernier bit avec &1(comme %2ici), produisant une valeur de vérité uniquement si l'original était pair.

Pyth, 10 octets

f!%/`Tz2SE

Essayez-le en ligne. Suite de tests.

Lua, 86 Bytes

Si l'utilisation d'un séparateur incohérent est autorisée, je pourrais remplacer io.writeparprint , ce qui signifie que les nombres seraient séparés par une ou plusieurs nouvelles lignes.

Ceci est un programme complet, qui doivent être appelé comme ceci: lua file.lua d n.

Il supprime tous les non- dcaractères du nombre actuel et utilise la taille de la chaîne résultante pour décider si elle doit ou non être sortie.

for i=1,0+arg[2]do io.write(#(i..''):gsub("[^"..arg[1].."]","")%2<1 and i.." "or"")end

JavaScript (ES6) 64

Une fonction anonyme avec sortie sur console. Mise en œuvre simple utilisant splitle décompte des chiffres.

(d,n)=>{for(i=0;i++<n;)(i+'').split(d).length&1&&console.log(i)}

La sortie utilisant alertserait moins de 6 octets, mais je n'aime vraiment pas ça (et je ne vais pas battre les langues du jouet de toute façon)

MATL , 12 à 10 octets

:!V!=s2\~f

La première entrée est n , la seconde est d en tant que chaîne. Par exemple:

12
'1'

Essayez-le en ligne!

:       % implicitly take input n (number). Generate row vector [1,2,...,n]
!       % transpose into column vector
V       % convert each number to string. Gives 2D char array padded with spaces
!       % transpose
=       % implicitly take input d (string). Compare with each element of the array
s       % sum of each column: number of coincidences with d
2\~     % true for even values
f       % find indices of true values. Implicitly display

Ruby, 47 42 octets

?1.upto $*[1]{|s|s.count($*[0])%2<1&&p(s)}

Exécuter avec d et n comme paramètres de ligne de commande, par exemple

ruby golf.rb 1 12

PowerShell, 62 55

param($1,$2);1..$2|?{!(([char[]]"$_"-match$1).Count%2)}

edit: utiliser un bloc param dans ce cas est plus court. enlevé de l'espace redondant

Pas une langue de golf mais c’est le seul que je connaisse vraiment. Cela fonctionnerait enregistré en tant que script et appelé comme ceci M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12. Le premier argument est le chiffre d et le second est le nombre entier n .

Créez un tableau du nombre 1 à n . Pour chacun de ceux-ci, convertissez cela en un tableau de caractères. 10 serait 1,0. L'utilisation en -matchtant qu'opérateur de tableau renvoie tous les éléments correspondant au chiffre d . Comptez le nombre d'éléments retournés et mod 2 le résultat. Le résultat sera 0 pour pair et 1 pour impair. 0 étant un booléen faux, nous utilisons donc !pour la boucle l'évaluation des résultats impairs à faux et des résultats pairs à vrais.

La sortie est une nouvelle ligne délimitée sur la console.

Retina , 99 à 105 octets

Notez les espaces de fin. <empty>représente une ligne vide.

\d+$
$*
+`^(. )(1*)1\b
$1$2 1$2
1+
$.0
+`^(.)(.*) ((?!\1)\d)*\1((?!\1)\d|(\1)((?!\1)\d)*\1)*\b
$1$2
^.  
<empty>

Prend les entrées comme 1 12. La sortie est séparée par espace en ordre décroissant.

J'ai modifié 0*1(0|10*1)*pour correspondre à un nombre impair de \1dans un nombre. J'ai changé 0pour (?!\1)\d, et 1pour \1créer la longue ligne de regex que vous voyez ci-dessus. Comprendre le fonctionnement de la regex liée est crucial.

Essayez-le en ligne

Explication commentée de l'ancienne version

Si l'ordre décroissant était correct

\d+$            Convert last number N to unary
$*
+`1(1*)$        Create list N N-1 ... 1 in unary
$0 $1
 (1)+           Convert back to decimal
 $#1
+`^(.)(.*) ((?!\1)\d)*\1((?!\1)\d|(\1)((?!\1)\d)*\1)*   Remove numbers w/ odd num of D's
$1$2 
^.              Remove first parameter
<empty>

Utilitaires Bash + GNU, 37

• 1 octet enregistré grâce à @Ruud.

seq $1|egrep "^[^$2]*($2[^$2]*){2}*$"

Python 3.4, 92 85 79 85 octets

Sauvegardé 7 octets grâce à Mego
Sauvegardé 6 autres octets grâce à mbomb007
ces 6 octets car Python 3.x

Ceci est mon premier coup au code de golf, alors rien ne va ici!

lambda n,d:[i for i in range(n+1)if len([j for j in list(str(i))if j==str(d)])%2is 0]

Perl 6, 38 octets

{(1..$^n).grep(*.comb.Bag{~$^d} %% 2)}

Brachylog , 32 octets

:1reIlL,"":Ic:.xl-L=%2=0,Iw,@Sw\

Attend N en entrée et le chiffre en sortie, par exemple brachylog_main(12,1).

Explication

:1reI                            § I is a number between 1 and Input
     lL,                         § L is the length of I
        "":Ic                    § Convert I to a string
             :.x                 § Remove all occurences of Output in that string
                l-L=%2=0,        § Check that the length of that new string - L mod 2 is 0
                         Iw,@Sw  § Write I, then write a space
                               \ § Backtrack (i.e. try a new value of I)

Mathematica, 54 octets

Position[Count[#2]/@IntegerDigits/@Range@#,x_/;2∣x]&

Perl, 28 29 31 octets

Comprend +2 pour -an

Exécutez avec le chiffre de spécification et comptez sur des lignes consécutives sur STDIN:

echo -e "0\n111" | perl -anE'map s/@F/$&/g%2||say,1..<>'

Oracle SQL 11.2, 111 82 octets

SELECT LEVEL FROM DUAL WHERE MOD(REGEXP_COUNT(LEVEL,:d),2)=0 CONNECT BY LEVEL<=:n;

Kotlin, 136 octets

fun main(a:Array<String>)=print({n:String,d:String->IntRange(1,n.toInt()).filter{"$it".count{"$it"==d}%2==0}.joinToString()}(a[0],a[1]))

Programme entièrement fonctionnel, prend les arguments comme suit: nd

Essayez-le en ligne!

Java 8, 84 octets

Ceci est une expression lambda pour un BiConsumer< Integer, Integer>:

(d,n)->for(int x=0;x++<n;)if((""+x).split(""+d,-1).length%2>0)System.out.println(x);

Explication:

pour chaque nombre compris entre 1 et n, convertissez-le en chaîne et scindez-le en utilisant d comme délimiteur. S'il a été divisé en un nombre impair de sections, imprimez le numéro suivi d'une nouvelle ligne.

Rétine, 72 71 55

\d+$
$*
\B
¶$`
1+
$.0
G`(.),((?>.*?\1){2})*(?!.*\1)
.,
<empty>

Un grand merci à Martin qui, par accident, m'a rappelé les groupes de couplage atomique!

Essayez-le en ligne!

Explication:

\d+$
$*

Remplacez le nombre, mais pas le chiffre, par son équivalent unaire.

\B
¶$`

\Bcorrespond à chaque position (largeur nulle) qui n'est pas une limite de mot. Notez que cela ne correspond à aucun des éléments suivants: le début de la chaîne, la fin de la chaîne ou toute position autour de la virgule. Chacune de ces non-limites est ensuite remplacée par une nouvelle ligne, puis la chaîne précédant la correspondance ( $`). Cela donne une liste comme:

d,1
d,11
d,111

Où se dtrouve n'importe quel chiffre décimal.

1+
$.0

Ceci convertit toutes les listes de 1s en la représentation décimale de leurs longueurs. Cela n’aura pas d’incidence sur le contenu de la liste 1avant la virgule, car sa longueur est toujours 1la même.

G`(.),((?>.*?\1){2})*(?!.*\1)

Ici, le Gmode grep est activé, ce qui signifie que les lignes qui correspondent à l'expression rationnelle sont conservées et les autres lignes sont ignorées. Cette expression rationnelle est compliquée, mais elle correspond essentiellement à des groupes de 2 du premier chiffre (stockés dans le groupe de capture 1, afin que nous puissions la référencer avec \1).

La clé ici, est que si elle échouait lors de l'utilisation de la correspondance non gourmande jusqu'aux deux premières apparences des chiffres, il serait alors juste de revenir en arrière et de réessayer, avec une .correspondance sur le chiffre. Cela ferait correspondre des nombres comme 111 lorsque notre chiffre est 1. Par conséquent, nous utilisons ?>pour rendre la correspondance atomique, ce qui empêche essentiellement l'expression régulière de revenir en arrière avant qu'elle ne corresponde à cette valeur. Une correspondance atomique fonctionne un peu comme une correspondance possesive dans certaines saveurs. Puisque le *méta-caractère est suivi d'un, ?les caractères .seront comparés jusqu'à ce qu'il soit capable de correspondre à ce que nous avons stocké \1. Ensuite, une fois que nous faisons cela deux fois, la "mémoire" de l'expression régulière est détruite, empêchant ainsi le comportement normal de se produire..correspond à un caractère supplémentaire, notre \1chiffre, qui aurait créé des correspondances non valides.

Ensuite, nous vérifions que, à partir de la position finale, après l’appariement de groupes répétés de deux des chiffres entrés, nous ne pouvons pas faire correspondre un autre chiffre entré.

.,
<empty>

Ici, nous supprimons simplement le chiffre et la virgule de chacune des chaînes, nous obtenons donc notre belle réponse.

Python 2, 57 54 octets

lambda d,n:[i for i in range(1,n+1)if`i`.count(d)%2<1]

Usage

>>> (lambda d,n:[i for i in range(1,n+1)if`i`.count(d)%2<1])('1', 12)
[2, 3, 4, 5, 6, 7, 8, 9, 11]

Julia, 44 octets

f(n,d)=filter(i->sum(d.==digits(i))%2<1,1:n)

C'est une fonction qui accepte deux entiers et retourne un tableau.

Nous commençons avec l'ensemble des entiers de 1 à n, inclus. Pour chaque entier i, nous déterminons à quels chiffres décimaux sont égaux d, ce qui donne un tableau booléen. Nous souhaitons sumobtenir le nombre d'occurrences de dsous forme de chiffre iet filterla plage d'origine en fonction de la parité de la somme.

Essayez-le ici

Sérieusement, 17 octets

╩╜R;`$╛@c2@%Y`M@░

Prend les entrées en tant que n\n'd'(entier, nouvelle ligne, chaîne).

Essayez-le en ligne!

Explication:

╩╜R;`$╛@c2@%Y`M@░
╩                  push all inputs to registers
 ╜R;               push two copies of range(1, n+1)
    `        `M    map:
     $╛@c            count the number of d's
         2@%Y        modulo 2, logical not (1 if even, 0 if odd)
               @░  filter: take only the values of range(1, n+1) where the count is even

Mathematica, 45 octets

Select[a=#2;Range@#,2∣DigitCount[#,10,a]&]&

Utilise le intégré DigitCount.

Japt, 13 12 octets

Uò1 f_s èV v

L'entrée est n , puis d entre guillemets. Testez-le en ligne!

Comment ça marche

       // Implicit: U = input integer, V = input string
Uò1    // Create the inclusive range [1..U].
f_     // Filter to only the items Z that return truthily to this function:
s èV   //  Take Z.toString(), then count the number of matches of V.
v      //  Return 1 (truthy) if even, 0 (falsy) otherwise.
       // Implicit output, array separated by commas

CJam, 38 octets

r:P;r~1+,0-_{s{s}%Pe=2%!}%]z{~{}{;}?}%

Explication

r:P;                                    e# set input d to variable P
    r~1+,0-                             e# create a range(1, n+1)
           _{s{s}%Pe=2%!}%              e# determine which numbers are needed
                          ]z{~{}{;}?}%  e# remove extra numbers

Scala, 66 octets

(d:Int,n:Int)=>(1 to n).map(""+).filter(_.count((""+d)(0)==)%2==0)

R, 145 octets (je suis sûr qu'il y a moyen de raccourcir cela davantage) :)

g<-sapply(sprintf("%s",seq(1:111)),function(z){if(sapply(regmatches(z,gregexpr("0",z)),length)%%2==0){z}else{NULL}})
names(g[!sapply(g,is.null)])