Sag mir nie die Chancen

38

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.

msh210
quelle
Zählt 0 als gerade Zahl?
MilkyWay90
@ MilkyWay90 natürlich.
msh210

Antworten:

3

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.
Dennis
quelle
13

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.

Adnan
quelle
¢ interpretiert beide Argumente als Zeichenketten?
Sparr
@Sparr Das hängt davon ab, ob es sich um Listen handelt, die Zeichenfolgen enthalten. Aber hier interpretiert es beide Argumente als Zeichenfolgen.
Adnan
13

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!

Renzeee
quelle
2
Sie könnten den Filter durch eine Verständnisliste ersetzen: fdn = [i | i <- [1..n], sogar $ sum [1 | x <- zeige i, lese [x] == d]]
Damien
12

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.

rael_kid
quelle
Bitte schreibe eine Erklärung, wenn du Zeit hast!
Ein Simmons
Ich habe einen Versuch zu einer Beschreibung hinzugefügt .. Fand heraus, dass es nicht so einfach zu klären war ...
Zögern
Übrigens habe ich gerade herausgefunden, dass ich das Ergebnis in aufsteigender Reihenfolge ausgeben muss, was es noch unpassender für die Anforderungen macht ....
rael_kid
Immer +1 für eine funktionierende Antwort von Befunge! Übrigens, ist das wirklich 945 Bytes? Dies sagt 679
Luis Mendo
Hehe, danke. Ich habe 945 gezählt, weil ich das gesamte Quadrat mit 21 Zeilen x 45 Spalten (einschließlich Zeilenvorschub) genommen habe
rael_kid
7

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.
xnor
quelle
4

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
Katenkyo
quelle
4

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)

edc65
quelle
4

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
Luis Mendo
quelle
4

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
Jordan
quelle
2
Tolle erste Antwort! Willkommen bei PPCG! : D
mbomb007
Gut gemacht! In Ruby 1.9+ können Sie ?1für verwenden "1". Und es ist weniger hübsch, aber ein Byte kürzer zu tun , %2>0statt.odd?
histocrat
4

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.

Matt
quelle
Willkommen bei PPCG, schöne erste Antwort! :)
FryAmTheEggman
@FryAmTheEggman Süß. Danke für das Nicken. Ich dachte das wäre unter all den anderen Antworten begraben.
Matt
3

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>
mbomb007
quelle
1
Sie können 1+und verwenden $.0, um die Konvertierung von unär zurück nach dezimal durchzuführen.
FryAmTheEggman
3

Bash + GNU-Dienstprogramme, 37

  • 1 Byte gespart dank @Ruud.
seq $1|egrep "^[^$2]*($2[^$2]*){2}*$"
Digitales Trauma
quelle
Im *Folgenden scheint die öffnende Klammer überflüssig zu sein. Wenn Sie es entfernen, sparen Sie 1 Byte.
Ruud Helderman
@Ruud ja - danke - jetzt behoben.
Digital Trauma
3

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]
Nakaan
quelle
1
Hier können Sie einige Leerzeichen entfernen. Wenn Sie ein unbenanntes Lambda festlegen, wird es auch erheblich kürzer.
Mego
Sie können `d`anstelle von verwenden str(d), und wenn Sie annehmen, dass n eine Ganzzahl (<2 ** 32) ist, können Sie `i`anstelle von verwenden str(i).
mbomb007
Stehen die Backticks für str ()?
Nakaan
1
Die Backticks waren eine Abkürzung für __repr__in Python 2, sie wurden in Python 3 entfernt. Sie sollten wahrscheinlich Ihren Header ändern, um diese Einschränkung widerzuspiegeln.
FryAmTheEggman
Ja, ich habe das gerade gefunden, als ich herumgebuddelt und einen Testfall in den Dolmetscher geworfen habe. Trauriges Gesicht.
Nakaan
2

Perl 6, 38 Bytes

{(1..$^n).grep(*.comb.Bag{~$^d} %% 2)}
Hotkeys
quelle
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)
Tödlich
quelle
2

Mathematica, 54 Bytes

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

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..<>'
Tonne Hospel
quelle
2

Oracle SQL 11.2, 111 82 Bytes

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

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!

Matt Sams
quelle
2

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.

Jack Ammo
quelle
2

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.

FryAmTheEggman
quelle
Bitte fügen Sie eine Erklärung hinzu.
mbomb007
@ mbomb007 Ok, hinzugefügt :)
FryAmTheEggman
Atomic Matching verstehe ich noch nicht.
mbomb007
@ mbomb007 Ich habe versucht zu klären, was los ist, lass es mich wissen, wenn etwas als unklar auffällt.
FryAmTheEggman
1

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]
Zach Gates
quelle
1

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

Alex A.
quelle
1

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
Mego
quelle
1

Mathematica, 45 Bytes

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

Verwendet die eingebaute DigitCount.

LegionMammal978
quelle
1

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
ETHproductions
quelle
1

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
Zach Gates
quelle
1

Scala, 66 Bytes

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

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)])
Jeff I
quelle