Entrada

Un entero n (≥ 1) y un dígito d (un entero tal que 0 ≤  d  ≤ 9).

En cualquier orden; de stdin o parámetros o lo que sea; a un programa o función; etc.

Salida

Los enteros de 1 a n inclusive (en orden) cuyas representaciones decimales contienen un número par de d s. (Es decir, los enteros en la lista son los enteros que tienen, respectivamente, un número par de d s.)

En cualquier formato estándar, etc. En particular, la salida no necesita representarse en decimal.

Si sale como una sola cadena, los enteros deben estar separados de alguna manera (espacios, comas, líneas nuevas, bytes nulos, lo que sea).

Ejemplos

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

Gracias

A quintapia por el título.

Jalea, 7 bytes

RDċ€Ḃ¬T

Pruébalo en línea!

Cómo funciona

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 bytes

Código:

\>GN¹¢ÈiN,

Explicación:

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

Pruébalo en línea

Utiliza la codificación CP-1252 .

Haskell, 69 63 52 50 bytes

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

Solución directa para mi primera publicación aquí. Se utiliza showpara contar el número de d's. No utilicé explícitamente Charcomo entrada para d, lo que habría ahorrado 12 6 (después de la edición de Damien) bytes.

EDITAR: 11 bytes menos gracias a Damien! EDIT 2: otros 2 bytes menos gracias a nimi!

Befunge, 1080 945 bytes

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^

Se da la puntuación de que contamos todo el cuadrado, incluidas las nuevas líneas, lo que tiene sentido. Puede copiar y pegar el código en el intérprete . Proporcione dos entradas, primero d y luego n . Esta solución no funciona para valores mayores que n > 999.

Obviamente, esto no será un candidato para el gran premio, pero he querido implementar un codegolf en Befunge durante un tiempo, así que decidí hacerlo. Me imagino que esto ni siquiera se acercará a una solución óptima de Befunge, ya que es lo primero que hago en Befunge. Por lo tanto, las sugerencias son bienvenidas, si necesita aclaraciones o más información, hágamelo saber en los comentarios.

Intento de explicación:

En la primera columna hacia abajo, leemos un número entero de la entrada, agregamos 48 (6 * 8, lo verá con más frecuencia) para convertirlo al valor ASCII correspondiente y ponerlo (10, 0).

& - leer entrada

68*+ - agregar 48

55+0p - poner el valor en (10, 0)

Tenga en cuenta que dat (1, 0)es solo una manera fácil de obtener el número 100 en la pila.

Después de eso, vamos al este y leemos otro número entero y nos dirigimos a lo que llamo el ASCIIfier. Esto convierte el número actual en una serie de caracteres ASCII. El ASCIIfier es la pieza rectangular de (13, 12)a (26, 17). Consiste en dos bucles, primero contando los cientos y luego las decenas y poniéndolos en los tres dígitos en (6, 0)y (5, 0). Después de eso se pone el último dígito (4, 0). Entonces los números están en realidad en reversa.

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)

Después de poner el número entero actual en una serie de caracteres ASCII, vamos un poco más al sur para eliminar los ceros antepuestos. Por lo tanto, luego, lo que inicialmente son los tres ceros en la parte superior, será el número actual, sin ceros antepuestos.

Luego volvemos a subir, todo el camino hacia el norte, donde ponemos los tres dígitos en la pila. Repetimos los tres dígitos en el bucle superior, incrementando cada vez el contador ubicado en (1, 1)si el dígito actual corresponde con la entrada d

Cuando eso está hecho, vamos y verificamos si el contador que está ubicado en (1, 1)es impar o par. Si es par, sacamos el número actual y pasamos al gran bucle externo para disminuir el valor actual y comenzar de nuevo.

Python 2, 50 bytes

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

Una función recursiva que toma el dígito dcomo una cadena y el límite superior ncomo un número.

El recuento de dígitos den 's nse prueba para ser aún tomándolo de bits complemento módulo 2, lo que da 1por uniforme y 0para odd. Este número nse agrega a la lista, y la función recurre a n-1, deteniéndose a través de un cortocircuito lógico en la lista vacía cuando n==0.

Si la salida se puede dar en orden decreciente, se puede guardar un byte, para 49 bytes:

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

Antigua solución de 51 bytes:

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

Una función anónima que toma el dígito dcomo una cadena y el límite superior ncomo un número.

Se usan dos trucos:

• Python rangeestá indexado a cero 0...n-1, por lo que agregamos uno a cada valor potencial x. Entonces, para contar dque está en x+1, se ahorra un personaje para utilizar su negación ~xen su lugar.
• Para filtrar valores pares, hacemos ~_%2, qué primer bit cambia para cambiar la paridad, luego toma el último bit con &1(igual que %2aquí), produciendo un valor verdadero solo si el original era par.

Pyth, 10 bytes

f!%/`Tz2SE

Pruébalo en línea. Banco de pruebas.

Lua, 86 bytes

Si se permite el uso de un separador inconsistente, podría reemplazarlo io.writepor print, lo que significa que los números estarían separados por una o varias líneas nuevas.

Se trata de un programa completo, que tiene que ser llamado como esto: lua file.lua d n.

Elimina todos los dcaracteres que no son del número actual y utiliza el tamaño de la cadena resultante para decidir si se debe superar o no.

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

JavaScript (ES6) 64

Una función anónima con salida a la consola. Implementación sencilla usando splitpara contar los dígitos.

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

El uso de salida alertsería de 6 bytes menos, pero realmente no me gusta (y no voy a superar los idiomas de juguete de todos modos)

MATL , 12 10 bytes

:!V!=s2\~f

La primera entrada es n , la segunda es d como una cadena. Por ejemplo:

12
'1'

Pruébalo en línea!

:       % 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 bytes

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

Ejecutar con d y n como parámetros de línea de comandos, p. Ej.

ruby golf.rb 1 12

PowerShell, 62 55

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

editar: usar un bloque param en este caso es más corto. eliminado algo de espacio redundante

No es un lenguaje de golf, pero es el único que realmente conozco. Esto funcionaría guardado como un script y llamado así M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12. El primer argumento es el dígito d y el segundo es el número entero n .

Crea una matriz del número 1 a n . Para cada uno de esos convertir eso en una matriz de caracteres. 10 sería 1,0. Utilizando -matchcomo operador de matriz, devuelve todos los elementos que coinciden con el dígito d . Cuente la cantidad de elementos devueltos y mod 2 el resultado. El resultado será 0 para pares y 1 para impares. 0 como booleano es falso, por lo que usamos !para el bucle para evaluar los resultados impares a falso y los resultados pares a verdadero.

La salida es una nueva línea delimitada en la consola.

Retina , 99 105 bytes

Tenga en cuenta los espacios finales. <empty>representa una línea vacía

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

Toma entrada como 1 12. La salida está separada por espacios en orden decreciente.

Modifiqué 0*1(0|10*1)*para que coincida con un número impar de \1un número. Cambié 0a (?!\1)\d, y 1para \1crear la larga línea de expresiones regulares que ves arriba. Comprender cómo funciona la expresión regular vinculada es crucial.

Pruébalo en línea

Explicación comentada de la versión anterior.

Si el orden descendente estuviera bien

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

Bash + GNU utilidades, 37

• 1 byte guardado gracias a @Ruud.

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

Python 3.4, 92 85 79 85 bytes

Guardado 7 bytes gracias a Mego
Guardado otros 6 bytes gracias a mbomb007 Recuperó
esos 6 bytes porque Python 3.x

Esta es mi primera oportunidad en el código de golf, ¡así que aquí no pasa nada!

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 bytes

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

Brachylog , 32 bytes

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

Espera N como entrada y el dígito como salida, p. Ej. brachylog_main(12,1).

Explicación

: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 bytes

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

Perl, 28 29 31 bytes

Incluye +2 para -an

Ejecute con el dígito de especificación y cuente con líneas consecutivas en STDIN:

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

Oracle SQL 11.2, 111 82 bytes

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

Kotlin, 136 bytes

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

Programa completamente funcional, toma argumentos como: nd

Pruébalo en línea!

Java 8, 84 bytes

Esta es una expresión lambda para a BiConsumer< Integer, Integer>:

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

Explicación:

para cada número entre 1 yn, convierta el número en una cadena y divídalo usando d como delimitador. Si se dividió en un número impar de secciones, imprima el número seguido de una nueva línea.

Retina, 72 71 55

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

¡Muchas gracias a Martin, quien por accidente me recordó a los grupos de emparejamiento atómico!

Pruébalo en línea!

Explicación:

\d+$
$*

Reemplace el número, pero no el dígito, con su equivalente unario.

\B
¶$`

\Bcoincide con cada posición (ancho cero) que no es un límite de palabra. Tenga en cuenta que esto no coincidirá con ninguno de los siguientes: el comienzo de la cadena, el final de la cadena o cualquier posición alrededor del carácter de coma. Cada uno de estos no límites se reemplaza con una nueva línea y luego la cadena que viene antes del partido ( $`). Esto da una lista como:

d,1
d,11
d,111

¿Dónde destá cualquier dígito decimal único?

1+
$.0

Esto convierte todas las listas de 1s en la representación decimal de sus longitudes. Esto convenientemente no afectará lo 1que podría estar antes de la coma, ya que su longitud siempre 1es igual.

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

Aquí, se Gactiva el modo grep, lo que significa que se mantienen las líneas que coinciden con la expresión regular y se descartan otras líneas. Esta expresión regular es complicada, pero esencialmente coincide con grupos de 2 del dígito inicial (almacenado en el grupo de captura 1, por lo que podemos hacer referencia a él \1).

La clave aquí es que si falla al usar la coincidencia no codiciosa hasta las dos primeras apariciones de los dígitos, entonces simplemente retrocedería e intentaría nuevamente, haciendo .coincidir el dígito. Esto haría que números como 111 coincidan cuando nuestro dígito sea 1. Por lo tanto, usamos ?>para hacer que la coincidencia sea atómica, esencialmente evitando que la expresión regular retroceda antes de que coincida con este valor. Un emparejamiento atómico funciona de manera similar a como lo haría un emparejamiento posesivo en ciertos sabores. Como el *metacaracteres es seguido por un, ?los .caracteres coincidirán hasta que pueda coincidir con lo que almacenamos \1. Luego, una vez que hacemos esto dos veces, la "memoria" de la expresión regular se destruye, evitando el comportamiento que normalmente ocurriría, donde regresa y tiene el.coincide con un carácter adicional, nuestro \1dígito, que crearía coincidencias no válidas.

Luego, verificamos que desde la posición final, después de hacer coincidir grupos repetidos de dos dígitos de entrada, no podemos hacer coincidir otro dígito de entrada.

.,
<empty>

Aquí solo estamos eliminando el dígito y la coma de cada una de las cadenas, por lo que solo obtenemos nuestra buena respuesta.

Python 2, 57 54 bytes

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

Uso

>>> (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 bytes

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

Esta es una función que acepta dos enteros y devuelve una matriz.

Comenzamos con el conjunto de enteros del 1 al n, inclusive. Para cada número entero i, determinamos cuáles de sus dígitos decimales son iguales d, lo que produce una matriz booleana. Hacemos sumesto para obtener el número de ocurrencias de dcomo un dígito iy filterel rango original basado en la paridad de la suma.

Pruébalo aquí

En serio, 17 bytes

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

Toma entradas como n\n'd'(entero, nueva línea, cadena).

Pruébalo en línea!

Explicación:

╩╜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 bytes

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

Utiliza el incorporado DigitCount.

Japt, 13 12 bytes

Uò1 f_s èV v

La entrada es n , luego d entre comillas. ¡Pruébelo en línea!

Cómo funciona

       // 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 bytes

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

Explicación

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 bytes

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

R, 145 bytes (estoy seguro de que hay formas de acortar esto aún más) :)

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