Одно Кольцо, чтобы править ими всеми. Одна строка, чтобы содержать их всех

43

Задачи: Вывести строку, которая содержит каждое положительное целое число строго ниже 1000.

Очевидным ответом будет объединение каждого из них, и это создаст строку из 2890 символов (спасибо manatwork), чтобы избежать такого простого ответа, длина строки должна быть не более 1500 символов. Вот простой Java-код, который выводит строку из 1200 символов.

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;

import static org.junit.Assert.assertTrue;

/**
 * Created with IntelliJ IDEA.
 * User: fab
 * Date: 05/11/13
 * Time: 09:53
 * To change this template use File | Settings | File Templates.
 */
public class AStringToContainThemAll {

    @Test
    public void testsubStrings() throws Exception {
        String a = generateNewString();
        boolean cool = true;
        for (int i = 0; i < 1000; i++) {
            assertTrue(a.contains(Integer.toString(i)));
        }
    }

    private String generateNewString() {
        List<Integer> myTree = new ArrayList<Integer>();
        String finalString = new String("100");
        for (int i = 10; i < 1000; i++) {
            myTree.add(i);
        }
        while (myTree.size() > 0) {
            if (finalString.contains(Integer.toString(myTree.get(0)))) {
                myTree.remove(0);
            } else {
                String substringLong = finalString.substring(finalString.length() - 2, finalString.length());
                boolean found = false;
                loop:
                for (Integer integer : myTree) {
                    if (integer.toString().startsWith(substringLong) && !finalString.contains(integer.toString())) {
                        finalString = finalString.concat(integer.toString().substring(2, 3));
                        myTree.remove(integer);
                        found = true;
                        break loop;
                    }
                }
                if(! found){
                    finalString = finalString.concat(myTree.get(0).toString());
                    myTree.remove(0);
                }
            }


        }
        return finalString;
    }
}

Самый короткий код выигрыша, бонусное очко за самую короткую строку!

code-golf string kolmogorov-complexity Fabinout
источник
11
Оптимальная строка длиной 1002 символа.
Питер Тейлор
8
По сути, вы запрашиваете последовательность де Брюина B(10, 3) , но поскольку вы не разрешаете циклическую перенос, необходимо повторить первые два символа.
Питер Тейлор
3
Но я хочу, чтобы строка содержала 1, 2 или 56, а не обязательно 001, 002 и 056.
Fabinout
6
Ваша проблема не может быть решена, потому что вы сказали, что число не целое число . Строка должна быть бесконечной длины, чтобы вместить все положительные числа ниже 1000.
Ramchandra Apte
11
@RamchandraApte И все же любая строка, даже с бесконечной длиной, пропустит большинство чисел ;-)
Говард

Ответы:

19

Golfscript - 13 байт, 1315 вывод

991,{`.$2>>},

Приведенное выше выбирает те числа от 0 до 990 , первая цифра которых является самой большой цифрой числа, то есть последняя цифра в представлении отсортированной строки лексикографически меньше самой строки. Логика следующая:

Для трехзначного числа abc , если a не является самой большой цифрой числа, число может быть пропущено, поскольку оно будет рассмотрено одним из двух случаев позже:

  1. b <c (например, 123 )
    Поскольку c является самой большой цифрой, номер кабины не будет пропущен. В этом примере 312 не будет пропущено, равно как и следующее значение 313 , которое при объединении ( 312 313 ) содержит 123 .

  2. b ≥ c (например, 132 )
    Поскольку b является самой большой цифрой, число bca не будет пропущено. В этом примере 321 не будет пропущено, равно как и следующее значение 322 , которое при объединении ( 321 322 ) содержит 132 . Если b = c (например, 122 ), этот случай также применяется. Значение bca не будет пропущено, как раньше, и, поскольку a обязательно меньше, чем b , bc <a + 1> также не будет пропущено. В этом примере 221 222 содержит 122 .

Поскольку приведенный выше код проверяет третью цифру, а не только последнюю, все значения от 0 до 99 включаются в результат. Однако значения от 1 до 99 могут быть пропущены, поскольку, если присутствует каждая трехзначная последовательность, то должны присутствовать также каждая однозначная и двухзначная последовательность.

Значения от 991-999 также могут быть пропущены, так как они генерируются ( 909 910 , 919 920 , ... 989 990 ).

При 1315 байтах вывода это удобно при спецификации задачи менее 1500.

Выход:

0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Вариация № 1

14 байт, вывод 1233

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

При выборе строго последней цифры для сравнения, а не третьей, многие из ненужных значений, меньших 100 , удаляются, сокращая результирующую строку.

101120212230313233404142434450515253545560616263646566707172737475767780818283848586878890919293949596979899100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Вариация № 2

16 байтов, 1127 вывод

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

Путем предварительного извлечения всех значений, меньших 99 , полученная строка может быть сокращена еще больше.

99100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990

Golfscript - 19 байт, 1016 вывод

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

Выше указано от 99 до 909 , добавляя любое значение, которое еще не появилось ( 909 обычно будет последним добавленным значением таким образом). Перемещение 99 вперед - это оптимизация, чтобы избежать необходимости 910 сзади.

Выход:

99100101102103104105106107108109111112113114115116117118119120122123124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190192193194195196197198199200202203204205206207208209222223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333334335336337338339340344345346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444445446447448449450455456457458459460465466467468469470475476477478479480485486487488489490495496497498499500505506507508509555556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666667668669670677678679680687688689690697698699700707708709777778779780788789790798799800808809888889890899900909

Golfscript 26 байт, 999 вывод

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

Обратите внимание, что строка символов 1016, созданная в предыдущем решении, является почти оптимальной, за исключением двух дополнительных цифр для каждого, кратного 111 (т. Е. 11111Вместо 111, 22222вместо 222и т. Д.). Решение можно сделать оптимальным, удалив эти дополнительные цифры (вставляя только одну цифру в каждое из этих значений вместо трех), и поворачивая 909вперед, удаляя 9(это отличается от предыдущих версий, которые 9100вместо этого переместились на заднюю часть). ).

Развернул и прокомментировал:

909.,99>  # add 909 to the stack, and duplicate
          # create an array from 0..908, and 
          # remove the first 99 elements (99..908)
{
  `..     # stringify, duplicate twice

  $.2><   # non-divisibility by 111 check
          # true if the last char of the sorted
          # string is greater than the first char

  3$@?    # first position of this number in
          # the total string so far (-1 if not found)

  +>      # add the two previous results,
          # and slice from that point
          # (see explanation below)

  +       # concat what remains to the total string

}/        # loop over the set

Логика выбора символов для добавления выполняется в трех случаях:

  1. 111 ∤ n , n ⊄ s
    Значение из первой проверки равно 1 , а из второй -1 .
    Срез начнется с индекса 0 ; он вернет всю строку.
  2. 111 ∤ n , n ⊂ s
    Значение из первой проверки равно 1 , а из второй что-то ≥ 2 .
    Срез начнется с индекса ≥ 3 ; он вернет пустую строку.
  3. 111 ∣ n , n ⊄ s
    Значение первой проверки равно 0 , а второй -1 .
    Срез начнется с индекса -1 ; он вернет только последний символ.

Сумма логики заключается в том, что любое значение, которое еще не появилось, будет добавлено целиком - если только оно не кратно 111 , в этом случае будет добавлен только один символ. Все остальные значения будут игнорироваться.

Обратите внимание, что полученная строка отличается от оптимальной, полученной из ответа Питера Тейлора .

История:

899,{101+.111%{`.2$\?0<*}{3/9%}if+}/

899,{101+`.2$\?0<\.~111%2*)<*+}/0

899,{101+`.2$\?0<\..2>-!2*>*+}/0

899,{101+`...2>|,1|<2$@?0<*+}/0

999,{`..$.2>>2*>2$@?0<*+}/3>0

899,{101+`..$.2><3$@?+>+}/0

Выход:

909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900
Примо
источник
45

GolfScript ( 35 31 26 символов)

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

Выход

000100110111200201210211220221222300301302310311312320321322330331332333400401402403410411412413420421422423430431432433440441442443444500501502503504510511512513514520521522523524530531532533534540541542543544550551552553554555600601602603604605610611612613614615620621622623624625630631632633634635640641642643644645650651652653654655660661662663664665666700701702703704705706710711712713714715716720721722723724725726730731732733734735736740741742743744745746750751752753754755756760761762763764765766770771772773774775776777800801802803804805806807810811812813814815816817820821822823824825826827830831832833834835836837840841842843844845846847850851852853854855856857860861862863864865866867870871872873874875876877880881882883884885886887888900901902903904905906907908910911912913914915916917918920921922923924925926927928930931932933934935936937938940941942943944945946947948950951952953954955956957958960961962963964965966967968970971972973974975976977978980981982983984985986987988990991992993994995996997998999

(1020 символов) Это вариант подхода объединения слов Линдона: вместо использования примитивных 1-символьных слов он использует кратные 111 для более короткого кода, но повторяющиеся вхождения этих чисел; и вместо того, чтобы использовать минимальные элементы групп сопряженности, он использует максимальные элементы, потому что это сокращает циклы.

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

в 40 символов (возможно, все еще может быть улучшен) генерирует оптимальную строку длиной 999 символов:

100200300400500600700800901101201301401501601701801902102202302402502602702802903103203303403503603703803904104204304404504604704804905105205305405505605705805906106206306406506606706806907107207307407507607707807908108208308408508608708808909109209309409509609709809911121131141151161171181191221231241251261271281291321331341351361371381391421431441451461471481491521531541551561571581591621631641651661671681691721731741751761771781791821831841851861871881891921931941951961971981992223224225226227228229233234235236237238239243244245246247248249253254255256257258259263264265266267268269273274275276277278279283284285286287288289293294295296297298299333433533633733833934434534634734834935435535635735835936436536636736836937437537637737837938438538638738838939439539639739839944454464474484494554564574584594654664674684694754764774784794854864874884894954964974984995556557558559566567568569576577578579586587588589596597598599666766866967767867968768868969769869977787797887897987998889899900

Попытка заставить это сделать обратные строки наталкивается на проблемы с пропуском, кратным 111.

Чтобы увидеть, что 999 является оптимальной длиной (поскольку мои краткие комментарии выше не убеждают всех), начните с полной последовательности де Брюина, которая (взятая как циклическая строка) содержит каждую 3-значную последовательность символов от 0 до 9. их 1000, длина должна быть не менее 1000 символов; тот факт, что длина может быть ровно 1000 символов, обычно подтверждается эйлеровым блужданием на графе, узлы которого представляют собой двузначные последовательности xyс 10 ребрами, каждое из которых помечено одной цифрой z, xyк которой относится yz.

Нам не нужно начинать последовательности 0, поэтому, учитывая последовательность де Брюина, мы можем повернуть, чтобы поставить 000в конце. Тогда нам не нужна ни одна из последовательностей, которые переносятся в начало, но нам нужны две из 0s, чтобы завершить последовательность, начинающуюся с цифры раньше 000, поэтому мы можем удалить одну из них, чтобы получить строку из 999 символов. Все остальные 0используются в числе, которое не начинается с 0.

Питер Тейлор
источник
8
Это действительно впечатляет!
Fabinout
Я бы предпочел использовать фильтрацию или генеративный подход. Для псевдо-Линдоновского подхода у меня есть генеративный подход до 32 символов: изменение, 10,:^{:x^>{x.@:&<+^>{x&@}/}/}/0.которое для истинных слов Линдона дает 10,:^{:x^>{x.@:&<+^>{.x>{x&@}*}/}/}%3>0.(40 символов) для оптимальной строки.
Питер Тейлор
Можете ли вы получить оптимальную строку, не используя начальные нули для чисел ниже 100?
Random832
1
@ Random832 Я уверен, что ты не сможешь. Вы должны включить числа 100, 200, ... 900, поэтому минимальная строка, безусловно, будет иметь восемь вхождений 00X (один может быть справа, как указано выше). Обратите внимание, что указанная оптимальная строка не содержит «001».
Tttppp
2
Обычно я не одобряю код, который не понимаю, но в этом случае я голосую за него, потому что я не понимаю. Браво.
Бен Джексон
29

GolfScript, 17 символов

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

Простой подход к добавлению каждого числа, если оно еще не присутствует в строке (примечание: 999 не проверяется и не добавляется, но уже содержится в выходных данных).

Вывод 1133 символа:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
Говард
источник
20

У меня нет никакого кода, но я подумал, что кто-то может оценить это интуитивное доказательство того, что 999 символов - это нижняя граница длины вывода:

Во-первых, каждое однозначное и двузначное число является частью трехзначного числа, поэтому игнорируйте все, что меньше 100. 100-999 включительно - это 900 трехзначных чисел.

Самый оптимальный способ решить эту проблему - это использовать как можно больше символов. Это означает, что числа перекрываются как можно больше, например так:

123
 234
  345

Поэтому к первому номеру добавляются 3 символа, а к каждому последующему числу добавляется 1 символ. Это дает 3 + 899 = 902 символа в качестве нижней границы.

Однако, когда есть ноль, мы не можем использовать его, чтобы начать новый 3-значный номер. Мы можем повторно использовать его в середине другого трехзначного числа, если за ним не следует еще один ноль:

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

Но:

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

Поэтому каждый ноль, который появляется в выходных данных, расширяет вывод на 1 символ - за исключением двух последних символов, которые могут быть нулевыми, поскольку они не перекрывают дальнейшие числа:

???
 ??0
  ?00

Есть 81 число со строго одним нулем в середине (? 0?), 81 со строго одним нулем в конце (?? 0) и 9 с двумя нулями (? 00).

Каждое число «0» может делить ноль с «0» число или число? 00, но не оба. ? 0? и? 00 никогда не может делить нули, поэтому в выходных данных должно быть не менее 81 + 9 * 2 нулей.

Это дает нижнюю границу 3 + 899 + 81 + 9 * 2 - 2 = 999 символов.

Извинения, если это считается не по теме, но это было слишком долго, чтобы вписаться в комментарий.

Алистер Бакстон
источник
1
Спасибо за головы! Забавно, что строка, содержащая все целые числа меньше 999, имеет длину 999 символов.
Fabinout
1
Смотрите также: en.wikipedia.org/wiki/De_Bruijn_sequence .
Лиори
1
Забавно отметить, что при сохранении каждого числа до 999 в строке длина его составляет 999 символов. Поправьте меня, если я ошибаюсь, но я считаю, что хранение каждого числа до 99 делает его длиной в 100 символов.
Fabinout
2
По тому же аргументу нижняя граница составляет 2 + 89 + 9 - 1 = 99, но это не доказывает, что 99 возможно, только 98 не возможно.
Алистер Бакстон
17

Perl, 37 34 33 32 (1136 1132 символа)

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

для $ @ (1..999) {$ _. = $ @, если! / $ @ /} печать

для $ i (1..999) {$ _. = $ i if! / $ i /} распечатать

для (1..1e3) {$ s. = $ _ если $ s! ~ / $ _ /} напечатать $ s

Выходы:

12345678910111314151617181920212224252627282930323335363738394043444647484950545557585960656668697076777980878890991001021031041051061071081091101121141151161171181191201241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901931941951961971981992002032042052062072082092192202212232252262272282292302312352362372382392402432442452462472482492502532542552562572582592602632642652662672682692702732742752762772782792802832842852862872882892902942952962972982993003043053063073083093113293303323343363373383393403423463473483493503543553563573583593603643653663673683693703743753763773783793803843853863873883893903953963973983994004054064074084094224394404434454474484494504534574584594604654664674684694704754764774784794804854864874884894904964974984995005065075085095335495505545565585595605645685695705765775785795805865875885895905975985996006076086096446596606656676696706756796806876886896906986997007087097557697707767787807867907977998008098668778798808878888978988999009089329439549659769799879891000

Более короткая строка: 38 37 34 (1020 символов):

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

для ($ @ = 1E3; $ @ -;) {$ _ = $ @, если / $ @ /.!} печать

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

Выходы:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Все еще не доволен дублированием, особенно 99999 в начале! Я думаю, что гораздо больше проверок создаст намного больше кода, хотя ...

Редактировать: Добавлено предложение от @Peter Taylor

Редактировать 2: Несколько замечательных предложений от @primo! Спасибо

Дом Гастингс
источник
2
Хороший трюк, чтобы написать 1000 как 1e3, но я думаю, что это бессмысленно. Вопрос говорит «строго ниже 1000», что будет означать до 999 включительно. (Пример кода также обрабатывает 0..999.)
manatwork
Отличный момент! У меня был другой цикл, я исправил это соответственно! Благодарность!
Дом Гастингс
3
Если вы используете не алфавитный символ для вашей переменной, можете ли вы удалить пробел?
Питер Тейлор
Ах, да, я могу! Благодарность!
Дом Гастингс
2
Еще несколько небольших улучшений: вместо этого $_.=$@if!/$@/вы можете использовать повторение строк $_.=$@x!/$@/. forМожет быть заменен на whileкачестве модификатора заявления, используя по модулю:...while$@=--$@%1e3
Primo
10

APL (20, выход: 1020)

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

Объяснение:

  • {∨/⍺⍷⍵:⍵⋄⍵,⍺}: if ⍺является подстрокой ⍵, return ⍵, else return⍵,⍺
  • /: уменьшить сверх
  • ⍕¨: строковое представление каждого из
  • ⍳999: целые числа от 1до 999.

Выход:

9999989979969959949939929919909889879869859849839829819809789779769759749739729719709689679669659649639629619609589579569
      55954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913
      91291191090890790690590490390290190088888788688588488388288188087787687587487387287187086786686586486386286186085785
      68558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108
      07806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735
      73473373273173072672572472372272172071671571471371271171070670570470370270170066666566466366266166065565465365265165
      06456446436426416406356346336326316306256246236226216206156146136126116106056046036026016005555545535525515505445435
      42541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411
      410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

APL (41, выход: 999)

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

Объяснение:

  • ⌽⍕¨100+⍳898: ('999' '998' ... '101')(в обратном порядке, потому что сокращение идет справа налево в APL, т.е. F/a b c ≡ a F (b F c))
  • /: уменьшить
  • ⍵,⍺⍴⍨: правый аргумент, за которым следуют первые Nсимволы левого аргумента, где N:
  • 3×~∨/⍺⍷⍵: 3если ⍺не является подстрокой ⍵, в противном случае0
  • (1=⍴∪⍺): 1если ⍺есть только один уникальный характер, в противном случае0
  • ∨: наибольший общий делитель двух предыдущих значений, поэтому: 1if ⍺еще не введен ⍵и имеет только один уникальный символ, 3если ⍺еще не введен, ⍵но имеет более одного уникального символа, в 0противном случае.
  • '0',⍨: добавить ноль в конец результата

Выход:

10110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451
      46147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188
      18919019219319419519619719819920020220320420520620720820922232242252262272282292302332342352362372382392402432442452
      46247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294
      29529629729829930030330430530630730830933343353363373383393403443453463473483493503543553563573583593603643653663673
      68369370374375376377378379380384385386387388389390394395396397398399400404405406407408409444544644744844945045545645
      74584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566
      56756856957057657757857958058658758858959059659759859960060660760860966676686696706776786796806876886896906976986997
      00707708709777877978078878979079879980080880988898908999009099100
Мэринус
источник
8

Рубин: 50 46 символов (вывод 1020 символов)

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

Образец прогона:

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

Тестовый забег:

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

Рубин: 102 97 символов (вывод 999 символов)

s=""
999.downto(0){|i|s[n=i.to_s]||[2,1].map{|j|n[0,j]==s[-j,j]&&s+=n[j,9]and break}&&s+=n}
$><<s

Образец прогона:

bash-4.1$ ruby -e 's="";999.downto(0){|i|s[n=i.to_s]||[2,1].map{|j|n[0,j]==s[-j,j]&&s+=n[j,9]and break}&&s+=n};$><<s'
999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110100

Тестовый забег:

bash-4.1$ ruby -e 's="";999.downto(0){|i|s[n=i.to_s]||[2,1].map{|j|n[0,j]==s[-j,j]&&s+=n[j,9]and break}&&s+=n};$><<s' | ruby -ne 'p (0..999).reject{|i|$_[i.to_s]}'
[]
manatwork
источник
Хорошая идея перейти с 999 на 0, а не наоборот. При этом мой метод Java выводит строку из 1048 символов (вместо 1200).
Fabinout
1
Если вас беспокоит только длина кода, а не длина вывода, вы можете улучшить первый, используя диапазон строк. Что-то вроде (?0..?9*3).map{|i|$/[i]||($><<i;$/+=i)}может быть?
Пол Престиж
5

JavaScript, 39

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

Вывод 1020 символов:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100


Проверка: for(i=0;i<1000;i++)console.assert(k.indexOf(i)>=0)

копия
источник
5

Mathematica ( 62 64 символа, 1002 выхода)

Поскольку для этого используется нативная функция, я все больше ценю красоту более коротких решений с нуля. Выход составляет 1002 символа.

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

"799798787770760750740730720710980970960950940930920910108908708608508408308208889998988081009909008007006005004003002000190180170160150140130120119118117116115114113112912812712612512412312213913813713613513413313214914814714614514414314215915815715615515415315216916816716616516416316217917817717617517417317218918818718618518418318219919819719619519419319212111029028027026025024023022922822722622522422392382372362352342332492482472462452442432592582572562552542532692682672662652642632792782772762752742732892882872862852842832992982972962952942932322202103903803703603503403393383373363353349348347346345344359358357356355354369368367366365364379378377376375374389388387386385384399398397396395394343330320310490480470460450449448447446445945845745645546946846746646547947847747647548948848748648549949849749649545444043042041059058057056055955855755695685675665795785775765895885875865995985975965655505405305205106906806706696686679678677689688687699698697676660650640630620610790780779778978879"
DavidC
источник
1
кажется, вам не хватает 799 и 997. см. ideone.com/d07bG2 (или выписать свой чек)
Джастин
Хороший улов. По умолчанию DeBruijnSequenceпредполагается циклическая упаковка. Предварительная «79», последние две цифры, решает проблему.
DavidC
4

Mathematica, 51 символ

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

Выход (1155 символов):

000100101110111200201202210211212220221222300301302303310311312313320321322323330331332333400401402403404410411412413414420421422423424430431432433434440441442443444500501502503504505510511512513514515520521522523524525530531532533534535540541542543544545550551552553554555600601602603604605606610611612613614615616620621622623624625626630631632633634635636640641642643644645646650651652653654655656660661662663664665666700701702703704705706707710711712713714715716717720721722723724725726727730731732733734735736737740741742743744745746747750751752753754755756757760761762763764765766767770771772773774775776777800801802803804805806807808810811812813814815816817818820821822823824825826827828830831832833834835836837838840841842843844845846847848850851852853854855856857858860861862863864865866867868870871872873874875876877878880881882883884885886887888900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999
alephalpha
источник
Что оно делает?
Fabinout
1
Он строит список списков формы , {i, j, k}где iнаходится от 0 до 9 и j, kменьше i. Затем он преобразует список в строку.
алефальфа
4

Python - 53 63Выход 1134

Это довольно грубо, но это действительно так. Да, он имеет ведущий ноль, но он сохраняет два символа, не имея range(1,1000).

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

Приведенное выше бросает более DeprecationWarningчем использование 1e3 в range()вызове, но сохраняет символ более 1000.

Также есть немного более оптимальная версия вывода длины, путем изменения строки за счет 65 символов (спасибо res и filmor за советы) :

Python - 58, выход 1021

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

источник
1
Я считаю, что ваша первая программа имеет длину вывода 1133, а не 1132. В Python 2 (но не Python 3) вы можете сократить код до 54 символов, используя обратные пометки:for i in range(999):s+=`i`*(not`i`in s)
res
Знаешь? Они вынули клюшки? Наверное, у Гвидо был день, когда я решал, что оставить. Я ненавижу Perl и все, что похоже на это.
Уоррен П
1
Вы можете сократить это на один символ, используя range(999,99,-1)вместо range(1000)[::-1].
фильм
А чаевые от res все же помогают, str(i)*(str(i)not in s)немного короче i=str(i);s+=[i,''][i in s];)
filmor
@filmor Сделано меньше и снова меньше, используя 1e3вместо1000
2

К, 33

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

В основном то же, что и решение Howards - 1133 символа.

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
tmartin
источник
2

Java - 126 98 символов (Java 6)

class b{static{String s="";for(int a=999;a>0;a--)s=s.contains(""+a)?s:s+a;System.out.println(s);}}

Выход (1020 символов):

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Может достичь хорошего (по словам Питера Тейлора , но позже он сказал, что 999 был оптимальным) Длина строки, добавив несколько символов (+20 символов для 147 118):

class b{static{String s="";for(int a=999;a>0;a--)s=s.contains(""+a)?s:(a+1)%111==0?s+a%10:s+a;System.out.println(s);}}

Выход (1002 символа):

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110101100

Редактировать : Спасибо Fabinout за указание, что Java 6 может сохранить 28 символов.

Джастин
источник
Если вы хотите, вы можете скомпилировать с Java 6 и использовать статический блок вместо System.out.println () !!
Fabinout
@Fabinout Вы имеете в виду вместо public static void main(String[]a)? (это изменило бы мой код с ...public static void main(String[]c){...на ...static{...)
Джастин
Да. вы можете попробовать с Java 6.
Fabinout
Кстати, вы должны использовать exit () в конце статического блока, если вы не хотите, чтобы ваша программа вылетала. Даже при том, что в гольфе не требуется, чтобы не разбиться.
Fabinout
2

Windows PowerShell - 40, выход 1020

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

Выход:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100
goric
источник
2

Haskell, 75 байт - выход 1002

Сетчатый подход, который возвращает минимальное решение.

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

Обратите внимание, что это решение нереально медленно.

Томас Эдинг
источник
Вы должны включить импорт Data.Listfor isInfixOf, однако вы все равно можете сэкономить 2 байта, играя в гольф еще немного: 1) Жесткий код n = 10002) Использовать allболее andи бессмысленную версию предиката 3) Использовать (!!0)более head4) Использовать понимание списка вместо комбинации map& filter5) использовать (<$>)более map:[s|s<-show<$>[1..],all((`isInfixOf`s).show)[1..1000]]!!0
მოიმო
2

Powershell, 36 байт, 1020 вывод

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

Выход:

999998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888887886885884883882881880877876875874873872871870867866865864863862861860857856855854853852851850847846845844843842841840837836835834833832831830827826825824823822821820817816815814813812811810807806805804803802801800777776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555554553552551550544543542541540534533532531530524523522521520514513512511510504503502501500444443442441440433432431430423422421420413412411410403402401400333332331330322321320312311310302301300222221220211210201200111110101100

Альтернатива, 69 байтов, 1000 выходных

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

Выход:

9998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888788688588488388288188087787687587487387287187086786686586486386286186085785685585485385285185084784684584484384284184083783683583483383283183082782682582482382282182081781681581481381281181080780680580480380280180077767757747737727717707667657647637627617607567557547537527517507467457447437427417407367357347337327317307267257247237227217207167157147137127117107067057047037027017006665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555455355255155054454354254154053453353253153052452352252152051451351251151050450350250150044434424414404334324314304234224214204134124114104034024014003332331330322321320312311310302301300222122021121020120011101100

Альтернатива, 82 73 байта, 999 выводов (минимум)

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

Это упрощенный алгоритм из « Генерации кратчайшего де Брюйна», адаптированный для констант: алфавит = 9876543210и длина =3

Выход:

999899799699599499399299199098898798698598498398298198097897797697597497397297197096896796696596496396296196095895795695595495395295195094894794694594494394294194093893793693593493393293193092892792692592492392292192091891791691591491391291191090890790690590490390290190088878868858848838828818808778768758748738728718708678668658648638628618608578568558548538528518508478468458448438428418408378368358348338328318308278268258248238228218208178168158148138128118108078068058048038028018007776775774773772771770766765764763762761760756755754753752751750746745744743742741740736735734733732731730726725724723722721720716715714713712711710706705704703702701700666566466366266166065565465365265165064564464364264164063563463363263163062562462362262162061561461361261161060560460360260160055545535525515505445435425415405345335325315305245235225215205145135125115105045035025015004443442441440433432431430423422421420413412411410403402401400333233133032232132031231131030230130022212202112102012001110100

Тестовый скрипт:

$f= {

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

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

}

$s=&$f

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

05AB1E , 9 байтов и 1109 символов

₄FDNå_iNì

Выходы:

90990190089989088981980980880079979879078978878077977870970870770069969869769068968868768067967867767066966866760960860760660059959859759659058958858758658057957857757657056956856756656055955855755650950850750650550049949849749649549048948848748648548047947847747647547046946846746646546045945845745645545044944844744644540940840740640540440039939839739639539439038938838738638538438037937837737637537437036936836736636536436035935835735635535435034934834734634534434033933833733633533430930830730630530430330029929829729629529429329028928828728628528428328027927827727627527427327026926826726626526426326025925825725625525425325024924824724624524424324023923823723623523423323022922822722622522422320920820720620520420320220019919719619519419319219118918818718618518418318218017917817717617517417317217016916816716616516416316216015915815715615515415315215014914814714614514414314214013913813713613513413313213012912812712612512412312212011811711611511411311211110910810710610510410310210110099919089888079787770696867666059585756555049484746454440393837363534333029282726252423222018171615141312119876543210

Попробуйте онлайн или убедитесь, что он содержит все числа ниже 1000 .

Объяснение:

₄            # Push 1000
 F           # Loop N in the range [0,1000):
  D          #  Duplicate the top value on the stack
   Nå_i      #  If it does not contain N as substring yet:
       Nì    #   Prepend N to it
             # (Output implicitly after the loop)
Кевин Круйссен
источник
1

Пайк, 13 байтов (неконкурентный), длина строки 1133

Пайк новее, чем вызов и, следовательно, неконкурентоспособен.

k~mV~oi{!o`*+

Попробуй это здесь!

              - o = 0
k~mV          - repeat 1000 times, i = ""
    ~oi{      -     str(o) in i
        !     -    not ^
         o`*  -   str(o++) * ^
            + -  i += ^
синий
источник
Как долго это выход?
Kritixi Lithos
1

PHP, 48 44 байта

Спасибо @primo за напоминание ereg.

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

или

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

Выход: 1020 символов. требует PHP <7

PHP 7, 48 байт:

ereg был удален в PHP 7

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

Если второй аргумент strstr(или strposдругих функций поиска строк) не является строкой, он будет использоваться как код ascii, поэтому $iтребуется приведение к строке.

Titus
источник
1
ereg($i,$s)для 4 (я бы также включил <?в подсчет байтов).
Примо
@primo Я только что заметил, что этот вызов старше, чем PHP 7. Двойное спасибо. :)
Титус
eregбыл удален, предположительно, из-за того, что имя функции слишком короткое и / или не содержит достаточного подчеркивания. Это splitбыло также удалено, особенно блестяще.
Примо
eregбыл удален, потому что POSIX содержит только подмножество возможностей PCRE; и они, вероятно, не хотели поддерживать две разные библиотеки. Я спрошу, должен ли я когда-нибудь снова встретиться с Расмусом Лердорфом. splitбыл удален, но joinостался (вероятно, потому что это «только» псевдоним). Извините за педантизм; но я знаю людей, которые не могут распознать иронию.
Тит
1

Groovy, 49 символов / байт

Я не был уверен, делать ли это как функцию, возвращающую строковую переменную, или распечатывать результат, так что это просто выводит его на стандартный вывод. С помощью сопоставителя регулярных выражений удалось сохранить 2 байта, используя троичный оператор вместо «если» сохранил другой байт. Выходная строка - 1133 символа.

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

Выход:

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100102103104105106107108109110112114115116117118119120124125126127128129130132133134135136137138139140142143144145146147148149150152153154155156157158159160162163164165166167168169170172173174175176177178179180182183184185186187188189190193194195196197198199200203204205206207208209219220221223225226227228229230231235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290294295296297298299300304305306307308309311329330332334336337338339340342346347348349350354355356357358359360364365366367368369370374375376377378379380384385386387388389390395396397398399400405406407408409422439440443445447448449450453457458459460465466467468469470475476477478479480485486487488489490496497498499500506507508509533549550554556558559560564568569570576577578579580586587588589590597598599600607608609644659660665667669670675679680687688689690698699700708709755769770776778780786790797799800809866877879880887888897898899900908932943954965976979987989
Rado
источник
-1

Game Maker Language, 1014 - Строка 1000

show_message(909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900)

Также:

Рубин, 1003 - Строка 1000

p'909910010110210310410510610710810911121131141151161171181191201221231241251261271281291301321331341351361371381391401421431441451461471481491501521531541551561571581591601621631641651661671681691701721731741751761771781791801821831841851861871881891901921931941951961971981992002022032042052062072082092223224225226227228229230233234235236237238239240243244245246247248249250253254255256257258259260263264265266267268269270273274275276277278279280283284285286287288289290293294295296297298299300303304305306307308309333433533633733833934034434534634734834935035435535635735835936036436536636736836937037437537637737837938038438538638738838939039439539639739839940040440540640740840944454464474484494504554564574584594604654664674684694704754764774784794804854864874884894904954964974984995005055065075085095556557558559560566567568569570576577578579580586587588589590596597598599600606607608609666766866967067767867968068768868969069769869970070770870977787797807887897907987998008088098889890899900'

Timtech
источник
3
1) Ваше первое решение нарушает правило «длина строки должна быть не более 1500 символов». 2) Я не могу найти номер 909 в вашем выводе. (Вы пропустили первую цифру при копировании из ответа primo ?) 3) rubyКод можно использовать pвместо putsпередачи числового параметра.
manatwork