вход

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

В любом порядке; от стандартного ввода или параметров или чего-либо; к программе или функции; и т.п.

Выход

Целые числа от 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 (после редактирования Дэмиена) байтов.

РЕДАКТИРОВАТЬ: 11 байтов меньше благодаря Дэмиену! РЕДАКТИРОВАТЬ 2: еще 2 байта меньше благодаря Ними!

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.

Это, очевидно, не будет претендентом на главный приз, но я давно хотел внедрить Codegolf в Befunge, поэтому я решил просто сделать это. Я полагаю, что это не будет даже близко к оптимальному решению 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 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 . Подсчитайте количество возвращаемых элементов и смоделируйте 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)

Mathematica, 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соответствует каждой позиции (нулевой ширины), которая не является границей слова. Обратите внимание, что это не будет совпадать ни с одним из следующих: начало строки, конец строки или любая позиция вокруг символа запятой. Каждая из этих неограниченных границ затем заменяется новой строкой, а затем строкой, которая идет перед match ( $`). Это дает список как:

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

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

Скала, 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)])