Given an integer n as input, return a list containing n, repeated n times. For example, the program would take 5 and turn it into [5,5,5,5,5]. The elements need to be integers, not strings. No built-in functions that accomplish the task are allowed.
This is code-golf, so standard rules apply.
x Note that this is not the “repeat n n times” built-in — its function is more general than that. For example 4,5,6x1,2,3 equals [4, 5, 5, 6, 6, 6]. Given only one argument, Jelly just happens to use it as both the left and right argument for the supplied link, but this functionality is not inherent to x.
If this doesn’t count, there are various fun 2-byte alternatives:
x` ṁ` Ra Rị R» a€ oR oḶ oṬ oẊ Ḷị Ḷ» Ṭị Ṭ» Ẋị Ẋ» ị€ ṛ€ ȧ€ »€ etc.
x did “all the work”, but it most certainly doesn’t — there’s an implicit “0 bytes” of link-parsing and array-coercion logic going on to turn this into repeat([n], n), which is exactly what other answers do. \$\endgroup\$ ṁ and ẋ so this answer could be any one of the three. There aren't 3 built-ins (one would hope) for "repeat n n times", so they can't ALL be a "built-in" for it. \$\endgroup\$ [n]*n? \$\endgroup\$ f={a=[];t=_this;while{count a<t}do{a=a+[t]};a} Call with:
hint format["%1", 5 call f] Output:
i--, and += in this? \$\endgroup\$ Five equally short solutions. Last two are courtesy of Zacharý.
⍴⍨ ⍴ cyclically reshape
⍨ self
/⍨ / replicate
⍨ self
\⍨ \ expand
⍨ self
⌿⍨ ⌿ replicate along first (and only) axis
⍨ self
⍀⍨ ⍀ expand along first (and only) axis
⍨ self
⌿⍨ and ⍀⍨ work. \$\endgroup\$ ⍨ by typing ``selfie. \$\endgroup\$ #~Table~#& 
~ is the not operator that converts 1:n to an array of 0s of size n. You can use ! instead of it. \$\endgroup\$ n=>Array(n).fill(n) o.innerText=(f= n=>Array(n).fill(n) )(i.value=8);oninput=_=>o.innerText=f(+i.value)<input id=i type=number><pre id=o>
*] *]QQ - Full program with implicit input ] - Turn the input into a list. * - Repeat it a number of times equal to the input.
f n=n<$[1..n] Try it online! Usage: f 5 yields [5,5,5,5,5]. For n=5, [1..n] yields the list [1,2,3,4,5]. n<$ replaces each element of this list with n.
join replicate \$\endgroup\$ join is not part of Prelude and thus requiers a lengthy import Control.Monad, which rarely makes it useful for golfing. \$\endgroup\$ 
rep(n<-scan(),n) too close to a builtin? \$\endgroup\$ 
.D). \$\endgroup\$ f f r 2 2 r r d f s t f d dip f s t f t dot f dot s s dip f dab f is an alias for dab (tail).
s is subtraction, as explained on the wiki: (x, y) → (0, y−x) when x ≤ y.
t maps (a, b, c…) to (b+c+…, a+b+c+…).
f s t maps (a, b, c…) to a. This is our “head” function.
d dips only the head of its argument: (a, b, c…) → (|a−1|, b, c…)
r is the main repetition logic. We map (a, b) to (*r(|a−1|, b), b).
For example, r(4, 7) will evaluate as
r(4, 7) = r(3, 7), 7 = r(2, 7), 7, 7 = r(1, 7), 7, 7, 7 = r(0, 7), 7, 7, 7, 7 → This would call r(1, 7), but (1, 7) ≥ (0, 7), so surrender! = 0, 7, 7, 7, 7, 7. Finally, we define 2, which maps n → (n, n), and define main as f f r 2, computing r(n, n) and chopping off the first two elements.
ÆU Implicit input of integer U. Generate an array of integers from 0 to U-1. Fill it with U. Implicit output of resulting array.
\newcommand{\f}[1]{#1\count0=2\loop,#1\advance\count0 by1\ifnum\count0<#1\repeat} \documentclass[12pt,a4paper]{article} \begin{document} \newcommand{\f}[1]{#1\count0=2\loop,#1\advance\count0 by1\ifnum\count0<#1\repeat} \f{5} \f{10} \end{document} 
´R ´ -- Apply next function twice to same argument R -- given an integer n and some element, replicate the element n-times ṠIR replicate>>=id Thanks to @nimi, I don't need any import anymore. Yay!
It's a function that takes an integer argument; for example, the following returns [5,5,5,5,5]:
(replicate>>=id) 5 
id=<<replicate? It's also 14 bytes but doesn't need the import. \$\endgroup\$ n->java.util.Arrays.stream(new int[n]).map(i->n) -2 bytes thanks to @Jakob
Inspired by the comments in @OlivierGrégoire's post, and optimized a little further. Takes an integer input, creates an IntStream of n elements, then maps each element to n and returns it.
java.util.Arrays.stream(new int[n]). \$\endgroup\$ -4 bytes thanks to @DomHastings
sub{(@_)x"@_"} Is x a builtin that does the entire task? Sort of? Not really? Rules unclear?
Edit: Yeah, probably it's fine.
$_[0] to @_! Also the second can be"@_" I think... \$\endgroup\$ $_=$_ x$_ with perl -pe? \$\endgroup\$ x does string repetition, not list repetition, unless the left operand is in parentheses (or is a qw operator) and the x is evaluated in list context. And of course $_ is a scalar, not a list. \$\endgroup\$ $~ Same as the APL answer: reflexively shape the input. In other words:
$~ y y $ y NB. y copies of y 
>-[-[-<]>>+<]>->#[->+>+<<]>>[-<;<<.>>>] Prints N N times. Works by generating 32, taking input, then duplicating the input twice, then output the first for each 1 in the second.
int*f(k){int*r=malloc(k*4),a=k;for(;a-->0;)r[a]=k;k=r;} Returns a list of k integers.
eax for locals. Go figure. \$\endgroup\$ *f(k){int r[k], instead of int*f(k){int*r=malloc(k*4), \$\endgroup\$ {[[_]*_1]} Explanation:
{[[_]*_1]} { } /* Anonymous function */ _ /* The input (_1) */ [ ] /* As a list */ *_1 /* Repeated _1 times */ [ ] /* Pushed to the stream */ 
[_]*_ = [_1]*_2. Because the first underscore is the first, it has automatically the number 1. \$\endgroup\$ 
[->+>+<<]>[->.<] [->+>+<<] Duplicate 'n' into the next 2 cells to the right > Move to the first duplicate [->.<] Print 'n', 'n' times As I'm sure you're aware, brainfuck takes input and output values as ASCII characters. So a ! is represented as the value 33.
yes $1|sed $1q As a zsh function, 20 19 bytes:
f(){yes $1|sed $1q} 
yes $1|sed $1q? \$\endgroup\$ declare -i integer variables. But it also has to be an array. I'm not sure bash even supports an integer array (like eval declare -ia "$1" to use the first function arg as the name of an array return value.) I upvoted this because it follows the spirit of the question; I doubt the question meant to exclude languages that don't really have integer lists / arrays. \$\endgroup\$ ->n{[n]*n} Sample run:
irb(main):001:0> ->n{[n]*n}[5] => [5, 5, 5, 5, 5] ->n{Array.new n,n} Sample run:
irb(main):001:0> ->n{Array.new n,n}[5] => [5, 5, 5, 5, 5] 
tY" Explanation:
t % duplicate elements Y" % replicate elements of array % (implicit) convert to string and display 
n->{int a[]=new int[n],i=n;for(;i-->0;)a[i]=n;return a;} -2 bytes thanks to @KevinCruijssen
n->{int a[]=new int[n],i=n;for(;i-->0;)a[i]=n;return a;} \$\endgroup\$ IntStream.generate(() -> n).limit(n) but decided it wasn't worth typing up and upvoted this instead :) \$\endgroup\$ ::n :: Mode: sequence 2. Given input n, output the sequence n times n Each item in the sequence is n 
& instead of :: \$\endgroup\$
built-in. \$\endgroup\$*operator ok? What's an example of a built-in that isn't ok? \$\endgroup\$