text:
Reversible program
Objective
Write a program that outputs some printable ASCII characters. The trick is that if the program is reversed byte-by-byte, it must output the same thing in the reverse order, byte-by-byte, too.
Rules

No standard loopholes.
The program must not be a palindrome, nor can it be 1 byte in length (or empty). No restriction for patterns of the output as long as:
The output is at least 2 bytes long. It must contain solely printable ASCII characters, including visible characters and newlines, tabs and spaces. It should not be empty.
Outputs to standard error is ignored.
Quine programs are forbidden.
For example, the following program makes no sense (HQ9+)
AQ

Easy Mode
Paired parentheses/brackets/curly brackets are swapped after reversing source, so a reverse may be:
print("Hello");
;("olleH")tnirp  # not ;)"olleH"(tnirp

Make a note in your answer if your program uses this "Easy Mode".
Example
These are theoretical examples and may not exist in any programming language.
input -> output

program -> abcd
margorp -> dcba

() -> 10
)( -> 01

print('yes')tnirp -> yes
print('sey')tnirp -> sey

This is a code-golf, so the program with the shortest source code (in bytes) in each language wins!
Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

/* Configuration */

var QUESTION_ID = 142801; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];

  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '
' + c.body.replace(OVERRIDE_REG, '') + '
';
    });

    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });

  });

  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;

    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/ b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Surely any cat-like language can do this in 2 bytes?

Better description for that last rule should be "Your source should not be a quine". Also, a clear example would be nice.

@Neil Good point. It's forbidden now.

@iBug I think you should try sandbox next time. I feel that you just wanted to post your answer without taking sometime to think about other peoples answers (like quines). Also it is not nice to change the rules after 12 answers have been posted...

I see this put on hold but I do not see any comments about how this question can be improved. I'm voting to reopen.

I don't understand the last test case -- shouldn't it be sey output for the second part?

Why is this challenge still getting downvoted? Please leave a comment if you think this challenge can be improved.

RProgN 2, 2 bytes
Ai

Forwards, produces ZYXWVUTSRQPONMLKJIHGFEDCBA, backwards, produces ABCDEFGHIJKLMNOPQRSTUVWXYZ.
A pushes the alphabet, and i reverses it, although if i doesn't have anything to reverse, it conveniently does nothing.
Try it online!

Jelly, 5 bytes
22«33

Try it online!
The first is min(22, 33) and the reverse is min(33, 22)
Also 5 bytes
.)25½

Try it online!
The ) seems to discard everything before it. This is sqrt(25) which is 5.0 and the reverse is . which is 0.5.

+1 for the 5.0 vs. 0.5.

The program must not be a palindrome, nor can it be 1 byte in length (or empty). No restriction for patterns of the output as long as:

Excel VBA, 11 Bytes
(Ab)uses the fact that Excel has more than one STDOUT; Does not use Easy Mode
Anonymous VBE immediate window function that takes no input and outputs 12 to the VBE immediate window.
?12'12=]1A[

Reversed
Anonymous VBE immediate window function that takes no input and outputs 21 to the the range [A1] on the ActiveSheet Object.
[A1]=21'21?

Note: ?12'12? works as well but feels a bit too close to palindromic to be within the spirit of the challenge

shouldn't [A1] be reversed to [1A]?

@Jenny_mathy Yep it should - and now it is

Brain-Flak, 35 28+1=29 bytes
((#)}{))
()()()()(
 )){})#((

1 extra byte because of the flag -A to print ascii. This prints "\n\n"
Try it online!
-6 bytes thanks to Riley pointing out that I can cleverly use newlines in order to not duplicate as much code for the reversed program. This works because the pound sign only starts a single line comment.

When reversed, this does not produce the output reversed.

@ATaco fixed...

Seems to print a space and a newline at the TIO link you provided.

@JonathanAllan For some reason I thought 32 was a newline yesterday. Fixed to use 10 instead.

Saved quite a few bytes from that :D

Combining this with Funky Computer Man's answer you can get to 30 bytes

Rain-Flak, 65 59 bytes
((((((#)])([))(}{)}{))}{))
()()()()(
)){})){}){})())#((((((

Try it online!
This pushes

()

going forwards and

)(

going backwards.
It needs to pad the front with a newline because Brain-Flak's output automatically gets a newline added to the end of the output.

The language changed its name too?

@JonathanAllan That is the (informal) name of the Ruby interpreter of the language.

@JonathanAllan What Erik said is correct.  The comment behavior used here is unique to the Ruby interpreter so I specified the interpreter as to avoid confusion.

Jelly, 2 bytes
0%

Try it online! ...or try %0
Both full programs output the palindromic nan as they both attempt to take a modulo of zero by zero and implicitly print the result.

Mathematica, 5 bytes
44+55

or...
Mathematica, 4 bytes
11*9

outputs 99

The last one is no longer allowed. Quines are forbidden.

@iBug I think you should try sandbox next time. I feel that you just wanted to post your answer without taking sometime to think about other peoples answers (like quines). Also it is not nice to change the rules after 12 answers have been posted...

Pyth, 4 bytes
"Jj"

Outputs Jj and jJ when reversed.

Python 2, 43 42 52 bytes
Source
#1.,"n\"tnirp:tpecxe
#"""
print"\n",\
1.#"""cexe:yrt

Try it online!
Reversed source
try:exec"""#.1
\,"n\"tnirp
"""#
except:print"\n",.1#

Try it online!

Inspired by i cri everytim's answer. Does, however, not require 'easy mode'.
The program's outputs now are true reverses of one another, not ignoring the new line character. Thanks to @Jonathan Allan for pointing it out.

Japt, 4 3 bytes
-1 byte thanks to @ETHproductions
Normal
12C

Try it online! Prints 12.
Reversed
C21

Try it online! Prints 21.
Only the last statement is printed, and C is the constant for 12.

Don't think you even need the ;, do you?

@ETHproductions Right, I don't. I had been trying to implement using ; as the first char before coming to this one.

Jelly, 3 bytes
1+³

Try it online!
This is 1 + 100 which is 101. The reverse is just 100 + 1 which is also 101. Replacing + with _ works too.
Also 3 bytes
11»

Try it online!
The first is max(11, 0). The reverse is just max(0, 11). The argument is 0 by default if not present.

brainfuck, 67 23 21 bytes

Saved two bytes thanks to 12Me21; using a tab instead of a new line.

+++++++++..+++++++++>
Try it online!
The program's ouput are two spaces new lines tabs. It is nearly a palindrome, apart from the trailing or leading cell shift (>).

Using tab (character 9) would save 2 more bytes.

Perl 5 / Perl 6 / Ruby, 17 bytes
print 12#12 tnirp

Try it in Perl 5
Try it reversed in Perl 5
Try it in Perl 6
Try it reversed in Perl 6
Try it in Ruby
Try it reversed in Ruby

Python 2, 20 bytes
print'\n';#'n\'tnirp

Try it online!
print'\n' prints both the single newline it instructs and an implicit newline after.
print'\n'; does exactly the same - the ; is just there to stop the program being a palindrome.
The # marks the start of a comment.

18 bytes if you return a number instead of a string -> if the implicit newline counts you could save even 2 more bytes from that answere. Or am I missing something?

@Simon print 12; does not "return a number" it prints a string representation of the number. The implicit newline needs to be a part of the reversed output, so you'd need to print'\n'+`12`;#...

...we could have print'';#''tnirp if it were not for the specification: "The output is at least 2 bytes long".

Okay, I did read that reverse specification wrong.Would print 1;#'1n\'tnirpwork?

@Simon forwards that outputs 1\n and in reverse it outputs \n1\n.

Allright. I think its too late right now. I should stop trying to think of something else.

Japt, 2 bytes
Both output 11. B is the Japt constant for 11 and the w method, when applied to a number, returns the larger of that number and any number passed to it as an argument.
wB

Try it
Bw

Try it

Charcoal, 2 bytes
-¹

The - is simply a string literal that implicitly prints itself. The ¹ is a numeric literal, and the default is to implicitly print one - too. Any ASCII character and non-zero Unicode superscript would work.
²←

Forwards, this prints two -s, then moves the cursor back one step (but this does not affect the output). Backwards, this prints two -s leftwards, but the output remains the same. Any subscript from 2 to 9 would work here, as would a right arrow or the reflect operator ‖.

Java 8, 132 bytes
Dang full program requirements..
interface M{static void main(String[]a){System.out.print("OK");}}//}};)"OK"(tnirp.tuo.metsyS{)a][gnirtS(niam diov citats{M ecafretni

Try it here. Prints OK.
Reversed:
interface M{static void main(String[]a){System.out.print("KO");}}//}};)"KO"(tnirp.tuo.metsyS{)a][gnirtS(niam diov citats{M ecafretni

Try it here. Prints KO.

Hey! I said "make a note" if you're using the Easy Mode rule.

@iBug Oops.. misread that part. Roll-backed to my initial version. I edited on purpose so it wasn't the easy mode anymore; but apparently I've edited into the easy mode instead.. My initial answer was already not the easy mode.. My bad.

05AB1E, 4 bytes
?RA?

Try it online! or Try it reversed!

Javascript (ES6), 12 bytes
_=>12//12>=_

Reversed:
_=>21//21>=_

Code snippet:

a=_=>12//12>=_
b=_=>21//21>=_
console.log(a())
console.log(b())

Triangular, 6 bytes
%.%%%%

Prints 000. Triangle looks like this:
  %
 . %
% % %

Reversed triangle looks like this:
  %
 % %
% . %

The IP starts travelling southeast from the topmost character, so in both triangles %%% is interpreted.

Neim, 2 bytes
γδ

Outputs 12. Reversed, outputs 21.
Try it online!

SmileBASIC, 4 bytes
?12?

This will work in many BASIC dialects.
Prints "12" forwards, and "21" backwards.

Zsh, 16 bytes
printf 12 ftnirp
Attempt This Online!

Implicit, 2 bytes
À\

Same as the winning RProgN 2 answer. Try it online!
You can use a tool in this language to print the reverse of your code.

Cubically 2.1, 5 bytes
%0%1%

Prints 09. Try it online! or Try it reversed!
The top (0-indexed) face is initialized to 0 and the left (1-indexed) face is initialized to 9. So printing (%) 0 prints 0 and printing 1 prints 9.
No longer works in Cubically 2.2 as % can be called implicitly.

shortC, 18 bytes
AJ"hi")}//})"hi"JA

Prints hi. Exploits comments. Try it online!

rk, 50 bytes
rk:start
dne:kr
print: "hi" :tnirp
trats:kr
rk:end

Reversed via this tool:
dne:kr
rk:start
print: "ih" :tnirp
rk:end
trats:kr

rk ignores everything before rk:start and rk:end. Of course, it ignores everything in the middle it doesn't understand anyway.
Try it online! vs Try it reversed!

Unix sh, 15 bytes
echo ab#ab ohce

Reversed:
echo ba#ba ohce

Outputs ab and ba, respectively.

I don't know what shell you're using, but this outputs ab#ab ohce in every shell I've tried. (because # only starts a comment after a space)

RProgN 2, 3 bytes
1
0

Output:
0
1

Try it online!

Reversed source:
0
1

Reversed output:
1
0

Try it online!

at least give other people a chance to answer your challenge before you post your own answers

Is this the only thing anyone knows about RProgN2? It's a rather powerful language >:I

@ATaco Yes. Someone else posted this twice on my questions, so it's the only program I can write.

Well it Has a tutorial if you ever feel like learning more about it! :P


text:
Output with the same number of digits of pi as the length of the code
Your challenge is to print x digits of pi where x is your code length.
Examples:
Source code (length) -> output
foo!        (4)         3.141
foobar      (6)         3.14159
kinda long  (10)        3.141592653
+++++       (5)         3.1415
123456789   (9)         3.14159265

You can use floor(π/10 * 10code_length) / 10code_length - 1 to determine the number of digits you need to print. Note that the decimal point does not count as a digit of pi - so code of length 3 should have output 3.14, of length 4.
Rules:

Your code length must be larger than three characters.
You may not use any standard loopholes.
You may use any standard allowed output methods.
You may not read your source to determine code length.
You may not use a builtin pi constant.
Pi must be completely accurate and not approximated.
The decimal point in the output is necessary. If you choose to output via return value, you must return a floating point integer.
The goal of this challenge is to find the shortest solution in each language, not the shortest language for the solution. Don't be afraid to post a solution in a language when a shorter solution is posted in the same language as long as your solution uses a different method.

...so would this be valid or not?

(edit ^ this even (rounding))

“Code length” ← in bytes or in characters?

@Lynn Bytes, as usual.

Is just 3 allowed?

@NoOneIsHere Your code length must be larger than three characters.

Japt, 9 4 bytes
As short as it can allowably get :)
Includes an unprintable (reverse line feed, charcode 141) after the #.
3.#

Test it
In Japt, any character following # is converted to its character code and appended to any digits or decimal points which may precede it, in this case the 3.

Mathematica, 18 bytes
using zeta function

Sqrt[6Zeta@2]~N~18

Try it online!

Jelly, 9 bytes
“Œı⁸Ç’÷ȷ8

Try it online!
Outputs 3.14159265
How it Works
“Œı⁸Ç’     - The integer 314159265
      ÷    - divide
       ȷ8  - The integer 100000000

Pi is not being calculated!

yes it is, dividing 314159265 by 100000000 :-)

Jelly, 6 bytes
3;⁽4ƒṾ

Try it online!
Prints 3,14159 with the allowed "European" decimal separator, ,.
How?
3;⁽4ƒṾ - Main link: no arguments
3      - literal 3                3
  ⁽4ƒ  - base 250 literal 14159   14159
 ;     - concatenate              [3,14159]
     Ṿ - unevaluate               ['3', ',', '1', '4', '1', '5', '9']
       - implicit print           3,14159

That digit list looks odd. I think there is an extra ,' in there.

You can do -ÆAær5 and use . instead of ,, but then it would be the same as my Jelly solution.

VBA (Excel), 15 bytes
MsgBox 4*Atn(1)

Output:
3.14159265358979
I think this is not acceptable as I golfed it just to fit the length of the PI. The un-golfed length of it is 17 bytes. D:

Looks as though you have not yet been welcomed, so, welcome to the site!

Oh, Thank you, Sir! :D

Isn't Atn arctangent? I'm not sure if this is allowed... asking OP

I thought OP is referring for built-in PI only. My bad.

Python 3, 64 bytes
print("3.%d"%int("SIXW57LUPVBUA10HBQJOL57QLF54UT0U00KIN32O",36))

Try it online!

The Python 2 equivalent is 60 bytes print'3.%d'%int('3p3aqd50r7654t9ywkfkgsm0yx0bikcluxlhsm',36).

@JonathanAllan python 2 in 59: https://tio.run/##K6gsycjPM/r/v8K2wFbXxMCcqzwjMye1rsAKKKBvpFWhX6BtpGVooKVlamFdoG1rxFVQlJlXom6sp66dUJEQbWhVEPv/PwA

@primo looks like one to post if&when...

@JonathanAllan if you mean when it's reopened, it is now.

Desmos, 130 bytes
f\left(\right)=\frac{\operatorname{floor}\left(10^{128}\cdot 4\sum_{k=1}^{9^9}\frac{\left(-1\right)^{k+1}}{2k-1}\right)}{10^{128}}

The source code for this (Which can be accessed by copy and pasting inside and outside of Desmos) isn't optimal when generated using the Desmos editor, so a few bytes of whitespace were golfed down where possible.
This defines a function f which takes no arguments returns pi, calculated using the Gregory Sequence to k=9^9 (I can't confirm this is accurate enough, however I am of the believe that it is, it can be made more accurate with a greater value of k) it then floors the result to 128 decimal places, which, alongside the 3., is the length of the source code.
Try it online!

How does one actually see the result - I only see 3.14159265617, am I looking in the wrong place; do I need to hit a button?

Desmos doesn't defaultly print to as many decimal places as provided, but the value should still be accurate.

That is disappointing since the challenge is "to print..."

"The decimal point in the output is necessary. If you choose to output via return value, you must return a floating point integer." which makes this valid.

I feel the intent of that statement was not to allow for less precision but to ensure a decimal separator. Mind you I don't think your answer is bad.

The precision is there, it's just that Desmos can't print it all in a single output, but it can return from a function fine.

SOGL V0.12, 10 9 7 bytes
4ΘΞ“6⌡υ

Try it Here!
Explanation:
4ΘΞ“     push 31415
    6⌡   6 times do
      υ    divide by 10

CJam, 5 bytes
3.14F

Try it online!
How it works
3.14   e# Push 3.14.
    F  e# Push 15.

If only you could've done 3.E. :P, either way, amazing abuse of IO.

Was going to post 3'.EF, but then I saw this answer...

Charcoal, 8 bytes
”i‴Ａχ:&”

Try it online!
Just a compressed string.

Javascript, 16 bytes
_=>Math.acos(-1)

f=
_=>Math.acos(-1)
console.log(f())

APL, 6 bytes
10○⍟-1

Takes the imaginary part of ln(-1).
Try it online!

Hey, welcome back @Uriel! Nice one, I wasn't thinking of anything like that (with logs of negative numbers), nice job!

@Zacharý thanks, just dropped a visit and couldn't help answering this :P

Neim, 5 bytes
3FBρσ

Explanation:
3      Push 3
 FB    F pushes 45, B converts it into a character code, '.'
   ρ   Push 14
    σ  Push 15
Implicitly concatenate and print stack

Try it online!

J, 16 bytes
17j15":4*_3 o.1:

Try it online!
Similar to the VBA answer. Outputs: 3.141592653589793.

"You may not use a builtin macro or constant to determine pi." Funny, it's your comment

Your output is 17 bytes, not 16.

@ATaco exactly, it's 16 digits

@LeakyNun it doesn't. _3 o.1 calculates atan(1). As you may have known, I'm well aware of the rules.

Math.JS, 17 bytes.
     log(-1,e).im

That's 5 leading spaces
This calculates  to 15 decimal places, and implicitly prints it.
Try It Online!

Well, technically this calculates the imaginary portion of ln(-1), but since it's a purely imaginary number, it's equivalent to dividing by i.

MATL, 9 8 bytes
-1X;V9:)

Try it online!
Explanation:
-1      % number literal
X;      % inverse cosine (radians), giving pi
V       % convert to string
9       % specify precision
:)      % keep first 9 characters - 8 digits of precision

Saved one byte thanks to Luis Mendo!

05AB1E, 11 bytes
3•∊&SK•)'.ý

Try it online!
COMMAND     # CURRENT STACK         | EXPLANATION
------------#-----------------------+-----------------------------------
3           # [3]                   | Push 3.
 •∊&SK•     # [3, 1415926535]       | Push compressed base-255 number 1415926535.
       )    # [[3,1415926535]]      | Wrap the 2 to an array.
        '.  # [[3,1415926535],'.']  | Push a decimal point.
          ý # ['3.1415926535']      | Join 3 and 1415926535 with a decimal point.

USING BUILT-INS:
05AB1E, 4 bytes
žq5£

Try it online!

3žs doesn't work for some reason...

@Zacharý did I miss something? Why is that special xD?

It's in my username, and also, can you add an explanation?

@Zacharý HA! My brain was going through all the possible funny PPCG-related jokes it could be, coming up blank. I overthink crap.

@Zacharý also, added.

If MY had implicit IO, there would be no way to beat E3., I'm mad at myself now :p.

@Zacharý can I get a link to "MY"? If you want a comment link use: "MY".

Here: https://bitbucket.org/zacharyjtaylor/my-language/src. MY does have a TIO (it's not synced due to me being suspended from chat for just pushing it way too far, (if anyone wants to ask Dennis to pull MY for me, that would be nice)).

@Zacharý I have requested a pull but apparently it doesn't work.

There, I fixed that >_<. It can hopefully be pulled successfully.

2žs does work now and for the non-built-in version you could have •Iò₅U•8°/.

Jelly, 6 bytes
-ÆAær5

Try it online!
Uses a different approach than the other Jelly answers.
How?
-ÆA is inverse cosine of -1 (which is pi), ær5 retrieves the needed section. It worked out so rounding is equivalent to truncation in this case

ForceLang, 269 bytes
set S 0x5F258E476FC1B3B5571012206C637089460E41E814CB071E61431B5F0671F551D18D2C5D2D3A2565E408C6DE8D753F595B6E9979C3866D1C9965008DCFB02E3BD11D21DFFAF17978F05C8BBACF55A5ED5E90B1D8CAD8736AA4B728EB342B453F86353DB371D322B6A98613BC5CCB00AC2.mult 1e-270
io.write S.toString 268

Link to the language on github at least.

RPL (HP48), 86.5 bytes, 87 digits [Does this count?]
« GROB 8 43
14159265358979323846264338327950288419716939937510582097494459230781640628620899862803
→STR 9 OVER SIZE SUB 2 "." REPL »

GROB is an image keyword. The 2 numbers that follow are width and height. The hexadecimal digits that follow are bitmap. That's 1 byte of storage for every 2 digits plus the image metadata.
Empty program « » takes 10 bytes. A command takes 2.5 bytes. A float takes 10.5 bytes, but if it's equal to a single digit integer, it can take 2.5 bytes.
HP48 stores 4 rather than 8 bits at each memory location, so a byte occupies 2 consecutive locations (low endian). Often 20-bit chunks are used, and they do take 2.5 bytes (not 3).

TI-BASIC, 7 bytes
round(4tan⁻¹(1),6

round(2sin⁻¹(1),6

round(cos⁻¹(-1),6

These three statements will print 3.141593.

Note:  TI-BASIC is a tokenized language.  Character count does not equal byte count.

Julia 1.0, 16 bytes
show(acos(-1))##

Try it online!
This is the default precision printed, I sadly have to add 2 dummy characters but I don't think it's possible to make it shorter

No bytes improvement, but there is no unused characters in print(4*atan(1))

Perl 5, 40 bytes
}{$\=$\/~(2*$_)*~$_+2for-130..-2

Requires the command line option -pMbignum, counted as 8.
Sample Useage:
$ perl -pMbignum test.pl < /dev/null
3.141592653589793238462643383279502884197

I apologize for no TIO link, it doesn't seem to support bignum (or an unmatched opening brace...).

MY, 7 bytes
’2ō"8↑↵

Try it online!
How?

’, decrement the top of the stack (0 is popped if empty, making the stack [-1]). (Same symbol as Jelly)
2, push 2.
ō, since the top of the stack is two, discard the 2, pop n, then push acos(n) (in radians, this gives pi, this symbol is o with a negative sign on top of it. o (for normal trig) comes from APL).
", pop the top element of the stack and push it as a string.
8, push 8.
↑, pop a then b, push b[:a] (This is another symbol taken from APL).
↵, output with a new line (OUTPUT <- STACK).

Then add implicit output :P

I'm keeping true to the nature of MY, I might make an improved version with actual syntax, and definitely with implicit output

Haskell, 15 bytes
 acos(-1)-3e-15

Try it online!
Using @JungHwanMin formula.

><>, 16 bytes
"]a:5;."3no>n<

Try it online!
There's a couple of unprintables in there, with the first having value 26 and the second 141.

C (gcc), 99 bytes
i;main(){for(;i<46;)printf(i++?"%02d":"3.",i[L"0;5:a]î.+& O2TÅ©']KiR J^-\N¤>cV0ý*uO"]);}

Try it online!
Hardcode 99 bottle of digits

Pyth, 9 bytes
<`.ttZ4 T

Try it here.
Works with the fact that .

Ruby, 16 bytes
->{Math.acos -1}

Try it online!

Excel VBA, 16 Bytes
Anonymous VBE immediate window functions that takes no input and output to any of Excel VBA's STDOUTs
Each line represents a separate function that returns Pi of length 16
?Mid(4*Atn(1),1)
?Str([Acos(-1)])
Debug.?4*Atn(1);
MsgBox[Acos(-1)]
[A1]="=ACOS(-1)"

Octave, 16 bytes
vpa(acos(-1),16)

Try it online!
I'm having a hard time imagining how this could be shorter...

PHP, 14 Bytes
Try it online!
<?=acos(-001);

A bit tricky, but the precition of M_PI is 3.1415926535898

Brainfuck (32 bit), 672 660 bytes
++++++[->++++++++++<]>[->+++++++++++<]>[<+>>>>>>>>++++++++++<<<<<<<-]>+++++[<+++++++++>-]+>>>>>>+[<<+++[>>[-<]<[>]<-]>>[>+>]<[<]>]>[[->>>>+<<<<]>>>+++>-]<[<<<<]<<<<<<<<+[->>>>>>>>>>>>[<+[->>>>+<<<<]>>>>>]<<<<[>>>>>[<<<<+>>>>-]<<<<<-[<<++++++++++>>-]>>>[<<[<+<<+>>>-]<[>+<-]<++<<+>>>>>>-]<<[-]<<-<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]>[-]>+<<<-[>>+<<-]<]<<<<+>>>>>>>>[-]>[<<<+>>>-]<<++++++++++<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]>[-]>+>[<<+<+>>>-]<<<<+<+>>[-[-[-[-[-[-[-[-[-<->[-<+<->>]]]]]]]]]]<[+++++[<<<++++++++<++++++++>>>>-]<<<<+<->>>>[>+<<<+++++++++<->>>-]<<<<<[>>+<<-]+<[->-<]>[>>.<<<<[+.[-]]>>-]>[>>.<<-]>[-]>[-]>>>[>>[<<<<<<<<+>>>>>>>>-]<<-]]>>[-]<<<[-]<<<<<<<<]

All credit should go to Felix Nawothnig's yapi.b.
Should you decide to downvote, please leave a comment explaining why.

Perl 6, 16 bytes
{4*atan       1}

Try it online!

13 bytes using tau

Thunno 2, 9 bytes
»Øȯ\œ»k6/

Try it online!
Compressed integer 314159265 divided by 100000000.
Thunno 2, 4 bytes
kP5ɱ

Try it online!
Using built-in Pi constant.

source: Stack Exchange

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/

sort: votes


text:
Hidden sentences in the license plates
Introduction:
Inspired by both Perfect License Plates and How many points does my license plate give?
Just like in the challenges above, me and my little brother had a game of our own with license plates as kids. We tried to create (random/funny) sentences with the (numbers and) letters of the license plates.
For example, I can still remember the license plate of our old car from over ten years ago, because of the silly sentence we had created with it:
71-NN-BT
71 Nare Nonnen Bijten Tijgers   [Dutch for: 71 Nasty Nuns Biting Tigers]

Input:

A license plate, which for the sake of this challenge will always start with two digits [0-9], followed by four uppercase letters [A-Z].
Three fixed lists (see below): consisting of Dutch plural nouns; Dutch adjectives; and Dutch verbs.

Output:
Using the list of Dutch plural nouns, adjectives and verbs below as input, create a random Dutch sentence with the given license plate using the following rules:

Start with the numbers, followed by a space;
And the four letters should either be used in the pattern adjective noun verb noun or noun verb adjective noun (50/50 random).
This would mean that the sentence mentioned earlier ("Nare Nonnen Bijten Tijgers" / "Nasty Nuns Biting Tigers") is in the pattern adjective noun verb noun, and this alternative sentence "Nonnen Negeren Blote Theekopjes" / "Nuns Ignoring Naked Teacups" is in the pattern noun verb adjective noun).

Lists of words
Formatted pastebin thanks to @Arnauld.
Nouns:
Aanbeelden [Anvils]
Aardbeien [Strawberries]
Apen [Monkeys]
Appels [Apples]
Auto's [Cars]
Bananen [Bananas]
Bessen [Berries]
Bloemen [Flowers]
Bomen [Trees]
Bijen [Bees]
Cadeaus [Presents]
Cavia's [Guinea pigs]
Cheerleaders [Cheerleaders]
Circusdieren [Circus animals]
Citroenen [Limons]
Dinosaurussen [Dinosaurs]
Dieren [Animals]
Documenten [Documents]
Doctoren [Doctors]
Dolfijnen [Dolphins]
E-mails [Emails]
Edelstenen [Gemstones]
Eekhoorns [Squirles]
Enqûetes [Enquetes]
Ezels [Donkeys]
Fabrieken [Factories]
Fietsen [Bicycles]
Flessen [Bottles]
Fontijnen [Fountains]
Foto's [Photographs]
Giraffen [Girafs]
Glazen [Glasses]
Gummen [Erasers]
Guppy's [Guppies]
Gymschoenen [Gym shoes]
Haaien [Sharks]
Homo's [Gay men]
Honden [Dogs]
Hoofden [Heads]
Horloges [Watches]
Idioten [Idiots]
Idolen [Idols]
IJsklontjes [Ice cubes]
Illusies [Illusions]
Imperia [Empires]
Jassen [Jackets]
Jokers [Jokers]
Jongleurs [Jugglers]
Jurken [Dresses]
Juwelen [Jewels]
Kabels [Cables]
Katten [Cats]
Kauwgomballen [Gum-balls]
Knoppen [Buttons]
Konijnen [Rabbits]
Leesboeken [Reading books]
Leeuwen [Lions]
Legercommandanten [Commander-in-chieves]
Lesbies [Lesbians]
Lummels [Oafs]
Maagden [Virgins]
Mannen [Men]
Mensen [People]
Mieren [Ants]
Muren [Walls]
Neuzen [Noses]
Nieuwkomers [Novices]
Nonnen [Nuns]
Noten [Nuts]
Nummerborden [License plates]
Oceanen [Oceans]
Ogen [Eyes]
Olifanten [Elephants]
Oren [Ears]
Orkanen [Huricanes]
PC's [PCs]
Pizza's [Pizzas]
Politieagenten [Police officers]
Postbezorgers [Mail men]
Potloden [Pencils]
Quads [ATVs]
Quaggamosselen [Quagga mussels]
Querulanten [Querulants]
Quiëtisten [Quietists]
Quizzen [Quizzes]
Radio's [Radios]
Ramen [Windows]
Regiseuren [Film directors]
Rekenmachines [Calculators]
Relschoppers [Hooligans]
Schepen [Ships]
Slakken [Snails]
Slangen [Snakes]
Stegosaurussen [Stegosauruses]
Stoelen [Chairs]
T-rexen [T-rexes]
Tafels [Tables]
Theekopjes [Teacups]
Tijgers [Tigers]
Tovenaars [Wizards]
Uien [Unions]
Uilen [Owls]
Universa [Universes]
Universiteiten [Universities]
USB-sticks [USB-sticks]
Vliegtuigen [Planes]
Vrachtwagens [Trucks]
Vrienden [Friends]
Vrouwen [Women]
Vulkanen [Vulcanos]
Walvissen [Whales]
Wespen [Wasps]
Wormen [Worms]
Worstelaars [Wrestlers]
Wortels [Carrots]
X-assen [X-axes]
X-chromosomen [X-chromosomes]
Xenonlampen [Xenon lamps]
Xylofonen [Xylophones]
Xylofonisten [Xylophonists]
Y-assen [Y-axes]
Y-chromosomen [Y-chromosomes]
Yoghurtdranken [Yugurt drinks]
Yogaleraren [Yoga teachers]
Yogaleraressen [Female yoga teachers]
Zeeën [Seas]
Zeehonden [Seals]
Zeepbellen [Soap bubbles]
Zwanen [Swans]
ZZP'ers [Freelancers]

Verbs:
X has some duplicated verbs, because there aren't enough verbs starting with an X in Dutch..
Accepteren [Accepting]
Activeren [Activating]
Amputeren [Amputating]
Amuseren [Amuzing]
Assisteren [Assisting]
Bakken [Baking]
Bedreigen [Threatening]
Bellen [Calling]
Bevruchten [Fertilizing/Impregnating]
Bijten [Biting]
Castreren [Castrating]
Categoriseren [Categorizing]
Centrifugeren [Centrifuging]
Claimen [Claiming]
Coachen [Coaching]
Dagvaardigen [Prosecuting]
Daten [Dating]
Degraderen [Downgrading]
Dienen [Serving]
Dwarsbomen [Thwarting]
Electroniseren [Eletronizing]
Eren [Show respect for]
Erven [Inherit]
Eten [Eating]
Exploderen [Blow up]
Factureren [Invoicing]
Fokken [Breeding]
Föhnen [Blow-drying]
Fotographeren [Photographing]
Frituren [Frying]
Gooien [Throwing]
Graderen [Grading]
Grijpen [Grabbing]
Groeperen [Making groups of]
Groeten [Greeting]
Hacken [Hacking]
Hallucineren [Hallucinating]
Haten [Hating]
Helpen [Helping]
Huren [Renting]
Importeren [Importing]
Inspireren [Inspiring]
Ironiseren [Ridiculing]
Irriteren [Irritating/Annoying]
Isoleren [Isolating]
Jagen op [Hunting on]
Jatten [Stealing]
Jennen [Teasing]
Jongleren met [Juggling with]
Justeren [Adjusting]
Klonen [Cloning]
Koken [Cooking]
Kopen [Buying]
Kraken [Cracking]
Kussen [Kissing]
Labelen [Labeling]
Leasen [Leasing]
Lonken [Ogling]
Loven [Praising]
Lusten [Having a taste for]
Maken [Creating]
Martelen [Torturing]
Merken [Labeling]
Meten [Measuring]
Mollen [Breaking]
Negeren [Ignoring]
Neuken [Having sex with]
Neutraliseren [Neutralizing]
Normaliseren [Normalizing]
Notificeren [Notifying]
Observeren [Observing]
Oliën [Oiling]
Ontbloten [Denuding]
Ontsmetten [Disinfecting]
Ordenen [Sorting]
Penetreren [Penetrating]
Pesten [Bullying]
Plagen [Teasing]
Porren [Poking]
Produceren [Producing]
Quadrilleren met [Quadrille-dancing with]
Quadrupleren [Quadrupling]
Queruleren over [Grumbling about]
Quoteren [Giving a rating to]
Quotiseren [Distributing]
Raadplegen [Consulting]
Redden [Saving]
Reinigen [Cleaning]
Ruilen [Trading]
Roken [Smoking]
Schieten [Shooting]
Schoppen [Kicking]
Schudden [Shaking/Shuffling]
Slaan [Hitting]
Stoppen [Stopping]
Tackelen [Assaulting]
Telen [Cultivating]
Tellen [Counting]
Temperen [Tempering]
Torpederen [Torpedo-ing]
Unificeren [Uniformising]
Unlocken [Unlocking]
Upgraden [Updrading]
Urineren [Urinating]
Utiliseren [Making use of]
Verbinden [Binding]
Verjagen [Scaring away]
Verkopen [Selling]
Vermoorden [Killing]
Verwijderen [Deleting]
Wassen [Washing]
Wekken [Awakening]
Wijzigen [Modifying]
Wreken [Avenging]
Wurgen [Strangling]
Xeroxen [Photocopying]
Xoipen [Sending over the internet]
Xeroxen [Photocopying]
Xoipen [Sending over the internet]
X-en [X-ing]
Yammeren [Yammering]
Yellen [Cheerleading]
Yielding [Calculating percentages of]
YouTube-streamen [YouTube-streaming]
Youtuben [YouTubing]
Zegenen [Blessing]
Zieken [Nagging]
Zien [Seeing]
Zoeken [Searching]
Zoenen [Making out with]

Adjectives:
Abstracte [Abstract]
Achterlijke [Morron]
Afrikaanse [African]
Amerikaanse [American]
Angstaanjagende [Scary]
Baby [Baby]
Blauwe [Blue]
Blote [Naked]
Boze [Angry]
Broze [Fragile]
Charmante [Charming]
Chinese [Chinese]
Chocolade [Chocolade]
Coole [Cool]
Corrupte [Corrupt]
Dagdromende [Daydreaming]
Dansende [Dancing]
Dikke [Fat]
Dode [Dead]
Dunne [Skinny]
Echte [Real]
Effectieve [Effective]
Elektrische [Electronic]
Enorme [Enormous]
Europese [European]
Felle [Bright]
Fictieve [Fictive]
Fietsende [Cycling]
Fluisterende [Whispering]
Fluitende [Whistling]
Gele [Yellow]
Glow-in-the-dark [Glow-in-the-dark]
Grijze [Grey]
Groene [Green]
Grote [Big]
Harige [Hairy]
Harde [Hard]
Homosexuele [Gay]
Horde [Troop of]
Hyperactieve [Hyperactive]
Idiote [Idiotic]
IJzere [Iron]
IJzige [Frosty]
Instelbare [Adjustable]
Ivoren [Ivory]
Jaloerse [Jealous]
Jammerende [Whining]
Japanse [Japanese]
Jokkende [Fibbing]
Jonge [Young]
Kale [Bald]
Kapotte [Broken]
Kleine [Little]
Knappe [Handsome]
Koude [Cold]
Lelijke [Ugly]
Lege [Empty]
Levende [Living]
Lopende [Walking]
Luie [Lazy]
Maffe [Weird]
Massieve [Massive]
Middeleeuwse [Medieval]
Milde [Mellow]
Mythische [Mythical]
Naakte [Naked]
Nachtelijke [Nocturnal]
Nare [Nasty]
Nucleaire [Nuclear]
Normale [Normal]
Ongelovige [Infidel]
Oranje [Orange]
Oude [Old]
Overheerdende [Prevailing]
Oxiderende [Oxidizing]
Paarse [Purple]
Platte [Flat]
Pratende [Talking]
Piraten [Pirate]
Puzzelende [Puzzling]
Quiteense [Female resident of the city of Quito]
Quad-rijdende [ATV-driving]
Quasi [Quasi]
Queue-stotende [(Billiard) cue thumping]
Quiche-etende [Quiche-eating]
Rennende [Running]
Rode [Red]
Romantische [Romantic]
Ronde [Round]
Roze [Pink]
Saaie [Boring]
Schattige [Cute]
Scherpe [Sharp]
Springende [Jumping]
Stoffige [Dusty]
Tongzoenende [French kissing]
Transformerende [Transforming]
Transparente [Transparent]
Treiterende [Tormenting]
Triomferende [Victorious]
Ultieme [Supreme]
Unieke [Unique]
Uniseks [Unisex]
Uiteenlopende [Various]
Uitmuntende [Outstanding]
Vage [Vague]
Verdrietige [Sad]
Vierkante [Square]
Vliegende [Flying]
Vrolijke [Jolly]
Warme [Warm]
Waterige [Aquatic]
Wijze [Wise]
Witte [White]
Wraakzuchtige [Vindicitive]
Xenofobische [Xenophobic]
Xhosa-sprekende [Xhosa-speaking]
XTC-verslaafde [XTC-addicted]
XXX [XXX]
Xylofoonspelende [Xylophone-playing]
Yahoo-zoekende [Yahoe-searching]
Yammerende [Yammering]
Yellende [Cheerleading]
YouTube-streamende [YouTube-streaming]
Youtubende [YouTubing]
Zachte [Soft]
Zingende [Singing]
Zwarte [Black]
Zwemmende [Swimming]
Zwevende [Floating]

Challenge rules:

You aren't allowed to use the same random noun twice in one sentence.
You have to take the license plate input either as string or array/list of characters. You can choose to input without delimiter however, so all these are valid input-formats: NN-CC-CC; NN CC CC; NN CCCC; NNCCCC; N N C C C C; etc.
The list of words can be in any reasonable format. Can be three separate lists; maps with the first letters as keys; one or multiple separate text files to read from; all possible. (You are allowed to take the input with or without the English translations added, as long as you output the Dutch sentence.)
Output can be printing to STDOUT or returning a string.
The lists above and the resulting sentences will only be in Dutch (with optionally the English translations added behind every word / the entire sentence).
NOTE: The original idea was to have the lists being part of the code, and @JonathanAllan suggested to use just Dutch instead of English, since there are quite a few languages with build-in English libraries. Later in the Sandbox, this switched to having the lists as input, and since I was already halfway through finishing the lists, I kept them Dutch. I've still added the English translations of each word in the list, so you can easily translate what your random output means.
Because all the nouns are plural, we can assume the numbers will be in the range 02-99.
The numbers 02-09 may be outputted with or without leading zero.
You are allowed to take the input license plate as lowercase instead of uppercase.

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code.
Also, please add an explanation if necessary.

Some possible test cases (but feel free to use your own as well).
71-NN-BT
80-XW-IK
13-UU-EF
12-AA-AA
99-ZX-YW
73-TH-QQ
04-DJ-IO

What are some of your favorite random sentences?

Somehow I can't believe those are the lists of words you used to use...

@Neil As a kid in the past you mean? You're probably right. X would always result in something with xylophones, since it was the only word with an X I knew as a kid. But when I created this list earlier this week I wanted to have 5 words of each letter for each noun, verb and adjective for the sake of this challenge (which was pretty hard to accomplish for some letters..) Some of those words with a Q or X I had never even heard of.. And some words would be inappropriate to know as a < 12 y.o. kid. :)

Jelly,  37  35 bytes
ṙ2X¤;⁸ṪW¤i’¥Ðḟ"⁹ṫ3¤ŒpŒQẠ$ÐfXK⁹ḣ2¤,K

A dyadic link taking a list of lists (of lists of characters): [[verbs],[adjectives],[nouns]] on the left and the numberplate (format = NNCCCC) on the right and returning a list of characters.
Try it online!
How?
ṙ2X¤;⁸ṪW¤i’¥Ðḟ"⁹ṫ3¤ŒpŒQẠ$ÐfXK⁹ḣ2¤,K - Link: list of lists of lists, words; list, plate
   ¤                                - nilad followed by link(s) as a nilad:
 2                                  -   literal two
  X                                 -   random integer in [1,z] -------- gets 1 or 2
ṙ                                   - rotate left by - words [v,a,n] -> [a,n,v] or [n,v,a]
        ¤                           - nilad followed by link(s) as a nilad:
     ⁸                              -   chain's left argument, words
      Ṫ                             -   tail - get the nouns
       W                            -   wrap in a list
    ;                               - concatenate - add another noun list to the end
                                    - (call this allWordLists) - either [a,n,v,n] or [n,v,a,n])
                  ¤                 - nilad followed by link(s) as a nilad:
               ⁹                    -   chain's right argument, plate
                 3                  -   literal three
                ṫ                   -   tail from index - get the four letters
                                    - (call this letters)
              "                     - zip with the dyadic operation:
            Ðḟ                      -   filter discard if:
           ¥                        -     last two links as a dyad:
         i                          -       first index of (a letter in a word in a wordList in allWordLists)
          ’                         -       decrement (if not found i yields 0, so this result is only 0 when the first index is the head of the list)
                                    - ...this gives us a list of lists of words beginning with the appropriate letters ordered either as [a,v,n,n] or [n,v,a,n]
                   Œp               - Cartesian product of the filtered lists
                         Ðf         - filter keep if:
                        $           -   last two links as a monad:
                     ŒQ             -     distinct sieve (1s at 1st occurrences, 0s elsewhere)
                       Ạ            -     all truthy - i.e. all distinct?
                           X        - random choice from the resulting list - get one four word choice
                            K       - join with spaces
                                ¤   - nilad followed by link(s) as a nilad:
                             ⁹      -   chain's right argument, plate
                               2    -   literal two
                              ḣ     -   head to index - get the two digits
                                 ,  - pair
                                  K - join with a space

Perl 5, 89 bytes
88 bytes code + 1 for -p.
Requires the numberplate to be in the format ## A A A A and the lists need to be formatted like ("A","B",...). If this is pushing the limits of acceptable, please let me know.
@$_=eval<>for n,v,a;s!\pL!(grep/^$&/,@{(rand>.5?(a,n,v,n):(n,v,a,n))[$-++]})[rand 5]!egi

Try it online!

JavaScript (ES6), 124 120 118 bytes
Takes input in currying syntax (s)(a) where s is a string in "NNCCCC" format and a is the array of arrays of words [nouns, verbs, adj].
s=>a=>s.replace(/\D/g,c=>' '+(g=a=>a.sort(R)[0][0]==c?a.shift(i/=4):g(a))(a[i&3]),i=(R=_=>Math.random()-.5)()<0?18:36)

Test cases

let f =

s=>a=>s.replace(/\D/g,c=>' '+(g=a=>a.sort(R)[0][0]==c?a.shift(i/=4):g(a))(a[i&3]),i=(R=_=>Math.random()-.5)()<0?18:36)

const NOUNS = ["Aanbeelden","Aardbeien","Apen","Appels","Auto's","Bananen","Bessen","Bloemen","Bomen","Bijen","Cadeaus","Cavia's","Cheerleaders","Circusdieren","Citroenen","Dinosaurussen","Dieren","Documenten","Doctoren","Dolfijnen","E-mails","Edelstenen","Eekhoorns","Enqûetes","Ezels","Fabrieken","Fietsen","Flessen","Fontijnen","Foto's","G-spots","Giraffen","Glazen","Gymschoenen","Gummen","Haaien","Homo's","Honden","Hoofden","Horloges","Idioten","Idolen","IJsklontjes","Illusies","Imperia","Jassen","Jokers","Jongleurs","Jurken","Juwelen","Kabels","Katten","Kauwgomballen","Knoppen","Konijnen","Leesboeken","Leeuwen","Legercommandanten","Lesbies","Lummels","Maagden","Mannen","Mensen","Mieren","Muren","Neuzen","Nieuwkomers","Nonnen","Noten","Nummerborden","Oceanen","Ogen","Olifanten","Oren","Orkanen","PC's","Pizza's","Politieagenten","Postbezorgers","Potloden","Quads","Quaggamosselen","Querulanten","Quiëtisten","Quizzen","Radio's","Ramen","Regiseuren","Rekenmachines","Relschoppers","Schepen","Slakken","Slangen","Stegosaurussen","Stoelen","T-rexen","Tafels","Theekopjes","Tijgers","Tovenaars","Uien","Uilen","Universa","Universiteiten","USB-sticks","Vliegtuigen","Vrachtwagens","Vrienden","Vrouwen","Vulkanen","Walvissen","Wespen","Wormen","Worstelaars","Wortels","X-assen","X-chromosomen","Xenonlampen","Xylofonen","Xylofonisten","Y-assen","Y-chromosomen","Yoghurtdranken","Yogaleraren","Yogaleraressen","Zeeën","Zeehonden","Zeepbellen","Zwanen","ZZP'ers"];
const VERBS = ["Accepteren","Activeren","Amputeren","Amuseren","Assisteren","Bakken","Bedreigen","Bellen","Bevruchten","Bijten","Castreren","Categoriseren","Centrifugeren","Claimen","Coachen","Dagvaardigen","Daten","Degraderen","Dienen","Dwarsbomen","Electroniseren","Eren","Erven","Eten","Exploderen","Factureren","Fokken","Föhnen","Fotographeren","Frituren","Gooien","Graderen","Grijpen","Groeperen","Groeten","Hacken","Hallucineren","Haten","Helpen","Huren","Importeren","Inspireren","Intelligente","Irriteren","Isoleren","Jagen op","Jatten","Jennen","Jongleren met","Justeren","Klonen","Koken","Kopen","Kraken","Kussen","Labelen","Leasen","Lonken","Loven","Lusten","Maken","Martelen","Merken","Meten","Mollen","Negeren","Neuken","Neutraliseren","Normaliseren","Notificeren","Observeren","Oliën","Ontbloten","Ontsmetten","Ordenen","Penetreren","Pesten","Plagen","Porren","Produceren","Quadrilleren met","Quadrupleren","Queruleren over","Quoteren","Quotiseren","Raadplegen","Redden","Reinigen","Ruilen","Roken","Schieten","Schoppen","Schudden","Slaan","Stoppen","Tackelen","Telen","Tellen","Temperen","Torpederen","Unificeren","Unlocken","Upgraden","Urineren","Utiliseren","Verbinden","Verjagen","Verkopen","Vermoorden","Verwijderen","Wassen","Wekken","Wijzigen","Wreken","Wurgen","Xeroxen","Xoipen","Xeroxen","Xoipen","X-en","Yammeren","Yellen","Yielding","YouTube-streamen","Youtuben","Zegenen","Zieken","Zien","Zoeken","Zoenen"];
const ADJECTIVES = ["Abstracte","Achterlijke","Afrikaanse","Amerikaanse","Angstaanjagende","Baby","Blauwe","Blote","Boze","Broze","Charmante","Chinese","Chocolade","Coole","Corrupte","Dagdromende","Dansende","Dikke","Dode","Dunne","Echte","Effectieve","Elektrische","Enorme","Europese","Felle","Fictieve","Fietsende","Fluisterende","Fluitende","Gele","Glow-in-the-dark","Grijze","Groene","Grote","Harige","Harde","Homosexuele","Horde","Hyperactieve","Idiote","IJzere","IJzige","Instelbare","Ivoren","Jaloerse","Jammerende","Japanse","Jokkende","Jonge","Kale","Kapotte","Kleine","Knappe","Koude","Lelijke","Lege","Levende","Lopende","Luie","Maffe","Massieve","Middeleeuwse","Milde","Mythische","Naakte","Nachtelijke","Nare","Nucleaire","Normale","Ongelovige","Oranje","Oude","Overheerdende","Oxiderende","Paarse","Platte","Pratende","Piraten","Puzzelende","Quiteense","Quad-rijdende","Quasi","Queue-stotende","Quiche-etende","Rennende","Rode","Romantische","Ronde","Roze","Saaie","Schattige","Scherpe","Springende","Stoffige","Tongzoenende","Transformerende","Transparente","Treiterende","Triomferende","Ultieme","Unieke","Uniseks","Uiteenlopende","Uitmuntende","Vage","Verdrietige","Vierkante","Vliegende","Vrolijke","Warme","Waterige","Wijze","Witte","Wraakzuchtige","Xenofobische","Xhosa-sprekende","XTC-verslaafde","XXX","Xylofoonspelende","Yahoo-zoekende","Yammerende","Yellende","YouTube-streamende","Youtubende","Zachte","Zingende","Zwarte","Zwemmende","Zwevende"];

console.log(f("71NNBT")([NOUNS, VERBS, ADJECTIVES]))
console.log(f("80XWIK")([NOUNS, VERBS, ADJECTIVES]))
console.log(f("13UUEF")([NOUNS, VERBS, ADJECTIVES]))
console.log(f("12AAAA")([NOUNS, VERBS, ADJECTIVES]))
console.log(f("99ZXYW")([NOUNS, VERBS, ADJECTIVES]))
console.log(f("73THQQ")([NOUNS, VERBS, ADJECTIVES]))
console.log(f("04DJIO")([NOUNS, VERBS, ADJECTIVES]))

How?
The sequences of lists to pick the words from are stored as bitmasks, in reverse order:
Noun, Verb, Adjective, Noun --> 0, 1, 2, 0 --> 00 01 10 00 --[reverse]--> 00100100 --> 36
Adjective, Noun, Verb, Noun --> 2, 0, 1, 0 --> 10 00 01 00 --[reverse]--> 00010010 --> 18

That's why i is randomly initialized to either 18 or 36.
s => a =>                           // given 's' and 'a'
  s.replace(                        // replace in 's'
    /\D/g, c =>                     // each non-digit character 'c' with:
    ' ' + (                         // a space followed by
      g = a =>                      // a word picked from the list 'a'
        a.sort(R)                   //   shuffle the list
        [0][0] == c ?               //   if the 1st char. of the 1st word is matching 'c':
          a.shift(i /= 4)           //     return this word (removing it from the list)
                                    //     and discard the 2 least significant bits of 'i'
        :                           //   else:
          g(a)                      //     try again with a recursive call
    )(a[i & 3]),                    // initial call to g() with the next list
    i = (                           // initialize 'i', using:
      R = _ => Math.random() - 0.5  //   R(): returns a random float in [-0,5, 0.5)
    )() < 0 ? 18 : 36               // to either 18 or 36 (see above)
  )                                 // end of replace()

Excel, 382 353 bytes
=D1&E1&" "&IF(RAND()>0.5,INDIRECT("C"&INT((CODE(F1)-64.8+RAND())*5))&" "&INDIRECT("A"&INT((CODE(G1)-64.8+RAND())*5))&" "&INDIRECT("B"&INT((CODE(H1)-64.8+RAND())*5)),INDIRECT("A"&INT((CODE(F1)-64.8+RAND())*5))&" "&INDIRECT("B"&INT((CODE(G1)-64.8+RAND())*5))&" "&INDIRECT("C"&INT((CODE(H1)-64.8+RAND())*5)))&" "&INDIRECT("A"&INT((CODE(I1)-64.8+RAND())*5))

Three lists in A, B and C respectively.  Numberplate characters in D1 -to- I1.  Formula in any other cell.
Golfing:

Last word will always be NOUN,
-14 bytes replacing ADDRESS with "A"&INT()
-14 bytes arithmetic(CODE(F1)-65)*5+RAND()*5+1 with (CODE(F1)-64.8+RAND())*5

Java (OpenJDK 8), 535 314 304 297 382 bytes
import java.util.*;
L->N->V->A->{int c=((int)(Math.random()*8))%2,i=0,f;String[]a=new String[4],b[]={A,N,V,N,N,V,A,N};for(;i<4;i++){List<String>p=new ArrayList();for(f=0;f<b[i+c*4].length;f++)if(b[i+c*4][f].charAt(0)==L.charAt(i+2)&&(i<3|!b[i+c*4][f].equals(a[1-c])))p.add(b[i+c*4][f]);a[i]=p.get((int)(Math.random()*p.size()));}System.out.print(L.substring(0,2)+" "+L.join(" ",a));}

Try it online!

You can still golf some more things: L->N->V->A-> can be (L,N,V,A)->; int j=i can be j=i when you add ,j to the other ints; the space j< 3 can be removed; some of those || can be | and && can be &; (c<0?!s.equals(a[1]):!s.equals(a[0])) can be !s.equals(c<0?a[1]:a[0]). Apart from that it looks like a great answer now that it's golfed from 535 to 314. :)

@Giuseppe I've fixed the previous problem but I can't deal with -xxx-, it's non-competing now

It seems to work now after your last edit. :) Now that it's working, let's get to some more golfing: TryItOnline: 365 bytes. Short summary of the changes: int variables inside for-loop; ArrayList to Stack; L->N->V->A-> to (L,N,V,A)->; removed parenthesis around (int)(Math.random()*8); Added int t to replace 4x i+c*4; && to &.

Love heart code <3

Python 3, 82 bytes
def f(l,d):print(l[:2],*map(lambda i,j:d[i][j].pop(),{'anvn','nvan'}.pop(),l[2:]))

Try it online!
Function taking a string l for the license plate and a dictionary d containing dictionaries with nouns, verbs and adjectives. These must be labeled 'n', 'v' and 'a', respectively.
In each of these dictionaries, the words are grouped and labeled by their first letter. Each key then contains a set of words. By using the set.pop() method to generate output, the chosen words are both random and non-duplicate.

Oh, I like the set.pop() approach! Very nice. :) I'm not entirely sure if the input method of the lists you've used is valid according to the meta though. It now looks like a snipper instead of program/function taking the lists as input(s)/argument(s). Regardless, nice answer.

@KevinCruijssen You are right concerning the input, this is indeed just a snippet. I'll update my code.

C#, 245 bytes
Random r=new Random();var a1=a[r.Next(0,a.Length)];var n1=n[r.Next(0,n.Length)];var n2=n[r.Next(0,n.Length)];var v1=v[r.Next(0,v.Length)];var m=r.Next(0,2)==0;Console.WriteLine($"{r.Next(0,10)}{r.Next(0,10)} {m?a1:n1} {m?n1:v1} {m?v1:a1} {n2}");

Surely not the shortest but it was fun to do so idc xD
Same code uncompacted (272 bytes):
Random r=new Random();
var a1 = a[r.Next(0, a.Length)];
var n1 = n[r.Next(0, n.Length)];
var n2 = n[r.Next(0, n.Length)];
var v1 = v[r.Next(0, v.Length)];
var m = r.Next(0, 2)==0;
Console.WriteLine($"{r.Next(0,10)}{r.Next(0,10)} {m?a1:n1} {m?n1:v1} {m?v1:a1} {n2}");

Currently is not a full program. Will do that tomorrow

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


text:
Make two numbers co-prime while preserving their least common multiple
Given two positive integers a and b, output two positive integers c and d such that:

c divides a
d divides b
c and d are co-prime
the least common multiple of c and d equals the least common multiple of a and b.

If there are more than one possible answers, you can output only one or all of them.
Test cases:
 a  b  c  d
12 18  4  9
18 12  9  4
 5  7  5  7
 3  6  1  6 or 3 2
 9  9  9  1 or 1 9
 6 15  2 15 or 6 5
 1  1  1  1

This is code-golf. Shortest answer in bytes wins.

What's to stop me returning (1, LCM)?

@Neil The requirement that d divides b

Maybe you should define LCM or at least not use the acronym.  I didn't know what was being asked for a bit.

Jelly, 21 13 bytes
ÆEz®0iṂ$¦€ZÆẸ

Try it online!

If a = 2A · 3B · 5C · … and b = 2α · 3β · 5γ · …, then we compute

c = 2A>α?A:0 · 3B>β?B:0 · 5C>γ?C:0 · …

d = 2A>α?0:α · 3B>β?0:β · 5C>γ?0:γ · …

Now lcm(c, d) = 2max(A>α?A:0, A>α?0:α) · … = 2max(A, α) · 3max(B, β) · … = lcm(a, b)
and gcd(c, d) = 2min(A>α?A:0, A>α?0:α) · … = 20 · 30 · 50 · … = 1.

In other words: start from (c, d) = (a, b). Then, for each prime, divide that prime all the way out of the factorization of either c or d: whichever has the smallest exponent for that prime. (In this implementation, in case of a tie, c loses its exponent.)
So if a = 2250 = 21 · 32 · 53 and b = 360 = 23 · 32 · 51,
then c = 20 · 30 · 53 = 125 and d = 23 · 32 · 50 = 72.
Jonathan Allan golfed down a whopping 8 bytes! Thank you~

This is my original algorithm... The Perl algorithm is better.

Very nice. Here it is in 12 bytes

Here's another 12 byter ÆEZ×Ụ’$€$ZÆẸ

This now gives [1,18] for [15,18]. The initial version was returning the correct answer ([5,18]).

@JonathanAllan Any idea why? (I’ll revert to 21B for now.)

Ah - yes we'd need a filler of zero on the transpose. ÆEz®0iṂ$¦€ZÆẸ should do the trick for 13.

No need for ® btw. ÆEz00iṂ$¦€ZÆẸ works just as well.

R, 143 139 123 bytes
f=function(a,b,q=1:(a*b))for(i in 1:a)for(j in 1:b)if(!a%%i+b%%j&max(q[!i%%q+j%%q])<2&i*j==min(q[!q%%a+q%%b]))cat(i,j,"\n")

(Thanks to @Giuseppe for those 19 bytes off!)
With indentations, newlines and some explanations:
f=function(a,b,
           q=1:(a*b)) #Defined as function arguments defaults to avoid having to use curly brackets
    for(i in 1:a)
        for(j in 1:b)
            if(!a%%i + b%%j & #Is a divided by c and b divided by d
               max(q[!i%%q+j%%q])<2 & #Are c and d coprimes
               i*j==min(q[!q%%a+q%%b])) #Is this the same lcm
                   cat(i,j,"\n") #Then print

Test cases:
> f=function(a,b,q=1:(a*b))for(i in 1:a)for(j in 1:b)if(!a%%i+b%%j&max(q[!i%%q+j%%q])<2&i*j==min(q[!q%%a+q%%b]))cat(i,j,"\n")
> f(5,7)
5 7
> f(12,18)
4 9
> f(6,15)
2 15
6 5
> f(1,1)
1 1

! has higher precedence than & and | but lower than + and *; you should be able to golf down a few bytes that way; i.e., !i%%q&j%%q should be equivalent to !i%%q+j%%q

Okay well observation: if GCD(c,d)==1, then LCM(c,d)==c*d. So we can test GCD(c,d)==1 and then check if c*d==a*b/GCD(a,b) since the latter is LCM(a,b)...

Indeed! (though calculating a*b/GCD(a,b) is not shorter than LCM(a,b)).

120 bytes -- anonymous function + literal newline for -3 bytes

Husk, 10 bytes
→ÖF§-⌋⌉ΠmḊ

Brute force. Takes and returns lists, and works for more than two numbers too. Try it online!
Explanation
→ÖF§-⌋⌉ΠmḊ  Implicit input, say [6,15]
        mḊ  Map divisors: [[1,2,3,6],[1,3,5,15]]
       Π    Cartesian product:[[1,1],[2,1],[1,3],[2,3],[3,1],[1,5],[3,3],[6,1],[1,15],[2,5],[3,5],[6,3],[2,15],[6,5],[3,15],[6,15]]
 Ö          Sort by
  F         reduce by
     ⌉      lcm
   -⌋       minus gcd: [[1,1],[3,3],[2,1],[1,3],[3,1],[6,3],[1,5],[2,3],[6,1],[2,5],[3,15],[1,15],[3,5],[6,15],[2,15],[6,5]]
→           Get last element: [6,5]

Mathematica, 82 bytes
#&@@Select[Subsets[Flatten@Divisors[{t=#,r=#2}],{2}],GCD@@#==1&&LCM@@#==t~LCM~r&]&

I am not sure, but could you not use list indexing Select[...][[1]] instead of First@Select[...] to save a byte?

yes, but then I could use #&@@ instead of [[1]] to save one more ;-)

MATL, 17 16 bytes
&YFt&X>2:!=*^!Xp

Try it online!
Same method as Lynn's Jelly solution
It's been a while since I've used any MATL (or matlab for that matter) so many improvements are likely possible.

JavaScript (ES6), 90 84 80 bytes
Takes input in currying syntax (a)(b) and returns an array of 2 integers.
a=>g=(b,c=1)=>(G=(a,b)=>b?G(b,a%b):a)(c,d=a*b/G(a,b)/c)-1|a%c|b%d?g(b,c+1):[c,d]

Test cases

let f =

a=>g=(b,c=1)=>(G=(a,b)=>b?G(b,a%b):a)(c,d=a*b/G(a,b)/c)-1|a%c|b%d?g(b,c+1):[c,d]

console.log(JSON.stringify(f(12)(18))) // [ 4,  9 ]
console.log(JSON.stringify(f(18)(12))) // [ 9,  4 ]
console.log(JSON.stringify(f( 5)( 7))) // [ 5,  7 ]
console.log(JSON.stringify(f( 3)( 6))) // [ 1,  6 ] or [ 3, 2 ]
console.log(JSON.stringify(f( 9)( 9))) // [ 9,  1 ] or [ 1, 9 ]
console.log(JSON.stringify(f( 6)(15))) // [ 2, 15 ] or [ 6, 5 ]
console.log(JSON.stringify(f( 1)( 1))) // [ 1,  1 ]

How?
a =>                            // a = first input
  g = (                         // g = recursive function that takes:
    b,                          //   b = second input
    c = 1                       //   c = first output divisor, initially set to 1
  ) =>                          //
    (G = (a, b) =>              // G = function that takes a and b
      b ? G(b, a % b) : a       //     and returns the greatest common divisor
    )(                          // we call it with:
      c,                        //   - c
      d = a * b / G(a, b) / c   //   - d = LCM(a, b) / c = a * b / GCD(a, b) / c
    ) - 1 |                     // if the result is not 1 (i.e. c and d are not coprime)
    a % c |                     // or c does not divide a
    b % d ?                     // or d does not divide b:
      g(b, c + 1)               //   do a recursive call with c + 1
    :                           // else:
      [c, d]                    //   return [c, d], a valid factorization of the LCM

Haskell, 50 48 47 45 42 bytes
(?)=gcd;a!b|c<-div a$a?b=(c*c?b,div b$c?b)

Idea: I noticed that c*d = a*b/gcd(a,b). So the algorithm performs two steps:

Begin with c' = a/gcd(a,b) and d' = b. This fulfils all requirements except that c' and d' have to be co-prime.
To make them co-prime, I calculate e = gcd(c',d') and then set c = c'*e and d = d'/e. This keeps all properties (since the combined factors stay the same), but since I remove all shared factors from d, I make cand d coprime.

In my implementation, c' is just called c.
Try it online!
-3 bytes thanks to Laikoni

Using a pattern guard to bind c saves 3 bytes: Try it online!

@Laikoni Ooh, I didn't even know that trick. Thanks!

05AB1E, 12 bytes
Ñ`âʒ.¿I.¿Q}н

Try it online!
or as a Test suite

Still a brute-force :c

@LeakyNun: Yeah, there's probably a mathier way to do this :)

Haskell, 91 74 bytes
a!b=[(x,y)|x<-[1..a],y<-[1..b],rem a x+rem b y+gcd x y<2,lcm a b==lcm x y]

Try it online!
Saved 17 bytes thanks to Laikoni

u*v`div`gcd u v saves a byte.

Is there any reason not to use the built-in lcm function?

Also rem a x+rem b y+gcd x y<2 should work.

@Laikoni a very good reason:  I didn't even know the builtin lcm existed. rem a x+rem b y+gcd x y<2 works, and I wonder if rem a x+rem b y+gcd x y+lcm a b-lcm x y<2 works. There is maybe a (mathematical) guarantee that lcm a b>=lcm x y.

Indeed, lcm a b>=lcm x y because 1. x=x1*...*xi (prime decomposition), y=y1*...yj, lcm x y=z1*...*zk where z1,...,zk are common to x1,...,xi and y1,...,yj. 2. a=u1*...*um*x1*...*xi (prime decomposition), b=v1*...vn*y1*...yj, lcm a b=t1*...*tl where t1,...,tl are common to u1*...*um*x1*...*xi and v1*...vn*y1*...yj. It's  obvious that t1,...,tl contains z1,...,zk, thus lcm a b>=lcm x y. But that's not useful for writing the condition as a sum.

R, 126 bytes
function(a,b,g=function(x,y)ifelse(o<-x%%y,g(y,o),y),l=a*b/g(a,b))matrix(c(C<-(1:l)[!l%%1:l],D<-l/C),,2)[g(C,D)<2&!a%%C+b%%D,]

Try it online!
This takes a different (and apparently less golfy) approach to finding the values than the other R answer.
Explanation:
function(a,b){
 G <- function(x,y)ifelse(o<-x%%y,G(y,o),y) #gcd function, vectorized for x,y
 l <- a*b/g(a,b)                            #lcm of a,b
 C <- (1:l)[!l%%1:l]                        #divisors of l
 D <- l/C                                   #l/C is the other half of the pair
 rel_prime <- G(C, D) < 2                   #pairs where C,D are relatively prime, lol, GCD
 a_div <- !a%%C                             #divisors of a
 b_div <- !b%%D                             #divisors of b
 C <- C[rel_prime & a_div & b_div]
 D <- D[rel_prime & a_div & b_div]          #filter out the bad pairs
 matrix(c(C,D),,ncol = 2)                   #matrix of pairs, returned
}

except I shoehorn all the definitions as default arguments and do all the calculations on one line for the golfiness.

J, 19 bytes
(*/:"1)&.|:&.(_&q:)

Try it online!
Based on @Lynn's solution.
Explanation
(*/:"1)&.|:&.(_&q:)  Input: [a, b]
              _&q:   Get exponenets of each prime
         |:&         Transpose
  /:"1 &             Grade each row
 *                   Multiply elementwise
       &.|:          Transpose
           &. _&q:   Convert exponents back to numbers

Python 2, 75 bytes
def f(x):n=1;exec'n+=1;j=k=1\nwhile x[j]%k<1:k*=n**j;j^=1\nx[j]/=k/n;'*x[0]

Input is taken as a list, which the function modifies in place.
Try it online!

Python 3, 129 bytes
lambda a,b:[[c,d]for c in range(1,-~a)for d in range(1,-~b)if((gcd(c,d)<2)*a*b/gcd(a,b)==c*d/gcd(c,d))>a%c+b%d]
from math import*

Try it online! or Try the test suite.
Outputs all possible combinations in  the form of a nested list.

You and your bitwise stuff... -~a and -~b can just be rewritten as a+1 and b+1 for readability :P

@Stephen As you can see, I specialize in [tag:obfuscation]

Doesn't work for my newly added second testcase.

@LeakyNun Rolled back. Didn't have time to check the validity of the golf.

Jelly,  19 15  14 bytes
-4 with pointer from Leaky Nun (use divisor built-in)
I am almost 100% certain this is not the way to actually do this one, but here is a first attempt.
Let's see who outgolfs it with a seven or eight byter!
Yep... see Lynn's answer with explanation!
g/÷æl/
ÆDp/ÇÐṂ

A monadic link taking a list of the two numbers and returning a list of lists of the possibilities.
Try it online!
How?
g/÷æl/  - Link: gcd divided by lcm: list [x, y]
g/      - reduce by gcd = gcd(x, y)
   æl/  - reduce by lcm = lcm(x,y)
  ÷     - divide

ÆDp/ÇÐṂ - Main link: list [a, b]    e.g. [160, 90]
ÆD      - divisors (vectorises)          [[1,2,4,5,8,10,16,20,32,40,80,160],[1,2,3,5,6,9,10,15,18,30,45,90]]
  p/    - reduce by Cartesian product    [[1,1],[1,2],...,[1,90],[2,1],[2,2],...,[2,90],....,[160,90]]
     ÐṂ - entries for which this is minimal:
    Ç   -   call the last link (1) as a monad

Let's see who outgolfs it with a seven or eight byter! - Don't think so...

You think six? ...FIVE?!

:P No... I don't think less than ~13-15 is possible (Dennis would disagree, of course!)

Divisor built-in?

Yeah ÆD but (shrug) brain obviously not in gear...

@LeakyNun - thanks, I'm still of the mind there will be a clever trick :)

@JonathanAllan of course there is, but up till now everybody has been using brute force

@LeakyNun That's probably not what Jonathan meant...

Let's see who outgolfs it with a seven or eight byter! with two numbers both extending to infinity? don't think so

Python 2 + sympy, 148 bytes
from sympy import*
a,b=input()
c=d=z=1
while(a/c*c+b/d*d<a+b)+gcd(c,d)-1+(lcm(c,d)!=lcm(a,b)):E=c==d==z;Q=c==z;d=+E or Q+d;c=+Q or-~c;z+=E
print c,d

Try it online!
-1 thanks to Jonathan Frech.
This answer works in Python 2 (not Python 3), using sympy.gcd and sympy.lcm instead of math.gcd and math.lcm which are only available in Python 3. And yes, this is brute force :)

Golfing in progress...

You may be able to save a byte by defining Q=c==z; (+7 bytes) at the start of the while loop and replacing or(c==z)+d with or Q+d (-4 bytes) and c=+(c==z)or with c=+Q or (-4 bytes). (TIO)

Just as a question, are you using the + operator in d=+E or c=+(c==z) to convert a boolean into an integer?

@JonathanFrech Yes I am, since you can't use True and False instead of 1 and 0 in sympy.

That is the first instance I ever saw where the vanilla +... has any use.

@JonathanFrech Probably has no use in real life though...real life code should be clear, e.g. 1 if condition else 0...however some things may be to be thought of as -x, 0, +x instead of -x, 0, x, and that's where + strikes in for clarity

You can probably also operator overload it on your own classes; though I have not yet found any real use for it there either.

05AB1E, 32 26 24 22 20 19 bytes
Ó0ζεD`›0sǝ}øεā<ØsmP

Try it online! I still have no idea how to write in this language, but at least it's not a brute-force algorithm. Explanation:
Ó                       Get exponents of prime factors (vectorised)
 0ζ                     Zip, filling with 0
   ε      }             For each prime
    D`                  Extract the pair of exponents
      ›0sǝ              Overwrite the smaller with 0
           ø            Zip back into two lists of prime exponents
            ε           For each list (} implied)
             ā<Ø        Get a list of primes
                sm      Raise each prime to the exponent
                  P     Take the product

What’s it doing?

Same as yours, but by actually factorising and comparing the exponents and recombining the factors.

PARI/GP, 86 bytes
This just does what Lynn says in her answer:
f(a,b)=forprime(p=2,a*b,v=valuation(a,p);w=valuation(b,p);if(w<v,b/=p^w,a/=p^v));[a,b]

If I do not count the f(a,b)= part, it is 79 bytes.

Jelly, 13 bytes
Ụ€’×
ÆEz0ÇZÆẸ

Try it online! My first Jelly answer! Edit: ÆEz0µỤ€’×µZÆẸ also works for 13 bytes. Explanation:
ÆE              Get prime factor exponents of both values (vectorises)
  z0            Zip but fill the shorter array with 0
    µ           New monadic link
     Ụ€         Grade up each pair (1-indexed)
       ’        Convert to 0-indexing (vectorises)
        ×       Multiply each pair by its grade (vectorises)
         µ      New monadic link
          Z     Zip back into separate lists of prime factor exponents
           ÆẸ   Turn prime exponent lists back into values (vectorises)

Perl 6, 72 bytes
{([X] map {grep $_%%*,1..$_},@^a).grep:{([lcm] @a)==([lcm] $_)==[*] $_}}

Try it online!
Takes a list (a, b). Returns a list of all possible lists (c, d).
Explanation:
-> @ab {
    # Generate all pairs (c, d)
    ([X]
         # where c divides a and d divides b.
         map { grep $_%%*, 1..$_ }, @ab)
    # Only keep pairs with lcm(a, b) = lcm(c, d) and lcm(c, d) = c * d.
    # The latter implies gcd(c, d) = 1.
    .grep: { ([lcm] @ab) == ([lcm] $_) == [*] $_ }
}

Python 2, 126 121 bytes
def f(a,b):
 c=[1,1];p=2
 while p<=a*b:
	t=m=1
	while(a*b)%p<1:m*=p;t=b%p<1;a/=p**(a%p<1);b/=p**t
	p+=1;c[t]*=m
 return c

Try it online!


text:
Dizzy integer enumeration
Your challenge today is to output a given term of a sequence enumerating all of the integers. The sequence is as follows: If we have a 0-indexed function generating the sequence f(n) and ceil(x) is the ceiling function, then f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n)) is positive when n and ceil(n/2) are either both even or both odd.
To help understand this sequence, the first few terms are as follows: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...
Your task is to write a program to that takes an integer n and outputs the nth term of the sequence. Input may be 0 or 1-indexed only.
Test cases (0-indexed):
0  =>  0
1  =>  1
2  => -1
3  => -2
4  =>  2
5  =>  3

This is code-golf, fewest bytes wins!

Related: Print all integers

It seems the inverse of a Folding function

SOGL V0.12, 8 6 bytes
I».»⌡±

Try it Here! or try the first couple numbers (changed a bit so it'd work)
0-indexed.
Explanation:
I       increment the input
 »      floor divide by 2
  .     push the original input
   »    floor divide by 2
    ⌡   that many times
     ±    negate

Or simpler:
(input + 1) // 2 negated input // 2 times
        I     »     ±      .     »    ⌡

IT DIDN'T TAKE A SINGLE MINUTE!

I ».» am on the phone I».»⌡±.

@JonathanAllan I don't get it ._.

Python 2, 26 24 bytes
lambda x:-~x/2/(1-(x&2))

Try it online!

You could save a byte using -~-(x&2) for the final denominator.

JavaScript (ES6), 18 bytes
1-indexed.
n=>n/(++n&2||-2)|0

Demo

let f =

n=>n/(++n&2||-2)|0

for(n = 1; n < 20; n++) {
  console.log(n + ' --> ' + f(n))
}

Jelly, 6 bytes
HµĊN⁸¡

Try it online!
Uses dzaima's algorithm.
-1 thanks to Jonathan Allan.

SOGL can't be beating Jelly...? Will look into golfing.

@JonathanAllan duh >_<

Haskell, 26 bytes
f x=div(x+1)2*(-1)^div x 2

Try it online!
The other Haskell answers seem to be overcomplicating things… ^^

C, 25 bytes
f(n){return~n/2*~-(n&2);}

You can save 4 bytes by assigning your return value to the first paramter instead of using the keyword return. f(n){n=~n/2*~-(n&2);}

@cleblanc That's not how C works.

gcc -O0 for x86-64 does happen to compile @cleblanc's version to instructions that happen to leave the multiply result in eax (https://godbolt.org/g/dztKPV), but then it would be an x86-64 gcc -O0 answer, not a C answer.  I don't up-vote C answers that break with optimization enabled, especially not that stupid last expression as return-value crap.  Even if that's how gcc happens to work, that's not how C works.

Make n a pointer. You don't need optimizations if the original and final values aren't on the stack.

@mreff555 That would be a non-standard (although acceptable) IO method, and wouldn't be any shorter.

Pyke, 6 bytes
heQeV_

Try it here!
Uses dzaima's approach... Beats Ties Jelly!
Explanation
h      - Increment the input, which is implicit at the beginning.
 e     - Floor halve.
  Q    - Push the input.
   e   - Floor halve.
    V_ - Apply repeatedly (V), ^ times, using negation (_).
       - Output implicitly.

The hex-encoded bytes equivalent would be: 68 65 51 65 56 5F.

05AB1E, 6 bytes
;DîsF(

Try it online!
Uses dzaima's algorithm.

Java 8, 15 bytes
n->~n/2*~-(n&2)

EDIT: Is Java really the shortest of the non-golfing languages?! o.Ô
Explanation:
Try it here.
I'll use the table below as reference of what's happening.

~n is equal to -n-1.
Since integer division in Java automatically floors on positive integers and ceils on negative integers, ~n/2 will result in the sequence 0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
n&2 will result in either 0 or 2, in the sequence 0,0,2,2,0,0,2,2,0,0,2,...
~-x is equal to (x-1), so ~-(n&2) (((n&2)-1)) results in the sequence -1,-1,1,1,-1,-1,1,1,-1,-1,1,...
Multiplying the two sequences of ~n/2 and ~-(n&2) gives is the correct sequence asked in the challenge: 0,1,-1,-2,2,3,-3,-4,4,5,-5,...

Overview table:
n       ~n      ~n/2    n&2     ~-(n&2)     ~n/2*~-(n&2)
0       -1      0       0       -1          0
1       -2      -1      0       -1          1
2       -3      -1      2       1           -1
3       -4      -2      2       1           -2
4       -5      -2      0       -1          2
5       -6      -3      0       -1          3
6       -7      -3      2       1           -3
7       -8      -4      2       1           -4
8       -9      -4      0       -1          4
9       -10     -5      0       -1          5
10      -11     -5      2       1           -5

Haskell, 25 43 42 bytes
((do a<-[0..];[[-a,a],[a,-a]]!!mod a 2)!!)

Try it online! 1-indexed.
Edit: The previous version had the signs in a wrong order, thanks to @Potato44 for pointing out. Fixed for 18 bytes ...
Edit 2: Thanks to BMO for -1 byte!

You can save 1 byte by using do-notation, try it online!

Mathematica, 24 bytes
(s=⌈#/2⌉)(-1)^(#+s)&

-14 bytes from @Misha Lavrov

Using Boole and OddQ has the effect of converting odd numbers to 1 and even numbers to 0, but you don't need that here: powers of -1 give you the right answer for all odd numbers anyway. So you can cut down that step to (-1)^Tr@{#,s} or just (-1)^(#+s).

Python 2, 21 bytes
lambda x:-x/2*~-(x&2)

Try it online!

Python 3, 29 bytes
lambda n:-~n//2*(-1)**(n%4>1)

Try it online!

(-1)**(n%4>1) is a rather convoluted way of writing (1-(n&2)) ;)

Pyth, 9 bytes
_F/hQ2/Q2

Try it here!
Uses dzaima's approach.

Batch, 29 bytes
@cmd/cset/a"%1/2^(%1<<30>>30)

Haskell, 36 bytes
g x=x: -x:g(-x-signum x)
((0:g 1)!!)

Try it online!

Brain-Flak, 86 74 72 70 bytes
{({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}<>{}{<>([{}])(<>)}<>

Try it online!
Explanation
There are two parts to this code.  The first part
({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}

does the brawn of the computation.  It determines ceil(n/2) and whether or not to negate the output.
To explain how it works I will first explain how one would calculate ceil(n/2).  This could be done with the following code
{({}[()]<({}([{}]()))>)}{}

This counts down from n each time it performs a not (([{}]())) on a counter and adds the counter to a result.  Since the counter is zero half the time we only increment every other run starting with the first one.
Now I want to also compute the sign of our results.  To do this we start another counter.  This counter only changes state if the first counter is off.  That way we get the desired pattern.  We put these two counters on the off stack to ease with moving them around when the time comes.
Now once we have finished that computation our stack looks like this
          parity(n)
ceil(n/2) sign

So we need to do some work to get the intended result this second part does it.
<>{}{<>([{}])(<>)}<>

JavaScript (ES6), 18 bytes

f=
n=>n/2^(n<<30>>30)
<input type=number min=0 value=0 oninput=o.textContent=f(this.value)>
0

0-indexed.

Javascript, 17 bytes
n=>~n/2*~-(n&2)^0

f=
n=>~n/2*~-(n&2)^0
<input type=number min=0 value=0 oninput=o.textContent=f(this.value)>
0

This one is 0 indexed.  It's entirely bitwise trickery.

dc, 16 bytes
1+d2~+2%2*1-r2/*

I am sure there's a way to make 0..1 to -1..1 in dc shorter, but no ideas for now.
Try it online!

Cubically, 23 bytes
(1-indexed)
FDF'$:7+8/0_0*0-8*7/0%6

Try it online!
The main difficulty when writing code in Cubically are:

There is only 1 write-able variable, and
Get constants is hard.

So, this solution calculate
((((n+1)/2)%2)*2-1)*n/2

where / denotes integer division. That only need 1 temporary variable, and constants 1 and 2.
Explanation:
FDF'$:7+8/0_0*0-8*7/0%6
FDF'                      Set face value of face 0 to 2, and value of memory index 8 (cube is unsolved) to 1 (true = unsolved)
    $                     Read input
     :7                                 input
       +8                                + 1
         /0                        (        ) /2
           _0                     (             ) %2
             *0                  (                  ) *2
               -8                                        -1
                 *7             (                          ) *n
                   /0                                          /2
                     %6   Print

TI-Basic (TI-84 Plus CE), 20 bytes
‾int(‾Ans/2)(1-2remainder(int(Ans/2),2

A full program that is called like 5:prgmNAME.
TI-Basic is a tokenized lanugage, all tokens used here are one byte, except for remainder( which is two. ‾ represents the regative token, which is typed with the (-) key.
Examples:
0:prgmNAME
 => 0
1:prgmNAME
 => 1
2:prgmNAME
 => -1
#etc

Explanation:
‾int(‾Ans/2)(1-2remainder(int(Ans/2),2
‾int(‾Ans/2)                           # -int(-X) is ciel(X), so ciel(Ans/2)
                          int(Ans/2)   # int(X) is floor(X), so floor(Ans/2)
                remainder(int(Ans/2),2 # 1 if floor(Ans/2) is odd else 0
            (1-2remainder(int(Ans/2),2 # -1 if floor(Ans/2) is odd, else 1
_int(_Ans/2)(1-2remainder(int(Ans/2),2 # -ciel(Ans/2) if floor(Ans/2) is odd, else ciel(Ans/2)

Same formula as a Y-var function:
Y1= ‾int(‾X/2)(1-2remainder(int(X/2),2

Perl 5, 32 + 1 (-p) = 33 bytes
$_='-'x(($_+++($b=0|$_/2))%2).$b

Try it online!

Proton, 23 bytes
n=>-~n//2//(-1)**(n//2)

Try it online!
Port of Halvard's solution.
Proton, 23 bytes
n=>-~n//2*(-1)**(n%4>1)

Try it online!
Port of Leaky's solution.
A bit more Protonic, 24 bytes:
n=>-~n//2*(**)(-1,n%4>1)

Clojure  122 bytes
Verbose, even when golfed. I'm going for the sympathy vote here... :-)
Golfed:
(defn d[n](let[x(int(Math/ceil(/ n 2)))y(cond(or(and(even? n)(even? x))(and(odd? n)(odd? x)))(Math/abs x):else(- 0 x))]y))

Ungolfed:
(defn dizzy-integer [n]
  (let [x   (int (Math/ceil (/ n 2)))
        y   (cond
                (or (and (even? n) (even? x))
                    (and (odd? n)  (odd? x))) (Math/abs x)
                :else (- 0 x)) ]
    y))

Excel VBA 32-Bit, 39 37 Bytes
Anonymous VBE immediate window function that takes input from cell A1 and outputs to the VBE immediate window
?[Sign((-1)^Int(A1/2))*Int((A1+1)/2)]

Restricted to 32-Bit as A^Bis not valid in 64-Bit (A ^B is as close as can be achieved)

Is the space between (-1) and ^[Int needed?

@Pavel at least for the 64-Bit Version of Excel VBA, yes; But that said I swear that it does not for the 32-Bit Version, but alas I cannot test that on any of the hardware I have on hand

@Pavel - I've looked at it under a 32-Bit System (default install spec) and under that system the space is not required - I have restricted the solution to 32-Bit to take advantage of this

Cool! You forgot to add in the corrected byte count though.

Whoops, Thanks @Pavel - Its fixed now

QBIC, 27 26 bytes
g=(:+1)'\2`~(a-g)%2|?-g\?g

Explanation
g=          set worker var 'g' to
(:+1)           our index (plus one for the ceil() bit)
'\2`            integer divided by 2 (the int div needs a code literal: '..`
~(a-g)%2    IF index - temp result is odd (index 2 minus result 1 = 1)
|?-g        THEN PRINT g negated
\?g         ELSE PRINT g

Julia 0.6, 16 bytes
It's just the java solution except I need ÷ for integer division.

n->~n÷2*~-(n&2)

Try it online!

Husk, 9 bytes
!m?I_%2İZ

Try it online!
1-indexed.
Explanation
!m?I_%2İZ
       İZ List of all integers (builtin) [0,1,-1,2,-2,...]
 m        map to the following function
  ?  %2   if the number is even,
    _     negate it.
   I      otherwise return it
!         find element at input index

Alternate solution, 9 bytes
!⌊½¹¡_⌊½→

Try it online!
Uses the same equation as the SOGL answer.

Japt, 8 bytes
z°U&2ªJÑ

Try it

Factor, 28 bytes
[ dup 1 + 2/ -1 rot 2/ ^ * ]

Try it online!
Explanation
\$\large f(n)=\left\lfloor\frac{n+1}{2}\right\rfloor\times-1^\left\lfloor\frac{n}{2}\right\rfloor\$
         ! 6
dup      ! 6 6
1        ! 6 6 1
+        ! 6 7
2/       ! 6 3
-1       ! 6 3 -1
rot      ! 3 -1 6
2/       ! 3 -1 3
^        ! 3 -1
*        ! -3


text:
Evaluate an expression of minus and tilde
Given an expression matching the regex /^[-~]*x$/, evaluate it in terms of x and output a string matching the regex /^-?x[+-]\d+$/.
For example, the string -~x evaluates to x+1, while the string -~-x evaluates to -x+1, and the string -~-~--x evaluates to x+2.
We start from x and evaluate the string right to left. - negates the term, while ~ converts y to -y-1.
Testcases:
    x  x+0
   ~x -x-1
  -~x  x+1
 ~-~x -x-2
-~-~x  x+2
--~~x  x+0
  ~-x  x-1
 -~-x -x+1

This is code-golf. Shortest answer in bytes wins.
The input/output format is strict. The "x" is mandatory.

Can we output x+010 instead of x+10 for -~-~-~-~-~-~-~-~-~-~x? It matches the second regex.

You can, though I see no reason why.

And can we take input as a list of chars, or we must take a string?

@ThePirateBay you can take input as a list of characters, which is equivalent to a string.

The input/output format is strict. - Can we change "x" to "Z", though?

@Mr.Xcoder you can't :P

The tilde has different meaning in different languages. You should probably clarify that you intend the Python meaning

@LuisMendo read the last sentence of my third paragraph

related

@LeakyNun Ah, sorry, I didn't see that. Anyway, I think it should appear earlier on. The first two paragraphs and part of the third talk about ~ while it hasn't been defined

Suggested test case: -~-x => -x+1

@EriktheOutgolfer done.

Python 2, 42 41 39 bytes
lambda s,x=0:'-x%+d'[len(s)%2:]%eval(s)

Try it online!

Retina, 47 44 bytes
+`--|~~

((~)|-)*x
$&+$#2
T`+`-`^~.*
~
-
--

Try it online! Edit: Saved 3 bytes thanks to @MartinEnder. Expanation:
+`--|~~

Delete pairs of adjacent duplicates.
((~)|-)*x
$&+$#2

Count the number of ~s which gives us the magnitude of the term.
T`+`-`^~.*

If the first character is a ~ then the term should be negative.
~
-
--

If the number of ~s and -s is odd then the x should be negative.

JavaScript, 59 bytes
x=>['-'[x.length&1]]+'x'+['+'[(x=eval(x.join` `))<0^0]]+~~x

Try it online!

Beat me by 16 secs and 38 bytes. Well done.

Fails for test cases containing multiple - in a row. (i.e. --~-~x)

@Luke. I'm not sure what do you mean. My script works for these test cases too.

This survives my new testcase :D

@ThePirateBay: oops, nvm then...

PowerShell Core, 102 bytes
$s=-1
switch -r($args[$args.Count..0]){.{$a=-$a;$s=-$s}~{$a--}}"$s`x+$a"|% *ce '+-','-'|% *ce '1x','x'

Try it online!
Passes an expression as a string using splatting
Then processes it from right to left
For each char, negate $s and $a, and if the char is ~ , decrement $a
Then concatenate them all: $s + "x+" + $a
Replace +- with -
Remove the useless 1 before x

C (gcc), 69 bytes
a;s;f(char*p){for(a=s=0;*p;a-=*p++%5*~-s)s^=2;printf("-x%+d"+!!s,a);}

Try it online!
-1 byte thanks to @ThePirateBay

Perl 5, 75 + 1 (-n)= 76 bytes
map{$y=-$y;$y--if/~/}reverse/-|~/g;printf"%sx%+d",((-1)**y/-~//)=~s/1//r,$y

Try it online!

Ruby, 36 bytes
Port of user48543‘s Python answer.
->s{x=0
"-x%+d"[s.size%2..]%eval(s)}

Attempt This Online!

><> (Fish), 91 79 bytes
Was producing incorrect output, but for a change fixing this actually saved me bytes.
10>i:'-'=?v:'~'=?vv
 .\r*-10r~<1-@:$~/~
d3/"+"on; .3dv?(0r/
;n^?)-10:o"x"\"-"o/

Try this

Significantly harder to parse in reverse order. Basically produce a expression of the form ax + b

For a -, set a to -a.
For a ~, set b to b-a, then re-use the same code to set a to -a.

Rest of the code is printing the solution. Special cases for printing the - in front of x and needing a + if the extra number is not negative.

Java 8, 186 168 167 bytes
s->{s=s.replaceAll("--|~~","");int l,i=s.length()-(l=(s=s.replace("-~","")).length())>>1;return(l-(s=s.replace("~","")).length()>0?"-"+s+~i:s+"+"+i).replace("--","");}

Definitely room for improvements..
-1 byte thanks to @ceilingcat replacing (a-b)/2 with a-b>>1.
Try it online.
Explanation:
s->{                            // Method with String as both parameter and return-type
  s=s.replaceAll("--|~~","");   //  Remove all "--" and "~~"
  int l,                        //  Temp integer to reduce bytes
      i=s.length()-(l=(s=s.replaceAll("-~","")).length())>>1;
                                //  Remove all "-~" and save count in `i`
  return(l-(s=s.replaceAll("~","")).length()
                                //  Remove all remaining "~"
         >0?                    //  and if its non-empty:
           "-"                  //   Start with a minus sign
           +s                   //   followed by the remaining `s`
           +~i                  //   followed by `-i-1`
          :                     //  Else:
           s                    //   Start with the remaining `s`
           +"+"                 //   followed by a plus sign
           +i                   //   followed by `i`
         ).replaceAll("--","");}//  And then remove all "--"

05AB1E (legacy), 20 bytes
á0:.E…-x+ì„+-¤:IgÉi¦

Port of (deleted) user48543's Python answer.
Try it online or verify all test cases.
Explanation:
á      # Only keep the letters of the (implicit) input (the "x")
 0:    # Replace the "x" in the (implicit) input with "0"
   .E  # Evaluate and execute it as Python code
…-x+ì  # Prepend string "-x+"
„+-¤:  # Replace a potential "+-" with "-"
IgÉi   # If the length of the original input is odd:
    ¦  #  Remove the leading "-"
       # (after which the result is output implicitly)