Einführung

Diese Herausforderung besteht darin, die größte Zahl zu finden, wobei y Ziffern von der ursprünglichen Zahl n mit x Ziffern entfernt werden.

Angenommen y=2 n=5263 x=4, die möglichen Zahlen, die y = 2 Ziffern entfernen, sind:

[52, 56, 53, 26, 23, 63]

Die größte Zahl 63muss also für dieses Beispiel ausgegeben werden.

Eine andere Logik wäre: Suchen Sie für jedes y von links nach rechts nach der Ziffer, deren nächste Ziffer größer ist, und entfernen Sie sie, andernfalls, wenn keine Übereinstimmung vorliegt, die letzten y-Ziffern .

Mit y=3 n=76751432 x=8erklären:

y=3
76751432
-^------ remove 6 because right next 7 is greater

y=2
7751432
---^--- remove 1 because right next 4 is greater

y=1
775432
-----^ the search failed, then remove last y digits

result = 77543

Beide oben erläuterten Methoden funktionieren. Natürlich können Sie auch eine andere Methode verwenden :)

Herausforderung

Die Zahl n darf nicht mehr als 8 Stellen haben, und y ist immer größer als Null und kleiner als x .

Um ein striktes Eingabeformat zu vermeiden, können Sie die Werte y n xwie gewünscht als Parameter in Funktion, Roheingabe oder auf eine andere gültige Weise verwenden. Vergiss nur nicht zu sagen, wie du das in deiner Antwort getan hast.

Die Ausgabe sollte die Ergebnisnummer sein.

Dies ist Code-Golf , die kürzeste Antwort in Bytes gewinnt.

Beispiel für Ein- und Ausgabe

Nochmals: Sie müssen nicht zu streng sein :)

4 1789823 7 -> 983
1 54132 5   -> 5432
3 69314 5   -> 94
2 51794 5   -> 794

Bearbeiten

Ich habe die Eingabereihenfolge geändert, um der Tatsache Rechnung zu tragen, dass einige von Ihnen den x- Wert möglicherweise nicht benötigen , um das Problem zu lösen. x ist jetzt ein optionaler Wert.

A-Ray , 9 7 Bytes

Meine neue Sprache! Laut Meta ist dies erlaubt, aber wenn dies nicht akzeptiert wird, werde ich es entfernen.

pM:i-II

Erläuterung:

  :i-II       Gets all permutations possible for the given number converted to an array,
                      with the length of y-x, which is the -II part
 M            Gets the maximum of the result above
p             Prints the resulting array above, with no separators

Beispieleingabe (Zahl, x, y):

1736413 7 4

Ausgabe:

764

Sie können dies mit der .jar-Datei testen, die im Github-Link angegeben ist.

MATL , 10 Bytes

-jowXncUX>

Dies verwendet die Version (9.2.1) der Sprache / des Compilers, die älter als diese Herausforderung ist.

Es werden drei Eingaben von stdin in dieser Reihenfolge benötigt: Stringlänge, Anzahl der entfernten Zeichen, String.

Beispiel

>> matl
 > -jowXncUX>
 > 
> 7
> 4
> 1789823
983

EDIT : Probieren Sie es online! (der Code in der Verbindung hat XNstatt Xnauf Veränderungen in der Sprache nach dieser Herausforderung zu entsprechen, auch, owird nicht mehr benötigt)

Erläuterung

(Dies kostet immer noch 2 Byte mehr, als es sollte, da sich die nchoosekFunktionen von Octave und Matlab unterschiedlich verhalten. In der nächsten Version des Compilers behoben.)

-        % implicitly input two numbers, and subtract them
jo       % input string, and convert to ASCII codes
wXn      % swap inputs. Generate all combinations, each in a row
c        % convert to char array
U        % convert each row to a number
X>       % get maximum. Implicitly display

Antwort auf die ursprüngliche Aufforderung (strengere Eingabeanforderungen): 16 Byte

jYbZ)b-wowXncUX>

Verwendet die aktuelle Version (9.2.1) der Sprache / des Compilers.

Beispiel

>> matl jYbZ)b-wowXncUX>
> 4 1789823 7
983

Erläuterung

(Das hätte 4 Bytes weniger sein sollen, aber ich brauche das, wow...cweil die nchoosekFunktion von Octave im Gegensatz zu Matlab nicht mit der Zeicheneingabe funktioniert. Wird für die nächste Version des Compilers behoben.)

j              % input string
YbZ)           % split at spaces into strings
b-             % subtract first and third (1-digit) strings
wow            % convert middle string into ASCII codes
Xn             % get all combinations, each in a row
c              % convert to char array
U              % convert each row to a number
X>             % get maximum. Implicitly display

Pyth - 11 9 8 Bytes

eS.cz-QE

Test Suite .

Japt, 19 Bytes

Vs ¬àW-U m¬mn n!- g

Probieren Sie es online!

Wie es funktioniert

        // Implicit: U = y, V = n, W = x
Vs ¬    // Convert V into a string, then split into an array of chars.
àW-U    // Generate all combinations of length W-U.
m¬mn    // Join each pair back into a string, then convert each string to a number.
n!-     // Sort by backwards subtraction (b-a instead of a-b; highest move to the front).
g       // Get the first item in this list.
        // Implicit: output last expression

Brachylog , 30 Bytes

,{,[N:Y].hs?lL,Nl-Y=L}?:1forh.

Da OP die Randbedingungen für IO gelockert hat, erwartet dies [Number, NumberOfDigitsRemoved]als Eingabe und gibt die Antwort als Ausgabe zurück, z brachylog_main([1789823,4], Z)..

Erläuterung

,{                   }?:1f     § Declare sub-predicate 1 and find all inputs which satisfy
                               § this sub-predicate with output = Input of the main predicate
                               § (i.e. [Number, Number of digits to remove])

                               § -- Sub-predicate 1 --
  ,[N:Y].                      § Output = [N, Y]
         hs?                   § Input = a subset of N
            lL,Nl-Y=L          § Length of Input = Length of N - Y

                          orh. § Order the list of answers, reverse it an return the first
                               § element (i.e. the biggest number of the list)

Python 3, 69 Bytes

Dies definiert eine anonyme Funktion, die alle drei Argumente akzeptiert. Unter voller Ausnutzung der Regel , dass „Sie die Werte verwenden können: y n xso , wie Sie es vorziehen“, habe ich zu akzeptieren , ausgewählt yund xals ganze Zahlen und nals String zurück . Der Rückgabewert ist eine Zeichenfolge.

from itertools import*
lambda y,n,x:''.join(max(combinations(n,x-y)))

Nur für den Fall, dass jemand der Meinung ist, dass dies die Regeln zu weit ausdehnt, nimmt diese Version alle Eingaben als ganze Zahlen und ist 74 Bytes groß.

from itertools import*
lambda y,n,x:''.join(max(combinations(str(n),x-y)))

Und gerade für Tritte, ich schrieb auch ein zweiargumentigen Version unter yund nüber die Befehlszeile und Druck das Ergebnis STDOUT. Es sind 92 Bytes.

import sys,itertools as i
_,y,n=sys.argv
print(*max(i.combinations(n,len(n)-int(y))),sep='')

ES6, 70 Bytes

r=(y,n)=>y?r(y-1,Math.max(...`${n}`.replace(/./g," $`$'").split` `)):n

Gibt ein numerisches Ergebnis zurück, es ysei denn, es ist falsch und neine Zeichenfolge. Ich habe mich selbst davon überzeugt, dass es immer noch funktioniert, die Rekursion in der falschen Richtung durchzuführen (meine Lösung ist nicht anwendbar, um die korrekte Rekursion durchzuführen).

Auch mein erster Code Golf, bei dem ich alle drei Anführungszeichen (wenn auch nicht alle als Anführungszeichen) verwende, was mich daran hinderte, die Länge trivial zu berechnen.

Julia, 128 95 Bytes

f(y,n,x)=maximum(i->parse(join(i)),filter(k->endof(k)==x-y,reduce(vcat,partitions(["$n"...]))))

Dies ist eine Funktion, die die drei Werte als Parameter akzeptiert und eine Ganzzahl zurückgibt.

Ungolfed:

function f{T<:Integer}(y::T, n::T, x::T)
    # Get all ordered partitions of the digits of n
    p = reduce(vcat, partitions(["$n"...]))

    # Filter to groups of size x-y
    g = filter(k -> endof(k) == x - y, p)

    # Get the maximum resulting number
    return maximum(i -> parse(join(i)), g)
end

Haskell, 64 Bytes

import Data.List
y#x=maximum.filter((==x-y).length).subsequences

Anwendungsbeispiel: (4#7)"1789823"-> "983".

Die ursprüngliche Nummer nwird als Zeichenfolge verwendet. (Ich bin mir nicht sicher, ob ich die Regel "Kein strenges Eingabeformat" überstrapaziert habe, aber in der ersten Version war eine Zeichenfolgeeingabe (!) Erforderlich.)

So funktioniert es: Erstellen Sie eine Liste aller Folgen von n, behalten Sie die Länge bei x-yund wählen Sie das Maximum aus.

Ruby, 40 Bytes

->y,n,x{n.chars.combination(x-y).max*''}

Dies ist eine anonyme Funktion , die nimmt yund xals ganze Zahlen und nals String und gibt einen String zurück. Sie können es zum Beispiel so nennen

->y,n,x{n.chars.combination(x-y).max*''}[2,"5263",4]

und es wird zurückkehren "63".

MATLAB 40 Bytes

@(n,y)max(str2num(nchoosek(n,nnz(n)-y)))

Prüfung:

ans('76751432',3)
ans = 77543

Pyth, 45 Bytes

=cz)Fk.P@z1-l@z1v@z0I:@z1j".*"k1I>vkZ=Zvk)))Z

versuche es hier

JavaScript (ES6), 78

Eine rekursive Funktion mit 2 Argumenten y und d. ykann eine Zahl oder eine Zeichenfolge sein, dmuss eine Zeichenfolge sein.

r=(y,d)=>y?Math.max(...[...d].map((x,i)=>r(y-1,d.slice(0,i)+d.slice(i+1)))):+d

Bevor sich die Herausforderung änderte, waren es 107 - ... mit allen Ein- / Ausgabesonderheiten ...

x=>(r=(n,d)=>n?Math.max(...[...d].map((x,i)=> r(n-1,d.slice(0,i)+d.slice(i+1)))):+d)(...x.match(/\d+/g))+'\n'

Prüfung

r=(y,d)=>y?Math.max(...[...d].map((x,i)=>r(y-1,d.slice(0,i)+d.slice(i+1)))):+d

function test() {
  [a,b]=I.value.match(/\d+/g)
  O.textContent=r(a,b)
}

test()

y,n: <input id=I value='4 1789823' oninput="test()">
<pre id=O></pre>