আন্তঃলিভ সংখ্যা 1 থেকে এন, একই সংখ্যার বিপরীতে

Question

একটি সাধারণ:

একটি ধনাত্মক পূর্ণসংখ্যা নিন এন 1000 কম, এবং আউটপুট পূর্ণসংখ্যার 1 থেকে এন থেকে পূর্ণসংখ্যার সঙ্গে ইন্টারলিভড্ এন করতে 1 । আপনাকে অবশ্যই সংখ্যাগুলি একত্রিত করতে হবে যাতে তারা তাদের মধ্যে কোনও সীমানা ছাড়াই উপস্থিত হয়।

পরীক্ষার কেস:

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

এটি কোড-গল্ফ তাই প্রতিটি ভাষার বাইটে সংক্ষিপ্ততম জমাটি জিততে পারে। ব্যাখ্যা উত্সাহিত হয়।

Answer 1

জাভাস্ক্রিপ্ট (ES6), 30 বাইট

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

কিভাবে?

এটি বেশ সোজা সরল তবে এটি লক্ষ্য করার মতো যে স্ট্রিংটি লেজ থেকে মাথা পর্যন্ত নির্মিত। শুরুতে একটি খালি স্ট্রিংটি সর্বশেষে যুক্ত হয় এবং চূড়ান্ত ফলাফলের জোরকে স্ট্রিংয়ের অনুমতি দেয়।

নীচে এর জন্য পুনরাবৃত্তির বিবরণ দেওয়া হল f(4):

f(4) =                                            // initial call
f(4, 1) =                                         // applying the default value to k
f(3, 2) + 4 + 1 =                                 // recursive call #1
(f(2, 3) + 3 + 2) + 4 + 1 =                       // recursive call #2
((f(1, 4) + 2 + 3) + 3 + 2) + 4 + 1 =             // recursive call #3
(((f(0, 5) + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =   // recursive call #4
((('' + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =        // n = 0 --> end of recursion
'' + 1 + 4 + 2 + 3 + 3 + 2 + 4 + 1 =              // final sum
'14233241'                                        // final result

পরীক্ষার মামলা

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

console.log(f(1))
console.log(f(4))
console.log(f(26))
console.log(f(100))

Answer 2

পাইথন 2 , 46 বাইট

lambda n:''.join(`x+1`+`n-x`for x in range(n))

4 বাইটের জন্য ovs ধন্যবাদ

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

lambda n:''.join(`x+1`+`n-x`for x in range(n))
lambda n:                                      # anonymous lambda taking one parameter n
                 `x+1`+`n-x`                   # `x` is repr(x) which is equivalent to str(x) for integers less than INT_MAX
                            for x in range(n)  # integers x in [0, n)

Comments

পাইথন 3 এ আরও দুটি বাইট:f'{x}{n-~-x}'

— L3viathan

@ L3viathan এটি একটি নতুন বৈশিষ্ট্য 3.6-এ যুক্ত হয়েছে।

— মেগো

পাইথন 3.6 পাইথন 3 নয়?

— L3viathan

lambda n:''.join('x+1'+'n-x'for x in range(n))46 বাইটের জন্য। ( 'ব্যাকটিক্স সহ তালিকার

— উপলব্ধিতে

@ ওভস হে, আপনি ব্যাকটিকটি এড়াতে পারবেন -> এতে `\`x+1\``রেন্ডার হয়`x+1`

— রড

Answer 3

-5 ধন্যবাদ অর্জান জোহানসেনকে

হাস্কেল , 33 বাইট

f n=do a<-[1..n];[a,n-a+1]>>=show

এটি অনলাইন চেষ্টা করুন!

Comments

(1) একটি doএক্সপ্রেশনটি >>=লম্বা লম্বার চেয়ে সংক্ষিপ্ত । (2) তবে showএস ব্যবহার করে একত্রিত করা যেতে পারে >>=show।

— janrjan জোহানসেন

Answer 4

বাশ , 25 বাইট

printf %s`seq $1 -1 1|nl`

এটি অনলাইন চেষ্টা করুন!

প্রিন্ট হ্রাস ক্রম, সংখ্যা লাইন বৃদ্ধি এবং প্রিন্টফ লাইন যোগ দেয়

স্থান সীমিত, 20 বাইট: seq $ 1 -1 1 | nl | xargs

Comments

যদি তা গ্রহণযোগ্য না হয় তবে আমি এটি seq $1 -1 1|nl|tr -d ' \n\t'আরও 8 বাইটের জন্য পরিবর্তন করতে পারি

— মার্কোসমে

20 বাইট জমা অবৈধ। আমার আপভোটটি 25 বাইট জমা দেওয়ার জন্য।

— ডিজিটাল ট্রমা

ডিজিটাল ট্রমা হিসাবে উল্লেখ করা হয়েছে, 20-বাইট সমাধানটি অবৈধ।

— এরিক দি আউটগল্ফার

time printf %s'seq 1000000 -1 1|nl'; grep name /proc/cpuinfo real 0m7.985s user 0m6.092s sys 0m0.392s model name : Intel(R) Pentium(R) D CPU 3.00GHz model name : Intel(R) Pentium(R) D CPU 3.00GHz

— marcosm

Answer 5

আর, 35 বাইট

n=scan();cat(rbind(1:n,n:1),sep="")

এটি অনলাইনে চেষ্টা করুন

rbind(1:n,n:1)প্রথম সারিতে 1 থেকে n এবং দ্বিতীয়টিতে n থেকে 1 দিয়ে একটি 2 সারি ম্যাট্রিক্স তৈরি করে। catফাংশন এই ম্যাট্রিক্স ভেঙে, প্রতিটি কলাম নিচে পড়া চালিয়ে যান।

Comments

মনে রাখবেন এটি কেবল ইন্টারেক্টিভ মোডে কাজ করে এবং ব্যবহারকারীকে nকমান্ড লাইনে প্রবেশ করতে হবে (স্টিডিন দিয়ে যাওয়ার পরিবর্তে)।

— শ্যাডট্যালকার

@ এসএসডেকট্রোল হ্যাঁ, আমি মনে করি এটি সাধারণত অনুমোদিত হয় তবে আমি এখানে মোটামুটি নতুন, ভুল হতে পারে।

— ব্যবহারকারী 2390246

আমার মনে হয় এটা সাধারণত গ্রহণযোগ্য, কিন্তু বিশেষ দ্রষ্টব্য, এটা Tio মধ্যে সঠিকভাবে চালনার জন্য আপনি পাদলেখ ক্ষেত্রের ইনপুট (গুলি) দিতে হবে (এবং এটা সবসময় একটি লিঙ্ক অন্তর্ভুক্ত ভালো লাগলো!) Tio.run/nexus/...

— : Giuseppe

Answer 6

05 এ বি 1 ই , 6 5 বাইট

যেমন দ্বারা প্রস্তাবিত একটি বাইট নতুন ইন্টারলিভ বিল্ট-ইন ব্যবহার করে সংরক্ষণ Rev

LÂ.ιJ

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

L        # range [1 ... input]
 Â       # create a reversed copy
  .ι     # interleave the lists
    J    # join

Comments

রেভ নামে একজন ব্যবহারকারী প্রস্তাবিত LÂ.ιJ।

— জোনাথন ফ্রেচ

@ জোনাথনফ্রেচ: আমি জানি এখন sensক্যমত্য হ'ল আমরা চ্যালেঞ্জের চেয়ে নতুন বৈশিষ্ট্যগুলি ব্যবহার করতে পারি তবে আমি সাধারণত পুরানো উত্তরগুলি সম্পাদনা করতে দ্বিধা বোধ করি কারণ একটি নতুন অন্তর্নির্মিত চ্যালেঞ্জটি আরও ভালভাবে সম্পন্ন করে। সেভাবে উন্নত করা যায় এমন

— সবগুলিতে

ঠিক আছে, আমি কেবল মেসেঞ্জার ছিলাম; সম্ভব @ রেভের নিজস্ব উত্তর পোস্ট করা উচিত।

— জোনাথন ফ্রেচ

@ জোনাথানফ্রেচ: আমি এটিকে তিরস্কার হিসাবে বোঝাতে চাইনি। রেভ এটিকে সঠিকভাবে করেছিলেন যখন তিনি সম্পাদনার পরামর্শ দিয়েছিলেন কারণ যখনই কোনও নতুন অন্তর্নির্মিত করা হয় তখন একটি নতুন উত্তর পোস্ট করার চেয়ে বিদ্যমান উত্তরটি সম্পাদনা করা ভাল। পুরানো উত্তরগুলি ঠিক করার ক্ষেত্রে আমার পক্ষে আরও ভাল হওয়া উচিত, কমপক্ষে যখন পরামর্শ দেওয়া হয়।

— এমিগনা

Answer 7

সিজেম , 10 বাইট

ri,:)_W%]z

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

ri   e# Read input and convert to integer N.
,    e# Turn into range [0 1 ... N-1].
:)   e# Increment to get [1 2 ... N].
_W%  e# Duplicate and reverse the copy.
]    e# Wrap both in an array to get [[1 2 ... N] [N ... 2 1]]
z    e# Transpose to get [[1 N] [2 N-1] ... [N-1 2] [N 1]]
     e# This list is printed implicitly at the end of the program,
     e# but without any of the array structure (so it's essentially flattened,
     e# each number is converted to a string and then all the strings
     e# are joined together and printed).

Answer 8

রুবি , 29 বাইট

->n{n.times{|x|$><<x+1<<n-x}}

ব্যাখ্যা:

->n{n.times{|x|                # x in range [0..n-1]
               $><<            # output on console
                   x+1<<n-x}}  # x+1, then n-x

এটি অনলাইন চেষ্টা করুন!

Answer 9

সাদা ব্যবধান , 71 বাইট

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

sssn  ; push 0 - seed the stack with 0 (this will be our 1->n counter, a)
sns   ; dup
tntt  ; getnum - read n (stored on the heap)
sns   ; dup
ttt   ; retr - pull n onto the stack (this will be our n->1 counter, b)
nssn  ; label 'loop'
snt   ; swap - bring a to the top
ssstn ; push 1
tsss  ; add - increment a
sns   ; dup
tnst  ; putnum - output a as a number
snt   ; swap - bring b to the top
sns   ; dup
tnst  ; putnum - output b as a number
ssstn ; push 1
tsst  ; sub - decrement b
sns   ; dup
ntstn ; jez 'exit' if b is 0
nsnn  ; jmp 'loop'

স্ট্যাকটি সঠিকভাবে সেট আপ করার জন্য প্রথম দু'পক্ষের নির্দেশাবলীর প্রয়োজন, হোয়াইটস্পেসের ইনপুট কমান্ডগুলি হিপটিতে লিখুন যাতে আমাদের বি (ইনপুট মান )টিকে স্ট্যাকের পিছনে অনুলিপি করতে হবে। আমরা একটি = 0 দিয়ে শুরু করি যেহেতু এটি 1 এর পরিবর্তে 0 ঘোষণা করা সংক্ষিপ্ত হয় (একটি বাইট সাশ্রয় করে) এবং কেবলমাত্র আমাদের মোকাবেলা করার জন্য বর্ধিত নির্দেশ পুনরায় অর্ডার করতে হবে। এর পরে আমরা কেবল লুপ করব এবং একটি বৃদ্ধি করব, আউটপুট এ, আউটপুট বি, হ্রাস খ, যতক্ষণ না খ 0 পৌঁছায় (হ্রাসের পরে পরীক্ষিত)।

Comments

আপনি যদি সেই সমস্ত পেছনের সাদা জায়গাটি সরিয়ে ফেলেন তবে এটি আরও গল্ফ হতে পারে: পি

— বিড়াল

Answer 10

হাস্কেল, 65 48 47 বাইট

লাইকোনিতে 1 বাইট সংরক্ষণ করা হয়েছে:

f n=show=<<(\(l,r)->[l,r])=<<zip[1..][n,n-1..1]

---

নিমিকে ধন্যবাদ 6 বাইট সংরক্ষণ করা হয়েছে:

f n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1]

---

পূর্ববর্তী উত্তর এবং ব্যাখ্যা:

f n=concatMap show$concatMap(\(l,r)->[l,r])(zip[1..n][n,n-1..1])

এখানে ইতিমধ্যে একটি আরও ভাল উত্তর উত্তর রয়েছে, তবে আমি হাস্কেল এবং কোড গল্ফিং উভয়ের মধ্যেই নতুন, তাই আমি এটি পোস্টও করতে পারি :)

এই ফাংশনটি তালিকার [1..n] সাথে তার বিপরীতগুলি জিপ করে, ফলস্বরূপ একটি তালিকার তালিকা তৈরি করে।

[(1,n),(2,n-1),(3,n-2)..(n,1)]

তারপরে এটি concatMapটিপলগুলির এই তালিকায় একটি ল্যাম্বডাকে মানচিত্রের জন্য ব্যবহার করে যা ফলাফলগুলির তালিকাগুলির তালিকায় ...

[[1,n],[2,n-1],[3,n-2]..[n,1]]

... এবং এটি সংবিধান।

[1,n,2,n-1,3,n-2..n,1]

তারপরে তালিকার একটি চূড়ান্ত concatMapমানচিত্র showএবং এটিকে একক স্ট্রিংয়ে যুক্ত করে।

f 26 "12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"

Comments

পোতা ফাংশন =<<একই (তালিকা একসংখ্যা মধ্যে) হিসাবে concatMap: f n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1]।

— নিমি

1) আপনার বর্তমান সমাধানটি কেবল 48 বাইট। 2) আপনি ড্রপ করতে পারেন nমধ্যে [1..n]: এটি অনলাইন ব্যবহার করে দেখুন!

— লাইকনি

1) ডাং অফ বাই এক ত্রুটি ... 2) ভাল কল!

— ড্যান অ্যামব্রজিও

Answer 11

পাইথ, 7 বাইট

jksC_BS

অনলাইনে চেষ্টা করুন: বিক্ষোভ

ব্যাখ্যা:

jksC_BSQ   implicit Q (=input number) at the end
      SQ   create the range [1, ..., Q]
    _B     bifurcate by inversion, this gives [[1, ..., Q], [Q, ..., 1]]
  sC       zip and flatten result
jk         join to a string

Answer 12

অক্টাভা, 29 বাইট

@(n)printf("%d",[1:n;n:-1:1])

এটি অনলাইন চেষ্টা করুন!

Comments

My implementation was so, so much longer! Nice! =)

— Stewie Griffin

Answer 13

Perl 6, 20 bytes

{[~] 1..*Z~($_...1)}

Test it

With an input of 100000 this takes roughly 10 seconds, including compilation and printing the output.

Expanded:

{                # bare block lambda with implicit parameter ｢$_｣

  [~]            # reduce using concatenation operator ｢&infix:«~»｣
                 # (shorter than ｢join '',｣)

    1 .. *       # Range from 1 to infinity

    Z~           # zip using concatenation operator

    ( $_ ... 1 ) # deduced sequence starting at the input
                 # going down to 1
}

The Z~ needs the ~ because otherwise it generates a list of lists which will stringify with spaces.

There is no need to limit the Range starting at 1, because Z stops when any of the input lists run out.
This saves two bytes (a space would be needed after $_)

Answer 14

Java 61 bytes

(int n)->{for(int i=0;i<n;System.out.print(i+1+""+(n-i++)));}

Comments

Also, welcome to PPCG! :)

— Stewie Griffin

We allow anonymous functions, so (int n)->{//for loop} should work here.

— Nathan Merrill

Is that better?

— cheemcheem

Yep! You can potentially put your System.out.print() in the last statement of the for loop, but it gets complicated because you are using i twice (and you need to increment it in the expression).

— Nathan Merrill

I put the print inside the loop and incremented i at the last possible place then checked it with the Test cases to make sure it worked, thanks @NathanMerrill

— cheemcheem

Answer 15

Jelly, 5 bytes

RṚĖVV

Try it online!

How it works

RṚĖVV  Main link. Argument: n

R      Range; yield [1, ..., n].
 Ṛ     Reverse; yield [n, ..., 1].
  Ė    Enumerate; yield [[1, n], ..., [n, 1]].
   V   Eval; convert each flat array to a string, interpret it as a Jelly program,
       and yield the output. This concatenates the integers in each pair, yielding
       a flat array of integers
    V  Repeat the previous step, concatenating the intgegers from before.

Answer 16

Röda, 21 19 bytes

{seq 1,_<>seq _1,1}

Try it online!

This is an anonymous function that takes input from the stream.

Explanation

{seq 1,_<>seq _1,1}               Anonymous function, takes integer n from the stream
        <>                        Interleave
 seq 1,_                            the range 1 .. n with
          seq _1,1                  the range n .. 1

Answer 17

Clojure, 61 bytes

#(let[a(range 1(+ 1 %))](apply str(interleave a(reverse a))))

Literally does what is asked. I believe it can be outgolfed by a less trivial solution.

See it online

Answer 18

Aceto, 25 22 bytes

)&
pX`=
(pl0
id@z
r}Z)

Explanation:

We read an integer and put it on two stacks.

id
r}

On one, we call range_up (Z), on the other range_down (z), then we set a catch mark to be able to return to this place later:

  @z
  Z)

We then check if the current stack is empty and exit if so:

 X`=
  l0

Otherwise, we print from both stacks and jump back to the catch mark:

)&
p
(p

Answer 19

R, 41 bytes

pryr::f(for(i in 1:x){cat(i);cat(x-i+1)})

pryr::f() creates a function that takes one input. Loops over 1:x and prints each element of 1:x along with each element of x:1. Prints to STDOUT.

Comments

+1, nice use of pryr

— shadowtalker

@ssdecontrol its pretty much staple replacement of function(x) :)

— JAD

Answer 20

Brachylog, 10 9 bytes

⟦₁g↔ᶻczcc

Try it online!

Explanation

⟦₁           [1, …, Input]
  g↔ᶻc       [[1, …, Input],[Input, …, 1]]
      z      Zip
       cc    Concatenate twice

Answer 21

MATL, 13 11 9 bytes

2 bytes saved thanks to @Luis

:tPv1eVXz

Try it at MATL Online

Explanation

        % Implicitly grab input as a number, N
:       % Create an array from 1..N
tP      % Create a reversed copy
v       % Vertically concatenate the two
1e      % Reshape it into a row vector
V       % Convert to a string
Xz      % Remove whitespace and implicitly display

Comments

@LuisMendo Ah! I thought there was a function that removed whitespace but couldn't find it. Thanks!

— Suever

Answer 22

PHP, 36 35 29 bytes

for(;$argn;)echo++$i,$argn--;

Saved one byte thanks to Jörg Hülsermann.
Saved six bytes thanks to Christoph.

Comments

Uhm... for(;$argn;)echo++$i,$argn--; ?

— Christoph

Answer 23

Scala, 43 bytes

It's not the best but it's my first code golf.

n=>1.to(n).foldLeft("")((s,x)=>s+x+(n-x+1))

Answer 24

V, 20 bytes

ywo1@"­ñykPjñkògJ

Try it online!

Explain:

yw                    ' Copy the input number (for looping later)
  o1                 ' Insert a 1 under the input (on a newline)
     @"               ' [Copy register] number of times
       ­ñ      ñ       ' Do the thing inside of this loop
        ykP           ' Copy the current line and line above it, and paste above both
           j        ' decrement the current (top) number, and increment the one below
               k      ' Go to the top line
                ògJ   ' recursively join all of the lines

Answer 25

Cubix, 17 bytes

....1I>sO)su.@?(O

Try it online!

cubified:

    . .
    . .
1 I > s O ) s u
. @ ? ( O . . .
    . .
    . .

Pushes 1, reads in the input (I), then enters the loop which swaps the top of the stack, outputs it, increments, swaps, outputs the top of the stack, decrements, and stops if the top of the stack is 0.

Answer 26

K (ngn/k), 16 bytes

{,//$r,'|r:1+!x}

Try it online!

Comments

r,'|r: -> +|:\

— ngn

Answer 27

MathGolf, 5 bytes

{îkï-

Try it online!

Explanation:

{      Run a for loop over implicit input
 î     Push 1 based index of loop
  k    Push inputted number
   ï-  Subtract 0 based index of loop
       Implicitly output all this joined together

Comments

I've been able to find 13 programs of length 5 which yield the same result: ╒{ïí,, ╒{ïk,, ╒{íï-, ╒{kï-, ╒{┐í,, ╒{┐k,, ╒x{î\ , {îïí,, {îïk,, {îíï-, {îkï-, {î┐í,, {î┐k,. However, I have not been able to find any program of length 4 or less. I haven't done a full search, but it is very probable that 5 bytes is optimal for MathGolf.

— maxb

Answer 28

Common Lisp, 63 54 bytes

(lambda(n)(dotimes(i n)(format t"~a~a"(1+ i)(- n i))))

Try it online!

Answer 29

Mouse-2002, 32 30 bytes

-2 moved conditional to start of loop (z.^ ... ) instead of (... z.0>^)

?n:n.z:(z.^a.1+a:a.!z.!z.1-z:)

Try it online!

Explanation:

?n:                                 ~ get input and store in n
   n.z:                             ~ copy n into z
       (z.^                         ~ stop if z equals 0
           a.1+a:                   ~ add 1 to a
                 a.!                ~ print a
                    z.!             ~ print z
                       z.1-z:)      ~ substract 1 from z

Answer 30

Actually, 9 bytes

R;R@Z♂iεj

Try it online!, or run all test cases

Explanation:

R;R@Z♂iεj
R          range(1, n+1)
 ;R        duplicate and reverse
   @Z      swap and zip
     ♂i    make 1D
       εj  join with empty string