9 में से सबसे छोटी बहु को 0 के वैकल्पिक रन द्वारा चलाया जा रहा है

22

एक सकारात्मक पूर्णांक को देखते हुए, इसके सबसे छोटे धनात्मक पूर्णांक को एकाधिक खोजें, जो कि 9 का एक रन है, जिसके बाद 0. का वैकल्पिक रन है। दूसरे शब्दों में, इसके सबसे छोटे धनात्मक पूर्णांक को एकाधिक से खोजें जो regex द्वारा मेल खाता है /^9+0*$/ ।

उदाहरण के लिए, यदि दिया गया धनात्मक पूर्णांक 2 है, तो 90 लौटें, क्योंकि 90 एक पूर्णांक गुणक 2 से अधिक है और सबसे छोटा है जो रेगेक्स से मेल खाता है /^9+0*$/ ।

परीक्षण के मामलों:

n  f(n)
1  9
2  90
3  9
4  900
5  90
6  90
7  999999
8  9000
9  9
10 90
11 99
12 900
13 999999
14 9999990
15 90
16 90000

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

code-golf  arithmetic 
— लीक नन
स्रोत
3
अच्छी तरह से परिभाषित का सबूत?
— विनाशकारी नींबू
2
@DestructibleLemon यह सबूत पर्याप्त है, क्योंकि परिणाम को 9. से गुणा किया जा सकता है
— xnor
1
मुझे लगता है कि अधिक परीक्षण मामलों की जांच करना अच्छा होगा कि समाधान को 0 से पहले आने के लिए 9 की आवश्यकता होती है।
— xnor
2
@LeakyNun शायद नहीं, लेकिन 9900099 है, और नियमों के अनुसार अनुमति नहीं दी जानी चाहिए।
— DrQuarius
2
@koita_pisw_sou नियम यह है कि किसी भी पूर्णांक के लिए कार्यक्रम को "सैद्धांतिक रूप से" काम करना चाहिए जो कि मनमाना परिशुद्धता और स्मृति और समय दिया गया हो।
— लीकी नून

जवाबों:

6

जेली , 13 11 बाइट्स

ṚḌ‘DS=ḍ@ð1#

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

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

ṚḌ‘DS=ḍ@ð1#  Main link. Argument: n

        ð    Start a dyadic chain with arguments n and n.
         1#  Execute the chain to the left with left argument k = n, n+1, n+2, ...
             and right argument n until 1 match has been found. Return the match.
Ṛ                Get the decimal digits of k, reversed.
 Ḍ               Convert from base 10 to integer.
                 This essentially removes trailing zeroes. As a side effect, it
                 reverses the digits, which doesn't matter to us.
  ‘              Increment the resulting integer. If and only if it consisted
                 entirely of 9's, the result is a power of 10.
   DS            Compute the sum of the digits. The sum is 1 if and only if the
                 integer is a power of 10. Note that the sum cannot be 0.
      ḍ@         Test k for divisibility by n.
     =           Compare the results.
— डेनिस
स्रोत
4
ಠ_ಠ कैसे आप के साथ न तो यह क्या किया 9या 0में अपने कोड
— पावेल
मैंने एक स्पष्टीकरण जोड़ा है।
— डेनिस
5

जावास्क्रिप्ट (ईएस 6), 47 43 42 बाइट्स

-4 बाइट्स @Arnauld
-1 बाइट के लिए @Luke को धन्यवाद

n=>eval('for(i=0;!/^9+0*$/.test(i);)i+=n')

टेस्ट

let f=
n=>eval('for(i=0;!/^9+0*$/.test(i);)i+=n')

for(let i=1;i<=16;i++)console.log(`f(${i}) = `+f(i))
स्निपेट का विस्तार करें

पुनरावर्ती समाधान (7, 13 और 14 के लिए विफल रहता है), 38 बाइट्स

n=>g=(i=0)=>/^9+0*$/.test(i+=n)?i:g(i)

जैसे कहा जाता है f(5)()। के लिए क्रोम और फ़ायरफ़ॉक्स में अधिकतम कॉल स्टैक आकार तक पहुँच जाता है n=7, n=13और n=14।

कोड स्निपेट दिखाएं

— जस्टिन मेरिनर
स्रोत
3
एक बाइट छोटी:n=>eval('for(i=0;!/^9+0*$/.test(i);)i+=n')
— ल्यूक
4

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

->x{r=0;1until"#{r+=x}"=~/^9+0*$/;r}

ब्रूट-फोर्सिंग - हमेशा के लिए x = 17 में ले जाता है।

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

— जीबी
स्रोत
मैं आपके साथ लगभग एक ही समाधान के साथ आया था, लेकिन एक पूर्ण कार्यक्रम के रूप में: codegolf.stackexchange.com/a/130106/60042 । मैंने आपसे स्ट्रिंग प्रक्षेप का उपयोग उधार लिया है, मुझे आशा है कि यह ठीक है।
— पावेल
4

जावा 8, 61 57 बाइट्स

n->{int r=0;for(;!(""+r).matches("9+0*");r+=n);return r;}

-4 बाइट्स (और तेज निष्पादन) @JollyJoker के लिए धन्यवाद ।

स्पष्टीकरण:

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

n->{                              // Method with integer as parameter and return-type
  int r=0;                        //  Result-integer
  for(;!(""+r).matches("9+0*");   //  Loop as long as `r` doesn't match the regex
    r+=n                          //   And increase `r` by the input every iteration
  );                              //  End of loop
  return r;                       //  Return the result-integer
}                                 // End of method
— केविन क्रूज़सेन
स्रोत
अनुकूलन के लिए हाँ! ^ ^
— ओलिवियर ग्राएगोइरे
1
एन द्वारा वृद्धि r%nजाँच से बचा जाता है ,n->{int r=0;for(;!(""+(r+=n)).matches("9+0*"););return r;}
— जॉली जोकर
for(;!(""+r).matches("9+0*");r+=n)
— जॉली जोकर
मैंने कोशिश की है, और पूर्णांक और गणित के साथ प्राप्त करने की कोशिश की है, लेकिन मैं इसे हरा नहीं सकता! बधाई :)
— ओलिवियर ग्रेजायर
2

RProgN 2 , 18 बाइट्स

x={x*'^9+0*$'E}éx*

व्याख्या की

x={x*'^9+0*$'E}éx*
x=                  # Set the value of "x" to the input.
  {           }é    # Find the first positive integer in which passing it to the defined function returns truthy.
   x*               # Multiply the index by x, this essentially searches multiples now.
     '^9+0*$'       # A Regex defined by a literal string.
             E      # Does the multiple match the regex?
                x*  # Multiple the outputted index by x, giving the result.

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

— Ataco
स्रोत
2

मैथिक्स , 71 बाइट्स

(x=#;While[!StringMatchQ[ToString@x,RegularExpression@"9+0*"],x+=#];x)&

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

बहुत तीक्ष्ण जानवर बल समाधान नहीं है, लेकिन यह अन्य गणितज्ञ उत्तर को हरा देता है, जो कुछ चतुर चाल का उपयोग करता है।

इस चुनौती के संबंध में माथमेटाका की गुणवत्ता को कम करने वाला तथ्य यह है कि StringMatchQएक पूर्ण मैच की आवश्यकता है, इसलिए मैं इसके 9+0*बजाय कर सकता हूं ^9+0*$।

— पावेल
स्रोत
2
यदि आप गणित के बजाय गणितज्ञ का उपयोग करने के लिए तैयार हैं, तो आप "9"..~~"0"...इसके बजाय कुछ बाइट्स बचा सकते हैं RegularExpression@"9+0*"।
— एक पेड़ नहीं
1
@ नॉटट्री थैंक्स, मैं इसे बाद में ध्यान में रखूंगा, लेकिन मैं मैथिक्स के साथ रहूंगा। मैं सिंटैक्स का उपयोग नहीं करना पसंद करता हूँ जो मुझे समझ में नहीं आता है, और मैंने पहली बार सिंटैक्स को इस तरह देखा है।
— पावेल
काफी उचित। (मैथमेटिका का पैटर्न मिलान वाक्यविन्यास एक शक्तिशाली उपकरण है, लेकिन अगर आप नियमित अभिव्यक्ति से परिचित हैं, तो शायद आप पहले से ही जानते हों!)
— न
2

बैच, 175 बाइट्स

@set/pn=
@set s=
:g
@set/ag=-~!(n%%2)*(!(n%%5)*4+1)
@if not %g%==1 set s=0%s%&set/an/=g&goto g
@set r=1
:r
@set s=9%s%
@set/ar=r*10%%n
@if %r% gtr 1 goto r
@echo %s%

STDIN पर इनपुट लेता है। ब्रूट फोर्स सॉल्यूशन नहीं, लेकिन वास्तव में मेरे दशमलव पर सटीक दशमलव के उत्तर पर आधारित है, इसलिए यह 17, 19, आदि के लिए काम करेगा, जो अन्यथा अपनी पूर्णांक सीमा से अधिक होगा।

— नील
स्रोत
2

गणितज्ञ, 127 बाइट्स

Select[FromDigits/@Select[Tuples[{0,9},c=#],Count[#,9]==1||Union@Differences@Flatten@Position[#,9]=={1}&],IntegerQ[#/c]&][[1]]&


इनपुट

[17]

उत्पादन

9999999999999999

यहां पहले 20 शब्द हैं

{9, 90, 9, 900, 90, 90, 999999, 9000, 9, 90, 99, 900, 999999, 9999990, 90, 90000, 9999999999999999, 90, 999999999999999, 900}

— J42161217
स्रोत
1
चतुर, लेकिन स्पष्ट समाधान सबसे छोटा लगता है: codegolf.stackexchange.com/a/130115/60042
— Pavel
अपने स्पष्ट समाधान 17 ऐसा नहीं कर सकते ;-)
— J42161217
मैं क्या कह सकता हूं, सबसे तेज़-कोड नहीं
— पावेल
वैसे, आपका हल मैथिक्स में काम करता है, आप इसे बदल सकते हैं और एक टीआईओ लिंक जोड़ सकते हैं।
— पावेल
— पावेल
2

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

f पूर्णांक लेता है और वापस करता है।

f n=filter(all(<'1').snd.span(>'8').show)[n,n+n..]!!0

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

यह समय 17 के लिए है, जो आसानी से परीक्षण मामलों से परे है। 56 बाइट्स में एक तेज़ संस्करण:

f n=[x|a<-[1..],b<-[0..a-1],x<-[10^a-10^b],mod x n<1]!!0

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

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

  • fके सभी गुणकों को उत्पन्न करता है n, प्रत्येक को एक स्ट्रिंग में परिवर्तित करता है, सही प्रारूप वाले लोगों को फ़िल्टर करता है, फिर पहले को लेता है।

  • तेजी से संस्करण के बजाय का उपयोग करता है के लिए आवश्यक संख्या के रूप में हैं 10^a-10^b, a>=1, a>b>=0। गोल्फ उद्देश्यों के लिए यह इस तथ्य का भी उपयोग करता है कि न्यूनतम के लिए a, केवल एक b ही काम कर सकता है, जो इसे bथोड़ा कम "गलत" क्रम में एस उत्पन्न करने की अनुमति देता है ।

— अर्जन जोहान्सन
स्रोत
1

माणिक , 38 + 1 = 39 बाइट्स

-pध्वज का उपयोग करता है ।

$_=y=eval$_
1until"#{$_+=y}"=~/^9+0*$/

-p कार्यक्रम को घेरता है:

while gets
    ...
end
puts $_

getsमें इसका परिणाम संग्रहीत करता है $_। evalइसे संख्या में परिवर्तित करने के लिए उपयोग किया जाता है, क्योंकि यह इससे छोटा है .to_i, तो brute बल का उपयोग किया जाता है, जब तक कि यह regex से मेल नहीं खाता तब तक $ _ को बढ़ाता है। "#{}"इंटरट्रैपेशन है, यह एक .to_sकॉल से कम है क्योंकि इसके लिए चारों ओर पैरेन्थेस की आवश्यकता होगी $_+=y। अंत में, $_मुद्रित किया जाता है।

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

सभी परीक्षण मामलों की कोशिश करो!

— पावेल
स्रोत
1

सी ++, 106 बाइट्स

int main(){long N,T=9,j=10,M;cin>>N;while(T%N){if(T/j){T+=(M/j);j*=10;}else{T=(T+1)*9;j=10;M=T;}}cout<<T;}

विस्तृत रूप:

int main()
{
    long N,T=9,j=10,M;
    cin >> N;

    while (T%N)
    {
        if (T/j)
        {
            T += (M/j);
            j *= 10;
        }
        else
        {
            T = (T+1)*9;
            j = 10;
            M = T;
        }
    } 

    cout << T;
}

यह ऑनलाइन कोशिश करो!

— koita_pisw_sou
स्रोत
बेहतर गोल्फ:, [](int n){int T=9,j=10,m;while(t%n)if(t/j){t+=m/j;j*=10;}else{t=(t+1)*9;j=10;m=t;}return t;}}94 बाइट्स लेता है। अनिवार्य रूप से, इसे बाइट्स को बचाने के लिए फ़ंक्शन फ़ंक्शन के रूप में माना जाता है, अनावश्यक कोष्ठक पर सहेजें, प्रकार नामकरण और प्रकार पर सहेजने के लिए लंबो फ़ंक्शन का उपयोग करें।
— enedil
यह लंबोदर का उपयोग करके संकलन नहीं कर सकता। क्या आप एक हाथ दे सकते हैं?
— koita_pisw_sou
यह कारण हो सकता है कि मैं अंत में बहुत सारे आच्छादन कोष्ठक डाल दिया।
— enedil
इसके अलावा, लैम्बडा को शायद वैश्विक दायरे में मौजूद नहीं होना है, भले ही इसे नियमित फ़ंक्शन में लपेटने में 97 बाइट्स लगते हैं।
— ईनदिल
1

पायथन 2 , 79 बाइट्स

x=input();n=10;y=9
while y%x:
 b=n
 while(b-1)*(y%x):b/=10;y=n-b
 n*=10
print y

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

कुछ स्पष्टीकरण इसके 10**n-10**bसाथ सबसे छोटे प्राकृतिक रूप का पता लगाते हैंn>b>=0 इनपुट के विभाजन के ।

कुछ आई.ओ.

f(1) = 9
f(2) = 90
f(3) = 9
f(4) = 900
f(5) = 90
f(6) = 90
f(7) = 999999
f(8) = 9000
f(9) = 9
f(10) = 90
f(11) = 99
f(12) = 900
f(13) = 999999
f(14) = 9999990
f(15) = 90
f(16) = 90000
f(17) = 9999999999999999
f(18) = 90
f(19) = 999999999999999999
— mdahmoune
स्रोत
1

स्विफ्ट 3.0, बाइट्स: 121

var i=2,m=1,n=""
while(i>0){n=String(i*m)
if let r=n.range(of:"^9+0*$",options:.regularExpression){print(n)
break};m=m+1}

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

— उ। पूजा
स्रोत
क्या करता let r=है? मुझे rकहीं और नहीं भेजा गया है
— Cyoce
@Cyoce को r = check करता है कि n.range रिटर्न nil को मूल्य देता है या नहीं। आप let_ = का उपयोग कर सकते हैं। मैं किसी भी बाइट को कम करने के लिए यहां वैकल्पिक बाइंडिंग का उपयोग कर रहा हूं।
— A. पूजा
1

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

यह फ़ंक्शन पूर्णांक लेता है nऔर mशून्य पर आरम्भ करता है। फिर यह सभी शून्य को समाप्त mकरता है और जाँचता है कि क्या परिणाम में केवल 9 है, mअगर यह होता है। यदि नहीं, तो यह फिर से जोड़ता nहै mऔर जांच करता है, आदि।

def f(n,m=0):
 while{*str(m).strip('0')}!={'9'}:m+=n
 return m

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

— C मैकआवॉय
स्रोत
1

जावा (ओपनजेडके 8) , 66 बाइट्स, 17 पर चोक नहीं करता है

n->{long a=10,b=1;for(;(a-b)%n>0;b=(b<10?a*=10:b)/10);return a-b;}

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

@ केविनक्रूजसेन के समाधान की तुलना में लंबा है लेकिन थोड़ी बड़ी संख्या को संभाल सकता है। यह 10 ^ 6 - 10 ^ 3 = 999000 जैसे उम्मीदवार संख्याओं की गणना करता है। 64-बिट लॉन्ग अभी भी सीमा = 23 = के लिए टूट रहे हैं।

शायद थोड़ा गोल्फ हो सकता है लेकिन पहले से ही इसे काम करने के लिए बहुत लंबा समय लगा ...

— जॉली विदूषक
स्रोत
1

> <> , 35 बाइट्स

&a:v ;n-<
:,a/?(1:^!?%&:&-}:{
a*:\~

इसे ऑनलाइन आज़माएं , या इसे देखें मछली के खेल के मैदान में देखें !

मान लें कि इनपुट पहले से ही स्टैक पर है। फार्म 10 a  - 10 b की संख्याओं की तलाश में काम करता है , एक <b (हाँ, यह संकेत से कम है - यह कम बाइट्स है!) जब तक कि इनपुट द्वारा विभाज्य नहीं किया जाता है, तब तक 10 b  - 10 a की छपाई होती है । यह ब्रूट फोर्स विधि की तुलना में बहुत तेज है (जो कि> <> वैसे भी मुश्किल होगा)।

— पेड़ नहीं
स्रोत
1

वी , 19 14 बाइट्स

é0òÀ/[1-8]ü09

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

व्याख्या

é0              ' <m-i>nsert a 0
  ò             ' <m-r>ecursively
   À            ' <m-@>rgument times
               ' <C-A> increment the number (eventually gives all multiples)
     /[1-8]ü09  ' find ([1-8]|09) if this errors, the number is of the form
                ' (9+0*) (because there won't ever be just zeros)
                ' implicitly end the recursion which breaks on the above error
— nmjcman101
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 51 49 बाइट्स

let
f=(n,x=1,y=1)=>(x-y)%n?f(n,x,y*10):x-y||f(n,x*10)
<input type=number value=1 step=1 min=1 oninput=O.value=f(value)>
<input type=number value=9 id=O disabled>
स्निपेट का विस्तार करें

सबसे छोटा दृष्टिकोण नहीं है, लेकिन यह तेजी से दुष्ट है।

— ETHproductions
स्रोत
1

गणितज्ञ, 82 बाइट्स

@ जेनी_मैथी के जवाब से सबमिशन के पैटर्न का उपयोग ...

(d=x=1;y=0;f:=(10^x-1)10^y;n:=If[y>0,y--;x++,y=d;d++;x=1];While[Mod[f,#]!=0,n];f)&

इनपुट:

[17]

आउटपुट:

9999999999999999

और कम से @ साथ Jenny_mathy के जवाब टिप्पणियों में तर्क के सापेक्ष @Phoenix ... RepeatedTiming[]इनपुट करने के लिए आवेदन के [17]लिए देता है

{0.000518, 9999999999999999}

इतना आधा मिलीसेकंड। थोड़ा बड़े इनपुट पर जा रहे हैं [2003]:

{3.78, 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999}

4 सेकंड के तहत थोड़ा सा।

परीक्षण तालिका: पहले 30 सकारात्मक पूर्णांकों पर, परिणाम हैं 

{9, 90, 9, 900, 90, 90, 999999, 9000, 9, 90, 99, 900, 999999, 
9999990, 90, 90000, 9999999999999999, 90, 999999999999999999, 900, 
999999, 990, 9999999999999999999999, 9000, 900, 9999990, 999, 
99999900, 9999999999999999999999999999, 90}

स्पष्टीकरण: यहां एकमात्र जादू कस्टम इट्रेटर ("इटेटर" सीएस अर्थ में है, एम'एमए अर्थ नहीं)

n := If[ y>0  ,  y-- ; x++  ,  y=d ; d++ ; x=1]

जो वैश्विक चर पर कार्य करता है x, अग्रणी "9" yकी संख्या, अनुगामी "0" की संख्या, और वांछित मूल्य है ।)d , अंकों की कुल संख्या। हम अंकों की संख्या के माध्यम से पुनरावृत्ति करना चाहते हैं, और, अंकों की संख्या के प्रत्येक विकल्प के लिए, सबसे "0" s और कम से कम "9" s से शुरू करें। इस प्रकार पहली चीज जो कोड करती है dवह 1 के लिए प्रारंभिक है, मजबूरनx 1 के लिएy 0. के लिए । कस्टम पुनरावृत्ति जाँचता है कि "0" के स्ट्रिंग को छोटा किया जा सकता है। यदि ऐसा है, तो यह एक से "0" के स्ट्रिंग को छोटा करता है और एक "1" के स्ट्रिंग को बढ़ाता है। यदि नहीं, तो यह अंकों की संख्या में वृद्धि करता है, "0" s की संख्या को अंकों की संख्या से कम करता है, और "9" की संख्या को 1 पर सेट करता है।dy

— एरिक टावर्स
स्रोत
और फिर भी, अभी भी जानवर बल और रेगेक्स की तुलना में अधिक है।
— पावेल
@Phoenix: तो 2003 में आपकी टाइमिंग क्या है?
— एरिक टावर्स
1

टीआई-बेसिक (TI-84 Plus CE), 48 41 बाइट्स

Prompt X
For(K,1,0
For(M,-K+1,0
10^(K)-10^(-M
If 0=remainder(Ans,X
Return
End
End

Promptकार्यक्रम के दौरान इनपुट -ed है; उत्पादन में संग्रहीत किया जाता हैAns ।

स्पष्टीकरण:

फॉर्म की संख्या (10 n ) (10 m -1) = 10 k- 10 m , जहां m + n = k 1 से शुरू होता है और बढ़ता है, और k के प्रत्येक मान के लिए, यह m = 1, n = k की कोशिश करता है -1; मीटर = 2, एन = k-2; ... एम = के, एन = 0; जब तक यह एक से अधिक नहीं मिल जाता है X।

यह 16 तक काम करता है; 17 एक डोमेन त्रुटि देता है क्योंकि remainder(केवल 9999999999999 (13 nines) तक के लाभांश को स्वीकार कर सकते हैं, और 17 को 9999999999999999 (16 nines) का उत्पादन करना चाहिए।

Prompt X               # 3 bytes, input number
For(K,1,0              # 7 bytes, k in the description above; until a match is found
For(M,-K+1,0           # 10 bytes, start with n=1, m=(k-n)=k-1;
                           # then n=2, m=(k-n)=k-2, up to n=k, m=(k-n)=0
                           # (M=-m because it saved one byte)
10^(K)-10^(-M           # 8 bytes, n=(k-m) nines followed by m zeroes → Ans
If not(remainder(Ans,X # 8 bytes, If X is a factor of Ans (remainder = 0)
Return                 # 2 bytes, End program, with Ans still there
End                    # 2 bytes,
End                    # 1 byte (no newline)
— pizzapants184
स्रोत
1

क्यूबिक , 53 बाइट्स

{p=p+1┘o=p*9_F!o$|┘n=!A!~(_l!n$|=_l!n+1$|)-(o%:)|\_Xo

व्याख्या

{        infinitely DO
p=p+1    raise p (starts out as 0)
┘o=p*9   Get the mext multiple of 9 off of p
_F!o$|   Flip a string representation of p*9
┘n=!A!   and set 'n' to be an int version of the flipped p*9 
         (this effectively drops trailing 0's)
~        This IF will subtract two values: the first is either 0 for n=x^10, or -1
         and the second bit does (p*9) modulo 'a' (input number): also 0 for the numbers we want
(
 _l!n$|  the length of n's string representation
=        is equal to
_l!n+1$| the length of (n+1)'s string rep (81 + 1 = 82, both are 2 long; 99 + 1 = 100, there's a difference)
)        The above yields -1 (Qbasic's TRUE value) for non-9 runs, 0 for n=x^10
-        Subtract from that 
(o%:)    (p*9) modulo a     0 for p*9 = a*y
|       THEN (do nothing, since we want 0+0=0 in the conditionals above, execution of the right path jumps to ELSE
\_Xo    ELSE quit, printing (p*9)
— steenbergh
स्रोत
1

सी (जीसीसी) , 126 बाइट्स

#include<stdio.h>
main(x,n,y,b){n=10;y=9;scanf("%d",&x);while(y%x){b=n;while((b-1)*(y%x)){b/=10;y=n-b;}n*=10;}printf("%d",y);}

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

कुछ स्पष्टीकरण यह सबसे छोटा प्राकृतिक रूप पाता है10**n-10**bn>b>=0 इनपुट के विभाजन के साथ ।

कुछ आई.ओ.

f(1) = 9
f(2) = 90
f(3) = 9
f(4) = 900
f(5) = 90
f(6) = 90
f(7) = 999999
f(8) = 9000
f(9) = 9
f(10) = 90
f(11) = 99
f(12) = 900
f(13) = 999999
f(14) = 9999990
f(15) = 90
f(16) = 90000
— mdahmoune
स्रोत
1

पर्ल ५ , 23 + 2 (-pa) = 25 बाइट्स

ब्रूट फोर्स मेथड 

$_+=$F[0]while!/^9+0*$/

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

यह धीमा है, लेकिन यह छोटा है।

अधिक कुशल विधि:

41 + 2 (-pa) = 43 बाइट्स

$_=9;s/0/9/||($_=9 .y/9/0/r)while$_%$F[0]

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

यह किसी भी इनपुट के लिए अच्छी तरह से काम करता है, लेकिन यह लंबा कोड है।

— Xcali
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.