Wkład

Liczba całkowita n (≥ 1) i cyfra d (liczba całkowita taka, że ​​0 ≤  d  ≤ 9).

W dowolnej kolejności; od standardu lub parametrów lub cokolwiek innego; do programu lub funkcji; itp.

Wydajność

Liczby od 1 do n włącznie (w tej kolejności), którego reprezentacje dziesiętny zawierać nawet szereg d s. (Oznacza to, że całkowite na liście są liczbami całkowitymi, które mają, odpowiednio, liczbę nawet d s).

W dowolnym standardowym formacie itp. W szczególności dane wyjściowe nie muszą być przedstawiane w postaci dziesiętnej.

Jeśli dane wyjściowe są wyprowadzane jako pojedynczy ciąg, liczby całkowite należy jakoś oddzielić (spacje, przecinki, znaki nowej linii, bajty puste, cokolwiek).

Przykłady

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

Dzięki

Do kwintopii dla tytułu.

Galaretka, 7 bajtów

RDċ€Ḃ¬T

Wypróbuj online!

Jak to działa

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 bajtów

Kod:

\>GN¹¢ÈiN,

Wyjaśnienie:

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

Wypróbuj online

Wykorzystuje kodowanie CP-1252 .

Haskell, 69 63 52 50 bajtów

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

Proste rozwiązanie dla mojego pierwszego postu tutaj. Używa showdo zliczania liczby d. Ja wyraźnie nie użyłem Charjako danych wejściowych d, co zaoszczędziłoby 12 6 (po edycji Damiena) bajtów.

EDYCJA: 11 bajtów mniej dzięki Damienowi! EDYCJA 2: kolejne 2 bajty mniej dzięki nim!

Befunge, 1080 945 bajtów

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^

Wynik jest taki, że liczymy cały kwadrat, w tym znaki nowej linii, co ma sens. Możesz skopiować wklej kod do interpeter . Podaj dwa dane wejściowe, najpierw d, a następnie n . To rozwiązanie nie działa dla wartości większych niż n > 999.

Oczywiście nie będzie to pretendent do nagrody głównej, ale od jakiegoś czasu chciałem wdrożyć codegolfa w Befunge, więc postanowiłem to zrobić. Myślę, że nie będzie to nawet bliskie optymalnemu rozwiązaniu Befunge, ponieważ jest to pierwsza faktyczna rzecz, którą zrobiłem w Befunge. Tak więc wskazówki są mile widziane, jeśli potrzebujesz wyjaśnień lub więcej informacji, daj mi znać w komentarzach.

Próba wyjaśnienia:

W pierwszej kolumnie w dół odczytujemy liczbę całkowitą z wejścia, dodajemy 48 (6 * 8, zobaczysz to częściej), aby przekonwertować ją na odpowiednią wartość ASCII i umieścić na (10, 0).

& - odczytać wejście

68*+ - dodaj 48

55+0p - umieść wartość na (10, 0)

Zauważ, że dat (1, 0)to prosty sposób na uzyskanie liczby 100 na stosie.

Następnie idziemy na wschód, czytamy kolejną liczbę całkowitą i kierujemy się do czegoś, co nazywam palcem ASCII. To zamienia bieżącą liczbę w ciąg znaków ASCII. ASCIIfier to prostokątny element od (13, 12)do (26, 17). Składa się z dwóch pętli, najpierw licząc hunderdy, a następnie dziesiątki i umieszczając je w trzech cyfrach na (6, 0)i (5, 0). Następnie wstawiana jest ostatnia cyfra (4, 0). Tak więc liczby są odwrotnie.

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)

Po umieszczeniu bieżącej liczby całkowitej w szeregu znaków ASCII idziemy nieco dalej na południe, aby usunąć poprzedzone zera. Zatem później, początkowo trzy zera u góry, będą bieżącą liczbą bez zer zerowych.

Następnie wracamy w górę, aż do północy, gdzie kładziemy trzy cyfry na stosie. Iterujemy trzy cyfry w górnej pętli, za każdym razem zwiększając licznik znajdujący się w, (1, 1)jeśli bieżąca cyfra odpowiada wejściu d

Po wykonaniu tej czynności sprawdzamy, czy licznik znajdujący się przy (1, 1)jest nieparzysty, czy parzysty. Jeśli jest równy, wyprowadzamy bieżącą liczbę i przechodzimy do dużej zewnętrznej pętli, aby zmniejszyć bieżącą wartość i zacząć od nowa.

Python 2, 50 bajtów

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

Funkcja rekurencyjna, która przyjmuje cyfrę djako ciąg, a górną granicę njako liczbę.

Ilość cyfr dw „s ntestuje się nawet biorąc go za nieco dopełniacza modulo 2, który daje 1do nawet i 0za dziwne. Tych wielu ndołącza się do listy, a funkcja powraca do n-1, zatrzymując się przez logiczne zwarcie na pustej liście, kiedy n==0.

Jeśli dane wyjściowe można podawać w malejącej kolejności, można zapisać jeden bajt na 49 bajtów:

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

Stare 51-bajtowe rozwiązanie:

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

Anonimowa funkcja, która przyjmuje cyfrę djako ciąg, a górną granicę njako liczbę.

Wykorzystywane są dwie sztuczki:

• Python rangejest indeksowany na zero 0...n-1, więc dodajemy jeden do każdej potencjalnej wartości x. Następnie, aby liczyć d„sw x+1, zapisuje znak do wykorzystania jego negację ~xzamiast.
• Aby filtrować wartości parzyste, robimy to ~_%2, które najpierw odwraca bit, aby przełączyć parzystość, a następnie bierze ostatni bit za pomocą &1(tak jak %2tutaj), generując prawdziwą wartość tylko wtedy, gdy oryginał był parzysty.

Pyth, 10 bajtów

f!%/`Tz2SE

Wypróbuj online. Zestaw testowy.

Lua, 86 bajtów

W przypadku korzystania z niespójne separator pozostawia może zastąpić io.writeprzez print, co oznacza, że numery oddzielone jedną lub wieloma znakami nowej linii.

Jest to pełny program, który ma się nazywać tak: lua file.lua d n.

Usuwa wszystkie dznaki niebędące znakami z bieżącej liczby i używa rozmiaru wynikowego łańcucha, aby zdecydować, czy ma zostać wyprowadzony, czy nie.

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

JavaScript (ES6) 64

Anonimowa funkcja z wyjściem na konsolę. Prosta implementacja za pomocą splitliczenia cyfr.

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

Wykorzystanie danych wyjściowych alertbyłoby o 6 bajtów mniej, ale tak naprawdę to nie lubię (i tak nie zamierzam pokonać języków zabawek)

MATL , 12 10 bajtów

:!V!=s2\~f

Pierwsze wejście to n , drugie to d jako ciąg. Na przykład:

12
'1'

Wypróbuj 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 bajtów

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

Uruchom za pomocą d i n jako parametrów wiersza polecenia, np

ruby golf.rb 1 12

PowerShell, 62 55

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

edycja: użycie bloku parametrów w tym przypadku jest krótsze. usunięto trochę zbędnego miejsca

Nie jest to język golfowy, ale jest to jedyny język, który naprawdę znam. To działałoby zapisane jako skrypt i tak się nazywało M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12. Pierwszy argument to cyfra d, a drugi to liczba całkowita n .

Utwórz tablicę od 1 do n . Dla każdego z nich przekonwertuj to na tablicę znaków. 10 byłoby 1,0. Używając -matchjako operatora tablicy zwracamy wszystkie elementy, które pasują do cyfry d . Policz ilość zwróconych elementów i zmień wynik na 2. Wynik wyniesie 0 dla parzystej i 1 dla nieparzystej. 0 jako boolean jest fałszem, więc używamy !dla pętli oceny nieparzystych wyników na false, a nawet wyników na true.

Dane wyjściowe to nowy wiersz rozdzielany na konsoli.

Retina , 99 105 bajtów

Zwróć uwagę na spacje końcowe. <empty>reprezentuje pustą linię.

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

Przyjmuje dane wejściowe jak 1 12. Wyjście jest oddzielane spacją w malejącej kolejności.

Zmodyfikowałem, 0*1(0|10*1)*aby dopasować nieparzystą liczbę \1w liczbie. Zmieniłem 0na (?!\1)\di, 1aby \1utworzyć długą linię wyrażeń regularnych, którą widzisz powyżej. Zrozumienie, jak działa połączony regex, jest kluczowe.

Wypróbuj online

Skomentowano wyjaśnienie starej wersji

Jeśli kolejność malejąca była w porządku

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

Narzędzia Bash + GNU, 37

• 1 bajt zapisany dzięki @Ruud.

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

Python 3.4, 92 85 79 85 bajtów

Zaoszczędzono 7 bajtów dzięki Mego
Zaoszczędzono kolejne 6 bajtów dzięki mbomb007
Odzyskano te 6 bajtów, ponieważ Python 3.x

To jest moja pierwsza gra w golfa kodowego, więc tutaj nic nie idzie!

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 bajtów

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

Brachylog , 32 bajty

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

Oczekuje, że N jako wejście, a cyfra jako wyjście, np brachylog_main(12,1).

Wyjaśnienie

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

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

Perl, 28 29 31 bajtów

Obejmuje +2 za -an

Uruchom z cyfrą specyfikacji i licz na kolejne linie na STDIN:

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

Oracle SQL 11.2, 111 82 bajtów

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

Kotlin, 136 bajtów

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

W pełni funkcjonalny program, przyjmuje argumenty jako: nd

Wypróbuj online!

Java 8, 84 bajtów

To jest wyrażenie lambda dla BiConsumer< Integer, Integer>:

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

Wyjaśnienie:

dla każdej liczby od 1 do n przekonwertuj liczbę na ciąg i podziel ją za pomocą d jako separatora. Jeśli został podzielony na nieparzystą liczbę sekcji, wydrukuj liczbę, a następnie nową linię.

Siatkówka oka, 72 71 55

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

Ogromne podziękowania dla Martina, który zupełnie przypadkowo przypomniał mi o grupach atomowych!

Wypróbuj online!

Wyjaśnienie:

\d+$
$*

Zamień liczbę, ale nie cyfrę, na jej jednoargumentowy odpowiednik.

\B
¶$`

\Bdopasowuje każdą pozycję (szerokość zero), która nie jest granicą słowa. Zauważ, że nie będzie to pasowało do żadnego z poniższych: początku łańcucha, końca łańcucha ani żadnej pozycji wokół znaku przecinka. Każda z tych granic jest następnie zastępowana nową linią, a następnie ciągiem poprzedzającym match ( $`). To daje listę jak:

d,1
d,11
d,111

Gdzie djest jakakolwiek pojedyncza cyfra dziesiętna.

1+
$.0

Konwertuje wszystkie listy 1s na dziesiętne przedstawienie ich długości. To dogodnie nie wpłynie na to, 1co może być przed przecinkiem, ponieważ zawsze ma też swoją długość 1.

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

Tutaj Gwłącza się tryb grep, co oznacza, że ​​linie pasujące do wyrażenia regularnego są zachowywane, a inne linie są odrzucane. Wyrażenie regularne jest skomplikowane, ale zasadniczo pasuje do grup 2 cyfr wiodących (przechowywanych w grupie przechwytywania 1, więc możemy się z nim odwoływać \1).

Kluczem tutaj jest to, że jeśli zawiódł podczas używania nie-zachłannego dopasowania do dwóch najwcześniejszych pojawień cyfr, to po prostu cofnąłby się i spróbował ponownie, z .dopasowaniem nad cyfrą. Sprawiłoby to, że liczby takie jak 111 pasowałyby, gdy nasza cyfra wynosiła 1. Dlatego używamy, ?>aby dopasować liczbę atomową, zasadniczo zapobiegając cofnięciu wyrażenia regularnego, zanim dopasuje tę wartość. Dopasowywanie atomowe działa podobnie jak dopasowanie dodatnie w niektórych smakach. Ponieważ *meta-znaków następuje dopasuje znaki aż jest w stanie dopasować to, co zapisane w . Następnie, gdy zrobimy to dwa razy, „pamięć” wyrażenia regularnego jest niszczona, co uniemożliwia zachowanie, które normalnie by się zdarzyło, gdy wraca i ma?.\1.dopasuj dodatkowy znak, naszą \1cyfrę, która utworzyłaby nieprawidłowe dopasowania.

Następnie sprawdzamy, czy z pozycji końcowej, po dopasowaniu powtarzanych grup dwóch cyfr wejściowych, nie możemy dopasować innej cyfry wejściowej.

.,
<empty>

Po prostu usuwamy cyfrę i przecinek z każdego łańcucha, więc otrzymujemy naszą ładną odpowiedź.

Python 2, 57 54 bajtów

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

Stosowanie

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

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

Jest to funkcja, która akceptuje dwie liczby całkowite i zwraca tablicę.

Zaczynamy od zestawu liczb całkowitych od 1 do nwłącznie. Dla każdej liczby całkowitej iokreślamy, która z cyfr dziesiętnych jest równa d, co daje tablicę boolowską. Mamy sumto, aby uzyskać liczbę wystąpień djako cyfry w i, i filteroryginalny zakres oparty na parzystości sumy.

Wypróbuj tutaj

Poważnie, 17 bajtów

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

Pobiera dane wejściowe jako n\n'd'(liczba całkowita, nowa linia, ciąg).

Wypróbuj online!

Wyjaśnienie:

╩╜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 bajtów

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

Korzysta z wbudowanego DigitCount.

Japt, 13 12 bajtów

Uò1 f_s èV v

Wejście jest N , a następnie d owinięty w cudzysłowach. Przetestuj online!

Jak to działa

       // 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 bajtów

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

Wyjaśnienie

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 bajtów

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

R, 145 bajtów (jestem pewien, że są sposoby na dalsze skrócenie) :)

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