Un anello per domarli tutti. Una stringa per contenerli tutti

43

Obiettivi: produrre una stringa che contenga tutti i numeri interi positivi al di sotto di 1000.

La risposta ovvia sarebbe quella di concatenare ognuno di essi, e ciò creerebbe una stringa di 2890 caratteri (grazie all'opera d'arte), per evitare questo tipo di risposta facile, la lunghezza della stringa deve essere inferiore a 1500 caratteri. Ecco un semplice codice Java che genera una stringa da 1200 caratteri.

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

Vincita del codice più breve, punto bonus per la stringa più corta!

code-golf  string  kolmogorov-complexity 
— Fabinout
fonte
11
La stringa ottimale è lunga 1002 caratteri.
— Peter Taylor,
8
Fondamentalmente stai chiedendo una sequenza de Bruijn B(10, 3) , ma poiché non permetti il ​​wrapping ciclico è necessario ripetere i primi due caratteri.
— Peter Taylor,
3
Ma voglio che la stringa contenga 1, 2 o 56, non necessariamente 001 002 e 056.
— Fabinout,
6
Il tuo problema è impossibile da risolvere perché hai detto numero non intero . La stringa dovrebbe essere di lunghezza infinita per contenere tutti i numeri positivi inferiori a 1000.
— Ramchandra Apte
11
@RamchandraApte E comunque qualsiasi stringa anche con lunghezza infinita mancherebbe la maggior parte dei numeri ;-)
— Howard

Risposte:

19

Golfscript - 13 byte, 1315 output

991,{`.$2>>},

Quanto sopra seleziona quei numeri da 0 a 99 la cui prima cifra è la cifra più grande del numero, ovvero l'ultima cifra della rappresentazione della stringa ordinata è lessicograficamente inferiore alla stringa stessa. La logica è la seguente:

Per un numero di 3 cifre abc , se a non è la cifra più grande del numero, il numero my verrà ignorato, poiché in seguito verrà coperto da uno dei due casi:

  1. b <c (es. 123 )
    Poiché c è la cifra più grande, il numero di cabina non verrà ignorato. In questo esempio 312 non verrà ignorato, né verrà visualizzato il valore successivo 313 , che quando concatenato ( 312 313 ) contiene 123 .

  2. b ≥ c (es. 132 )
    Poiché b è la cifra più grande, il numero bca non verrà ignorato. In questo esempio 321 non verrà ignorato, né il prossimo valore 322 , che quando concatenato ( 321 322 ), contiene 132 . Se b = c (ad es. 122 ), vale anche questo caso. Il valore bca non verrà ignorato, come in precedenza, e poiché a è necessariamente inferiore a b ,neppure bc <a + 1> verrà ignorato. In questo esempio, 221 222 contiene 122 .

Poiché il codice sopra testa la terza cifra, piuttosto che l'ultima, tutti i valori compresi tra 0 e 99 sono inclusi nel risultato. I valori da 1 a 99 possono essere ignorati, perché se è presente ogni sequenza di 3 cifre, deve essere presente anche ogni sequenza di 1 cifra e 2 cifre.

I valori da 991-999 possono anche essere saltati, poiché sono generati da ( 909 910 , 919 920 , ... 989 990 ).

A 1315 byte di output, questo è comodamente sotto le specifiche del problema di meno di 1500.

Produzione:

0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Variazione n. 1

14 byte, uscita 1233

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

Selezionando rigorosamente l'ultima cifra per il confronto, anziché la terza, vengono eliminati molti dei valori non necessari inferiori a 100 , accorciando la stringa risultante.

101120212230313233404142434450515253545560616263646566707172737475767780818283848586878890919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Variazione n. 2

16 byte, uscita 1127

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

Facendo leva su tutti i valori inferiori a 99 in anticipo, la stringa risultante può essere accorciata ancora di più.

99100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Golfscript - 19 byte, 1016 output

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

Quanto sopra conta da 99 a 909 , aggiungendo qualsiasi valore che non è già apparso ( 909 sarebbe normalmente l'ultimo valore aggiunto in questo modo). Spostare 99 in avanti è un'ottimizzazione per evitare di aver bisogno di 910 sul retro.

Produzione:

99100101102103104105106107108109111112113114115116117118119120122123124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190192193194195196197198199200202203204205206207208209222223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333334335336337338339340344345346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444445446447448449450455456457458459460465466467468469470475476477478479480485486487488489490495496497498499500505506507508509555556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666667668669670677678679680687688689690697698699700707708709777778779780788789790798799800808809888889890899900909

Golfscript 26 byte, 999 output

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

Si noti che la stringa di caratteri 1016 prodotta dalla soluzione precedente è quasi ottimale, tranne per avere due cifre extra per ogni multiplo di 111 (ovvero 11111anziché 111, 22222anziché 222, ecc.). La soluzione può essere resa ottimale rimuovendo queste cifre extra (inserendo solo una cifra per ciascuno di questi valori, anziché tre), e ruotando 909in avanti, eliminando un 9(questo differisce dalle versioni precedenti, che invece si spostavano 9100sul retro ).

Non srotolato e commentato:

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 logica per scegliere quali caratteri vengono aggiunti segue tre casi:

  1. 111 ∤ n , n ⊄ s
    Il valore del primo controllo è 1 e del secondo -1 .
    La sezione inizierà a partire dall'indice 0 ; restituirà l'intera stringa.
  2. 111 ∤ n , n ⊂ s
    Il valore dal primo controllo è 1 e dal secondo qualcosa ≥ 2 .
    La sezione inizierà a fissare dall'indice ≥ 3 ; restituirà una stringa vuota.
  3. 111 ∣ n , n ⊄ s
    Il valore dal primo controllo è 0 e dal secondo -1 .
    La sezione inizierà a partire dall'indice -1 ; restituirà solo l'ultimo carattere.

La somma della logica è che qualsiasi valore che non è ancora apparso verrà aggiunto per intero - a meno che non sia un multiplo di 111 , nel qual caso verrà aggiunto solo un carattere. Tutti gli altri valori verranno ignorati.

Nota che la stringa prodotta è diversa da quella ottimale prodotta dalla risposta di Peter Taylor .

Storia:

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

Produzione:

909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900
— Primo
fonte
45

GolfScript ( 35 31 26 caratteri)

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

L'output è

000100110111200201210211220221222300301302310311312320321322330331332333400401402403410411412413420421422423430431432433440441442443444500501502503504510511512513514520521522523524530531532533534540541542543544550551552553554555600601602603604605610611612613614615620621622623624625630631632633634635640641642643644645650651652653654655660661662663664665666700701702703704705706710711712713714715716720721722723724725726730731732733734735736740741742743744745746750751752753754755756760761762763764765766770771772773774775776777800801802803804805806807810811812813814815816817820821822823824825826827830831832833834835836837840841842843844845846847850851852853854855856857860861862863864865866867870871872873874875876877880881882883884885886887888900901902903904905906907908910911912913914915916917918920921922923924925926927928930931932933934935936937938940941942943944945946947948950951952953954955956957958960961962963964965966967968970971972973974975976977978980981982983984985986987988990991992993994995996997998999

(1020 caratteri) Questa è una variante dell'approccio di concatenazione delle parole di Lyndon: piuttosto che usare le parole primitive a 1 carattere usa multipli di 111 per codice più breve ma ripetute occorrenze di quei numeri; e piuttosto che usare elementi minimi dei gruppi di coniugazione usa elementi massimi, perché ciò accorcia i circuiti.

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

a 40 caratteri (probabilmente può ancora essere migliorato) genera una stringa ottimale, che è di lunghezza 999 caratteri:

100200300400500600700800901101201301401501601701801902102202302402502602702802903103203303403503603703803904104204304404504604704804905105205305405505605705805906106206306406506606706806907107207307407507607707807908108208308408508608708808909109209309409509609709809911121131141151161171181191221231241251261271281291321331341351361371381391421431441451461471481491521531541551561571581591621631641651661671681691721731741751761771781791821831841851861871881891921931941951961971981992223224225226227228229233234235236237238239243244245246247248249253254255256257258259263264265266267268269273274275276277278279283284285286287288289293294295296297298299333433533633733833934434534634734834935435535635735835936436536636736836937437537637737837938438538638738838939439539639739839944454464474484494554564574584594654664674684694754764774784794854864874884894954964974984995556557558559566567568569576577578579586587588589596597598599666766866967767867968768868969769869977787797887897987998889899900

Se si tenta di eseguire questa operazione, le stringhe inverse si verificano problemi con l'omissione dei multipli di 111.

Per vedere che 999 è la lunghezza ottimale (poiché i miei brevi commenti sopra non convincono tutti), inizia dalla sequenza completa di Bruijn che (presa come una stringa ciclica) contiene ogni sequenza di 3 cifre di caratteri da 0 a 9. Poiché ce ne sono 1000, deve contenere almeno 1000 caratteri; che può essere precisamente lungo 1000 caratteri è di solito dimostrato da una passeggiata euleriana su un grafico i cui nodi sono sequenze di due cifre xycon 10 spigoli, ciascuno etichettato con una cifra z, che porta xya yz.

Non abbiamo bisogno di iniziare le sequenze 0, quindi data una sequenza di de Bruijn possiamo ruotare per mettere 000alla fine. Quindi non abbiamo bisogno di nessuna delle sequenze che si avvolgono all'inizio, ma abbiamo bisogno di due delle 0s per terminare la sequenza che inizia con la cifra prima 000, quindi possiamo eliminarne una per ottenere una stringa di 999 caratteri. Ogni rimanente 0viene utilizzato in un numero che non inizia con 0.

— Peter Taylor
fonte
8
È davvero impressionante !!
— Fabinout,
Preferirei usare un approccio filtrante o generativo. Per l'approccio pseudo-Lyndon ho l'approccio generativo fino a 32 caratteri: 10,:^{:x^>{x.@:&<+^>{x&@}/}/}/0.Variabile che per le parole reali di Lyndon dà 10,:^{:x^>{x.@:&<+^>{.x>{x&@}*}/}/}%3>0.(40 caratteri) per la stringa ottimale.
— Peter Taylor,
È possibile ottenere la stringa ottimale più breve non utilizzando zeri iniziali per numeri inferiori a 100?
— Casuale 832
1
@ Random832 Sono abbastanza sicuro che non puoi. Devi includere i numeri 100, 200, ... 900, quindi la stringa minima avrà sicuramente otto ricorrenze di 00X (una può essere all'estrema destra, come sopra). Si noti che la stringa ottimale fornita non contiene "001".
— tttppp,
2
Normalmente non aggiorno il codice che non capisco, ma in questo caso lo sto votando perché non capisco. Bravo.
— Ben Jackson,
29

GolfScript, 17 caratteri

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

Approccio semplice per aggiungere ogni numero se non è già presente nella stringa (nota: 999 non è controllato o aggiunto, ma contenuto già nell'output).

L'output è di 1133 caratteri:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
— Howard
fonte
20

Non ho alcun codice, ma ho pensato che qualcuno potesse apprezzare questa prova intuitiva che 999 caratteri è il limite inferiore alla lunghezza dell'output:

Innanzitutto, ogni numero di 1 e 2 cifre fa parte di un numero di 3 cifre, quindi ignora tutto meno di 100. 100-999 incluso è 900 numeri di 3 cifre.

Il modo più ottimale per risolvere il problema è se ogni personaggio viene usato il più possibile. Ciò significa che i numeri si sovrappongono il più possibile, in questo modo:

123
 234
  345

Il primo numero aggiungerà quindi 3 caratteri e ogni numero successivo aggiungerà 1 carattere. Questo dà 3 + 899 = 902 caratteri come limite inferiore.

Tuttavia, quando c'è uno zero, non possiamo usarlo per iniziare un nuovo numero di 3 cifre. Possiamo riutilizzarlo nel mezzo di un altro numero di 3 cifre, purché non sia seguito da un altro zero:

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

Ma:

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

Pertanto, ogni zero che appare nell'output estende l'output di 1 carattere, ad eccezione degli ultimi due caratteri che possono essere zero poiché non si sovrappongono ad altri numeri:

???
 ??0
  ?00

Ci sono 81 numeri con rigorosamente uno zero nel mezzo (? 0?), 81 con rigorosamente uno zero alla fine (?? 0) e 9 con due zeri (? 00).

Ogni numero ?? 0 può condividere uno zero con uno? 0? numero o un numero? 00, ma non entrambi. ? 0? e? 00 non possono mai condividere zeri, quindi devono esserci almeno 81 + 9 * 2 zeri nell'output.

Questo dà un limite inferiore di 3 + 899 + 81 + 9 * 2 - 2 = 999 caratteri.

Ci scusiamo se questo è considerato fuori tema, ma era troppo lungo per inserirsi in un commento.

— Alistair Buxton
fonte
1
Grazie per il testa a testa! È abbastanza divertente che la stringa che contiene tutti i numeri inferiori a 999 sia lunga 999 caratteri.
— Fabinout,
1
— liori,
1
È abbastanza divertente notare che la memorizzazione di ogni numero fino a 999 in una stringa lo rende lungo 999 caratteri. Correggimi se sbaglio, ma credo che la memorizzazione di ogni numero fino a 99 lo rende lungo 100 caratteri.
— Fabinout,
2
Per lo stesso argomento, il limite inferiore è 2 + 89 + 9 - 1 = 99 ma questo non dimostra che 99 sia possibile, solo che 98 non lo è.
— Alistair Buxton,
17

Perl, 37 34 33 32 (1136 1132 caratteri)

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

a $ @ (1..999) {$ _. = $ @ se! / $ @ /} stampa

per $ i (1..999) {$ _. = $ i se! / $ i /} stampa

per (1..1e3) {$ s. = $ _ se $ s! ~ / $ _ /} stampa $ s

Uscite:

12345678910111314151617181920212224252627282930323335363738394043444647484950545557585960656668697076777980878890991001021031041051061071081091101121141151161171181191201241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901931941951961971981992002032042052062072082092192202212232252262272282292302312352362372382392402432442452462472482492502532542552562572582592602632642652662672682692702732742752762772782792802832842852862872882892902942952962972982993003043053063073083093113293303323343363373383393403423463473483493503543553563573583593603643653663673683693703743753763773783793803843853863873883893903953963973983994004054064074084094224394404434454474484494504534574584594604654664674684694704754764774784794804854864874884894904964974984995005065075085095335495505545565585595605645685695705765775785795805865875885895905975985996006076086096446596606656676696706756796806876886896906986997007087097557697707767787807867907977998008098668778798808878888978988999009089329439549659769799879891000

Stringa più corta: 38 37 34 (1020 caratteri):

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

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

per ($ i = 1e3; $ i -;) {$ _. = $ i se! / $ i /} stampa

Uscite:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Ancora non contento della duplicazione soprattutto all'inizio del 99999! Penso che molti più controlli creerebbero molto più codice però ...

Modifica: aggiunto il suggerimento di @Peter Taylor

Modifica 2: alcuni fantastici suggerimenti di @primo! Grazie

— Dom Hastings
fonte
2
Bel trucco per scrivere 1000 come 1e3, ma penso che sia inutile. La domanda dice "rigorosamente inferiore a 1000", che significherebbe fino a 999 inclusi. (Il codice di esempio elabora anche 0..999.)
— manatwork
Un punto eccellente! Ho avuto un ciclo diverso per cominciare, l'ho modificato di conseguenza! Grazie!
— Dom Hastings,
3
Se usi un carattere non alfabetico per la tua variabile, puoi rimuovere lo spazio?
— Peter Taylor,
Ahhh sì, posso! Grazie!
— Dom Hastings,
2
Alcuni miglioramenti minori: invece di $_.=$@if!/$@/, puoi usare la ripetizione di stringhe $_.=$@x!/$@/. La forpuò essere sostituito da una whilecome modificatore dichiarazione, utilizzando un modulo:...while$@=--$@%1e3
— primo
10

APL (20, uscita: 1020)

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

Spiegazione:

  • {∨/⍺⍷⍵:⍵⋄⍵,⍺}: if ⍺è una sottostringa di ⍵, return ⍵, else return⍵,⍺
  • /: ridurre oltre
  • ⍕¨: la rappresentazione di stringa di ciascuno di
  • ⍳999: i numeri interi da 1a 999.

Produzione:

9999989979969959949939929919909889879869859849839829819809789779769759749739729719709689679669659649639629619609589579569
      55954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913
      91291191090890790690590490390290190088888788688588488388288188087787687587487387287187086786686586486386286186085785
      68558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108
      07806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735
      73473373273173072672572472372272172071671571471371271171070670570470370270170066666566466366266166065565465365265165
      06456446436426416406356346336326316306256246236226216206156146136126116106056046036026016005555545535525515505445435
      42541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411
      410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

APL (41, uscita: 999)

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

Spiegazione:

  • ⌽⍕¨100+⍳898: ('999' '998' ... '101')(in ordine inverso, perché la riduzione va da destra a sinistra in APL, cioè F/a b c ≡ a F (b F c))
  • /: ridurre
  • ⍵,⍺⍴⍨: argomento destro, seguito dai primi Ncaratteri dell'argomento sinistro, dove Nè:
  • 3×~∨/⍺⍷⍵: 3if ⍺non è una sottostringa di ⍵, altrimenti0
  • (1=⍴∪⍺): 1se ⍺ha un solo carattere unico, altrimenti0
  • ∨: il massimo comune divisore dei due precedenti valori, quindi: 1se ⍺non è già in ⍵e ha solo un carattere unico, 3se ⍺non è già in ⍵ma ha più di un carattere unico, 0altrimenti.
  • '0',⍨: aggiungi uno zero alla fine del risultato

Produzione:

10110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451
      46147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188
      18919019219319419519619719819920020220320420520620720820922232242252262272282292302332342352362372382392402432442452
      46247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294
      29529629729829930030330430530630730830933343353363373383393403443453463473483493503543553563573583593603643653663673
      68369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444544644744844945045545645
      74584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566
      56756856957057657757857958058658758858959059659759859960060660760860966676686696706776786796806876886896906976986997
      00707708709777877978078878979079879980080880988898908999009099100
— marinus
fonte
8

Rubino: 50 46 caratteri (output di 1020 caratteri)

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

Esecuzione di esempio:

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

Prova:

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

Rubino: 102 97 caratteri (output di 999 caratteri)

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

Esecuzione di esempio:

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

Prova:

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]}'
[]
— uomo al lavoro
fonte
Bella idea di passare da 999 a 0 e non il contrario. Con questo, il mio metodo Java genera una stringa di 1048 caratteri (anziché 1200).
— Fabinout,
1
Se sei solo preoccupato per la lunghezza del codice e non per la lunghezza dell'output, potresti migliorare il primo usando un intervallo di stringhe. Qualcosa del genere (?0..?9*3).map{|i|$/[i]||($><<i;$/+=i)}forse?
— Paul Prestidge,
5

JavaScript, 39

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

1020 caratteri in uscita:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100


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

— copia
fonte
5

Mathematica ( 62 64 caratteri, 1002 output)

Poiché questo fa uso di una funzione nativa, apprezzo ancora di più la bellezza di soluzioni più brevi da zero. L'output è lungo 1002 caratteri.

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

"799798787770760750740730720710980970960950940930920910108908708608508408308208889998988081009909008007006005004003002000190180170160150140130120119118117116115114113112912812712612512412312213913813713613513413313214914814714614514414314215915815715615515415315216916816716616516416316217917817717617517417317218918818718618518418318219919819719619519419319212111029028027026025024023022922822722622522422392382372362352342332492482472462452442432592582572562552542532692682672662652642632792782772762752742732892882872862852842832992982972962952942932322202103903803703603503403393383373363353349348347346345344359358357356355354369368367366365364379378377376375374389388387386385384399398397396395394343330320310490480470460450449448447446445945845745645546946846746646547947847747647548948848748648549949849749649545444043042041059058057056055955855755695685675665795785775765895885875865995985975965655505405305205106906806706696686679678677689688687699698697676660650640630620610790780779778978879"
— DavidC
fonte
1
sembra che manchi 799 e 997. vedi ideone.com/d07bG2 (o scrivi il tuo assegno)
— Justin,
Buona pesca. Per impostazione predefinita, DeBruijnSequencepresuppone un avvolgimento ciclico. La preparazione di "79", le ultime due cifre, risolve il problema.
— DavidC,
4

Mathematica, 51 caratteri

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

Uscita (1155 caratteri):

000100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999
— alephalpha
fonte
Che cosa fa?
— Fabinout,
1
Costruisce un elenco di elenchi del modulo in {i, j, k}cui iè compreso tra 0 e 9 e j, ksono più piccoli di i. Quindi converte l'elenco in una stringa.
— alephalpha,
4

Python - 53 63, 1134 uscite

Questo è abbastanza bruto, ma è valido. Sì, ha uno zero iniziale, ma salva due caratteri non avendo range(1,1000).

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

Quanto sopra getta un DeprecationWarningover sull'uso di 1e3 nella range()chiamata, ma salva un personaggio usando 1000.

Esiste anche una versione di output leggermente più ottimale, invertendo la stringa al costo di 65 personaggi (grazie a res e filmor per i suggerimenti) :

Python - 58, 1021 output

s=''
for i in range(999,9,-1):s+=`i`*(not`i`in s)
print s
1
Trovo che il tuo primo programma abbia una lunghezza di output 1133, non 1132. In Python 2 (ma non in Python 3), puoi accorciare il codice a 54 caratteri usando i backtick:for i in range(999):s+=`i`*(not`i`in s)
— res
Wot? Hanno tirato fuori i bastoncini? Guido deve aver avuto un I Hate Perl e tutto ciò che sembra il giorno in cui decide cosa tenere.
— Warren P
1
Puoi accorciarlo di un personaggio usando range(999,99,-1)invece di range(1000)[::-1].
— film
E il suggerimento di res ancora aiuta, str(i)*(str(i)not in s)è un po 'più corto di i=str(i);s+=[i,''][i in s];)
— filmatore
@filmor Reso più piccolo e più piccolo usando 1e3invece di1000
2

K, 33

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

Fondamentalmente lo stesso della soluzione Howards - 1133 caratteri.

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
— tmartin
fonte
2

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

Output (1020 caratteri):

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Può raggiungere un buon valore (secondo Peter Taylor , ma in seguito ha detto che 999 era ottimale) Lunghezza della stringa aggiungendo alcuni caratteri (+20 caratteri per 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);}}

Output (1002 caratteri):

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110101100

Modifica : grazie a Fabinout per aver sottolineato che Java 6 può salvare 28 caratteri.

— Justin
fonte
Se vuoi, puoi compilare con Java 6 e usare un blocco statico invece di un System.out.println () !!
— Fabinout,
@Fabinout Intendi invece di un public static void main(String[]a)? (che cambierebbe il mio codice da ...public static void main(String[]c){...a ...static{...)
— Justin l'
Sì, certamente. puoi provare con Java 6.
— Fabinout,
A proposito, dovresti usare exit () alla fine del tuo blocco statico se non vuoi che il tuo programma vada in crash. Anche se non è necessario che il golf non si blocchi.
— Fabinout,
2

Windows PowerShell - 40, 1020 Output

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

Produzione:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100
— goric
fonte
2

Haskell, 75 byte - 1002 output

Un approccio setaccio che restituisce una soluzione minima.

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

Si noti che questa soluzione è incredibilmente lenta.

— Thomas Eding
fonte
Devi includere l'importazione di Data.Listper isInfixOf, tuttavia puoi comunque salvare 2 byte giocando a golf un po 'di più: 1) Hardcode n = 10002) Usa allsopra ande una versione senza punti del predicato 3) usa (!!0)oltre head4) Usa la comprensione dell'elenco sulla combinazione di map& filter5) utilizzare (<$>)su map:[s|s<-show<$>[1..],all((`isInfixOf`s).show)[1..1000]]!!0
— ბიმო
2

Powershell, 36 byte, 1020 output

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

Produzione:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Alternativa, 69 byte, 1000 output

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

Produzione:

9998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888788688588488388288188087787687587487387287187086786686586486386286186085785685585485385285185084784684584484384284184083783683583483383283183082782682582482382282182081781681581481381281181080780680580480380280180077767757747737727717707667657647637627617607567557547537527517507467457447437427417407367357347337327317307267257247237227217207167157147137127117107067057047037027017006665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555455355255155054454354254154053453353253153052452352252152051451351251151050450350250150044434424414404334324314304234224214204134124114104034024014003332331330322321320312311310302301300222122021121020120011101100

Alternativa, 82 73 byte, 999 output (minimo)

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

Questo è un algoritmo semplificato di Genera il De Bruijn più corto adattato per le costanti: alfabeto = 9876543210e lunghezza =3

Produzione:

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110100

Script di prova:

$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
fonte
2

05AB1E , 9 byte e 1109 caratteri

₄FDNå_iNì

Uscite:

90990190089989088981980980880079979879078978878077977870970870770069969869769068968868768067967867767066966866760960860760660059959859759659058958858758658057957857757657056956856756656055955855755650950850750650550049949849749649549048948848748648548047947847747647547046946846746646546045945845745645545044944844744644540940840740640540440039939839739639539439038938838738638538438037937837737637537437036936836736636536436035935835735635535435034934834734634534434033933833733633533430930830730630530430330029929829729629529429329028928828728628528428328027927827727627527427327026926826726626526426326025925825725625525425325024924824724624524424324023923823723623523423323022922822722622522422320920820720620520420320220019919719619519419319219118918818718618518418318218017917817717617517417317217016916816716616516416316216015915815715615515415315215014914814714614514414314214013913813713613513413313213012912812712612512412312212011811711611511411311211110910810710610510410310210110099919089888079787770696867666059585756555049484746454440393837363534333029282726252423222018171615141312119876543210

Provalo online o verifica che contenga tutti i numeri inferiori a 1000 .

Spiegazione:

₄            # 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
fonte
1

Pyke, 13 byte (non competitivo), lunghezza stringa 1133

Pyke è più recente della sfida e quindi non competitivo.

k~mV~oi{!o`*+

Provalo qui!

              - o = 0
k~mV          - repeat 1000 times, i = ""
    ~oi{      -     str(o) in i
        !     -    not ^
         o`*  -   str(o++) * ^
            + -  i += ^
— Blu
fonte
Quanto dura l'output?
— Kritixi Lithos,
1

PHP, 48 44 byte

Grazie a @primo per avermelo ricordato ereg.

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

o

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

uscita: 1020 caratteri. richiede PHP <7

PHP 7, 48 byte:

ereg è stato rimosso in PHP 7

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

Se il secondo argomento di strstr( strposoe altre funzioni di ricerca di stringhe) non è una stringa, verrà utilizzato come codice ascii, quindi $inecessita di un cast su stringa.

— Titus
fonte
1
ereg($i,$s)per 4 (includerei anche <?nel conteggio dei byte).
— primo
@primo Ho appena notato che questa sfida è più vecchia di PHP 7. doppio grazie. :)
— Tito
eregè stato rimosso, presumibilmente, perché il nome della funzione è troppo breve e / o non conteneva abbastanza caratteri di sottolineatura. Anche quello che è splitstato rimosso è particolarmente brillante.
— primo
eregè stato rimosso perché POSIX contiene solo un sottoinsieme delle possibilità di PCRE; e probabilmente non volevano mantenere due librerie diverse. Chiederò se dovessi mai incontrare Rasmus Lerdorf di nuovo. splitè stato rimosso, ma è joinrimasto (probabilmente perché è "solo" un alias). Ci scusiamo per la pedanteria; ma conosco persone che non riconoscono l'ironia.
— Tito
1

Groovy, 49 caratteri / byte

Non ero sicuro di farlo come una funzione che restituisce una variabile stringa o di stampare il risultato, quindi questo lo stampa semplicemente su stdout. L'uso del matcher regex ha salvato 2 byte, usando l'operatore ternario invece di "se" è stato salvato un altro byte. La stringa di output è di 1133 caratteri.

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

Produzione:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
— Rado
fonte
-1

Game Maker Language, 1014 - String 1000

show_message(909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900)

Anche:

Rubino, 1003 - Corda 1000

p'909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900'

— Timtech
fonte
3
1) La tua prima soluzione viola la regola "la lunghezza della stringa deve essere inferiore a 1500 caratteri". 2) Non riesco a trovare il numero 909 nella tua uscita. (Hai perso la prima cifra durante il copia-incolla dalla risposta di primo ?) 3) Il rubycodice può usare pinvece di putspassarlo parametro numerico.
— arte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.