输入值

甲整数Ñ（≥1）和一个数字d的整数（例如0≤  d  ≤9）。

以任何顺序；从标准输入或参数或任何东西; 程序或功能；等等

输出量

从1到整数Ñ包容（按顺序），其十进制表示包含一个偶数的数目d秒。（也就是说，列表中的整数分别是具有偶数d的整数。）

特别是，可以采用任何标准格式等。输出不必用十进制表示。

如果输出为单个字符串，则整数必须以某种方式分隔（空格，逗号，换行符，空字节等）。

例子

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

谢谢

以quintopia为标题。

果冻，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计数的数量d。我明确未将Char用作输入d，这将节省12 6（在Damien编辑之后）字节。

编辑：多亏了达米恩，少了11个字节！编辑2：多亏了nimi，少了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^

给出的分数是我们计算包括换行符在内的整个正方形，这很有意义。您可以将代码复制粘贴到interpeter中。提供两个输入，首先是d，然后是n。该解决方案不适用于大于n > 999的值。

这显然不是大奖的竞争者，但是我一直想在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中的x+1，它将保存一个字符以使用其取反~x。
• 为了过滤偶数值，我们执行~_%2，首先翻转位以切换奇偶校验，然后使用&1（与%2此处相同）获取最后一位，仅当原始数为偶数时才产生真实值。

Pyth，10个字节

f!%/`Tz2SE

在线尝试。 测试套件。

Lua，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

Ruby，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作为布尔值是假的，因此我们!用于循环将奇数结果评估为false，甚至结果评估为true。

输出是在控制台上定界的换行符。

视网膜，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

• @Ruud节省了1个字节。

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

蟒3.4，92 85 79 85个字节

多亏了Mego，
节省了7个字节多亏了mbomb007，又节省了6个
字节，因为Python 3.x重新获得了这6个字节

这是我第一次打代码高尔夫，所以什么都没有！

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

Brachylog，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;

Kotlin，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字节

这是Lambda表达式，用于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

这会将的所有列表转换1为其长度的十进制表示形式。这很方便，不会影响1逗号前的内容，因为它的长度也总是1如此。

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

在这里，G打开grep模式，这意味着将保留与正则表达式匹配的行，并丢弃其他行。这个正则表达式很复杂，但是它实际上匹配前导数字2的组（存储在捕获组1中，因此我们可以使用来引用它\1）。

这里的关键是，如果在使用最早出现在数字的两个最早位置上的非贪婪匹配时失败了，那么它将回滚并重试一次，并且.对数字进行匹配。当我们的数字为1时，这将使像111这样的数字匹配。因此，我们?>使原子匹配成为原子，从本质上防止了正则表达式回溯到与该值匹配之前。一个原子匹配效果有点像possesive匹配会在某些口味。由于*元字符后接a，?因此.将匹配字符直到可以匹配我们存储在中的字符\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，包括1和2 。对于每个整数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

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