introduction

Ce défi consiste à trouver le plus grand nombre en supprimant y chiffres du numéro d'origine n qui a x chiffres.

En supposant que y=2 n=5263 x=4les nombres possibles supprimant y = 2 chiffres sont:

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

Ainsi, le plus grand nombre est celui 63qui doit être la sortie de cet exemple.

Une autre logique serait: pour chaque y, recherchez de gauche à droite le chiffre qui est le chiffre suivant droit, puis supprimez-le, sinon en cas de non-correspondance, supprimez les derniers chiffres y .

Utiliser y=3 n=76751432 x=8pour expliquer:

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

Les deux méthodes expliquées ci-dessus fonctionnent .. bien sûr, vous pouvez également utiliser une autre méthode :)

Défi

Le nombre n ne comportera pas plus de 8 chiffres, et y sera toujours supérieur à zéro et inférieur à x .

Pour éviter un format d'entrée strict, vous pouvez utiliser les valeurs: y n xcomme vous préférez: comme paramètres dans la fonction, entrée brute ou tout autre moyen valide. N'oubliez pas de dire comment vous avez fait cela dans votre réponse.

La sortie doit être le numéro de résultat.

C'est le code-golf , la réponse la plus courte en octets l'emporte.

Exemple d'entrée et de sortie

Encore une fois: vous n'avez pas besoin d'être trop strict :)

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

modifier

J'ai modifié l'ordre d'entrée pour refléter le fait que certains d'entre vous n'ont peut-être pas besoin de la valeur x pour résoudre le problème. x est désormais une valeur facultative.

A-Ray , 9 7 octets

Ma nouvelle langue! Selon la méta, cela est autorisé, mais si cela n'est pas accepté, je le supprimerai.

pM:i-II

Explication:

  :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

Exemple d'entrée (nombre, x, y):

1736413 7 4

Sortie:

764

Vous pouvez tester cela avec le fichier .jar fourni dans le lien github.

MATL , 10 octets

-jowXncUX>

Cela utilise la version (9.2.1) du langage / compilateur, qui est antérieure à ce défi.

Il prend trois entrées de stdin dans cet ordre: longueur de chaîne, nombre de caractères supprimés, chaîne.

Exemple

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

EDIT : Essayez-le en ligne! (le code dans le lien doit XNau lieu de Xnse conformer aux changements de langue après ce défi; aussi, on'est plus nécessaire)

Explication

(Cela coûte toujours 2 octets de plus qu'il ne devrait en raison du nchoosekcomportement différent des fonctions d'Octave et de Matlab . Corrigé dans la prochaine version du compilateur.)

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

Réponse au défi d'origine (exigences d'entrée plus strictes): 16 octets

jYbZ)b-wowXncUX>

Utilise la version actuelle (9.2.1) du langage / compilateur.

Exemple

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

Explication

(Cela aurait dû être 4 octets de moins, mais j'en ai besoin wow...cparce que la nchoosekfonction d'Octave , contrairement à Matlab, ne fonctionne pas avec la saisie de caractères. Sera corrigé pour la prochaine version du compilateur.)

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 octets

eS.cz-QE

Suite de tests .

Japt, 19 octets

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

Essayez-le en ligne!

Comment ça marche

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

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

Depuis OP a assoupli les contraintes sur IO, cela attend [Number, NumberOfDigitsRemoved]en entrée et renvoie la réponse en sortie, par exemple brachylog_main([1789823,4], Z)..

Explication

,{                   }?: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 octets

Cela définit une fonction anonyme acceptant les trois arguments. Profitant pleinement de la règle selon laquelle "vous pouvez utiliser les valeurs: y n xcomme vous préférez", j'ai choisi d'accepter yet en xtant qu'entiers et en ntant que chaîne. La valeur de retour est une chaîne.

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

Juste au cas où quelqu'un sentirait que cela étire trop les règles, cette version prend toutes les entrées sous forme d'entiers et fait 74 octets.

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

Et juste pour les coups de pied, j'ai également écrit une version à deux arguments, en prenant yet à npartir de la ligne de commande et en imprimant le résultat dans STDOUT. C'est 92 octets.

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

ES6, 70 octets

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

Renvoie un résultat numérique à moins qu'il ne ysoit faux et nsoit une chaîne. Je me suis convaincu que faire la récursion à l'envers fonctionne toujours (ma solution ne s'applique pas à faire la récursivité correcte).

Aussi mon premier code de golf où j'utilise les trois guillemets (mais pas tous comme guillemets), ce qui m'a empêché de calculer trivialement la longueur.

Julia, 128 95 octets

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

Il s'agit d'une fonction qui accepte les trois valeurs comme paramètres et renvoie un entier.

Non golfé:

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 octets

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

Exemple d'utilisation: (4#7)"1789823"->"983" .

Le numéro d'origine n est pris sous forme de chaîne. (Je ne sais pas si je surestime la règle "pas de format d'entrée strict", mais une entrée de chaîne était requise (!) Dans la première version).

Comment ça marche: faites une liste de toutes les sous-séquences de n, conservez-les avec la longueur x-yet choisissez le maximum.

Rubis, 40 octets

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

Il s'agit d'une fonction anonyme qui prend yet xsous forme d'entiers et nde chaîne, et renvoie une chaîne. Vous pouvez l'appeler par exemple comme ceci

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

et il reviendra "63".

MATLAB 40 octets

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

Tester:

ans('76751432',3)
ans = 77543

Pyth, 45 octets

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

essayez-le ici

JavaScript (ES6), 78

Une fonction récursive avec 2 arguments y et d. ypeut être numérique ou chaîne, ddoit être une chaîne.

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

Avant que le défi ne change, il était de 107 - ... avec toutes les bizarreries d'entrée / sortie ...

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'

Tester

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>