Un anneau pour les gouverner tous. Une chaîne pour tous les contenir

43

Objectifs: Produire une chaîne contenant chaque entier positif strictement inférieur à 1000.

La réponse évidente serait de les concaténer, ce qui créerait une chaîne de 2890 caractères (merci manatwork). Pour éviter ce genre de réponse facile, la longueur de la chaîne doit être inférieure à 1500 caractères. Voici un code Java simple qui génère une chaîne de 1 200 caractères.

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

Code le plus court gagnant, point bonus pour la plus courte chaîne!

code-golf string kolmogorov-complexity Fabinout
la source
11
La chaîne optimale comporte 1002 caractères.
Peter Taylor
8
En gros, vous demandez une séquence de De Bruijn B(10, 3) , mais comme vous n'autorisez pas le retour à la ligne cyclique, il est nécessaire de répéter les deux premiers caractères.
Peter Taylor
3
Mais je veux que la chaîne contienne 1, 2 ou 56, pas nécessairement 001 002 et 056.
Fabinout
6
Votre problème est impossible à résoudre parce que vous avez dit nombre pas entier . La chaîne devrait être d'une longueur infinie pour accueillir tous les nombres positifs inférieurs à 1000.
Ramchandra Apte
11
@RamchandraApte Et encore une chaîne, même avec une longueur infinie, serait absente de la plupart des nombres ;-)
Howard

Réponses:

19

Golfscript - 13 octets, 1315 sorties

991,{`.$2>>},

Ce qui précède sélectionne les nombres de 0 à 990 dont le premier chiffre est le plus grand chiffre du nombre, c.-à- d. Que le dernier chiffre de la représentation de chaîne triée est inférieur lexicographiquement à la chaîne elle-même. La logique est la suivante:

Pour un numéro à 3 chiffres abc , si a n'est pas le chiffre le plus grand du nombre, le nombre peut être ignoré, car il sera couvert par l'un des deux cas suivants:

  1. b <c (ex. 123 )
    Comme c est le chiffre le plus élevé, le nombre de cabines ne sera pas ignoré. Dans cet exemple, 312 ne sera pas ignoré, pas plus que la valeur suivante 313 qui, une fois concaténée ( 312 313 ), contient 123 .

  2. b ≥ c (par exemple 132 )
    Puisque b est le chiffre le plus grand, le nombre bca ne sera pas ignoré. Dans cet exemple, 321 ne sera pas ignoré, pas plus que la valeur suivante 322 qui, une fois concaténée ( 321 322 ), contient 132 . Si b = c (par exemple 122 ), ce cas est également valable. La valeur bca ne sera pas ignorée, comme auparavant, et comme a est nécessairement inférieur à b , bc <a + 1> nesera pas ignoré non plus. Dans cet exemple, 221 222 contient 122 .

Parce que le code ci-dessus teste le troisième chiffre, plutôt que strictement le dernier, toutes les valeurs comprises entre 0 et 99 sont incluses dans le résultat. Toutefois, les valeurs de 1 à 99 peuvent être omises, car si chaque séquence de 3 chiffres est présente, toutes les séquences de 1 et 2 chiffres doivent également l'être.

Les valeurs de 991 à 999 peuvent également être ignorées, car elles sont générées par ( 909 910 , 919 920 , ... 989 990 ).

Avec une puissance de sortie de 1315 octets, cela correspond à la spécification du problème de moins de 1500.

Sortie:

0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Variation # 1

14 octets, 1233 sorties

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

En sélectionnant strictement le dernier chiffre à comparer, plutôt que le troisième, de nombreuses valeurs inutiles inférieures à 100 sont éliminées, ce qui raccourcit la chaîne résultante.

101120212230313233404142434450515253545560616263646566707172737475767780818283848586878890919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Variation n ° 2

16 octets, 1127 sorties

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

En enlevant au préalable toutes les valeurs inférieures à 99 , la chaîne résultante peut être raccourcie encore plus.

99100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Golfscript - 19 octets, 1016 sorties

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

Ce qui précède compte de 99 à 909 , en ajoutant toute valeur qui n’est pas déjà apparue ( 909 serait normalement la dernière valeur ajoutée de cette manière). Déplacer 99 vers l’avant est une optimisation pour éviter d’avoir besoin du 910 à l’arrière.

Sortie:

99100101102103104105106107108109111112113114115116117118119120122123124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190192193194195196197198199200202203204205206207208209222223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333334335336337338339340344345346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444445446447448449450455456457458459460465466467468469470475476477478479480485486487488489490495496497498499500505506507508509555556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666667668669670677678679680687688689690697698699700707708709777778779780788789790798799800808809888889890899900909

Golfscript 26 octets, sortie 999

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

Notez que la chaîne de 1016 caractères générée par la solution précédente est presque optimale, sauf que vous devez avoir deux chiffres supplémentaires pour chaque multiple de 111 (c'est- 11111à- dire au lieu de 111, 22222au lieu de 222, etc.). La solution peut être optimisée en supprimant ces chiffres supplémentaires (en insérant seulement un chiffre à chacune de ces valeurs, au lieu de trois), et en effectuant 909une rotation vers l'avant pour éliminer un 9(ce qui diffère des versions précédentes, qui se déplaçait 9100à l'arrière )

Déroulé et commenté:

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

La logique de choix des caractères à ajouter suit trois cas:

  1. 111 ∤ n , n ⊄ s
    La valeur de la première vérification est 1 et de la seconde -1 .
    La tranche commencera à partir de l'index 0 ; il retournera la chaîne entière.
  2. 111 ∤ n , n ⊂ s
    La valeur de la première vérification est 1 et de la seconde quelque chose ≥ 2 .
    La tranche commencera à regarder à partir de l'indice ≥ 3 ; il retournera une chaîne vide.
  3. 111 ∣ n , n ⊄ s
    La valeur de la première vérification est 0 et de la seconde -1 .
    La tranche commencera à partir de l'index -1 ; il ne renverra que le dernier caractère.

La somme de la logique est que toute valeur qui n'est pas encore apparue sera ajoutée en entier, à moins qu'il ne s'agisse d'un multiple de 111 , auquel cas un seul caractère sera ajouté. Toutes les autres valeurs seront ignorées.

Notez que la chaîne produite est différente de la chaîne optimale produite par la réponse de Peter Taylor .

Histoire:

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

Sortie:

909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900
primo
la source
45

GolfScript ( 35 31 26 caractères)

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

La sortie est

000100110111200201210211220221222300301302310311312320321322330331332333400401402403410411412413420421422423430431432433440441442443444500501502503504510511512513514520521522523524530531532533534540541542543544550551552553554555600601602603604605610611612613614615620621622623624625630631632633634635640641642643644645650651652653654655660661662663664665666700701702703704705706710711712713714715716720721722723724725726730731732733734735736740741742743744745746750751752753754755756760761762763764765766770771772773774775776777800801802803804805806807810811812813814815816817820821822823824825826827830831832833834835836837840841842843844845846847850851852853854855856857860861862863864865866867870871872873874875876877880881882883884885886887888900901902903904905906907908910911912913914915916917918920921922923924925926927928930931932933934935936937938940941942943944945946947948950951952953954955956957958960961962963964965966967968970971972973974975976977978980981982983984985986987988990991992993994995996997998999

(1020 caractères) Il s'agit d'une variante de la méthode de concaténation de mots de Lyndon: plutôt que d'utiliser les mots primitifs à 1 caractère, elle utilise des multiples de 111 pour un code plus court mais des occurrences répétées de ces nombres; et plutôt que d'utiliser des éléments minimaux des groupes de conjugaison, il utilise des éléments maximaux, car cela raccourcit les boucles.

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

à 40 caractères (peut encore probablement être amélioré) génère une chaîne optimale, d'une longueur de 999 caractères:

100200300400500600700800901101201301401501601701801902102202302402502602702802903103203303403503603703803904104204304404504604704804905105205305405505605705805906106206306406506606706806907107207307407507607707807908108208308408508608708808909109209309409509609709809911121131141151161171181191221231241251261271281291321331341351361371381391421431441451461471481491521531541551561571581591621631641651661671681691721731741751761771781791821831841851861871881891921931941951961971981992223224225226227228229233234235236237238239243244245246247248249253254255256257258259263264265266267268269273274275276277278279283284285286287288289293294295296297298299333433533633733833934434534634734834935435535635735835936436536636736836937437537637737837938438538638738838939439539639739839944454464474484494554564574584594654664674684694754764774784794854864874884894954964974984995556557558559566567568569576577578579586587588589596597598599666766866967767867968768868969769869977787797887897987998889899900

Essayer de faire cela en inversant les chaînes se heurte à des problèmes en omettant les multiples de 111.

Pour voir que 999 est la longueur optimale (puisque mes brefs commentaires ci-dessus ne convainquent pas tout le monde), commençons par la séquence complète de Bruijn qui (prise comme une chaîne cyclique) contient toutes les séquences de caractères à 3 chiffres de 0 à 9. il y en a 1000, il doit y avoir au moins 1000 caractères; Il est généralement prouvé par une marche eulérienne sur un graphe dont les nœuds sont des séquences xyà deux chiffres avec 10 arêtes, chacune étiquetée avec un chiffre z, qui porte xyà yz.

Nous n'avons pas besoin de séquences commençant 0, donc avec une séquence de Bruijn, nous pouvons effectuer une rotation pour mettre 000à la fin. Ensuite, nous n'avons besoin d'aucune des séquences qui se terminent au début, mais nous avons besoin de deux des 0s pour terminer la séquence en commençant par le chiffre précédent 000. Nous pouvons donc en supprimer une pour obtenir une chaîne de 999 caractères. Chaque reste 0est utilisé dans un nombre qui ne commence pas par 0.

Peter Taylor
la source
8
C'est vraiment impressionnant !!
Fabinout
Je préférerais utiliser une approche de filtrage ou générative. Pour l'approche pseudo-Lyndon, j'ai l'approche générative jusqu'à 32 caractères: 10,:^{:x^>{x.@:&<+^>{x&@}/}/}/0.Varier que pour les vrais mots Lyndon donne 10,:^{:x^>{x.@:&<+^>{.x>{x&@}*}/}/}%3>0.(40 caractères) la chaîne optimale.
Peter Taylor
Pouvez-vous raccourcir la chaîne optimale en n'utilisant pas de zéros à gauche pour les nombres inférieurs à 100?
Random832
1
@ Random832 Je suis sûr que tu ne peux pas. Vous devez inclure les nombres 100, 200, ... 900, donc la chaîne minimale va certainement avoir huit occurrences de 00X (une peut être à l'extrême droite, comme ci-dessus). Notez que la chaîne optimale donnée ne contient pas "001".
tttppp
2
Normalement, je ne vote pas le code, je ne comprends pas, mais dans ce cas, je le vote parce que je ne comprends pas. Bravo.
Ben Jackson
29

GolfScript, 17 caractères

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

Approche simple pour ajouter chaque nombre s'il n'est pas déjà présent dans la chaîne (note: 999 n'est ni coché ni ajouté, mais déjà contenu dans la sortie).

La sortie est 1133 caractères:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
Howard
la source
20

Je n'ai pas de code, mais j'ai pensé que quelqu'un pourrait apprécier cette preuve intuitive que 999 caractères est la limite inférieure de la longueur de la sortie:

Tout d'abord, chaque numéro à 1 ou 2 chiffres fait partie d'un nombre à 3 chiffres, donc ignorez tout ce qui est inférieur à 100. 100 à 999 inclus est 900 numéros à 3 chiffres.

Le moyen le plus optimal de résoudre le problème consiste à utiliser chaque caractère autant que possible. Cela signifie que les chiffres se chevauchent autant que possible, comme ceci:

123
 234
  345

Le premier numéro ajoutera donc 3 caractères, et chaque numéro suivant ajoutera 1 caractère. Cela donne 3 + 899 = 902 caractères en tant que limite inférieure.

Cependant, lorsqu'il y a un zéro, nous ne pouvons pas l'utiliser pour créer un nouveau nombre à 3 chiffres. Nous pouvons le réutiliser au milieu d'un autre numéro à 3 chiffres, tant qu'il n'est pas suivi d'un autre zéro:

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

Mais:

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

Par conséquent, chaque zéro qui apparaît dans la sortie étend la sortie de 1 caractère - à l'exception des deux derniers caractères qui peuvent être zéro car ils ne chevauchent aucun autre nombre:

???
 ??0
  ?00

Il y a 81 nombres avec strictement un zéro au milieu (? 0?), 81 avec strictement un zéro à la fin (?? 0) et 9 avec deux zéros (? 00).

Chaque numéro ?? 0 peut partager un zéro avec un? 0? nombre ou un nombre? 00, mais pas les deux. ? 0? et? 00 ne peut jamais partager de zéros, il doit donc y avoir au moins 81 + 9 * 2 zéros dans la sortie.

Cela donne une limite inférieure de 3 + 899 + 81 + 9 * 2 - 2 = 999 caractères.

Toutes mes excuses si cela est considéré comme hors sujet, mais c'était trop long pour tenir dans un commentaire.

Alistair Buxton
la source
1
Merci pour l'information! C'est un peu drôle que la chaîne qui contient tous les entiers inférieurs à 999 est de 999 caractères.
Fabinout
1
Voir aussi: en.wikipedia.org/wiki/De_Bruijn_sequence .
Liori
1
C'est assez drôle de remarquer que stocker chaque nombre jusqu'à 999 dans une chaîne en fait 999 caractères. Corrigez-moi si je me trompe, mais je pense que stocker chaque nombre jusqu'à 99 en fait un long de 100 caractères.
Fabinout
2
Par le même argument, la limite inférieure est 2 + 89 + 9 - 1 = 99 mais cela ne prouve pas que 99 est possible, seulement que 98 ne l’est pas.
Alistair Buxton
17

Perl, 37 34 33 32 (1136 1132 caractères)

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

pour $ @ (1..999) {$ _. = $ @ if! / $ @ /} print

pour $ i (1..999) {$ _. = $ i if! / $ i /} print

pour (1..1e3) {$ s. = $ _ si $ s! ~ / $ _ /} print $ s

Les sorties:

12345678910111314151617181920212224252627282930323335363738394043444647484950545557585960656668697076777980878890991001021031041051061071081091101121141151161171181191201241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901931941951961971981992002032042052062072082092192202212232252262272282292302312352362372382392402432442452462472482492502532542552562572582592602632642652662672682692702732742752762772782792802832842852862872882892902942952962972982993003043053063073083093113293303323343363373383393403423463473483493503543553563573583593603643653663673683693703743753763773783793803843853863873883893903953963973983994004054064074084094224394404434454474484494504534574584594604654664674684694704754764774784794804854864874884894904964974984995005065075085095335495505545565585595605645685695705765775785795805865875885895905975985996006076086096446596606656676696706756796806876886896906986997007087097557697707767787807867907977998008098668778798808878888978988999009089329439549659769799879891000

Chaîne plus courte: 38 37 34 (1020 caractères):

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

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

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

Les sorties:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Toujours pas content de la duplication surtout le 99999 au début! Je pense que beaucoup plus de contrôles créeraient beaucoup plus de code si ...

Edit: Ajout de la suggestion de @Peter Taylor

Edit 2: Quelques bonnes suggestions de @primo! Merci

Dom Hastings
la source
2
Belle astuce pour écrire 1000 en 1e3, mais je pense que c'est inutile. La question dit «strictement en dessous de 1000», ce qui voudrait dire jusqu'à 999 inclus. (Le code de code traite également de 0 à 999.)
manatwork
Un excellent point! J'ai eu une boucle différente pour commencer, j'ai modifié cela en conséquence! Merci!
Dom Hastings
3
Si vous utilisez un caractère non alphabétique pour votre variable, pouvez-vous supprimer l'espace?
Peter Taylor
Ahhh oui, je peux! Merci!
Dom Hastings
2
Quelques améliorations mineures supplémentaires: au lieu de cela $_.=$@if!/$@/, vous pouvez utiliser la répétition de chaîne $_.=$@x!/$@/. Le forpeut être remplacé par un whilemodificateur d'instruction, à l'aide d'un modulo:...while$@=--$@%1e3
primo
10

APL (20, sortie: 1020)

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

Explication:

  • {∨/⍺⍷⍵:⍵⋄⍵,⍺}: si ⍺est une sous-chaîne de ⍵, return ⍵, return return⍵,⍺
  • /: réduire plus
  • ⍕¨: la représentation sous forme de chaîne de chacun des
  • ⍳999: les entiers de 1à 999.

Sortie:

9999989979969959949939929919909889879869859849839829819809789779769759749739729719709689679669659649639629619609589579569
      55954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913
      91291191090890790690590490390290190088888788688588488388288188087787687587487387287187086786686586486386286186085785
      68558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108
      07806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735
      73473373273173072672572472372272172071671571471371271171070670570470370270170066666566466366266166065565465365265165
      06456446436426416406356346336326316306256246236226216206156146136126116106056046036026016005555545535525515505445435
      42541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411
      410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

APL (41, sortie: 999)

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

Explication:

  • ⌽⍕¨100+⍳898: ('999' '998' ... '101')(dans l'ordre inverse, car la réduction va de droite à gauche dans APL, c'est-à-dire F/a b c ≡ a F (b F c))
  • /: réduire
  • ⍵,⍺⍴⍨: argument de droite, suivi des premiers Ncaractères de l'argument de gauche, où Nest:
  • 3×~∨/⍺⍷⍵: 3si ⍺n'est pas une sous-chaîne de ⍵, sinon0
  • (1=⍴∪⍺): 1si ⍺seulement un caractère unique, sinon0
  • ∨: plus grand commun diviseur des deux valeurs précédentes, donc: 1si ⍺n'est pas déjà entré ⍵et n'a qu'un seul caractère, 3s'il ⍺n'est pas déjà ⍵mais a plus d'un caractère unique, 0sinon.
  • '0',⍨: ajoute un zéro à la fin du résultat

Sortie:

10110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451
      46147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188
      18919019219319419519619719819920020220320420520620720820922232242252262272282292302332342352362372382392402432442452
      46247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294
      29529629729829930030330430530630730830933343353363373383393403443453463473483493503543553563573583593603643653663673
      68369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444544644744844945045545645
      74584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566
      56756856957057657757857958058658758858959059659759859960060660760860966676686696706776786796806876886896906976986997
      00707708709777877978078878979079879980080880988898908999009099100
marinus
la source
8

Ruby: 50 46 caractères (sortie de 1020 caractères)

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

Échantillon échantillon:

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

Essai:

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 caractères (sortie de 999 caractères)

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

Échantillon échantillon:

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

Essai:

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]}'
[]
homme au travail
la source
Belle idée de passer de 999 à 0 et non l'inverse. Avec cela, ma méthode Java génère une chaîne de 1048 caractères (au lieu de 1200).
Fabinout
1
Si vous ne vous inquiétez que de la longueur du code et non de la longueur de sortie, vous pouvez améliorer le premier en utilisant une plage de chaînes. Quelque chose comme (?0..?9*3).map{|i|$/[i]||($><<i;$/+=i)}peut-être?
Paul Prestidge
5

JavaScript, 39

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

Sortie de 1020 caractères:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100


Vérification: for(i=0;i<1000;i++)console.assert(k.indexOf(i)>=0)

copie
la source
5

Mathematica ( 62 64 caractères, 1002 sorties)

Parce que cela utilise une fonction native, j'apprécie d'autant plus la beauté des solutions plus courtes à partir de zéro. La sortie est longue de 1002 caractères.

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

"799798787770760750740730720710980970960950940930920910108908708608508408308208889998988081009909008007006005004003002000190180170160150140130120119118117116115114113112912812712612512412312213913813713613513413313214914814714614514414314215915815715615515415315216916816716616516416316217917817717617517417317218918818718618518418318219919819719619519419319212111029028027026025024023022922822722622522422392382372362352342332492482472462452442432592582572562552542532692682672662652642632792782772762752742732892882872862852842832992982972962952942932322202103903803703603503403393383373363353349348347346345344359358357356355354369368367366365364379378377376375374389388387386385384399398397396395394343330320310490480470460450449448447446445945845745645546946846746646547947847747647548948848748648549949849749649545444043042041059058057056055955855755695685675665795785775765895885875865995985975965655505405305205106906806706696686679678677689688687699698697676660650640630620610790780779778978879"
DavidC
la source
1
vous semblez manquer 799 et 997. Voir ideone.com/d07bG2 (ou faites votre propre chèque)
Justin
Bonne prise. Par défaut, DeBruijnSequencesuppose un wrapping cyclique. Le préfixe "79", les deux derniers chiffres, résout le problème.
DavidC
4

Mathematica, 51 caractères

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

Sortie (1155 caractères):

000100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999
Alephalpha
la source
Qu'est ce que ça fait?
Fabinout
1
Elle construit une liste de listes de la forme {i, j, k}où iune valeur de 0 à 9 et j, ksont plus petites que i. Ensuite, il convertit la liste en une chaîne.
Alephalpha
4

Python - 53 63, 1134 sortie

C'est assez brutal, mais c'est valable. Oui, il a un zéro, mais il enregistre deux caractères en l’absence de range(1,1000).

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

Ce qui précède jette un DeprecationWarningsur l'utilisation de 1e3 dans l' range()appel, mais enregistre un caractère sur 1000.

Il existe également une version légèrement plus optimale de la longueur, en inversant la chaîne au prix de 65 personnages (merci à res et filmor pour les astuces) :

Python - 58, 1021 sorties

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

la source
1
Je trouve que votre premier programme a une longueur de sortie de 1133, pas de 1132. En Python 2 (mais pas Python 3), vous pouvez raccourcir le code à 54 caractères en utilisant des backticks:for i in range(999):s+=`i`*(not`i`in s)
res
Wot? Ils ont sorti des backticks? Guido devait avoir un I Hate Perl et tout ce qui lui ressemble jour pour décider quoi garder.
Warren P
1
Vous pouvez raccourcir cela d'un caractère en utilisant à la range(999,99,-1)place de range(1000)[::-1].
Filmor
Et le conseil de res toujours utile, str(i)*(str(i)not in s)est un peu plus court que i=str(i);s+=[i,''][i in s];)
filmor
@filmor Fait plus petit, et plus petit encore en utilisant 1e3au lieu de1000
2

K, 33

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

Fondamentalement identique à la solution Howards - 1133 caractères.

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
tmartin
la source
2

Java - 126 98 caractères (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);}}

Sortie (1020 caractères):

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Peut atteindre une bonne longueur (selon Peter Taylor , mais plus tard il a dit que 999 était optimal) Longueur de la chaîne en ajoutant quelques caractères (+20 caractères pour 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);}}

Sortie (1002 caractères):

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110101100

Edit : Merci à Fabinout pour avoir signalé que Java 6 peut enregistrer 28 caractères.

Justin
la source
Si vous le souhaitez, vous pouvez compiler avec Java 6 et utiliser un bloc statique à la place de System.out.println () !!
Fabinout
@Fabinout Voulez-vous dire au lieu d'un public static void main(String[]a)? (qui changerait mon code de ...public static void main(String[]c){...à ...static{...)
Justin
Oui. vous pouvez essayer avec Java 6.
Fabinout
Au fait, vous devriez utiliser exit () à la fin de votre bloc statique si vous ne voulez pas que votre programme plante. Même s'il n'est pas nécessaire de jouer au golf pour ne pas tomber en panne.
Fabinout
2

Windows PowerShell - 40, sortie 1020

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

Sortie:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100
goric
la source
2

Haskell, 75 octets - 1002 sorties

Une approche de tamis qui renvoie une solution minimale.

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

Notez que cette solution est peu pratique.

Thomas Eding
la source
Vous devez inclure l'importation de Data.Listpour isInfixOf, mais vous pouvez toujours enregistrer 2 octets par ce golf un peu plus: 1) hardcode n = 10002) Utilisation allplus andet une version Pointfree de l'utilisation prédicat 3) (!!0)sur head4) Utilisez la liste-compréhension sur la combinaison de map& filter5) utiliser (<$>)sur map:[s|s<-show<$>[1..],all((`isInfixOf`s).show)[1..1000]]!!0
ბიმო
2

Powershell, 36 octets, 1020 sorties

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

Sortie:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Alternative, 69 octets, 1000 sorties

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

Sortie:

9998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888788688588488388288188087787687587487387287187086786686586486386286186085785685585485385285185084784684584484384284184083783683583483383283183082782682582482382282182081781681581481381281181080780680580480380280180077767757747737727717707667657647637627617607567557547537527517507467457447437427417407367357347337327317307267257247237227217207167157147137127117107067057047037027017006665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555455355255155054454354254154053453353253153052452352252152051451351251151050450350250150044434424414404334324314304234224214204134124114104034024014003332331330322321320312311310302301300222122021121020120011101100

Alternative, 82 73 octets, 999 sorties (minimum)

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

Ceci est un algorithme simplifié de Generate le plus court de De Bruijn adapté aux constantes: alphabet = 9876543210et length =3

Sortie:

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110100

Script de test:

$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
mazzy
la source
2

05AB1E , 9 octets et 1109 caractères

₄FDNå_iNì

Les sorties:

90990190089989088981980980880079979879078978878077977870970870770069969869769068968868768067967867767066966866760960860760660059959859759659058958858758658057957857757657056956856756656055955855755650950850750650550049949849749649549048948848748648548047947847747647547046946846746646546045945845745645545044944844744644540940840740640540440039939839739639539439038938838738638538438037937837737637537437036936836736636536436035935835735635535435034934834734634534434033933833733633533430930830730630530430330029929829729629529429329028928828728628528428328027927827727627527427327026926826726626526426326025925825725625525425325024924824724624524424324023923823723623523423323022922822722622522422320920820720620520420320220019919719619519419319219118918818718618518418318218017917817717617517417317217016916816716616516416316216015915815715615515415315215014914814714614514414314214013913813713613513413313213012912812712612512412312212011811711611511411311211110910810710610510410310210110099919089888079787770696867666059585756555049484746454440393837363534333029282726252423222018171615141312119876543210

Essayez-le en ligne ou vérifiez qu'il contient tous les chiffres inférieurs à 1000 .

Explication:

₄            # 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)
Kevin Cruijssen
la source
1

Pyke, 13 octets (sans compétition), longueur de chaîne 1133

Pyke est plus récent que le défi et est donc non compétitif.

k~mV~oi{!o`*+

Essayez-le ici!

              - o = 0
k~mV          - repeat 1000 times, i = ""
    ~oi{      -     str(o) in i
        !     -    not ^
         o`*  -   str(o++) * ^
            + -  i += ^
Bleu
la source
Combien de temps dure la sortie?
Kritixi Lithos
1

PHP, 48 44 octets

Merci à @primo de me l'avoir rappelé ereg.

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

ou

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

sortie: 1020 caractères. nécessite PHP <7

PHP 7, 48 octets:

ereg a été supprimé en PHP 7

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

Si le second argument de strstr(ou strposet d'autres fonctions de recherche de chaîne) n'est pas une chaîne, il sera utilisé comme code ASCII. $iUn transtypage en chaîne est donc nécessaire.

Titus
la source
1
ereg($i,$s)pour 4 (je voudrais également inclure <?dans le nombre d'octets).
Primo
@primo Je viens de remarquer que ce challenge est plus ancien que PHP 7. double merci. :)
Titus
erega probablement été supprimé, car le nom de la fonction est trop court et / ou ne contient pas assez de traits de soulignement. Cela splita également été supprimé est particulièrement brillant.
dimanche
erega été supprimé car POSIX ne contient qu’un sous-ensemble des possibilités de PCRE; et ils ne voulaient probablement pas maintenir deux bibliothèques différentes. Je demanderai si je rencontre encore Rasmus Lerdorf. splita été supprimé, mais joinest resté (probablement parce que c’est "seulement" un alias). Désolé pour le pédantisme; mais je connais des gens qui ne peuvent pas reconnaître l'ironie.
Titus
1

Groovy, 49 caractères / octets

Je ne savais pas si cela deviendrait une fonction renvoyant une variable de chaîne ou imprimant le résultat. Elle est donc simplement imprimée sur stdout. En utilisant le matcher regex enregistré 2 octets, en utilisant l'opérateur ternaire au lieu de "si" a enregistré un autre octet. La chaîne de sortie contient 1133 caractères.

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

Sortie:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
Rado
la source
-1

Jeu Game Maker Language, 1014 - String 1000

show_message(909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900)

Également:

Ruby, 1003 - Corde 1000

p'909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900'

Timtech
la source
3
1) Votre première solution enfreint la règle «la longueur de la chaîne doit être inférieure à 1500 caractères». 2) Je ne trouve pas le numéro 909 dans votre sortie. (Vous avez manqué le premier chiffre lors du copier-coller de la réponse de primo ?) 3) Le rubycode peut utiliser pau lieu de lui putstransmettre le paramètre numérique.
Manatwork