Inspirado por este post sobre Puzzling. Spoilers para esse quebra-cabeça estão abaixo.

Dado três números inteiros positivos como entrada, (x, y, z)construa o intervalo inclusivo [x, y], concatene esse intervalo e remova zdígitos não necessariamente consecutivos para produzir o maior e o menor número inteiro positivo possível. Zeros à esquerda não são permitidos (ou seja, os números devem começar com [1-9]). Saída esses dois números em qualquer ordem.

Para o exemplo do post Puzzling, para entrada (1, 100, 100), o maior número possível é 99999785960616263646566676869707172737475767778798081828384858687888990919293949596979899100,
e o menor número é 10000012340616263646566676869707172737475767778798081828384858687888990919293949596979899100,
seguindo a lógica abaixo da resposta da jafe publicada lá:

• Não podemos influenciar o comprimento do número (há um número fixo de dígitos); portanto, para maximizar o valor, usamos o primeiro dígito máximo, depois o segundo dígito etc.
• Remova os 84 primeiros não-noves (16 dígitos restantes para remover): 999995051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
• O maior número dentro dos próximos 17 dígitos é 7, portanto, a partir daqui, o próximo dígito na resposta pode ter no máximo 7 (não podemos remover mais de 16 dígitos). Portanto, remova 15 não-7's ... (1 dígito para remover):999997585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
• A partir daqui, o próximo dígito pode ter no máximo 8, então remova um não-8 do meio: 99999785960616263646566676869707172737475767778798081828384858687888990919293949596979899100
• Lógica semelhante, mas invertida (ou seja, queremos líderes 1s em vez de líderes 9s) para o menor número.

Aqui está um exemplo menor: (1, 10, 5).

Construímos o intervalo 12345678910e determinamos quais 5dígitos podemos remover, deixando o maior número possível. Obviamente, isso significa que queremos maximizar o dígito inicial, pois não podemos influenciar o comprimento da saída. Então, se removermos 12345, ficamos com 678910, e é o maior que podemos fazer. Tornar o menor é um pouco mais complicado, pois podemos extrair números do meio, deixando 123410o menor possível.

Pois (20, 25, 11), o resultado é bastante chato, como 5e 1.

Finalmente, descartar respostas que tentam zeros à esquerda, (9, 11, 3)fornece as 91011que, por sua vez, produzem 91e 10são as maiores e as menores.

E / S e regras

• Se for mais fácil / mais curto, você pode codificar dois programas / funções - um para o maior e outro para o menor -, nesse caso, sua pontuação é a soma das duas partes.
• A entrada e saída podem ser fornecidas por qualquer método conveniente .
• Pode-se presumir que a entrada se encaixa no tipo de número nativo do seu idioma, no entanto , nem o número concatenado nem a saída podem ser assumidos para isso.
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Haskell , 162 bytes

l=length
((m,f)%n)s|n>=l s=[]|n>0,(p,c:r)<-span(/=m(f$take(n+1)s))s=c:((m,id)%(n-l p)$r)|1>0=s
(x#y)z=[p%z$show=<<[x..y]|p<-[(maximum,id),(minimum,filter(>'0'))]]

Experimente online!

Usa o algoritmo descrito por jafe. Pode ser mais curto para usar um método menos eficiente, mas isso foi mais divertido de escrever :)

A %operação recebe 4 argumentos (na verdade 3, mas o que for): mqual é uma função que seleciona o membro "ideal" de uma lista ( maximumou minimumdependendo do que queremos); fque é uma função de "filtro"; no número de dígitos restantes para serem descartados; e sa corda. Primeiro, verificamos se n é igual ao número de dígitos restantes na string (usei >=por segurança) e eliminamos o restante s. Caso contrário, verificamos se ainda precisamos soltar dígitos ( n>0) e, em seguida, spandividimos nossa string em três partes: pos dígitos a serem soltos, co dígito alcançável ideal era sequência restante. Fazemos isso passando um predicado que verifica a igualdade em relação ao nosso dígito ideal. Para encontrar esse dígito, pegamos os primeiros n+1dígitos da string, filtramos e passamos para nossa função "seletor". Agora, apenas produzimos nosso dígito ideal e recorremos, subtraindo o comprimento de p(o número de dígitos descartados) de n. Observe que não passamos nossa função de filtragem para a chamada recursiva e, em vez disso, a substituímos por id. Isso ocorre porque o filtro existe apenas para evitar a seleção de 0s iniciais no minimumcaso, o que é relevante apenas na primeira iteração. Depois disso, não precisamos mais de nenhum filtro.

%é realmente apenas uma função auxiliar para #que é nossa função "real", tendo x, ye z. Usamos uma compreensão de lista apenas para evitar um pouco de repetição, repetindo as tuplas de função e passando-as para %junto com za string concatenada. Essa string é criada usando o operador magic monad (=<<)que, nesse contexto, funciona como concatMap.

Gelatina , 17 bytes

r/VDœcL_¥¥ḷ/ƇVṢ.ị

Experimente online!

Calcula todas as possibilidades e mantém a maior e a menor.

Argumento x,yà esquerda: para construir o intervalo. Argumento correto: zdígitos a serem removidos.

r/VDœcL_¥¥ḷ/ƇVṢ.ị
r/                 Inclusive range from x to y
  V                Concatenate the digits together
   D               Get the resulting digits
         ¥         Dyad:
        ¥            Dyad:
      L                Length of the list of digits in the concatenated number.
       _               Subtract the number of digits to be removed.
    œc               Combinations without replacement. (remove z digits)
            Ƈ      Keep lists of digits that:
          ḷ/       have a positive first element (no leading zeros).
             V     Combine digits into integers. (vectorizes to ldepth 1)
              Ṣ    Sort the numbers
               .ị  Indexes at value 0.5 which yields the first and last elements.

Python 2 , 143 bytes

import itertools
s,e,r=input()
l=''.join(map(str,range(s,e+1)))
L=[i for i in itertools.combinations(l,len(l)-r)if'0'<i[0]]
print min(L),max(L)

Experimente online!

Isso funciona calculando todas as combinações do tamanho do destino (a ordem dos elementos é preservada) e obtendo os menores / maiores números

Carvão , 56 bytes ou 21 + 46 35 = 67 56 bytes

≔⪫…·ＮＮωθＦＮ≔⌈ＥθΦθ⁻λνθθ

Experimente online! Link é a versão detalhada do código. Explicação:

≔⪫…·ＮＮωθ

Insira xe y, crie um intervalo inclusivo e junte os números em uma sequência.

ＦＮ

Faça um loop uma vez para cada dígito a ser removido.

≔⌈ＥθΦθ⁻λνθ

Crie uma lista de cadeias formadas removendo cada caractere possível da cadeia atual e use o máximo.

θ

Imprima o resultado.

≔⪫…·ＮＮωθＦ⊕Ｎ⊞υωΦθ∧⁼ι⌊Φ✂θκＬυ¹∨κＩλ⊞Ｏυω

Experimente online! Link é a versão detalhada do código. Explicação:

≔⪫…·ＮＮωθ

Insira xe y, crie um intervalo inclusivo e junte os números em uma sequência.

Ｆ⊕Ｎ⊞υω

Insira ze aumente. Em seguida, crio uma lista com esse comprimento: preciso incrementar zo filtro a seguir, mas apenas os comandos têm permissão para incrementar variáveis; existe uma brecha que PushOperatoraumenta o comprimento da lista.

 θ                      String of digits
Φ                       Filter over characters
         κ              Current index
          Ｌυ            Length of list i.e. current `z` value
            ¹           Literal 1
       ✂θ               Slice string of digits
      Φ                 Filter over characters
              κ         Outer index
               Ｉλ       Cast inner character to number
             ∨          Logical OR
     ⌊                  Minimum
   ⁼ι                   Equals the outer character
  ∧              ⊞Ｏυω   And also push to list i.e. increment `z`
                        Implicitly print

Filtre os caracteres desejados, verificando se não há caracteres inferiores na região cortável. A região começa com os primeiros z+1caracteres (já que é possível dividir os primeiros z, se necessário) e o ponto final é incrementado para cada caractere mantido. É tomado cuidado para não escolher um zero para o primeiro caractere.

O algoritmo mais rápido tem 30 bytes quando usado para calcular o maior número possível:

≔⪫…·ＮＮωθＦ⊕Ｎ⊞υωΦθ∧⁼ι⌈✂θκＬυ¹⊞Ｏυω

Experimente online! Link é a versão detalhada do código. Edit: desde então, consegui combinar os dois acima em uma segunda solução de 56 bytes, que gera os dois resultados:

≔⪫…·ＮＮωθＦ⊕Ｎ⊞υω≔⮌υη⟦Φθ∧⁼ι⌈✂θκＬυ¹⊞ＯυωΦθ∧⁼ι⌊Φ✂θκＬη¹∨κＩλ⊞Ｏηω

Experimente online! Link é a versão detalhada do código. Explicação:

≔⪫…·ＮＮωθ

Gere a sequência inicial.

Ｆ⊕Ｎ⊞υω

Representar z+1como o comprimento da lista.

≔⮌υη

Inverta a lista, clonando-a e salve o resultado.

⟦

Imprima os dois resultados em linhas separadas. (Outra maneira de fazer isso é separar os resultados com um \rcaractere literal .)

Φθ∧⁼ι⌈✂θκＬυ¹⊞Ｏυω

Gere o maior número possível.

Φθ∧⁼ι⌊Φ✂θκＬη¹∨κＩλ⊞Ｏηω

Gere o menor número possível usando a lista clonada para acompanhar z.

Geléia ,  19  18 bytes

rDẎœcL_⁵Ɗ$ị@Ƈ1ḌṢ.ị

Experimente online!

1, 100, 100$\binom{192}{92}=305812874887035355118559193163641366325011573739619723360$

05AB1E , 16 bytes

ŸSDg³-.Æʒ¬Ā}{Ć`‚

Experimente online!

Programa completo, lendo as entradas nesta ordem: y, x, z . Produz uma lista de duas listas de caracteres.

Explicação

ŸSDg³-.Æʒ¬Ā}{Ć`‚    Full program. Inputs: y, x, z.
Ÿ                   Inclusive binary range from x to y. Push [x ... y].
 S                  Dump the digits separately in a list.
  Dg                Duplicate, and use the second copy to get its length.
    ³-              Subtract z from the length.
      .Æ            Retrieve all combinations of length - z elements from the digits.
        ʒ  }        Keep only those that...
         ¬Ā         Don't start with a 0 (head, then Python-style boolean).
            {       Sort the remaining elements.
             Ć      Enclose. Pushes list + list[0] (appends its tail to itself)
              `     Dump all elements separately on the stack.
               ,    Pair, to get the last two, min and max (after enclosing)

Matlab, 95 bytes

function[m]=f(s,e,c),a=sprintf('%d',s:e);x=str2num(combnk(a,length(a)-c));m=[min(x),max(x)];end

Experimente Online!

Retorna uma matriz 1x2 com min e max.

Como funciona

% Full code
function[m]=f(s,e,c),a=sprintf('%d',s:e);x=str2num(combnk(a,length(a)-c));m=[min(x),max(x)];end

% The function
function[m]=f(s,e,c),                                                                       end

                     % Creates the range in a single string
                     a=sprintf('%d',s:e);

                                                   % Gets all the combinations
                                                   combnk(a,length(a)-c)

                                         % Converts the string combinations to integers
                                         x=str2num(                     );

                                                                          % Finds min and max
                                                                          m=[min(x),max(x)];