Herausforderung:

Ihr Programm nimmt zwei Ganzzahlen nund kals Eingabe und gibt die kleinste Ganzzahl aus, die größer (aber nicht gleich) nist und mindestens kVorkommen der Ziffer enthält 5.

Sie können davon ausgehen 1 ≤ k ≤ 15und 1 ≤ n < 10**15.

Dies ist eine zeitlich begrenzte Herausforderung. Ihr Programm muss für alle Testfälle auf TIO ausgeführt und innerhalb von insgesamt 10 Sekunden abgeschlossen sein.

Allgemeine Regeln:

• Dies ist Code-Golf , daher gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich nicht von Code-Golf-Sprachen davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden .

• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln . Sie können also STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf. Die Funktionsparameter können in beliebiger Reihenfolge verwendet werden, bitte geben Sie dies in Ihrer Antwort an.

• Standardschlupflöcher sind verboten.
• Sie müssen einen Link mit einem Test für Ihren Code (dh TIO ) hinzufügen .
• Der Antwortheader sollte die Punktzahl in Bytes, aber auch die Gesamtzeit für alle Testfälle auf TIO auflisten
• Wenn Ihre Sprache nicht auf TIO ist, sollte der Code auf Ihrem Computer weit unter 10 Sekunden dauern, damit Sie sicher sind, dass er auf jedem vernünftigen Computer schnell genug ist.
• Es wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

(n, k) ->  output
(53, 2) -> 55
(55, 1) -> 56
(65, 1) -> 75
(99, 1) -> 105
(555, 3) -> 1555
(557, 1) -> 558
(5559, 3) -> 5565
(6339757858743, 5) -> 6339757859555
(99999999999999, 15) -> 555555555555555

Programmbeispiel:

Dieses Programm ist korrekt.

R + stringr, 85 84 76 Bytes, 0,062 s auf TIO

f=function(n,k,m=2+stringr::str_count(n+1,"5")-k)`if`(m<2,f(n+.1^m*2,k),n+1)

Probieren Sie es online aus!

-1 Byte dank Robert S.
-8 Byte dank Giuseppe.

Eine einfache rekursive Lösung wäre, um 1 zu erhöhen, bis die Antwort gefunden ist, aber dies würde die zeitliche Beschränkung nicht erfüllen. Um die zeitliche Beschränkung zu erfüllen, nutzt diese Funktion die Tatsache, dass wir, wenn p 5s fehlen, um 2 * 10 ^ (p-2) inkrementieren können.

Beachten Sie, dass bei p = 1 das Inkrement 0,2 wird. Dies ist in Ordnung, da wir nach 5 Schritten zu einer Ganzzahl zurückkehren und keine der in der Zwischenzeit angetroffenen Dezimalzahlen eine zusätzliche 5 hat. Wenn wir stattdessen um 5 * 10 ^ (p-2) oder um 1 erhöhen würden * 10 ^ (p-2), dann würden wir zum Beispiel f (24, 1) = 24,5 anstelle von 25 finden.

Gelee , 37 Bytes 0,113 s auf TIO

»DL‘Ɗ}©5xḌ_DḌÐƤ;®ŻṬ€UḌ¤+⁹D=5S>ʋƇ⁸’¤ḟṂ

Probieren Sie es online aus!

Das funktioniert von

1. Berechnen Sie das Maximum der Anzahl der Stellen in der Eingabe plus eins und kund machen Sie eine Zahl mit so vielen Fünfern
2. Subtrahieren der Eingabe von dieser Zahl
3. Generieren aller Suffixe dieser Nummer
4. Erzeugt auch alle Zehnerpotenzen von 1 bis zur nächsten, die größer als die Eingabe sind
5. Fügt jede der Zahlen in 3 und 4 zur Eingabe hinzu
6. Entfernt Antworten mit zu wenigen 5en
7. Filtert die Eingabe aus den Antworten heraus
8. Und gibt das Minimum zurück

05AB1E , 33 32 Bytes

sg>‚à©5s×α.s0š®Ý°0šâO+IKʒ§5¢¹@}ß

Port of @NickKennedys erstaunlicher Ansatz in seiner Jelly-Antwort , also stellen Sie sicher, dass Sie ihn positiv bewerten !!

$k$$n$

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

sg>                # Get the length+1 of the second (implicit) input-integer
   ‚à              # Pair it with the first input-integer, and leave the maximum
     ©             # Store this maximum in the register (without popping)
      5s×          # Create an integer (actually, create a string..) with that many 5s
         α         # Take the absolute difference with the second (implicit) input
          .s       # Get the prefixes of that number
            0ª     # Prepended with an additional 0
    ®              # Get the maximum from the register again
     Ý             # Create a list in the range [0, max]
      °            # Raise 10 to the power of each integer
       0ª          # And also prepend an additional 0 to this list
              â    # Then create each possible pair of these two lists
               O   # Sum each pair
                +  # Add the second input to each sum
IK                 # Then remove the second input from this list (if present)
  ʒ                # And filter this list by:
   §               #  Cast the number to a string (bug, shouldn't be necessary)
    5¢             #  Count the amount of 5s in the string
      ¹@           #  And check if this count is larger than or equal to the first input
        }ß         # After the filter: only leave the lowest number
                   # (which is output implicitly as result)

Stax , 17 Bytes (insgesamt 6,861 Sekunden bei TIO)

≈ª╞¥é£ôñτ←╝α┴╢JLd

Führen Sie es aus und debuggen Sie es

Dieses Programm nimmt kund nauf Standardeingabe durch Leerzeichen getrennt. Stax bietet keine bequeme Möglichkeit, mehrere Testfälle auf TIO auszuführen. Daher habe ich jede Eingabe separat ausgeführt und die Zeit addiert. In 99% der Fälle wird der Interpreterprozess gestartet. Mit dem Javascript-Interpreter in staxlang.xyz werden alle Testfälle in 50 Millisekunden ausgeführt.

Letzter Testfall auf Try it online!

Vorgehensweise :

1. Eingabe erhöhen
2. Wenn genügend 5s vorhanden sind , beenden und drucken
3. t= Anzahl der nachgestellten 5s in der Anzahl
4. Hinzufügen 10 ** t
5. Gehe zu 2

Python 2 , 70 68 Bytes (0,025 Sekunden bei TIO)

l=lambda n,k:'5'*k*(10**~-k>n)or-~n*(`n+1`.count('5')>=k)or l(n+1,k)

Probieren Sie es online aus!

Dies könnte ein bisschen langwierig sein; Es ist in allen Fällen korrekt und endet in vernachlässigbarer Zeit für die Testfälle, in einigen anderen Fällen jedoch nicht in angemessener Zeit. Es erfüllt jedoch technisch die Anforderungen.

Kurz gesagt, wenn die kleinste Zahl mit kfünf größer als ist n, verwenden wir diese Zahl, da dies offensichtlich die richtige Lösung ist. Ist dies nicht der Fall, greifen wir auf den rekursiven Standardansatz zurück.

Perl 5 -pl , 44 Bytes

$k=<>;$_++;s/.*?(?=5*$)/1+$&/e while$k>y/5//

Probieren Sie es online aus!

Findet, was die Zahl ist, ohne die nachgestellten 5s. Erhöht diesen Teil um 1. Fährt fort, bis genügend 5s in der Zahl sind. Es dauert ungefähr 0,012 Sekunden auf TIO, um alle Testfälle auszuführen.

Python 3 , 144 98 86 75 Bytes

f=lambda N,k,d=1:k>str(-~N).count("5")and f(N+-(-~N//d+5)%10*d,k,d*10)or-~N

Probieren Sie es online aus!

$\mathcal{O}(k)$

Der Algorithmus besteht darin, jede Ziffer (beginnend mit der niedrigstwertigen) auf den nächsten Wert von 5 aufzurunden, bis die Dezimaldarstellung der neuen Zahl die gewünschte Anzahl aufweist.

Der ursprüngliche Ansatz verwendete ein abbrechbares Listenverständnis (D = iter (Bereich (k)) und Liste (D) bei der Arbeit hier), aber @ ASCII-only hat mich überzeugt, dass Code-Golf niemals gewinnen wird. Ich mag keine Rekursion, aber wenn der Algorithmus so geschrieben ist, dass die Rekursionstiefe minimiert wird, ist ein zukünftiger Compiler / Interpreter klug genug, um ihn als while-Schleife erneut zu implementieren.

Python 3 , 59 Bytes

Rekursive Lösung. Die Rekursionstiefe ist ein Problem (muss für höhere Zahlen geändert werden), ist aber korrekt.

lambda x,k:eval(("f(x+1,k)","x+1")[str(x+1).count("5")==k])

Probieren Sie es online aus!

Python 3, 72 Bytes

def f(n,k):
 while(1):
  n+=1
  if str(n).count('5')>=k:return n

Probieren Sie es online aus!

Java 8, 69 Bytes, 60+ Sekunden auf TIO mit dem letzten Testfall, ~ 1,5 Sekunden ohne.

(n,k)->{for(;(++n+"").chars().filter(i->i==53).count()<k;);return n;}

Hat jemand eine Idee, wie man den letzten Testfall besteht?

PHP ,109 97 Bytes (<0,03 s bei TIO)

function($n,$k){++$n;do if(count_chars($n)[53]>=$k)return$n;while($n+=10**strspn(strrev($n),5));}

Probieren Sie es online aus!

Basierend auf dem Algorithmus von @ recursive .

Netzhaut , 63 Bytes

.+$
*
^.+
$.(*__
/((5)|.)+¶(?<-2>_)+$/^+`^.*?(?=5*¶)
$.(*__
1G`

Probieren Sie es online aus! Nimmt nund kin separaten Zeilen, aber Link enthält Header, der die Testsuite in das entsprechende Format konvertiert. Erläuterung:

.+$
*

In unary konvertieren k.

^.+
$.(*__

Inkrementieren n. Das *wiederholt sein rechtes Argument (hier das erste _Zeichen) so oft, wie es von seinem linken Argument angegeben wird (das wie hier standardmäßig mit der Übereinstimmung übereinstimmt). Dies führt zu einer Zeichenfolge dieser Länge. Das $((das )ist impliziert) verkettet dann das mit dem zweiten _und .bewirkt, dass die resultierende Länge genommen wird. (Tatsächlich ist Retina 1 klüger als das und führt zunächst nur die Berechnung der zugrunde liegenden Längen durch.)

/((5)|.)+¶(?<-2>_)+$/

Testen Sie, ob genügend 5s gefunden werden können, um nmit dem _s der unären Darstellung von übereinzustimmen k. Dieser Test wurde golfen und wäre dreimal schneller mit dem ^Hinzufügen nach dem ersten /und noch schneller, wenn [^5]er anstelle von verwendet würde ..

^+`

Bis der Test bestanden ist ...

^.*?(?=5*¶)
$.(*__

... inkrementieren, naber abschließende 5s ausschließen.

1G`

Löschen k.

Clam , 30 Bytes, ~ 0,2 s auf TIO

=Q+r1=qC5R1?<qQ[=qrw<n#:q5QqiQ

Transpiles zu diesem JS (vollständige Testsuite für das Timing hinzugefügt), wo inputssich ein Array der Eingaben befindet ( nerste, kzweite)

Danke @ArBo für den Ansatz

Erläuterung

=Q+r1=qC5R1?<qQ[=qrw<n#:q5QqiQ - Implicit Q = first input
=Q+r1                          - Q = next input (1st input) + 1
     =qC5R1                    - q = 2nd input 5s (eg 555 for k=3)
           ?<qQ[               - if q < Q...
                =qr            -   q = next input (2nd input)
                   w           -   while...
                     n         -     length of...
                      #:q5Q    -       Q.filter(q=>q==5)
                    <          -     is less than...
                           q   -       q
                            iQ -     Increment Q
                               - Implicit output of Q

C (gcc) , 159 158 152 150 149 Bytes, ~ 0,04 s

Gibt die Antwort an STDOUT mit führenden Nullen aus.

-3 Byte dank Deckenkatze

m,j;f(n,k)long n;{char*t,s[17];for(t=s+sprintf(s,"%016ld",++n),m=n=0;m<k&--t>s;m<k&&*t-53?n=*t>53,*t=53:0)for(*t+=n,m=j=17;j--;)m-=s[j]!=53;puts(s);}

Probieren Sie es online aus!