Eingang

Eine ganze Zahl n (≥ 1) und eine Ziffer d (eine ganze Zahl mit 0 ≤  d  ≤ 9).

In jeder Reihenfolge; von stdin oder Parametern oder was auch immer; zu einem Programm oder einer Funktion; etc.

Ausgabe

Die ganzen Zahlen von 1 bis einschließlich n (in der Reihenfolge), deren Dezimaldarstellungen eine gerade Anzahl von ds enthalten . (Das heißt, die Ganzzahlen in der Liste sind die Ganzzahlen, die jeweils eine gerade Anzahl von ds haben .)

In jedem Standardformat usw. Insbesondere muss die Ausgabe nicht dezimal dargestellt werden.

Bei der Ausgabe als einzelne Zeichenfolge müssen die Ganzzahlen getrennt werden (Leerzeichen, Kommas, Zeilenumbrüche, Null-Bytes usw.).

Beispiele

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

Vielen Dank

Zur Quintopie für den Titel.

Gelee, 7 Bytes

RDċ€Ḃ¬T

Probieren Sie es online!

Wie es funktioniert

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 Bytes

Code:

\>GN¹¢ÈiN,

Erläuterung:

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

Probieren Sie es online aus

Verwendet die CP-1252- Codierung.

Haskell, 69 63 52 50 Bytes

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

Direkte Lösung für meinen allerersten Post hier. Es verwendet showdie Anzahl der zu zählen dist. Ich habe ausdrücklich nicht Charals Eingabe für verwendet d, die 12 6 (nach Damiens Bearbeitung) Bytes gespeichert hätte .

EDIT: 11 Bytes weniger dank Damien! EDIT 2: noch 2 Bytes weniger dank nimi!

Befunge, 1080 945 Bytes

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^

Die Punktzahl ergibt, dass wir das gesamte Quadrat einschließlich der Zeilenumbrüche zählen, was sinnvoll ist. Sie können den Code kopieren und in den Interpeter einfügen . Stellen Sie zwei Eingänge bereit, zuerst d und dann n . Diese Lösung funktioniert nicht für Werte größer als n > 999.

Dies wird natürlich kein Anwärter auf den Hauptpreis sein, aber ich wollte schon seit einiger Zeit ein Codegolf in Befunge implementieren, also habe ich beschlossen, es einfach zu tun. Ich gehe davon aus, dass dies nicht annähernd zu einer optimalen Befunge-Lösung führen wird, da es das erste ist, was ich in Befunge gemacht habe. Also, Hinweise sind willkommen, wenn Sie Klarstellung oder weitere Informationen benötigen, lassen Sie es mich bitte in den Kommentaren wissen.

Erklärungsversuch:

In der ersten Spalte abwärts lesen wir eine Ganzzahl aus der Eingabe, addieren 48 (6 * 8, das sehen Sie öfter), um sie in den entsprechenden ASCII-Wert umzuwandeln und zu setzen (10, 0).

& - Eingabe lesen

68*+ - 48 hinzufügen

55+0p - Setzen Sie den Wert auf (10, 0)

Beachten Sie, dass dat (1, 0)nur ein einfacher Weg ist, um die Zahl 100 auf den Stapel zu bekommen.

Danach gehen wir nach Osten und lesen eine andere Ganzzahl und gehen zu dem, was ich ASCIIfier nenne. Dadurch wird die aktuelle Nummer in eine Reihe von ASCII-Zeichen umgewandelt. Der ASCIIfier ist das rechteckige Stück von (13, 12)bis (26, 17). Es besteht aus zwei Schleifen, die zuerst die Hunderter und dann die Zehner zählen und diese bei (6, 0)und auf die drei Ziffern setzen (5, 0). Danach wird die letzte Ziffer eingegeben (4, 0). Die Zahlen sind also eigentlich umgekehrt.

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)

Nachdem wir die aktuelle Ganzzahl in eine Reihe von ASCII-Zeichen eingefügt haben, gehen wir etwas weiter nach Süden, um vorangestellte Nullen zu entfernen. Somit ist danach, was anfangs die drei oberen Nullen sind, die aktuelle Zahl ohne vorangestellte Nullen.

Dann gehen wir zurück nach Norden, wo wir die drei Ziffern auf den Stapel legen. Wir iterieren über die drei Ziffern in der oberen Schleife und erhöhen jedes Mal den Zähler, der sich auf befindet, (1, 1)wenn die aktuelle Ziffer der Eingabe d entspricht

Wenn das erledigt ist, gehen wir und prüfen, ob der Zähler, an dem sich (1, 1)befindet, ungerade oder gerade ist. Wenn es gerade ist, geben wir die aktuelle Zahl aus und fahren mit der großen äußeren Schleife fort, um den aktuellen Wert zu dekrementieren und von vorne zu beginnen.

Python 2, 50 Bytes

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

Eine rekursive Funktion, die die Ziffer dals Zeichenfolge und die Obergrenze nals Zahl verwendet.

Die Zahl der Stellen dist in ngetestet sogar sein , indem sie die Bit - Komplement Modulo - 2 - Aufnahme, die gibt es 1noch und 0für ungerade. Diese vielen nwerden an die Liste angehängt und die Funktion läuft weiter bis n-1und stoppt über einen logischen Kurzschluss auf der leeren Liste, wenn n==0.

Wenn die Ausgabe in absteigender Reihenfolge erfolgt, kann ein Byte für 49 Byte gespeichert werden:

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

Alte 51-Byte-Lösung:

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

Eine anonyme Funktion, die die Ziffer dals Zeichenfolge und die Obergrenze nals Zahl verwendet.

Zwei Tricks werden verwendet:

• Python's rangeist null-indiziert 0...n-1, also addieren wir einen zu jedem potenziellen Wert x. Dann zu zählen d‚s in x+1, es spart ein Zeichen seine Negation verwenden ~xstatt.
• Um nach geraden Werten zu filtern, verwenden wir ~_%2zuerst die Bit-Flips, um die Parität umzuschalten, und nehmen dann das letzte Bit mit &1(wie %2hier). Dabei wird nur dann ein wahrer Wert erzeugt, wenn das Original gerade war.

Pyth, 10 Bytes

f!%/`Tz2SE

Probieren Sie es online aus. Testsuite.

Lua, 86 Bytes

Bei der Verwendung von inkonsistenten Separator erlaubt ist, könnte ich ersetzen io.writedurch print, dh Zahlen , die durch einen oder mehrere Zeilenumbrüche getrennt werden würde.

Dies ist ein komplettes Programm, das wie folgt aufgerufen werden müssen: lua file.lua d n.

Es entfernt alle Nicht- dZeichen aus der aktuellen Zahl und verwendet die Größe der resultierenden Zeichenfolge, um zu entscheiden, ob sie ausgegeben werden soll oder nicht.

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

JavaScript (ES6) 64

Eine anonyme Funktion mit Ausgabe an die Konsole. Einfache Implementierung mit, splitum die Ziffern zu zählen.

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

Die Ausgabe mit alertwürde 6 Byte weniger sein, aber ich mag es wirklich nicht (und ich werde die Spielzeugsprachen sowieso nicht schlagen)

MATL , 12 10 Bytes

:!V!=s2\~f

Die erste Eingabe ist n , die zweite ist d als Zeichenfolge. Beispielsweise:

12
'1'

Probieren Sie es online!

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

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

Führen Sie mit d und n als Befehlszeilenparameter aus, z

ruby golf.rb 1 12

PowerShell, 62 55

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

edit: die verwendung eines param-blocks ist in diesem fall kürzer. redundanten Speicherplatz entfernt

Keine Golfsprache, aber die einzige, die ich wirklich kenne. Dies würde als Skript gespeichert und so aufgerufen werden M:\Scripts\cgNeverTellMeTheOdds.ps1 1 12. Das erste Argument ist die Ziffer d und das zweite ist die Ganzzahl n .

Erstellen Sie ein Array mit den Nummern 1 bis n . Für jeden konvertieren Sie das in ein Zeichen-Array. 10 wäre 1,0. Bei Verwendung -matchals Array-Operator werden alle Elemente zurückgegeben, die mit der Ziffer d übereinstimmen . Zählen Sie die Anzahl der zurückgegebenen Elemente und mod 2 das Ergebnis. Das Ergebnis ist 0 für gerade und 1 für ungerade. 0 als Boolescher Wert ist false, daher wird !für die Schleife verwendet, um die ungeraden Ergebnisse als false und die geraden Ergebnisse als true auszuwerten.

Ausgabe ist ein Zeilenumbruch, der auf der Konsole begrenzt ist.

Retina , 99 105 Bytes

Beachten Sie die nachstehenden Leerzeichen. <empty>steht für eine leere Zeile.

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

Nimmt Eingaben wie 1 12. Die Ausgabe wird in absteigender Reihenfolge durch Leerzeichen getrennt.

Ich habe geändert 0*1(0|10*1)*, um einer ungeraden Zahl \1in einer Zahl zu entsprechen. Ich habe 0zu (?!\1)\dund 1zu geändert , \1um die lange Regex-Linie zu erstellen, die Sie oben sehen. Es ist entscheidend zu verstehen, wie der verknüpfte reguläre Ausdruck funktioniert.

Probieren Sie es online aus

Kommentierte Erklärung der alten Version

Wenn absteigende Reihenfolge in Ordnung wäre

\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-Dienstprogramme, 37

• 1 Byte gespart dank @Ruud.

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

Python 3.4, 92 85 79 85 Bytes

7 Bytes dank Mego
gespeichert Weitere 6 Bytes dank mbomb007 gespeichert
6 Bytes wurden aufgrund von Python 3.x

Dies ist mein erster Versuch mit Codegolf, hier geht also nichts!

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 Bytes

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

Brachylog , 32 Bytes

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

Erwartet N als Eingabe und die Ziffer als Ausgabe, z brachylog_main(12,1).

Erläuterung

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

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

Perl, 28 29 31 Bytes

Beinhaltet +2 für -an

Führen Sie mit der Spezifikationsziffer aus und zählen Sie in aufeinanderfolgenden Zeilen auf STDIN:

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

Oracle SQL 11.2, 111 82 Bytes

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

Kotlin, 136 Bytes

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

Voll funktionsfähiges Programm, Argumente wie: nd

Probieren Sie es online!

Java 8, 84 Bytes

Dies ist ein Lambda-Ausdruck für BiConsumer< Integer, Integer>:

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

Erläuterung:

Konvertieren Sie für jede Zahl zwischen 1 und n die Zahl in eine Zeichenfolge und teilen Sie sie mit d als Trennzeichen. Wenn es in eine ungerade Anzahl von Abschnitten aufgeteilt wurde, drucken Sie die Nummer aus, gefolgt von einer neuen Zeile.

Retina, 72 71 55

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

Ein großes Dankeschön an Martin, der mich aus Versehen an atomare Matching-Gruppen erinnert hat!

Probieren Sie es online!

Erläuterung:

\d+$
$*

Ersetzen Sie die Zahl, aber nicht die Ziffer, durch das unäre Äquivalent.

\B
¶$`

\Bstimmt mit jeder Position (Breite Null) überein, die keine Wortgrenze ist. Beachten Sie, dass dies keinem der folgenden Elemente entspricht: dem Anfang der Zeichenfolge, dem Ende der Zeichenfolge oder einer beliebigen Position um das Komma. Jede dieser Nichtgrenzen wird dann durch eine neue Zeile und dann die Zeichenfolge ersetzt, die vor dem match ( $`) steht. Dies gibt eine Liste wie:

d,1
d,11
d,111

Wo dist eine einzelne Dezimalstelle.

1+
$.0

Dies konvertiert alle Listen von 1s in die dezimale Darstellung ihrer Länge. Dies wirkt sich günstigerweise nicht auf das 1Komma aus, da es immer 1auch die Länge hat .

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

Hier wird der GGrep-Modus aktiviert, was bedeutet, dass Zeilen, die mit dem regulären Ausdruck übereinstimmen, beibehalten und andere Zeilen verworfen werden. Dieser reguläre Ausdruck ist kompliziert, stimmt jedoch im Wesentlichen mit Gruppen von 2 der führenden Ziffer überein (in Erfassungsgruppe 1 gespeichert, sodass wir darauf verweisen können \1).

Der Schlüssel hier ist, dass, wenn es fehlschlägt, wenn die nicht-gierige Übereinstimmung bis zu den zwei frühesten Erscheinungen der Ziffern verwendet wird, es einfach zurückgesetzt und erneut versucht wird, wobei die .Übereinstimmung über der Ziffer erfolgt. Dies würde dazu führen, dass Zahlen wie 111 übereinstimmen, wenn unsere Ziffer 1 ist. Daher verwenden wir ?>, um die Übereinstimmung atomar zu machen, wodurch im Wesentlichen verhindert wird, dass der Regex zurückverfolgt wird, bevor er mit diesem Wert übereinstimmt. Ein atomares Match funktioniert in bestimmten Geschmacksrichtungen ähnlich wie ein Possesive Matching. Da auf das *Metazeichen ein folgt, werden ?die .Zeichen solange mit dem übereinstimmen, bis es mit dem übereinstimmt, was wir in gespeichert haben \1. Sobald wir dies zweimal tun, wird der "Speicher" des regulären Ausdrucks zerstört, wodurch das normalerweise auftretende Verhalten verhindert wird, bei dem er zurückgeht und das hat.stimmen mit einem zusätzlichen Zeichen, unserer \1Ziffer, überein , wodurch ungültige Übereinstimmungen erzeugt würden.

Dann prüfen wir von der Endposition aus, nachdem wir wiederholte Gruppen von zwei der Eingabeziffer abgeglichen haben, dass wir nicht mit einer anderen Eingabeziffer übereinstimmen können.

.,
<empty>

Hier entfernen wir nur die Ziffer und das Komma von jeder der Zeichenfolgen, sodass wir nur unsere nette Antwort erhalten.

Python 2, 57 54 Bytes

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

Verwendung

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

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

Dies ist eine Funktion, die zwei Ganzzahlen akzeptiert und ein Array zurückgibt.

Wir beginnen mit der Menge der ganzen Zahlen von 1 bis neinschließlich. Für jede Ganzzahl ibestimmen wir, welche ihrer Dezimalstellen gleich sind d, was ein Boolesches Array ergibt. Wir berechnen sumdies, um die Anzahl der Vorkommen dals Ziffer in iund filterden ursprünglichen Bereich basierend auf der Parität der Summe zu erhalten.

Probieren Sie es hier aus

Im Ernst, 17 Bytes

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

n\n'd'Übernimmt Eingaben als (Integer, Newline, String).

Probieren Sie es online!

Erläuterung:

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

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

Verwendet die eingebaute DigitCount.

Japt, 13 12 Bytes

Uò1 f_s èV v

Eingang ist n , dann d in Anführungszeichen gewickelt. Online testen!

Wie es funktioniert

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

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

Erläuterung

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 Bytes

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

R, 145 Bytes (ich bin sicher, dass es Möglichkeiten gibt, dies weiter zu verkürzen) :)

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