Вхідні дані

Ціле число n (≥ 1) і цифра d (ціле число таке, що 0 ≤  d  ≤ 9).

У будь-якому порядку; від stdin або параметрів або будь-якого іншого; до програми або функції; тощо.

Вихідні дані

Цілі числа від 1 до n включно (по порядку), десяткові подання яких містять парне число d s. (Тобто цілі числа у списку - це цілі числа, які мають, відповідно, парне число d s.)

У будь-якому стандартному форматі тощо. Зокрема, вихідні дані не повинні бути представлені у десятковій формі.

Якщо виводиться як один рядок, цілі числа повинні бути розділені якось (пробіли, коми, нові рядки, нульові байти, що завгодно).

Приклади

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

Спасибі

До кінтопії за титулом.

Желе, 7 байт

RDċ€Ḃ¬T

Спробуйте в Інтернеті!

Як це працює

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 байт

Код:

\>GN¹¢ÈiN,

Пояснення:

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

Спробуйте в Інтернеті

Використовує кодування CP-1252 .

Haskell, 69 63 52 50 байт

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

Безпосередньо розроблене рішення для моєї першої в історії публікації тут. Він використовується showдля підрахунку кількості ds. Я явно не використовував Charяк вхід для d, що дозволило б зберегти 12 6 (після редагування Дамієна) байтів.

EDIT: 11 байт менше завдяки Деймієну! EDIT 2: ще 2 байти менше завдяки nimi!

Befunge, 1080 945 байт

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^

Оцінка дається, що ми рахуємо всю площу, включаючи нові рядки, що має сенс. Ви можете скопіювати вставити код в інтерпетер . Надайте два входи, спочатку d, а потім n . Це рішення не працює для значень більше n > 999.

Це, очевидно, не буде претендентом на головний приз, але я вже деякий час хотів реалізувати кодегольф у Бефунге, тому вирішив це просто зробити. Я вважаю, що це навіть не буде близьким до оптимального рішення Befunge, оскільки це перше, що я зробив у Befunge. Отже, підказки вітаються, якщо вам потрібні роз'яснення або додаткова інформація, будь ласка, повідомте мене про це у коментарях.

Спроба пояснення:

У першому стовпчику вниз ми читаємо ціле число з введення, додаємо до нього 48 (6 * 8, ви побачите це частіше), щоб перетворити його у відповідне значення ASCII і помістити його (10, 0).

& - читати введення

68*+ - додайте 48

55+0p - поставте значення на (10, 0)

Зауважте, що dat (1, 0)- це просто простий спосіб отримати число 100 на стеці.

Після цього ми їдемо на схід і читаємо ще одне ціле число і переходимо до того, що я називаю ASCIIfier. Це перетворює поточне число в ряд символів ASCII. ASCIIfier - це прямокутна деталь від (13, 12)до (26, 17). Він складається з двох петель, спочатку підраховуючи гундери, а потім десятки і вводячи їх у три цифри в (6, 0)і (5, 0). Після цього вводиться остання цифра (4, 0). Тож цифри насправді зворотні.

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)

Вставивши поточне ціле число в ряд символів ASCII, ми підемо трохи більше на південь, щоб видалити попередні нулі. Таким чином, згодом те, що спочатку є трьома нулями вгорі, буде поточним числом без попередніх нулів.

Потім ми повертаємось вгору, аж до Півночі, де ставимо три цифри на стек. Ми повторюємо три цифри у верхній петлі, щоразу збільшуючи лічильник, розташований у, (1, 1)якщо поточна цифра відповідає вхідному d

Коли це зроблено, ми переходимо і перевіряємо, чи лічильник, що знаходиться на (1, 1), непарний чи парний. Якщо це парне число, ми виводимо поточне число і переходимо до великої зовнішньої петлі, щоб зменшити поточне значення і почати заново.

Python 2, 50 байт

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

Рекурсивна функція, яка приймає цифру dяк рядок, а верхню межу - nяк число.

Кількість цифр dу nвипробовується рівним, приймаючи його бітове доповнення по модулю 2, що дає 1парне і 0непарне. Це багато nхто додає до списку, і функція повторюється вниз n-1, зупиняючись через логічне коротке замикання на порожньому списку, коли n==0.

Якщо вихід може бути заданий у порядку зменшення, один байт можна зберегти для 49 байт:

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

Старе 51-байтове рішення:

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

Анонімна функція, яка приймає цифру dяк рядок, а верхню межу - nяк число.

Використовуються два прийоми:

• Python's range дорівнює нулю 0...n-1, тому ми додаємо його до кожного потенційного значення x. Тоді, для підрахунку d's у x+1, він зберігає персонажа, щоб використовувати його заперечення ~xзамість цього.
• Для фільтрування рівних значень ми робимо ~_%2, який спочатку біт перевертає, щоб переключити паритет, а потім бере останній біт з &1(те саме, що%2 тут), виробляючи триєдне значення лише в тому випадку, якщо оригінал був рівним.

Pyth, 10 байт

f!%/`Tz2SE

Спробуйте в Інтернеті. Тестовий набір.

Луа, 86 байт

Якщо дозволено використання непослідовного роздільника, я можу замінити io.writeйого print, тобто числа будуть розділені одним або кількома новими рядками.

Це повна програма, яка повинна називатися так: lua file.lua d n.

Він видаляє всі не dсимволи з поточного числа і використовує розмір результуючого рядка, щоб вирішити, чи слід його замінити, чи ні.

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

JavaScript (ES6) 64

Анонімна функція з виходом на консоль. Безпосередня реалізація за допомогою splitпідрахунку цифр.

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

Вихід з використанням alertбув би на 6 байт менше, але мені це дуже не подобається (і я все одно не буду бити мов іграшок)

MATL , 12 10 байт

:!V!=s2\~f

Перший вхід - n , другий - d як рядок. Наприклад:

12
'1'

Спробуйте в Інтернеті!

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

Рубі, 47 42 байти

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

Запустити з d і n в якості параметрів командного рядка, наприклад

ruby golf.rb 1 12

PowerShell, 62 55

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

редагувати: використання парам-блоку в цьому випадку коротше. видалили зайвий простір

Не мова про гольф, але єдина, яку я справді знаю. Ця робота буде збережена як сценарій і називається так M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12. Перший аргумент - цифра d, а другий - ціле n .

Створіть масив від 1 до n . Для кожного з них перетворите це в масив символів. 10 було б 1,0. Використовуючи -matchяк оператор масиву повернення всіх елементів, що відповідають цифрі d . Підрахуйте кількість повернених елементів та mod 2 результат. Результат буде 0 для парного і 1 для непарного. 0 як булева помилкова, тому ми використовуємо! цикл для оцінки непарних результатів у хибних і навіть результатів до істинних.

Вихід - це новий рядок на консолі.

Сітківка , 99 105 байт

Зверніть увагу на пробіли. <empty>являє собою порожній рядок.

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

Приймає вхід як 1 12. Вихід - це простір, розділений у порядку зменшення.

Я змінив, 0*1(0|10*1)*щоб відповідати непарне число \1числа. Я змінився 0на (?!\1)\d, і 1щоб \1створити довгу лінію регулярних виразів, яку ви бачите вище. Розуміння того, як працює пов'язаний регулярний вираз, має вирішальне значення.

Спробуйте в Інтернеті

Прокоментував пояснення старої версії

Якби порядок зменшення був у порядку

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

• 1 байт збережено завдяки @Ruud.

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

Python 3.4, 92 85 79 85 байт

Збережено 7 байт завдяки Mego
Збережено ще 6 байт завдяки mbomb007 Відновило
ці 6 байт, тому що Python 3.x

Це мій перший вистріл у кодовому гольфі, тому тут нічого не виходить!

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 байт

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

Брахілог , 32 байти

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

Очікує N як вхід, а цифру як вихід, наприклад brachylog_main(12,1).

Пояснення

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

Математика, 54 байти

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

Perl, 28 29 31 байт

Включає +2 для -an

Запустіть зі знаком специфікації та порахуйте послідовні рядки на STDIN:

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

Oracle SQL 11.2, 111 82 байт

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

Котлін, 136 байт

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

Повністю функціональна програма, приймає аргументи як: nd

Спробуйте в Інтернеті!

Java 8, 84 байти

Це лямбда-вираз для BiConsumer< Integer, Integer>:

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

Пояснення:

для кожного числа між 1 і n перетворіть число в рядок і розділіть його, використовуючи d як роздільник. Якщо воно було розділене на непарну кількість розділів, виведіть номер, за яким слід новий рядок.

Сітківка, 72 71 55

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

Велике спасибі Мартіну, який абсолютно випадково нагадав мені про групи атомних збігів!

Спробуйте в Інтернеті!

Пояснення:

\d+$
$*

Замініть число, але не цифру, його одинарним еквівалентом.

\B
¶$`

\Bвідповідає кожній позиції (нульова ширина), яка не є межею слова. Зауважте, що це не буде відповідати жодному з наступного: початок рядка, кінець рядка або будь-яке положення навколо символу кома. Кожен з цих немежних параметрів потім замінюється новим рядком, а потім рядком, що надходить до відповідності ( $`). Це дає такий список, як:

d,1
d,11
d,111

Де dє будь-яка одна десяткова цифра.

1+
$.0

Це перетворює всі списки 1s в десяткове представлення їх довжин. Це зручно не впливатиме на 1те, що може бути перед комою, так як це завжди 1і довжина .

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

Тут Gвмикається режим grep, що означає, що рядки, які відповідають регулярному вираженню, зберігаються, а інші рядки відкидаються. Цей регулярний вираз є складним, але він по суті відповідає групам з 2 провідних цифр (зберігається в групі захоплення 1, тому ми можемо посилатися на нього \1).

Ключовим тут є те, що якщо воно не вдалося при використанні ненажерливого збігу до двох ранніх цифр, то воно просто повернеться назад і спробує ще раз, .зіставляючи цифру. Це зробить числа, як 111, збігаються, коли наша цифра дорівнює 1. Тому ми використовуємо ?>для того, щоб збіг був атомним, по суті запобігаючи зворотньому відстеженню регексу до того, як він відповідав цьому значенню. Атомна відповідність працює на зразок того, що позитивна відповідність була б у певних смаках. Так як *мета-символ супроводжується буде відповідати символи до тих пір, поки не зможе відповідати тому , що ми зберегли в . Потім, коли ми робимо це двічі, "пам'ять" регулярного виразу знищується, запобігаючи поведінці, яка зазвичай виникає там, де вона повертається назад і має?.\1.відповідають додатковому символу, нашому \1розряду, який створив би недійсні збіги.

Потім ми перевіряємо, що з кінцевої позиції, після узгодження повторних груп з двох вхідних цифр, ми не можемо співставити іншу вхідну цифру.

.,
<empty>

Тут ми просто видаляємо цифру і коску з кожної з рядків, тому ми просто отримуємо нашу приємну відповідь.

Python 2, 57 54 байт

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

Використання

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

Джулія, 44 байти

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

Це функція, яка приймає два цілі числа і повертає масив.

Почнемо з набору цілих чисел від 1 до nвключно. Для кожного цілого числа iми визначаємо, якій з його десяткових цифр дорівнює d, що дає булевий масив. Ми sumце отримаємо кількість входжень dяк цифри в i, так і filterпочаткового діапазону на основі паритету суми.

Спробуйте тут

Серйозно, 17 байт

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

Приймає введення як n\n'd'(ціле число, новий рядок, рядок).

Спробуйте в Інтернеті!

Пояснення:

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

Математика, 45 байт

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

Використовує вбудований DigitCount.

Japt, 13 12 байт

Uò1 f_s èV v

Введення n , то d, загорнуте в лапки. Перевірте це в Інтернеті!

Як це працює

       // 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 байт

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

Пояснення

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 байт

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

R, 145 байт (я впевнений, є способи скоротити це далі) :)

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