Input number; Output line number

Question

Code Golf

Totally real backstory: I'm a contractor working on a website www.Sky.Net and one of our tasks it to create some self-aware program or something, I don't know I wasn't really listening to the boss. Anyways in an effort to make our code more self-aware we need IT to be able to know what code is on each line-number.

---

Challenge

Create a program or function that takes an input n and returns the code of said program or function on line n.

---

Rules

➊ Your program or function must be at least 4 lines long. Each line must be unique.

➋ You may assume the input will always be a positive integer greater than or equal to 1 and less than or equal to the number of lines in your program/function.

➌ The first line in your program/function is line 1, not line 0.

➍ You can not access the file that your program is on. (If someone has to ask "Isn't this technically breaking rule #4"; it probably is)

➎ Lines can-not be empty (this includes a space if spaces don't do anything in your language)

➏ Lines can-not be //comments (/* of any <!--style)

---

This is a quine-like challenge
This is code-golf, so the submission with the fewest bytes wins!

Answer 1

Vim, 7 bytes

1
2
3
4

Try it online!

As far as I can tell, this complies with all of the rules. In vim by default, the empty program prints out all of the input. Since

<N><CR>

Is a noop, nothing changes the input text, and since each input matches the desired output, this same approach works with any number of lines.

Answer 2

Ruby, 71 70 66 bytes

Try it online!

->n{
k=["}", "k[-n]%%k.inspect", "k=%s", "->n{"]
k[-n]%k.inspect
}

"Cheating" Mode: 7+1 = 8 bytes

Requires the -p flag for +1 byte. Literally a copy of the V answer. Prints the number that is inputted; the entire program is effectively just no-ops.

1
2
3
4

Answer 3

Haskell, 69 59 bytes

(lines(s++show
 s)
 !!)
s="\n(lines(s++show\n s)\n !!)\ns="

Based on the standard Haskell quine. The first expression (spread over the first three lines) is an unnamed function that picks the nth line from the quinified string s (s++show s). +2 bytes for making indexing 1-based (imho an unnecessary rule).

For a Try it online! version I have to name the function which adds 4 bytes.

Answer 4

PowerShell, 184 172 bytes

$v=0,
'$v=0,',
"'`$v=0',",(($q='"{0}`$v=0{0},",(($q={0}{1}{0})-f([char]39),$q)')-f([char]39),$q),
(($z='(($z={0}{1}{0})-f([char]39),$z;$v[$args]')-f([char]39),$z);$v[$args]

Try it online!

Explanation

Starts by creating an array $v on the first line. On that same line, the first (0th) element is set to 0, and a comma , continues its definition.

The next line sets the next element (1) of the array to a string representing the content of the first line of the script, so that $v[1] returns the first line.

The 3rd line first sets the 3rd element of the array (index 2) to a string representing the 2nd line of the script, then on the same line sets the 4th element (index 3) using a quine snippet that uses the format operator (-f) to replace certain instances of single quotes ([char]39) and the format template string, into itself, to reproduce the entirety of the 3rd line.

Line 4 basically does the same thing, but also ends the creation of the array and then indexes into it using the supplied argument.

Answer 5

Python 2, 104 73 67 bytes

Thanks to Jonathan Allan for saving 6 bytes!

s=\
['print s[input()]or s', 's=\\', 0, 'exec s[', '0]']
exec s[
0]

Edit: Same byte count, but I like this solution better

Try it online!

Python version of Value Ink's Ruby answer.

Older answer (67 bytes):

1
s=\
['print s[-input()]or s', 0, 's=\\', 1]
print s[-input()]or s

Answer 6

CJam, 19 18 17 bytes

1
{'_'~]ri(=}
_
~

Try it online!

Based on the standard CJam-quine. The {...}_~ runs the ... with the block itself on the stack (and in this case, also 1 below that). Then we do:

'_'~  e# Push the third and fourth line.
]     e# Wrap all four lines in a list.
ri    e# Read input and convert to integer.
(=    e# Use as index into the lines.

Answer 7

PHP, 261 bytes

<?php function f($l){
$a="aWYoJGw9PTEpJG09Ijw/cGhwIGZ1bmN0aW9uIGYoXCRsKXsiO2lmKCRsPT0yKSRtPSJcJGE9XCIkYVwiOyI7aWYoJGw9PTMpJG09IlwkYj1cIiR";
$b="iXCI7IjtpZigkbD09NCkkbT0iZXZhbChiYXNlNjRfZGVjb2RlKFwkYS5cJGIpKTt9Pz4iO2VjaG8gJG07";
eval(base64_decode($a.$b));}?>

Try it online !!

The encoded string is:

if($l==1)$m="<?php function f(\$l){";
if($l==2)$m="\$a=\"$a\";
if($l==3)$m="\$b=\"$b\";
if($l==4)$m="eval(base64_decode(\$a.\$b));}?>";
echo $m;

Answer 8

Perl, 52 bytes

$_=q{print+(split/
/,"\$_=q{$_};
eval")[<>-1]};
eval

This is a simple variation on the classic quine

$_=q{print"\$_=q{$_};eval"};eval

The "payload" is split on newlines and the correct line is selected by indexing into the resulting list.

Perl, 49 48 bytes (non-competing)

#!/usr/bin/perl -d:A
sub DB'DB{
print${"_<$0"}[<>]}
1

38 bytes for the code (excluding the shebang but including -d:A) plus 10 bytes for the filename, which must be Devel/A.pm. The Devel directory must be in @INC.

Technically, this violates Rule #4 because -d:A causes the file to be parsed twice, so it's a non-competing solution.

It uses a debugger hook to access the lines of the file, which perl stores in the @{"_<$filename"} array at compile time.