text:
Horizontally Aligned ASCII Art
Your task is to accept as input two "ASCII Art"s, and align each piece of art next to each other horizontally.
For example, say you have two strings, "abc\ndef" and "123\n456". You need to align them horizontally to produce the string "abc123\ndef456". I'm calling this "aligning horizontally" because while the inputs, when printed, look like this:
abc
def

and:
123
456

The output, when printed, will look like this:
abc123
def456

Note how one input is placed next to the other.

Input

Input will be strings, and can be as two separate arguments, or as a sequence of strings.

The characters in the arts will have decimal codes in the range 32-126 (inclusive).

It's fine to support an arbitrary number of arts to align instead of just two (but obviously you must support at least two).

You can assume that each art will have the same dimensions, and that they will contain at least one line.

You must be able to support at least 100x100 character arts.

To align with conventions on the site, the argument order does not matter. It does not matter which art is on the left or right.

Output

Output will be the aligned arts as mentioned above, either returned or output to the stdout.

Any trailing whitespace in optional.

There must be no visual separator between the aligned arts.

Input and output arts must be \n or \r delimited strings. It would be overly trivial to allow 2D-arrays.
Submissions may be functions or full programs.
Test Cases:
"abc\ndef", "123\n456" -> "abc123\ndef456".

"qwertyuiop\n asdfghjkl", "Some other\nTextFiller" -> "qwertyuiopSome other\n asdfghjklTextFiller"

"  *  \n *** \n*****\n *** \n  *  \n", "  +  \n  +  \n+++++\n  +  \n  +  \n" -> "  *    +  \n ***   +  \n*****+++++\n ***   +  \n  *    +  \n"

Can we use a custom delimiter instead of newlines? i.e. "|" or " "?

I'm gonna say no given that would kind of ruin any art.

May we use \r instead of \n?

@Adám Sure. I'll update the wording.

Is leading whitespace ok?

@Adám What do you mean? The arts may contain leading whitespace. They could be all whitespace in theory.

@Carcigenicate I mean that my output has an additional column of whitespace on the far left.

@Adám I think I'll say no since that would be changing the art beyond what the challenge requires.

Can we output an array of lines?

@Shaggy No. I decided originally to limit the input/output to newline delimited strings so there's actually a challenge here to do. I think the challenge is already easy enough.

So we can't take input as an array of 2 newline-delimited strings either, then? e.g., ["abc\ndef","123\n456"]

@Shaggy Oh, yes, I worded that comment poorly. Ya, the input can be a sequence of arts as listed in the specification. The arts themselves must be single strings though.

For the last testcase should there not be a trailing newline?

@Cowsquack Yes, fixed. I also added an Output note though that trailing whitespace is optional, since that seems to be pretty common for ascii art challenges.

For sed, is it okay to have the inputs separated by an unprintable like a null byte?

@Cowsquack As long as nothing shows when printed, sure. I added "visual" to the output specification, then moved that part to the output section. I'm not sure why it was under Input originally.

I meant taking the input as asd\ndef<null byte>123\n456 since otherwise there is not way I know of to distinguish between the inputs in sed

@Cowsquack Oh, sure. That sounds reasonable.

Canvas, 1 byte
×

Try it here!

Cause who doesn't just have a builtin for this? :P

That's not even fair. ;-;

The lines of the output are swapped? "abc\def" and "123\n456" should output "abc123\ndef456", but it's currently outputting "123abc\n456def" instead.

@KevinCruijssen On PPCG it's usually allowed to take inputs in whatever order you want, and for a stack-based language the current order makes more sense than reverse.

@KevinCruijssen although I just remembered that I have a built-in for reverse add, so I'm updating the post :p

@dzaima After I made my comment I indeed thought to myself it's probably allowed, since I take input in reversed order as well sometimes if it helps. And you're indeed right about the stack-based language part. Rofl at the build-in for reversed input and add at the same time, +1 from me! :D

So Canvas has two builtins for this? Ok, why not?

Haskell, 37 bytes
(unlines.).(.lines).zipWith(++).lines

Try it online!
IO as lists of lines would just be zipWith(++). :P

Python 2, 59 bytes
lambda y:'\n'.join(map(str.__add__,*map(str.splitlines,y)))

Try it online!

It can also be shortened by removing the space. :P

If you want to input and output lists of lines, as you had before, you can get it down to 30: Try it online!

I sat there for like 5 minutes trying to decide if I should allow that. As the Haskell answer shows, it would reduce the challenge down to something much more trivial. I suppose though that the overly trivial solutions just wouldn't be as popular.

05AB1E, 6 bytes
|¶¡øJ»

Try it online!
Explanation
|        # push all input into a list
 ¶¡      # split on newlines
   ø     # zip
    J    # join the rows to single strings
     »   # merge on newlines

Too bad a space between the two inputs wasn't allowed :(.

Jelly, 4 bytes
Ỵ€ZY

Try it online!

Perl 5 -0F, 28 bytes
Includes +2 for the \n argument to -F (it's "code" so it should count)
Give inputs directly after each other on STDIN.
#!/usr/bin/perl -0F\n
say@F[$%++,$_]for@F/2..$#F

Try it online!

Perl 6, 27 bytes
{join "\n",[Z~] $_>>.lines}

Try it online!
Works with arbitrary number of arts. IO as list of lists would be just &[Z~].

Bash + coreutils, 14

4 bytes saved thanks to @DavidFoerster.

paste -d "" $@

Input is given as two filenames as command-line parameters.
Try it online.

You can save 4 bytes: paste -d "" $@

@DavidFoerster Thanks! Weird - I tried that earlier and it didn't work. Edit - I see now - instead of -d "", I tried -d"", which of course is no different to -d

Java 8, 100 84 78 bytes
a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);}

Exits with an ArrayIndexOutOfBoundsException to STDERR after it has printed the result to STDOUT, which is allowed.
-6 bytes thanks to @OlivierGrégoire.
Explanation:
Try it online.
a->b->{                        // Method with two String parameters and no return-type
  for(int i=0;;)               //  Loop over the substrings of the first input
    System.out.println(        //   Print:
     a.split("\n")[i]          //    The substring of the first input
     +b.split("\n")[i++]);}    //    plus the same-indexed substring of the second input

a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);} 78 bytes. Nothing is said about not having any extra side-effect. So we could simply count until an exception occurs.

@OlivierGrégoire Thanks! And exiting with an error to STDERR is indeed allowed after it has printed everything to STDOUT.

APL (Dyalog Unicode), 9 bytesSBCS
Full program. Prompts (STDIN) for any length list of \r-delimited strings. The strings may be ragged and of different widths as long as they have the same number of lines. Prints (STDOUT) resulting ASCII art.
⊃,/⎕FMT¨⎕

Try it online!
⎕ prompt for evaluated input
⎕FMT¨ format (evaluate all control characters and return character matrix) each
,/ combine them horizontally (catenation reduction)
⊃ disclose (because the reduction reduced the rank from 1 to 0)

Ruby, 48 bytes
->a,b{$;=$/;a.split.zip(b.split).map(&:join)*$/}

Try it online!
A lambda taking two strings and returning a string. Setting the default split delimiter to newline with $;=$/; doesn't save any bytes, but it makes the rest look a little nicer.
Ruby, 49 bytes (arbitrarily many strings)
->s{s.map{|a|a.split$/}.transpose.map(&:join)*$/}

Try it online!
Just for fun. It turns out we can accept an array of strings at an additional cost of only 1 byte.

JavaScript (ES6), 51 bytes

f=
(a,b)=>a.replace(/.+/g,a=>a+b.shift(),b=b.split`
`)
;document.write("<pre>"+f("abc\ndef", "123\n456")+"</pre>")

Wonder, 21 bytes
->#oN.zip#++.-> <>"
"

Usage example:
(->#oN.zip#++.-> <>"
")["abc#ndef" "abc#ndef"]

#n is used instead of \n to denote newlines.
Explanation
Verbose version:
(map #oN) . (zip #con) . (map split "#n")

Split each string in the input array along newlines, zip with string concatenate, and output each item.

Kotlin, 73 bytes
a,b->a.split("\n").mapIndexed{i,s->s+b.split("\n")[i]}.joinToString("\n")

Try it online!

Vyxal j, 4 bytes
↵∩vṅ

Try it Online!

K (ngn/k), 15 14 bytes
"\n"/,'/"\n"\'

Try it online!
-1 byte thanks to ngn

,/'+ -> ,'/

APL (Dyalog Unicode), 22 bytes (Adám's SBCS)
{⊃,/↑¨⍵}'[^\n]+'⎕S'&'¨

Try it online!

Add++, 24 bytes
L,c10CdVAptA$pG$tBcB@£+n

Try it online!

C, 96 bytes
#define L(s)for(;*s++>10;)putchar(s[-1]);
i;f(s,t)char*s,*t;{for(;i=!!s[-i];puts("")){L(s)L(t)}}

Try it online!

PowerShell, 51 49 bytes
param($a,$b)$a-split"
"|%{$_+($b-split"
")[$i++]}

Try it online!
Takes input as literal strings with newlines. You could also use `n (the newline delimiter in PowerShell, not \n) instead.
We first -split the left input string on newlines, which creates an array, and loop through that |%{...}. Each iteration, we string concatenate with the right input string again split on newlines, indexed and incremented.
Those are left on the pipeline and the implicit Write-Output at completion gives us output as an array of strings, which are printed with newlines between.

JavaScript (ES6), 52 bytes
Takes input in currying syntax (a)(b).
a=>b=>a.split`
`.map((s,i)=>s+b.split`
`[i]).join`
`

Try it online!

Japt -R, 8 7 5 bytes
·í+V·

Try it
·í+V·     :Implcict input of strings U & V
·         :Split U on newlines
 í        :Interleave with
   V·     :  V split on newlines
  +       :  Reduce by concatenation
          :Implicit output, joined by newlines

Red, 78 bytes
func[a b][b: split b"^/"foreach c split a"^/"[prin c print first b b: next b]]

Try it online!

Bash, 92 bytes
a=();for b;do c=;while IFS= read -r d;do a[c++]+=$d;done<<<"$b";done;printf '%s\n' "${a[@]}"

Try it online!
Ungolfed:
array=()                             # Initialize the array
for argument in "${@}"; do           # Loop over the arguments list
  index='0'                          # Reset the index
  while IFS='' read -r 'line'; do    # Loop over every line of the current argument
    array[index]+="${line}"          # Append the line to its corresponding place
    (( index++ ))                    # Increment the index
  done <<< "${argument}"             # End while loop
done                                 # End for loop
printf '%s\n' "${array[@]}"          # Print array's content

Examples:
$ foo $'abc\ndef' $'123\n456'
abc123
def456

$ foo $'qwertyuiop\n asdfghjkl' $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller

$ foo \
>   $'  *  \n *** \n*****\n *** \n  *  \n' \
>   $'  +  \n  +  \n+++++\n  +  \n  +  \n'
  *    +
 ***   +
*****+++++
 ***   +
  *    +

# https://gist.github.com/nxnev/dad0576be7eb2996b860c320c01d0ec5
$ foo "$(< input1)" "$(< input2)" "$(< input3)" > output

I also have a shorter one but it fails if the second read statement returns a non-zero value.
Bash, 55 bytes
while IFS= read -r a;IFS= read b<&3;do echo "$a$b";done

Note: <&3 doesn't seem to work on tio.run
This one uses file descriptors (1 and 3) instead of arguments:
$ foo <<< $'qwertyuiop\n asdfghjkl' 3<<< $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller

Charcoal, 8 bytes
ＰθＭ⌕θ¶→η

Try it online! Link is to verbose version of code. Explanation:
 θ          First input
Ｐ           Print without moving the cursor
    θ       First input
     ¶      Literal newline
   ⌕        Find index
  Ｍ   →     Move that many squares right
       η    Implicitly print second input

Add 2 bytes to accept multiple inputs:
ＦＡ«ＰιＭ⌕ι¶→

Try it online! Link is to verbose version of code. Explanation:
 Ａ          Input
Ｆ «         Loop over all entries
   Ｐι       Print current entry
     Ｍ⌕ι¶→  Move to next entry

Add 4 bytes to accept unpadded input:
ＰθＭ⌈Ｅ⪪θ¶Ｌι→η

Try it online! Link is to verbose version of code. Explanation:
      θ         First input
       ¶        Literal newline
     ⪪          Split
    Ｅ           Map over each string
         ι      Current string
        Ｌ       Length
   ⌈            Maximum
  Ｍ       →     Move that many squares right

JavaScript (Node.js), 79 bytes
a=>(b=a.map(x=>x.split`
`))[i=0].map(y=>b.map(z=>c+=z[i],c="")&&++i&&c).join`
`

Try it online!
Supports arbitrary number of ASCII arts joining together rather than just 2 (as in the 2 previous JS answers).

Clean, 61 bytes
import StdEnv
$a b=flatlines[u++v\\u<-mklines a&v<-mklines b]

Try it online!

Swift 4, 119 bytes
func f(s:[String])->String{return s[0].split{$0=="\n"}.enumerated().map{$0.1+s[1].split{$0=="\n"}[$0.0]+"\n"}.joined()}

Explanation
func f(s: [String]) -> String {
    return s[0].split{ $0=="\n" }       //splitting the first string after every \n
    .enumerated()                       //create a tuple of offsets and elements
    .map {
        $0.1 +                          //current element
        s[1].split{$0 == "\n"}[$0.0] +  //splitting the second string + indexing
        "\n"                            //new line after every line
     }
     .joined()
}

Try it online!

Julia 1.0, 34 bytes
^,x=split,"\n"
a\b=join(a^x.*b^x,x)

Try it online!

Wolfram Language (Mathematica), 43 bytes (41 chars)
Column[StringJoin/@(#~StringSplit~"
")]&

 is an unprintable character in the private use area which represents Transpose in Mathematica.
This function takes input as a list of any number of strings and returns a Column object, which displays in a Mathematica notebook in the required manner (although it doesn't on TIO). For an additional ten bytes, replacing Column[---] with StringRiffle[---," "] will cause an output in the form of a single string. This code can take input of any number of strings with varied-length lines, as long as each string has the same number of lines.

Explanation:
#~StringSplit~ Split the input (implicitly applied to each string in the list)
" " at each newline.
 Then, transpose this list of lists of strings
StringJoin/@ and join together each of the sublists.
Column Finally, convert this list of strings to a Column object.
Try it online!

Just out of curiosity, how did you come by my challenge? There's been like four very recent submissions to a challenge I posted 4 years ago.

It popped up on the recently answered questions (probably from Steffan's Vyxal answer) and so I decided to do it.

Julia 0.6, 41 bytes
(a,b)->map(*,split(a,'\n'),split(b,'\n'))

Try it online!

returning a list of lines is explicitly not allowed


text:
Race for the Steward Badge
Backstory
If you visit the Steward Badge Page, you will see no one has received one of these badges from PPCG yet. However, there are two users:
DJMcMayhem & Martin Ender, that are only a few reviews away from this badge!
Challenge
Your challenge is to write a program or function that when run outputs DJMcMayhem's review count from the Low Quality reviews & Martin Ender's review count from First Posts reviews.
Your code needs to be dynamic so you should not hard-code the values of the current count. You should actually go and fetch the counts from those pages.
Your output should be the user's name and the count, with some delimiter in between each value, and there is no input.
Examples
DJMcMayhem, Count] [Martin Ender, Count]

DJMcMayhem, Count, Martin Ender, Count

DJMcMayhem Count Martin Ender Count

DJMcMayhem
Count
Martin Ender
Count

etc.....

No extraneous info is allowed.
Rules
Standard loopholes are not allowed.
This is code-golf, so the shortest code in bytes for each language wins!
Sandbox post

Interesting challenge. Just a heads up, 22 hours in the Sandbox is quite short. The recommended time is 72 hours, so that many people can see and offer criticism.

How does this challenge make sense in the context of this standard loophole?

@Nit standard loopholes don’t have to be disallowed

I’ve casted my vote to close this question as a duplicate because it is a [tag:stack-exchange-api] challenge involving and comparing 2 users, just like the other challenge. In my opinion, the only difference is looking at a badge progess rather than the reputation, and moreover the post I linked to has looser I/O rules.

@Mr.Xcoder, I looked for reviews in the API but couldn't find them so I'd argue against that dupe target. We have had a couple of challenges that required scraping data from an SE page, though; one of those would probably be a better target.

Very related; potentially duplicate. Also requires scraping an SE webpage (though with ID input not hardcode). I can't vote though because it is binding.

@dylnan Yeah, but the challenge text says all of them are disallowed.

Awarded 1 time: DJMcMayhem

Red, 259 bytes
c:"https://codegolf.stackexchange.com/review/"t: copy c
d:"low-quality-posts/stats"e:"first-posts/stats"
f: func[s q][parse find s q[thru{-count">^M^/}any" "copy n to" "(print[q n])]]
f read to-url append c d"DJMcMayhem"
f read to-url append t e"Martin Ender"

Try it online!
Unfortunately doesn't work in TIO - results in timeout, although works normally in Red console.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Self-growing code codee codeee codeeee
Write a program (or function) (let's call it P1), that when run, outputs another program P2 of the same language and exactly 1 byte longer than P1.
Program P2 when run, should output a 3rd program P3 that's 1 byte longer than P2. P3 must output a program P4 that's one byte longer than P3, etc. The same for P5, P6, ..., P∞.
The program chain should go indefinitely, or to a place where the interpreter can't handle anymore (but must remain as a theoretically valid program in the language)
Rules

Standard loopholes forbidden
All programs in the chain should be in one language
No input is given. Output goes to stdout or function return value
The program must end after a period of time. A program that stops generating output after a certain time spot but never terminates does not qualify

The shortest program P1 in bytes in each language wins!

Since the quine tag was added after the three current answers were posted, were you intending to forbid the quine loopholes in addition to the other ones?

@Οurous What??? I did not add that tag myself...

@iBug Regardless, are submissions allowed to read their own source code?

@MartinEnder What's the site's stance or general case? I did forbid it at the beginning, but I removed it during the grace period and I'm now unsure. I tend to forbit it now.

@iBug The "quine" tag forbids it by default, and it usually makes answers more interesting to do so. It's up to you though.

More restrictive challenge but highly related.

"puts <<2*2,2\nputs <<2*2,2\n\n2" grows by 2 at each iteration in Ruby. I couldn't find anything better. :-/. Interesting challenge!

less restricted but highly related

Possible duplicate of Program that creates larger versions of itself (quine-variant)

JavaScript (ES6), 14 12 bytes
-2 bytes thanks to @Shaggy
f=_=>"f=_"+f

Testing snippet

s=`f=_=>"f=_"+f`;

for(i=10;i--;s=eval(s)())
  o.innerText+=s+"\n";

Took me a second to spot that. Sneaky!

Can someone please explain, I cannot wrap my head around it, how does it increase?

@htmlcoderexe "f=_" prepends an extra _ before the parameter name, which causes it to increase in length every iteration.

Haskell, 74 66 bytes
EDIT:

-2 bytes by H.PWiz by using <>, then -6 by moving the (10*)<$>.

This now uses the newly free <> operator (Semigroup multiplication, requires GHC 8.4 to work without an import.)
main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)

Try it online! (Cheats with an import since TIO doesn't have GHC 8.4 yet.)
How it works

main=putStr$ is boilerplate to output the following string value.
fst<>show is a function that takes a tuple, and returns a string consisting of the first element of the tuple concatenated with the tuple's string representation. I.e.
(fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)

(10*)<$> multiplies the last element of the following tuple by 10, adding a digit 0 to its string representation.

You can save at least 2 bytes with (<>)

@H.PWiz Thanks, got some more by moving (10*)<$>.

7, 4 bytes of ASCII
1603

Try it online!
I know that 7 isn't normally encoded in ASCII, but this time it's a more convenient encoding so that we're adding 1 byte with each run, not 3 bits.
I'm also not sure whether this counts as cheating or not. (It's usual to be unclear whether or not a 7 quine is cheating, as it straddles the borderline in a number of ways.) You can make a decent argument that the 0 encodes the 6, but in general it's unclear where the resulting characters "come from" in 7 because it has so many, fairly bizarre, implicit behaviours.
This program prints itself with 1 appended, and will do so even if you append a number of 1s to it. Here's a commented debug trace of 160311:
|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source

(There are no | left in the program, so e will immediately quit the program as a side effect, meaning that the final 7s never run).
The basic confusion about where all the characters are coming from is that most commands in 7 just produce data when run, and then 6 attempts to reconstruct a sequence of commands that would produce the given fragment of data; this often ends up close to, but not identical to, the original. (For quining purposes, you normally write a 7 program in such a way that the result will be almost the same, normally differing in leading or trailing 7s.) So for example, the 1 in the data becomes 716, which is the easiest way to append 1 to the current data string. We originally produced it with 16, a different (but similar) character sequence, destructively removing one of the | markers the data started with. (I guess perhaps the best argument that this isn't a literal-only quine is that the output is different from the input!)

C (gcc), 134 132 bytes
Slight reworking of the canonical C quine. Dreadfully long.
x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}

Try it online!

Pari/GP, 35 bytes
(f=(x)->print1("(f="f")("1x")"))(1)

Try it online!

Fission 2, 7 bytes
'!+OR!"

Try it online!
The standard Fission quine, but with an extra ! that prints an additional 0x01 at the beginning of the code on each iteration.

Python 2, 38 bytes
s="print's=%r;exec s'%(s+'#')";exec s

Try it online!

brainfuck, 420 bytes
->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.

Try it online!
This is a modification on the "standard" BrainFuck quine, with a . at the end that tacks on an extra . each iteration.
The quine itself encodes Brainfuck characters as a stack of hex digits: specifically, the hex digits of c-0x2b, which conveniently are the following:
+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03

The encoding covers two snippets of code: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++ pushes the encoding of the encoding itself, and [[<++++++++++++++++>-]<+++++++++.<] walks the stack and prints everything.

Dirty, 9 bytes
'"n[!]a!␛

Try it online!
'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program

If source-code reading is allowed:
Dirty, 8 bytes
Q[!]W33!

Try it online!
Explained:
Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark

Might be valid:
Dirty, 4 bytes
Q[‼]

Try it online!
It prints the source code with a trailing newline.
(And a bunch of spaces, due to a bug. It works the same without them though.)
Note that it only works in the native character set, and not when you use the UTF8 front-end - so to try it on TIO you need to replace the character it outputs between the []s with ‼, which is the UTF8 equivalent for what it's printing.

The 4-byte version is definitely invalid.

GolfScript, 9 bytes
{'.~1'}.~

Try it online!
CJam, 9 bytes
{"_~1"}_~

Try it online!
I'm posting both of these solutions in the same answer, since they're just trivial variations of each other  and work in exactly the same way.  They're both based on the common GolfScript quine {'.~'}.~ (or {"_~"}_~ in CJam), which is described in more detail e.g. in this previous answer of mine.
The only difference is that this variant appends a 1 byte to the end of its output.  As it happens, any string of 1s (or any other integer literal without leading zeros) is itself a trivial quine in both GolfScript and CJam, so any ones already present at the end of the code above will simply be copied verbatim to the output.  Since GolfScript (and CJam) use arbitrary-length integers, this will work for arbitrarily long programs, at least as long as the computer running the code has enough memory to store it.

Java 8, 162 146 bytes
v->{String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"+1;return s.format(s,34,s).replaceAll("1+$","");}

Try it online.
Try the first output program; Try the second output program; Try the third output program.
Explanation:
v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s

quine-part:

The String s contains the unformatted source code.
%s is used to input this String into itself with the s.format(...).
%c, %1$c and the 34 are used to format the double-quotes.
s.format(s,34,s) puts it all together

Challenge part:

+1 adds a 1 to both the unformatted and formatted program.
.replaceAll("1+$","");}: Because we only want to increase the program byte-count by one instead of two, we remove any trailing 1s before returning.

Jstx, 4 bytes
£↕♣:

Try it online!

><>, 9 bytes
#o<:}-1:"

Try it online!
Variation on a classic ><> quine, which simply adds another dupe command to copy the # in the front.

Perl 5, 32 bytes
$_=q{say"\$_=q{$_
};eval"};eval

Try it online!

Attache, 76 72 61 bytes
Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Try it online!
Standard quine which adds a space to the end of x after each iteration.
First few iterations:
Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]

etc.
Attache, 72 bytes
y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

Try it online!
This is simply a variation of the standard format quine, with a variable y that is set to 10*y after each iteration
The first few iterations:
y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

etc.

Runic Enchantments, 6 bytes
"'<S@>

Try it online!

This one was weird. All I had to do was remove a ~ from the original quine found by Jo King.
Every additional run appends another < to the end, e.g.:
"'<S@><<<<<<<<<

All of which do nothing.

Direct copy of this answer on a related challenge. It just so happened to already grow by 1 byte every iteration (strong argument for this challenge being a duplicate of that one or vice versa).

Swift 4, 89 bytes
let(a,b)=(";print(\"let(a,b)=\\((a,b+\"-\"))\"+a)", "");print("let(a,b)=\((a,b+"-"))"+a)

Includes a trailing newline
Try it online!

Haskell, 88 bytes
main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"

Try it online! Grows by prepending # to the data string.

You can save a bit by showing more than just a string and using pattern matching. Try it online!

@ØrjanJohansen Nice! Except for the underlying standard Haskell quine this is a completely different approach, so feel free to post it yourself.

OK, if you think so.

Wonder, 33 bytes
f\ @(-> ol) ["f\ ";f;";f1";#0];f1

An interesting variant on the normal quine that appends a 1 after each iteration.
Progression:
f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...

Explanation
f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument

One of the interesting parts of this quine is that Wonder can work with numbers of arbitrary precision, so the progression won't break after a certain amount of ones.

Stax, 20 18 bytes
"34s+cTZL"34s+cTZL

Run and debug it
Generates an extra space before the 2nd quotation mark every iteration.
Explanation
Uses the program "34s+cTZL "34s+cTZL to explain.
"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.

Gol><>, 7 bytes
":r2ssH

Try it online! Try it online!! Try it online!!!
This is a simple variation of the regular Gol><> quine but adds a copy of H each time it's run. Since the H command halts the program, additional H at the end does not change the behavior.

C# (Visual C# Interactive Compiler), 89 bytes
var s="var s={0}{1}{0}+8;Write(s.Trim('8'),(char)34,s);"+8;Write(s.Trim('8'),(char)34,s);

Inspired by Kevin Cruijssen's answer.
Try it online!

Jelly, 11 bytes
“⁾;⁶;ØV” ṘV

Try it online!

Windows Batch, 38 36 bytes
echo|set/p"=q">q&copy/b/y %0+q %0
::
This code creates a file called "q", containing the letter 'q', and then appends it to the original file.
Note that "::" is an alias for "rem" that does not require an additional space.
Saved 2 bytes thanks to user3493001.

ColdFusion, 277 bytes
<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>

This is a trivial modification of my ColdFusion quine which adds a newline each extra time it's called.
Tested locally on lucee-express-5.2.6.60

T-SQL, 175 bytes
DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @

First I wrote an SQL quine, then I modified it to add an extra space (somewhat inspired by this answer).

Befunge-98 (PyFunge), 22 19 bytes
r:#,_ #;'D2/'<,,@;"

Try it online!
Adds a < before the last " every generation.

Jstx, 4 bytes
£↕☺V

Try it online!
Explanation
Verbose code:
meta.source    Push the source
load 1         Push 1
string.concat  Concatenate source with 1
               Implicit output

C (gcc), 71 bytes
#define a(b)*s=#b;b
a(main(){printf("#define a(b)*s=#b;b\na(%s;)",s);})

Every iteration adds a semicolon after the closing brace of the main function.
Try it online!

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Swap program halves to test divisors
Four integer sequences
In this challenge, you will test four different properties of a positive integer, given by the following sequences.
A positive integer N is

perfect (OEIS A000396), if the sum of proper divisors of N equals N. The sequence begins with 6, 28, 496, 8128, 33550336, 8589869056, 137438691328, 2305843008139952128...
refactorable (OEIS A033950), if the number of divisors of N is a divisor of N. The sequence begins with 1, 2, 8, 9, 12, 18, 24, 36, 40, 56, 60, 72, 80, 84, 88, 96, 104, 108, 128...
practical (OEIS A005153), if every integer 1 ≤ K ≤ N is a sum of some distinct divisors of N. The sequence begins with 1, 2, 4, 6, 8, 12, 16, 18, 20, 24, 28, 30, 32, 36, 40, 42, 48, 54, 56...
highly composite (OEIS A002128), if every number 1 ≤ K < N has strictly fewer divisors than N. The sequence begins with 1, 2, 4, 6, 12, 24, 36, 48, 60, 120, 180, 240, 360, 720, 840, 1260, 1680, 2520, 5040...

Four programs
Your task is to write four programs (meaning full programs, function definitions or anonymous functions that perform I/O by any of the standard methods).
Each program shall solve the membership problem of one of these sequences.
In other words, each program will take a positive integer N ≥ 1 as input, and output a truthy value if N is in the sequence, and a falsy value if not.
You can assume that N is within the bounds of the standard integer type of your programming language.
The programs must be related in the following way.
There are four strings ABCD such that

AC is the program that recognizes perfect numbers.
AD is the program that recognizes refactorable numbers.
BC is the program that recognizes practical numbers.
BD is the program that recognizes highly composite numbers.

Scoring
Your score is the total length (in bytes) of the strings ABCD, or in other words, the total byte count of the four programs divided by two.
The lowest score in each programming language is the winner.
Standard code-golf rules apply.
For example, if the four strings are a{, b{n, +n} and =n}?, then the four programs are a{+n}, a{=n}?, b{n+n} and b{n=n}?, and the score is 2+3+3+4=12.

Related, Related, Related.

JavaScript (ES6), 46 + 55 + 6 + 36 = 282 274 ... 158 143 bytes
A:
n=>(r=0,D=x=>x&&D(x-1,n%x||(r++?q-=x:q=n)))(n)

B:
n=>(q=(g=D=x=>x&&!(n%x||(g|=m>2*(m=x),0))+D(x-1))(m=n))

C:
?!g:!q

D:
?(P=k=>--k?D(n=k)<q&P(k):1)(n):n%r<1

The result is 4 anonymous functions which give truthy/falsy values for their respective inputs (AC, AD, and BC give true/false, BD gives 1/0).
Test snippet

let AC =
n=>(r=0,D=x=>x&&D(x-1,n%x||(r++?q-=x:q=n)))(n)
?!g:!q

let AD =
n=>(r=0,D=x=>x&&D(x-1,n%x||(r++?q-=x:q=n)))(n)
?(P=k=>--k?D(n=k)<q&P(k):1)(n):n%r<1

let BC =
n=>(q=(g=D=x=>x&&!(n%x||(g|=m>2*(m=x),0))+D(x-1))(m=n))
?!g:!q

let BD =
n=>(q=(g=D=x=>x&&!(n%x||(g|=m>2*(m=x),0))+D(x-1))(m=n))
?(P=k=>--k?D(n=k)<q&P(k):1)(n):n%r<1

let update = n => O.innerText = [
  'perfect: ' + AC(n),
  'refactorable: ' + AD(n),
  'practical: ' + BC(n),
  'highly composite: ' + BD(n)
].join("\n")
<input type=number value=1 min=1 oninput=update(this.value)>

I like how you have spread the actual code over all 4 parts and mixed it with the "conditionals" unlike me (I have the code on parts A and B and "conditionals" on parts C and D.)

Jelly, 8 + 17 + 2 1 + 2 = 29 28 bytes
A:
Æṣ⁼$Ædḍ$

B:
ÆDŒPS€QṢwRµṖÆdṀ<Ʋ

C:
ƭ

D:
0?

For practical numbers (BC), 0 is falsy and any other result is truthy.
AC and BC are full programs, since they're not reusable as functions.

BC and BD don't seem to work properly.

ÆDŒPS€ḟ@RṆµṖÆd<ÆdẠµ works as B for a cost of two bytes though (and makes BC return 0 and 1 only like the others).

@JonathanAllan Oh no, it seems that I confused ŒP with ŒṖ. What a shame! Does it work if you fix that? (i.e. try my new edit) It's not that it's very easy to test anyway, that's why I haven't included a TIO link yet.

Jelly, 5 + 17 + 3 + 3 = 28 bytes
There's already a 28-byte Jelly answer, but I have a different approach, so why not add it too?
Parts
The pilcrow ¶ represents a newline.
A: S=¶ḍ¶ (5 bytes)
B: ŒP§iⱮḶ}Ạ¶>ḶÆd$}Ạ¶ (17 bytes)
C: ÆḌñ (3 bytes)
D: Ædç (3 bytes)
Perfect (8 bytes)
S=
ḍ
ÆḌñ

Try it online!
Explanation
S=   Auxiliary dyadic link
S    Sum of items in left argument
 =   Equals right argument?

ḍ   Ignored

ÆḌñ   Main monadic link
ÆḌ    Proper divisors
  ñ   Apply next link, with the number as right argument

Refactorable (8 bytes)
S=
ḍ
Ædç

Try it online!
Explanation
S=   Ignored

ḍ   Auxiliary dyadic link: Divides?

Ædç   Main monadic link
Æd    Number of divisors
  ç   Apply previous link, with the number as right argument

Practical (20 bytes)
ŒP§iⱮḶ}Ạ
>ḶÆd$}Ạ
ÆḌñ

Try it online!
Explanation
ŒP§iⱮḶ}Ạ   Auxiliary dyadic link
ŒP         Power set
  §        Sum of each
   iⱮ      Find index of each item from
     Ḷ}      Lowered range [0..(right argument - 1)]
       Ạ   All?

>ḶÆd$}Ạ   Ignored

ÆḌñ   Main monadic link
ÆḌ    Proper divisors
  ñ   Apply next link, with the number as right argument

Highly composite (20 bytes)
ŒP§iⱮḶ}Ạ
>ḶÆd$}Ạ
Ædç

Try it online!
Explanation
ŒP§iⱮḶ}Ạ   Ignored

>ḶÆd$}Ạ   Auxiliary dyadic link
>         Greater than?
    $     (
 Ḷ   }      Lowered range [0..(right argument - 1)]
  Æd        Number of divisors [of each]
    $     )
      Ạ   All?

Ædç   Main monadic link
Æd    Number of divisors
  ç   Apply previous link, with the number as right argument

05AB1E, 8 + 16 + 1 + 0 = 25 bytes
A: Ñ¨O©QI®Ö
B: ÑæOILåPILÑ€gRć‹P
C: s
D:
The long parts each calculate both values, s swaps to the first one.
Ñ          # push list of divisors
 ©         # store this list
  ¨        # remove the last (largest) value
   O       # take the sum
    Q      # is this equal to the input (perfect)
     I     # push the input
      ®    # push the stored divisor list
       g   # take the length
        Ö  # does it divide the input? (refactorable)
        (s)# (swap to perfect)

Try perfect online! or Try refactorable online!
ÑæOILåP    # practical?
Ñ          # push list of divisors
 æ         # take the powerset
  O        # sum of each subset
   IL      # push the range [1..input]
     å     # is each value in the sums of divisor-subsets?
      P    # take the product / boolean all

ILÑ€gRć‹P  # highly composite?
IL         # push the range [1..input]
  Ñ        # take the divisors of each integer
   €g      # take the length of each divisor list
     R     # reverse it (swap the input's to the front)
      ć    # push the first value seperately
       ‹   # is this larger
        P  # than all other values?

(s)        # (swap to practical)

Try practical online! or Try highly composite online

Haskell, 69 + 133 + 3 + 3 = score 208
A:
d n=filter((<1).mod n)[1..n]
f n=[sum(d n)-n==n,length(d n)`elem`d n]

B:
import Data.List
d n=filter((<1).mod n)[1..n]
f n=[all(\n->any(==n)$sum$subsequences$d n)[1..n],all((<length(d n)).length.d)[1..n-1]]

C:
!!0

D:
!!1

Try it online!
Yeah, it's pretty cheap but I'm not smart enough for a cooler solution. :P

I don't know much about Haskell but this could help you with subsequences

[x|x<-[1..n],mod n x<1] is shorter than filter((<1).mod n)[1..n].


text:
Cross-Alphabetic Characters
Background
I saw this very interesting Venn Diagram on wikipedia: https://simple.wikipedia.org/wiki/Alphabet#/media/File:Venn_diagram_gr_la_ru.svg
It shows the letters (physical shapes) in different alphabets that are common between Russian, Greek and Latin alphabets.
The Challenge
Given an input string of characters from any of the three scripts shown (i.e capitalised Greek, Cyrillic or Latin letters), output a percentage of the string that matches each language. Repeated letters count every time.
For example, FFLURS is all latin-only characters, so the output is FFLURS is 100% Latin, 0% Cyrillic and 0% Greek.
By contrast, TOX BEAM PHP is formed completely of characters that appear in all three languages, so the output is TOX BEAM PHP is 100% Cyrillic, 100% Greek and 100% Latin.
Lookup Tables
The Venn diagram is the source of the letters below:
Latin Only:
J,G,S,D,Q,U,V,W,F,L,R

Latin and Cyrillic:
C, С

Latin and Greek:
I,Ι, N,Ν, Z,Ζ

Greek and Cyrillic
Φ,Ф, Π,П, Γ,Г, Λ,Л

All three:
A,B,E,O,M,K,T,X,Y,H,P (and equivalents in greek and cyrillic), (space)

The rest
...are Greek-only or Cyrillic-only.
IMPORTANT NOTE
Unicode defines (for example) "A" in (at least) three separate ways - one for each language. Whichever is used in the input (&#0391, &#0410 or &#0041), the program should understand it as matching all three languages.
So, A (Latin), Α (Greek Alpha) and А (Cyrillic) should all give 100% Cyrillic, 100% Greek and 100% Latin as the answer.
Input Format
Any string containing exclusively А-Я, Α-Ω, A-Z and   (space). These characters can be repeated multiple times within the string.
Output Format
The output can be in any format, provided the function produces consistent results. I would like to see output in the format I show in my examples (FFLURS is 100% Latin, 0% Cyrillic and 0% Greek), but in order to make the challenge more open to anyone I'm happy to accept arrays/strings of percentages/ratios:
[100,0,0],
100 0 0
[1.0 0.0 0.0]
as long as it's always clear which number is which language - so the output should be consistent.
Some more test cases
CINEMATICS -> CINEMATICS is 100% Latin, 70% Greek and 60% Cyrillic
ЩJЩFЩLΞRΞVΞW -> ЩJЩFЩLΞRΞVΞW is 50% Latin, 25% Cyrillic and 25% Greek
  ->   is 100% Cyrillic, 100% Greek and 100% Latin
ΨΩTESTINGЯЮ -> ΨΩTESTINGЯЮ is 63.6% Greek, 63.6% Latin and 45.5% Cyrillic
Winning Criteria
Usual rules and exclusions apply; shortest answer (bytes) wins.
(sandbox link: https://codegolf.meta.stackexchange.com/a/14984/62289)
For the avoidance of doubt, the only Unicode characters valid in the input are:

0020, 0041-005A (Latin alphabet)
0020, 0391-03A9 (Greek alphabet)
0020, 0401, 0410-042F (Cyrillic alphabet)

But as shown in the lookup tables, characters may be cross-alphabetic.
Adding Jonathan Allan's table from the comments:
                                                 Latin  Greek  Cyrillic
U+0020     Space                                 1      1      1
U+0041  A  Latin capital letter A                1      1      1
U+0042  B  Latin capital letter B                1      1      1
U+0043  C  Latin capital letter C                1      0      1
U+0044  D  Latin capital letter D                1      0      0
U+0045  E  Latin capital letter E                1      1      1
U+0046  F  Latin capital letter F                1      0      0
U+0047  G  Latin capital letter G                1      0      0
U+0048  H  Latin capital letter H                1      1      1
U+0049  I  Latin capital letter I                1      1      0
U+004A  J  Latin capital letter J                1      0      0
U+004B  K  Latin capital letter K                1      1      1
U+004C  L  Latin capital letter L                1      0      0
U+004D  M  Latin capital letter M                1      1      1
U+004E  N  Latin capital letter N                1      1      0
U+004F  O  Latin capital letter O                1      1      1
U+0050  P  Latin capital letter P                1      1      1
U+0051  Q  Latin capital letter Q                1      0      0
U+0052  R  Latin capital letter R                1      0      0
U+0053  S  Latin capital letter S                1      0      0
U+0054  T  Latin capital letter T                1      1      1
U+0055  U  Latin capital letter U                1      0      0
U+0056  V  Latin capital letter V                1      0      0
U+0057  W  Latin capital letter W                1      0      0
U+0058  X  Latin capital letter X                1      1      1
U+0059  Y  Latin capital letter Y                1      1      1
U+005A  Z  Latin capital letter Z                1      1      0

U+0391  Α  Greek capital letter Alpha            1      1      1
U+0392  Β  Greek capital letter Beta             1      1      1
U+0393  Γ  Greek capital letter Gamma            0      1      1
U+0394  Δ  Greek capital letter Delta            0      1      0
U+0395  Ε  Greek capital letter Epsilon          1      1      1
U+0396  Ζ  Greek capital letter Zeta             1      1      0
U+0397  Η  Greek capital letter Eta              1      1      1
U+0398  Θ  Greek capital letter Theta            0      1      0
U+0399  Ι  Greek capital letter Iota             1      1      0
U+039A  Κ  Greek capital letter Kappa            1      1      1
U+039B  Λ  Greek capital letter Lambda           0      1      1
U+039C  Μ  Greek capital letter Mu               1      1      1
U+039D  Ν  Greek capital letter Nu               1      1      0
U+039E  Ξ  Greek capital letter Xi               0      1      0
U+039F  Ο  Greek capital letter Omicron          1      1      1
U+03A0  Π  Greek capital letter Pi               0      1      1
U+03A1  Ρ  Greek capital letter Rho              1      1      1

U+03A3  Σ  Greek capital letter Sigma            0      1      0
U+03A4  Τ  Greek capital letter Tau              1      1      1
U+03A5  Υ  Greek capital letter Upsilon          1      1      1
U+03A6  Φ  Greek capital letter Phi              0      1      1
U+03A7  Χ  Greek capital letter Chi              1      1      1
U+03A8  Ψ  Greek capital letter Psi              0      1      0
U+03A9  Ω  Greek capital letter Omega            0      1      0

U+0401  Ё  Cyrillic capital letter Io            0      0      1

U+0410  А  Cyrillic capital letter A             1      1      1
U+0411  Б  Cyrillic capital letter Be            0      0      1
U+0412  В  Cyrillic capital letter Ve            1      1      1
U+0413  Г  Cyrillic capital letter Ghe           0      1      1
U+0414  Д  Cyrillic capital letter De            0      0      1
U+0415  Е  Cyrillic capital letter Ie            1      1      1
U+0416  Ж  Cyrillic capital letter Zhe           0      0      1
U+0417  З  Cyrillic capital letter Ze            0      0      1
U+0418  И  Cyrillic capital letter I             0      0      1
U+0419  Й  Cyrillic capital letter Short I       0      0      1
U+041A  К  Cyrillic capital letter Ka            1      1      1
U+041B  Л  Cyrillic capital letter El            0      1      1
U+041C  М  Cyrillic capital letter Em            1      1      1
U+041D  Н  Cyrillic capital letter En            1      1      1
U+041E  О  Cyrillic capital letter O             1      1      1
U+041F  П  Cyrillic capital letter Pe            0      1      1
U+0420  Р  Cyrillic capital letter Er            1      1      1
U+0421  С  Cyrillic capital letter Es            1      0      1
U+0422  Т  Cyrillic capital letter Te            1      1      1
U+0423  У  Cyrillic capital letter U             1      1      1
U+0424  Ф  Cyrillic capital letter Ef            0      1      1
U+0425  Х  Cyrillic capital letter Ha            1      1      1
U+0426  Ц  Cyrillic capital letter Tse           0      0      1
U+0427  Ч  Cyrillic capital letter Che           0      0      1
U+0428  Ш  Cyrillic capital letter Sha           0      0      1
U+0429  Щ  Cyrillic capital letter Shcha         0      0      1
U+042A  Ъ  Cyrillic capital letter hard sign     0      0      1
U+042B  Ы  Cyrillic capital letter Yeru          0      0      1
U+042C  Ь  Cyrillic capital letter soft sign     0      0      1
U+042D  Э  Cyrillic capital letter E             0      0      1
U+042E  Ю  Cyrillic capital letter Yu            0      0      1
U+042F  Я  Cyrillic capital letter Ya            0      0      1

Welcome to PPCG! This is a nice first challenge. :) A note on your UTF-8 note: it's not UTF-8 which defines multiple versions of these characters but Unicode (and UTF-8 is just one specific way to encode Unicode code points). Also, since this part is rather important for answers to get right, you might want to include the explicit list of all Unicode characters that need to be handled correctly.

@JonathanAllan, ngn: I agree, I intended just the letters that are in the Venn diagram - but all representations of those letters are valid - like I try to say in the question, there are multiple unicode representations of "A", for example

Cyrillic "El" is actually Greek "Lambda". Cyrillic "Pe" is Greek "Pi".

@JonathanAllan Depending on font, Cyrillic Л can look exactly like Greek Λ. The Π-like shape is just another stylistic variation of the same letter.

@simonalexander2005 &#0391 - if you meant that as an html character entity, it should be Α

By the way, I still think A-Z should be referred to as the "English alphabet". The "Latin alphabet" is a broader concept.

Jelly, 56 bytes
A hash may well be shorter.
O:⁹:2;ON©œị“ŒḂI4ƥƒⱮıtɱN¦“¤COṙṚ¹`“ÑṂḄẈɼ]ġÐ’b4¤+4Bṙ®Ḣµ€S÷L

A monadic link returning a list of ratio amounts in the order English, Greek, Russian.
Try it online!
...or see a fully formatted output (including the implied rounding to one decimal place)
How?
We wish to have code which translates each possible character to a triple of ones and zeros representing whether they belong to each of the alphabets (much like the table in the question where C is 1 0 1). Once that is done we can sum across these and divide by the length to yield the ratios (between zero and one inclusive) - this is just S÷L (seen at the right of the code).
For any given character We know that if the ordinal is less than 256 it counts as English, if it is greater than 1024 it counts as Russian, and that if it is in-between 256 and 1024 it counts as Greek. As such taking the ordinal and integer dividing by 256 and then integer dividing the result by two yields 0 for the space and Latin characters (count as English), 1 for Hellenic (count as Greek), and 2 for Cyrillic (count as Russian). This is just O:⁹:2 in Jelly (seen at the left of the code).
If we rotate the triples of bits such that the natural alphabet bit* is the most significant then we can encode the lower two bits (as values between zero and three inclusive) in a look-up table with three rows and then rotate right by the numbers found above.
When we do this there are two things worthy of note - 1. Jelly has a rotate-left-by atom not a rotate-right-by one; 2. the Hellenic row of the look-up table would start with a zero (since Ξ is only Greek), thwarting a simple base-4 encoding (since leading zeros are not encodable). To alleviate (1) we can rotate-left by the negated value and to alleviate (2) we can encode our rows in reverse and index into them with the negative amount. This way we can negate both the row and column index with a single byte (N) as such our row and column indices may be calculated with O:⁹:2;ON.
Note that Jelly now has a multi-dimensional indexing atom, œị.
The table is formed from three large numbers which, once converted to base four, give the lower bits required for Cyrillic, Greek and Latin(+Space) respectively. They are of minimal length such that modular indexing by the negated ordinal values is possible - 47, 25, and 30 respectively (the .s are at unused indexes):
1: 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 1 3 3 2 3 1 3 3 3 1 3 0 0 0 0 3 0 1 3 0 3 0 0 0 0 0 0
   . . . . . . . . . Я Ю Э Ь Ы Ъ Щ Ш Ч Ц Х Ф У Т С Р П О Н М Л К Й И З Ж Е Д Г В Б А Ё . . . . .

2: 3 2 3 1 0 3 1 3 0 2 3 3 0 0 3 2 3 3 0 0 3 2 3 0 1
   Μ Λ Κ Ι Θ Η Ζ Ε Δ Γ Β Α Ω Ψ Χ Φ Υ Τ Σ . Ρ Π Ο Ξ Ν

3: 3 3 0 0 0 3 0 0 0 3 3 2 3 0 3 0 2 3 0 0 3 0 1 3 3 0 0 3 0 2
   Y X W V U T S R Q P O N M L K J I H G F E D C B A . .   . Z

As an example consider the character Φ at Unicode point U+03A6 (which should yield [0,1,1]) it has an ordinal value of (3×16²+10×16+6 =) 934. (O:⁹:2 means 934//256//2 =) 1 identifying it as part of the Hellenic block. The ;O concatenates the ordinal giving us [1,934] and the N then negates both values giving us [-1,-934]. Since Jelly indexing is both 1-based and modular and there are three rows the -1 references the second of the three rows (row 2 in the above code-block), since the middle row has a length of 25 the -934 references the (-934%25 =) 16th entry in that row, which is 2. The code then adds four (the most significant bit) giving us 6 which converted to binary is [1,1,0]. The code then rotates this left by each of [-1,-934] and takes the head (i.e. the rotation left by -1, a rotation right by 1) yielding [0,1,1] as required.
* English for space since it's grouped with the Latin characters

Commented code
O:⁹:2;ON©œị“...“...“...’b4¤+4Bṙ®Ḣµ€S÷L - Link: list of characters        e.g.: "СЯ"
                                 µ€    - for €ach character:                С       Я
O                                      -   cast to ordinal               1057    1071
  ⁹                                    -   literal 256
 :                                     -   integer division                 4       4
   :2                                  -   integer divide by 2              2       2
      O                                -   cast to ordinal               1057    1071
     ;                                 -   concatenate                  [2,1057] [2,1071]
       N                               -   negate                     [-2,-1057] [-2,-1071]
        ©                              -   copy to register for later
                          ¤            -   nilad followed by link(s) as a nilad:
           “...“...“...’               -     list of integers encoded in base 250 = [4951760157204492290900832256, 1043285073970097, 1081712651052809266]
                        b4             -     convert to base 4                    = [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,1,3,3,2,3,1,3,3,3,1,3,0,0,0,0,3,0,1,3,0,3,0,0,0,0,0,0],[3,2,3,1,0,3,1,3,0,2,3,3,0,0,3,2,3,3,0,0,3,2,3,0,1],[3,3,0,0,0,3,0,0,0,3,3,2,3,0,3,0,2,3,0,0,3,0,1,3,3,0,0,3,0,2]]
         œị                            -   index into                       2       0                   ^--[-2,-1071]   [-2,-1057]--^
                           +4          -   add four                         6       4
                             B         -   convert to binary             [1,1,0] [1,0,0]
                               ®       -   recall from register       [-2,-1057] [-2,-1071]
                              ṙ        -   rotate left         [[1,0,1],[0,1,1]] [[0,0,1],[1,0,0]]
                                Ḣ      -   head                          [1,0,1] [0,0,1]
                                   S   - sum                                 [1,0,2]
                                     L - length                                 2
                                    ÷  - divide                            [0.5,0,1]
                                       -   i.e.: 50.0% Latin, 0% Greek, 100% Russian

Looks like you have some terminology there...does "hash" mean a construct like (keys)iị(values)Ʋ?

I mean forming a distinct set of keys from some mathematical manipulation so one can index into a list of values, yes. So like ...ị“... or possibly ...ṃ“... (strictly speaking the monadic chain I formed is a hash function)

@ngn M kebard is anning

Oh, I know how to fix that! Reconfigure your keyboard and type Cyrillic "у" and "о" instead of "y" and "o" :D

I have never seen such a long Jelly answer... great job!

JavaScript (ES6), 197 179 bytes
Returns an array of 3 ratios in [0..1].
s=>[...s].map(_=>(x='b;C6cC6%c>b^[<$]_3--_c_acC-----$+aKHbKK[`H`H]'[(p=s[a='charCodeAt'](l++)%202%116%89)>>1][a]()-36,x/=p&1||8,L+=x/4&1,G+=x/2&1,C+=x&1),l=L=G=C=0)&&[L/l,G/l,C/l]

Try it online!
How?
We use the (rather inefficient) hash function % 202 % 116 % 89 to transform each character code into an index in [0..88]. The corresponding lookup table consists of 3-bit entries where bit #2 = Latin, bit #1 = Greek and bit #0 = Cyrillic. Using decimal digits, this gives:
76273722773722017732767267300071731711117377737577371111111111000775474476474767744474447

We append an extra 1 to get en even number of entries and encode this bit stream with printable ASCII characters in the range [37..99] (% to c), with 6 bits of payload data per character.
This leads to the following string:
b;C6cC6%c>b^[<$]_3--_c_acC-----$+aKHbKK[`H`H]

The offset was chosen to avoid characters such as \ that would have required escaping.

Ruby, 165 bytes
->s{(0..2).map{|x|s.chars.map{|c|o=c.ord;(o<33?7:"ĝ]ē¯]÷W59WUė½ñĝĕ×ßoĝėÏė55#{?!*15}"[o-[913,1040,65][y=o>>7<=>7]].ord+226>>3*-~y)[x]*1.0}.sum/s.size}}

Try it online!
Edit: Significantly golfed the code, and most importantly, squeezed 3 translation sequences into one UTF-8 string. The original longer code is kept below for better readability and explanation of the logic.
Ruby, 211 bytes
->s{(0..2).map{|x|s.chars.map{|x|o=x.ord;o<33?7:o<91?"77517117317173771117111773"[o-65]:o<938?"7762737237673276702776722"[o-913]:"74764744444767776757767#{?4*15}"[o-1040]}.inject(0.0){|y,z|y+=z.to_i[x]}/s.size}}

Try it online!
May not be the most efficient approach, but does the job. Uses a translation table for each alphabet with character occurrence in different scripts encoded by the bits of the number (in the order: Latin, Greek, Russian). The output is an array of percentages in the same order.
To fix the outlier Ё case I extended the Russian-only block of 4-s from 10 positions at the end of the alphabet to 15. This way, Ё gets picked correctly with negative index (and we are not required to handle lowercase letters than correspond to these extra indices).

Retina 0.8.2, 230 bytes
.+
$&¶$&¶$&¶$&
T`ΓΔΘΛΞΠΣΦΨΩЁБГДЖ-ЙЛПФЦ-Я`_`.+(?=¶.+¶.+$)
T`CDFGJ\LQRSUVWЁБДЖ-ЙС-Я`_`.+(?=¶.+$)
T`DFGIJ\LNQRSUVWZΔΖΘΙΝΞΣΨΩ`_`.+$
¶(.*)
¶$.1$*
1
100$*
.
1
(1+)¶(\1)*1*¶(\1)*1*¶(\1)*1*
$#2 $#3 $#4

Try it online! Link includes test cases. Note: Output is in % truncated down to an integer, because increasing the precision made the script too slow and it timed out on TIO.


text:
How old is it roughly?
Write a short program which takes in a positive number of seconds representing an age, and outputs an estimate of that time in English.
Your program must output the least precise amount of time which has passed, among the following metrics and their lengths in seconds:
second = 1
minute = 60
hour   = 60 * 60
day    = 60 * 60 * 24
week   = 60 * 60 * 24 * 7
month  = 60 * 60 * 24 * 31
year   = 60 * 60 * 24 * 365

Examples
input      : output
1          : 1 second
59         : 59 seconds
60         : 1 minute
119        : 1 minute
120        : 2 minutes
43200      : 12 hours
86401      : 1 day
1815603    : 3 weeks
1426636800 : 45 years

As you can see above, after the time of say, 1 day (60 * 60 * 24 = 86400 seconds), we no longer output minute(s) or hour(s), but only days until we surpass the time of one week, and so on.
Consider the given length of time to be an age. For example, after 119 seconds, 1 minute has passed, not 2.
Rules

No specification for 0 or negative inputs.
Follow proper pluralization. Every measure greater than 1 must include an s following the word.
You may not use a pre-existing library which serves the function of the entire program.
This is a code golf, shortest program wins the internet points.
Have fun!

I don't understand how we choose a unit or amount. Do we round?

@xnor we integer divide and use the smallest non-zero value along with its unit (possibly pluralised). Hence 59 -> "59 seconds" and 86401 -> "1 day".

Welcome to PPCG! Nice first challenge. For future reference there is a sandbox which is useful for getting feedback before posting to main.

It's too bad that weeks are included 'cause if they weren't there would be a 33 byte Mathematica solution: Floor[DateObject@#-DateObject@0]&.

@DanTheMan That's neat! Just tried it out and it doesn't appear to count for no pluralization though.

Note that Do X without Y is discouraged, as well as Non-observable program requirement.

How should we round the numbers? Should 119 seconds be 1 minute or 2 minutes? What about 90?

@user202729 Is that all in regard to my rule against using a library which "serves the function of the entire program"? I see that on quite a few other codegolfs, it seemed sensible. Also, as Johnathan Allan said, always round down to the nearest increment of the unit. 119 and 90 both round down to 60 = 1 minute.

Postgres has a near built-in for this (justify_interval).

Rules should be put in the challenge, not comment. See Changing the challenge in the comments.

@user202729 what change? Could you be more specific?

The "integer-divide" (round down) part.

Whether one uses "integer division" is implementation specific. Since Jonathan's comment and your question I've made clarifications within the challenge. Thanks!

But then, you should specify that the time should be rounded down.

My initial assumption was that people would understand that after 90 seconds, 1 minute has passed but 2 minutes haven't.
It's one minute old, not two. Similar to how someone's age counts only how many years have passed since their birth.
I have now edited the challenge, thanks again.

Jelly, 62 bytes
TṀị
“¢<<ð¢‘×\×€0¦7,31,365F⁸:µç“ɲþḣ⁹ḢṡṾDU¤µQƝṁ⁼ẹ»Ḳ¤ṭÇK;⁸Ç>1¤¡”s

A full program printing the result.
(As a monadic link it returns a list of an integer followed by characters)
Try it online!
How?
TṀị - Link 1: list of integers, K; list, V  e.g. [86401,1440,24,1,0,0,0], ["second","minute","hour","day","week","month","year"]
T   - truthy indexes of K                        [1,2,3,4]
 Ṁ  - maximum                                    4
  ị - index into V                               "day"

“¢<<ð¢‘×\×€0¦7,31,365F⁸:µç“...»Ḳ¤ṭÇK;⁸Ç>1¤¡”s - Main link: integer, N  e.g. 3599
“¢<<ð¢‘                                       - list of code-page indices = [1,60,60,24,1]
        \                                     - cumulative reduce with:
       ×                                      -  multiplication = [1,60,3600,86400,86400]
             7,31,365                         - list of integers = [7,31,365]
            ¦                                 - sparse application...
           0                                  - ...to index: 0 (rightmost)
         ×€                                   - ...of: multiplication for €ach = [1,60,3600,86400,[604800,2678400,31536000]]
                     F                        - flatten = [1,60,3600,86400,604800,2678400,31536000]
                      ⁸                       - chain's left argument, N    3599
                       :                      - integer divide         [3599,59,0,0,0,0,0]
                        µ                     - start a new monadic chain, call that X
                                ¤             - nilad followed by links as a nilad:
                          “...»               -   compression of "second minute hour day week month year"
                               Ḳ              -   split at spaces = ["second","minute","hour","day","week","month","year"]
                         ç                    - call the last link (1) as a dyad - i.e. f(X,["second","minute","hour","day","week","month","year"])
                                              -                             "minute"
                                  Ç           - call the last link (1) as a monad - i.e. f(X,X)
                                              -                             59
                                 ṭ            - tack                        [59,['m','i','n','u','t','e']]
                                   K          - join with spaces            [59,' ','m','i','n','u','t','e']
                                           ”s - literal character '
                                          ¡   - repeat...
                                         ¤    - ...number of times: nilad followed by link(s) as a nilad:
                                     ⁸        -   chain's left argument, X  [3599,59,0,0,0,0,0]
                                      Ç       -   call the last link (1) as a monad - i.e. f(X,X)
                                              -                             59
                                       >1     -   greater than 1?           1
                                    ;         - concatenate                 [59,' ','m','i','n','u','t','e','s']
                                              - implicit print - smashes to print  "59 minutes"

C, 194 180 144 128 characters
Thanks to @gastropher for the code reductions. I forgot that C allows for implicit parameters using K&R-style functions! Also thanks to @gmatht for the idea of putting literals inside instead of arrays. I extended that to the characters by abusing taking advantage of wide character/char16_t strings! The compiler doesn't seem to like \1 in its ☺ form though.
f(t,c,d){for(c=7;!(d=t/L"\1<ฐ\1•▼ŭ"[--c]/(c>2?86400:1)););printf("%d %.6s%s\n",d,c*6+(char*)u"敳潣摮業畮整潨牵 慤y†敷步 潭瑮h敹牡",(d<2)+"s");}

Try it online!
Original solution
I split up the arrays into separate lines to make it easier to see the rest of the solution.
char *n[]={"second","minute","hour","day","week","month","year"};
int o[]={1,60,3600,86400,604800,2678400,31536000};
f(int t){int c=7,d;while(!(d=t/o[--c]));printf("%d %s%s\n",d,n[c],d>1?"s":"");}

Try it online!
Running the divisors in order from largest to smallest, we get the coarsest unit of time. The program misbehaves if you give it 0 seconds, but as the specification explicitly excludes this value, I deem that to be acceptable.

Some tricks can be used to get it down to 183 bytes: Try it online!

Sorry, that one introduced a bug. Proper one at 180 bytes: Try it online!

@gastropner I think the last one has a bug too. '(d<1)' should be '(d<2)'... or '(d<=1)', but lets not go crazy.

@gmatht You are quite right!

OK, last one, I promise. 164 bytes.

OK, but your promises don't bind me. 160 bytes: Try it online!

both o and n are only used once. Can you not just use them as literals in the source? (e.g. n[c] becomes {"second","minute","hour","day","week","month","year"}[c])

@LambdaBeta is that legal syntax in C?

Unfortunately only somewhat. Example:printf((char*[]){"alpha","bravo","charlie"}[1]); does print bravo. Here it can save 1 byte at least on the char array (removes the 'n' twice, removes the ';', adds '(' and ')')

you could remove \n from printf

Suggest 1/d instead of (d<2)

Perl 5, 110 bytes
year31536000month2678400week604800day86400hour3600minute60second1=~s:\D+:say"$% $&",$_=$%>1&&"s"if$%=$_/$':reg

Try it online!

Stax, 54 bytes
▀♂♂┼╕Qá◙à*ä∙Φò►⌠╨Ns↔║►πîÇ∙cI≡ªb?δ♪9gΓ╕┬≥‼⌡Öå01:♪EoE╘≡ë

Run and debug it
Here's the unpacked, ungolfed, ascii representation of the same program.
                            stack starts with total seconds
c60/                        push total minutes to stack
c60/                        ... hours
c24/                        ... days
Yc7/                        ... weeks
y31/                        ... months
y365/                       ... years
L                           make a list out of all the calculated time units
`)sQP(dr'pk,oV4?_HIFD?x`j   compressed literal for singular forms of unit names
\                           zip totals with names
rF                          foreach pair of total and name (in reverse orer)
  h!C                       skip if the current total is falsey (0)
  _J                        join the total and unit name with a space
  's_1=T+                   concat 's' unless the total is one

Following execution, since there's no other output, the top of the stack is printed implicitly.
Run this one

JavaScript (ES6), 131 bytes
n=>[60,60,24,7,31/7,365/31,0].map((v,i)=>s=n<1?s:(k=n|0)+' '+'second,minute,hour,day,week,month,year'.split`,`[n/=v,i])|k>1?s+'s':s

Try it online!

I wasn't aware of the syntax that you used (split,). I learned something new.  Great solution.

@Makotosan Note that what is actually passed to split is the array [',']. Therefore, this only works with functions that force coercion to a string.

Java 8, 197 195 157 bytes
n->(n<60?n+" second":(n/=60)<60?n+" minute":(n/=60)<24?n+" hour":(n/=24)<7?n+" day":n<31?(n/=7)+" week":n<365?(n/=31)+" month":(n/=365)+" year")+(n>1?"s":"")

-38 bytes thanks to @OlivierGrégoire.
Explanation:
Try it online.
n->               // Method with long parameter and String return-type
  (n<60?          //  If `n` is below 60:
    n             //   Output `n`
    +" second"    //   + " second"
   :(n/=60)<60?   //  Else-if `n` is below 60*60
    n             //   Integer-divide `n` by 60, and output it
    +" minute"    //   + " minute"
   :(n/=60)<24?   //  Else-if `n` is below 60*60*24:
    n             //   Integer-divide `n` by 60*60, and output it
    +" hour"      //   + " hour"
   :(n/=24)<7?    //  Else-if `n` is below 60*60*24*7:
    n             //   Integer-divide `n` by 60*60*24, and output it
    +" day"       //   + " day"
   :n<31?         //  Else-if `n` is below 60*60*24*31:
    (n/=7)        //   Integer-divide `n` by 60*60*24*7, and output it
    +" week"      //   + " week"
   :n<365?        //  Else-if `n` is below 60*60*24*365:
    (n/=31)       //   Integer-divide `n` by 60*60*24*31, and output it
    +" month"     //   + " month"
   :              //  Else:
    (n/=365)      //   Integer-divide `n` by 60*60*24*365, and output it
    +" year")     //   + " year"
   +(n>1?"s":"")  //  And add a trailing (plural) "s" if (the new) `n` is larger than 1

157 bytes. I just golfed your numbers to shorter ones and moved /= around where needed.

Personal favourite: n->{for(int t=60,d[]={1,t,t*=60,t*=24,t*7,t*31,t*365},x=7;;)if(n>=d[--x])return(n/=d[x])+" "+"second,minute,hour,day,week,month,year".split(",")[x]+(n>1?"s":"");} (162 bytes), probably a good base for golfing.

Save 9 bytes using n/7+ instead of (n/=7)+ etc.

@Neil I'm afraid that won't work. For example, if the input is 2678400, the output should be 1 month instead of 1 months (singular instead of plural).

Oh, subtle, thanks for letting me know.

Kotlin, 205 203 196 bytes
x->val d=86400
with(listOf(1 to "second",60 to "minute",3600 to "hour",d to "day",d*7 to "week",d*31 to "month",d*365 to "year").last{x>=it.first}){val c=x/first
"$c ${second+if(c>1)"s" else ""}"}

Try it online!

APL+WIN, 88 119 bytes
Original version missed out weeks and months as pointed out by Phil H;(
Prompts screen input of number of seconds
a←⌽<\⌽1≤b←⎕÷×\1 60 60 24 7,(31÷7),365÷31⋄b,(-(b←⌊a/b)=1)↓∊a/'seconds' 'minutes' 'hours' 'days' 'weeks' 'months' 'years'

Explanation
b←⎕÷×\1 60 60 24 7,(31÷7),365÷31 prompts for input and converts to years, days, hours, minutes, seconds

a←⌽<\⌽1≤b identify largest unit of time and assign it to a

a/'years' 'days' 'hours' 'minutes' 'seconds' select time unit

(-(b←⌊a/b)=1)↓∊ determine if singular if so drop final s in time unit

b, concatenate number of units to time unit from previous steps

Did someone eat the weeks and months?

@PhilH Cookie monster ? ;) Thanks. Answer edited accordingly.

It looked too neat, even for APL! Also, how are you counting the bytes? I count 119 characters rather than bytes...

@PhilH I do not understand your comment first we agree on 119 bytes which I changed on editing the answer and above you do not say how many bytes you are questioning

T-SQL, 306 bytes (281 bytes without I/O)
DECLARE @n INT=1
DECLARE @r VARCHAR(30)=TRIM(COALESCE(STR(NULLIF(@n/31536000,0))+' year',STR(NULLIF(@n/2678400,0))+' month',STR(NULLIF(@n/604800,0))+' week',STR(NULLIF(@n/86400,0))+' day',STR(NULLIF(@n/3600,0))+' hour',STR(NULLIF(@n/60,0))+' minute',STR(@n)+' second'))IF LEFT(@r,2)>1 SET @r+='s'
PRINT @r

Two small typos: TRIM is not defined, this possibly should be LTRIM. Between week and day, you have a + , should possibly be a ,

Indeed, instead of +  it should be a , and I corrected that now. However, the TRIM function is defined since SQL Server 2017. Thanks.

R, 157 bytes
function(n,x=cumprod(c(1,60,60,24,7,31/7,365/31)),i=cut(n,x),o=n%/%x[i])cat(o," ",c("second","minute","hour","day","week","year")[i],"if"(o>1,"s",""),sep="")

Try it online!
cut is handy, since it splits ranges into factors, which are stored internally as integers, meaning we can use them as array indices as well. We can probably do something a bit more clever with the time period names, but I can't figure it out just yet.

JavaScript (Node.js), 177 bytes
x=>{return d=86400,v=[[d*365,'year'],[d*31,'month'],[d*7,'week'],[d,'day'],[3600,'hour'],[60,'minute'],[1,'second']].find(i=>x>=i[0]),c=parseInt(x/v[0]),c+' '+v[1]+(c>1?'s':'')}

Try it online!

Python 2, 146 144 bytes
lambda n,d=86400:[`n/x`+' '+y+'s'*(n/x>1)for x,y in zip([365*d,31*d,7*d,d,3600,60,1],'year month week day hour minute second'.split())if n/x][0]

Try it online!
2 bytes saved thanks to Jonathan Allan

if n/x saves a byte.

Reversing the order and indexing with 0 saves another.

Batch, 185 bytes
@for %%t in (1.second 60.minute 3600.hour 43200.day 302400.week, 1339200.month, 15768000.year)do @if %1 geq %%~nt set/an=%1/%%~nt&set u=%%~xt
@if %n% gtr 1 set u=%u%s
@echo %n%%u:.= %

PHP, 183 bytes
<?$a=[second=>$l=1,minute=>60,hour=>60,day=>24,week=>7,month=>31/7,year=>365/31];foreach($a as$p=>$n){$q=$n*$l;if($q<=$s=$argv[1])$r=($m=floor($s/$q))." $p".($m>1?s:"");$l=$q;}echo$r;

Try it online!

Julia 0.6, 161 bytes
f(n,d=cumprod([1,60,60,24,7,31/7,365/31]),r=div.(n,d),i=findlast(r.>=1),l=Int(r[i]))="$l $(split("second minute hour day week month year",' ')[i])$("s"^(l>1*1))"

Try it online!

Ruby, 129 bytes
->n{x=[365*d=24*k=3600,d*31,d*7,d,k,60,1].index{|j|0<d=n/k=j};"#{d} #{%w{year month week day hour minute second}[x]}#{d>1??s:p}"}

Try it online!

Perl 6/Rakudo 138 bytes
I'm sure there's further to go, but for now
{my @d=(365/31,31/7,7,24,60,60);$_/=@d.pop while @d&&$_>@d[*-1];$_.Int~" "~ <year month week day hour minute second>[+@d]~($_>1??"s"!!"")}

Explicate:
{ # bare code block, implicit $_ input
    my @d=(365/31,31/7,7,24,60,60); # ratios between units
    $_ /= @d.pop while @d && $_ > @d[*-1]; # pop ratios off @d until dwarfed
    $_.Int~   # implicitly output: rounded count
        " "~  # space
        <year month week day hour minute second>[+@d]~ # unit given @d
        ($_>1??"s"!!"")  # plural
}

R, 336
Working in progress
function(x){
a=cumprod(c(1,60,60,24,7,31/7,365/31))
t=c("second","minute","hour","day","week","month")
e=as.data.frame(cbind(table(cut(x,a,t)),a,t))
y=x%/%as.integer(as.character(e$a[e$V1==1]))
ifelse(x>=a[7],paste(x%/%a[7],ifelse(x%/%a[7]==1,"year","years")),
ifelse(y>1,paste(y,paste0(e$t[e$V1==1],"s")),paste(y,e$t[e$V1==1])))}

R, 246 bytes
f=function(x,r=as.integer(strsplit(strftime(as.POSIXlt(x,"","1970-01-01"),"%Y %m %V %d %H %M %S")," ")[[1]])-c(1970,1,1,1,1,0,0),i=which.max(r>0)){cat(r[i],paste0(c("year","month","week","day","hour","minute","second")[i],ifelse(r[i]>1,"s","")))}

Try it online!
This is using time formating instead of arithemtics, just for the hell of it. Maybe others could make this smaller?


text:
What is my exponential potential?
We'll define the N-exponential potential of a positive integer M as the count of prefixes of MN that are perfect N-powers.
The prefixes of an integer are all the contiguous subsequences of digits that start with the first one, interpreted as numbers in base 10. For example, the prefixes of 2744 are 2, 27, 274 and 2744.
A prefix P is a perfect N-power if there exists an integer K such that KN = P. For example, 81 is a perfect 4-power because 34 = 81.

Given two strictly positive integers M and N, compute the N-exponential potential of M according to the definition above.
For instance, the 2-exponential potential of 13 is 3 because 132 is 169, and 1, 16 and 169 are all perfect squares.
Test cases
Naturally, the outputs will nearly always be pretty small because powers are... well... exponentially growing functions and having multiple perfect-power prefixes is rather rare.
M, N     -> Output

8499, 2  -> 1
4,    10 -> 2
5,    9  -> 2
6,    9  -> 2
13,   2  -> 3

hello, how the output of : ( 4, 10 ) is 2  and not 1?   because 4 power 10 is 1048576, 1 is a perfect power but not 10

@AliISSA Hi, The output for 4, 10 is 2, because 1 is a perfect 10-power and 1048576 is also a perfect 10-power (while 10, 104, 1048, 10485 and 104857 are not). Thus, there are 2 valid prefixes, so the output is 2.

Brachylog, 12 bytes
{^a₀.&b~b^}ᶜ

Try it online!
Explanation
{^a₀.&b~b^}ᶜ
{         }ᶜ  Count the number of ways the following can succeed:
  a₀            A prefix of
 ^                the first {input} to the power of the second {input}
    .&          produces the same output with the same input as
       ~b         any number
         ^        to the power of
      b           all inputs but the first (i.e. the second input)

Jelly, 10 bytes
*DḌƤÆE%Ḅċ0

Try it online!
How it works
*DḌƤÆE%Ḅċ0  Main link. Left argument: m. Right argument: n.

*           Compute m**n.
 D          Generate its decimal digits.
  ḌƤ        Convert prefixes back to integers.
    ÆE      Get the exponents of each prefix's prime factorization.
      %     Take all exponents modulo n.
            For a perfect n-th power, all moduli will be 0.
       Ḅ    Convert from binary to integer, mapping (only) arrays of 0's to 0.
        ċ0  Count the zeroes.

Haskell, 56 bytes
0%n=0
x%n=sum[1|t<-[1..x],t^n==x]+div x 10%n
m#n=(m^n)%n

Try it online!
Extracts the prefixes arithmetically by repeated \x->div x 10. I tried expressing the last line point-free but didn't find a shorter expression.

05AB1E, 8 bytes
mηÓ¹%O0¢

Try it online!
Uses Dennis's Jelly 10-byte algorithm. Inputs are in reversed order.

Perl 5, 38 bytes
#!/usr/bin/perl -p
/ /;$_=grep/^${\++$n**$'}/,($`**$')x$`

Try it online!

Haskell, 73 bytes
m#n=sum[1|c<-scanl(\s c->s++[c])"0"$show$m^n,any(==read c)$map(^n)[1..m]]

Try it online!

Java (OpenJDK 9), 105 bytes
m->n->{int c=1,k=m;for(;--k>0;)if((""+(int)Math.pow(m,n)).matches((int)Math.pow(k,n)+".*"))c++;return c;}

Try it online!
Credits

-1 byte thanks to Kevin Cruijssen

.startsWith(""+(int)Math.pow(k,n)) can be .matches((int)Math.pow(k,n)+".*") for -1 byte.

Perl 6, 40 bytes
{1+(^$^m X**$^n).grep({$m**$n~~/^$^p/})}

Try it online!

If you assign a Callable to a &foo variable you can call it as you would a subroutine foo( 'bar' ) or foo 'bar' no need to include &. I mean you didn't write it as &say(&f(|$_)) (say is not special in any way)

@BradGilbertb2gills I only use Perl 6 for code golf and still have a lot to learn, so thanks for the tip.

Jelly, 14 bytes
*DḌƤ*İ}ær⁵%1¬S

Try it online! or see the test suite
How it works
*DḌƤ*İ}ær⁵%1¬S - Main link. Arguments: n, m (integers)  e.g. 13, 2
*              - Power. Raise x to the power y               169
 D             - Convert to a list of digits                 [1 6 9]
   Ƥ           - Convert each Ƥrefix
  Ḍ            - Back to an integer                          [1 16 169]
     İ         - Calculate the İnverse of
      }        - The right argument                          0.5
    *          - Raise each element to that power            [1 4 13]
       ær⁵     - Round each to 10 ** -10                     [1 4 13]
               - to remove precision errors
          %1   - Take the decimal part of each               [0 0 0]
            ¬  - Logical NOT each                            [1 1 1]
             S - Sum                                         3

Python 2, 83 71 70 bytes
n,m=input();s=n**m;k=0
while s:k+=round(s**(1./m))**m==s;s/=10
print k

Try it online!
Thx for 1 from ovs.

@ovs: d'oh! been coding too much javascript lately... was thinking I'd need math.round() lol

APL (Dyalog), 31 bytes
{+/o=⌊o←(÷⍵)*⍨10⊥¨,\10⊥⍣¯1⊢⍺*⍵}

Try it online!

Haskell, 83 bytes
import Data.List
m#n=sum[1|x<-read<$>(tail$inits$show(m^n)),x`elem`((^n)<$>[1..m])]

Try it online!

Ruby, 60 bytes
->m,n{c=1;s=m**n;c+=(0..m).count{|j|j**n==s}while 0<s/=10;c}

a lot of it is to deal with floating point errors
Try it online!

Kotlin, 89 bytes
m,n->1+(1..m-1).count{"${Math.pow(m+0.0,n)}".startsWith("${Math.pow(it+0.0,n).toInt()}")}

Try it online!
In the test cases, passed in n as double values (2.0, 10.0, 9.0) so that I don't have to convert to double when calling Math.pow().

Jelly, 9 bytes
*DḌƤœ&*€L

Try it online!


text:
Fastest to find the joint
The input is an array (or space-separated string, as you wish), zero-indexed, consisting of one strictly increasing array and one strictly decreasing array (in this order, not other vice versa), each having a length of 2 at least. Example is:
-10 -2 4 18 38 46 28 19 10

The goal is to write the fastest algorithm to find the joint of two sorted arrays.
In other words, the output is the index of the greatest element. In the provided case the output should be 5.
The input is guaranteed not to contain repeating numbers.
It's obvious that this can be solved with O(n) with ease, so please provide more interesting faster answers :)

Other test cases (first line is input, second is output):
0 1 4 3
2

1 10 9 8 7 6 5 4 3 1
1

1 3 4 6 7 8 0 -10 -20
5

1 3 5 3 1
2

You could also accept the length of the array as additional input, if needed

Do we get the length of the array for free? Is arbitrary access O(1)? (I'm guessing yes to both, but they are not stated.)

@Jon yep right, sorry for not mentioning

I believe the fastest will be O(log n) by divide & conquer.

Well, too easy for a [tag:fastest-algorithm], IMO. Now the challenge is essentially closed.

@JonathanAllan, well, there's a bit faster solution (I mean, it exists, but not posted here yet) :)

@nicael average or worst-case?

@nicael: You've chosen to score this question by asymptotic complexity (fastest-algorithm tag description: "Fastest-algorithm competitions are won by the answer with the smallest asymptotic time complexity. For challenges based on actual runtime, use [fastest-code] instead.") If you're thinking of some constant-factor improvement, it doesn't matter for this challenge.

@ngn the fastest algorithm to solve this task that I know is O(log(m)), where m is the position of the found max element, i.e. the answer.

@user2357112 please see the above comment, I'd say it's not a constant factor.

That's average-case O(log(n)), and using the position of the max as a parameter in the time complexity opens things up to too much ambiguity - you could just as easily make the algorithm O(log(n-m)), or O(log(distance of max from array center)), or any number of other ways of prioritizing the search.

@nicael "Fastest" could mean fastest on average or fastest in the worst case. If it's worst-case, O(log(m)) is indistinguishable from O(log(n)), as m can be anywhere in 0...n-1. If it's on average,  O(log(m)) could be asymptotically better, provided there's a strong bias towards smaller m.

C (gcc)
int find_joint(int *array, int length) {
	int left_bound = 0, right_bound = length - 1, joint = length / 2;

	while (array[joint-1] > array[joint] || array[joint] < array[joint+1]) {
		if (array[joint-1] < array[joint])
			left_bound = joint + 2;
		else
			right_bound = joint - 2;

		joint = left_bound + (right_bound - left_bound) / 2;
	}

	return joint;
}

Try it online!

You can improve by replacing left_bound + (right_bound - left_bound) / 2 by (right_bound + left_bound) / 2, which is equivalent.

@Angelorf I would assume that such an optimisation could be performed by the compiler. If it is not, since this challenge is about finding a well performing algorithm, altering the formula in this manner does not change the algorithm's asymptotic time complexity.

My suggestion can't make it slower and it could make it faster for some compilers in some interpretation of the word 'fast'. It's just a suggested edit.

JavaScript (ES6), O(log n)
Now assuming that accessing Array.length is always O(1) (as suggested by @12Me21 and @ETHproductions) and therefore not requiring the length to be passed as input anymore.
Returns a string describing the result (index + number of iterations).
f = (a, n = 1, min = 0, max = a.length - 1) => {
  let res = x => `Found index ${x} in ${n} iteration(s)`,
      mid;

  return (
    // only one slot left?
    max == min ? res(max) :

    // only two slots left?
    max == min + 1 ? res(a[max] > a[min] ? max : min) :

    // is the middle slot greater than its two neighbors?
    a[mid = min + max >> 1] > a[mid + 1] && a[mid] > a[mid - 1] ? res(mid) :

    // recursive call required
    a[mid] > a[mid + 1] ?
      f(a, n + 1, min, mid - 1)
    :
      f(a, n + 1, mid + 1, max)
  );
}

Try it online!

Are you allowed to take the length as input, even though it isn't needed?

@12Me21 Testing Array.length is probably O(1) in most - if not all - JS engines, but I don't think this is part of the specification (in other words, it could be O(n) just as well). Since taking the length as input was explicitly allowed by the OP, I guess it doesn't hurt to do so.

I would assume that Array.length is an actual property on all platforms (thus accessing it is O(1)), simply due to the fact that the length cannot be calculated from the number of items in the array or the index of the last item.

@ETHproductions Thanks for your feedback. I went ahead and updated it accordingly.

JavaScript (ES7)
function find_join(a, l) {
    p = 1.25 ** .5 - .5;
    n = 1;
    i = 0;
    j = l * p + .5 | 0;
    k = j * p + .5 | 0;
    x = a[j];
    y = a[k];
    while (l > 2) {
        n++;
        if (x > y) {
            l = j;
            j = k;
            k = j * p + .5 | 0;
            x = y;
            y = a[i + k];
        } else {
            i += k;
            l -= k;
            k = j - k;
            j = l * p + .5 | 0;
            y = x;
            x = a[i + j];
        }
    }
    return [n, a.indexOf(Math.max(...a.slice(i, i + l)), i)];
}

I was too lazy to write out the full l < 3 case.
This algorithm optimises the number of accesses of the array a. In practice this is not very useful, since the binary search always tests consecutive elements, which is not likely to be much slower than testing a single element.