Introducción

Este desafío consiste en encontrar el mayor número eliminando dígitos y del número original n que tiene x dígitos.

Suponiendo que y=2 n=5263 x=4los números posibles que eliminan y = 2 dígitos son:

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

Entonces, el mayor número es el 63que debe ser la salida para este ejemplo.

Otra lógica sería: para cada y, busque de izquierda a derecha el dígito que el siguiente dígito derecho es mayor, luego elimínelo, de lo contrario, cuando no coincida, elimine los últimos dígitos y .

Usando y=3 n=76751432 x=8para explicar:

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

Ambos métodos explicados anteriormente funcionan ... por supuesto, también puedes usar otro método :)

Reto

El número n no tendrá más de 8 dígitos, y y siempre será mayor que cero y menor que x .

Para evitar un formato de entrada estricto, puede usar los valores: y n xla forma que prefiera: como parámetros en función, entrada sin formato o cualquier otra forma válida. Simplemente no olvides decir cómo lo hiciste en tu respuesta.

La salida debe ser el número del resultado.

Este es el código de golf , gana la respuesta más corta en bytes.

Ejemplo de entrada y salida

Nuevamente: no necesitas ser demasiado estricto :)

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

Editar

Cambié el orden de entrada para reflejar el hecho de que algunos de ustedes pueden no necesitar el valor x para resolver el problema. x es ahora un valor opcional.

Rayos A , 9 7 bytes

Mi nuevo idioma! Según el meta, esto está permitido, pero si no se acepta, lo eliminaré.

pM:i-II

Explicación:

  :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

Entrada de ejemplo (número, x, y):

1736413 7 4

Salida:

764

Puede probar esto con el archivo .jar proporcionado en el enlace de github.

MATL , 10 bytes

-jowXncUX>

Utiliza la versión (9.2.1) del lenguaje / compilador, que es anterior a este desafío.

Toma tres entradas de stdin en este orden: longitud de cadena, número de caracteres eliminados, cadena.

Ejemplo

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

EDITAR : ¡ Pruébelo en línea! (el código en el enlace tiene XNlugar de Xnajustarse a los cambios en el idioma después de este desafío; también, oya no es necesario)

Explicación

(Esto todavía cuesta 2 bytes más de lo que debería debido a que la función de Octave y Matlab se nchoosekcomporta de manera diferente. Se corrigió en la próxima versión del compilador).

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

Respuesta al desafío original (requisitos de entrada más estrictos): 16 bytes

jYbZ)b-wowXncUX>

Utiliza la versión actual (9.2.1) del idioma / compilador.

Ejemplo

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

Explicación

(Esto debería haber sido 4 bytes menos, pero lo necesito wow...cporque la nchoosekfunción de Octave , a diferencia de la de Matlab, no funciona con la entrada de caracteres. Se solucionará para la próxima versión del compilador).

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

Pruébalo en línea!

Cómo funciona

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

Dado que OP ha relajado las restricciones sobre IO, esto espera [Number, NumberOfDigitsRemoved]como entrada y devuelve la respuesta como salida, por ejemplo brachylog_main([1789823,4], Z)..

Explicación

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

Esto define una función anónima que acepta los tres argumentos. Aprovechando al máximo la regla de que "puede usar los valores: y n xla forma que prefiera", he elegido aceptar yy xcomo enteros y ncomo una cadena. El valor de retorno es una cadena.

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

En caso de que alguien sienta que esto está estirando demasiado las reglas, esta versión toma todas las entradas como enteros y tiene 74 bytes.

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

Y solo por diversión, también escribí una versión de dos argumentos, tomando yy ndesde la línea de comandos e imprimiendo el resultado en STDOUT. Son 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

Devuelve un resultado numérico a menos que ysea ​​falso y nsea ​​una cadena. Me he convencido de que hacer la recursión al revés sigue funcionando (mi solución no es aplicable para hacer la recursión correcta).

También mi primer código de golf donde uso los tres signos de comillas (aunque no todos como comillas), lo que me impidió calcular trivialmente la longitud.

Julia, 128 95 bytes

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

Esta es una función que acepta los tres valores como parámetros y devuelve un entero.

Sin 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 bytes

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

Ejemplo de uso: (4#7)"1789823"-> "983".

El número original nse toma como una cadena. (No estoy seguro de si estoy haciendo demasiado hincapié en la regla "sin formato de entrada estricto", pero se requirió la entrada de cadena (!) En la primera versión).

Cómo funciona: haga una lista de todas las subsecuencias de n, mantenga aquellas con longitud x-yy elija el máximo.

Rubí, 40 bytes.

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

Esta es una función anónima que toma yy xcomo enteros y ncomo una cadena, y devuelve una cadena. Puedes llamarlo por ejemplo así

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

y volverá "63".

MATLAB 40 bytes

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

Prueba:

ans('76751432',3)
ans = 77543

Pyth, 45 bytes

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

pruébalo aquí

JavaScript (ES6), 78

Una función recursiva con 2 argumentos y y d. ypuede ser numérico o cadena, ddebe ser una cadena.

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

Antes de que el desafío cambiara, era 107 - ... con todas las rarezas de entrada / salida ...

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'

Prueba

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>