อินพุต

จำนวนเต็ม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

ขอบคุณ

เพื่อ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's ฉันไม่ได้ใช้Charเป็นอินพุตอย่างชัดเจนdซึ่งจะมีการบันทึกไบต์12 6 (หลังจากการแก้ไขของดาเมียน)

แก้ไข: น้อยกว่า 11 ไบต์เพื่อดาเมียน! แก้ไข 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^

คะแนนถูกระบุว่าเรานับทั้งสแควร์รวมถึงการขึ้นบรรทัดใหม่ซึ่งสมเหตุสมผล คุณสามารถคัดลอกวางโค้ดลงInterpeter ให้สองปัจจัยแรกdแล้วn โซลูชันนี้ใช้ไม่ได้กับค่าที่มากกว่าn > 999

เห็นได้ชัดว่านี่จะไม่ใช่คู่แข่งสำหรับรางวัลใหญ่ แต่ฉันอยากจะใช้ codegolf ใน Befunge มาระยะหนึ่งแล้วฉันจึงตัดสินใจทำมัน ฉันคิดว่าสิ่งนี้จะไม่ใกล้เคียงกับโซลูชั่น Befunge ที่ดีที่สุดเพราะเป็นสิ่งแรกที่ฉันทำใน Befunge ดังนั้นคำแนะนำยินดีต้อนรับถ้าคุณต้องการชี้แจงหรือข้อมูลเพิ่มเติมโปรดแจ้งให้เราทราบในความคิดเห็น

พยายามอธิบาย

ในคอลัมน์แรกลงมาเราอ่านจำนวนเต็มจากอินพุตเพิ่ม 48 (6 * 8 คุณจะเห็นสิ่งนี้บ่อยกว่า) เพื่อแปลงให้เป็นค่า ASCII ที่สอดคล้องกันและนำไป(10, 0)ใช้

& - อ่านอินพุต

68*+ - เพิ่ม 48

55+0p - ใส่ค่าที่ (10, 0)

โปรดทราบว่าdที่(1, 0)เป็นเพียงวิธีที่ง่ายที่จะได้รับหมายเลข 100 ในกอง

หลังจากนั้นเราไปทางทิศตะวันออกและอ่านจำนวนเต็มอื่นแล้วมุ่งหน้าไปยังสิ่งที่ฉันเรียกว่า ASCIIfier เปลี่ยนตัวเลขปัจจุบันเป็นชุดของอักขระ ASCII ASCIIfier เป็นชิ้นสี่เหลี่ยมจากไป(13, 12) (26, 17)ประกอบด้วยสองลูปเป็นครั้งแรกนับ Hunderds และกว่าสิบและวางไว้ในตัวเลขสามหลักที่และ(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ใน 's nมีการทดสอบเพื่อจะได้ด้วยการเอาของบิตสมบูรณ์แบบโมดูโล 2 ซึ่งจะช่วยให้1สำหรับแม้แต่และ0สำหรับคี่ นี้หลายn's จะผนวกกับรายการและฟังก์ชั่น recurse ลงไปหยุดทางตรรกะลัดวงจรในรายการว่างเปล่าเมื่อn-1n==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 นับจำนวนขององค์ประกอบที่ส่งคืนและแก้ไขผลลัพธ์ 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สร้างบรรทัด regex ยาวที่คุณเห็นด้านบน การทำความเข้าใจว่าการเชื่อมโยง regex ทำงานอย่างไรมีความสำคัญ

ลองออนไลน์

แสดงความคิดเห็นคำอธิบายของรุ่นเก่า

หากคำสั่งจากมากไปน้อยก็โอเค

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

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 ไบต์

นี่คือการแสดงออกแลมบ์ดาสำหรับ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 ซึ่งหมายความว่ามีการเก็บรักษาบรรทัดที่ตรงกับ regex และบรรทัดอื่น ๆ จะถูกยกเลิก regex นี้มีความซับซ้อน แต่เป็นหลักตรงกับกลุ่มของ 2 ของตัวเลขนำหน้า (เก็บไว้ในกลุ่มการดักจับ 1 ดังนั้นเราสามารถอ้างอิงได้\1)

กุญแจที่นี่คือว่าถ้ามันล้มเหลวเมื่อใช้การจับคู่ที่ไม่โลภมากถึงสองครั้งแรกของตัวเลขมันจะย้อนกลับและลองอีกครั้งโดย.จับคู่กับตัวเลขหลัก สิ่งนี้จะทำให้มีจำนวนเช่น 111 การแข่งขันเมื่อตัวเลขของเราคือ 1 ดังนั้นเราใช้?>เพื่อทำให้การแข่งขันอะตอมเป็นหลักป้องกัน regex จาก backtracking ไปก่อนที่จะตรงกับค่านี้ การแข่งขันอะตอมทำงานชนิดเช่นpossesiveจับคู่จะอยู่ในรสชาติบางอย่าง ตั้งแต่*เมตาตัวอักษรตามด้วยจะตรงกับตัวอักษรจนกว่าจะสามารถให้ตรงกับสิ่งที่เราเก็บไว้ใน จากนั้นเมื่อเราทำเช่นนี้สองครั้ง "หน่วยความจำ" ของนิพจน์ปกติจะถูกทำลายเพื่อป้องกันพฤติกรรมที่จะเกิดขึ้นตามปกติซึ่งจะกลับไปและมี?.\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 13ไบต์

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