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

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

1
21
321
4321
54321
654321
Without newlines (valid output):
121321432154321654321

вход

Ваш код может принимать любые виды ввода (графический, 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

победитель

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

Желе , 5 байт

RRUVV

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

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

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

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

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

JavaScript (ES6), 37 байт

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

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

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

console.log(f(6))

Альтернативный метод для 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"

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)

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)

Чистая Баш, 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параметр расширялся первым, и для второго уровня, чтобы он расширялся после первого уровня.

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

Perl, 21 байт

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

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

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

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

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

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объединяет все элементы в один текстовый объект, который отображается.

Python 2, 51 байт

r=s=''
n=0
exec'n+=1;s=`n`+s;r+=s;'*input()
print r

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

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

.+
$*

$`¶
1
$.%'
0?¶

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

объяснение

.+
$*

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

$`¶

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

1
$.%'

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

0?¶

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

Язык GameMaker, 65 байт

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

APL, 10 байт

∊⍕¨∘⌽∘⍳¨∘⍳

Например:

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

Объяснение:

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

Python 2, 71 68 байт

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

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

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

На самом деле 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)

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

Брахилог , 8 байт

yb@[rcw\

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

объяснение

yb         The list [1, ..., Input]
  @[       Take a prefix of that list
    rc     Reverse it and concatenate into an integer
      w    Write to STDOUT
       \   Backtrack: try another prefix

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

Haskell, 35 байт

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

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

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

C89, 54 байта

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

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

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)

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

05AB1E , 6 байтов

LR.sJJ

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

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"

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.

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 байтов и показывая, почему я не должен играть в гольф во время встреч.

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

мозговой трах, 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

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

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

PHP, 35 34 33 байта

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

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

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

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

CJam, 13 байтов

ri,:){,:)W%}%

переводчик