अधिक संख्या को बनाए रखते हुए अंक निकालें

Question

परिचय

इस चुनौती में मूल अंक n से y अंकों को निकालने वाली सबसे बड़ी संख्या है, जिसमें x अंक हैं।

यह मानते हुए कि y = 2 अंक y=2 n=5263 x=4निकालने वाली संभावित संख्याएँ हैं:

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

तो, सबसे बड़ी संख्या है 63जो इस उदाहरण के लिए आउटपुट होना चाहिए।

---

एक और तर्क होगा: प्रत्येक y के लिए, बाएं से दाएं अंक की खोज करें जो दाएं अगला अंक अधिक है, फिर इसे हटा दें, जब कोई मिलान नहीं होता है, तो अंतिम y- अंकों को हटा दें ।

y=3 n=76751432 x=8समझाने के लिए उपयोग करना :

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

ऊपर बताए गए दोनों तरीके काम करते हैं .. बेशक, आप दूसरी विधि का भी उपयोग कर सकते हैं :)

चुनौती

संख्या n में 8 से अधिक अंक नहीं होंगे, और y हमेशा शून्य से अधिक और x से कम होगा ।

सख्त इनपुट प्रारूप से बचने के लिए, आप मानों का उपयोग कर सकते हैं: y n xजिस तरह से आप पसंद करते हैं: फ़ंक्शन, कच्चे इनपुट या किसी अन्य मान्य तरीके के पैरामीटर के रूप में। बस यह कहना न भूलें कि आपने अपने उत्तर में ऐसा कैसे किया।

आउटपुट परिणाम संख्या होना चाहिए।

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा जवाब।

उदाहरण इनपुट और आउटपुट

फिर से: आपको बहुत सख्त होने की आवश्यकता नहीं है :)

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

संपादित करें

मैंने इस तथ्य को प्रतिबिंबित करने के लिए इनपुट ऑर्डर को बदल दिया कि आप में से कुछ को समस्या को हल करने के लिए x मान की आवश्यकता नहीं हो सकती है। x अब एक वैकल्पिक मान है।

Comments

कृपया अधिक सामान्य इनपुट और आउटपुट की अनुमति दें, विशिष्ट स्ट्रिंग प्रारूप की आवश्यकता आमतौर पर एक बुरा विचार है ।

— xnor

@LuisMendo मैं I / O का संपादन करने में बुरा नहीं मानूंगा। ¯ \ _ (ツ) _ / ¯

— एलेक्स ए।

-1 की वजह से सख्त I / O आवश्यकताओं, एक दिलचस्प चुनौती के लिए +1। कुल मिलाकर, एक ठोस पक्ष।

— मेगो

इनपुट प्रारूप बहुत सख्त है जैसा कि अन्य लोगों ने कहा है, विशेष रूप से यह देखते हुए कि xयह एक बेकार जानकारी है।

— घातक

@Fatalize वास्तव में, मुझे लगता है कि आपके द्वारा उठाए गए दृष्टिकोण के आधार पर, xइनपुट के रूप में कोड को छोटा कर सकते हैं। (बिंदु में मामला: मेरा जूलिया जवाब।)

— एलेक्स ए।

Answer 1

ए-रे , ९ 7 बाइट्स

मेरी नई भाषा! मेटा के अनुसार, यह अनुमति है, लेकिन अगर यह स्वीकार नहीं किया जाता है, तो मैं इसे हटा दूंगा।

pM:i-II

स्पष्टीकरण:

  :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

उदाहरण इनपुट (संख्या, x, y):

1736413 7 4

आउटपुट:

764

आप इसे github लिंक में दी गई .jar फ़ाइल से जांच सकते हैं।

Answer 2

MATL , 10 बाइट्स

-jowXncUX>

यह भाषा / संकलक के संस्करण (9.2.1) का उपयोग करता है , जो इस चुनौती से पहले है।

यह इस क्रम में स्टड से तीन इनपुट लेता है: स्ट्रिंग की लंबाई, हटाए गए पात्रों की संख्या, स्ट्रिंग।

उदाहरण

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

संपादित करें : इसे ऑनलाइन आज़माएं! (लिंक में कोड है XNबजाय Xnइस चुनौती के बाद भाषा में परिवर्तन के अनुरूप है, यह भी, oअब कोई आवश्यकता नहीं है)

व्याख्या

(यह अभी भी 2 बाइट्स की तुलना में अधिक है क्योंकि यह ओक्टेव और मैटलैब के nchoosekफ़ंक्शन के अलग-अलग व्यवहार के कारण होना चाहिए । संकलक की अगली रिलीज में फिक्स्ड।)

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

---

मूल चुनौती (सख्त इनपुट आवश्यकताओं) का उत्तर: 16 बाइट्स

jYbZ)b-wowXncUX>

भाषा / संकलक के वर्तमान संस्करण (9.2.1) का उपयोग करता है ।

उदाहरण

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

व्याख्या

(यह 4 बाइट्स कम होना चाहिए था, लेकिन मुझे इसकी आवश्यकता है wow...cक्योंकि ऑक्टेव का nchoosekफ़ंक्शन, मैटलैब के विपरीत, चरित्र इनपुट के साथ नहीं है। कंपाइलर के अगले रिलीज के लिए तय किया जाएगा।)

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

Comments

wowआपका कोड अपनी स्वयं की कमी पर चकित है;)

— ETHproductions

@ETHproductions हा। खैर, नए इनपुट आवश्यकताओं के साथ यह 6 बाइट्स खो गया और मिला ... अवाक

— लुइस मेंडो

Answer 3

पायथ - 11 9 8 बाइट्स

eS.cz-QE

टेस्ट सूट ।

Comments

अच्छा गोल्फ, लेकिन इनपुट स्वरूपण का पालन नहीं करता है?

— लूई

@Lui ओह, यह नहीं देखा कि यह सख्त था, फिक्सिंग।

— माल्टीसेन

पर्याप्त रूप से, ऐसा लगता है कि सवाल पर टिप्पणियों में इसके बारे में कुछ चर्चाएं हैं, लेकिन यह हल नहीं हुई है।

— लूई

@ एल तय। अंतरिक्ष शिक्षक।

— माल्टीसेन

बेहतर लगता है, लेकिन मुझे लगता है कि इनपुट में भी उसी लाइन पर x है, जहां x मुख्य पूर्णांक में अंकों की संख्या है? अर्थात्: 2 5263 4।

— लुई

Answer 4

जाप, 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

Answer 5

ब्रेकीलॉग , 30 बाइट्स

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

चूंकि ओपी ने IO पर बाधाओं को शांत किया है, इसलिए यह [Number, NumberOfDigitsRemoved]इनपुट के रूप में उम्मीद करता है और आउटपुट के रूप में उत्तर देता है brachylog_main([1789823,4], Z).।

व्याख्या

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

Answer 6

पायथन 3, 69 बाइट्स

यह तीनों तर्कों को स्वीकार करते हुए एक अनाम फ़ंक्शन को परिभाषित करता है। नियम का पूरा फायदा उठाते हुए कि "आप मूल्यों का उपयोग कर सकते हैं: y n xजिस तरह से आप पसंद करते हैं", मैंने स्वीकार करने के लिए yऔर xपूर्णांकों के nरूप में और एक स्ट्रिंग के रूप में चुना है। वापसी मान एक स्ट्रिंग है।

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

बस अगर किसी को लगता है कि यह नियमों को बहुत दूर खींच रहा है, तो यह संस्करण पूर्णांक के रूप में सभी इनपुट लेता है और 74 बाइट्स है।

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

और सिर्फ kicks के लिए, मैंने कमांड लाइन से लेने yऔर nपरिणाम को प्रिंट करने के लिए दो-तर्क संस्करण भी लिखा STDOUT। यह 92 बाइट्स है।

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

Answer 7

ईएस 6, 70 बाइट्स

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

एक संख्यात्मक परिणाम देता है जब तक yकि झूठा न हो और nएक स्ट्रिंग हो। मैंने अपने आप को आश्वस्त किया है कि रिकर्सियन को अभी भी काम करने के आसपास गलत तरीके से कर रहा है (मेरा समाधान सही पुनरावर्तन करने के लिए लागू नहीं है)।

इसके अलावा मेरा पहला कोड गोल्फ जहां मैं सभी तीन उद्धरण चिह्नों का उपयोग करता हूं (हालांकि सभी उद्धरण के रूप में नहीं), जिसने मुझे तुच्छ रूप से लंबाई की गणना करने से रोका।

Answer 8

जूलिया, 128 95 बाइट्स

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

यह एक फ़ंक्शन है जो तीन मानों को मापदंडों के रूप में स्वीकार करता है और पूर्णांक देता है।

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

Answer 9

हास्केल, 64 बाइट्स

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

प्रयोग उदाहरण: (4#7)"1789823"-> "983"।

मूल संख्या nको एक स्ट्रिंग के रूप में लिया जाता है। (निश्चित नहीं है कि मैं "कोई सख्त इनपुट प्रारूप" नियम से आगे नहीं बढ़ रहा हूं, लेकिन पहले संस्करण में स्ट्रिंग इनपुट की आवश्यकता थी!)।

यह कैसे काम करता है: के सभी बाद की सूची बनाएं n, जो लंबाई के साथ रखें x-yऔर अधिकतम चुनें।

Answer 10

रूबी, 40 बाइट्स

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

इस को उस अज्ञात फ़ंक्शन लेता है yऔर xपूर्णांक के रूप में और nएक स्ट्रिंग के रूप में, और रिटर्न एक स्ट्रिंग। आप इसे उदाहरण के लिए कह सकते हैं

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

और यह वापस आ जाएगा "63"।

Answer 11

MATLAB 40 बाइट्स

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

परीक्षा:

ans('76751432',3)
ans = 77543

Answer 12

पायथ, 45 बाइट्स

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

इसे यहाँ आज़माएँ

Answer 13

जावास्क्रिप्ट (ईएस 6), 78

2 तर्कों y और d के साथ एक पुनरावर्ती कार्य। yसंख्यात्मक या स्ट्रिंग dहो सकता है, एक स्ट्रिंग होना चाहिए।

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

चुनौती बदलने से पहले यह 107 था ... ... सभी इनपुट / आउटपुट विषमताओं के साथ ...

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'

परीक्षा

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>

Comments

टाइपो: n-1होना चाहिए y-1।

— नील