Ingresso

Un numero intero n (≥ 1) e una cifra d (un numero intero tale che 0 ≤  d  ≤ 9).

In entrambi gli ordini; da stdin o parametri o altro; a un programma o una funzione; eccetera.

Produzione

I numeri da 1 a n compreso (in ordine) le cui rappresentazioni decimali contenere un anche il numero di d s. (Cioè, i numeri interi nell'elenco sono i numeri interi che hanno, rispettivamente, un numero pari di d s.)

In qualsiasi formato standard, ecc. In particolare, l'output non deve essere rappresentato in decimale.

Se l'output è una singola stringa, gli interi devono essere separati in qualche modo (spazi, virgole, newline, byte nulli, qualunque cosa).

Esempi

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

Grazie

Alla quintopia per il titolo.

Gelatina, 7 byte

RDċ€Ḃ¬T

Provalo online!

Come funziona

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 byte

Codice:

\>GN¹¢ÈiN,

Spiegazione:

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

Provalo online

usi codifica CP-1252 .

Haskell, 69 63 52 50 byte

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

Soluzione semplice per il mio primo post in assoluto qui. Usa showper contare il numero di d. Non ho usato esplicitamente Charcome input perd , che avrebbe salvato 12 6 (dopo la modifica di Damien) byte.

EDIT: 11 byte in meno grazie a Damien! EDIT 2: altri 2 byte in meno grazie a nimi!

Befunge, 1080 945 byte

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^

Il punteggio è dato dal fatto che contiamo l'intero quadrato, comprese le nuove linee, il che ha senso. È possibile copiare incollare il codice nel l'interpeter . Fornire due ingressi, prima d e poi n . Questa soluzione non funziona per valori superiori a n > 999.

Questo ovviamente non sarà un concorrente per il primo premio, ma ho voluto implementare un codegolf in Befunge ormai da un po ', quindi ho deciso di farlo. Immagino che questo non sarà nemmeno vicino a una soluzione Befunge ottimale, poiché è la prima cosa reale che ho fatto in Befunge. Quindi, i suggerimenti sono benvenuti, se hai bisogno di chiarimenti o ulteriori informazioni, per favore fatemelo sapere nei commenti.

Tentativo di spiegazione:

Nella prima colonna in basso leggiamo un numero intero dall'input, aggiungiamo 48 (6 * 8, lo vedrai più spesso) ad esso per convertirlo nel corrispondente valore ASCII e metterlo in (10, 0) .

& - leggi input

68*+ - aggiungi 48

55+0p - metti il ​​valore a (10, 0)

Si noti che dat (1, 0)è solo un modo semplice per ottenere il numero 100 in pila.

Dopodiché, andiamo a est, leggiamo un altro numero intero e andiamo a quello che chiamo ASCIIfier. Ciò trasforma il numero corrente in una serie di caratteri ASCII. ASCIIfier è il pezzo rettangolare da (13, 12)a (26, 17). Si compone di due anelli, prima contando gli hunderds e poi le decine e inserendoli nelle tre cifre in (6, 0)e (5, 0). Successivamente viene inserita l'ultima cifra (4, 0). Quindi i numeri sono in realtà al contrario.

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)

Dopo aver inserito il numero intero corrente in una serie di caratteri ASCII, andiamo un po 'più a sud per rimuovere gli zeri anteposti. Quindi, in seguito, quelli che inizialmente sono i tre zeri in alto, sarà il numero corrente, senza zeri anteposti.

Quindi risaliamo, fino a nord, dove mettiamo le tre cifre in pila. Esaminiamo le tre cifre nel ciclo superiore, ogni volta incrementando il contatore situato (1, 1)se la cifra corrente corrisponde all'ingresso d

Fatto ciò andiamo a controllare se il contatore che si trova in (1, 1)è pari o dispari. Se è pari, emettiamo il numero corrente e passiamo al grande loop esterno per diminuire il valore corrente e ricominciare da capo.

Python 2, 50 byte

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

Una funzione ricorsiva che accetta la cifra dcome stringa e il limite superiore ncome numero.

Il conteggio delle cifre din nè verificato per essere pari prendendo il suo complemento di bit modulo 2, che dà 1per pari e 0dispari. Questi molti si nstanno aggiungendo all'elenco e la funzione ricorre fino a n-1, arrestandosi tramite un cortocircuito logico nell'elenco vuoto quandon==0 .

Se l'output può essere fornito in ordine decrescente, è possibile salvare un byte, per 49 byte:

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

Vecchia soluzione a 51 byte:

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

Una funzione anonima che accetta la cifra dcome stringa e il limite superiore ncome numero.

Vengono utilizzati due trucchi:

• Python rangeè a zero 0...n-1, quindi ne aggiungiamo uno a ciascun valore potenziale x. Poi, a contare d's in x+1, fa risparmiare un carattere da utilizzare la sua negazione ~x, invece.
• Per filtrare i valori pari, lo facciamo ~_%2, che prima lancia bit per cambiare la parità, quindi prende l'ultimo bit con &1(uguale a %2qui), producendo un valore di verità solo se l'originale era pari.

Pyth, 10 byte

f!%/`Tz2SE

Provalo online. Suite di test.

Lua, 86 byte

Se l'uso del separatore incoerente è consentito, potrei sostituirlo io.writeconprint , il che significa che i numeri sarebbero separati da una o più righe.

Si tratta di un programma completo, che devono essere chiamati in questo modo: lua file.lua d n.

Rimuove tutti i non dcaratteri dal numero corrente e utilizza le dimensioni della stringa risultante per decidere se deve essere emesso o meno.

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

JavaScript (ES6) 64

Una funzione anonima con output per console. Implementazione semplice usando splitper contare le cifre.

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

L'output usando alertsarebbe di 6 byte in meno, ma in realtà non mi piace (e non batterò comunque le lingue dei giocattoli)

MATL , 12 10 byte

:!V!=s2\~f

Il primo input è n , il secondo è d come stringa. Per esempio:

12
'1'

Provalo 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

Rubino, 47 42 byte

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

Esegui con d e n come parametri della riga di comando, ad es

ruby golf.rb 1 12

PowerShell, 62 55

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

modifica: l'utilizzo di un blocco param in questo caso è più breve. rimosso dello spazio ridondante

Non è un linguaggio da golf ma è l'unico che conosco davvero. Questo avrebbe funzionato salvato come uno script e chiamato in questo modo M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12. Il primo argomento è la cifra d e il secondo è il numero intero n .

Creare una matrice di numero da 1 a n . Per ognuno di quelli, convertilo in una matrice di caratteri. 10 sarebbe 1,0. L'utilizzo -matchcome operatore di matrice restituisce tutti gli elementi che corrispondono alla cifra d . Conta la quantità di elementi restituiti e mod 2 il risultato. Il risultato sarà 0 per pari e 1 per dispari. 0 come booleano è falso, quindi usiamo !per il ciclo per valutare i risultati dispari su falso e anche i risultati su vero.

L'output è una nuova riga delimitata sulla console.

Retina , 99 105 byte

Nota gli spazi finali. <empty>rappresenta una linea vuota.

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

Accetta input come 1 12. L'output è spazio separato in ordine decrescente.

Ho modificato 0*1(0|10*1)*per abbinare un numero dispari di \1in un numero. Ho cambiato 0in (?!\1)\d, e 1per \1creare la lunga linea regex che vedi sopra. Comprendere come funziona la regex collegata è fondamentale.

Provalo online

Spiegazione commentata della vecchia versione

Se l'ordine decrescente fosse a posto

\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à Bash + GNU, 37

• 1 byte salvato grazie a @Ruud.

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

Python 3.4, 92 85 79 85 byte

Salvati 7 byte grazie a Mego
Salvati altri 6 byte grazie a mbomb007 Hai recuperato
quei 6 byte perché Python 3.x

Questo è il mio primo colpo al code golf, quindi qui non c'è niente!

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 byte

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

Brachylog , 32 byte

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

Si aspetta N come input e la cifra come output, ad es brachylog_main(12,1).

Spiegazione

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

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

Perl, 28 29 31 byte

Include +2 per -an

Esegui con la cifra delle specifiche e conta su righe consecutive su STDIN:

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

Oracle SQL 11.2, 111 82 byte

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

Kotlin, 136 byte

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

Programma completamente funzionale, accetta argomenti come: nd

Provalo online!

Java 8, 84 byte

Questa è un'espressione lambda per un BiConsumer< Integer, Integer>:

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

Spiegazione:

per ogni numero compreso tra 1 e n, converti il ​​numero in una stringa e suddividilo usando d come delimitatore. Se è stato diviso in un numero dispari di sezioni, quindi stampare il numero seguito da una nuova riga.

Retina, 72 71 55

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

Un grande ringraziamento a Martin, che per caso mi ha ricordato per caso gruppi atomici!

Provalo online!

Spiegazione:

\d+$
$*

Sostituisci il numero, ma non la cifra, con il suo equivalente unario.

\B
¶$`

\Bcorrisponde a ciascuna posizione (larghezza zero) che non è un limite di parole. Si noti che ciò non corrisponderà a nessuno dei seguenti elementi: l'inizio della stringa, la fine della stringa o qualsiasi posizione attorno al carattere virgola. Ciascuno di questi non-limiti viene quindi sostituito con una nuova riga e quindi la stringa che precede la corrispondenza ( $`). Questo dà un elenco come:

d,1
d,11
d,111

Dov'è duna singola cifra decimale.

1+
$.0

Questo converte tutti gli elenchi di 1s nella rappresentazione decimale delle loro lunghezze. Ciò non influirà convenientemente su 1ciò che potrebbe essere prima della virgola, poiché è sempre 1anche la lunghezza .

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

Qui, il G modalità grep viene attivata, il che significa che le linee che corrispondono al regex vengono mantenute e le altre linee vengono scartate. Questa regex è complicata, ma fondamentalmente corrisponde a gruppi di 2 della cifra iniziale (memorizzata nel gruppo di acquisizione 1, quindi possiamo fare riferimento con\1 ).

La chiave qui è che se falliva quando si utilizzava la corrispondenza non avida fino alle due prime apparizioni delle cifre, quindi si limitava a tornare indietro e riprovare, con la .corrispondenza sulla cifra. Ciò farebbe corrispondere numeri come 111 quando la nostra cifra è 1. Pertanto, usiamo ?>per rendere atomica la corrispondenza, essenzialmente impedendo al regex di tornare indietro prima che corrispondesse a questo valore. Una partita atomica funziona in modo simile a una corrispondenza possessiva in certi gusti. Dal momento che il *meta-carattere è seguito da una ?della. corrisponderà caratteri fino a quando è in grado di corrispondere a ciò che abbiamo memorizzato in \1. Quindi, una volta che lo facciamo due volte, la "memoria" dell'espressione regolare viene distrutta, impedendo il comportamento che si verificherebbe normalmente, dove ritorna e ha il.abbina un carattere aggiuntivo, la nostra \1cifra, che creerebbe corrispondenze non valide.

Quindi, controlliamo che dalla posizione finale, dopo aver abbinato gruppi ripetuti di due della cifra di input, non possiamo abbinare un'altra cifra di input.

.,
<empty>

Qui stiamo semplicemente rimuovendo la cifra e la virgola da ciascuna delle stringhe, quindi otteniamo solo la nostra bella risposta.

Python 2, 57 54 byte

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 byte

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

Questa è una funzione che accetta due numeri interi e restituisce un array.

Iniziamo con il set di numeri interi da 1 a n, incluso. Per ogni numero intero i, determiniamo a quale delle sue cifre decimali è uguale d, il che produce un array booleano. Abbiamo sumquesto per ottenere il numero di occorrenze di duna cifrai , e filterla gamma originale sulla base della parità della somma.

Provalo qui

Scherzi a parte, 17 byte

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

Accetta input come n\n'd' (intero, newline, stringa).

Provalo online!

Spiegazione:

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

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

Utilizza il built-in DigitCount.

Japt, 13 12 byte

Uò1 f_s èV v

L'input è n , quindi d racchiuso tra virgolette. Provalo online!

Come funziona

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

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

Spiegazione

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 byte

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

R, 145 byte (sono sicuro che ci sono modi per accorciarlo ulteriormente) :)

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