입력

정수 n (≥ 1) 및 숫자 d (0 ≤ d  ≤ 9 와 같은 정수  ).

어느 쪽이든 stdin 또는 매개 변수 또는 기타 프로그램이나 기능에; 기타

산출

10 진수 표현에 짝수 의 d가 포함 된 1부터 n 까지 의 정수 (순서대로)입니다 . (즉, 목록의 정수는 각각 짝수의 d 를 갖는 정수입니다 .)

표준 형식 등. 특히 출력은 10 진수로 표현할 필요가 없습니다.

단일 문자열로 출력되는 경우 정수는 공백, 쉼표, 줄 바꿈, 널 바이트 등 어떻게 든 구분해야합니다.

예

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 인코딩을 사용합니다 .

하스켈, 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 바이트가 더 적습니다!

비 펀지, 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)

것을 참고 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 문자에 넣은 후 앞에 0을 제거하기 위해 조금 더 남쪽으로갑니다. 따라서 나중에 맨 위에있는 세 개의 0은 앞에 0이없는 현재 숫자가됩니다.

그런 다음 북쪽까지 올라가서 세 자리 숫자를 쌓아 올립니다. 우리 (1, 1)는 현재 루프 가 입력 d 와 일치하는 경우 에 위치한 카운터를 증가시킬 때마다 상단 루프에서 세 자리를 반복합니다.

그것이 끝나면 우리는 가서 카운터 (1, 1)가 홀수인지 짝수인지 확인합니다. 짝수이면 현재 숫자를 출력하고 큰 외부 루프로 이동하여 현재 값을 줄이고 다시 시작합니다.

파이썬 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 바이트 동안 1 바이트를 저장할 수 있습니다.

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.

두 가지 트릭이 사용됩니다.

• 파이썬 range은 인덱스가 0 0...n-1이므로 각 잠재적 값에 하나씩 추가합니다 x. 그런 다음, 계산하기 d에이야 ' 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

자바 스크립트 (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 번째된다 거라고 문자열로. 예를 들면 다음과 같습니다.

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

편집 :이 경우 param 블록을 사용하는 것이 짧습니다. 여분의 공간을 제거했습니다.

골프 언어는 아니지만 내가 아는 유일한 언어입니다. 이것은 스크립트로 저장되어 다음과 같이 호출 M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12됩니다. 첫 번째 인수는 숫자 d 이고 두 번째 인수는 정수 n입니다. 입니다.

1에서 n 까지의 배열을 만듭니다 . 각각에 대해 문자 배열로 변환하십시오. 10은 1,0입니다. -match배열 연산자로 사용 하면 숫자 d 와 일치하는 모든 요소가 반환됩니다 . 리턴 된 요소의 수를 세고 결과를 mod 2로 설정하십시오. 짝수의 경우 결과는 0이고 홀수의 경우 1입니다. 부울 값이 0 인 경우 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>

배쉬 + 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]

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

수학, 54 바이트

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

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

완전한 기능의 프로그램으로 다음과 같은 인수를 사용합니다.

온라인으로 사용해보십시오!

자바 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>

원자 적으로 짝을 이루는 그룹을 생각 나게 한 Martin에게 감사합니다!

온라인으로 사용해보십시오!

설명:

\d+$
$*

숫자가 아닌 숫자를 단항으로 바꿉니다.

\B
¶$`

\B단어 경계가 아닌 각 위치 (너비 0)와 일치합니다. 이는 문자열의 시작, 문자열의 끝 또는 쉼표 문자 주위의 위치와 일치하지 않습니다. 이러한 각 비 경계는 개행 문자로 바뀐 다음 일치하기 전에 오는 문자열 ( $`) 로 바뀝니다 . 이것은 다음과 같은 목록을 제공합니다.

d,1
d,11
d,111

d소수점 이하 자릿수가 어디에 있습니까 ?

1+
$.0

모든 1s 목록을 길이의 10 진수 표현으로 변환합니다 . 이 1길이는 항상 길이가 길기 때문에 쉼표 앞에있을 수 있는 것에는 편리하게 영향을 미치지 않습니다 1.

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

여기서 Ggrep 모드를 켜면 정규 표현식과 일치하는 줄이 유지되고 다른 줄은 삭제됩니다. 이 정규식은 복잡하지만 본질적으로 선행 자릿수 2의 그룹과 일치합니다 (캡처 그룹 1에 저장되므로이를 참조 할 수 있음 \1).

여기서 핵심은 욕심없는 일치를 사용하여 숫자의 가장 빠른 두 모양까지 실패했을 경우 롤백 .하고 숫자 와 일치하여 다시 시도한다는 것 입니다. 이것은 우리의 숫자가 1 일 때 111과 같은 숫자를 일치시킬 것입니다. 따라서 ?>정규 표현식을 원자 적으로 만드는 데 사용 합니다. 원자 일치는 특정 풍미에서 포괄적 일치 와 비슷하게 작동합니다 . 때문에 *메타 문자는 뒤에?. 우리가에 저장된 내용과 일치 할 수있을 때까지 문자를 일치합니다 \1. 그런 다음이 작업을 두 번 수행하면 정규식의 "메모리"가 손상되어 정상적으로 발생하는 동작을 방지하며.\1유효하지 않은 일치 항목을 만든 추가 문자 인 숫자를 일치시킵니다.

그런 다음 입력 위치 중 두 개의 반복 된 그룹을 일치시킨 후 최종 위치에서 다른 입력 숫자와 일치 할 수 없는지 확인합니다.

.,
<empty>

여기서 우리는 각 문자열에서 숫자와 쉼표를 제거하기 때문에 좋은 대답을 얻습니다.

파이썬 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.

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