Ein Ring sie alle zu knechten. Ein String für alle


43

Ziele: Einen String ausgeben, der jede positive ganze Zahl enthält, die genau unter 1000 liegt.

Die naheliegende Antwort wäre, jeden von ihnen zu verketten, und das würde eine Zeichenfolge von 2890 Zeichen ergeben (danke manatwork). Um diese Art der einfachen Antwort zu vermeiden, muss die Länge der Zeichenfolge unter 1500 Zeichen liegen. Hier ist ein einfacher Java-Code, der einen String mit 1200 Zeichen ausgibt.

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

Kürzester Code-Gewinn, Bonuspunkt für die kürzeste Saite!


11
Die optimale Zeichenfolge ist 1002 Zeichen lang.
Peter Taylor

8
Grundsätzlich fragen Sie nach einer de Bruijn-Sequenz B(10, 3) , aber da Sie keinen zyklischen Zeilenumbruch zulassen, müssen Sie die ersten beiden Zeichen wiederholen.
Peter Taylor

3
Aber ich möchte, dass die Zeichenfolge 1, 2 oder 56 enthält, nicht unbedingt 001 002 und
056.

6
Ihr Problem ist nicht zu lösen, weil Sie die Zahl nicht ganzzahlig angegeben haben . Die Zeichenfolge müsste unendlich lang sein, um alle positiven Zahlen unter 1000 aufzunehmen.
Ramchandra Apte

11
@RamchandraApte Und immer noch fehlt jede Zeichenfolge auch mit unendlicher Länge die meisten Zahlen ;-)
Howard

Antworten:


19

Golfscript - 13 Bytes, 1315 Ausgabe

991,{`.$2>>},

Das Obige wählt die Zahlen von 0 bis 990 aus, deren erste Ziffer die größte Ziffer der Zahl ist, dh die letzte Ziffer der sortierten Zeichenfolgendarstellung ist lexikografisch kleiner als die Zeichenfolge selbst. Die Logik ist die folgende:

Bei einer 3-stelligen Zahl abc kann die Zahl übersprungen werden , wenn a nicht die größte Ziffer der Zahl ist, da sie später in einem von zwei Fällen behandelt wird:

  1. b <c (z . B. 123 )
    Da c die größte Ziffer ist, wird die Nummer cab nicht übersprungen. In diesem Beispielwird weder 312 übersprungen noch der nächste Wert 313 , der, wenn er verkettet ist ( 312, 313 ), 123 enthält.

  2. b ≥ c (zB 132 )
    Da b die größte Ziffer ist, wird die Zahl bca nicht übersprungen. In diesem Beispielwird weder 321 übersprungen noch der nächste Wert 322 , der, wenn er verkettet ist ( 321, 322 ), 132 enthält. Ist b = c (z. B. 122 ), gilt dies auch. Der Wert bca wird nicht wie zuvor übersprungen, und da a notwendigerweise kleiner als b ist , wird auch bc <a + 1> nicht übersprungen. In diesem Beispielenthält 221 222 122 .

Da der obige Code nicht nur die letzte, sondern die dritte Ziffer testet, sind alle Werte von 0 bis 99 im Ergebnis enthalten. Die Werte von 1 bis 99 können jedoch übersprungen werden, da, wenn jede dreistellige Folge vorhanden ist, auch jede ein- und zweistellige Folge vorhanden sein muss.

Die Werte von 991-999 können ebenfalls übersprungen werden, da sie von ( 909 910 , 919 920 , ... 989 990 ) generiert werden .

Bei einer Ausgabe von 1315 Byte entspricht dies der Spezifikation des Problems von weniger als 1500.

Ausgabe:

0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Variante # 1

14 Bytes, 1233 Ausgabe

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

Durch die strikte Auswahl der letzten statt der dritten Ziffer für den Vergleich werden viele der unnötigen Werte unter 100 eliminiert, wodurch die resultierende Zeichenfolge verkürzt wird.

101120212230313233404142434450515253545560616263646566707172737475767780818283848586878890919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Variante # 2

16 Bytes, 1127 Ausgabe

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

Durch vorheriges Abhebeln aller Werte unter 99 kann die resultierende Zeichenfolge noch weiter gekürzt werden.

99100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Golfscript - 19 Bytes, 1016 Ausgabe

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

Die obigen Werte reichen von 99 bis 909 und addieren jeden Wert, der noch nicht erschienen ist ( 909 wäre normalerweise der letzte Wert, der auf diese Weise hinzugefügt wird). Das Verschieben von 99 nach vorne ist eine Optimierung, um zu vermeiden, dass 910 nach hinten benötigt wird.

Ausgabe:

99100101102103104105106107108109111112113114115116117118119120122123124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190192193194195196197198199200202203204205206207208209222223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333334335336337338339340344345346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444445446447448449450455456457458459460465466467468469470475476477478479480485486487488489490495496497498499500505506507508509555556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666667668669670677678679680687688689690697698699700707708709777778779780788789790798799800808809888889890899900909

Golfscript 26 Bytes, 999 Ausgabe

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

Beachten Sie, dass die von der vorherigen Lösung erzeugte 1016- Zeichenfolge nahezu optimal ist, mit Ausnahme von zwei zusätzlichen Ziffern für jedes Vielfache von 111 (dh 11111anstelle von 111, 22222anstelle von 222usw.). Die Lösung kann optimiert werden, indem diese zusätzlichen Ziffern entfernt werden (statt drei nur eine Ziffer bei jedem dieser Werte) und 909nach vorne gedreht wird, um ein zu entfernen 9(dies unterscheidet sich von den vorherigen Versionen, die 9100stattdessen nach hinten verschoben wurden) ).

Abgerollt und kommentiert:

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

Die Logik zur Auswahl der angehängten Zeichen besteht aus drei Fällen:

  1. 111n , ns
    Der Wert aus der ersten Prüfung ist 1 und aus der zweiten -1 .
    Das Slice beginnt ab Index 0 ; Es wird die gesamte Zeichenfolge zurückgegeben.
  2. 111n , ns
    Der Wert aus der ersten Prüfung ist 1 und aus der zweiten etwas ≥ 2 .
    Die Scheibe beginnt ab Index ≥ 3 zu starren; Es wird eine leere Zeichenfolge zurückgegeben.
  3. 111n , ns
    Der Wert aus der ersten Prüfung ist 0 und aus der zweiten -1 .
    Das Slice beginnt mit Index -1 . es wird nur das letzte Zeichen zurückgegeben.

Die Summe der Logik ist, dass ein noch nicht erschienener Wert vollständig angehängt wird - es sei denn, es handelt sich um ein Vielfaches von 111. In diesem Fall wird nur ein Zeichen angehängt. Alle anderen Werte werden ignoriert.

Beachten Sie, dass sich die erzeugte Saite von der optimalen Saite unterscheidet, die von Peter Taylors Antwort erzeugt wurde .

Geschichte:

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

Ausgabe:

909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900

45

GolfScript ( 35 31 26 Zeichen)

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

Ausgabe ist

000100110111200201210211220221222300301302310311312320321322330331332333400401402403410411412413420421422423430431432433440441442443444500501502503504510511512513514520521522523524530531532533534540541542543544550551552553554555600601602603604605610611612613614615620621622623624625630631632633634635640641642643644645650651652653654655660661662663664665666700701702703704705706710711712713714715716720721722723724725726730731732733734735736740741742743744745746750751752753754755756760761762763764765766770771772773774775776777800801802803804805806807810811812813814815816817820821822823824825826827830831832833834835836837840841842843844845846847850851852853854855856857860861862863864865866867870871872873874875876877880881882883884885886887888900901902903904905906907908910911912913914915916917918920921922923924925926927928930931932933934935936937938940941942943944945946947948950951952953954955956957958960961962963964965966967968970971972973974975976977978980981982983984985986987988990991992993994995996997998999

(1020 Zeichen) Dies ist eine Variante des Ansatzes der Lyndon-Wortverkettung: Anstatt die primitiven 1-Zeichen-Wörter zu verwenden, werden für kürzeren Code ein Vielfaches von 111 verwendet, diese Zahlen jedoch wiederholt. und anstatt minimale Elemente der Konjugationsgruppen zu verwenden, werden maximale Elemente verwendet, da dies die Schleifen verkürzt.


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

Bei 40 Zeichen (kann wahrscheinlich noch verbessert werden) wird eine optimale Zeichenfolge mit einer Länge von 999 Zeichen generiert:

100200300400500600700800901101201301401501601701801902102202302402502602702802903103203303403503603703803904104204304404504604704804905105205305405505605705805906106206306406506606706806907107207307407507607707807908108208308408508608708808909109209309409509609709809911121131141151161171181191221231241251261271281291321331341351361371381391421431441451461471481491521531541551561571581591621631641651661671681691721731741751761771781791821831841851861871881891921931941951961971981992223224225226227228229233234235236237238239243244245246247248249253254255256257258259263264265266267268269273274275276277278279283284285286287288289293294295296297298299333433533633733833934434534634734834935435535635735835936436536636736836937437537637737837938438538638738838939439539639739839944454464474484494554564574584594654664674684694754764774784794854864874884894954964974984995556557558559566567568569576577578579586587588589596597598599666766866967767867968768868969769869977787797887897987998889899900

Der Versuch, dies zu tun, führt zu Problemen beim Weglassen der Vielfachen von 111.

Um zu sehen, dass 999 die optimale Länge ist (da meine obigen kurzen Kommentare nicht alle überzeugen), gehen Sie von der vollständigen de Bruijn-Sequenz aus, die (als zyklische Zeichenfolge betrachtet) jede dreistellige Folge von Zeichen von 0 bis 9 enthält es gibt 1000 von ihnen, es muss mindestens 1000 Zeichen lang sein; dass es lange genau 1000 Zeichen werden in der Regel durch einen Eulersche Fuß auf einem Graph , dessen Knoten sind zweistellige Sequenzen nachgewiesen wird , xymit 10 Kanten, jeweils markiert mit einer Ziffer z, das nehmen xyzu yz.

Wir brauchen keine Sequenzen, die beginnen 0, also können wir bei einer de Bruijn-Sequenz drehen, um sie 000am Ende zu setzen . Dann brauchen wir keine der Sequenzen, die sich zum Anfang drehen, aber wir brauchen zwei der 0s, um die Sequenz mit der vorhergehenden Ziffer zu beenden 000, sodass wir eine von ihnen löschen können, um eine Zeichenfolge mit 999 Zeichen zu erhalten. Jeder verbleibende 0wird in einer Zahl verwendet, die nicht mit beginnt 0.


8
Das ist wirklich beeindruckend !!
Fabinout

Ich würde es vorziehen, einen Filter- oder generativen Ansatz zu verwenden. Für den Pseudo-Lyndon-Ansatz habe ich den generativen Ansatz auf 32 Zeichen reduziert: 10,:^{:x^>{x.@:&<+^>{x&@}/}/}/0.Abweichend davon, was für echte Lyndon-Wörter 10,:^{:x^>{x.@:&<+^>{.x>{x&@}*}/}/}%3>0.(40 Zeichen) für die optimale Zeichenfolge ergibt .
Peter Taylor

Können Sie die optimale Zeichenfolge verkürzen, indem Sie keine führenden Nullen für Zahlen unter 100 verwenden?
Random832

1
@ Random832 Ich bin mir ziemlich sicher, dass du das nicht kannst. Sie müssen die Zahlen 100, 200, ... 900 eingeben, damit die minimale Zeichenfolge mit Sicherheit acht Vorkommen von 00X hat (eines kann wie oben ganz rechts stehen). Beachten Sie, dass die angegebene optimale Zeichenfolge nicht "001" enthält.
TTTPP

2
Normalerweise stimme ich Code nicht zu, den ich nicht verstehe, aber in diesem Fall stimme ich zu, weil ich ihn nicht verstehe. Bravo.
Ben Jackson

29

GolfScript, 17 Zeichen

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

Einfacher Ansatz, um jede Zahl zu addieren, wenn sie nicht bereits in der Zeichenfolge vorhanden ist (Hinweis: 999 ist nicht aktiviert oder hinzugefügt, aber bereits in der Ausgabe enthalten).

Die Ausgabe umfasst 1133 Zeichen:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

20

Ich habe keinen Code, aber ich dachte, jemand würde diesen intuitiven Beweis dafür zu schätzen wissen, dass 999 Zeichen die untere Grenze für die Länge der Ausgabe sind:

Erstens ist jede ein- und zweistellige Zahl Teil einer dreistelligen Zahl. Ignorieren Sie daher alle Zahlen unter 100. 100-999 einschließlich sind 900 dreistellige Zahlen.

Der beste Weg, um das Problem zu lösen, ist, wenn jeder Charakter so oft wie möglich verwendet wird. Das heißt, die Zahlen überlappen sich so weit wie möglich:

123
 234
  345

Die erste Zahl fügt daher 3 Zeichen hinzu, und jede nachfolgende Zahl fügt 1 Zeichen hinzu. Das ergibt 3 + 899 = 902 Zeichen als Untergrenze.

Wenn es jedoch eine Null gibt, können wir sie nicht verwenden, um eine neue dreistellige Zahl zu beginnen. Wir können es jedoch in der Mitte einer anderen dreistelligen Zahl wiederverwenden, solange keine weitere Null folgt:

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

Aber:

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

Daher erweitert jede in der Ausgabe auftauchende Null die Ausgabe um 1 Zeichen - mit Ausnahme der letzten beiden Zeichen, die Null sein können, da sie keine weiteren Zahlen überlappen:

???
 ??0
  ?00

Es gibt 81 Zahlen mit genau einer Null in der Mitte (? 0?), 81 mit genau einer Null am Ende (?? 0) und 9 mit zwei Nullen (? 00).

Jede ?? 0-Zahl kann eine Null mit einer ?? 0? nummer oder eine? 00 nummer, aber nicht beides. 0 & le; und? 00 kann niemals Nullen gemeinsam nutzen, daher müssen mindestens 81 + 9 * 2 Nullen in der Ausgabe vorhanden sein.

Dies ergibt eine Untergrenze von 3 + 899 + 81 + 9 * 2 - 2 = 999 Zeichen.

Entschuldigung, wenn dies als nicht thematisch angesehen wird, aber es war zu lang, um in einen Kommentar zu passen.


1
Danke für die Warnung! Das ist ein bisschen komisch, dass die Zeichenfolge, die alle Ganzzahlen unter 999 enthält, 999 Zeichen lang ist.
Fabinout


1
Es ist ein bisschen komisch zu bemerken, dass das Speichern jeder Zahl bis zu 999 in einer Zeichenfolge 999 Zeichen lang macht. Korrigieren Sie mich, wenn ich falsch liege, aber ich glaube, dass das Speichern jeder Zahl bis zu 99 eine Länge von 100 Zeichen ergibt.
Fabinout

2
Nach dem gleichen Argument ist die Untergrenze 2 + 89 + 9 - 1 = 99, aber dies beweist nicht, dass 99 möglich ist, nur dass 98 nicht möglich ist.
Alistair Buxton

17

Perl, 37 34 33 32 (1136 1132 Zeichen)

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

für $ @ (1..999) {$ _. = $ @ if! / $ @ /} print

für $ i (1..999) {$ _. = $ i if! / $ i /} print

für (1..1e3) {$ s. = $ _ if $ s! ~ / $ _ /} print $ s

Ausgänge:

12345678910111314151617181920212224252627282930323335363738394043444647484950545557585960656668697076777980878890991001021031041051061071081091101121141151161171181191201241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901931941951961971981992002032042052062072082092192202212232252262272282292302312352362372382392402432442452462472482492502532542552562572582592602632642652662672682692702732742752762772782792802832842852862872882892902942952962972982993003043053063073083093113293303323343363373383393403423463473483493503543553563573583593603643653663673683693703743753763773783793803843853863873883893903953963973983994004054064074084094224394404434454474484494504534574584594604654664674684694704754764774784794804854864874884894904964974984995005065075085095335495505545565585595605645685695705765775785795805865875885895905975985996006076086096446596606656676696706756796806876886896906986997007087097557697707767787807867907977998008098668778798808878888978988999009089329439549659769799879891000

Kürzere Zeichenfolge: 38 37 34 (1020 Zeichen):

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

für ($ @ = 1e3; $ @ -;) {$ _. = $ @ if! / $ @ /} print

für ($ i = 1e3; $ i -;) {$ _. = $ i if! / $ i /} print

Ausgänge:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Immer noch nicht zufrieden mit der Vervielfältigung vor allem des 99999 zu Beginn! Ich denke, dass viel mehr Prüfungen viel mehr Code erzeugen würden ...

Bearbeiten: Vorschlag von @Peter Taylor hinzugefügt

Edit 2: Einige tolle Vorschläge von @primo! Danke


2
Netter Trick, 1000 als 1e3 zu schreiben, aber ich finde es sinnlos. Die Frage lautet "Streng unter 1000", das würde bis einschließlich 999 bedeuten. (Der Beispielcode verarbeitet auch 0..999.)
manatwork

Ein ausgezeichneter Punkt! Ich hatte zu Beginn eine andere Schleife, die ich entsprechend angepasst habe! Vielen Dank!
Dom Hastings

3
Wenn Sie ein nicht-alphabetisches Zeichen für Ihre Variable verwenden, können Sie das Leerzeichen entfernen?
Peter Taylor

Ahhh ja, ich kann! Vielen Dank!
Dom Hastings

2
Noch ein paar kleinere Verbesserungen: Stattdessen $_.=$@if!/$@/können Sie die Zeichenfolge wiederholen $_.=$@x!/$@/. Das forkann durch ein whileals Anweisungsmodifikator verwendetes Modulo ersetzt werden:...while$@=--$@%1e3
primo

10

APL (20, Ausgabe: 1020)

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

Erläuterung:

  • {∨/⍺⍷⍵:⍵⋄⍵,⍺}: wenn ist ein Teilstring von , return , sonst return⍵,⍺
  • /: reduzieren über
  • ⍕¨: die Zeichenfolgendarstellung von jedem von
  • ⍳999: die ganzen Zahlen von 1bis 999.

Ausgabe:

9999989979969959949939929919909889879869859849839829819809789779769759749739729719709689679669659649639629619609589579569
      55954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913
      91291191090890790690590490390290190088888788688588488388288188087787687587487387287187086786686586486386286186085785
      68558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108
      07806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735
      73473373273173072672572472372272172071671571471371271171070670570470370270170066666566466366266166065565465365265165
      06456446436426416406356346336326316306256246236226216206156146136126116106056046036026016005555545535525515505445435
      42541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411
      410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

APL (41, Ausgabe: 999)

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

Erläuterung:

  • ⌽⍕¨100+⍳898: ('999' '998' ... '101')(in umgekehrter Reihenfolge, da die Reduktion in der APL von rechts nach links verläuft, dh F/a b c ≡ a F (b F c))
  • /: reduzieren
  • ⍵,⍺⍴⍨: rechtes Argument, gefolgt von den ersten NZeichen des linken Arguments, wobei Ngilt:
  • 3×~∨/⍺⍷⍵: 3if ist kein Teilstring von , sonst0
  • (1=⍴∪⍺): 1wenn nur ein einziges Zeichen, sonst0
  • : größter gemeinsamer Teiler der beiden vorherigen Werte, also: 1wenn nicht bereits vorhanden ist und nur ein eindeutiges Zeichen hat, 3wenn nicht bereits vorhanden ist, aber mehr als ein eindeutiges Zeichen hat, 0andernfalls
  • '0',⍨: füge am Ende des Ergebnisses eine Null hinzu

Ausgabe:

10110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451
      46147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188
      18919019219319419519619719819920020220320420520620720820922232242252262272282292302332342352362372382392402432442452
      46247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294
      29529629729829930030330430530630730830933343353363373383393403443453463473483493503543553563573583593603643653663673
      68369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444544644744844945045545645
      74584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566
      56756856957057657757857958058658758858959059659759859960060660760860966676686696706776786796806876886896906976986997
      00707708709777877978078878979079879980080880988898908999009099100

8

Ruby: 50 46 Zeichen (Ausgabe von 1020 Zeichen)

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

Probelauf:

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

Testlauf:

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 Zeichen (999 Zeichen werden ausgegeben)

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

Probelauf:

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

Testlauf:

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

Gute Idee, von 999 auf 0 zu kommen und nicht umgekehrt. Damit gibt meine Java-Methode eine Zeichenfolge mit 1048 Zeichen (anstelle von 1200) aus.
Fabinout

1
Wenn Sie sich nur Gedanken über die Codelänge und nicht über die Ausgabelänge machen, können Sie die erste mit einem Zeichenfolgenbereich verbessern. So etwas wie (?0..?9*3).map{|i|$/[i]||($><<i;$/+=i)}vielleicht?
Paul Prestidge

5

JavaScript, 39

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

1020 Zeichen Ausgabe:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100


Nachprüfung: for(i=0;i<1000;i++)console.assert(k.indexOf(i)>=0)


5

Mathematica ( 62 64 Zeichen, 1002 Ausgabe)

Da dies eine native Funktion nutzt, schätze ich umso mehr die Schönheit kürzerer Lösungen von Grund auf. Die Ausgabe ist 1002 Zeichen lang.

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

"799798787770760750740730720710980970960950940930920910108908708608508408308208889998988081009909008007006005004003002000190180170160150140130120119118117116115114113112912812712612512412312213913813713613513413313214914814714614514414314215915815715615515415315216916816716616516416316217917817717617517417317218918818718618518418318219919819719619519419319212111029028027026025024023022922822722622522422392382372362352342332492482472462452442432592582572562552542532692682672662652642632792782772762752742732892882872862852842832992982972962952942932322202103903803703603503403393383373363353349348347346345344359358357356355354369368367366365364379378377376375374389388387386385384399398397396395394343330320310490480470460450449448447446445945845745645546946846746646547947847747647548948848748648549949849749649545444043042041059058057056055955855755695685675665795785775765895885875865995985975965655505405305205106906806706696686679678677689688687699698697676660650640630620610790780779778978879"

1
Sie scheinen 799 und 997 zu fehlen. Siehe ideone.com/d07bG2 (oder schreiben Sie Ihren eigenen Scheck)
Justin

Guter Fang. Standardmäßig wird ein DeBruijnSequencezyklischer Zeilenumbruch vorausgesetzt. Das Voranstellen von "79", den letzten beiden Ziffern, löst das Problem.
DavidC

4

Mathematica, 51 Zeichen

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

Ausgabe (1155 Zeichen):

000100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999

Was tut es?
Fabinout

1
Es erstellt eine Liste der Listen von der Form in {i, j, k}dem ivon 0 bis 9 ist und j, ksind kleiner als i. Dann konvertiert es die Liste in eine Zeichenfolge.
Alephalpha

4

Python - 53 631134 Ausgabe

Das ist ziemlich brachial, aber es ist gültig. Ja, es hat eine führende Null, aber es speichert zwei Zeichen, indem es keine hat range(1,1000).

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

Das obige wirft eine DeprecationWarningÜberschreitung der Verwendung von 1e3 in dem range()Aufruf, aber es speichert ein Zeichen über 1000.

Es gibt auch eine etwas optimalere Längenausgabeversion, indem die Zeichenfolge auf Kosten von umgekehrt wird 65 Zeichen (danke an res und filmor für die Tipps) :

Python - 58, 1021 Ausgabe

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

1
Ich finde, dass Ihr erstes Programm die Ausgabelänge 1133 und nicht 1132 hat. In Python 2 (aber nicht in Python 3) können Sie den Code mit Backticks auf 54 Zeichen verkürzen:for i in range(999):s+=`i`*(not`i`in s)
res

Wot? Sie haben Backticks rausgenommen? Guido muss ein Ich hasse Perl und alles, was so aussieht, gehabt haben, als er sich entschied, was er behalten soll.
Warren P

1
Sie können dies durch Verwenden von range(999,99,-1)anstelle von um ein Zeichen verkürzen range(1000)[::-1].
Filmor

Und der Tipp von Res noch helfen, str(i)*(str(i)not in s)ist ein bisschen kürzer als i=str(i);s+=[i,''][i in s];)
Filmor

@filmor Wird immer kleiner, indem 1e3anstelle von1000

2

K, 33

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

Grundsätzlich dasselbe wie die Howards-Lösung - 1133 Zeichen.

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

2

Java - 126 98 Zeichen (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);}}

Ausgabe (1020 Zeichen):

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Kann eine gute Saitenlänge erreichen (laut Peter Taylor , aber später sagte er 999 war optimal), indem man ein paar Zeichen hinzufügt (+20 Zeichen für 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);}}

Ausgabe (1002 Zeichen):

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110101100

Edit : Danke an Fabinout für den Hinweis, dass Java 6 28 Zeichen einsparen kann.


Wenn Sie möchten, können Sie mit Java 6 kompilieren und einen statischen Block anstelle eines System.out.println () verwenden !!
Fabinout

@Fabinout Meinst du statt a public static void main(String[]a)? (das würde meinen Code von ...public static void main(String[]c){...auf ändern ...static{...)
Justin

Ja, ich will. Sie können mit Java 6 versuchen.
Fabinout

Übrigens sollten Sie exit () am Ende Ihres statischen Blocks verwenden, wenn Sie nicht möchten, dass Ihr Programm abstürzt. Auch wenn es beim Golfen nicht erforderlich ist, nicht zusammenzustoßen.
Fabinout

2

Windows PowerShell - 40, 1020 Ausgabe

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

Ausgabe:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

2

Haskell, 75 Bytes - 1002 Ausgabe

Ein Siebansatz, der eine minimale Lösung ergibt.

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

Beachten Sie, dass diese Lösung unpraktisch langsam ist.


Sie müssen den Import von Data.Listfor isInfixOfeinbinden, können aber dennoch 2 Bytes einsparen, indem Sie etwas mehr Golf spielen: 1) Hardcode n = 10002) Use allover andund eine pointfreie Version des Prädikats 3) Use (!!0)over head4) Use list- understand über die Kombination von map& filter5) Verwendung (<$>)über map:[s|s<-show<$>[1..],all((`isInfixOf`s).show)[1..1000]]!!0
ბიმო

2

Powershell, 36 Bytes, 1020 Ausgabe

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

Ausgabe:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Alternative, 69 Bytes, 1000 Ausgabe

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

Ausgabe:

9998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888788688588488388288188087787687587487387287187086786686586486386286186085785685585485385285185084784684584484384284184083783683583483383283183082782682582482382282182081781681581481381281181080780680580480380280180077767757747737727717707667657647637627617607567557547537527517507467457447437427417407367357347337327317307267257247237227217207167157147137127117107067057047037027017006665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555455355255155054454354254154053453353253153052452352252152051451351251151050450350250150044434424414404334324314304234224214204134124114104034024014003332331330322321320312311310302301300222122021121020120011101100

Alternative, 82 73 Bytes, 999 Ausgabe (Minimum)

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

Dies ist ein vereinfachter Algorithmus von Generiere den kürzesten De Bruijn, der für Konstanten angepasst ist: alphabet = 9876543210und length =3

Ausgabe:

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110100

Testskript:

$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 Bytes und 1109 Zeichen

₄FDNå_iNì

Ausgänge:

90990190089989088981980980880079979879078978878077977870970870770069969869769068968868768067967867767066966866760960860760660059959859759659058958858758658057957857757657056956856756656055955855755650950850750650550049949849749649549048948848748648548047947847747647547046946846746646546045945845745645545044944844744644540940840740640540440039939839739639539439038938838738638538438037937837737637537437036936836736636536436035935835735635535435034934834734634534434033933833733633533430930830730630530430330029929829729629529429329028928828728628528428328027927827727627527427327026926826726626526426326025925825725625525425325024924824724624524424324023923823723623523423323022922822722622522422320920820720620520420320220019919719619519419319219118918818718618518418318218017917817717617517417317217016916816716616516416316216015915815715615515415315215014914814714614514414314214013913813713613513413313213012912812712612512412312212011811711611511411311211110910810710610510410310210110099919089888079787770696867666059585756555049484746454440393837363534333029282726252423222018171615141312119876543210

Probieren Sie es online aus oder überprüfen Sie, ob es alle Zahlen unter 1000 enthält .

Erläuterung:

            # 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 Bytes (nicht konkurrierend), Stringlänge 1133

Pyke ist neuer als die Herausforderung und daher nicht wettbewerbsfähig.

k~mV~oi{!o`*+

Probieren Sie es hier aus!

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

Wie lang ist die Ausgabe?
Kritixi Lithos

1

PHP, 48 44 Bytes

Vielen Dank an @primo, der mich daran erinnert hat ereg.

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

oder

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

Ausgabe: 1020 Zeichen. benötigt PHP <7

PHP 7, 48 Bytes:

ereg wurde in PHP 7 entfernt

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

Wenn das zweite Argument für strstr(oder strposandere Zeichenfolgensuchfunktionen) keine Zeichenfolge ist, wird es als ASCII-Code verwendet, sodass eine Umwandlung in eine Zeichenfolge $ierforderlich ist.


1
ereg($i,$s)für 4 (ich würde auch <?in die Byteanzahl einschließen ).
Primo

@primo Mir ist gerade aufgefallen, dass diese Herausforderung älter als PHP 7 ist. Vielen Dank. :)
Titus

eregwurde vermutlich entfernt, weil der Funktionsname zu kurz ist und / oder nicht genügend Unterstriche enthält. Das splitwurde auch beseitigt, ist besonders genial.
Primo

eregwurde entfernt, da POSIX nur einen Teil der Möglichkeiten von PCRE enthält; und wahrscheinlich wollten sie nicht zwei verschiedene bibliotheken unterhalten. Ich werde fragen, ob ich jemals wieder Rasmus Lerdorf treffen sollte. splitwurde entfernt, ist aber joingeblieben (wahrscheinlich, weil es "nur" ein Alias ​​ist). Entschuldigung für die Pedanterie; aber ich kenne leute, die ironie nicht erkennen können.
Titus

1

Groovy, 49 Zeichen / Byte

Ich war mir nicht sicher, ob ich dies als eine Funktion tun sollte, die eine Zeichenfolgenvariable zurückgibt, oder ob ich das Ergebnis ausdrucken sollte. Bei Verwendung des Regex-Matchers wurden 2 Bytes gespeichert, bei Verwendung des ternären Operators anstelle von "if" wurde ein anderes Byte gespeichert. Die Ausgabezeichenfolge besteht aus 1133 Zeichen.

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

Ausgabe:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

-1

Game Maker Language, 1014 - String 1000

show_message(909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900)

Ebenfalls:

Ruby, 1003 - String 1000

p'909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900'


3
1) Ihre erste Lösung verstößt gegen die Regel "Die Länge der Zeichenfolge muss unter 1500 Zeichen liegen". 2) Ich kann die Nummer 909 in Ihrer Ausgabe nicht finden. (Sie haben die erste Ziffer beim Einfügen aus der Antwort von primo verpasst ?) 3) Der rubyCode kann panstelle der putsÜbergabe einen numerischen Parameter verwenden.
Manatwork
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.