introduzione

Questa sfida consiste nel trovare il numero più grande rimuovendo y cifre dal numero originale n che ha x cifre.

Supponendo y=2 n=5263 x=4, i possibili numeri che rimuovono y = 2 cifre sono:

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

Quindi, il numero più grande è 63quale deve essere l'output per questo esempio.

Un'altra logica sarebbe: per ogni y, cercare da sinistra a destra la cifra la cui cifra successiva a destra è maggiore, quindi rimuoverla, altrimenti quando non c'è corrispondenza, rimuovere le ultime cifre y .

Usando y=3 n=76751432 x=8per spiegare:

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

Entrambi i metodi spiegati sopra funzionano .. ovviamente, puoi usare anche un altro metodo :)

Sfida

Il numero n non avrà più di 8 cifre e y sarà sempre maggiore di zero e inferiore di x .

Per evitare un formato di input rigoroso, è possibile utilizzare i valori: y n xil modo in cui si preferisce: come parametri in funzione, input non elaborato o qualsiasi altro modo valido. Non dimenticare di dire come l'hai fatto nella tua risposta.

L'output dovrebbe essere il numero del risultato.

Questo è code-golf , vince la risposta più breve in byte.

Esempio di input e output

Ancora: non devi essere troppo severo :)

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

modificare

Ho modificato l'ordine di input per riflettere il fatto che alcuni di voi potrebbero non aver bisogno del valore x per risolvere il problema. x è ora un valore opzionale.

A-Ray , 9 7 byte

La mia nuova lingua! Secondo meta, questo è permesso, ma se questo non è accettato, lo rimuoverò.

pM:i-II

Spiegazione:

  :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

Esempio di input (numero, x, y):

1736413 7 4

Produzione:

764

Puoi provarlo con il file .jar indicato nel link github.

MATL , 10 byte

-jowXncUX>

Questo utilizza la versione (9.2.1) del linguaggio / compilatore, che è precedente a questa sfida.

Prende tre input dallo stdin in questo ordine: lunghezza della stringa, numero di caratteri rimossi, stringa.

Esempio

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

EDIT : provalo online! (il codice nel link deve XNinvece Xnessere conforme ai cambiamenti nella lingua dopo questa sfida; inoltre, onon è più necessario)

Spiegazione

(Questo costa ancora 2 byte in più di quanto dovrebbe a causa del nchoosekcomportamento diverso di Octave e Matlab . Risolto nel prossimo rilascio del compilatore.)

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

Risposta alla sfida originale (requisiti di input più rigorosi): 16 byte

jYbZ)b-wowXncUX>

Utilizza la versione corrente (9.2.1) del linguaggio / compilatore.

Esempio

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

Spiegazione

(Questo avrebbe dovuto essere di 4 byte in meno, ma ne ho bisogno wow...cperché la nchoosekfunzione di Octave , a differenza di quella di Matlab, non funziona con l'inserimento dei caratteri. Sarà risolto per la prossima versione del compilatore.)

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 byte

eS.cz-QE

Test Suite .

Japt, 19 byte

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

Provalo online!

Come funziona

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

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

Poiché OP ha attenuato i vincoli su IO, ciò si aspetta [Number, NumberOfDigitsRemoved]come input e restituisce la risposta come output, ad es brachylog_main([1789823,4], Z)..

Spiegazione

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

Questo definisce una funzione anonima che accetta tutti e tre gli argomenti. Sfruttando appieno la regola che "puoi usare i valori: y n xil modo che preferisci", ho scelto di accettare ye xcome numeri interi e ncome stringa. Il valore restituito è una stringa.

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

Nel caso in cui qualcuno pensi che questo stia allungando troppo le regole, questa versione accetta tutti gli input come numeri interi ed è di 74 byte.

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

E solo per i calci, ho anche scritto una versione a due argomenti, prendendo ye ndalla riga di comando e stampando il risultato su STDOUT. Sono 92 byte.

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

ES6, 70 byte

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

Restituisce un risultato numerico a meno che non ysia falso ed nè una stringa. Mi sono convinto che fare la ricorsione nel modo sbagliato funziona ancora (la mia soluzione non è applicabile a fare la ricorsione corretta).

Anche il mio primo codice golf dove uso tutti e tre i segni di virgolette (anche se non tutti come virgolette), che mi ha impedito di calcolare banalmente la lunghezza.

Julia, 128 95 byte

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

Questa è una funzione che accetta i tre valori come parametri e restituisce un numero intero.

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 byte

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

Esempio di utilizzo: (4#7)"1789823"-> "983".

Il numero originale nè preso come una stringa. (Non sono sicuro se sto sovraccaricando la regola "nessun formato di input rigoroso", ma nella prima versione era richiesto l'input di stringa (!)).

Come funziona: crea un elenco di tutte le sottosequenze di n, mantieni quelle di lunghezza x-ye scegli il massimo.

Rubino, 40 byte

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

Questa è una funzione anonima che accetta ye xcome numeri interi e ncome stringa e restituisce una stringa. Puoi chiamarlo per esempio in questo modo

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

e tornerà "63".

MATLAB 40 byte

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

Test:

ans('76751432',3)
ans = 77543

Pyth, 45 byte

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

provalo qui

JavaScript (ES6), 78

Una funzione ricorsiva con 2 argomenti y e d. ypuò essere numerico o stringa, ddeve essere una stringa.

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

Prima che la sfida fosse cambiata era 107 - ... con tutte le stranezze di input / output ...

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'

Test

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>