Entrada

Um número inteiro n (≥ 1) e um dígito d (um número inteiro tal que 0 ≤  d  ≤ 9).

Em qualquer ordem; de stdin ou parâmetros ou o que seja; para um programa ou função; etc.

Saída

Os números inteiros de 1 a n inclusive (em ordem) cujas representações decimais contêm um número par de d s. (Ou seja, os números inteiros na lista são os números inteiros que possuem, respectivamente, um número par de d s.)

Em qualquer formato padrão, etc. Em particular, a saída não precisa ser representada em decimal.

Se emitidos como uma única sequência, os números inteiros devem ser separados de alguma forma (espaços, vírgulas, novas linhas, bytes nulos, qualquer que seja).

Exemplos

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

obrigado

Para quintopia pelo título.

Geléia, 7 bytes

RDċ€Ḃ¬T

Experimente online!

Como 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,

Explicação:

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

Experimente online

Usa a codificação CP-1252 .

Haskell, 69 63 52 50 bytes

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

Solução simples para o meu primeiro post aqui. Ele usa showpara contar o número de d's. Eu explicitamente não usei Charcomo entrada para d, o que teria economizado 12 6 (após a edição de Damien) bytes.

EDIT: 11 bytes a menos, graças a Damien! EDIT 2: mais 2 bytes a menos graças ao 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^

O resultado é que contamos o quadrado inteiro, incluindo novas linhas, o que faz sentido. Você pode copiar e colar o código no interpretador . Proporcionar duas entradas, a primeira d e, em seguida, n . Esta solução não funciona para valores maiores que n > 999.

Obviamente, isso não será um candidato ao grande prêmio, mas eu estou querendo implementar um codegolf no Befunge há algum tempo, então decidi fazê-lo. Eu acho que isso não chegará nem perto de uma solução ideal do Befunge, pois é a primeira coisa real que fiz no Befunge. Portanto, dicas são bem-vindas, se você precisar de esclarecimentos ou mais informações, informe-me nos comentários.

Tentativa de explicação:

Na primeira coluna para baixo, lemos um número inteiro da entrada, adicione 48 (6 * 8, você verá isso com mais frequência) para convertê-lo no valor ASCII correspondente e colocá-lo em (10, 0) .

& - entrada de leitura

68*+ - adicionar 48

55+0p - coloque o valor em (10, 0)

Observe que o dat(1, 0) é apenas uma maneira fácil de obter o número 100 na pilha.

Depois disso, vamos para o leste e lemos outro número inteiro e seguimos para o que chamo de ASCIIfier. Isso transforma o número atual em uma série de caracteres ASCII. O ASCIIfier é a peça retangular de (13, 12)até (26, 17). Consiste em dois loops, contando primeiro os hunderds e as dezenas e colocando-os nos três dígitos em (6, 0)e (5, 0). Depois disso, o último dígito é inserido (4, 0). Portanto, os números estão realmente ao contrário.

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)

Depois de colocar o número inteiro atual em uma série de caracteres ASCII, vamos um pouco mais ao sul para remover os zeros anexados. Assim, posteriormente, o que são inicialmente os três zeros no topo, será o número atual, sem zeros prependidos.

Depois, voltamos ao norte, onde colocamos os três dígitos na pilha. Repetimos os três dígitos no loop superior, cada vez incrementando o contador localizado (1, 1)se o dígito atual corresponde à entrada d

Quando isso é feito, vamos verificar se o contador localizado em (1, 1)é ímpar ou par. Se for par, emitimos o número atual e passamos para o grande loop externo para diminuir o valor atual e começar de novo.

Python 2, 50 bytes

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

Uma função recursiva que aceita o dígito dcomo uma sequência e o limite superior ncomo um número.

A contagem de dígitos dem 's né testado para ser mesmo por tê-la de bit complemento módulo 2, que dá 1para o mesmo e 0para ímpar. Muitos nestão anexando à lista, e a função recua atén-1 , parando através de um curto-circuito lógico na lista vazia when n==0.

Se a saída puder ser fornecida em ordem decrescente, um byte pode ser salvo, por 49 bytes:

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

Solução antiga de 51 bytes:

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

Uma função anônima que aceita o dígito dcomo uma sequência e o limite superiorn como um número.

Dois truques são usados:

• Como o Python rangeé indexado em zero 0...n-1, adicionamos um a cada valor potencial x. Em seguida, a contagem dé em x+1, ele salva um personagem para usar sua negação ~xem seu lugar.
• Para filtrar os valores pares, escolhemos ~_%2qual primeiro bit alterna para alternar a paridade e, em seguida, pega o último bit &1(o mesmo que %2aqui), produzindo um valor de verdade somente se o original fosse par.

Pitão, 10 bytes

f!%/`Tz2SE

Experimente online. Suíte de teste.

Lua, 86 bytes

Se o uso de separador inconsistente for permitido, eu poderia substituir io.writeporprint , o que significa que os números seriam separados por uma ou várias linhas novas.

Este é um programa completo, que deve ser chamado assim: lua file.lua d n .

Ele remove todos os não dcaracteres do número atual e usa o tamanho da sequência resultante para decidir se deve ou não ser impressa.

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

JavaScript (ES6) 64

Uma função anônima com saída para o console. Implementação direta usando splitpara contar os dígitos.

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

A saída usando alertseria de 6 bytes a menos, mas eu realmente não gosto (e não vou vencer as linguagens de brinquedo)

MATL , 12 10 bytes

:!V!=s2\~f

A primeira entrada é n , a segunda é d como uma string. Por exemplo:

12
'1'

Experimente online!

:       % 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)}

Execute com d e n como parâmetros da linha de comando, por exemplo

ruby golf.rb 1 12

PowerShell, 62 55

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

editar: usar um bloco param neste caso é mais curto. removeu algum espaço redundante

Não é uma linguagem de golfe, mas é a única que eu realmente conheço. Isso funcionaria salvo como um script e chamado assim M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12. O primeiro argumento é o dígito d e o segundo é o número n .

Crie uma matriz do número 1 para n . Para cada um deles, converta isso em uma matriz de caracteres. 10 seria 1,0. Utilizando -matchcomo operador de matriz, retorne todos os elementos que correspondem ao dígito d . Conte a quantidade de elementos retornados e mod 2 o resultado. O resultado será 0 para par e 1 para ímpar. 0 como booleano é falso, então usamos !o loop para avaliar os resultados ímpares como falsos e os resultados pares como verdadeiros.

A saída é uma nova linha delimitada no console.

Retina , 99 105 bytes

Observe os espaços à direita. <empty>representa uma linha vazia.

\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. A saída é espaço separado em ordem decrescente.

Modifiquei 0*1(0|10*1)*para corresponder a um número ímpar de \1em um número. Mudei 0para (?!\1)\de 1para \1criar a longa linha de expressão regular que você vê acima. Entender como o regex vinculado funciona é crucial.

Experimente online

Explicação comentada da versão antiga

Se a ordem decrescente estiver correta

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

Utilitários Bash + GNU, 37

• 1 byte salvo graças ao @Ruud.

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

Python 3.4, 92 85 79 85 bytes

Economizou 7 bytes graças ao Mego
Economizou outros 6 bytes graças ao mbomb007
esses 6 bytes porque o Python 3.x

Esta é a minha primeira chance no código de golfe, então aqui não vale 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)}

Braquilog , 32 bytes

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

Espera N como entrada e o dígito como saída, por exemplo brachylog_main(12,1).

Explicação

: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

Inclui +2 para -an

Execute com o dígito da especificação e conte com linhas consecutivas no 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 totalmente funcional, aceita argumentos como: nd

Experimente online!

Java 8, 84 bytes

Esta é uma expressão lambda para um BiConsumer< Integer, Integer>:

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

Explicação:

para cada número entre 1 e n, converta o número em uma sequência e divida-o usando d como delimitador. Se foi dividido em um número ímpar de seções, imprima o número seguido por uma nova linha.

Retina, 72 71 55

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

Muito obrigado a Martin, que totalmente por acidente me lembrou grupos atômicos!

Experimente online!

Explicação:

\d+$
$*

Substitua o número, mas não o dígito, pelo seu equivalente unário.

\B
¶$`

\Bcorresponde a cada posição (largura zero) que não é um limite de palavra. Observe que isso não corresponderá a nenhum dos seguintes itens: início da sequência, final da sequência ou qualquer posição ao redor do caractere vírgula. Cada um desses não limites é então substituído por uma nova linha e, em seguida, pela string que vem antes da partida ( $`). Isso fornece uma lista como:

d,1
d,11
d,111

Onde destá qualquer dígito decimal único.

1+
$.0

Isso converte todas as listas de 1s na representação decimal de seus comprimentos. Convenientemente, isso não afetará o 1que poderia estar antes da vírgula, pois ela também é longa 1.

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

Aqui, Gativa o modo grep, o que significa que as linhas que correspondem ao regex são mantidas e outras são descartadas. Esse regex é complicado, mas basicamente corresponde a grupos de 2 do dígito inicial (armazenado no grupo de captura 1, para que possamos fazer referência \1).

A chave aqui é que, se falhasse ao usar a correspondência não gananciosa até as duas primeiras aparências dos dígitos, ela seria revertida e tentaria novamente, com a .correspondência acima do dígito. Isso faria números como 111 corresponderem quando nosso dígito for 1. Portanto, usamos ?>para tornar a correspondência atômica, essencialmente impedindo que a regex retorne antes de corresponder a esse valor. Uma combinação atômica funciona como uma combinação possessiva em certos sabores. Como o *meta-caractere é seguido por um, ?os .caracteres corresponderão até que seja capaz de corresponder ao que armazenamos em um caractere adicional, nosso dígito, o que criaria correspondências inválidas.\1 . Então, uma vez que fazemos isso duas vezes, a "memória" da expressão regular é destruída, impedindo o comportamento que normalmente ocorreria, onde ela volta e tem o.\1

Em seguida, verificamos que, a partir da posição final, depois de corresponder grupos repetidos de dois do dígito de entrada, não podemos corresponder a outro dígito de entrada.

.,
<empty>

Aqui, estamos apenas removendo o dígito e a vírgula de cada uma das cadeias, para que possamos obter nossa resposta agradável.

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 é uma função que aceita dois números inteiros e retorna uma matriz.

Começamos com o conjunto de números inteiros de 1 a n, inclusive. Para cada número inteiro i, determinamos quais de seus dígitos decimais são iguais d, o que gera uma matriz booleana. Fazemos sumisso para obter o número de ocorrências de dcomo um dígito iefilter o intervalo original com base na paridade da soma.

Experimente aqui

Sério, 17 bytes

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

Toma entradas como n\n'd' (inteiro, nova linha, sequência).

Experimente online!

Explicação:

╩╜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]&]&

Usa o built-in DigitCount.

Japonês, 13 12 bytes

Uò1 f_s èV v

A entrada é n , depois d está entre aspas. Teste online!

Como 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{~{}{;}?}%

Explicação

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 (tenho certeza de que há maneiras de diminuir ainda mais isso) :)

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