31

ইতিবাচক পূর্ণসংখ্যার এবং দুটি স্বতন্ত্র বৈধ সূচকগুলির একটি অ্যারে দেওয়া, দুটি সূচকগুলিকে অদলবদল করে দুটি উপাদানগুলির সাথে অ্যারেটি ফেরত দিন।

আপনি 0-ইনডেক্সিং বা 1-ইনডেক্সিং ব্যবহার করতে বেছে নিতে পারেন তবে নীচের পরীক্ষাগুলি 0-সূচকযুক্ত হবে।

array        m n output
[1,2,3,4]    0 1 [2,1,3,4]
[5,8,9]      0 2 [9,8,5]
[11,13,15,3] 1 2 [11,15,13,3]
[11,13,15,3] 2 1 [11,15,13,3]
[11,15,15,3] 2 1 [11,15,15,3]

এটি কোড-গল্ফ । বাইট জিতে সংক্ষিপ্ত উত্তর। স্ট্যান্ডার্ড লুফোলস প্রযোজ্য।

code-golf array-manipulation

— ফুটো নুন
সূত্র

সম্পর্কিত , সম্পর্কিত ।

— লিকি নুন

1

হুঁ, এটি একটি কাজ হতে পারে যা অনেক গল্ফ ভাষাগুলির সাথে খুব কঠিন সময় হয় তবে বেশিরভাগ ব্যবহারিক ভাষা সহজ বলে মনে করে। (পরিবর্তনীয় উপাদানগুলির সাথে তালিকাগুলি ভাষা গল্ফ করার পক্ষে সাধারণ জিনিস নয়)) যদি এটি হয় তবে এটি বেশ আকর্ষণীয় হবে। (গল্ফিং ভাষাগুলি সম্ভবত এখনও জিতবে, যদিও এগুলি এত বেশি পরিশ্রমী তারা আরও জটিল অ্যালগরিদম দিয়ে

7

আশ্চর্যরূপে এটি সম্ভবত কোনও দ্বিপশু নয়, তবে এই চ্যালেঞ্জটি আসলে সৃজনশীল, কারণ এটি অনেকগুলি গল্ফ ভাষার পক্ষে বাস্তব চ্যালেঞ্জ।

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

@ ল্যাকইনুন আমি অতীতে যেমন ডাউনটা পেয়েছি (এবং ভোটগুলি মুছে ফেলেছি), সে সম্পর্কে খুব বেশি চিন্তা করবেন না ...

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

mএবং nঅ্যারে হিসাবে নেওয়া যেতে পারে?

— Okx

17

সি/ সি ++, 53 50 39 বাইট

f(a,m,n)int*a;{a[m]^=a[n]^=a[m]^=a[n];}

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

@ ডেনিসকে 11 বাইট সংরক্ষণ করা হয়েছে

— Ra8
সূত্র

10

অপারেশন ফ্ল্যাশপয়েন্ট স্ক্রিপ্টিং ভাষা, 98 95 বাইট

f={t=_this;a=t select 0;b=+a;m=t select 1;n=t select 2;a set[m,b select n];a set[n,b select m]}

সরাসরি অ্যারে পরিবর্তন করে।

ব্যাখ্যা:

t=_this;                   // Give a shorter name for the array of arguments.

a=t select 0;              // Let 'a' be a pointer to the array that we modify.
                           // (The language doesn't have a concept of pointers really,
                           // yet its array variables are pointers to the actual array.)

b=+a;                      // Make a copy of the original array and save a pointer to it
                           // in the variable 'b'. This saves a few bytes later.

m=t select 1;              // Read the index arguments from the input array and save them
n=t select 2;              // to their respective variables.

a set[m,b select n];       // Do the swapping by reading the values from the copy and
a set[n,b select m]        // writing them to the original array. The last semicolon can
                           // be omitted because there are no more statements following 
                           // the last statement.

সাথে কল করুন:

array = [1,2,3,4];
str = format["%1", array];
[array, 0, 1] call f;
hint format["%1\n%2", str, array];

আউটপুট:

— Steadybox
সূত্র

7

জাভাস্ক্রিপ্ট ES6, 36 32 বাইট

দেখো মা, কোন অস্থায়ী পরিবর্তনশীল!

(a,m,n)=>[a[m],a[n]]=[a[n],a[m]]

4 বাইট আমার পক্ষে এই sens ক্যমতটি আনার জন্য নীলকে ধন্যবাদ জানিয়েছে saved

চেষ্টা করে দেখুন

& এর aজন্য 2 পূর্ণসংখ্যার জন্য কমা দ্বারা পৃথককৃত উপাদানের তালিকা লিখুন ।mn

f=
(a,m,n)=>[a[m],a[n]]=[a[n],a[m]]
oninput=_=>o.innerText=(f(b=i.value.split`,`,+j.value,+k.value),b);o.innerText=(f(b=(i.value="5,8,9").split`,`,j.value=0,k.value=2),b)

*{font-family:sans-serif}input{margin:0 5px 0 0;width:100px;}#j,#k{width:50px;}

<label for=i>a: </label><input id=i><label for=j>m: </label><input id=j type=number><label for=k>n: </label><input id=k type=number><pre id=o>

স্নিপেট প্রসারিত করুন

— রোমশ
সূত্র

2

এই নির্দেশাবলী অ্যারে পরিবর্তন করে, যার অর্থ আপনাকে অ্যারেটি ফেরত দেওয়ার অনুমতি দেওয়া হয়নি যা আপনাকে কয়েকটি বাইট সংরক্ষণ করবে।

— নিল

@ নীল: আপনি শুধু ব্যবহার করতে বলছেন (a,m,n)=>[a[m],a[n]]=[a[n],a[m]]? এটি কেবল অ্যারে (যেমন, [5,8,9],0,2-> [9,5]) ব্যতীত 2 অদলবদলের উপাদান আউটপুট দেয় ।

— ঝাঁকুনি

@ নীল: ঠিক, তাই aআমাদের সম্পূর্ণ, পরিবর্তিত অ্যারে দেওয়ার জন্য শেষে আমাদের দরকার । বা আপনি যা বলার চেষ্টা করছেন তা কি আমি পুরোপুরি অনুপস্থিত?

— শেগি

@ নীল: হুম ... ঠিক আছে, আমি মনে করি আপনি এখন যা পাচ্ছেন তা আমি দেখছি (দুঃখিত, একই সাথে আজ অনেক কিছু করার চেষ্টা করছি)। ভকভগক. তাতে কি aক্যমত্য আছে এবং যদি তাই হয় তবে আমি নিজে এটি অনুসন্ধান করার আগে আপনার কি কোনও লিঙ্ক কার্যকর হবে?

— শেগি

1

codegolf.meta.stackexchange.com/a/4942/48934

— নিল

5

পাইথন 3 , 41 32 বাইট

-9 বাইটস @ নোটজাগানকে ধন্যবাদ

def f(a,m,n):a[m],a[n]=a[n],a[m]

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

এর যুক্তিটি সংশোধন করে, যা একটি বৈধ আউটপুট ফর্ম্যাট ।

— ovs
সূত্র

3

এটি মজার বিষয় কীভাবে এটি আইডিয়োমেটিক পাইথন কোডের সাথে তুলনা করে এতটা গল্ফও করে না।

— asukasz Rogalski

5

জেলি , 7 বাইট

Ṛ,ḷyJ}ị

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

কিভাবে এটা কাজ করে

Ṛ,ḷyJ}ị  Main link. Left argument: [i, j]. Right argument: A (array)

Ṛ        Reverse; yield [j, i].
  ḷ      Left; yield [i, j].
 ,       Pair; yield [[j, i], [i, j]].
    J}   Indices right; yield all indices of A.
   y     Transliterate; replace j with i and i with j.
      ị  Index into A.

— ডেনিস
সূত্র

tfw মোড়কটি প্রোগ্রামের মতো প্রায় দীর্ঘ ...

— লিকি নুন

আমি কখনই এর অস্তিত্ব সম্পর্কে জানতাম নাy

— লীকি নুন

আমি জানতাম y, তবে এটি এখানে ব্যবহার করার কথা ভাবি নি। এটি একটি সুন্দর চালাক উত্তর।

এই আমাকে ভাবছে ... Jellyবৈধ জেলি কোড?

— এম হার্জক্যাম্প

@ এম হার্জক্যাম্প এটি। যদিও আমি এর ব্যতিক্রমী দরকারী সন্দেহ।

— ডেনিস

4

জাপট , 17 16 বাইট

hV(A=UgV UgW¹hWA

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

ETH প্রোডাকশনগুলিতে একটি বাইট ধন্যবাদ সংরক্ষণ করা

— টম
সূত্র

2

খুশী হলাম। যদিও আপনার কমা দরকার মনে করবেন না।

— ইটিএইচ প্রডাকশনগুলি

@ ইথ প্রডাকশন ধন্যবাদ, আপনি ঠিক বলেছেন।

— টম

বিকল্প 16 বাইট বাস্তবায়ন কিন্তু আমি এখনও একটি সংক্ষিপ্ত সমাধান আছে নিশ্চিত।

— শেগি

2

15 বাইট

— ইটিএইচ প্রোডাকশনগুলি

4

এমএটিএল , 7 6 বাইট

yyP)w(

সূচকগুলি 1-ভিত্তিক।

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

ব্যাখ্যা

ইনপুট বিবেচনা করুন [11 13 15 3], [2 3]।

yy   % Take two inputs implicitly. Duplicate them
     % STACK: [11 13 15 3], [2 3], [11 13 15 3], [2 3]
P    % Flip
     % STACK: [11 13 15 3], [2 3], [11 13 15 3], [3 2]
)    % Reference indexing (pick indexed entries)
     % STACK: [11 13 15 3], [2 3], [15 13]
w    % Swap
     % STACK: [11 13 15 3], [15 13], [2 3]
(    % Assignment indexing (write values into indexed entries). Implicitly display
     % STACK: [11 15 13 3]

— Luis Mendo
সূত্র

4

C# (.NET Core), 48 43 31 bytes

(a,m,n)=>a[m]+=a[n]-(a[n]=a[m])

Try it online!

Swaps the numbers in the original array, no temporary variables used. Nonetheless I can't take credit for this answer as it has been Neil's idea.

— Charlie
সূত্র

@LeakyNun it does not seem to work, as that leaves a[m] with a value of 0. Try it yourself!

— Charlie

(a,m,n)=>a[m]+=a[n]-(a[n]=a[m]) seems to work though.

— Neil

(These answers are all also valid in ES6 JavaScript, no?)

— Neil

4

Common Lisp, 42 bytes

-2 bytes thanks to @coredump.

(lambda(a i j)(rotatef(elt a i)(elt a j)))

Try it online!

Quite straight forward, since there is a Common Lisp macro to swap: rotatef.

— Dada
সূত্র

You could use ELT instead of AREF

— coredump

1

@coredump Right, thanks!

— Dada

3

Javascript ES6, 36 34 bytes

(a,m,n)=>(x=a[m],a[m]=a[n],a[n]=x)

-2 Bytes because the function is altering the array. No need to return the array. Thanks to @Neil

Demo

Show code snippet

f=

(a,m,n)=>(x=a[m],a[m]=a[n],a[n]=x)

let a1=[1,2,3,4], a2=[5,8,9], a3=[11,13,15,3]

f(a1,0,1);
f(a2,0,2);
f(a3,1,2);

console.log(JSON.stringify(a1)); //[2,1,3,4]
console.log(JSON.stringify(a2)); //[9,8,5]
console.log(JSON.stringify(a3)); //[11,15,13,3]

Expand snippet

— Weedoze
সূত্র

1

Those instructions modify the array, which means you're allowed to not return the array, which will save you a few bytes.

— Neil

3

CJam, 4 bytes

{e\}

Try it online!

— Dennis
সূত্র

2

Java 8, 48 bytes

(a,b,c)->{int t=a[b];a[b]=a[c];a[c]=t;return a;}

Input:

int[] a
int b
int c

— Okx
সূত্র

How do you do lambdas with three arguments in Java?

— Leaky Nun

1

Those instructions modify the array, which means you're allowed to not return the array, which will save you a few bytes.

— Neil

1

@LeakyNun I'm not Okx, but here is a Try it now example with Okx's current answer and custom interface.

— Kevin Cruijssen

1

And based on Carlos Alejo's amazing C# answer (with @Neil's help), you can make it even shorter by getting rid of the temporary variable: (a,b,c)->a[b]+=a[c]-(a[c]=a[b]) (31 bytes)

— Kevin Cruijssen

1

cough cough Collections::swap is 17 bytes... at least assuming this holds for this challenge...

— Socratic Phoenix

2

05AB1E, 10 bytes

D²è³ǝ¹³è²ǝ

Try it online!

— Okx
সূত্র

2

Octave, 28 bytes

@(a,n){a(n)=a(flip(n)),a}{2}

Try it online!

Quite satisfied with this one actually :)

Takes input on the form: f([1,2,3,4],[1,2]), 1-indexed.

Explanation:

@(a,n)                         % Anonymous function that takes two 1-dimensional
                               % arrays as input
      {               , }      % Create a cell with two elements
       a(n)=a(flip(n))         % One element are the two number at indices given by
                               % the second input array. This will be a 1x2 array
      {a(n)=a(flip(n)),a}      % Place those two in a cell together with the entire array a
                               % a is now updated, thanks to Octave's inline assignment
      {a(n)=a(flip(n)),a}{2}   % Return the second element

— Stewie Griffin
সূত্র

2

Jellyfish, 7 bytes

p
ZRi
i

Takes a list and a pair of indices. Try it online!

Explanation

Jellyfish happens to have a "modify items at indices" function, Z, which does exactly what we need. The two is grab the inputs from STDIN. Z takes as arguments the second input, the reversal function R, and the list. Then Z performs the modification, and p prints the result.

— Zgarb
সূত্র

2

R, 38 bytes

function(x,a,b){x[c(a,b)]=x[c(b,a)];x}

Feels rather long, but I can't get it much shorter. Sadly it requires the explicit returning through x, requiring {} around the function body. pryr::f() doesn't recognise the need for x as function argument so doesn't work :/.

— JAD
সূত্র

I think function(x,i)replace(x,i,rev(i)) would work, even with pryr syntax.

— Giuseppe

@Giuseppe Ah, I was looking for a convenient function to do the swap, but was searching with the wrong terms. Feel free to post that as an own answer.

— JAD

@Giuseppe I think you need to do replace(x,i,x[rev(i)]), else you'll place the indices instead of their values.

— JAD

2

Shenzhen I/O, 735 Bytes

23¥, 810 Power, 48 Lines of Code

[traces] 
......................
......................
......................
......................
......................
......................
.14.14.14.............
.94.14.14.............
.A........1C..........
.3554..95556..........
.9554.16..............
.A....................
.2....................
......................

[chip] 
[type] UC6
[x] 4
[y] 2
[code] 
  slx x0
  mov x1 acc
  mov x1 dat
  mov acc x3
  mov dat x3
  mov acc x3
  mov dat x3

[chip] 
[type] UC6
[x] 8
[y] 5
[code] 
  slx x2
  mov x2 x1
  mov x0 dat
  mov x2 x1
  mov x0 acc
  mov x2 x1
  mov dat 

[chip] 
[type] UC4X
[x] 2
[y] 6
[code] 
  slx x0
  mov 0 x3
j:  mov x0 acc
  mov acc x2
  teq acc 0
- jmp j
  mov -999 x1

[chip] 
[type] RAM
[x] 5
[y] 6

DISCLAIMER: Arrays are 0-terminated in this. Arrays are a pain in the ass to work with in Shenzhen I/O otherwise.

I actually made a steam level for this game. You can play it here.

EDIT: Aaand I just realized I said that the array in was ordered. Heck.

— junkmail
সূত্র

Welcome to the site This is really cool! do you think that you might be able to remove some of the whitespace in the file and still have Shenzhen IO accept the file? I don't know how much you have fiddled with it, but you should try and see how flexible the format is.

— Wheat Wizard

I haven't played around with it! On the other hand, I am axing the header for the puzzle which contains the puzzle name and solution name, so I dunno if I should bother.

— junkmail

1

Swift, 111 65 bytes (0-indexed)

Swift is already notorious for being one of the worst code-golf languages, but here is a function ~~that makes use of ternary expressions~~:

func t(l:[Int],m:Int,n:Int){var r=l;r[m]=l[n];r[n]=l[m];print(r)}

Check it out! - Usage: t(l:[1,2,3],m:0,n:1).

— Mr. Xcoder
সূত্র

Using a default param for r would save you bytes and you can also just mutate the passed array (AFAIK swift array are pass by value)

— Downgoat

Default parameter in Swift? How can I do that?

— Mr. Xcoder

And parameters are constants in Swift @Downgoat

— Mr. Xcoder

1

k (kona), 13 bytes

{x[y]:x@|y;x}

Pretty basic, but it works. Ex:

k){x[y]:x@|y;x}[1 2 3 4; 0 1]
2 1 3 4

— Simon Major
সূত্র

1

Perl 5, 32 bytes

-3 bytes thanks to @Dom Hastings!

30 bytes of code + -pa flags.

@F[pop@p,@p]=@F[@p=<>];$_="@F"

Try it online!

Quite straight forward, using array slices.

— Dada
সূত্র

Hey hey, tinkered with this a little and managed to save 3 bytes! @F[pop@p,@p]=@F[@p=<>];$_="@F".

— Dom Hastings

@DomHastings Hmm, nice, as always! Thanks :)

— Dada

1

Mathematica, 32 bytes

(a=#;a[[{##2}]]=a[[{#3,#2}]];a)&

— alephalpha
সূত্র

3

a[[{##2}]]==a[[{#3,#2}]] should be a[[{##2}]]=a[[{#3,#2}]] (using Set, not Equals)

— JungHwan Min

1

C, 42 bytes

Modify the array in place with a temp value.

f(r,m,n){int*a=r;r=a[m];a[m]=a[n];a[n]=r;}

C, 60 58 bytes

A little more interesting, not using any temp value...

f(a,m,n)int*a;{a[m]+=a[n];a[n]-=a[m];a[n]*=-1;a[m]-=a[n];}

C, 49 bytes

Using XOR

f(a,m,n)int*a;{a[m]^=a[n];a[n]^=a[m];a[m]^=a[n];}

— cleblanc
সূত্র

Heh, I was just about to post f(x,i,j,t)int*x;{t=x[i];x[i]=x[j];x[j]=t;}.

— Dennis

@Dennis you saved me two bytes on the other solution, thanks!

— cleblanc

Wouldn't the second solution be shorter (and safer) with ^?

— Dennis

-1 for the XOR version using a define instead of a function #define X(x,y,z)x[y]^=x[z],x[z]^=x[y],x[y]^=x[z]

— Giacomo Garabello

f(r,m,n){int*a=r;r=a[m];a[m]=a[n];a[n]=r;} is broken: SIGSEGV.

— Bodo Thiesen

1

Pyth, 17 8 bytes

Saved 9 bytes thanks to Leaky Num.

@LQ.rUQE

Test it online!

This is 0-indexed, and the indices are provided as a tuple: (n, m).

Explanations

@LQ.rUQE

     UQ     # Generate [0, 1, 2, ..., len(input)]
       E    # Get the indices as the tuple (1, 2)
   .r       # Translate each element of UQ to its cyclic successor in E
            # Now the indices are permuted (e.g. [0, 2, 1, ..., len(input)]
@LQ         # For each index, get it's value. Implicit print

— Jim
সূত্র

8 bytes: @LQ.rUQE

— Leaky Nun

@LeakyNun It's so different I think you can post it for yourself!

— Jim

I'm the OP; I don't post on my own challenge.

— Leaky Nun

1

Mathematica, 20 bytes

#~Permute~Cycles@#2&

Pure function taking two arguments in the following 1-indexed (and possibly abusive) format: the second test case [5,8,9]; 0 2; [9,8,5] would be called as

#~Permute~Cycles@#2& [ {5,8,9} , {{1,3}} ]

(spaces are extraneous and just for visible parsing). Permute is the builtin function that applies a permutation to a list, and Cycles[{{a,b}}] represents the permutation that exchanges the ath and bth elements of a list and ignores the rest.

— Greg Martin
সূত্র

What do the ~ do?

— Cyoce

~ is Mathematica's infix notation for a binary function: x~f~y means the same thing as f[x,y].

— Greg Martin

1

x86 Machine Code, 10 bytes

8B 04 8B 87 04 93 89 04 8B C3

This is a function written in 32-bit x86 machine code that swaps the values at the specified indices in a given array. The array is modified in-place, and the function does not return a value.

A custom calling convention is used, requiring the function's parameters to be passed in registers:

The address of the array (pointer to its first element) is passed in the EBX register.
The zero-based index of element A is passed in the ECX register.
_{(Assumed to be a valid index.)}
The zero-based index of element B is passed in the EDX register.
_{(Assumed to be a valid index.)}

This keeps the size down and complies with all formal requirements, but does mean that the function cannot be easily called from other languages like C. You'd need to call it from another assembly-language program. (You could rewrite it to use any input registers, though, without affecting the byte count; there's nothing magical about the ones I chose.)

Ungolfed:

8B 04 8B     mov  eax, DWORD PTR [ebx+ecx*4]   ; get value of element A
87 04 93     xchg eax, DWORD PTR [ebx+edx*4]   ; swap element A and element B
89 04 8B     mov  DWORD PTR [ebx+ecx*4], eax   ; store new value for element A
C3           ret                               ; return, with array modified in-place

— Cody Gray
সূত্র

1

R, 34 bytes

pryr::f(`[<-`(a,c(m,n),a[c(n,m)]))

— Sven Hohenstein
সূত্র

1

Java 8 + InverseY, 27 bytes

java.util.Collections::swap

Just calls the swap function... this is a method reference of the type Consumer3<List, Integer, Integer>.

Try it online! (header and footer for boilerplate & copy of Consumer3 interface)

— Socratic Phoenix
সূত্র

You don't need to add " + InverseY". It's valid in vanilla Java 8.

— Olivier Grégoire

1

JavaScript (ES2015), 66 57 49 bytes

A different (alas, longer) approach than previous JavaScript answers

(s,h,o,w=s.splice.bind(s))=>w(h,1,...w(o,1,s[h]))

Source

const swap = (arr, a, b, splice) => {
  splice(a, 1, ...splice(arr[b], 1, arr[a]))
}

— sshow
সূত্র

1

(s,h,o,w=s.splice.bind(s))=>w(h,1,...w(o,1,s[h])) 49 bytes

— Patrick Roberts

Forgot about them default args. Thanks!

— sshow

0

awk, 31 bytes

{c=$a;$a=$b;$b=c;a=$1;b=$2}NR>1

Try it online!

Takes input in the format

1 2
1 2 3 4

and outputs as

2 1 3 4

(1-indexed).

Explanation

The entire program is a missing pattern with an action followed by a pattern with a missing action.

Since a missing pattern runs on each line, the code inside the braces runs for both input lines. The c=$a;$a=$b;$b=c; part swaps the two values at indices a and b (through the temporary variable c). This only has an effect on the second line, since on the first line a and b are not yet defined. The a=$1;b=$2 part defines a to be the first field and b to be the second field, which sets the appropriate values for the first part to run on the second line.

Since a missing action is equivalent to {print}, the pattern prints every line it matches. This pattern in particular is NR>1: that is, print whenever the line number is greater than 1, which happens to be line 2. This runs after the swapping of values has taken place, thus completing the task.

— Doorknob
সূত্র

0

q/kdb+, 17 bytes

Solution:

{@[x;(|)y;:;x y]}

Example:

q){@[x;(|)y;:;x y]}[1 2 3 4;0 1]
2 1 3 4

Explanation:

A q version of the k answer by Simon. Apply the assign : function to x at indices reverse-y with value of x indexed at y. Broken down you can see more clearly:

q)x:1 2 3 4
q)y:0 1
q)x y
1 2
q)(|)y
1 0
q)x(|)y
2 1
q)@[x;(|)y;:;x y]
2 1 3 4

— streetster
সূত্র

প্রদত্ত দুটি সূচক অদলবদল করুন

সি/ সি ++, 53 50 39 বাইট

অপারেশন ফ্ল্যাশপয়েন্ট স্ক্রিপ্টিং ভাষা, 98 95 বাইট

জাভাস্ক্রিপ্ট ES6, 36 32 বাইট

চেষ্টা করে দেখুন

পাইথন 3 , 41 32 বাইট

জেলি , 7 বাইট

কিভাবে এটা কাজ করে

জাপট , 17 16 বাইট

এমএটিএল , 7 6 বাইট

ব্যাখ্যা

C# (.NET Core), 48 43 31 bytes

Common Lisp, 42 bytes

Javascript ES6, 36 34 bytes

Demo

CJam, 4 bytes

Java 8, 48 bytes

05AB1E, 10 bytes

Octave, 28 bytes

Jellyfish, 7 bytes

Explanation

R, 38 bytes

Shenzhen I/O, 735 Bytes

Swift, 111 65 bytes (0-indexed)

k (kona), 13 bytes

Perl 5, 32 bytes

Mathematica, 32 bytes

C, 42 bytes

C, 60 58 bytes

C, 49 bytes

Pyth, 17 8 bytes

Mathematica, 20 bytes

x86 Machine Code, 10 bytes

R, 34 bytes

Java 8 + InverseY, 27 bytes

JavaScript (ES2015), 66 57 49 bytes

awk, 31 bytes

Explanation

q/kdb+, 17 bytes