Выведите целые числа в отрицательном порядке, увеличивайте максимальное целое число каждый раз


44

Основная задача

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

1
21
321
4321
54321
654321
Without newlines (valid output):
121321432154321654321
Примечание: это A004736 в OEIS. Кроме того, первый пример (с символами новой строки) является неверным выводом, как указано в правилах.

вход

Ваш код может принимать любые виды ввода (графический, STDIN) в виде целого числа или числа.

Выход

Ваш код должен выводить описанную выше последовательность, до тех пор, пока не будет достигнут вводимый номер, а затем завершить вывод, пока он снова не достигнет 1. Вывод может быть любым, поэтому числа, строки, целые числа или графический вывод. Требуется распечатать одно число (без перевода строки, если это строка). Ваш вывод может быть введен и выведен с таким количеством символов, как вам нужно (например []).

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

^(\D*(\d)+\D*)$

правила

  • Вывод должен быть полным числом, не разделенным ничем, даже переводом строк.
  • Алгоритм должен проверять не первый экземпляр N, появляющийся каким-либо образом (например, 21in 121321), а скорее первый экземпляр N как фактическое число.
  • Допускается один завершающий перевод строки.
  • Обработка для отрицательного ввода - полностью ваш выбор, отрицательные числа - не случаи, которые вы должны проверить.

Контрольные примеры

Input: 6
Output: 121321432154321654321

Input: 1 Output: 1

Input: 26 Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0 Output: 0, Empty, or Error

Input: 21 Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

Спасибо @Emigna, я использовал его алгоритм для расчета этих тестов.

победитель

Победитель был выбран! Это был ответ ErikGolfer с впечатляющими 5 байтами! Поздравляем!


The output must be a full number ...Вы имеете в виду всю последовательность или только разные подстроки (1, 2-1, 3-1 ...)? Ваш первый пример не соответствует этому утверждению.
Стинберг

1
Если выходные данные должны быть одним числом, как это могут быть «массивы»?
Smls

Будет ли этот массив приемлемым в качестве вывода? [1, 21, 321, 4321, 54321, 654321] Как насчет этого? [1,2,1,3,2,1,4,3,2,1,5,4,3,2,1,6,5,4,3,2,1] Или вы просто говорите о массивах с одним элементом, как [121321432154321654321]?
Smls

1
Я запутался насчет формата вывода. Можете ли вы привести примеры того, что является приемлемым? Массив чисел? Строка с числами, разделенными пробелами?
Луис Мендо

1
Ваше регулярное выражение разрешает вывод mickey321211mouse. На самом деле у \Dчастей нет причин быть там
edc65

Ответы:


13

Желе , 5 байт

RRUVV

Попробуйте онлайн!

Формула не моя.

Я подозреваю, что здесь происходит слишком много ...

[ПРИНЯТЬ ОТВЕТ] Я бы дал Деннису около 5 повторений, но это не Reputation Exchange. Деннис показал мне VVповедение. К моему удивлению, это короче, чем 05AB1E.


Поздравляем, этот код имеет наименьшее количество кода!
devRicher

19

05AB1E , 6 байтов

L€LíJJ

Попробуйте онлайн!

объяснение

Пример ввода 4

L       # range [1 ... input]
        # STACK: [1,2,3,4]
 €L     # map: range
        # STACK: [[1],[1,2],[1,2,3],[1,2,3,4]]
   í    # reverse each
        # STACK: [[1],[2,1],[3,2,1],[4,3,2,1]]
    J   # join inner lists
        # STACK: ['1','21','321','4321']
     J  # join list
        # OUTPUT: 1213214321

13

JavaScript (ES6), 37 байт

f=(n,k=1)=>k>n?n--?f(n):'':f(n,k+1)+k

демонстрация

Альтернативный метод для n <10, 34 байта (не конкурирующий)

f=(n,s='1')=>--n?s+f(n,++s[0]+s):s

В JavaScript строки неизменны. Следовательно, невозможно изменить содержимое N-го символа строки s, присвоив новое значение s[N].

Тем не менее, выражение ++s[N]является допустимым и действительно оценивает, как и следовало ожидать, даже если строка остается неизменной. Например:

++"1"[0] // equals 2

И по расширению:

s = "21"
++s[0] + s // equals "321"

Кажется, не работает для n> 9
edc65

@ edc65 Ты прав, конечно. Я не знаю, почему я думал, что все в порядке, чтобы остановиться в 9.
Арнаулд

12

V, 29 28 27 23 19 17 16 байтов

8 байтов сохранено благодаря @DJMcMayhem

3 байта сохранены благодаря @ nmjcman101

"apÀ­ñÄòy$jpkgJ

Скрытые персонажи:

"apÀ<C-x>ñÄ<C-x>òy$jpkgJ

C-x это Ctrl + x.

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

HexDump:

0000000: 2261 70c0 adf1 c418 f279 246a 706b 674a  "ap......y$jpkgJ

объяснение

"ap            Paste the argument
À<C-x>         Argument minus 1 times (so that we exclude the 0)
ñ ... ò        Loop (for some weird reason the ò closes the ñ)
Ä<C-x>         paste current line above and decrement it

Теперь это выглядит так:

1
2
...
n

продолжение ...

ò             recursively do (until a breaking error)
y$             yank this line
  jp           paste it down
    kgJ        go up and join
              implicit ò end

GIF (устаревший)

(для аргумента 6)

GIF


Я получил несколько, изменив ваш цикл на а) неявное завершение и б) присоединение строк по ходу (а не в конце)òy$jpkgJ
nmjcman101

@ nmjcman101 Спасибо, что помогли мне сэкономить 2 байта!
Критиси Литос

Это очень хорошо в гольф. Я ломал голову уже 20 минут и не могу придумать ничего более короткого. :)
DJMcMayhem

@DJMcMayhem Это потому, что мне очень помогли :)
Kritixi Lithos

Я это сделал! Вы можете получить до 16 байтов. Если вы вставите arg, а затем дублируете / уменьшите вверх, вы получите возможность удалить H. Тогда, если вы используете оператор декремента на вашем À, у вас не будет 0 в верхней части, поэтому вы можете удалить x. Затем, по-видимому, a òзакроет a, ­ñчтобы вы могли удалить второй ­ñ(это байт, который вы сохраняете). Ссылка, потому что это не имело смысла
nmjcman101

11

C #, 72 69 65 байт

n=>{for(int i=0,j;i<n;)for(j=++i;j>0;)System.Console.Write(j--);}

Если вывод может быть просто возвращен, а не записан на консоль

C #, 71 68 64 байта

n=>{var s="";for(int i=0,j;i<n;)for(j=++i;j>0;)s+=j--;return s;}

Спасибо @VisualMelon за сохранение большого количества байтов

Проверьте это здесь (шутливо, что онлайн-компилятор ломается на любое число выше 420)


Это было действительно быстро.
devRicher

@devRicher Что я могу сказать, я ждал, чтобы что-то было опубликовано: P
Alfie Goodacre

2
Нет никакой причины использовать цикл while в гольфе кода C #, цикл for всегда будет работать так же хорошо, если не лучше. В этом случае вы можете включить присвоение j=1в цикл for и сохранить точку с запятой. Вы можете также объявить jвместе с i, чтобы спасти int. i++Также может быть перемещен в j=iуступке, экономя байт. Вы также должны быть в состоянии заменить i<=nс , i<nесли вы сделаете это j=++iвместо того, чтобы начать и iв 0.
VisualMelon

@VisualMelon отредактировал его, сохранил 3 байта! Объявление целых чисел фактически не имело никакого значения для количества байтов, но это заставляет циклы выглядеть немного лучше
Alfie Goodacre

@AlfieGoodacre, если вы объявляете их вместе в цикле for, то вы сохраняете еще 2 байта for(int i=0,j;i<n;);) Также нет необходимости {}во внутреннем цикле for.
VisualMelon

8

Чистая Баш, 34

eval eval printf %s \\{{1..$1}..1}

Два уровня расширения скобки. При вводе 6первый уровень расширяется до {1..1} {2..1} {3..1} {4..1} {5..1} {6..1}. Затем это расширяется до 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1 6 5 4 3 2 1, который смешивается в одну строку с printf %s. evalТребуются на обоих уровнях расширения - для первого уровня, чтобы $1параметр расширялся первым, и для второго уровня, чтобы он расширялся после первого уровня.

Попробуйте онлайн


8

Perl, 21 байт

Используется -Eбез каких-либо дополнительных затрат.

say map$}=$_.$},1..<>

использование

perl -E 'say map$}=$_.$},1..<>' <<< 6
121321432154321654321

7

Pyth, 7 байт

jks}R1S

Программа, которая принимает ввод целого числа и печатает результат.

Попробуйте онлайн!

Как это работает

jks}R1S   Program. Input: Q
jks}R1SQ  Implicit input fill
    R     Map
      SQ  over [1, 2, 3, 4, ..., Q] with i:
   } 1     Yield [i, i-1, i-2, i-3, ..., 1]
  s       Merge
jk        Join
          Implicitly print

Лично я очень разочарован, что jk_hC.:Sэто дольше, но хорошая работа!
FryAmTheEggman

7

GeoGebra , 67 байт

1
InputBox[a]
Sum[Join[Sequence[Sequence[Text[j],j,i,1,-1],i,1,a]]]

Каждая строка вводится отдельно в строку ввода. Ввод берется из поля ввода.

Вот gif исполнения:

Выполнение программы

Как это работает

Ввод 1неявно правопреемников aк 1, и InputBoxкоманда связывает поле ввода с a. Затем для каждого iдюйма {1, 2, 3, ..., a}, список {i, i-1, i-2, ..., 1}создается с помощью Sequenceкоманды, и каждый jв этом списке преобразуется в строку , используя Text. Наконец, Joinобъединяет все списки и Sumобъединяет все элементы в один текстовый объект, который отображается.


@devRicher Это кажется разумным. Благодарность!
TheBikingViking


7

Сетчатка , 26 22 байта

Число байтов предполагает кодировку ISO 8859-1.

.+
$*

$`¶
1
$.%'
0?¶

Попробуйте онлайн!

объяснение

.+
$*

Преобразовать ввод в унарный.


$`¶

В каждой позиции вставьте префикс до этой точки, а также перевод строки. Это создает унарный диапазон от 2до n+1, одно значение в строке.

1
$.%'

Замените каждый 1на количество символов после него в той же строке. Это превращает что-то вроде 11111в 43210.

0?¶

Удалите все переводы строк и нули, предшествующие им.


5

Язык GameMaker, 65 байт

b=""for(i=1;i<=argument0;i++){c=i while(j)b+=string(c--)}return b

5

APL, 10 байт

∊⍕¨∘⌽∘⍳¨∘⍳

Например:

      (∊⍕¨∘⌽∘⍳¨∘⍳)6
121321432154321654321

Объяснение:

  • : получить числа от 1 до N.
  • ⍳¨∘: для каждого из них получить числа от 1 до N.
  • ⌽∘: перевернуть этот список
  • ⍕¨∘: получить символьное представление каждого элемента (чтобы не выводить числа с пробелами между ними)
  • : сгладить результирующий массив

Так что это анализ кода в обратном направлении?
devRicher

Это композиция функций, я дал объяснение в том порядке, в котором функции действительно выполняются
marinus

1
Вот дерево разбора для любопытных: tryapl.org/…
marinus

5

Python 2, 71 68 байт

Бьюсь об заклад, рекурсивное решение может быть короче, но мне трудно сформулировать это как единое целое.

n=input()
i=0
o=""
while i<n:
    i+=1;j=i
    while j:o+=`j`;j-=1
print o

Попробуйте онлайн


5

На самом деле 8 байтов

RR♂RΣRεj

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

Как это работает

Program takes implicit input, implicit print at EOF
R           Takes the input and creates a range (1, input)   
                STACK = [1,2,..,n]
 R          Reverse the top stack item (our range)
                STACK = [n,..,2,1]
  ♂R        For each item in our range, create a range (1, rangeitem)
                STACK = [[1,2,..,n], .., [1,2], [1]]
    Σ       Stitch the items of the list together
                STACK = [n,..,1,2,3,1,2,1]
     R      Reverse the top stack item again (our answer)
                STACK = [1,2,1,3,2,1,..n]
      εj    Create an empty string and append each item from the list to it.
            (turns non string items into strings)

Попробуйте онлайн!


1
Я не уверен , что это более короткое решение, но я доказал себя неправильно раньше. В любом случае, вот ссылка Try It Online для вашего ответа.
Sherlock9

1
Код R♂R♂RΣεjпредставляет собой то же количество байтов, но может быть проще написать объяснение.
Sherlock9

@ Sherlock9 твой путь немного более элегантен, я добавил ссылку и объяснение, которое я забыл добавить вчера, чтобы попытаться объяснить это немного подробнее.
Тил пеликан


4

Perl 6 , 22 байта

{[~] flat [\R,] 1..$_}

Лямбда, которая возвращает строку.

( Попробуйте онлайн. )

Объяснение:

  • 1..$_: Диапазон целых чисел ... (1 2 3 4)
  • [,] 1..$_: Уменьшить ("сложить") через оператор запятой ... (1 2 3 4)
  • [\,] 1..$_: С промежуточными результатами ( треугольное уменьшение ) ...((1) (1 2) (1 2 3) (1 2 3 4))
  • [\R,] 1..$_: Применить обратный мета-оператор к запятой ...((1) (2 1) (3 2 1) (4 3 2 1))
  • [~] flat ...: Удалить вложение списка и сложить оператор строки concat ... 1213214321

4

Haskell, 35 байт

f x=[1..x]>>= \y->[y,y-1..1]>>=show

Пример использования: f 6-> "121321432154321654321".

Для всех чисел xв 1 ... xсписке x,x-1, ... ,1, превратить числа в строку и объединить их в одну строку. Опять же, объедините эти строки в одну строку.


4

C89, 54 байта

i,j;f(n){for(i=1;j<=n;j=i++)while(j)printf("%d",j--);}

56 -2 = 54 благодаря ErikGolfer!


Я думаю, что вы можете сделать (j=i++)вместо (j=i)и удалить последний i++(непроверенный).
Эрик Outgolfer

Вот более короткая рекурсивная версия: i,j;f(n){j=++i;while(j)printf("%d",j--);i-n?f(n):0;}(52 байта)
Steadybox

@Steadybox Вы можете добавить это как свой собственный ответ, если хотите, но спасибо!
кот

@ Cat Хорошо, спасибо, только что сделал. Не был уверен, должен ли я, так как я только отредактировал ваше решение.
Steadybox

4

Python 3, 87 92 83 74 байта

lambda n:"".join(["".join([str(i)for i in range(1,k)][::-1])for k in range(1,n+2)])

Краткий ответ с использованием рекурсии:

f=lambda n:f(n-1)+"".join([str(i)for i in range(1,n+1)][::-1])if n>0else""

Возможно, не самый короткий, но он сделан только с пониманием списка Python!

(Отредактировано, чтобы добавить функцию печати и удалить \ n)

(Отредактировано для удаления функции печати и изменения n + 1, k + 1 на n, k + 2)


Работает с k, n + 2, но не с k + 2, n, спасибо за идею :)
Sygmei

Код, который вы набираете, должен быть первым. Кроме того, вы должны использовать Python 2, а затем использовать `i`вместо str(i). И вы можете использовать "".join(...)вместо "".join([...]), и range(1,k,-1)удалить [...][::-1].
mbomb007

Также n>0может быть n. И я имел в виду range(n,0,-1). И использовать n and f(n-1)+...)or"".
mbomb007

1
62 байта . На самом деле, это может быть слишком близко к этому ответу .
mbomb007

Да, это становится довольно близко, я увидел это после того, как сделал мою вторую версию :(
Sygmei

3

Pyth, 8 байт

jks_M._S

объяснение

jks_M._SQ   Implicit input
       SQ   Get the range [1, 2, ..., N]
     ._     Get each prefix
   _M       Reverse each prefix
jks         Join everything as a string


3

Mathematica, 36 байт

ToString/@(""<>Range[Range@#,1,-1])&

Выдает кучу предупреждений, которые можно смело игнорировать.

объяснение

Используя вход 5в качестве примера:

Range@#

Создает диапазон {1, 2, 3, 4, 5}.

Range[...,1,-1]

Rangeявляется списком, поэтому мы можем дать ему список для любого из его аргументов, и он будет автоматически перебирать этот аргумент. Так что это дает нам несколько обращенных списков:

{{1}, {2, 1}, {3, 2, 1}, {4, 3, 2, 1}, {5, 4, 3, 2, 1}}

Следующий:

(""<>...)

Это объединяет вложенный список с пустой строкой. Поскольку вложенный список на самом деле не содержит никаких строк, он не может действительно соединять значения (именно там генерируются предупреждения), но ""<>имеет побочный эффект сглаживания списка. Так что это дает нам

1 <> 2 <> 1 <> 3 <> 2 <> 1 <> 4 <> 3 <> 2 <> 1 <> 5 <> 4 <> 3 <> 2 <> 1

Теперь появилась прекрасная особенность Mathematica, которая Mapне заботится о структуре, которую она отображает. Вы обычно применяете это к списку, но это работает с любой головой. f /@ h[a, b, c]просто дает тебе h[f[a], f[b], f[c]]. В нашем случае заголовок StringJoinи значения являются целыми числами.

ToString/@...

Так что это просто превращает целые числа в строки. На этом этапе StringJoin[...]знает, что с ними делать, и объединяет их все в одну строку:

"121321432154321"

1
Это просто противно. :)
Грег Мартин

3

GolfScript , 14 байтов

~,{),{)}%-1%}%

Попробуйте онлайн!

Обычный метод конечно, но это GolfScript.

Пояснение к этому фрагменту кода VAST :

~,{),{)}%-1%}% # Code
               # Initial stack.      ["n"]
~              # Eval ToS.           [n]
 ,             # ToS' lowered range. [[0..n)]
  {),{)}%-1%}  # Block. 1 argument.  [a]
   )           # Increment.          [a+1]
    ,          # Range.              [[0..a)]
     {)}       # Block. 1 argument.  [b]
      )        # Increment.          [b+1]
        %      # Map.                [[1..a]]
         -1    # Integer. -1         [[1..a] -1]
           %   # Each nth element.   [[a..1]]
             % # Map.                [[[1],[2,1],...,[n..1]]]
               # Implicit output.    121...n..1

Обратите внимание, что вывод в виде одного числа. Скользящий \n.


3

R, 38 33 44 байта

if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")

Принимает ввод в STDIN и выполняет цикл от 1 до n, создавая последовательность от i до 1 для каждого шага и печатая ее.

Редактировать: заменить seq(i,1), i:1сохранив 5 байтов и показывая, почему я не должен играть в гольф во время встреч.


Это производит, 101если ввод 0. if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")делает трюк.
Фредерик

Блин, предположил ненулевой ввод :(
JAD

if(n<-scan())должно быть достаточно.
Джузеппе

3

MATL , 14 11 байт

:"@:P]v!VXz

Попробуйте онлайн!

объяснение

:      % Input N implicitly. Push range [1 2 ...N]
"      % For each k in [1 2 ...N]
  @:   %   Push range [1 2 ... k]
  P    %   Reverse
]      % End
v!     % Concatenate all arrays horizontally
V      % Convert to string
Xz     % Remove spaces. Display implicitly

not split up by anythingне думайте, что второй разрешен.
JAD

2
@JarkoDubbeldam Я буду удалять это, пока ОП не прояснит
Луис Мендо

1
@Jarko ОП уточнил. Текущее решение соответствует спецификации
Луис Мендо

3

мозговой трах, 17 байтов

>,[>[+.>]+.[<]>-]

объяснение

>           keep the first cell at 0
 ,          input of the decimal number into the cell
  [>        start a conditionnal loop and go to the next cell
   [+.>]    while it don't find 0, increment each cells and output the value
    +.      increment the new cell and output
     [<]    go to the first cell
      >-]   decrement the second cell and restart

Попробуйте онлайн!


Добро пожаловать в PPCG! Вы уже прочитали страницу тура и самые горячие мета вопросы? Я советую вам, они полезны! Кроме того, оберните ваш код в форматирование кода! Вы прочитали справку по форматированию? Вы также должны объяснить, как работает ваш код, если можете!
devRicher

@muddyfish Я только что добавил объяснение
Милихард

Я использовал мобильное приложение. Вы можете увидеть экран результата.
Милихард

Нет, все хорошо. Но в ссылке выходной результат представлен в
формате

@muddyfish Ваша постоянная ссылка немного сбивает с толку. На входе есть невидимый 0x06, за которым следует десятичная цифра 6 .
Деннис

3

Python , 63 57 59 байт

Рекурсивное решение, которое работает как в Python 2, так и в 3. Это, вероятно, можно продолжить. Предложения по игре в гольф приветствуются! Попробуйте онлайн!

Изменить: -6 байт благодаря Джонатану Аллану. +2 байта, спасибо mbomb007 за указание на проблему с моим ответом.

f=lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""

Ungolfing

def f(n):
    s = ""
    for i in range(n+1):
        m = map(str, range(n, 0, -1))
        s += "".join(m)
    return s

2
Используйте mapдля сохранения 6 байтов:lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""
Джонатан Аллан

2

PHP, 35 34 33 байта

Спас байт, потому что я ошибся, спасибо Титус! И другой!

while($i++<$argv[1])echo$s=$i.$s;

Запустите из командной строки с -r.

Довольно простой ответ, цикл от 1 до нашего ввода n, прикрепление числа к началу строки и распечатывание его.


Я считаю 34. Один байт короче с постинкрементом.
Тит

33 байта:while($i++<$argv[1])echo$s=$i.$s;
aross

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.