Đầu vào

Một số nguyên n (1) và một chữ số d (một số nguyên sao cho 0 ≤  d  9).

Theo một trong hai thứ tự; từ stdin hoặc tham số hoặc bất cứ điều gì; đến một chương trình hoặc chức năng; v.v.

Đầu ra

Các số nguyên từ 1 đến n , bao gồm (theo thứ tự) mà đại diện thập phân có chứa một thậm chí số d s. (Nghĩa là, các số nguyên trong danh sách là các số nguyên có số chẵn tương ứng là d s.)

Trong bất kỳ định dạng tiêu chuẩn, vv Đặc biệt, đầu ra không cần phải được biểu thị bằng số thập phân.

Nếu đầu ra dưới dạng một chuỗi, các số nguyên phải được phân tách bằng cách nào đó (dấu cách, dấu phẩy, dòng mới, byte rỗng, bất cứ thứ gì).

Ví 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

Cảm ơn

Để quintopia cho tiêu đề.

Thạch, 7 byte

RDċ€Ḃ¬T

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

Mã số:

\>GN¹¢ÈiN,

Giải trình:

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

Dùng thử trực tuyến

Sử dụng mã hóa CP-1252 .

Haskell, 69 63 52 50 byte

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

Giải pháp đơn giản cho bài viết đầu tiên của tôi ở đây. Nó sử dụng showđể đếm số lượng d. Tôi rõ ràng không sử dụng Charlàm đầu vào cho d, mà sẽ lưu 12 byte (sau khi chỉnh sửa của Damien).

EDIT: 11 byte ít hơn nhờ Damien! EDIT 2: thêm 2 byte nữa nhờ nimi!

Befunge, 1080 945 byte

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^

Điểm số được đưa ra là chúng tôi đếm toàn bộ hình vuông, bao gồm cả dòng mới, có ý nghĩa. Bạn có thể sao chép dán mã vào interpeter . Cung cấp hai đầu vào, đầu tiên d và sau đó n . Giải pháp này không hoạt động đối với các giá trị lớn hơn n > 999.

Đây rõ ràng sẽ không phải là ứng cử viên cho giải thưởng lớn, nhưng tôi đã muốn thực hiện một loại tiền mã hóa trong Befunge một thời gian rồi, vì vậy tôi quyết định chỉ làm điều đó. Tôi cho rằng điều này thậm chí sẽ không gần với một giải pháp Befunge tối ưu, vì đó là điều thực tế đầu tiên tôi đã làm trong Befunge. Vì vậy, gợi ý được chào đón, nếu bạn cần làm rõ hoặc biết thêm thông tin, xin vui lòng cho tôi biết trong các ý kiến.

Cố gắng giải thích:

Trong cột đầu tiên trở xuống, chúng tôi đọc một số nguyên từ đầu vào, thêm 48 (6 * 8, bạn sẽ thấy điều này thường xuyên hơn) để chuyển đổi nó thành giá trị ASCII tương ứng và đặt nó vào (10, 0).

& - đọc đầu vào

68*+ - thêm 48

55+0p - đặt giá trị tại (10, 0)

Lưu ý rằng dtại (1, 0)chỉ là một cách dễ dàng để có được số 100 trên ngăn xếp.

Sau đó, chúng tôi đi về phía đông và đọc một số nguyên khác và đi vào cái mà tôi gọi là ASCIIfier. Điều này biến số hiện tại thành một chuỗi các ký tự ASCII. ASCIIfier là mảnh hình chữ nhật từ (13, 12)đến (26, 17). Nó bao gồm hai vòng lặp, đầu tiên là đếm số lượng lớn hơn hàng chục và đặt chúng vào ba chữ số tại (6, 0)và (5, 0). Sau đó, chữ số cuối cùng được đưa vào (4, 0). Vì vậy, những con số thực sự là ngược lại.

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)

Sau khi đặt số nguyên hiện tại vào một loạt các ký tự ASCII, chúng ta đi thêm một chút về phía nam để loại bỏ các số 0 được chuẩn bị trước. Do đó, sau đó, ba số 0 ban đầu ở trên cùng sẽ là số hiện tại, không có số 0 được chuẩn bị trước.

Sau đó, chúng tôi quay trở lại, tất cả các cách để về phía Bắc, nơi chúng tôi đặt ba chữ số trên ngăn xếp. Chúng tôi lặp lại ba chữ số trong vòng lặp trên cùng, mỗi lần tăng bộ đếm nằm ở vị trí (1, 1)nếu chữ số hiện tại tương ứng với đầu vào d

Khi xong việc, chúng tôi đi và kiểm tra xem bộ đếm đặt tại (1, 1)là lẻ hay chẵn. Nếu là số chẵn, chúng ta xuất số hiện tại và chuyển sang vòng lặp lớn bên ngoài để giảm giá trị hiện tại và bắt đầu lại.

Python 2, 50 byte

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

Hàm đệ quy lấy chữ số ddưới dạng chuỗi và giới hạn trên nlà số.

Số lượng chữ số dtrong nđược kiểm tra là chẵn bằng cách lấy bit bổ sung modulo 2, cung cấp 1cho chẵn và 0lẻ. Điều này nhiều người nđang nối vào danh sách, và chức năng lặp lại n-1, dừng thông qua ngắn mạch logic trong danh sách trống khi n==0.

Nếu đầu ra có thể được đưa ra theo thứ tự giảm dần, một byte có thể được lưu, cho 49 byte:

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

Giải pháp 51 byte cũ:

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

Hàm ẩn danh lấy chữ số ddưới dạng chuỗi và giới hạn trên nlà số.

Hai thủ thuật được sử dụng:

• Python rangelà không có chỉ mục 0...n-1, vì vậy chúng tôi thêm một cho mỗi giá trị tiềm năng x. Sau đó, để đếm d's trong x+1, nó tiết kiệm một nhân vật sử dụng phủ định của nó ~xđể thay thế.
• Để lọc các giá trị chẵn, chúng tôi thực hiện ~_%2, lần đầu tiên lật bit để chuyển chẵn lẻ, sau đó lấy bit cuối cùng &1(giống như %2ở đây), tạo ra một giá trị trung thực chỉ khi giá trị gốc là chẵn.

Bình thường, 10 byte

f!%/`Tz2SE

Hãy thử trực tuyến. Bộ thử nghiệm.

Lua, 86 byte

Nếu sử dụng dấu tách không nhất quán được cho phép, tôi có thể thay thế io.writebằng print, có nghĩa là các số sẽ được phân tách bằng một hoặc nhiều dòng mới.

Đây là một chương trình đầy đủ, phải được gọi như thế này : lua file.lua d n.

Nó loại bỏ tất cả các dký tự không phải từ số hiện tại và sử dụng kích thước của chuỗi kết quả để quyết định chúng ta có nên xuất nó hay không.

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

JavaScript (ES6) 64

Một chức năng ẩn danh với đầu ra cho bàn điều khiển. Thực hiện đơn giản bằng cách sử dụng splitđể đếm các chữ số.

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

Đầu ra sử dụng alertsẽ ít hơn 6 byte, nhưng tôi thực sự không thích nó (và dù sao tôi cũng sẽ không đánh bại các ngôn ngữ đồ chơi)

MATL , 12 10 byte

:!V!=s2\~f

Đầu vào đầu tiên là n , thứ hai là d dưới dạng một chuỗi. Ví dụ:

12
'1'

Hãy thử trực tuyến!

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

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

Chạy với d và n là tham số dòng lệnh, vd

ruby golf.rb 1 12

PowerShell, 62 55

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

chỉnh sửa: sử dụng một khối param trong trường hợp này là ngắn hơn. loại bỏ một số không gian dư thừa

Không phải ngôn ngữ chơi gôn mà là ngôn ngữ duy nhất tôi thực sự biết. Điều này sẽ làm việc được lưu dưới dạng một kịch bản và được gọi như thế này M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12. Đối số đầu tiên là chữ số d và thứ hai là số nguyên n .

Tạo một mảng số 1 để n . Đối với mỗi người chuyển đổi đó thành một mảng ký tự. 10 sẽ là 1,0. Sử dụng -matchnhư một toán tử mảng trả về tất cả các phần tử khớp với chữ số d . Đếm số lượng phần tử được trả về và mod 2 kết quả. Kết quả sẽ là 0 cho chẵn và 1 cho lẻ. 0 là boolean là sai vì vậy chúng tôi sử dụng !vòng lặp để đánh giá kết quả lẻ thành sai và thậm chí kết quả là đúng.

Đầu ra là một dòng mới được phân định trên bảng điều khiển.

Võng mạc , 99 105 byte

Lưu ý các dấu cách. <empty>đại diện cho một dòng trống.

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

Đưa đầu vào như thế nào 1 12. Đầu ra là không gian được phân tách theo thứ tự giảm dần.

Tôi đã sửa đổi 0*1(0|10*1)*để khớp với số lẻ \1trong một số. Tôi đã thay đổi 0đến (?!\1)\d, và 1để\1 tạo ra dòng regex dài mà bạn nhìn thấy ở trên. Hiểu làm thế nào các regex liên kết hoạt động là rất quan trọng.

Dùng thử trực tuyến

Nhận xét giải thích về phiên bản cũ

Nếu thứ tự giảm dần là được

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

Tiện ích Bash + GNU, 37

• Lưu 1 byte nhờ @Ruud.

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

Python 3,4, 92 85 79 85 byte

Đã lưu 7 byte nhờ Mego
Lưu thêm 6 byte nhờ mbomb007 Lấy
lại 6 byte đó vì Python 3.x

Đây là phát bắn đầu tiên của tôi vào môn đánh gôn, vì vậy ở đây không có gì!

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 byte

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

Brachylog , 32 byte

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

Yêu cầu N là đầu vào và chữ số là đầu ra, vd brachylog_main(12,1).

Giải trình

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

Toán học, 54 byte

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

Perl, 28 29 31 byte

Bao gồm +2 cho -an

Chạy với chữ số đặc tả và đếm trên các dòng liên tiếp trên STDIN:

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

Oracle SQL 11.2, 111 82 byte

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

Kotlin, 136 byte

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

Chương trình đầy đủ chức năng, lấy các đối số là: nd

Hãy thử trực tuyến!

Java 8, 84 byte

Đây là một biểu thức lambda cho một BiConsumer< Integer, Integer>:

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

Giải trình:

đối với mỗi số từ 1 đến n, chuyển đổi số thành chuỗi và chia nó bằng cách sử dụng d làm dấu phân cách. Nếu nó được chia thành một số phần lẻ, sau đó in ra số theo sau là một dòng mới.

Võng mạc, 72 71 55

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

Rất cảm ơn Martin, người hoàn toàn tình cờ đã nhắc nhở tôi về các nhóm kết hợp nguyên tử!

Hãy thử trực tuyến!

Giải trình:

\d+$
$*

Thay thế số, nhưng không phải là chữ số, với tương đương đơn nguyên của nó.

\B
¶$`

\Bkhớp với từng vị trí (độ rộng bằng không) không phải là ranh giới từ. Lưu ý rằng điều này sẽ không khớp với bất kỳ điều nào sau đây: phần đầu của chuỗi, phần cuối của chuỗi hoặc bất kỳ vị trí nào xung quanh ký tự dấu phẩy. Mỗi không có ranh giới này sau đó được thay thế bằng một dòng mới và sau đó là chuỗi đi trước trận đấu ( $`). Điều này đưa ra một danh sách như:

d,1
d,11
d,111

Trường hợp dbất kỳ chữ số thập phân duy nhất.

1+
$.0

Điều này chuyển đổi tất cả các danh sách của 1s thành biểu diễn thập phân của độ dài của chúng. Điều này thuận tiện sẽ không ảnh hưởng đến 1cái có thể trước dấu phẩy, vì nó luôn luôn dài 1.

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

Ở đây, Gbật chế độ grep, có nghĩa là các dòng khớp với biểu thức chính quy được giữ và các dòng khác bị loại bỏ. Regex này rất phức tạp, nhưng về cơ bản nó phù hợp với các nhóm 2 của chữ số hàng đầu (được lưu trữ trong nhóm chụp 1, vì vậy chúng ta có thể tham chiếu nó với \1).

Chìa khóa ở đây, là nếu nó thất bại khi sử dụng kết hợp không tham lam cho đến hai lần xuất hiện sớm nhất của các chữ số, thì nó sẽ chỉ quay lại và thử lại, .khớp với chữ số. Điều này sẽ làm cho các số như 111 khớp với nhau khi chữ số của chúng tôi là 1. Do đó, chúng tôi sử dụng ?>để tạo ra nguyên tử khớp, về cơ bản ngăn không cho regex quay lại trước khi nó khớp với giá trị này. Một trận đấu nguyên tử làm việc giống như bản năng chiếm hữu hợp sẽ trong hương vị nhất định. Kể từ khi *meta-nhân vật được theo sau bởi một ?sự phù hợp với một nhân vật bổ sung, chúng tôi chữ số, trong đó sẽ tạo ra các trận đấu không hợp lệ.. sẽ phù hợp với nhân vật lên cho đến khi nó có thể phù hợp với những gì chúng ta lưu trữ trong \1. Sau đó, một khi chúng ta làm điều này hai lần, "bộ nhớ" của biểu thức chính quy sẽ bị hủy, ngăn chặn hành vi thường xảy ra, nơi nó quay trở lại và có.\1

Sau đó, chúng tôi kiểm tra xem từ vị trí cuối cùng, sau khi khớp các nhóm lặp lại của hai chữ số đầu vào, chúng tôi không thể khớp với một chữ số đầu vào khác.

.,
<empty>

Ở đây chúng tôi chỉ xóa các chữ số và dấu phẩy từ mỗi chuỗi, vì vậy chúng tôi chỉ nhận được câu trả lời hay của chúng tôi.

Python 2, 57 54 byte

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

Sử dụng

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

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

Đây là một hàm chấp nhận hai số nguyên và trả về một mảng.

Chúng tôi bắt đầu với bộ số nguyên từ 1 đến n, bao gồm. Đối với mỗi số nguyên i, chúng tôi xác định các chữ số thập phân nào bằng d, tạo ra một mảng Boolean. Chúng tôi sumđiều này để có được số lần xuất hiện ddưới dạng một chữ số ivà filterphạm vi ban đầu dựa trên tính chẵn lẻ của tổng.

Hãy thử nó ở đây

Nghiêm túc, 17 byte

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

Lấy đầu vào là n\n'd'(số nguyên, dòng mới, chuỗi).

Hãy thử trực tuyến!

Giải trình:

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

Toán học, 45 byte

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

Sử dụng tích hợp DigitCount.

Japt, 13 12 byte

Uò1 f_s èV v

Đầu vào là n , sau đó d bọc trong dấu ngoặc kép. Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

       // 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 byte

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

Giải trình

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 byte

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

R, 145 byte (Tôi chắc chắn có nhiều cách để rút ngắn điều này hơn nữa) :)

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