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

Ваше завдання - роздрукувати цілі числа у порядку зменшення, починаючи з 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

Переможець

Переможець обраний! Це була відповідь Еріка Гольфера з вражаючими 5 байтами! Вітаємо!

Желе , 5 байт

RRUVV

Спробуйте в Інтернеті!

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

Я підозрюю, що тут відбувається занадто багато ...

[ВІДПОВІДЬ ВИКОРИСТАНИЙ] Я б дав Денису десь 5 представників, але це не Репутаційна біржа. Денніс показав мені свою 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's потрібні для обох рівнів розширення - для першого рівня, щоб $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 до Н.
• ⍳¨∘: для кожного з них знайдіть числа від 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 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

Спробуйте в Інтернеті!

Математика, 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

Спробуйте в Інтернеті!

Пітон , 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%}%

перекладач