一个环统治他们全部。一个包含所有字符串的字符串


43

目标:输出一个字符串,其中包含每个严格低于1000的正整数。

显而易见的答案是将它们中的每一个串联起来,这将创建一个2890个字符的字符串(感谢manatwork),为避免这种简单的答案,字符串的长度必须小于1500个字符。这是输出1200个字符的String的简单Java代码。

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;
    }
}

最短的代码获胜,最短的String的加分!


11
最佳字符串长度为1002个字符。
彼得·泰勒

8
基本上,您需要的是de Bruijn序列 B(10, 3),但是因为您不允许循环换行,所以必须重复前两个字符。
彼得·泰勒

3
但我希望字符串包含1、2或56,不一定是001 002和
056。– Fabinout

6
因为你说你的问题是不可能解决的数量不是整数。该字符串必须是无限长的,以容纳低于1000所有的正数
Ramchandra阿普特

11
@RamchandraApte甚至任何具有无限长度的字符串都将丢失大多数数字;-)
霍华德

Answers:


19

Golfscript-13个字节,输出1315

991,{`.$2>>},

上面的方法从0-990中选择那些数字,其第一位是该数字的最大位,即,按字母顺序排序的字符串表示形式的最后一位小于字符串本身。逻辑如下:

对于3位数的数字abc,如果a不是该数字的最大位数,则将跳过该数字,因为稍后它将被以下两种情况之一覆盖:

  1. b <c(例如 123
    由于 c是最大的数字,因此不会跳过号码驾驶室。在此示例中,将不会跳过 312,也不会跳过下一个值 313,该值在连接时( 312 313)包含 123

  2. b≥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 910919 920,... 989 990)。

在1315字节的输出时,这在问题的小于1500的规格下比较合适。

输出:

0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

变化#1

14字节,1233输出

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

通过严格选择用于比较的最后一位而不是第三位,可以消除许多小于100的不必要值,从而缩短了结果字符串。

101120212230313233404142434450515253545560616263646566707172737475767780818283848586878890919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

变体#2

16字节,1127输出

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

通过事先撬开所有小于99的值,可以进一步缩短结果字符串。

99100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Golfscript-19个字节,输出1016

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

上面的数字从99909,增加了尚未出现的任何值(909通常是以此方式添加的最后一个值)。将99移到前面是一种优化,以避免后面需要910

输出:

99100101102103104105106107108109111112113114115116117118119120122123124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190192193194195196197198199200202203204205206207208209222223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333334335336337338339340344345346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444445446447448449450455456457458459460465466467468469470475476477478479480485486487488489490495496497498499500505506507508509555556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666667668669670677678679680687688689690697698699700707708709777778779780788789790798799800808809888889890899900909

Golfscript 26字节,输出999

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

请注意,由先前解决方案生成的1016字符串几乎是最佳的,除了对于111的每个倍数都有两个额外的数字(即,11111代替11122222代替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Ññš
    从第一检查的值是 1,并且从第二 -1
    切片将从索引 0开始;它将返回整个字符串。
  2. 111Ññš
    从第一检查的值是 1,并且从第二东西 ≥2
    切片将从索引 ≥3开始凝视;它将返回一个空字符串。
  3. 111 | Ññš
    从第一校验值是 0,并且从第二 -1
    切片将从索引 -1开始;它只会返回最后一个字符。

逻辑的总和是,尚未出现的任何值都将被整体附加-除非它是111的倍数,否则将仅附加一个字符。所有其他值将被忽略。

请注意,生成的字符串与Peter Taylor的答案生成的最佳字符串不同。

历史:

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个字符)这是Lyndon单词串联方法的一种变体:它不是使用原始的1个字符的单词,而是使用111的倍数表示较短的代码,但重复出现这些数字。而不是使用共轭组的最小元素,而是使用最大元素,因为这样可以缩短循环。


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

以40个字符(可能仍会改进)生成一个最佳字符串,该字符串的长度为999个字符:

100200300400500600700800901101201301401501601701801902102202302402502602702802903103203303403503603703803904104204304404504604704804905105205305405505605705805906106206306406506606706806907107207307407507607707807908108208308408508608708808909109209309409509609709809911121131141151161171181191221231241251261271281291321331341351361371381391421431441451461471481491521531541551561571581591621631641651661671681691721731741751761771781791821831841851861871881891921931941951961971981992223224225226227228229233234235236237238239243244245246247248249253254255256257258259263264265266267268269273274275276277278279283284285286287288289293294295296297298299333433533633733833934434534634734834935435535635735835936436536636736836937437537637737837938438538638738838939439539639739839944454464474484494554564574584594654664674684694754764774784794854864874884894954964974984995556557558559566567568569576577578579586587588589596597598599666766866967767867968768868969769869977787797887897987998889899900

尝试使此字符串反向,会遇到忽略111的倍数的问题。

要看到999是最佳长度(因为上面我的简短评论不能使所有人信服),请从完整的de Bruijn序列(作为循环字符串)开始,其中包含从0到9的每3位字符序列。其中有1000个,长度必须至少为1000个字符;通常可以通过在图上进行欧拉遍历来证明它的长度恰好为1000个字符,该图的节点是xy具有10个边的两位序列,每个序列用1位数字标记z,取xyyz

我们不需要序列开头0,因此给定de Bruijn序列,我们可以旋转将其放在000末尾。然后,我们不需要两个环绕到开头的序列,但是我们确实需要两个0s来完成以数字before开头的序列000,因此我们可以删除其中的一个以获得999个字符的字符串。其余0的所有数字都不以开头0


8
真是令人印象深刻!
Fabinout

我更喜欢使用过滤或生成方法。对于伪Lyndon方法,我将生成方法降到了32个字符:更改10,:^{:x^>{x.@:&<+^>{x&@}/}/}/0.为真正的Lyndon单词可获得10,:^{:x^>{x.@:&<+^>{.x>{x&@}*}/}/}%3>0.最佳字符串(40个字符)。
彼得·泰勒

您是否可以通过对100以下的数字不使用前导零来缩短最佳字符串?
2013年

1
@ Random832我很确定你不会。您必须包括数字100、200,... 900,因此最小字符串肯定会出现八次00X(如上所述,其中一个可以在最右边)。请注意,给出的最佳字符串不包含“ 001”。
tttppp 2013年

2
通常,我不会对我不了解的代码进行投票,但是在这种情况下,我会对其进行投票,因为我不理解。太棒了
本杰克逊

29

GolfScript,17个字符

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

如果字符串中不存在每个数字的简单方法(请注意:未选中或未添加999,但输出中已经包含了999)。

输出为1133个字符:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

20

我没有任何代码,但是我认为有人可能会喜欢这种直观的证明,即999个字符是输出长度的下限:

首先,每个1位和2位数字都是3位数字的一部分,因此请忽略小于100的所有内容。100-999(含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个数字,中间有严格的1个零(“ 0”),有81个数字在末尾有严格的1个零(“ 0”),还有9个有两个零(“ 00”)。

每个?? 0数字都可以与?0共享零。或00号码,但不能同时使用。0 ?00永远不能共享零,因此输出中必须至少有81 + 9 * 2个零。

这给出了3 + 899 + 81 + 9 * 2-2 = 999个字符的下限。

抱歉,如果这被认为是题外话,但太长了,无法在评论中显示。


1
感谢您的注意!包含小于999的每个整数的字符串的长度为999个字符,这有点好笑。
Fabinout


1
注意到字符串中存储的每个数字最多为999会使它的长度为999个字符,这有点好笑。如果我错了,请指正我,但是我相信每个数字最多存储99个使其长度为100个字符。
Fabinout

2
通过相同的论点,下限是2 + 89 + 9-1 = 99,但这不能证明99是可能的,只有98没有。
阿利斯泰尔·巴克斯顿2013年

17

Perl, 37 34 33 32(1136 1132个字符)

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

for $ @(1..999){$ _。= $ @ if!/ $ @ /}打印

for $ i(1..999){$ _。= $ i if!/ $ i /}打印

for(1..1e3){$ s。= $ _ if $ s!〜/ $ _ /} print $ s

输出:

12345678910111314151617181920212224252627282930323335363738394043444647484950545557585960656668697076777980878890991001021031041051061071081091101121141151161171181191201241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901931941951961971981992002032042052062072082092192202212232252262272282292302312352362372382392402432442452462472482492502532542552562572582592602632642652662672682692702732742752762772782792802832842852862872882892902942952962972982993003043053063073083093113293303323343363373383393403423463473483493503543553563573583593603643653663673683693703743753763773783793803843853863873883893903953963973983994004054064074084094224394404434454474484494504534574584594604654664674684694704754764774784794804854864874884894904964974984995005065075085095335495505545565585595605645685695705765775785795805865875885895905975985996006076086096446596606656676696706756796806876886896906986997007087097557697707767787807867907977998008098668778798808878888978988999009089329439549659769799879891000

较短的字符串: 38 37 34(1020个字符):

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

for($ @ = 1e3; $ @-;){$ _。= $ @ if!/ $ @ /}打印

for($ i = 1e3; $ i-;){$ _。= $ i if!/ $ i /}打印

输出:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

仍然对复制尤其是99999开头不满意!我认为更多检查将创建更多代码,但是...

编辑:添加了来自@Peter Taylor的建议

编辑2:@primo的一些很棒的建议!谢谢


2
将1000写为1e3的好技巧,但我认为这毫无意义。这个问题说“严格低于1000”,这意味着最多为999,包括999。(示例代码也处理0..999。)
manatwork 2013年

很棒的一点!我开始时有一个不同的循环,我对此进行了相应的修改!谢谢!
Dom Hastings,

3
如果对变量使用非字母字符,可以删除空格吗?
彼得·泰勒

是的,我可以!谢谢!
Dom Hastings

2
还有一些较小的改进:$_.=$@if!/$@/您可以使用字符串重复代替$_.=$@x!/$@/。该for可以通过替代while:作为一个语句修饰,使用模...while$@=--$@%1e3
普里莫

10

APL(20,输出:1020)

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

说明:

  • {∨/⍺⍷⍵:⍵⋄⍵,⍺}:如果是的子字符串,则返回,否则返回⍵,⍺
  • /:减少超过
  • ⍕¨:每个字符串的表示形式
  • ⍳999:从1到的整数999

输出:

9999989979969959949939929919909889879869859849839829819809789779769759749739729719709689679669659649639629619609589579569
      55954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913
      91291191090890790690590490390290190088888788688588488388288188087787687587487387287187086786686586486386286186085785
      68558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108
      07806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735
      73473373273173072672572472372272172071671571471371271171070670570470370270170066666566466366266166065565465365265165
      06456446436426416406356346336326316306256246236226216206156146136126116106056046036026016005555545535525515505445435
      42541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411
      410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

APL(41,输出:999)

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

说明:

  • ⌽⍕¨100+⍳898:(('999' '998' ... '101')以相反的顺序进行,因为减少在APL中从右到左,即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

Ruby: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]}'
[]

Ruby: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的好主意,并非相反。这样,我的Java方法将输出1048个字符串(而不是1200个)。
Fabinout

1
如果您只担心代码长度而不是输出长度,则可以使用字符串范围来改进第一个。喜欢的东西(?0..?9*3).map{|i|$/[i]||($><<i;$/+=i)}可能?
Paul Prestidge

5

JavaScript,39

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

Mathematica(62 64个字符,1002个输出)

因为这利用了本机函数,所以我从头开始更欣赏短解决方案的美丽。输出为1002个字符长。

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

"799798787770760750740730720710980970960950940930920910108908708608508408308208889998988081009909008007006005004003002000190180170160150140130120119118117116115114113112912812712612512412312213913813713613513413313214914814714614514414314215915815715615515415315216916816716616516416316217917817717617517417317218918818718618518418318219919819719619519419319212111029028027026025024023022922822722622522422392382372362352342332492482472462452442432592582572562552542532692682672662652642632792782772762752742732892882872862852842832992982972962952942932322202103903803703603503403393383373363353349348347346345344359358357356355354369368367366365364379378377376375374389388387386385384399398397396395394343330320310490480470460450449448447446445945845745645546946846746646547947847747647548948848748648549949849749649545444043042041059058057056055955855755695685675665795785775765895885875865995985975965655505405305205106906806706696686679678677689688687699698697676660650640630620610790780779778978879"

1
您似乎缺少799和997。请参见ideone.com/d07bG2(或写您自己的支票)
贾斯汀

接得好。默认情况下,DeBruijnSequence假定循环包装。前两位末尾加“ 79”即可解决问题。
DavidC

4

Mathematica,51个字符

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

输出(1155个字符):

000100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999

它有什么作用?
Fabinout

1
它构造形式的列表的列表{i, j, k},其中i是从0到9和jk是小于i。然后,它将列表转换为字符串。
alephalpha

4

Python-53 63,1134输出

这是蛮力的,但它是有效的。是的,它有一个前导零,但没有则保存了两个字符range(1,1000)

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

上面DeprecationWarning的代码在range()调用中抛出了1e3的用法,但是使用1000保存了一个字符。

还有一个更好的长度输出版本,通过以 65个字符(感谢res和filmor的提示)

Python-58,1021输出

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

1
我发现您的第一个程序的输出长度为1133,而不是1132。在Python 2(但不是Python 3)中,您可以使用反引号将代码缩短为54个字符:for i in range(999):s+=`i`*(not`i`in s)
res res

ot?他们拿出反引号了吗?Guido在决定要保留什么时,肯定一直都在讨厌I Perl。
沃伦·P

1
您可以使用range(999,99,-1)代替来将其缩短一个字符range(1000)[::-1]
电影制片人

由res提供的提示仍然有帮助,str(i)*(str(i)not in s)i=str(i);s+=[i,''][i in s];)短一些;)
电影或电影

@filmor通过使用1e3代替而不是1000

2

K,33

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

与Howards解决方案基本相同-1133个字符。

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

2

Java- 126 98个字符(Java 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

可以达到好的(根据 Peter Taylor的,但是后来他说999是最佳的),通过添加一些字符(+ 20个字符为147 118)字符串长度:

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

编辑:感谢Fabinout指出Java 6可以节省28个字符。


如果需要,可以使用Java 6进行编译,并使用静态块代替System.out.println()!
Fabinout

@Fabinout您是不是要表示public static void main(String[]a)?(那会将我的代码从更改...public static void main(String[]c){......static{...
贾斯汀

是的,我愿意。您可以尝试使用
Java6。– Fabinout

顺便说一句,如果您不希望程序崩溃,则应在静态块的末尾使用exit()。即使在打高尔夫球时不要求它不会崩溃。
Fabinout

2

Windows PowerShell-40、1020输出

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

输出:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

2

Haskell,75个字节-1002输出

一种筛分方法,可返回最小的解决方案。

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

请注意,此解决方案是不切实际的缓慢。


您需要包括Data.Listfor 的导入isInfixOf,但是您仍然可以通过打高尔夫球进一步节省2个字节:1)硬编码n = 10002)使用allover and和谓词的无点版本3)使用(!!0)over head4)在map&的组合上使用list-comprehension filter5)使用(<$>)以上map[s|s<-show<$>[1..],all((`isInfixOf`s).show)[1..1000]]!!0
ბიმო

2

Powershell,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

这是生成适用于常量的最短De Bruijn的简化算法:字母= 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

Pyke,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 += ^

输出多长时间?
Kritixi Lithos

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其他字符串搜索函数)的第二个参数不是字符串,则它将用作ASCII代码,因此$i需要强制转换为字符串。


1
ereg($i,$s)4(我还将包括<?在字节数中)。
primo

@primo我刚刚注意到这个挑战比PHP 7古老。谢谢。:)
泰特斯

ereg之所以被删除,可能是因为函数名太短和/或没有足够的下划线。那split也被删除是特别辉煌的。
2016年

ereg由于POSIX仅包含PCRE可能性的一部分,因此已被删除;他们可能不想维护两个不同的库。我会问我是否应该再见到拉斯穆斯·勒多夫。split已被删除,但join仍然保留(可能是因为“仅”是别名)。对不起,学究;但我知道无法承认讽刺意味的人。
泰特斯

1

Groovy,49个字符/字节

我不确定是将其作为返回字符串变量的函数来执行还是将结果打印出来,所以这只是将其打印到标准输出。使用正则表达式匹配器保存2个字节,使用三元运算符代替“ if”保存另一个字节。输出字符串为1133个字符。

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

输出:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

-1

游戏制作者语言1014-字符串1000

show_message(909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900)

也:

Ruby,1003-字符串1000

p'909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900'


3
1)您的第一个解决方案违反了“字符串的长度必须小于1500个字符”的规则。2)我在您的输出中找不到编号909。(从primo的答案中粘贴粘贴时,您错过了第一位数字?)3)ruby代码可以使用p而不是puts传递数字参数来使用。
manatwork 2014年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.