Ispirato da questo post su Puzzling. Gli spoiler per quel puzzle sono qui sotto.

Dati tre interi positivi come input, (x, y, z)costruisci l'intervallo inclusivo [x, y], concatena quell'intervallo insieme, quindi rimuovi zle cifre non necessariamente consecutive per produrre gli interi positivi più grandi e più piccoli possibili. Gli zeri iniziali non sono consentiti (ovvero, i numeri devono iniziare con [1-9]). Emetti quei due numeri in entrambi gli ordini.

Per l'esempio dal posto imbarazzo, per l'ingresso (1, 100, 100), il maggior numero possibile è 99999785960616263646566676869707172737475767778798081828384858687888990919293949596979899100,
e il numero più piccolo è 10000012340616263646566676869707172737475767778798081828384858687888990919293949596979899100,
seguendo la logica seguito da di jafe risposta PUBBLICATE:

• Non possiamo influenzare la lunghezza del numero (c'è un numero fisso di cifre), quindi per massimizzare il valore prendiamo la prima cifra massima, quindi la seconda cifra ecc.
• Rimuovi le prime 84 non-nove (16 cifre rimaste per rimuovere): 999995051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
• Il numero più grande entro le successive 17 cifre è 7, quindi da qui la cifra successiva nella risposta può essere al massimo 7 (non possiamo rimuovere più di 16 cifre). Quindi rimuovi 15 non-7 ... (1 cifra rimasta per rimuovere):999997585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
• Da qui, la cifra successiva può essere al massimo 8, quindi rimuovi una non-8 dal centro: 99999785960616263646566676869707172737475767778798081828384858687888990919293949596979899100
• Logica simile, ma invertita (vale a dire, desideriamo 1s iniziali anziché iniziali 9s) per il numero più piccolo.

Ecco un esempio più piccolo: (1, 10, 5).

Costruiamo l'intervallo 12345678910e determiniamo quali 5cifre possiamo rimuovere lasciando il numero più grande possibile. Ovviamente, ciò significa che vogliamo massimizzare la cifra iniziale, poiché non possiamo influenzare la lunghezza dell'output. Quindi, se rimuoviamo 12345, ci rimane 678910, e questo è il più grande che possiamo fare. Rendere il più piccolo è un po 'più complicato, dal momento che possiamo cogliere i numeri dal centro, lasciando 123410il più piccolo possibile.

Perché (20, 25, 11), il risultato è piuttosto noioso, come 5e1 .

Infine, per escludere le risposte che provano a condurre gli zeri, si (9, 11, 3)ottiene 91011che a sua volta produce 91e10 come il più grande e il più piccolo.

I / O e regole

• Se è più facile / più breve, puoi codificare due programmi / funzioni - uno per il più grande e uno per il più piccolo - nel qual caso il tuo punteggio è la somma di entrambe le parti.
• L'input e l'output possono essere forniti con qualsiasi metodo conveniente .
• Si può presumere che l'input si adatti al tipo di numero nativo della tua lingua, tuttavia , né il numero concatenato né l'output possono essere considerati come tali.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Haskell , 162 byte

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'))]]

Provalo online!

Utilizza l'algoritmo descritto da Jafe. Potrebbe essere più breve usare un metodo meno efficiente, ma è stato più divertente scrivere :)

L' %operazione accetta 4 argomenti (in realtà 3, ma qualunque cosa): mche è una funzione che seleziona il membro "ottimale" da un elenco ( maximumo a minimumseconda di ciò che vogliamo); fche è una funzione "filtro"; nil numero di cifre rimaste da rilasciare; e sla stringa. Per prima cosa controlliamo se n è uguale al numero di cifre rimaste nella stringa (ho usato >=per sicurezza) e lasciamo cadere il resto di sse. Altrimenti controlliamo se abbiamo ancora bisogno di rilasciare cifre ( n>0), quindi usiamo spanper spezzare la nostra stringa in tre pezzi: ple cifre da rilasciare, cla cifra ottimale raggiungibile erla stringa rimanente. Lo facciamo passando attraverso un predicato che verifica l'uguaglianza rispetto alla nostra cifra ottimale. Per trovare quella cifra prendiamo le prime caso che è rilevante solo nella prima iterazione. Dopodiché non abbiamo più bisogno di alcun filtro.n+1cifre della stringa, filtrala, quindi passala alla nostra funzione "selettore". Ora restituiamo solo la nostra cifra ottimale e ricorrono, sottraendo la lunghezza di p(il numero di cifre scartate) da n. Si noti che non passiamo la nostra funzione di filtro alla chiamata ricorsiva e, invece, la sostituiamo con id. Questo perché il filtro è lì solo per evitare di selezionare gli 0 iniziali inminimum

%è davvero solo una funzione di supporto per il #quale è la nostra funzione "reale", prendendo x, ye z. Usiamo un elenco di comprensione solo per evitare un po 'di ripetizione, iterare sulle nostre tuple di funzione e di passarli %insieme ze la stringa concatenata. Quella stringa viene creata usando l'operatore della monade magica (=<<)che, in questo contesto, funziona come concatMap.

Gelatina , 17 byte

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

Provalo online!

Calcola tutte le possibilità, quindi mantiene il più grande e il più piccolo.

Argomento sinistro: x,yper costruire l'intervallo. Argomento giusto: zcifre da rimuovere.

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 byte

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)

Provalo online!

Funziona calcolando tutte le combinazioni della dimensione target (l'ordine degli elementi viene conservato) e ricavandone il numero più piccolo / più grande

Carbone , 56 byte o 21 + 46 35 = 67 56 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔⪫…·ＮＮωθ

Immettere xe y, creare un intervallo inclusivo e unire i numeri in una stringa.

ＦＮ

Ripeti una volta per ogni cifra da rimuovere.

≔⌈ＥθΦθ⁻λνθ

Crea un elenco di stringhe formate rimuovendo ogni carattere possibile dalla stringa corrente e prendi il massimo.

θ

Stampa il risultato.

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔⪫…·ＮＮωθ

Immettere xe y, creare un intervallo inclusivo e unire i numeri in una stringa.

Ｆ⊕Ｎ⊞υω

Inseriscilo ze incrementalo. Creo quindi un elenco di quella lunghezza: devo essere in grado di incrementare zall'interno del seguente filtro, ma solo i comandi possono incrementare le variabili; c'è una scappatoia che PushOperatoraumenta la lunghezza dell'elenco.

 θ                      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

Filtra i caratteri desiderati verificando che non vi siano caratteri inferiori nella regione di taglio. La regione inizia con i primi z+1caratteri (poiché è possibile tagliare il primo zse necessario) e gli incrementi del punto finale per ogni carattere che viene mantenuto. Si fa attenzione a non scegliere uno zero per il primo personaggio.

L'algoritmo più veloce è di 30 byte se utilizzato per calcolare il numero più grande possibile:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: da allora sono stato in grado di combinare i due precedenti in una seconda soluzione a 56 byte che genera entrambi i risultati:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔⪫…·ＮＮωθ

Genera la stringa iniziale.

Ｆ⊕Ｎ⊞υω

Rappresenta z+1la lunghezza dell'elenco.

≔⮌υη

Invertire l'elenco in modo da clonarlo e salvare il risultato.

⟦

Stampa i due risultati su righe separate. (Un altro modo per farlo è quello di separare i risultati con un \rcarattere letterale .)

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

Genera il maggior numero possibile.

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

Genera il numero più piccolo possibile usando l'elenco clonato per tenerne traccia z.

Gelatina ,  19  18 byte

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

Provalo online!

Molto inefficiente, sicuramente inutile 1, 100, 100come$\binom{192}{92}=305812874887035355118559193163641366325011573739619723360$

05AB1E , 16 byte

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

Provalo online!

Programma completo, lettura degli ingressi in questo ordine: y, x, z . Emette un elenco di due elenchi di caratteri.

Spiegazione

Ÿ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 byte

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

Provalo online!

Restituisce una matrice 1x2 con min e max.

Come funziona

% 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)];