नंबर काटना

14

टास्क

पूर्णांक एन को प्रिंट करें, जहां 12 <= n <= 123456789, और एन में लगातार अंकों के सभी जोड़े उनके बीच समान सकारात्मक अंतर रखते हैं (जैसे 2468 लेकिन 2469 नहीं)।

कोई निवेश नहीं।

आउटपुट:

12
13
14
15
16
17
18
19
23
24
25
26
27
28
29
34
35
36
37
38
39
45
46
47
48
49
56
57
58
59
67
68
69
78
79
89
123
135
147
159
234
246
258
345
357
369
456
468
567
579
678
789
1234
1357
2345
2468
3456
3579
4567
5678
6789
12345
13579
23456
34567
45678
56789
123456
234567
345678
456789
1234567
2345678
3456789
12345678
23456789
123456789

नियम

  1. मानक खामियां लागू होती हैं।
  2. कोई निवेश नहीं

सबसे छोटा कोड जीतता है।

अराजकता गोल्फ का श्रेय

code-golf  number  sequence  kolmogorov-complexity 
— 0x45
स्रोत
8
यह समस्या अराजकता गोल्फ से है । आपको इसे श्रेय देना चाहिए (भले ही आप इसे प्रस्तुत करने वाले व्यक्ति थे)
— xnor
5
क्या उन्हें क्रम में मुद्रित करना होगा?
— H.PWiz
11
मैंने इस समस्या को एनागोल पर प्रस्तुत किया :)
— लिन
2
इस सूची में प्रत्येक पूर्णांक 0≤n <100 क्यों नहीं है?
— DonielF
3
@DonielF क्योंकि पूर्णांक 12 से अधिक या उसके बराबर होना चाहिए, और क्योंकि आगे का अंतर सकारात्मक होना चाहिए।
— डेनिस

जवाबों:

11

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

9œcḊẎIE$ÐfY

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

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

9œcḊẎIE$ÐfY  Main link. No arguments.

9            Set the argument and return value to 9.
   Ḋ         Dequeue; yield [2, ..., 9].
 œc          Take all k-combinations of [1, ..., 9], for each k in [2, ..., 9].
    Ẏ        Concatenate the arrays of k-combinations.
        Ðf   Filter the result by the link to the left.
     IE$         Compute the increments (I) of the combination / digit list and
                 tests if all are equal (E).
          Y  Join the results, separating by linefeeds.
— डेनिस
स्रोत
ìà Find fastest route between two points using Dykstra's Algorithm
— नील
7

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

k=71
exec"k+=1;r=range(k/8%9+1,10,k%8+1)\nif r[k/72:]:print`r`[1:k/24+2:3]\n"*576

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

अराजकता गोल्फ से मेरा समाधान । यह विचार लंबाई, प्रारंभ मूल्य, और चरण के सभी संभावित परीक्षणों पर पुनरावृति करना है, जो क्रमबद्ध आउटपुट देता है। ट्रिपल एक मूल्य के रूप में एन्कोड किया गया है rसे 72करने के लिए 647, और घटकों के रूप में निकाले जाते हैं k/72, k/8%9और k%8। kपर्याप्त उच्च शुरुआत एकल-अंकों की संख्या को आउटपुट होने से बचाती है।

xsot नेrange अंकों के हार्डकोड स्ट्रिंग के साथ प्रतिस्थापित करके इसे दो बाइट्स से बचाया'123456789' ।

यह दो सेकंड की रनटाइम सीमा के अवरोध के तहत लिखा गया था। एक धीमी रणनीति जो इनको उत्पन्न करने के बजाय संख्याओं को फ़िल्टर करती है, छोटी हो सकती है।

— XNOR
स्रोत
1
मजेदार तथ्य: यह समस्या वास्तव में "अराजकता गोल्फ रनटाइम सीमा" के लिए डिज़ाइन की गई है, यही वजह है कि मैंने इसे पीपीसीजी को प्रस्तुत नहीं किया। मैं सही से क्रमबद्ध (क्रमबद्ध) क्रम में सही संख्याएँ उत्पन्न करने के लिए कुछ चतुर तरीके से आने के लिए मजबूर 1करने 123456789के बजाय, से तोड़फोड़ करने को अयोग्य घोषित करना चाहता था ।
— लिन
6

सी, 166 152 बाइट्स

p,l,d,i=11;main(){for(char s[10];i<=1e9;){sprintf(s,"%d",++i);p=0;for(l=strlen(s);--l>0;){d=s[l]-s[l-1];if(!p)p=d;if(p^d|d<1)break;p=d;}if(!l)puts(s);}}

6 बाइट्स ने @KevinCruijssen को धन्यवाद दिया!

8 बाइट्स @JonathanFrech की बदौलत बच गए!

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

उपरोक्त कोड का पूरी तरह से प्रारूपित संस्करण नीचे देखा जा सकता है।

#include <string.h>
#include <stdio.h>

int main( void )
{
int prev_diff, diff, len;
int num = 11;
char str[10];

while(num<123456789)
    {
    prev_diff = 0;
    sprintf(str,"%d",++num);
    len = strlen(str)-1;
    for( ; len > 0; len-- )
        {
        diff = str[len] - str[len-1];
        if( prev_diff == 0 )
            {
            prev_diff = diff;
            }
        if( prev_diff != diff || diff < 1 )
            {
            break;
            }
        prev_diff = diff;
        }
    if ( len == 0 )
        {
        puts(str);
        }
    }
}
— Jacobinski
स्रोत
जब तक मैं कुछ याद नहीं कर रहा हूँ, चुनौती रेंज के अनुसार नहीं while(i<123456789)होना चाहिए while(i<=123456789)? इसके अलावा, आप इसे 6 बाइट्स में गोल्फ कर सकते हैं:p,l,d,i=11;main(){for(char s[10];i<=123456789;){sprintf(s,"%d",++i);p=0;for(l=strlen(s);--l>0;){d=s[l]-s[l-1];if(p<1)p=d;if(p^d|d<1)break;p=d;}if(l<1)puts(s);}}
— केविन क्रूज़सेन
@ केविनक्रूजसेन मैं सहमत होगा, हालांकि एक उच्च मूल्य का चयन करके सबसे अधिक संभावना एक-बाइट की तुलना का उपयोग कर सकती है; i<1e9।
— जोनाथन फ्रीच
इसके अलावा @KevinCruijssen, अगर मैं भूल नहीं कर रहा हूँ, l<1के लिए golfed किया जा सकता है !l, के रूप में lएक नकारात्मक मूल्य कभी नहीं पहुंचता है।
— जोनाथन फ्रेच
@JonathanFrech के बारे में अच्छी बात है i<1e9। और !lजब lहमेशा >=0सीआई अनुमान के लिए उचित लगता है (मैंने खुद सी में कभी भी प्रोग्राम नहीं किया है)।
— केविन क्रूज़सेन
@ केविनक्रूजसेन "i" स्प्रिंटफ () में बढ़ा हुआ है, जिससे हमें लूप में प्रवेश करने की अनुमति मिलती है जब मैं == 123456788, और इसे 123456789 के साथ छोड़ देता हूं। मैं उन बहुउद्देश्यीय लूपों को जोड़ूंगा और (l == 0) ) -> (l <1) अनुकूलन में, धन्यवाद :)
— याकूबिन्सकी
5

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

DIµEȧ>0Ȧ
Ç77#

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

एक बाइट @MrXcoder के लिए धन्यवाद बचाया!

यह बेहद अक्षम है, इसलिए यह TIO पर समय निकाल देगा, लेकिन अगर यह कभी खत्म हो जाता है, तो यह सही आउटपुट का उत्पादन करेगा। आप इसे छोटी संख्याओं के साथ यहाँ आज़मा सकते हैं: इसे ऑनलाइन आज़माएँ!

स्पष्टीकरण:

            # Helper link:
            #
D           # The Digits of 'n'
 I          # The increments (deltas, differences) between digits
  µ         # Give that array as an argument to the rest of this link:
   E        # Are all elements equal?
    ȧ       #   AND
     >0     # Are all elements greater then 0?
       Ȧ    # And is there at least one element?
            # (in the differences, so that numbers < 10 are false)
            #
            # Main link:
            #
 77#        # Return the first 77 'n's for which
Ç           #   The helper link is truthy
— जेम्स
स्रोत
1
ओह। मुझे इससे हराएं। +1
— caird कॉइनहेरिंगाहिंग
आपको $अपने सहायक लिंक के अंत में आवश्यकता नहीं है ।
— मिस्टर एक्सकोडर
ऐसा करने का एक स्पष्ट तरीका हैDIµ>0ȦȧE¶Ç77#
— एरिक द आउटगॉल्फ
4

05AB1E , 23 बाइट्स

•7=›ζ•FNS¥DËs0›PN11›&&–

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

•7=›ζ•इसे TIO पर समाप्त करने के लिए 7000 से बदलें , या इसे समाप्त करने से पहले "समाप्त" बटन को हिट करें, जिसके परिणामस्वरूप संख्या उस बिंदु तक मुद्रित होती है।

— जादू ऑक्टोपस Urn
स्रोत
इसका उपयोग करने की कोशिश करें:žh
— ओकेक्स
@ ओकेक्स मुझे नहीं लगता कि यह काम करेगा, यह सिर्फ एक विकल्प नहीं है '0123456789', 1357उदाहरण के लिए एक वैध संख्या भी है जिसे आपको आउटपुट करने की आवश्यकता है।
— एलिक्जेल आउट
@EriktheOutgolfer का मतलब था कि मैं बदल रहा हूँ•7=›ζ•
— ओक्क्स
@ ओकेक्स जो मेरे पास मूल रूप से था, लेकिन यह कुछ अजीब सामान (?) का कारण बनता है। पता नहीं क्यों, इसलिए मैंने इसे समाप्त कर दिया, जिसने लगातार काम किया।
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn आप शुरुआत में 0 को हटाने का प्रयास क्यों नहीं करते?
— ओकेक्स
4

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

Select[Range@123456789,Min[s=Union@Differences@IntegerDigits@#]>0&&Tr[1^s]==1&]

इसे ऑनलाइन आज़माएं! कम संख्या के साथ क्योंकि यह बहुत धीमा है

यहाँ एक और दृष्टिकोण है जो 1sec में सभी संख्याओं का निर्माण करता है

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

Union[FromDigits/@(F=Flatten)[Table[Partition[#,i,1],{i,2,9}]&/@Select[F[Table[Range[j,9,k],{j,9},{k,9}],1],Tr[1^#]>1&],2]]


इसे ऑनलाइन आज़माएं! एक सेकंड में सभी नंबर

— J42161217
स्रोत
4

भूसी , 14 13 बाइट्स

ÖifȯεuẊ≠Ṗ…"19

STDOUT को न्यूलाइन-अलग किए गए नंबर प्रिंट करता है। इसे ऑनलाइन आज़माएं!

H.PWiz से प्रेरणा के कारण -1 बाइट।

व्याख्या

ÖifȯεuẊ≠Ṗ…"19
         …"19  The string "19" rangified: "123456789"
        Ṗ      Powerset: ["","1","2","12","3",...,"123456789"]
  fȯ           Filter by function: (input is sublist, say "2469")
      Ẋ≠        Consecutive codepoint differences: [2,2,3]
     u          Remove duplicates: [2,3]
    ε           Is it a one-element list? No, so "2469" is dropped.
Öi             Sort the result by integer value, implicitly print separated by newlines.
— Zgarb
स्रोत
3

एपीएल (डायलॉग) , 37 28 बाइट्स

⍪x/⍨{1=≢∪2-/⍎¨⍕⍵}¨x←11+⍳1E9

इसे ऑनलाइन आज़माएं! (छोटी रेंज के साथ, टाइम-आउट के कारण)

कैसे?

x←11+⍳123456789- 11, 12... 1e9मेंx

¨ - प्रत्येक के लिए

    ⍎¨⍕⍵ - अंकों में विराम

    2-/ - अंतर सूची प्राप्त करें

    ∪ - अद्वितीय तत्व प्राप्त करें

    1=≢ - लंबाई == 1?

x/⍨ - बनाई गई रेंज पर मास्क के रूप में इसका इस्तेमाल करें

⍪ - और स्तंभित करें

— Uriel
स्रोत
3

बैच, 210 200 बाइट्स

कोई अनुकूलन नहीं, इतना धीमा - 12345 तक लगभग 25 सेकंड लगते हैं, इसलिए पूर्ण आउटपुट के लिए आपको लगभग 3 दिन इंतजार करना होगा।

@set z=@set/a
%z%c=12
:a
@echo %c%
:c
%z%c+=1&if %c%==123456790 exit/b
%z%n=c
%z%d=n%%10-n/10%%10
@if %d% leq 0 goto c
:d
%z%n=n/10
@if %n% leq 9 goto a
%z%e=n%%10-n/10%%10
@if %e%==%d% goto d
@goto c
— schnaader
स्रोत
3

जावा 8, 169 168 145 बाइट्स

v->{byte[]a;for(int i=9,d,l;++i<1e9;System.out.print(l<1?i+"\n":""))for(a=(i+"").getBytes(),d=0,l=a.length;--l>0&&d*(d^(d=a[l]-a[l-1]))<1&d>0;);}

पोर्ट ऑफ @ जेकोबिंस्की सी उत्तर (बाद में मैंने इसे थोड़ा सा गोल्फ दिया)।
-23 के लिए धन्यवाद बाइट्स @Nevay ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ। (यह अंत के पास थोड़ा धीमा है, इसलिए TIO पर अंतिम संख्या को प्रिंट नहीं करता है। यह स्थानीय रूप से लगभग 20 सेकंड में अंतिम संख्या प्रिंट करता है, हालांकि)।

v->{                         // Method with empty unused parameter and no return-type
  byte[]a;                   //  Byte-array
  for(int i=9,               //  Index integer, starting at 9
          d,                 //  Difference-integer
          l;                 //  Length integer
      ++i<1e9;               //  Loop (1) from 10 to 1,000,000,000 (exclusive)
      System.out.print(      //    After every iteration: print:
        l<1?                 //     If `l` is 0:
         i+"\n"              //      The current integer + a new-line
        :                    //     Else:
         ""))                //      Nothing
    for(a=(i+"").getBytes(), //   Convert the current item as String to a byte-array
        d=0,                 //   Reset the previous integer to 0
        l=a.length;          //   Set `l` to the length of the byte-array
        --l>0                //   Inner loop (2) from `l-1` down to 0 (exclusive)
        &&d*(d^(d=a[l]-a[l-1]))<1
                             //    As long as the previous difference is either 0
                             //    or the current diff is not equal to the previous diff
        &d>0;                //    and the current diff is larger than 0
    );                       //   End of inner loop (2)
                             //  End of loop (1) (implicit / single-line body)
}                            // End of method
— केविन क्रूज़सेन
स्रोत
1
145 बाइट्स:v->{byte[]a;for(int i=9,p,l;++i<1e9;System.out.print(l<1?i+"\n":""))for(a=(i+"").getBytes(),p=0,l=a.length;--l>0&&p*(p^(p=a[l]-a[l-1]))<1&p>0;);}
— नेवय
@ मुझे पता था कि इसे breakकिसी भी तरह से गिराने और इसे फॉर-लूप चेक में जोड़ने में सक्षम होना चाहिए , लेकिन यह मैं खुद के लिए नहीं आया था। ;) धन्यवाद!
— केविन क्रूज़सेन
2

05AB1E , 14 बाइट्स

TžhŸʒS¥D0›PsË&

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

— Okx
स्रोत
यही कारण है कि मैं मूल रूप से था, सिवाय मेरे पास 12žhŸʒS¥D0›PsË&, मैं इसे स्थानीय रूप से चलाने के लिए नहीं पा सकता था । क्या आप इसे वास्तव में निष्पादित कर सकते हैं?
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn यदि मैं संख्याओं को बदलने से पहले कोशिश करता हूं Ÿ, तो यह ठीक काम करता है
— Okx
मुझे अपने दूसरे नंबर को बदलने के बिना स्थानीय रूप से चलाने के लिए मिला, लेकिन यह अभी भी नहीं हो सकता है। Idk क्यों, मैं वास्तव में जानना चाहता हूं कि क्या अलग है।
— मैजिक ऑक्टोपस Urn
2

पायथन 2 , 103 97 95 बाइट्स

-2 बाइट्स @JonathanFrech को धन्यवाद

n=11
while n<1e9:
 n+=1;Q=`n`[1:]
 if`n`<Q>1==len({int(a)-int(b)for a,b in zip(`n`,Q)}):print n

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

— OVS
स्रोत
108 बाइट्स या 106 बाइट्स जो मेमोरी से बाहर निकलते हैं, लेकिन कम संख्या के साथ जांचे जा सकते हैं
— रॉड
95 बाइट्स ; दोहराया के लिए एक चर का उपयोग करना `n`[1:]।
— जोनाथन फ्रीच
2

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 105 बाइट्स

document.write(`<pre>`+(

_=>[for(x of s=`123456789`)for(y of s)for(z of s)if(x*z<10-y)s.replace(/./g,c=>c<y|(c-y)%z|c-y>x*z?``:c)]

)().join`\n`+`</pre>`);
स्निपेट का विस्तार करें

2 से 10 की लंबाई पर लूप (x अंतिम वर्ण का सूचकांक है और इसलिए लंबाई से 1 कम है), 1 से 9 तक अंक शुरू करते हैं और 1 से 9 तक कदम रखते हैं, फिर अंत अंक पर फिल्टर 10 से कम होने पर और यदि इसलिए अंक स्ट्रिंग से अंकों को फ़िल्टर करके परिणाम उत्पन्न करता है।

— नील
स्रोत
"रन कोड स्निपेट" एक त्रुटि की ओर जाता है:Uncaught SyntaxError: Unexpected token for
— schnaader
2
@schnaader क्या आप इसे फ़ायरफ़ॉक्स 30+ में चला रहे हैं? यह उत्तर गैर-मानक सरणी बोध वाक्यविन्यास का उपयोग करता है जो केवल फ़ायरफ़ॉक्स का समर्थन करता है।
— बिरजोलक्स्यूव १17
आह, टिप्पणी नहीं देखी, इसके लिए खेद है। क्रोम में चल रहा था, फ़ायरफ़ॉक्स में ठीक चलता है
— schnaader
1

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

पोर्ट ऑफ डेनिस का चतुर दृष्टिकोण ।

jjLkf!t{.+Tsm.cS9dtS9

यहाँ यह कोशिश करो!

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

j.f&!tl{K.+jZT*F>R0K77T

यह समय ऑनलाइन दुभाषिया पर निकलता है, लेकिन पर्याप्त समय और मेमोरी दिए जाने पर काम करता है।

कम संख्या के साथ इसे ऑनलाइन आज़माएं ।

— मिस्टर एक्सकोडर
स्रोत
1

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

लगभग नील के उत्तर के रूप में छोटा नहीं है , लेकिन मुझे लगा कि यह अभी भी पोस्ट करने लायक है।

एक '123456789'गैर-मिलान प्रविष्टियों के निर्माण का कार्य करता है जहां सभी गैर-मिलान प्रविष्टियों को छोटा और पूर्वनिर्मित किया जाता है 0, जिसके परिणामस्वरूप संख्यात्मक क्रम में क्रमबद्ध होता है और केवल 77 प्रासंगिक लोगों को रखता है।

_=>[...'123456789'].reduce((a,x)=>[...a,...a.map(y=>y[1]-y[0]+(y.slice(-1)-x)?'0':y+x)],['']).sort((a,b)=>a-b).slice(-77)

डेमो

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

— Arnauld
स्रोत
1

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

main(i,j,k,l){for(i=1;i<9;i++)for(j=8;j;j--)for(k=0;k<j/i;puts(""))for(l=0*k++;l<=i;)putchar(57-j+k*l++);}

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

असंगठित (पूर्व-निर्धारित) संस्करण:

int main() {
  int length, start_with, max_step, step, nth;
  for (length = 2; length <= 9; length++) {
    for (start_with = 1; start_with < 9; start_with++) {
      max_step = (9 - start_with) / (length - 1);
      for (step = 1; step <= max_step; step++) {
        for (nth = 0; nth < length; nth++) {
          putchar('0' + start_with + step * nth);
        }
        puts("");
      }
    }
  }
  return 0;
}
— TSH
स्रोत
1

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

सभी संभावित संख्याओं को उत्पन्न करके काम करता है: प्रत्येक वृद्धि के माध्यम से 8 से 1 (चर i) से लूप, 8 से 1 से प्रत्येक शुरुआती अंक (चर j) के माध्यम से छोरों, jऔर 10-i(चर k) के बीच प्रत्येक अंक के माध्यम से लूप और वर्तमान में tजोड़कर एक स्ट्रिंग उत्पन्न करता है । प्रत्येक चरण में आउटपुट सरणी में जोड़ा जाता है।ktt

(o=[],i=9)=>{while(--i){j=9;while(k=--j){t=""+k;while(k<10-i)o.push(t+=k+=i)}}return o.sort((a,b)=>a-b)}

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

f=

(o=[],i=9)=>{while(--i){j=9;while(k=--j){t=""+k;while(k<10-i)o.push(t+=k+=i)}}return o.sort((a,b)=>a-b)}

;
console.log(f().join("\n"))
स्निपेट का विस्तार करें

— Birjolaxew
स्रोत
0

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

थोड़ा जादू के साथ एक सीधा-आगे का दृष्टिकोण।

Array(123456790).fill().map((x,i)=>(''+i).split('')).map((a,i,d) => {d=a[1]-a[0];d>0&a.every((n,j)=>j<1||n-a[j-1]==d)?console.log(a.join('')):0})
स्निपेट का विस्तार करें

स्निपेट चलाने से मेमोरी की बहुत खपत होगी ...

— sshow
स्रोत
0

PHP, 85 84 बाइट्स

for(;++$d<9||++$a<9*$d=1;sort($r))for($x=$y=$a+1;10>$y+=$d;)$r[]=$x.=$y;print_r($r);

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

छँटाई लागत 17 बाइट्स। यह संस्करण अलग-अलग ऑर्डर किए गए परिणामों को प्रिंट करता है:

while(++$d<9||++$a<9*$d=1)for($x=$y=$a+1;10>$y+=$d;)echo"
",$x.=$y;
— टाइटस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.