एक अंगूठी सारों पर शासन के लिए। उन सभी को शामिल करने के लिए एक स्ट्रिंग


43

उद्देश्य: आउटपुट एक स्ट्रिंग जिसमें हर सकारात्मक पूर्णांक 1000 से नीचे सख्ती से होता है।

स्पष्ट उत्तर उनमें से हर एक को मिलाना होगा, और यह 2890 अक्षर (थैंक्स मैनेटवर्क) का निर्माण करेगा, इस तरह के आसान उत्तर से बचने के लिए, स्ट्रिंग की लंबाई 1500 वर्णों के नीचे होनी चाहिए। यहाँ एक सीधा जावा कोड है जो 1200 वर्ण स्ट्रिंग का आउटपुट देता है।

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;

import static org.junit.Assert.assertTrue;

/**
 * Created with IntelliJ IDEA.
 * User: fab
 * Date: 05/11/13
 * Time: 09:53
 * To change this template use File | Settings | File Templates.
 */
public class AStringToContainThemAll {

    @Test
    public void testsubStrings() throws Exception {
        String a = generateNewString();
        boolean cool = true;
        for (int i = 0; i < 1000; i++) {
            assertTrue(a.contains(Integer.toString(i)));
        }
    }

    private String generateNewString() {
        List<Integer> myTree = new ArrayList<Integer>();
        String finalString = new String("100");
        for (int i = 10; i < 1000; i++) {
            myTree.add(i);
        }
        while (myTree.size() > 0) {
            if (finalString.contains(Integer.toString(myTree.get(0)))) {
                myTree.remove(0);
            } else {
                String substringLong = finalString.substring(finalString.length() - 2, finalString.length());
                boolean found = false;
                loop:
                for (Integer integer : myTree) {
                    if (integer.toString().startsWith(substringLong) && !finalString.contains(integer.toString())) {
                        finalString = finalString.concat(integer.toString().substring(2, 3));
                        myTree.remove(integer);
                        found = true;
                        break loop;
                    }
                }
                if(! found){
                    finalString = finalString.concat(myTree.get(0).toString());
                    myTree.remove(0);
                }
            }


        }
        return finalString;
    }
}

सबसे छोटा कोड जीत, सबसे कम स्ट्रिंग के लिए बोनस बिंदु!


11
इष्टतम स्ट्रिंग 1002 वर्ण लंबा है।
पीटर टेलर

8
मूल रूप से आप डी ब्रूजन अनुक्रम के लिए पूछ रहे हैं B(10, 3), लेकिन क्योंकि आप चक्रीय रैपिंग की अनुमति नहीं देते हैं इसलिए पहले दो पात्रों को दोहराना आवश्यक है।
पीटर टेलर

3
लेकिन मैं चाहता हूं कि स्ट्रिंग में 1, 2 या 56, जरूरी नहीं कि 001 002 और 056 हों।
फेबिनआउट

6
आपकी समस्या को हल करना असंभव है क्योंकि आपने कहा कि संख्या पूर्णांक नहीं है । 1000 से नीचे की सभी सकारात्मक संख्याओं को समायोजित करने के लिए स्ट्रिंग को अनंत लंबाई का होना होगा।
रामचंद्र आप्टे

11
@ रामचंद्रअप्ते और अभी भी अनंत लंबाई के साथ कोई भी स्ट्रिंग सबसे अधिक संख्या में गायब होगी;;
हावर्ड

जवाबों:


19

गोल्फस्क्रिप्ट - 13 बाइट्स, 1315 आउटपुट

991,{`.$2>>},

उपरोक्त उन नंबरों को 0-990 से चुनता है, जिनका पहला अंक संख्या का सबसे बड़ा अंक है, यानी सॉर्ट किए गए स्ट्रिंग प्रतिनिधित्व का अंतिम अंक, स्ट्रिंग की तुलना में शाब्दिक रूप से कम है। तर्क निम्नलिखित है:

3 अंकों वाले नंबर के लिए एबीसी , अगर एक नंबर के सबसे बड़े अंकों नहीं है, संख्या, छोड़ी नहीं जा मेरी क्योंकि यह बाद में दो मामलों में से एक में शामिल किया जाएगा:

  1. b <c (उदाहरण 123 )
    क्योंकि c सबसे बड़ा अंक है, संख्या टैक्सी को छोड़ नहीं दिया जाएगा। इस उदाहरण में 312 को छोड़ दिया जाएगा, और न ही अगला मूल्य 313 होगा , जिसे समाप्‍त होने पर ( 312 313 ) में 123 शामिल हैं।

  2. b largest c (उदाहरण 132 )
    क्योंकि b सबसे बड़ा अंक है, संख्या bca को छोड़ा नहीं जाएगा। इस उदाहरण में 321 को छोड़ा नहीं जाएगा, और न ही अगले मूल्य 322 को , जिसे समाप्‍त होने पर ( 321 322 ) में 132 शामिल होंगे। यदि b = c (उदाहरण 122 ), यह मामला भी लागू होता है। मान bca को पहले की तरह स्किप नहीं किया जाएगा, और क्योंकि a आवश्यक रूप से b से कम है, bc <a + 1> को भी नहीं छोड़ा जाएगा। इस उदाहरण में, 221 222 में 122 शामिल हैं।

क्योंकि उपरोक्त कोड तीसरे अंक का परीक्षण करता है, बल्कि अंतिम रूप से सख्ती से, परिणाम में 0-99 से सभी मान शामिल हैं। हालाँकि, 1-99 से मानों को छोड़ दिया जा सकता है, क्योंकि यदि प्रत्येक 3-अंक अनुक्रम मौजूद है, तो प्रत्येक 1-अंक और 2-अंक अनुक्रम भी मौजूद होना चाहिए।

991-999 के मान भी छोड़े जा सकते हैं, क्योंकि ( 909 910 , 919 920 , ... 989 990 ) से उत्पन्न होते हैं ।

उत्पादन के 1315 बाइट्स पर, यह आराम से 1500 से कम की समस्या के विनिर्देश के तहत है।

आउटपुट:

0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

भिन्नता # 1

14 बाइट्स, 1233 आउटपुट

991,{`.$-1>>},

तुलना के लिए अंतिम अंक को कड़ाई से चुनने के बजाय, तीसरे के बजाय, 100 से कम अनावश्यक मानों को समाप्त कर दिया जाता है, जिसके परिणामस्वरूप स्ट्रिंग को छोटा कर दिया जाता है।

101120212230313233404142434450515253545560616263646566707172737475767780818283848586878890919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

भिन्नता # 2

16 बाइट्स, 1127 आउटपुट

991,99>{`.$2>>},

99 से कम पहले से सभी मानों को बंद करके , परिणामी स्ट्रिंग को और भी छोटा किया जा सकता है।

99100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

गोल्फस्क्रिप्ट - 19 बाइट्स, 1016 आउटपुट

910,99>{`.2$\?)>+}/

उपरोक्त संख्या 99 से 909 तक है , जो पहले से प्रकट नहीं हुई है ( 909 सामान्य रूप से इस तरह जोड़ा गया अंतिम मूल्य होगा) को जोड़ते हुए। बढ़ते 99 सामने से एक अनुकूलन की जरूरत से बचने के लिए है 910 पीछे।

आउटपुट:

99100101102103104105106107108109111112113114115116117118119120122123124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190192193194195196197198199200202203204205206207208209222223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333334335336337338339340344345346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444445446447448449450455456457458459460465466467468469470475476477478479480485486487488489490495496497498499500505506507508509555556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666667668669670677678679680687688689690697698699700707708709777778779780788789790798799800808809888889890899900909

गोल्फस्क्रिप्ट 26 बाइट्स, 999 आउटपुट

909.,99>{`..$.2><3$@?+>+}/

ध्यान दें कि 1016 चरित्र स्ट्रिंग पिछले समाधान द्वारा उत्पादित लगभग इष्टतम है, में से प्रत्येक के कई के लिए दो अतिरिक्त अंक होने के अलावा 111 (यानी 11111के बजाय 111, 22222के बजाय 222, आदि)। इन अतिरिक्त अंकों को हटाकर (इन मानों में से प्रत्येक के बजाय केवल एक अंक को तीन से घटाकर) हल किया जा सकता है, और 909आगे की ओर घूमते हुए, इसे हटा दिया जाता है 9(यह पिछले संस्करणों से भिन्न होता है, जो 9100इसके बजाय पीछे की ओर चला जाता है) )।

अनियंत्रित और टिप्पणी:

909.,99>  # add 909 to the stack, and duplicate
          # create an array from 0..908, and 
          # remove the first 99 elements (99..908)
{
  `..     # stringify, duplicate twice

  $.2><   # non-divisibility by 111 check
          # true if the last char of the sorted
          # string is greater than the first char

  3$@?    # first position of this number in
          # the total string so far (-1 if not found)

  +>      # add the two previous results,
          # and slice from that point
          # (see explanation below)

  +       # concat what remains to the total string

}/        # loop over the set

यह चुनने के लिए कि कौन से वर्णों को जोड़ा गया है तर्क तीन मामलों का अनुसरण करता है:

  1. 111 the n , n The s
    पहले चेक से मान 1 है , और दूसरे -1 से
    सूचकांक 0 से स्लाइस शुरू होगा; यह पूरी स्ट्रिंग लौटाएगा।
  2. 111एन , एनs
    पहली जांच से मूल्य है 1 , और दूसरा कुछ से ≥ 2
    टुकड़ा सूचकांक will 3 से घूरना शुरू कर देगा; यह एक खाली स्ट्रिंग लौटेगा।
  3. 111 | n , ns
    पहली जांच से मूल्य है 0 , और दूसरा से -1
    सूचकांक -1 से टुकड़ा शुरू होगा; यह अंतिम पात्र को ही लौटाएगा।

तर्क का योग यह है कि कोई भी मूल्य जो अभी तक प्रकट नहीं हुआ है, पूरे में जोड़ा जाएगा - जब तक कि यह 111 का गुणक न हो , उस स्थिति में केवल एक वर्ण ही जोड़ा जाएगा। अन्य सभी मूल्यों की अनदेखी की जाएगी।

ध्यान दें कि उत्पादित स्ट्रिंग पीटर टेलर के उत्तर द्वारा उत्पादित इष्टतम से भिन्न है ।

इतिहास:

899,{101+.111%{`.2$\?0<*}{3/9%}if+}/

899,{101+`.2$\?0<\.~111%2*)<*+}/0

899,{101+`.2$\?0<\..2>-!2*>*+}/0

899,{101+`...2>|,1|<2$@?0<*+}/0

999,{`..$.2>>2*>2$@?0<*+}/3>0

899,{101+`..$.2><3$@?+>+}/0

आउटपुट:

909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900

45

GolfScript ( 35 31 26 वर्ण)

10,{:x),{:&x=x+,{x&@}/}/}/

आउटपुट है

000100110111200201210211220221222300301302310311312320321322330331332333400401402403410411412413420421422423430431432433440441442443444500501502503504510511512513514520521522523524530531532533534540541542543544550551552553554555600601602603604605610611612613614615620621622623624625630631632633634635640641642643644645650651652653654655660661662663664665666700701702703704705706710711712713714715716720721722723724725726730731732733734735736740741742743744745746750751752753754755756760761762763764765766770771772773774775776777800801802803804805806807810811812813814815816817820821822823824825826827830831832833834835836837840841842843844845846847850851852853854855856857860861862863864865866867870871872873874875876877880881882883884885886887888900901902903904905906907908910911912913914915916917918920921922923924925926927928930931932933934935936937938940941942943944945946947948950951952953954955956957958960961962963964965966967968970971972973974975976977978980981982983984985986987988990991992993994995996997998999

(1020 वर्ण) यह लिंडन शब्द समवर्ती दृष्टिकोण पर एक प्रकार है: आदिम 1-चार शब्दों का उपयोग करने के बजाय यह छोटे कोड के लिए 111 के गुणक का उपयोग करता है, लेकिन उन संख्याओं की पुनरावृत्ति; और संयुग्मता समूहों के न्यूनतम तत्वों का उपयोग करने के बजाय यह अधिकतम तत्वों का उपयोग करता है, क्योंकि यह छोरों को छोटा करता है।


10,:^{:x^>{x.@:&<+^>{.x>{x&@}*}/}/}%3>0.

40 वर्णों पर (शायद अभी भी सुधार किया जा सकता है) एक इष्टतम स्ट्रिंग उत्पन्न करता है, जिसकी लंबाई 999 वर्ण है:

100200300400500600700800901101201301401501601701801902102202302402502602702802903103203303403503603703803904104204304404504604704804905105205305405505605705805906106206306406506606706806907107207307407507607707807908108208308408508608708808909109209309409509609709809911121131141151161171181191221231241251261271281291321331341351361371381391421431441451461471481491521531541551561571581591621631641651661671681691721731741751761771781791821831841851861871881891921931941951961971981992223224225226227228229233234235236237238239243244245246247248249253254255256257258259263264265266267268269273274275276277278279283284285286287288289293294295296297298299333433533633733833934434534634734834935435535635735835936436536636736836937437537637737837938438538638738838939439539639739839944454464474484494554564574584594654664674684694754764774784794854864874884894954964974984995556557558559566567568569576577578579586587588589596597598599666766866967767867968768868969769869977787797887897987998889899900

इसे करने की कोशिश करना उल्टा तार 111 के गुणकों को छोड़ने के साथ समस्याओं में चलता है।

यह देखने के लिए कि 999 इष्टतम लंबाई है (चूंकि मेरी संक्षिप्त टिप्पणी ऊपर सभी को मना नहीं करती है), पूर्ण डे ब्रूजन अनुक्रम से शुरू होती है (जिसे एक चक्रीय स्ट्रिंग के रूप में लिया जाता है) में 0 से 9 तक हर 3-अंकों का वर्ण होता है। उनमें से 1000 हैं, यह कम से कम 1000 वर्ण लंबा होना चाहिए; यह ठीक है कि 1000 वर्ण लंबे हो सकते हैं, आमतौर पर एक ग्राफ पर एक यूलरियन वॉक द्वारा सिद्ध किया जाता है, जिसके नोड्स xy10 अंकों के साथ दो-अंकीय अनुक्रम होते हैं, प्रत्येक को एक अंक के साथ लेबल किया जाता है z, जो इसे ले xyजाता है yz

हमें सीक्वेंस की शुरुआत की आवश्यकता नहीं है 0, इसलिए एक डे ब्रूजन अनुक्रम दिया 000गया जिसे हम अंत में डाल सकते हैं । तब हमें ऐसे किसी भी क्रम की आवश्यकता नहीं होती है जो शुरुआत में गोल-गोल लपेटते हैं, लेकिन 0अंक से पहले शुरू होने वाले अनुक्रम को पूरा करने के लिए हमें दो में से दो की आवश्यकता होती है 000, इसलिए हम 999-वर्ण स्ट्रिंग प्राप्त करने के लिए उनमें से एक को हटा सकते हैं। हर बचे 0का उपयोग एक संख्या में किया जाता है, जो शुरू नहीं होता है 0


8
यह वास्तव में प्रभावशाली है !!
फेबिनआउट

मैं एक फ़िल्टरिंग या जेनरेटर दृष्टिकोण का उपयोग करना पसंद करूंगा। छद्म-लिंडन दृष्टिकोण के लिए मुझे 32 वर्णों के लिए जनरेटिव दृष्टिकोण मिला है: यह 10,:^{:x^>{x.@:&<+^>{x&@}/}/}/0.समझना कि सच्चे लिंडन शब्दों 10,:^{:x^>{x.@:&<+^>{.x>{x&@}*}/}/}%3>0.के लिए इष्टतम स्ट्रिंग के लिए (40 वर्ण) देता है ।
पीटर टेलर

क्या आप 100 से नीचे की संख्या के लिए अग्रणी शून्य का उपयोग नहीं करके इष्टतम स्ट्रिंग को छोटा कर सकते हैं?
रैंडम 832

1
@ Random832 मुझे पूरा यकीन है कि आप नहीं कर सकते। आपको 100, 200, ... 900 की संख्याओं को शामिल करना होगा, इसलिए न्यूनतम स्ट्रिंग निश्चित रूप से 00X के आठ आवेशों में होने वाली है (एक सबसे ऊपर दाईं ओर हो सकता है)। ध्यान दें कि दिए गए इष्टतम स्ट्रिंग में "001" शामिल नहीं है।
tttppp

2
आम तौर पर मैं उस कोड को अपवोट नहीं करता, जिसे मैं नहीं समझता, लेकिन इस मामले में मैं इसे बढ़ा रहा हूं क्योंकि मुझे समझ नहीं आ रहा है। वाहवाही।
बेन जैक्सन

29

GolfScript, 17 अक्षर

999,{`1$1$?0<*+}/

प्रत्येक संख्या को जोड़ने के लिए सादा दृष्टिकोण यदि स्ट्रिंग में पहले से मौजूद नहीं है (नोट: 999 की जाँच या जोड़ा नहीं गया है, लेकिन पहले से ही आउटपुट में निहित है)।

आउटपुट 1133 वर्ण है:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

20

मेरे पास कोई कोड नहीं है, लेकिन मुझे लगा कि कोई व्यक्ति इस सहज प्रमाण की सराहना कर सकता है कि 999 वर्ण आउटपुट की लंबाई से कम है:

सबसे पहले, प्रत्येक 1- और 2-अंकीय संख्या 3-अंकीय संख्या का हिस्सा है, इसलिए 100 से कम सब कुछ अनदेखा करें। 100-999 समावेशी 900 3-अंकीय संख्या है।

समस्या को हल करने का सबसे इष्टतम तरीका यह है कि हर चरित्र का यथासंभव उपयोग किया जाए। इसका मतलब यह है कि संख्या इस तरह से ओवरलैप हो सकती है:

123
 234
  345

इसलिए पहली संख्या में 3 वर्ण जोड़े जाएंगे, और प्रत्येक बाद की संख्या में 1 वर्ण जोड़ा जाएगा। यह एक कम बाउंड के रूप में 3 + 899 = 902 अक्षर देता है।

हालांकि, जब कोई शून्य होता है, तो हम इसका उपयोग 3-अंकों की नई संख्या शुरू करने के लिए नहीं कर सकते हैं। हम इसे एक और 3-अंकीय संख्या के बीच में फिर से उपयोग कर सकते हैं, जब तक कि यह एक और शून्य द्वारा पीछा नहीं किया जाता है:

120
 203  <- Ok.
  034 <- not a number 100-999.

परंतु:

100
 002  <- not a number 100-999.
  023 <- not a number 100-999.

इसलिए, प्रत्येक शून्य जो आउटपुट में प्रकट होता है, आउटपुट को 1 वर्ण द्वारा विस्तारित करता है - अंतिम दो वर्णों को छोड़कर जो शून्य हो सकते हैं क्योंकि वे आगे की संख्याओं को ओवरलैप नहीं करते हैं:

???
 ??0
  ?00

बीच में सख्ती से एक शून्य के साथ 81 संख्याएं हैं (?!?), 81 अंत में सख्ती से एक शून्य के साथ (?? 0), और 9 के साथ दो शून्य (? 00)।

प्रत्येक बनाम 0 नंबर एक 0 के साथ एक शून्य साझा कर सकते हैं? संख्या या ए? 00 संख्या, लेकिन दोनों नहीं। ? 0? और! 00 कभी भी शून्य साझा नहीं कर सकता है, इसलिए आउटपुट में कम से कम 81 + 9 * 2 शून्य होना चाहिए।

यह ३ + + ९९ + *१ + ९ * २ - २ = ९९९ अक्षरों की एक निचली सीमा देता है।

माफी अगर यह ऑफ-टॉपिक माना जाता है, लेकिन यह एक टिप्पणी में फिट होने के लिए बहुत लंबा था।


1
सर उठाने के लिए धन्यवाद! यह थोड़े अजीब है कि स्ट्रिंग जिसमें 999 से कम हर पूर्णांक होता है, 999 वर्ण लंबा होता है।
फबिनआउट 10

1
यह भी देखें: en.wikipedia.org/wiki/De_Bruijn_sequence
लियोरी

1
यह देखने के लिए थोड़े मज़ेदार है कि एक स्ट्रिंग में हर नंबर को 999 तक संग्रहीत करने से यह 999 वर्णों तक लंबा हो जाता है। अगर मैं गलत हूं तो मुझे सुधारो लेकिन मेरा मानना ​​है कि हर नंबर को 99 तक संग्रहीत करने से यह 100 वर्ण लंबा हो जाता है।
फेबिनआउट

2
इसी तर्क से निचली सीमा 2 + 89 + 9 - 1 = 99 है, लेकिन यह साबित नहीं होता है कि 99 संभव है, केवल 98 नहीं।
एलिस्टेयर बुक्सटन

17

पर्ल, ३ ३४ ३३ 32 (1136 1132 अक्षर)

for$@(1..999){$_.=$@x!/$@/}print

$ के लिए @ (1..999) {$ _। = $ @ अगर! / $ @ /} प्रिंट

$ i (1..999) के लिए {$ _। = $ i if! / $ i /} प्रिंट

for (1..13) {$ s। = $ _ अगर $ s! ~ / $ _ /} $ s प्रिंट करें

आउटपुट:

12345678910111314151617181920212224252627282930323335363738394043444647484950545557585960656668697076777980878890991001021031041051061071081091101121141151161171181191201241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901931941951961971981992002032042052062072082092192202212232252262272282292302312352362372382392402432442452462472482492502532542552562572582592602632642652662672682692702732742752762772782792802832842852862872882892902942952962972982993003043053063073083093113293303323343363373383393403423463473483493503543553563573583593603643653663673683693703743753763773783793803843853863873883893903953963973983994004054064074084094224394404434454474484494504534574584594604654664674684694704754764774784794804854864874884894904964974984995005065075085095335495505545565585595605645685695705765775785795805865875885895905975985996006076086096446596606656676696706756796806876886896906986997007087097557697707767787807867907977998008098668778798808878888978988999009089329439549659769799879891000

कम स्ट्रिंग: ३ 37 ३ 37 34 (1020 अक्षर):

$_.=$@x!/$@/while$@=--$@%1e3;print

के लिए ($ @ = 1e3; $ @ -;) {$ _ = $ @ अगर / $ @ /।!} प्रिंट

के लिए ($ i = 1e3; $ i -;) {$ _। = $ i if /! $ i /} प्रिंट

आउटपुट:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

अभी भी शुरुआत में 99999 के दोहराव से खुश नहीं हैं! मुझे लगता है कि कई और चेक हालांकि बहुत अधिक कोड बनाएंगे ...

संपादित करें: @Peter टेलर से जोड़ा गया सुझाव

संपादित 2: @primo से कुछ बेहतरीन सुझाव! धन्यवाद


2
1000 को 1e3 के रूप में लिखने की अच्छी चाल है, लेकिन मुझे लगता है कि यह व्यर्थ है। प्रश्न कहता है कि "सख्ती से 1000 से नीचे", इसका मतलब 999 तक और इसमें शामिल होगा। (नमूना कोड भी 0..999 की प्रक्रिया करता है।)
मैनटवर्क

एक उत्कृष्ट बिंदु! मेरे पास शुरू करने के लिए एक अलग लूप था, मैंने इसके अनुसार संशोधन किया है! धन्यवाद!
डोम हेस्टिंग्स

3
यदि आप अपने चर के लिए एक गैर-अक्षर वर्ण का उपयोग करते हैं तो क्या आप अंतरिक्ष को हटा सकते हैं?
पीटर टेलर

आह, मैं कर सकता हूँ! धन्यवाद!
डोम हेस्टिंग्स

2
कुछ और मामूली सुधार: इसके बजाय $_.=$@if!/$@/, आप स्ट्रिंग पुनरावृत्ति का उपयोग कर सकते हैं $_.=$@x!/$@/forएक के द्वारा बदल दिया जा सकता है while: एक बयान आपरिवर्तक के रूप में, एक सापेक्ष का उपयोग कर...while$@=--$@%1e3
Primo

10

एपीएल (20, आउटपुट: 1020)

{∨/⍺⍷⍵:⍵⋄⍵,⍺}/⍕¨⍳999

स्पष्टीकरण:

  • {∨/⍺⍷⍵:⍵⋄⍵,⍺}: यदि की सबस्ट्रिंग है , वापसी , और वापसी⍵,⍺
  • /: कम करना
  • ⍕¨: प्रत्येक का स्ट्रिंग प्रतिनिधित्व
  • ⍳999: से पूर्णांकों 1के लिए 999

आउटपुट:

9999989979969959949939929919909889879869859849839829819809789779769759749739729719709689679669659649639629619609589579569
      55954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913
      91291191090890790690590490390290190088888788688588488388288188087787687587487387287187086786686586486386286186085785
      68558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108
      07806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735
      73473373273173072672572472372272172071671571471371271171070670570470370270170066666566466366266166065565465365265165
      06456446436426416406356346336326316306256246236226216206156146136126116106056046036026016005555545535525515505445435
      42541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411
      410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

एपीएल (41, आउटपुट: 999)

'0',⍨⊃{⍵,⍺⍴⍨(1=⍴∪⍺)∨3×~∨/⍺⍷⍵}/⌽⍕¨100+⍳898

स्पष्टीकरण:

  • ⌽⍕¨100+⍳898: ('999' '998' ... '101')(रिवर्स ऑर्डर में, क्योंकि एपीएल में बाएं से दाएं कमी आती है, अर्थात F/a b c ≡ a F (b F c))
  • /: कम करना
  • ⍵,⍺⍴⍨: सही तर्क, उसके बाद Nबाएं तर्क के पहले अक्षर, जहां Nहै:
  • 3×~∨/⍺⍷⍵: 3यदि का विकल्प नहीं है , अन्यथा0
  • (1=⍴∪⍺): 1यदि केवल एक अद्वितीय वर्णक है, अन्यथा0
  • : पिछले दो मूल्यों का सबसे बड़ा सामान्य विभाजक, इसलिए: 1यदि पहले से ही नहीं है और केवल एक अद्वितीय चरित्र है, 3अगर पहले से ही नहीं है, लेकिन एक से अधिक अद्वितीय चरित्र हैं, 0अन्यथा।
  • '0',⍨: परिणाम के अंत में एक शून्य जोड़ें

आउटपुट:

10110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451
      46147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188
      18919019219319419519619719819920020220320420520620720820922232242252262272282292302332342352362372382392402432442452
      46247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294
      29529629729829930030330430530630730830933343353363373383393403443453463473483493503543553563573583593603643653663673
      68369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444544644744844945045545645
      74584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566
      56756856957057657757857958058658758858959059659759859960060660760860966676686696706776786796806876886896906976986997
      00707708709777877978078878979079879980080880988898908999009099100

8

रूबी: 50 46 अक्षर (1020 वर्ण आउटपुट)

s=""
999.downto(0){|i|s[n=i.to_s]||s+=n}
$><<s

नमूना रन:

bash-4.1$ ruby -e 's="";999.downto(0){|i|s[n=i.to_s]||s+=n};$><<s'
999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

परीक्षण चालन:

bash-4.1$ ruby -e 's="";999.downto(0){|i|s[n=i.to_s]||s+=n};$><<s' | ruby -ne 'p (0..999).reject{|i|$_[i.to_s]}'
[]

रूबी: 102 97 अक्षर (999 वर्ण आउटपुट)

s=""
999.downto(0){|i|s[n=i.to_s]||[2,1].map{|j|n[0,j]==s[-j,j]&&s+=n[j,9]and break}&&s+=n}
$><<s

नमूना रन:

bash-4.1$ ruby -e 's="";999.downto(0){|i|s[n=i.to_s]||[2,1].map{|j|n[0,j]==s[-j,j]&&s+=n[j,9]and break}&&s+=n};$><<s'
999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110100

परीक्षण चालन:

bash-4.1$ ruby -e 's="";999.downto(0){|i|s[n=i.to_s]||[2,1].map{|j|n[0,j]==s[-j,j]&&s+=n[j,9]and break}&&s+=n};$><<s' | ruby -ne 'p (0..999).reject{|i|$_[i.to_s]}'
[]

अच्छा विचार 999 से 0 पर जाना है और विपरीत तरीके से नहीं। इसके साथ, मेरी जावा विधि 1048 वर्ण स्ट्रिंग (1200 के बजाय) को आउटपुट करती है।
फबिनौट

1
यदि आप कोड लंबाई के बारे में चिंतित हैं और आउटपुट लंबाई नहीं है, तो आप पहले एक स्ट्रिंग रेंज का उपयोग करके सुधार कर सकते हैं। (?0..?9*3).map{|i|$/[i]||($><<i;$/+=i)}शायद कुछ ऐसा ?
पॉल प्रेस्टिज

5

जावास्क्रिप्ट, ३ ९

for(k=i="999";~k.indexOf(--i)?i:k+=i;);

1020 वर्ण आउटपुट:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100


सत्यापन: for(i=0;i<1000;i++)console.assert(k.indexOf(i)>=0)


5

गणितज्ञ ( 62 64 वर्ण, 1002 आउटपुट)

क्योंकि यह एक देशी फ़ंक्शन का उपयोग करता है, मैं स्क्रैच से छोटे समाधानों की सभी अधिक सुंदरता की सराहना करता हूं। आउटपुट 1002 वर्ण लंबा है।

<< Combinatorica`
"79" <> DeBruijnSequence["0"~CharacterRange~"9", 3]

"799798787770760750740730720710980970960950940930920910108908708608508408308208889998988081009909008007006005004003002000190180170160150140130120119118117116115114113112912812712612512412312213913813713613513413313214914814714614514414314215915815715615515415315216916816716616516416316217917817717617517417317218918818718618518418318219919819719619519419319212111029028027026025024023022922822722622522422392382372362352342332492482472462452442432592582572562552542532692682672662652642632792782772762752742732892882872862852842832992982972962952942932322202103903803703603503403393383373363353349348347346345344359358357356355354369368367366365364379378377376375374389388387386385384399398397396395394343330320310490480470460450449448447446445945845745645546946846746646547947847747647548948848748648549949849749649545444043042041059058057056055955855755695685675665795785775765895885875865995985975965655505405305205106906806706696686679678677689688687699698697676660650640630620610790780779778978879"

1
आप 799 और 997 से गायब हो रहे हैं। देखें ideone.com/d07bG2 (या अपनी खुद की जांच लिखें)
जस्टिन 20

अच्छी पकड़। डिफ़ॉल्ट रूप से, DeBruijnSequenceचक्रीय आवरण को ग्रहण करता है। "79" को प्राथमिकता देते हुए, अंतिम दो अंक समस्या को हल करते हैं।
डेविड नोव

4

गणितज्ञ, ५१ वर्ण

""<>Table[ToString/@({i,j,k}-1),{i,10},{j,i},{k,i}]

आउटपुट (1155 वर्ण):

000100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999

यह क्या करता है?
फबिनौत

1
यह उस प्रपत्र की सूचियों की एक सूची बनाता है {i, j, k}जहां i0 से 9 तक है और j, kसे छोटे हैं i। फिर यह सूची को एक स्ट्रिंग में परिवर्तित करता है।
एलेफाल्फा

4

पायथन - 53 63, 1134 आउटपुट

यह सुंदर जानवर है, लेकिन यह वैध है। हां इसमें एक अग्रणी शून्य है, लेकिन यह दो वर्णों को नहीं होने से बचाता है range(1,1000)

s=''
for i in range(1e3):s+=`i`*(not`i`in s)
print s

उपरोक्त कॉल DeprecationWarningमें 1e3 के उपयोग से अधिक फेंकता है range(), लेकिन यह 1000 का उपयोग करके एक चरित्र बचाता है।

की लागत पर स्ट्रिंग को उल्टा करके, थोड़ा अधिक इष्टतम लंबाई आउटपुट संस्करण भी है 65 अक्षर (रेस और टिप्स के लिए धन्यवाद) :

पायथन - 58, 1021 आउटपुट

s=''
for i in range(999,9,-1):s+=`i`*(not`i`in s)
print s

1
मुझे लगता है कि आपके पहले कार्यक्रम की आउटपुट लंबाई 1133 है, न कि 1132। पायथन 2 में (लेकिन पायथन 3 नहीं), आप बैकटिक्स का उपयोग करके 54 वर्णों को कोड को छोटा कर सकते हैं :for i in range(999):s+=`i`*(not`i`in s)
रिस करें।

Wot? उन्होंने बैकटैक्स निकाला? गुइडो एक आई हेट पर्ल और सब कुछ है कि यह दिन की तरह लग रहा है जब निर्णय लेने के लिए क्या रखना चाहिए रहा है।
वॉरेन पी

1
आप range(999,99,-1)इसके बजाय का उपयोग करके एक वर्ण द्वारा छोटा कर सकते हैं range(1000)[::-1]
फिल्मकार

और रिस द्वारा टिप अभी भी मदद करता है, str(i)*(str(i)not in s)की तुलना में थोड़ा छोटा है i=str(i);s+=[i,''][i in s];)
17

@filmor को छोटे और छोटे को फिर से इस्तेमाल करके बनाया गया1e31000

2

के, ३३

{$[#ss[x]@y;x;,/x,y]}/["";$!1000]

मूल रूप से हावर्ड समाधान के रूप में एक ही - 1133 अक्षर।

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

2

जावा- 126 98 चार्ट्स (जावा 6)

class b{static{String s="";for(int a=999;a>0;a--)s=s.contains(""+a)?s:s+a;System.out.println(s);}}

आउटपुट (1020 वर्ण):

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

एक अच्छे तक पहुँच सकते हैं ( पीटर टेलर के अनुसार , लेकिन बाद में उन्होंने कहा कि 999 इष्टतम था) स्ट्रिंग कुछ लंबाई जोड़कर ( 147 118 के लिए +20 चार्ट ):

class b{static{String s="";for(int a=999;a>0;a--)s=s.contains(""+a)?s:(a+1)%111==0?s+a%10:s+a;System.out.println(s);}}

आउटपुट (1002 चार्ट):

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110101100

संपादित करें : जावा 6 इंगित करने के लिए Fabinout के लिए धन्यवाद कि 28 चार्ट बचा सकते हैं।


यदि आप चाहें, तो आप java 6 का संकलन कर सकते हैं और System.out.println () के बजाय एक स्थिर ब्लॉक का उपयोग कर सकते हैं !!
फेबिनआउट

@ फ़ैनबाउट क्या आपका मतलब एक के बजाय है public static void main(String[]a)? (है कि मेरे कोड बदल जाएगा ...public static void main(String[]c){...करने के लिए ...static{...)
जस्टिन

हां मैं करता हूं। आप जावा 6 के साथ कोशिश कर सकते हैं
फेबिनआउट

Btw, यदि आप अपने प्रोग्राम को क्रैश नहीं करना चाहते हैं, तो आपको अपने स्थिर ब्लॉक के अंत में निकास () का उपयोग करना चाहिए। भले ही यह दुर्घटनाग्रस्त नहीं होने के लिए गोल्फ में आवश्यक नहीं है।
फेबिनआउट

2

विंडोज पॉवरशेल - 40, 1020 आउटपुट

999..0|%{$s+=if(!($s-match$_)){"$_"}};$s

आउटपुट:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

2

हास्केल, 75 बाइट्स - 1002 आउटपुट

एक छलनी दृष्टिकोण जो एक न्यूनतम समाधान लौटाता है।

(\n->head.filter(\s->and[show k`isInfixOf`s|k<-[1..n]]).map show$[1..])1000

ध्यान दें कि यह समाधान अव्यावहारिक रूप से धीमा है।


आप के आयात शामिल करने की जरूरत Data.Listके लिए isInfixOf, फिर भी आप अभी भी 2 बाइट्स बचाने द्वारा यह गोल्फ कर सकते हैं कुछ और: 1) Hardcode n = 10002) उपयोग allके ऊपर andऔर विधेय 3) के उपयोग की एक pointfree संस्करण (!!0)से अधिक head4) के संयोजन से अधिक उपयोग सूची-समझ mapऔर filter5) का उपयोग (<$>)से अधिक map:[s|s<-show<$>[1..],all((`isInfixOf`s).show)[1..1000]]!!0
ბიმო

2

पॉवर्सशेल, 36 बाइट्स, 1020 आउटपुट

999..9|%{$s+=(,"$_")[$s-match$_]};$s

आउटपुट:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

वैकल्पिक, 69 बाइट्स, 1000 आउटपुट

999..9|%{$s+=("$_",($x="$_"[-1]))[2*($s-match$_)+($s+$x-match$_)]};$s

आउटपुट:

9998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888788688588488388288188087787687587487387287187086786686586486386286186085785685585485385285185084784684584484384284184083783683583483383283183082782682582482382282182081781681581481381281181080780680580480380280180077767757747737727717707667657647637627617607567557547537527517507467457447437427417407367357347337327317307267257247237227217207167157147137127117107067057047037027017006665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555455355255155054454354254154053453353253153052452352252152051451351251151050450350250150044434424414404334324314304234224214204134124114104034024014003332331330322321320312311310302301300222122021121020120011101100

वैकल्पिक, 82 73 बाइट्स, 999 आउटपुट (न्यूनतम)

for(;$z=9..0|?{"000$x"-notmatch-join"$x$_"[-3..-1]}|%{"$_"}){$x+=$z[0]}$x

यह स्थिरांक के लिए अनुकूलित सबसे कम डी ब्रूजन उत्पन्न से एल्गोरिदम सरल है : वर्णमाला = 9876543210और लंबाई =3

आउटपुट:

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110100

टेस्ट स्क्रिप्ट:

$f= {

#999..0|%{$s+=if(!($s-match$_)){"$_"}};$s

#999..9|%{$s+=("$_",($x="$_"[-1]))[2*($s-match$_)+($s+$x-match$_)]};$s-replace'1100','100'
#999..9|%{$s+=("$_",($x="$_"[-1]))[2*($s-match$_)+($s+$x-match$_)]};$s
#999..9|%{$s+=(,"$_")[$s-match$_]};$s-replace'(.)\1{3,}','$1$1$1'
#999..9|%{$s+=(,"$_")[$s-match$_]};$s-replace'(.)\1{3,}','$1$1$1'-replace'1100','0'
 for(;$z=9..0|?{"000$x"-notmatch-join"$x$_"[-3..-1]}|%{"$_"}){$x+=$z[0]}$x
#999..9|%{$s+=(,"$_")[$s-match$_]};$s

}

$s=&$f

$s
"Length:"
$s.Length
"count(###)!=1:"
$x=@{}
0..($s.Length-3)|%{$s.Substring($_,3)}|Group|%{
    $x[+$_.Name]=$_.Count
}
100..999|?{$x.$_-ne1}|%{,($_,+$x.$_)}|%{"$_"}
"count(##)!=10:"
$x=@{}
0..($s.Length-2)|%{$s.Substring($_,2)}|Group|%{
    $x[+$_.Name]=$_.Count
}
10..99|?{$x.$_-ne10}|%{,($_,+$x.$_)}|%{"$_"}
"count(#)!=100:"
$x=@{}
0..($s.Length-1)|%{$s.Substring($_,1)}|Group|%{
    $x[+$_.Name]=$_.Count
}
0..9|?{$x.$_-ne100}|%{,($_,+$x.$_)}|%{"$_"}
"All numbers:"
999-eq(1..999|?{$s-match$_}).Count

2

05AB1E , 9 बाइट्स और 1109 अक्षर

₄FDNå_iNì

आउटपुट:

90990190089989088981980980880079979879078978878077977870970870770069969869769068968868768067967867767066966866760960860760660059959859759659058958858758658057957857757657056956856756656055955855755650950850750650550049949849749649549048948848748648548047947847747647547046946846746646546045945845745645545044944844744644540940840740640540440039939839739639539439038938838738638538438037937837737637537437036936836736636536436035935835735635535435034934834734634534434033933833733633533430930830730630530430330029929829729629529429329028928828728628528428328027927827727627527427327026926826726626526426326025925825725625525425325024924824724624524424324023923823723623523423323022922822722622522422320920820720620520420320220019919719619519419319219118918818718618518418318218017917817717617517417317217016916816716616516416316216015915815715615515415315215014914814714614514414314214013913813713613513413313213012912812712612512412312212011811711611511411311211110910810710610510410310210110099919089888079787770696867666059585756555049484746454440393837363534333029282726252423222018171615141312119876543210

इसे ऑनलाइन आज़माएं या सत्यापित करें कि इसमें 1000 से नीचे की सभी संख्याएँ हैं

स्पष्टीकरण:

            # Push 1000
 F           # Loop N in the range [0,1000):
  D          #  Duplicate the top value on the stack
   Nå_i      #  If it does not contain N as substring yet:
       Nì    #   Prepend N to it
             # (Output implicitly after the loop)

1

पाइके, 13 बाइट्स (नॉनकमेटिंग), स्ट्रिंग की लंबाई 1133

Pyke चुनौती से नया है और इस प्रकार गैर-प्रतिस्पर्धी है।

k~mV~oi{!o`*+

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

              - o = 0
k~mV          - repeat 1000 times, i = ""
    ~oi{      -     str(o) in i
        !     -    not ^
         o`*  -   str(o++) * ^
            + -  i += ^

आउटपुट कब तक है?
कृति लिथोस

1

PHP, 48 44 बाइट्स

मुझे याद दिलाने के लिए @primo को धन्यवाद ereg

for($i=1e3;--$i;ereg($i,$s)?:$s.=$i);echo$s;

या

for($i=1e3;ereg(--$i,$s)?$i:$s.=$i;);echo$s;

आउटपुट: 1020 चार्ट। PHP <7 की आवश्यकता है

PHP 7, 48 बाइट्स:

ereg PHP 7 में हटा दिया गया है

for($i=1e3;--$i;strstr($s,"$i")?:$s.=$i);echo$s;

यदि दूसरा तर्क strstr(या strposअन्य स्ट्रिंग खोज फ़ंक्शंस) स्ट्रिंग नहीं है, तो इसे एससीआई कोड के रूप में उपयोग किया जाएगा, इसलिए $iस्ट्रिंग की आवश्यकता होती है।


1
ereg($i,$s)4 के लिए (मैं <?बाइट की गिनती में भी शामिल होगा )।
प्रिमो

@primo मैंने अभी देखा कि यह चुनौती PHP 7 से भी पुरानी है। डबल धन्यवाद। :)
टाइटस

eregसंभवतः हटा दिया गया था, क्योंकि फ़ंक्शन का नाम बहुत छोटा है, और / या पर्याप्त अंडरस्कोर नहीं था। यह splitभी हटा दिया गया था विशेष रूप से शानदार।
प्राइमो

eregहटा दिया गया था क्योंकि POSIX में केवल PCRE possibilitiess संभावनाओं का एक सबसेट होता है; और वे शायद दो अलग-अलग पुस्तकालयों को बनाए रखना चाहते थे। मैं पूछना चाहिए कि मैं कभी रासमस लेरडोर्फ से मिलूं। splitहटा दिया गया है, लेकिन joinबना हुआ है (शायद इसलिए कि यह केवल "एक उपनाम" है)। पांडित्य के लिए खेद है; लेकिन मैं ऐसे लोगों को जानता हूं जो विडंबना को नहीं पहचान सकते।
टाइटस

1

ग्रूवी, 49 वर्ण / बाइट्स

मुझे यकीन नहीं था कि यह एक स्ट्रिंग चर लौटाने वाले फ़ंक्शन के रूप में करना है, या परिणाम का प्रिंट आउट करना है, इसलिए यह बस इसे स्टडआउट करने के लिए प्रिंट करता है। रेगेक्स मैचर का उपयोग करके 2 बाइट्स को बचाया, "अगर" के बजाय टर्नरी ऑपरेटर को एक और बाइट बचाया। आउटपुट स्ट्रिंग 1133 वर्ण है।

a='';1000.times{a+=(a==~/.*$it.*/)?'':it};print a

आउटपुट:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

-1

गेम मेकर लैंग्वेज, 1014 - स्ट्रिंग 1000

show_message(909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900)

इसके अलावा:

रूबी, 1003 - स्ट्रिंग 1000

p'909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900'


3
1) आपका पहला समाधान "स्ट्रिंग की लंबाई 1500 वर्णों से कम होनी चाहिए" नियम का उल्लंघन करता है। 2) मुझे आपके आउटपुट में 909 नंबर नहीं मिला। ( प्राइमो के उत्तर से कॉपी-पेस्ट करते समय आप पहले अंक से चूक गए ?) 3) rubyकोड इसे संख्यात्मक पैरामीटर पास करने के pबजाय उपयोग कर सकता है puts
मैनटवर्क
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.