Introdução

Esse desafio consiste em encontrar o maior número removendo dígitos y do número original n que possui x dígitos.

Assumindo y=2 n=5263 x=4, os possíveis números que removem y = 2 dígitos são:

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

Portanto, o maior número é 63qual deve ser a saída para este exemplo.

Outra lógica seria: para cada y, pesquise da esquerda para a direita o dígito que é o próximo dígito maior e remova-o; caso contrário, remova os ú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 os métodos explicados acima funcionam .. é claro, você também pode usar outro método :)

Desafio

O número n não terá mais de 8 dígitos e y sempre será maior que zero e menor que x .

Para evitar um formato estrito de entrada, você pode usar os valores: y n xda maneira que preferir: como parâmetros em função, entrada bruta ou qualquer outra maneira válida. Só não se esqueça de dizer como você fez isso na sua resposta.

A saída deve ser o número do resultado.

Isso é código-golfe , a resposta mais curta em bytes vence.

Exemplo de entrada e saída

Novamente: você não precisa ser muito rigoroso :)

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

Editar

Alterei a ordem de entrada para refletir o fato de que alguns de vocês podem não precisar do valor x para resolver o problema. x agora é um valor opcional.

A-Ray , 9 7 bytes

Minha nova lingua! Segundo a meta, isso é permitido, mas se isso não for aceito, eu o removerei.

pM:i-II

Explicação:

  :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

Exemplo de entrada (número, x, y):

1736413 7 4

Saída:

764

Você pode testar isso com o arquivo .jar fornecido no link do github.

MATL , 10 bytes

-jowXncUX>

Isso usa versão (9.2.1) do idioma / compilador, anterior a esse desafio.

São necessárias três entradas do stdin nesta ordem: comprimento da string, número de caracteres removidos, string.

Exemplo

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

EDIT : Experimente online! (o código no link tem XN, em vez de Xnse conformar com as mudanças no idioma após este desafio, também,o não é mais necessário)

Explicação

(Isso ainda custa 2 bytes a mais do que deveria devido à função de Octave e Matlab nchoosekse comportando de maneira diferente. Corrigido na próxima versão do 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

Resposta ao desafio original (requisitos de entrada mais rigorosos): 16 bytes

jYbZ)b-wowXncUX>

Usa a versão atual (9.2.1) do idioma / compilador.

Exemplo

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

Explicação

(Isso deveria ter sido 4 bytes a menos, mas eu preciso disso wow...cporque a nchoosekfunção do Octave , ao contrário do Matlab, não funciona com a entrada de caracteres. Será corrigida para a próxima versão do 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

Pitão - 11 9 8 bytes

eS.cz-QE

Conjunto de Teste .

Japonês, 19 bytes

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

Experimente online!

Como 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

Braquilog , 30 bytes

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

Como o OP diminuiu as restrições de IO, isso espera [Number, NumberOfDigitsRemoved]como entrada e retorna a resposta como saída, por exemplo brachylog_main([1789823,4], Z)..

Explicação

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

Isso define uma função anônima que aceita todos os três argumentos. Aproveitando ao máximo a regra de que "você pode usar os valores: y n xda maneira que preferir", escolhi aceitar ye xcomo números inteiros e ncomo uma string. O valor de retorno é uma sequência.

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

Caso alguém ache que isso está estendendo as regras muito longe, esta versão aceita todas as entradas como números inteiros e tem 74 bytes.

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

E só para começar, também escrevi uma versão de dois argumentos, pegando ye nna linha de comando e imprimindo o resultado em STDOUT. São 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

Retorna um resultado numérico, a menos que yseja falso en seja uma sequência. Eu me convenci de que fazer a recursão da maneira errada ainda funciona (minha solução não é aplicável a fazer a recursão correta).

Também meu primeiro código de golfe, onde eu uso todos os três sinais de aspas (embora nem todos como aspas), o que me impediu de calcular trivialmente o comprimento.

Julia, 128 95 bytes

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

Esta é uma função que aceita os três valores como parâmetros e retorna um número inteiro.

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

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

O número original n é usado como uma string. (Não tenho certeza se estou sobrecarregando a regra "nenhum formato de entrada estrita", mas a entrada de string foi necessária (!) Na primeira versão).

Como funciona: faça uma lista de todas as subsequências de n, mantenha aquelas com comprimento x-ye escolha o máximo.

Ruby, 40 bytes

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

Esta é uma função anônima que usa ye xcomo números inteiros e ncomo uma string, e retorna uma string. Você pode chamá-lo, por exemplo, como este

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

e ele retornará "63".

MATLAB 40 bytes

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

Teste:

ans('76751432',3)
ans = 77543

Pitão, 45 bytes

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

tente aqui

JavaScript (ES6), 78

Uma função recursiva com 2 argumentos ye ed. ypode ser numérico ou sequência, ddeve ser uma sequência.

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

Antes que o desafio mudasse, era 107 - ... com todas as esquisitices de entrada / saída ...

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'

Teste

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>