Un anillo para gobernarlos a todos. Una cadena para contenerlos a todos


43

Objetivos: generar una cadena que contenga todos los enteros positivos estrictamente por debajo de 1000.

La respuesta obvia sería concatenar cada uno de ellos, y eso crearía una Cadena de 2890 caracteres (gracias al trabajo manual), para evitar este tipo de respuesta fácil, la longitud de la cadena debe ser inferior a 1500 caracteres. Aquí hay un código Java directo que genera una cadena de 1200 caracteres.

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

¡El código más corto gana, punto de bonificación para la cadena más corta!


11
La cadena óptima tiene 1002 caracteres de longitud.
Peter Taylor

8
Básicamente, está solicitando una secuencia de Bruijn B(10, 3) , pero debido a que no permite la envoltura cíclica, es necesario repetir los dos primeros caracteres.
Peter Taylor

3
Pero quiero que la cadena contenga 1, 2 o 56, no necesariamente 001 002 y 056.
Fabinout

66
Su problema es imposible de resolver porque dijo que el número no es entero . La cadena tendría que ser de longitud infinita para acomodar todos los números positivos por debajo de 1000.
Ramchandra Apte

11
@RamchandraApte Y a cualquier cadena, incluso con una longitud infinita, le faltarían la mayoría de los números ;-)
Howard

Respuestas:


19

Golfscript - 13 bytes, salida 1315

991,{`.$2>>},

Lo anterior selecciona aquellos números del 0-990 cuyo primer dígito es el dígito más grande del número, es decir, el último dígito de la representación de cadena ordenada es lexicográficamente menor que la cadena en sí. La lógica es la siguiente:

Para un número de 3 dígitos abc , si a no es el dígito más grande del número, se omitirá el número, porque se cubrirá en uno de los dos casos más adelante:

  1. b <c (por ejemplo, 123 )
    Como c es el dígito más grande,no se omitiráel número de cabina . En este ejemplo, 312 no se omitirá, ni el siguiente valor 313 , que cuando se concatena ( 312 313 ) contiene 123 .

  2. b ≥ c (por ejemplo, 132 )
    Debido a que b es el dígito más grande, el número bca no se omitirá. En este ejemplo, 321 no se omitirá, ni el siguiente valor 322 , que cuando se concatena ( 321 322 ) contiene 132 . Si b = c (por ejemplo, 122 ), este caso también se aplica. El valor bca no se omitirá, como antes, y dado que a es necesariamente menor que b , bc <a + 1> tampoco se omitirá. En este ejemplo, 221 222 contiene 122 .

Debido a que el código anterior prueba el tercer dígito, en lugar de estrictamente el último, todos los valores de 0-99 se incluyen en el resultado. Sin embargo, se pueden omitir los valores del 1 al 99 , porque si cada secuencia de 3 dígitos está presente, entonces cada secuencia de 1 y 2 dígitos también debe estar presente.

Los valores de 991-999 también se pueden omitir, ya que se generan por ( 909 910 , 919 920 , ... 989 990 ).

Con 1315 bytes de salida, esto está cómodamente bajo la especificación del problema de menos de 1500.

Salida:

0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Variación # 1

14 bytes, salida 1233

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

Al seleccionar estrictamente el último dígito para la comparación, en lugar del tercero, se eliminan muchos de los valores innecesarios menores de 100 , acortando la cadena resultante.

101120212230313233404142434450515253545560616263646566707172737475767780818283848586878890919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Variación # 2

16 bytes, salida 1127

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

Al extraer todos los valores inferiores a 99 de antemano, la cadena resultante se puede acortar aún más.

99100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Golfscript - 19 bytes, salida 1016

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

Lo anterior cuenta de 99 a 909 , agregando cualquier valor que aún no haya aparecido ( 909 normalmente sería el último valor agregado de esta manera). Mover 99 al frente es una optimización para evitar la necesidad de 910 en la parte posterior.

Salida:

99100101102103104105106107108109111112113114115116117118119120122123124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190192193194195196197198199200202203204205206207208209222223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333334335336337338339340344345346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444445446447448449450455456457458459460465466467468469470475476477478479480485486487488489490495496497498499500505506507508509555556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666667668669670677678679680687688689690697698699700707708709777778779780788789790798799800808809888889890899900909

Golfscript 26 bytes, salida 999

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

Tenga en cuenta que la cadena de 1016 caracteres producida por la solución anterior es casi óptima, excepto por tener dos dígitos adicionales para cada múltiplo de 111 (es decir, en 11111lugar de 111, en 22222lugar de 222, etc.). La solución puede hacerse óptima eliminando estos dígitos adicionales (solo insertando un dígito en cada uno de estos valores, en lugar de tres), y girando 909hacia el frente, eliminando un 9(esto difiere de las versiones anteriores, que se movieron 9100hacia atrás en su lugar) )

Desenrollado y comentado:

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 lógica para elegir qué caracteres se agregan sigue tres casos:

  1. 111n , ns
    El valor de la primera verificación es 1 , y de la segunda -1 .
    El segmento comenzará a partir del índice 0 ; devolverá toda la cadena.
  2. 111n , ns
    El valor de la primera verificación es 1 , y de la segunda algo ≥ 2 .
    La rebanada comenzará a mirar desde el índice ≥ 3 ; devolverá una cadena vacía.
  3. 111n , ns
    El valor de la primera verificación es 0 , y de la segunda -1 .
    El segmento comenzará a partir del índice -1 ; solo devolverá el último carácter.

La suma de la lógica es que cualquier valor que aún no haya aparecido se agregará en su totalidad, a menos que sea un múltiplo de 111 , en cuyo caso solo se agregará un carácter. Todos los demás valores serán ignorados.

Tenga en cuenta que la cadena producida es diferente a la óptima producida por la respuesta de Peter Taylor .

Historia:

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

Salida:

909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900

45

GolfScript ( 35 31 26 caracteres)

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

La salida es

000100110111200201210211220221222300301302310311312320321322330331332333400401402403410411412413420421422423430431432433440441442443444500501502503504510511512513514520521522523524530531532533534540541542543544550551552553554555600601602603604605610611612613614615620621622623624625630631632633634635640641642643644645650651652653654655660661662663664665666700701702703704705706710711712713714715716720721722723724725726730731732733734735736740741742743744745746750751752753754755756760761762763764765766770771772773774775776777800801802803804805806807810811812813814815816817820821822823824825826827830831832833834835836837840841842843844845846847850851852853854855856857860861862863864865866867870871872873874875876877880881882883884885886887888900901902903904905906907908910911912913914915916917918920921922923924925926927928930931932933934935936937938940941942943944945946947948950951952953954955956957958960961962963964965966967968970971972973974975976977978980981982983984985986987988990991992993994995996997998999

(1020 caracteres) Esta es una variante en el enfoque de concatenación de palabras de Lyndon: en lugar de usar las palabras primitivas 1-char, usa múltiplos de 111 para códigos más cortos pero ocurrencias repetidas de esos números; y en lugar de usar elementos mínimos de los grupos de conjugación, usa elementos máximos, porque eso acorta los bucles.


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

a 40 caracteres (probablemente todavía se puede mejorar) genera una cadena óptima, que tiene una longitud de 999 caracteres:

100200300400500600700800901101201301401501601701801902102202302402502602702802903103203303403503603703803904104204304404504604704804905105205305405505605705805906106206306406506606706806907107207307407507607707807908108208308408508608708808909109209309409509609709809911121131141151161171181191221231241251261271281291321331341351361371381391421431441451461471481491521531541551561571581591621631641651661671681691721731741751761771781791821831841851861871881891921931941951961971981992223224225226227228229233234235236237238239243244245246247248249253254255256257258259263264265266267268269273274275276277278279283284285286287288289293294295296297298299333433533633733833934434534634734834935435535635735835936436536636736836937437537637737837938438538638738838939439539639739839944454464474484494554564574584594654664674684694754764774784794854864874884894954964974984995556557558559566567568569576577578579586587588589596597598599666766866967767867968768868969769869977787797887897987998889899900

Intentar hacer que esto haga cadenas inversas tiene problemas al omitir los múltiplos de 111.

Para ver que 999 es la longitud óptima (dado que mis breves comentarios anteriores no convencen a todos), comience desde la secuencia completa de Bruijn que (tomada como una cadena cíclica) contiene cada secuencia de caracteres de 3 dígitos del 0 al 9. Desde hay 1000 de ellos, debe tener al menos 1000 caracteres de longitud; que puede ser precisamente 1.000 caracteres de longitud está generalmente probadas por un pie euleriano en un gráfico cuyos nodos son secuencias de dos dígitos xycon 10 bordes, cada uno marcado con un dígito z, que toman xya yz.

No necesitamos secuencias que comiencen 0, por lo tanto, dada una secuencia de Bruijn, podemos rotar para poner 000al final. Entonces no necesitamos ninguna de las secuencias que se envuelven hasta el principio, pero sí necesitamos dos de las 0s para terminar la secuencia que comienza con el dígito anterior 000, por lo que podemos eliminar una de ellas para obtener una cadena de 999 caracteres. Todos los restantes 0se usan en un número que no comienza con 0.


8
¡Eso es realmente impresionante!
Fabinout

Prefiero utilizar un enfoque de filtrado o generativo. Para el enfoque pseudo-Lyndon, tengo el enfoque generativo hasta 32 caracteres: 10,:^{:x^>{x.@:&<+^>{x&@}/}/}/0.variando eso para las palabras verdaderas de Lyndon da 10,:^{:x^>{x.@:&<+^>{.x>{x&@}*}/}/}%3>0.(40 caracteres) para la cadena óptima.
Peter Taylor

¿Puedes acortar la cadena óptima al no usar ceros a la izquierda para números inferiores a 100?
Random832

1
@ Random832 Estoy bastante seguro de que no puedes. Debe incluir los números 100, 200, ... 900, por lo que la cadena mínima seguramente tendrá ocho ocurrencias de 00X (una puede estar en el extremo derecho, como se indicó anteriormente). Tenga en cuenta que la cadena óptima dada no contiene "001".
tttppp

2
Normalmente no elevo el código que no entiendo, pero en este caso lo estoy votando porque no lo entiendo. Bravo.
Ben Jackson el

29

GolfScript, 17 caracteres

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

Enfoque simple para agregar cada número si aún no está presente en la cadena (nota: 999 no está marcado o agregado, pero ya está contenido en la salida).

La salida es de 1133 caracteres:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

20

No tengo ningún código, pero pensé que alguien podría apreciar esta prueba intuitiva de que 999 caracteres es el límite inferior a la longitud de la salida:

Primero, cada número de 1 y 2 dígitos es parte de un número de 3 dígitos, así que ignore todo menos que 100. 100-999 inclusive son 900 números de 3 dígitos.

La forma más óptima de resolver el problema es si cada personaje se usa tanto como sea posible. Eso significa que los números se superponen tanto como sea posible, así:

123
 234
  345

Por lo tanto, el primer número agregará 3 caracteres, y cada número subsiguiente agregará 1 carácter. Eso da 3 + 899 = 902 caracteres como límite inferior.

Sin embargo, cuando hay un cero, no podemos usarlo para comenzar un nuevo número de 3 dígitos. Sin embargo, podemos reutilizarlo en medio de otro número de 3 dígitos, siempre que no sea seguido por otro cero:

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

Pero:

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

Por lo tanto, cada cero que aparece en la salida amplía la salida en 1 carácter, excepto los dos últimos caracteres que pueden ser cero ya que no se superponen con ningún número adicional:

???
 ??0
  ?00

Hay 81 números con estrictamente un cero en el medio (? 0?), 81 con estrictamente un cero al final (?? 0) y 9 con dos ceros (? 00).

Cada número ?? 0 puede compartir un cero con un? 0? número o un número? 00, pero no ambos. ? 0? y? 00 nunca puede compartir ceros, por lo que debe haber al menos 81 + 9 * 2 ceros en la salida.

Esto proporciona un límite inferior de 3 + 899 + 81 + 9 * 2 - 2 = 999 caracteres.

Disculpas si esto se considera fuera de tema, pero fue demasiado largo para caber en un comentario.


1
¡Gracias por el aviso! Eso es un poco extraño que la cadena que contiene todos los enteros inferiores a 999 tiene 999 caracteres de longitud.
Fabinout el


1
Es un poco divertido notar que almacenar cada número hasta 999 en una cadena hace que tenga 999 caracteres de longitud. Corrígeme si me equivoco, pero creo que almacenar cada número hasta 99 hace que tenga 100 caracteres.
Fabinout

2
Por el mismo argumento, el límite inferior es 2 + 89 + 9 - 1 = 99, pero esto no prueba que 99 sea posible, solo que 98 no lo es.
Alistair Buxton

17

Perl 37 34 33 32 (1136 1132 caracteres)

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

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

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

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

Salidas:

12345678910111314151617181920212224252627282930323335363738394043444647484950545557585960656668697076777980878890991001021031041051061071081091101121141151161171181191201241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901931941951961971981992002032042052062072082092192202212232252262272282292302312352362372382392402432442452462472482492502532542552562572582592602632642652662672682692702732742752762772782792802832842852862872882892902942952962972982993003043053063073083093113293303323343363373383393403423463473483493503543553563573583593603643653663673683693703743753763773783793803843853863873883893903953963973983994004054064074084094224394404434454474484494504534574584594604654664674684694704754764774784794804854864874884894904964974984995005065075085095335495505545565585595605645685695705765775785795805865875885895905975985996006076086096446596606656676696706756796806876886896906986997007087097557697707767787807867907977998008098668778798808878888978988999009089329439549659769799879891000

Cadena más corta: 38 37 34 (1020 caracteres):

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

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

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

Salidas:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

¡Todavía no estoy contento con la duplicación, especialmente el 99999 al principio! Sin embargo, creo que muchas más comprobaciones crearían mucho más código ...

Editar: Sugerencia agregada de @Peter Taylor

Edición 2: ¡Algunas sugerencias geniales de @primo! Gracias


2
Buen truco para escribir 1000 como 1e3, pero creo que no tiene sentido. La pregunta dice “estrictamente inferior a 1000”, eso significaría hasta e incluyendo 999. (El código de ejemplo también procesa 0..999.)
manatwork

Un excelente punto! Para empezar, tenía un ciclo diferente, ¡lo modifiqué en consecuencia! ¡Gracias!
Dom Hastings

3
Si usa un carácter no alfabético para su variable, ¿puede eliminar el espacio?
Peter Taylor

Ahhh si, puedo! ¡Gracias!
Dom Hastings

2
Algunas mejoras menores más: en lugar de $_.=$@if!/$@/, puede usar la repetición de cadena $_.=$@x!/$@/. El forpuede ser reemplazado por a whilecomo un modificador de declaración, usando un módulo:...while$@=--$@%1e3
primo

10

APL (20, salida: 1020)

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

Explicación:

  • {∨/⍺⍷⍵:⍵⋄⍵,⍺}: si es una subcadena de , return , else return⍵,⍺
  • /: reducir más
  • ⍕¨: la representación de cadena de cada uno de
  • ⍳999: los enteros de 1a 999.

Salida:

9999989979969959949939929919909889879869859849839829819809789779769759749739729719709689679669659649639629619609589579569
      55954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913
      91291191090890790690590490390290190088888788688588488388288188087787687587487387287187086786686586486386286186085785
      68558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108
      07806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735
      73473373273173072672572472372272172071671571471371271171070670570470370270170066666566466366266166065565465365265165
      06456446436426416406356346336326316306256246236226216206156146136126116106056046036026016005555545535525515505445435
      42541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411
      410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

APL (41, salida: 999)

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

Explicación:

  • ⌽⍕¨100+⍳898: ('999' '998' ... '101')(en orden inverso, porque la reducción va de derecha a izquierda en APL, es decir F/a b c ≡ a F (b F c))
  • /: reducir
  • ⍵,⍺⍴⍨: argumento derecho, seguido de los primeros Ncaracteres del argumento izquierdo, donde Nestá:
  • 3×~∨/⍺⍷⍵: 3si no es una subcadena de , de lo contrario0
  • (1=⍴∪⍺): 1si solo tiene un carácter único, de lo contrario0
  • : máximo divisor común de los dos valores anteriores, por lo tanto: 1si aún no está dentro y solo tiene un carácter único, 3si no está ya dentro pero tiene más de un carácter único, de lo 0contrario.
  • '0',⍨: agrega un cero al final del resultado

Salida:

10110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451
      46147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188
      18919019219319419519619719819920020220320420520620720820922232242252262272282292302332342352362372382392402432442452
      46247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294
      29529629729829930030330430530630730830933343353363373383393403443453463473483493503543553563573583593603643653663673
      68369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444544644744844945045545645
      74584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566
      56756856957057657757857958058658758858959059659759859960060660760860966676686696706776786796806876886896906976986997
      00707708709777877978078878979079879980080880988898908999009099100

8

Ruby: 50 46 caracteres (salida de 1020 caracteres)

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

Ejecución de muestra:

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

Prueba de funcionamiento:

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 caracteres (salida de 999 caracteres)

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

Ejecución de muestra:

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

Prueba de funcionamiento:

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

Buena idea ir de 999 a 0 y no al revés. Con esto, mi método Java genera una cadena de 1048 caracteres (en lugar de 1200).
Fabinout

1
Si solo le preocupa la longitud del código y no la longitud de salida, puede mejorar el primero usando un rango de cadena. Algo como (?0..?9*3).map{|i|$/[i]||($><<i;$/+=i)}tal vez?
Paul Prestidge

5

JavaScript, 39

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

Salida de 1020 caracteres:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100


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


5

Mathematica ( 62 64 caracteres, salida 1002)

Como esto hace uso de una función nativa, aprecio aún más la belleza de las soluciones más cortas desde cero. La salida es de 1002 caracteres de largo.

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

"799798787770760750740730720710980970960950940930920910108908708608508408308208889998988081009909008007006005004003002000190180170160150140130120119118117116115114113112912812712612512412312213913813713613513413313214914814714614514414314215915815715615515415315216916816716616516416316217917817717617517417317218918818718618518418318219919819719619519419319212111029028027026025024023022922822722622522422392382372362352342332492482472462452442432592582572562552542532692682672662652642632792782772762752742732892882872862852842832992982972962952942932322202103903803703603503403393383373363353349348347346345344359358357356355354369368367366365364379378377376375374389388387386385384399398397396395394343330320310490480470460450449448447446445945845745645546946846746646547947847747647548948848748648549949849749649545444043042041059058057056055955855755695685675665795785775765895885875865995985975965655505405305205106906806706696686679678677689688687699698697676660650640630620610790780779778978879"

1
parece que faltan 799 y 997. visite ideone.com/d07bG2 (o escriba su propio cheque)
Justin

Buena atrapada. Por defecto, DeBruijnSequenceasume envoltura cíclica. Anteponer "79", los dos últimos dígitos, resuelve el problema.
DavidC

4

Mathematica, 51 caracteres

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

Salida (1155 caracteres):

000100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999

¿Qué hace?
Fabinout

1
Se construye una lista de listas de la forma {i, j, k}en que ies de 0 a 9 y j, kson más pequeños que i. Luego convierte la lista en una cadena.
alephalpha

4

Python - 53 63, 1134 salida

Esto es bastante brutal, pero es válido. Sí, tiene un cero a la izquierda, pero ahorra dos caracteres al no tener range(1,1000).

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

Lo anterior arroja un DeprecationWarningsobre el uso de 1e3 en la range()llamada, pero ahorra un personaje sobre el uso de 1000.

También hay una versión de salida de longitud ligeramente más óptima, invirtiendo la cadena a costa de 6 65 personajes (gracias a res y filmor por los consejos) :

Python - 58, salida 1021

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

1
Creo que su primer programa tiene una longitud de salida de 1133, no de 1132. En Python 2 (pero no Python 3), puede acortar el código a 54 caracteres mediante el uso de teclas de retroceso:for i in range(999):s+=`i`*(not`i`in s)
res

Wot? ¿Sacaron ticks? Guido debe haber tenido un día de Odio a Perl y todo lo que parece a la hora de decidir qué guardar.
Warren P

1
Puede acortar eso en un carácter usando en range(999,99,-1)lugar de range(1000)[::-1].
filmor

Y la sugerencia por res todavía ayuda, str(i)*(str(i)not in s)es un poco más corta que i=str(i);s+=[i,''][i in s];)
filmor

@filmor Se hizo más pequeño, y más pequeño nuevamente al usar en 1e3lugar de1000

2

K, 33

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

Básicamente lo mismo que la solución Howards - 1133 caracteres.

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

2

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

Salida (1020 caracteres):

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Puede alcanzar un buen (según Peter Taylor , pero luego dijo que 999 era óptimo) Longitud de la cadena al agregar algunos caracteres (+20 caracteres para 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);}}

Salida (1002 caracteres):

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110101100

Editar : Gracias a Fabinout por señalar que Java 6 puede guardar 28 caracteres.


¡Si lo desea, puede compilar con Java 6 y usar un bloque estático en lugar de un System.out.println () !!
Fabinout

@Fabinout ¿Quieres decir en lugar de un public static void main(String[]a)? (eso cambiaría mi código de ...public static void main(String[]c){...a ...static{...)
Justin

Sí. puedes probar con Java 6.
Fabinout

Por cierto, debe usar exit () al final de su bloque estático si no desea que su programa se bloquee. A pesar de que no es necesario en el golf no chocar.
Fabinout

2

Windows PowerShell - 40, salida 1020

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

Salida:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

2

Haskell, 75 bytes - salida 1002

Un enfoque de tamiz que devuelve una solución mínima.

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

Tenga en cuenta que esta solución es poco práctica.


Debe incluir la importación de Data.Listfor isInfixOf, sin embargo, aún puede guardar 2 bytes jugando un poco más: 1) Hardcode n = 10002) Use allover andy una versión sin puntos del predicado 3) use (!!0)over head4) Use la comprensión de la lista sobre la combinación de map& filter5) usar (<$>)sobre map:[s|s<-show<$>[1..],all((`isInfixOf`s).show)[1..1000]]!!0
ბიმო

2

Powershell, 36 bytes, salida 1020

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

Salida:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Alternativa, 69 bytes, salida 1000

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

Salida:

9998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888788688588488388288188087787687587487387287187086786686586486386286186085785685585485385285185084784684584484384284184083783683583483383283183082782682582482382282182081781681581481381281181080780680580480380280180077767757747737727717707667657647637627617607567557547537527517507467457447437427417407367357347337327317307267257247237227217207167157147137127117107067057047037027017006665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555455355255155054454354254154053453353253153052452352252152051451351251151050450350250150044434424414404334324314304234224214204134124114104034024014003332331330322321320312311310302301300222122021121020120011101100

Alternativa, 82 73 bytes, salida 999 (mínimo)

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

Este es un algoritmo simplificado de Generar el De Bruijn más corto adaptado para constantes: alfabeto = 9876543210y longitud =3

Salida:

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110100

Script de prueba:

$f= {

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

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

}

$s=&$f

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

2

05AB1E , 9 bytes y 1109 caracteres

₄FDNå_iNì

Salidas:

90990190089989088981980980880079979879078978878077977870970870770069969869769068968868768067967867767066966866760960860760660059959859759659058958858758658057957857757657056956856756656055955855755650950850750650550049949849749649549048948848748648548047947847747647547046946846746646546045945845745645545044944844744644540940840740640540440039939839739639539439038938838738638538438037937837737637537437036936836736636536436035935835735635535435034934834734634534434033933833733633533430930830730630530430330029929829729629529429329028928828728628528428328027927827727627527427327026926826726626526426326025925825725625525425325024924824724624524424324023923823723623523423323022922822722622522422320920820720620520420320220019919719619519419319219118918818718618518418318218017917817717617517417317217016916816716616516416316216015915815715615515415315215014914814714614514414314214013913813713613513413313213012912812712612512412312212011811711611511411311211110910810710610510410310210110099919089888079787770696867666059585756555049484746454440393837363534333029282726252423222018171615141312119876543210

Pruébelo en línea o verifique que contiene todos los números por debajo de 1000 .

Explicación:

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

1

Pyke, 13 bytes (sin competencia), longitud de cadena 1133

Pyke es más nuevo que el desafío y, por lo tanto, no es competitivo.

k~mV~oi{!o`*+

Pruébalo aquí!

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

¿Cuánto dura la salida?
Kritixi Lithos

1

PHP, 48 44 bytes

Gracias a @primo por recordármelo ereg.

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

o

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

salida: 1020 caracteres. requiere PHP <7

PHP 7, 48 bytes:

ereg ha sido eliminado en PHP 7

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

Si el segundo argumento para strstr(u strposotras funciones de búsqueda de cadenas) no es una cadena, se usará como un código ASCII, por lo que $inecesita una conversión a cadena.


1
ereg($i,$s)para 4 (también incluiría <?en el recuento de bytes).
primo

@primo Acabo de notar que este desafío es más antiguo que PHP 7. doble gracias. :)
Titus

eregse eliminó, presumiblemente, porque el nombre de la función es demasiado corto y / o no contenía suficientes guiones bajos. Eso splittambién fue eliminado es especialmente brillante.
primo

eregse eliminó porque POSIX solo contiene un subconjunto de posibilidades de PCRE; y probablemente no quisieron mantener dos bibliotecas diferentes. Preguntaré si alguna vez vuelvo a encontrarme con Rasmus Lerdorf. splitha sido eliminado, pero joinpermaneció (probablemente porque es "solo" un alias). Perdón por la pedantería; pero conozco personas que no pueden reconocer la ironía.
Tito

1

Groovy, 49 caracteres / bytes

No estaba seguro de si hacer esto como una función que devuelve una variable de cadena o imprimir el resultado, por lo que esto solo lo imprime en stdout. El uso del comparador de expresiones regulares ahorró 2 bytes, el uso del operador ternario en lugar de "si" guardó otro byte. La cadena de salida tiene 1133 caracteres.

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

Salida:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989

-1

Game Maker Language, 1014 - Cadena 1000

show_message(909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900)

También:

Ruby, 1003 - Cadena 1000

p'909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900'


3
1) Su primera solución viola la regla "la longitud de la cadena debe ser inferior a 1500 caracteres". 2) No puedo encontrar el número 909 en tu salida. (¿Se perdió el primer dígito al copiar y pegar de la respuesta de primo ?) 3) El rubycódigo puede usar en plugar de putspasarle el parámetro numérico.
manatwork
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.