text:
Faux Source Code
Output one random character for each character of source code (as illustrated below). The probability of each character is its frequency in the original source code. Thus the output will be fake source code resembling a quine.
Specification

Restrictions

Standard quine constrains apply. No empty programs or functions. Also no reading your own source.

Output

The number of characters output should be exactly the number of characters in the source code
Each output character should be randomly choosen
The probability of choosing any character is equal to (occurrences in source) / (length of source)
This means that even a unary solution needs to 'randomly' choose 1 with probability 1. Which is to say that the output can't be hard coded.

Winning

This is code golf, so fewest bytes wins

Example
Program           Frequency           Probability           Possible Output
-------           ---------           -----------           ---------------
 a@!@              a - 1               a - 25%               @@a@
                   ! - 1               ! - 25%
                   @ - 2               @ - 50%

Program           Frequency           Probability           Possible Output
-------           ---------           -----------           ---------------
caBaDBcDaBDB       a - 3               a - 25%               aaaBBBBccDDD
                   B - 4               B - 33%
                   c - 2               c - 17%
                   D - 3               D - 25%

Are single-character quines allowed?

@NathanMerrill Yes, single character (and other unary) solutions are allowed. However, their output still needs to be randomly chosen.

How shall I find the occurences of characters in a file if I am not allowed to read it?

That is the quine part. Usually quines have the actual source code and a string that contains a copy of the source code. Here is a Python quine _='_=%r;print _%%_';print _%_

Yup, I got it from the Jelly explanation. thanks.

@NonlinearFruit my program "randomly" chooses the letter s from the set of letters "s" it is truly random too!

Is this [tag:code-golf]?

@OldBunny2800 Good catch! I forgot the winning criterion (－‸ლ)

@RohanJhunjhunwala That is a bit of a loophole. In the Specification, I was trying to outlaw solutions like that. I'm sorry if it wasn't clear. Which is to say that the output can't be hard coded.

@NonlinearFruit so are unary quine answers unacceptable?

@RohanJhunjhunwala Unary solutions are welcome, that is why I chose the wording I used. But they have to conform (like everyone else) to the random criterion. Printing s and choosing s randomly from a one element set have the same result but are semantically different. This is a little nit-picky, but without it some solutions could curtail the gist of this challenge.

Is it mistake in the first example output? @@a@ should be @@a!?

@VolAnd No. The probability of each character appearing is based on the character frequency. If you flip a coin twice and it lands on heads once, it doesn't have to hand on tails the second time.

@wizzwizz4 I understand, it was necessary to use a random number to generate output

Is it ok to generate a random permutation of the source?

@Adam No, each output character should be chosen independently of the other output characters

Perl 5, 54 bytes
$_=q{print$_[rand@_]for@_="\$_=q{$_};eval"=~/./g};eval

Try it online!
Produces output like:
_anr_;q.=fn_}v"_eo_f=n\di{nqde}[;}}o}t==@$@$=nvr$}/r=.
"q}=g{;}=[av$a}a__l[q@@;$;_}./@__a.ne=@@i_}_aet.=$=_o"
/arr_r]po{{l_=;__e"_et=="@vr__a_}@nl"ll~$=~_q~d"=v$~$/
q/@=_$__{f{vl;.]@=__=@lpapr}da@eeg_[$@lr\_{{pq$$$vrq=/
=v{[_l=p{{={/n$nv$n[_/aev_v=@on}la;}q{_otr$oaglve$.a_}
_aa;@r='{{=@{ntf;;.if}f}a$;$g/n;g;_}rroaqra=;}l.gre[t'

In a brief test, ~3-4% of the results of the program eval successfully. I'm not sure what that says about Perl...

Ahah, that comment about the 3% of successful eval! Nice one! ;-)

@Dada Seriously! The submissions in the answer genuinely work! I was pretty impressed...

Hopefully, from what I've seen, it just comes from the output being a entire single quoted string (with ' or q//, q{} etc) !

@Dada Yeah, or a regex match. Made me chuckle though! :)

Happy to see you golfing again btw! :)

CJam, 14 bytes
{{E*`mR}`mR}E*

Try it online!
Explanation
Each character appears exactly twice, so the probabilities of the characters should all be the same.
{           e# Repeat this block 14 times.
  {E*`mR}   e# Push this (nonsensical) block.
  `         e# Stringify it, giving the string "{E*`mR}", which contains each of the
            e# seven characters once.
  mR        e# Select one of the characters at random.
}E*

Jelly, 13 bytes
“;⁾vṾWṁ$X€”vṾ

Try it online!
How it works
“;⁾vṾWṁ$X€”vṾ  Main link. No arguments.

“;⁾vṾWṁ$X€”    Set the argument and return value to the string s := ';⁾vṾWṁ$X€'.
            Ṿ  Uneval; construct a string representation of s.
               This yields r := '“;⁾vṾWṁ$X€”'.
           v   Dyadic eval; evaluate s with argument r.

 ;⁾vṾWṁ$X€     Evaluated link (s). Argument: r

  ⁾vṾ          Yield 'vṾ'.
 ;             Concatenate r with 'vṾ'.
               This yields t := '“;⁾vṾWṁ$X€”vṾ', i.e., the original source code.
       $       Combine the previous two links into a monadic chain.
     W           Wrap; yield ['“;⁾vṾWṁ$X€”vṾ'].
      ṁ          Mold; repeat ['“;⁾vṾWṁ$X€”vṾ'] once for each charcter in t.
        X€     Random each; select a character, uniformly at random, of each
               of the 13 repetitions of t.

Japt, 22 bytes
"+Q ²£ZgMqB"+Q ²£ZgMqB

Test it online!
How it works
"+Q ²£ZgMqB"+Q ²£ZgMqB  // Implicit: B = 11
"+Q ²£ZgMqB"            // Take this string.
            +Q          // Append a quotation mark.
               ²        // Double the result.
                £       // Replace each char in the result Z with
                 Zg     //  the char in Z at index
                   MqB  //   random integer in the range [0, 11).
                        // Implicit: output last expression

Pyth, 16 Bytes
smO+N"m1NOs+6"16

try it online!
Contains each char twice therefore the probability is the same as if each was only in there once.
smO+N"m1NOs+6"16     #
   +N"m1NOs+6"       # Add a quotation mark to the string: "m1NOs+6
  O                  # random choice from the string
 m            16     # do this 16 times.
s                    # join the list into a string

PHP, 71 140 110 124 140 120 bytes
for($i=2*$n=strlen($s='for($i=2*$n=strlen($s=.chr(39));$i--;)echo$s[rand(0,$n-1)];'.chr(39));$i--;)echo$s[rand(0,$n-1)];

run with php -d

creates a string containing the code without the quotation marks
and concatenates the quotation mark once using ord
(same probability as if I would double the string and add two quotes);
then loops over twice the length of the string to get random characters from it.

Can possibly be golfed further, but my attempts on eval where futile so far.
I will probably not go deeper here.

The probability of each character is its frequency in the original source code. I may be wrong, but it doesn't look like this entry meets this requirement.

Oh I missed that point. Back to the editor. How can this be done without reading the code?

Using this, I got a syntax error, unexpected '<'. But I'm not familiar with PHP, how do I test this?

@NonlinearFruit: Did you use the -d flag? This is supposed to be saved to a file and then called with php or php-cgi without any flags. Maybe you can use a heredoc.

@NonlinearFruit: ... or just remove the leading <? for usage with -d.

+1 It works! (the -cgi did it) But I think it is outputing 142 characters instead of 140

@NonlinearFruit: You´re right. I will debug.

Python 2, 88 bytes
s='''from random import*; print "".join(choice(s) for c in "s='"+s+"';exec s")''';exec s

All actual merit in getting this far goes to mbomb007 - thanks for your help (and the pointer about backslashes)

This is a quine-like challenge, without input or reading your source code (suppose it is n characters long), you need to print n random characters. Where the probability of a symbol c being chosen is equal to (number of times c occurs in your solution) / n.

So more like this?
exec("""s = 'from random import choice; print "".join([choice(s) for c in s])'; exec(s)""")

You haven't included the single quotes yet, and you don't need the square brackets within the join.

Thanks - and right, I got a little caught up in the rush of nudging closer to the solution

And you can exec s if you restrict yourself to Python 2. Also you haven't included s = .

Here you go: s='''from random import*;print"".join(choice(s)for c in s+"s='';''exec s''")''';exec s. I wish I'd thought of that.

+1 It works! But I'm getting a 84 character output..

@user59421 Your program is currently incorrect. Look at the differences between what you have and this: s='''from random import*;print"".join(choice(s)for c in s+"s='';''exec s''")''';exec s

Ruby, 47 bytes
eval r="47.times{$><<('eval r=%p'%r)[rand 47]}"

This is based on the standard eval quine:
eval r="$><<'eval r=%p'%r"

It's a byte longer than the shortest quine, but it's usually the better choice for generalised quines, because any computation done on the source code string does not need to be duplicated. Whereas in the usual quine, every additional computation needs to go both inside and outside the main string, it is only needed inside the main string for this kind of quine.
As for what the code actually does: after obtaining a string representing the entire source code, we simply select a random character (by selecting a random index) 47 times and print each character separately.

Wolfram Language/Mathematica, 109 Bytes
Function[Print[StringJoin[RandomChoice[StringSplit[StringJoin[ToString[FullForm[Slot[0]]],"[]"],""],109]]]][]

sample output:
niPi[no,ili[Siu[,Sdoio9nthg"t ginuu[1[o]"i,icgi[0TncrS"[ln"o0]r,i][Jon[[et]0"]m [ri"a[]motrin,iFoFnultnnno,Jl

Oh those square brackets.

JavaScript, 128 bytes
a=";a+=uneval(a);alert(a.replace(/./g,_=>a[Math.random()*64|0]))a=";a+=uneval(a);alert(a.replace(/./g,_=>a[Math.random()*64|0]))

Note: only works in Firefox due to the use of uneval.
Sample runs:
)a(rgc=d6m_a4uar=hp(lll(,d=m=dee(M(gtraoan0)(M(aaaa(M]c)e)/M()/u//M6_n/a"*unea(/>atugrn(a=nav"|;)|=)/,ataa,aaangtue;am)t0;|ctoa/
=lvct;eee,,a.e=6r0;);Mtaaoa.aeea4)a[r.6]e/ll+l.)=)|a[(c"rao4ea/=_acaMh=veerva"a(_(d(l)lgn.;rM">=ea40a*).e(h(laa6r)4a)rhlar=t(ta[
[rt]ll]n))aota.e)g;>ae*;..4tt];l[;].*lnr4(mnM|alg(a.ag(.=e(a>>aa>.hga;a/pat+elc];apc=(ag)tao.).ll4u)dah]r(ul)>lr;,)ret(e/g(=_c*r
M.r)_;.a(lraalg("mac>dmrlr"0/ah(a()ead|/0a(m.|u0)(a(0_[dn)a]/raal;eata)a.ataeaa*l)=ra()la=(a)*aaea>n;.a.)ca)orM(tm*a,a=)p;(>r)aa

I'm now really surprised that this produced more valid code in Perl than it appears it would in JS! Not as many fun words here, except gtraoan which is nearly a groan I guess...

@DomHastings Well, Perl is more of a mash of punctuation than JS ;)

Definitely! It's more of a mess of punctuation than an explosion in a punctuation factory! but I quite like that!

Does " have a probability of showing up?

@NonlinearFruit Yup. There's at least one in the first, second, and last example outputs.

Jelly, 44 bytes
I hope I have interpreted all the rules correctly (I'm not quite sure what the "carry payload" thing is in meta or if it's even relevant to this challenge).
“ẋ2;8220Ọ;8221ỌXµ44Ð¡Ḋ”ẋ2;8220Ọ;8221ỌXµ44Ð¡Ḋ

Test it out at TryItOnline
This constructs a string from which to choose characters. The initial string has all the character used except the open and close quotes. It then doubles that string and concatenates one of each of the open and close quotes from ordinals (hence the need to double the other characters). Lastly it repeatedly picks random characters from the composed string to the length of the program.

@NonlinearFruit Oops - I updated to add a missed character from my string but did not update to 44 - thanks!

Pyke, 35 bytes
35F\";"\\+3322 5**F;H)s"\"2*+2* H)s

Try it here!
To check: remove the final H and the resulting string contains the right number of each character (with the extra H)
This does NOT use a generalised quine or in fact a quine at all. It relies on being able to create a string containing all the characters in the source. It should be able to do it for any code but each character logarithmically increases code size. The only number of times a character is allowed in the source is 2 or 7

C, 125 bytes
char*s="char*s;l,i;f(){l=i=strlen(s);while(i--)putchar(s[rand()%l]);}";l,i;f(){l=i=strlen(s);while(i--)putchar(s[rand()%l]);}

C, 60 bytes for golfed but not quine code taking any string
l,i;f(char*s){l=i=strlen(s);while(i--)putchar(s[rand()%l]);}

While for counting characters my solution needed 86:
c[256];i;f(char*s){i=256;while(*s)c[*s++]++;while(--i)while(c[i]?c[i]--:0)putchar(i);}

It should not? Perhaps I do not understand the rules of this quiz. My f takes string and prints to standard output: string can be any sequence of characters.

@NonlinearFruit Probabilities not calculated but expression rand()%LENGTH_OF_STRING take character according to probability of that character with normal distribution provided by rand(). Perhaps, I do not understand quine approach for C....

+1 The new solution is nearly correct. s just needs to contain char*s="";. I think something like this char*s="char*s=l,i;f(){l=i=strlen(s);while(i--)putchar(s[rand()%l]);};+''"+'""' would do it (but I am not familiar with C).

If the answer is not valid in its current state, then it should be deleted.

@mbomb007 Could you explain your judgment and possibly provide come advice?

@NonlinearFruit Maybe you can explain.

@VolAnd Your string should contain a copy of your code. char*s=""; is part of your code but it does not show up in your string. That is to say, you had a working solution that you made into a quine, but you are not 'quining' the parts that you added to make that happen.

I have added char*s; in the string. Thanks for comments.

Ruby, 81 67 bytes
Saved a bunch of bytes by stealing some tricks from Martin's solution
s="s=%p;67.times{$><<(s%%s)[rand 67]}";67.times{$><<(s%s)[rand 67]}

I didn't realize that you had to randomly select every time; I thought a shuffle would do the trick. This can probably be golfed, but it's the shortest I could get it.
Standard Ruby quine with a few modifications so it prints out the shuffled string. I'm sad because it took like fifteen minutes to figure out the formatting quirks before I realized that I was subconsciously stealing it anyway.
I think the string shuffling can be shortened but I don't know how; I might also be able to finagle the formatting into being shorter once I put some thought into it. Help would be appreciated.
Try it online!

I think (like my CJam) answer, it's not necessary to use a standard quine as the basis. A direct port of my CJam solution gives 64 bytes: 64.times{$><<"64.times{$><<.inspect[rand 32]}".inspect[rand 32]}

Nevermind, basing it on a standard quine is shorter, but you'll have to use the eval-based quine: eval r="47.times{$><<('eval r=%p'%r)[rand 47]}"

@MartinEnder That's different enough to merit its own answer, I think. If you disagree, feel free to edit it into mine, but in the mean time I'll just steal a few tricks from yours to save a few bytes in mine.

C, 136 bytes
main(a){for(a=136;a--;)rand()%68?putchar("main(a){for(a=136;a--;)rand()%68?putchar([rand()%67]):putchar(34);}"[rand()%67]):putchar(34);}

Example output:
;%7c(u)"r4-hd)nnr-%n6;6(4or(n4(6(a:=a3r-:()hp(:aa%;4rru}h;(a()3mh3rdi7));a-u36:r3on[4?p((]6n6?()-6t736unhr%:[%[[d(p:[ru)-n(6r=:](p-})8"]

This program outputs 136 characters randomly.
The entire source code (less " quotation marks) is contained in a string. The program determines the probability of outputting a quotation mark as 2/136, otherwise outputting one of the other 67 characters randomly.
There are two occurrences of each character in the string in the program. The probability of outputting a character from the string is 134/136. The probability of choosing a specific character in the string is 1/67. So the chance of outputting a character in the string is 134/136 * 1/67 = 2/136. There are two occurrences of each string character in the program, so there is a 1/136 probability of outputting a character for each occurrence in the program.
The order of symbols inside the string doesn't matter.

R, 174 bytes
cat(sample(el(dimnames(a<-table(c("\n",el(strsplit(scan(,""),"")))))),174,T,a),sep="")
cat(sample(el(dimnames(a<-table(c("\n",el(strsplit(scan(,""),"")))))),174,T,a),sep="")

Try it online!
The function sample performs discrete random sampling. Itcan take as 4th argument a vector prob of probabilities. The vector prob does not need to be normalized (i.e. it does not need to sum to 1): here, we use a vector of counts, and sample does the renormalizing.
The 2 lines are identical. The 1st line does the hard work, and reads the contents of the 2nd line to get the counts of each character. So here, the vector of probabilities a actually sums to 87=174/2. Note the special treatment of the newline, which scan does not read. I can't think of a way of avoiding this without having to add more bytes to handle quotation marks.

TIO says Error in sample.int(length(x), size, replace, prob) : incorrect number of probabilities

@NonlinearFruit Thanks, should work now.

Python 3, 134 132 bytes
I use every character in my source code within the string the correct number of times, then multiply the string by two to include itself. The program prints a random character from that string for each character in the code (the length is hard-coded.)
from random import*
for i in[0]*134:print(choice("""from random import*
for i in[0]*134:print(choice(""*""2""),end='')"""*2),end='')

Try it online
I avoided backslashes like the plague. As soon as the code contains \n or \", you have a problem, because the string doesn't contain backslashes yet, so you have to add those also, but in a separate string multiplied by a higher number, because it takes two backslashes to represent one (\\).
Example output:
i(tc*"3]i o''r=,,,h34t"r
ri"](fco t)niap)t "it2nc0o  npoi3'"nto(*4 i(ido' r*4f"oi]d rm ,i"eif)m"d
m emi
dfr n*p 3*(i""r1d"dr menc hio'

I gotta say, it reminds me of FlogScript.

PowerShell v2+, 175 bytes
$d='$d={0}{1}{0}{2}-join(0..174|%{3}[char[]]($d-f [char]39,$d,"`n",[char]123,[char]125)|Random{4})'
-join(0..174|%{[char[]]($d-f [char]39,$d,"`n",[char]123,[char]125)|Random})

Quines in PowerShell suck, because the string replacement delimiters {} also denote loops and whatnot, so you need to use a bunch of chars in the -f operator, which bloats the code.
Similar-ish to my Quine on Every Line answer. Basically we loop from 0 to 174 and each iteration re-calculate the quine $d, cast it as a char-array, and pull out a Random element chosen uniformly from the input. By definition, this gives probability (occurrences in source) / (length of source) as required. Those characters are encapsulated in parens and -joined together back into a string.
Example
PS C:\Tools\Scripts\golfing> .\faux-souce-code.ps1
}}[${hr[`ini}}] [5i,=[]0,j2($=n4(dm]jh]jc]]7
}..j"rnj9|fn,4r]{9]('["jdh0}$rd,-f,a.c"}{h1 ]5d,),0n5|nh(]73a9da4aRi[5}a}430}}rd$,$r)-hhr%or79-R.R-`'r'aa|=1f0][|[{7}do1]$ja0 rd{h

(Yes, that's a newline in the output -- when a string containing a newline is char-array'd, the `n is treated as a character, since a char-array is just an array of byte codes, so it also has a 1/175th chance of being selected.)

Dyalog APL, 20 bytes
f←{(,⎕CR'f')[?⍴⍨20]}

f←{...} define f as
(,⎕CR'f') listified (,) Character (table) Representation (⎕CR) of f ('f')
[?⍴⍨20] indexed with ([...]) random-up-to (?) repeat-itself-times (⍴⍨) of twenty
Let us run it (with a dummy argument) a few times:
      f⍬
)0'0](⍨(([],}⎕))⎕'f2
      f⍬
{'['}f[←R[)2←?}⍨]}C2
      f⍬
,,⍨←?2}⍴?'⍨}C,'{⎕(C0

Fine, but is the distribution correct? Let us run it on 10,000 dummy arguments and see how many times each character occurs:
      {⍺ , 1E¯4× ⍴⍵}⌸ ∊ f¨ ⍳1E4
C 0.9952
⎕ 0.9996
' 1.9777
f 2.004
← 1.0018
⍨ 1.0173
0 1.0213
] 1.0049
[ 0.9988
2 0.9943
{ 0.9895
) 1.0093
R 1.0054
, 1.0029
? 0.9943
} 0.9861
⍴ 1.0032
( 0.9944

Clearly, f and ' occur twice as often as the other characters, just like in the original source code.
How did we do it?
{⍺ , 1E¯4× ⍴⍵}⌸ ∊ f¨ ⍳1E4`

⍳1E4 generates the first 10,000 integers
f¨ runs f on each of those numbers
∊ flattens all the pseudo-quines into a single 200,000-character string
⌸ is a higher-order function which for each unique character in the right side  data, feeds the left-side function the unique element as left-argument and the indices where that character occurs as right-argument. The left-side function is
{⍺ , 1E¯4× ⍴⍵}

⍺ left-argument, i.e. the unique character
, followed by
1E¯4× 1×10⁻⁴ times
⍴⍵ the shape of the right-argument (the occurrence indices), i.e.how many times it occurs
Finally, ⌸ puts it all together in a table.

C#, 277 280 268 bytes.
using System;class a{static void Main(){var s="using System;class a{static void Main(){var s=\"x5Cx5C\x5C\x5C\";Random d=new Random();for(int i=0;i++<268;)Console.Write(s[d.Next(0,134)]);}}";Random d=new Random();for(int i=0;i++<268;)Console.Write(s[d.Next(0,134)]);}}

Ungolfed:
using System;
class a
{
    static void Main()
    {
        var s="using System;class a{static void Main(){var s=\"x5Cx5C\x5C\x5C\";Random d=new Random();for(int i=0;i++<268;)Console.Write(s[d.Next(0,134)]);}}";
        Random d=new Random();
        for(int i=0;i++<268;)
            Console.Write(s[d.Next(0,134)]);
    }
}

Pretty sure this works correctly.
Sample output:
    fn;i)(]ns;<ftt08et]i+ii8]m[W}dr{rmte,)t edayid 2s cmsee\;ta["e n;o}]iolys;t sftoR{.=g vs8;(sd isWrecn++iia]iuf"avs\i<{ee vfs[ensin\s i]0a(We.0ns R(2roo=ldxil\{t(o"aistt.;.  r w"m1];idi}Ctitiindnn;M[,[+0(,o"]mca[rmnm)<;n"8ReaystinRsanr([(d,n\.ateiR sd.=[=;ttn.;wna)cCt[=+t{Wxs(\}rg

@NonlinearFruit Thanks, missed that space.  Also means I can't use a foreach loop which adds a few bytes :(.  However, I think I do have " included correctly with those two escaped quotes in the string, since they appear in the output a few times, unless I'm missing their use somewhere else.

Ahh, I thought they didn't count if they were in the string, my bad.  Will fix in a bit.

Okay, 's now appear as well!

Hm, interesting problem then.  Can't just keep adding \ or I'll always be one short.  I'll use the ascii code for \ instead.

Does (new Random()).Next(0,134)] work? It would save a couple bytes.

It appears as though a new random class each iteration uses the same seed multiple times resulting in non-random output (the same character the entire time).

Would var d works? I think you can get gain 6 bytes.

Julia 1.0, 50 bytes
(a=:(print.(rand("(a=:($(a)))|>eval", 50))))|>eval

Try it online!
based on this quine:
(a=:(print("(a=:($(a)))|>eval")))|>eval

Try it online!

R, 136 bytes
a=scan(,"");cat(intToUtf8(sample(rep(c(10,utf8ToInt(a)),2),136,T)))
a=scan(,"");cat(intToUtf8(sample(rep(c(10,utf8ToInt(a)),2),136,T)))

Try it online!
The "read-a-second-copy-and-sample-from-it" approach is shamefully copied from Robin Ryder's answer: please upvote that one.
Here, however, rather than counting the instances of each character and using this to weight the sampling, we just sample uniformly from the full set of characters (including repetitions).

Python 3.8 (pre-release), 75 bytes
exec(a:='from random import*;print(*choices("exec(a:=%r)"%a,k=75),sep="")')

Try it online!


text:
Count to 100 in Danish
Print all the numbers from 0-100 in the right order using the Danish way of counting
How they count

Like English, they have dedicated words for 0-20, 30, 40 and 100
Instead of saying twenty-one and twenty-two, they say one and twenty and two and twenty
Starting with fifty they say multiples of 10 as n*20
50 = half third times twenty = half way to the 3rd multiple of 20
60 = three times twenty
70 = half fourth times twenty
80 = four times twenty
90 = half fifth times twenty

So for instance, 55 would be five and half third times twenty.

Expected output
zero
one
two
three
four
five
six
seven
eight
nine
ten
eleven
twelve
thirteen
fourteen
fifteen
sixteen
seventeen
eighteen
nineteen
twenty
one and twenty
two and twenty
three and twenty
four and twenty
five and twenty
six and twenty
seven and twenty
eight and twenty
nine and twenty
thirty
one and thirty
two and thirty
three and thirty
four and thirty
five and thirty
six and thirty
seven and thirty
eight and thirty
nine and thirty
forty
one and forty
two and forty
three and forty
four and forty
five and forty
six and forty
seven and forty
eight and forty
nine and forty
half third times twenty
one and half third times twenty
two and half third times twenty
three and half third times twenty
four and half third times twenty
five and half third times twenty
six and half third times twenty
seven and half third times twenty
eight and half third times twenty
nine and half third times twenty
three times twenty
one and three times twenty
two and three times twenty
three and three times twenty
four and three times twenty
five and three times twenty
six and three times twenty
seven and three times twenty
eight and three times twenty
nine and three times twenty
half fourth times twenty
one and half fourth times twenty
two and half fourth times twenty
three and half fourth times twenty
four and half fourth times twenty
five and half fourth times twenty
six and half fourth times twenty
seven and half fourth times twenty
eight and half fourth times twenty
nine and half fourth times twenty
four times twenty
one and four times twenty
two and four times twenty
three and four times twenty
four and four times twenty
five and four times twenty
six and four times twenty
seven and four times twenty
eight and four times twenty
nine and four times twenty
half fifth times twenty
one and half fifth times twenty
two and half fifth times twenty
three and half fifth times twenty
four and half fifth times twenty
five and half fifth times twenty
six and half fifth times twenty
seven and half fifth times twenty
eight and half fifth times twenty
nine and half fifth times twenty
one hundred

Rules

You may use any separator to separate the numbers
Due to a typo in the original specification, you may use forth instead of fourth.
You may write a function or write to std-out
Standard loopholes apply
This is codegolf; shortest code in bytes win!

Related.

Why all the spaces? 55 is femoghalvtredsindstyve in Danish, not fem og halv tred sinds tyve.

The expected output looks decidedly non-Danish to me. (And 55 is femoghalvtreds, not femoghalvtredsinstyve unless you're being deliberately archaic).

@Adám I decided to use English rather than Danish words to make the challenge more accessible, and we don't contract words in English.

@BlackCap: Some words do become contracted over time. For instance, it is screenshot, not screen shot.

Related

Is printing in list-form also valid? E.g.: [zero, one, two,...]

@QBrute Yes, or you may just create a function that returns the list

English used to be like this. You know the nursery rhyme Sing a Song of Sixpence? "Four and twenty blackbirds, baked in a pie."

Not to mention our expected lifespan of 'three score and ten' years...

looks like German, which also counts "one and twenty"

@LưuVĩnhPhúc you are right that german, like danish, is also flipped compared to english. Germans operate in multiplies of 10 unlike danish which uses multiplies of 20.

JavaScript (ES6), 347 336 326 325 308 bytes
for(a=btoa`...`.split(i=0);i<101;i++)alert(i<13?a[i]:i<20?(a[i]||a[i-10])+"teen":i>99?"one hundred":(i%10?a[i%10]+" and ":"")+(i<30?"twenty":i<40?"thirty":i<50?"forty":(i%20>9?"half "+["third","forth","fifth"][i/20-2|0]:a[i/20|0])+" times twenty"))

Before running, replace the ... with the result of running this code:
atob("zero0one0two0three0four0five0six0seven0eight0nine0ten0eleven0twelve0thir00fif000eigh")

Or you could just use the uncompressed version:
for(a="zero0one0two0three0four0five0six0seven0eight0nine0ten0eleven0twelve0thir00fif000eigh".split(i=0);i<101;i++)alert(i<13?a[i]:i<20?(a[i]||a[i-10])+"teen":i>99?"one hundred":(i%10?a[i%10]+" and ":"")+(i<30?"twenty":i<40?"thirty":i<50?"forty":(i%20>9?"half "+["third","forth","fifth"][i/20-2|0]:a[i/20|0])+" times twenty"))

Still probably not optimal. 11 bytes saved in part by @Titus.

I was wrong. that´s a reasonable way to golf the exceptions.

-7 bytes: (x%20>9?"half ":"")+[third,forth,fifth][x/20-2.5|0] instead of (x%20>9?"half "+[third,forth,fifth][x/20-2.5|0]:f(x/20|0))

@Titus If I understand what you mean, that generates incorrect output for 60, 61, ..., 69, 80, 81... (e.g. third times twenty instead of three times twenty)

Oh I was missing that difference. You´re right. But get rid of the recursion; that will make way for a little more golfing.

@Titus Thanks for the tip. I didn't notice it, but recursion was actually saving me exactly 0 bytes over non-recursion. I've switched and golfed some more now.

_ as seperator should give another 13 bytes.

Ok, you finally beat me. :) The overhead for base64_encoding in PHP is larger than what I would save on the string.

@Titus I don't understand what you mean about using _ as separator. Do you mean using it in a, or in the output?

Any of >?<{:@ \[]^\_|;-},~)*&%!'"($#.as a word delimiter will give you a smalleratob` result. But it may contain bytes that you can´t put in an editor.

@Titus As far as I'm aware, all of those characters are illegal in atob inputs.

Fourier, 7028 bytes
The bounty will go to Paul Schmitz's answer
This was golfed programmatically using issacg's golfing program
[encoded data, 7028 characters]

Try it online!

Here's a suggestion: simply print the output.  It consists of 1989 characters that use the same number of bytes.

@DavidC As far as I know this is how you "simply print the output" in Fourier. There are no string literals if that's what you meant.

@DavidC Martin is right, strings don't exist in Fourier

My goodness, very strange language it seems!

I got 7020 bytes. http://pastebin.com/WGtHSGFT

@PaulSchmitz Post it as an answer so I can award the bounty

@BetaDecay http://codegolf.stackexchange.com/a/92812/59035

@BetaDecay Thank you for the bounty.

@PaulSchmitz My pleasure :)

JavaScript (ES6), non-competing
I decided to do what the title actually asked, and counted to 100 på dansk. This is based on ETHproductions' answer. It is 292 bytes (286 if you use alert instead)

for(a="nul0en0to0tre0fire0fem0seks0syv0otte0ni0ti0elleve0tolv0tret0fjor0fem0seks0syt0at0nit".split(i=0);i<101;i++)console.log(i<13?a[i]:i<20?(a[i])+"ten":i>99?"hundrede":(i%10?a[i%10]+"og":"")+(["tyve","tredive","fyrre","halvtreds","tres","halvfjerds","firs","halvfems"][Math.floor(i/10)-2]))

To be fair, you should append instyve to every number that ends in s.

@Adám: Why so? The -sinstyve is etymology, not actual Danish as currently spoken.

Yeah, but the English OP does include it, otherwise it should say 55 would be five and half third t.

PHP, 397 375 372 381 386 365 bytes
This was too funny to be ignored. It can possibly be golfed further.
zero_<?=join(_,$a=[one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thirteen,fourteen,fifteen,sixteen,seventeen,eighteen,nineteen])._;foreach([twenty,thirty,forty]as$t)for($i=-2;$i++<8;)echo($i<0?'':$c[]="$a[$i] and ").$t._;foreach([third,three,fourth,four,fifth]as$k=>$t)for($i=-2;$i++<8;)echo$c[$i],($k&1?'':'half '),"$t times twenty_";?>one hundred

It uses underscore as the separator
10 to 19 are still hardcoded; any way to compute them doesn´t give as much as the join.

///, 434 bytes
/(/\/\///D/\/7(7/ and (2/twenty(4/ times (_/half ([/42
(&/three(;/thir()/four(!/fort($/_fifth[(#/seven(^/eight(@D;ty
(%D_!h[(*D_;d[(-/nine(`D!y
(F/five(T/teen
(O/one(X/six(GD&[(HD)[(ID2
(Y/two(AD$/zero
O
Y
&
)
F
X
#
^
-
ten
eleven
twelve
;T)TfifTXT#T^een
-T2
OIYI&I)IFIXI#I^I-I;ty
O@Y@&@)@F@X@#@^@-@!y
O`Y`&`)`F`X`#`^`-`_;d42
O*Y*&*)*F*X*#*^*-*&[OGYG&G)GFGXG#G^G-G_!h[O%Y%&%)%F%X%#%^%-%)[OHYH&H)HFHXH#H^H-H$OAYA&A)AFAXA#A^A-AO hundred

Try it online!

Mathematica 251 238 230 bytes
This now presents the output in the format of a list, to save 8 more bytes.
c@s_:=s<>" times twenty";f@n_:=Which[n<21∨{30,40,100}~MemberQ~n,IntegerName@n,n==50,c@"half third",n==60,c@"three",n==70,c@"half forth",n==80,c@"four",n==90,c@"half fifth",3>2,NumberExpand@n/.{t_,u_}:>f@u<>" plus "<>f@t];f/@0~Range~100

I'm really jealous of that IntegerName function

Yeah, it does a good amount of the work.   NumberExpand is also useful for decomposing a number (in any base). `NumberExpand[943]-> {900,40,3}

Haskell, 308 291 285 bytes
w=words;q x=map(++x);m=w"thir four fif six seven eigh nine";t=w"zero one two three four five six seven eight nine ten eleven twelve"++q"teen"m++q"ty"(do b<-"twen":take 2m++q" times twen"["half third",t!!3,"half fourth",t!!4,"half fifth"];b:q b(q" and ".take 9$tail t))++["one hundred"]

Readable version:
w   = words
m   = w "thir four fif six seven eigh nine"
q x = map (++x)

t = w "zero one two three four five six seven eight nine ten eleven twelve"
 ++ q "teen" m
 ++ q "ty" (do b <- "twen" : take 2 m
                     ++ q " times twen"
                          ["half third",t!!3,"half fourth",t!!4,"half fifth"]
               b:q b(q" and ".take 9$tail t)
           )
 ++ ["one hundred"]

Also 285
w=words;m=w"thir four fif six seven eigh nine";x!l=map(++x)l
t  = w"zero one two three four five six seven eight nine ten eleven twelve"
  ++ "teen"!m
  ++ "ty"!(
  do x<-"twen":take 2m++" times twen"!
         ["half third",t!!3,"half fourth",t!!4,"half fifth"]
     x:x!(" and "!take 9(tail t)))
  ++ ["one hundred"]

It might not look much different, but it represents hours of factorization that eventually brought me full circle. I think I have done this before..

Damn, Nordic-related challenge and so there already is a fp solution I can hardly improve on (fp being quite popular in the Nordics, no?)

@LeifWillerts I don't know anyone else who do fp, nor do they teach it in schools- sadly. You could try Lisp, it has format nil "~R" which converts numbers to their English text representation

Why do you suggest that Lisp?
Well, I have been taught FP in Germany by a professor who had spent a lot of time at Chalmers in Sweden, and in here in Copenhagen they teach it on quite a high level and there is an active community in the city. Erlang was famously developed by Ericsson in Sweden. Where are you and what do you do?

@LeifWillerts I'm in Norway, just graduated from high-school and decided to work in webdev for a year before going to uni. I've obviously checked what options I have, and none of them are fp.
None of my colleges or friends had even heard of functional programming before they met me..
Also, I suggested Lisp because half of my bytes come from storing numbers in strings, and you could get around that in Lisp.

Why is it non-competing? Just because you are OP doesn't mean non-competing AFAIK. Mods correct me if I'm wrong though...

@EriktheGolfer Can someone confirm that? I thought competing in my own challenge sounded a bit cheesy..

C (gcc), 445 426 452 449 444 439 bytes
*t[]={0,0,"twenty","thirty","fourty",[10]="one hundred","third","fourth","fifth"},*o[101]={"zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"};i,p;main(j){for(;i<'e';i++)p=i%10,o[i]?puts(o[i]):printf("%s%s%s%s%s%s\n",p?o[p]:t,p?" and ":t,!t[j]&j%2?"half ":t,t[j]?t:j%2?t[j/2+9]:o[j/2],t[j]?t:" times ",t[j=i/10]?:t[2]);}

Try it online!
19 22 27 bytes shaved off thanks to @ceilingcat, but 26 bytes were added again, 3 to prevent a segfault (o[] really has to have 101 entries), and upon checking the rules again I noticed we had to print out all numbers from 0 to 100, not just provide a function that printed one number.
Ungolfed:
char *t[] = {0, 0, "twenty", "thirty", "fourty", 0, 0, 0, 0, 0, "one hundred", "third", "fourth", "fifth"};
char *o[101] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
                "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
int i = 0;
int j = 0;
int p = 0;

main()
{
  for(; i < 101; i++) {
    p = i % 10;
    if(o[i])
        puts(o[i]);
    else
        printf("%s%s%s%s%s%s\n",
               p ? o[p] : "",
               p ? " and " : "",
               !t[j] & j % 2 ? "half " : "",
               t[j] ? "" : j % 2 ? t[j / 2 + 9] : o[j / 2],
               t[j] ? "" : " times ",
               t[j = i / 10] ? : t[2]
        );
  }
}
```

PHP, 333 328 321 bytes
@ETHproductions´s expression ported to PHP and golfed down. I am surprised that PHP can beat JavaScript without any builtins.
I guess the mightiest builtins are the implicit typecasts:

I need no quotes for most of the strings, that alone is worth 12 bytes;
and it allows me to use an array directly instead of splitting a string.
the array indexing is implicitly typecasting any floats to integer, saving 6 bytes.

BUT: I need $s (21 of them) to tell PHP that it´s a variable.
So it´s still unclear where the 15 bytes actually come from. I didn´t golf away that much. Or did I? ETH caught up.
<?$a=[zero,one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thirteen,'',fifteen,'','',eighteen];for($n=-1;$n++<99;)echo$n>19?($n%10?$a[$n%10].' and ':'').($n>49?($n%20>9?"half ".[third,forth,fifth][$n/20-2.5]:$a[$n/20]).' times twenty':[twen,thir,'for'][$n/10-2].ty):($a[$n]?:$a[$n%10].teen),_;?>one hundred

Beating you now ;)

Fourier, 7020 bytes
122a101~za114a-3a10a111ava-9a10a116a+3a-8a10a116a104a114a101aa10a102a+9a+6a-3a10a102a+3a118a101a10a115a105a120a10a115a101a118a101a+9a10a101a+4a-2a^a116a10a110a-5a+5a-9a10a116a101a+9a10a101a+7a-7a118aza+9a10a116a+3a101a+7a118a101a10a116a104a^a+9a+2a101aa+9a10a102a+9a+6a-3a+2a101aa+9a10a102a+3a-3a116a101aa+9a10a115a105a120a-4a101aa+9a10a115a101a118aza+9a+6a101aa+9a10aza+4a-2a^a116a101aa+9a10a110a-5a+5a-9a116a101aa+9a10a116a+3a101a+9a+6a+5a10a111ava-9a32a97a110a100a32a116a+3a101a+9a+6a+5a10a116a+3a-8a32a97a110a100a32a116a+3a101a+9a+6a+5a10a116a104a114azaa32a97a110a100a32a116a+3a101a+9a+6a+5a10a102a+9a+6a-3a32a97a110a100a32a116a+3a101a+9a+6a+5a10a102a+3a118aza32a97a110a100a32a116a+3a101a+9a+6a+5a10a115a105a120a32a97a110a100a32a116a+3a101a+9a+6a+5a10a115a101a118a101a+9a32a97a110a100a32a116a+3a101a+9a+6a+5a10a101a+4a-2a^a116a32a97a110a100a32a116a+3a101a+9a+6a+5a10a110a-5a+5a-9a32a97a110a100a32a116a+3a101a+9a+6a+5a10a116a104a^a+9a+2a+5a10a111ava-9a32a97a110a100a32a116a104a^a+9a+2a+5a10a116a+3a-8a32a97a110a100a32a116a104a^a+9a+2a+5a10a116a104a114a101aa32a97a110a100a32a116a104a^a+9a+2a+5a10a102a+9a+6a-3a32a97a110a100a32a116a104a^a+9a+2a+5a10a102a+3a118a101a32a97a110a100a32a116a104a^a+9a+2a+5a10a115a105a120a32a97a110a100a32a116a104a^a+9a+2a+5a10a115a101a118a101a+9a32a97a110a100a32a116a104a^a+9a+2a+5a10a101a+4a-2a^a116a32a97a110a100a32a116a104a^a+9a+2a+5a10a110a-5a+5a-9a32a97a110a100a32a116a104a^a+9a+2a+5a10a102a+9a+3a+2a+5a10a111ava-9a32a97a110a100a32a102a+9a+3a+2a+5a10a116a+3a-8a32a97a110a100a32a102a+9a+3a+2a+5a10a116a104a114a101aa32a97a110a100a32a102a+9a+3a+2a+5a10a102a+9a+6a-3a32a97a110a100a32a102a+9a+3a+2a+5a10a102a+3a118a101a32a97a110a100a32a102a+9a+3a+2a+5a10a115a105a120a32a97a110a100a32a102a+9a+3a+2a+5a10a115a101a118a101a+9a32a97a110a100a32a102a+9a+3a+2a+5a10a101a+4a-2a^a116a32a97a110a100a32a102a+9a+3a+2a+5a10a110a-5a+5a-9a32a97a110a100a32a102a+9a+3a+2a+5a10a104a97a108a-6a32a116a104a^a+9a100a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a111ava-9a32a97a110a100a32a104a97a108a-6a32a116a104a^a+9a100a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a+3a-8a32a97a110a100a32a104a97a108a-6a32a116a104a^a+9a100a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a104a114a101aa32a97a110a100a32a104a97a108a-6a32a116a104a^a+9a100a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+9a+6a-3a32a97a110a100a32a104a97a108a-6a32a116a104a^a+9a100a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+3a118a101a32a97a110a100a32a104a97a108a-6a32a116a104a^a+9a100a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a115a105a120a32a97a110a100a32a104a97a108a-6a32a116a104a^a+9a100a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a115a101a118a101a+9a32a97a110a100a32a104a97a108a-6a32a116a104a^a+9a100a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a101a+4a-2a^a116a32a97a110a100a32a104a97a108a-6a32a116a104a^a+9a100a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a110a-5a+5a-9a32a97a110a100a32a104a97a108a-6a32a116a104a^a+9a100a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a104a114a101aa32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a111ava-9a32a97a110a100a32a116a104a114a101aa32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a+3a-8a32a97a110a100a32a116a104a114a101aa32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a104a114a101aa32a97a110a100a32a116a104a114a101aa32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+9a+6a-3a32a97a110a100a32a116a104a114a101aa32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+3a118a101a32a97a110a100a32a116a104a114a101aa32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a115a105a120a32a97a110a100a32a116a104a114a101aa32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a115a101a118a101a+9a32a97a110a100a32a116a104a114a101aa32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a101a+4a-2a^a116a32a97a110a100a32a116a104a114a101aa32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a110a-5a+5a-9a32a97a110a100a32a116a104a114a101aa32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a104a97a108a-6a32a102a+9a+6a-3a+2a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a111ava-9a32a97a110a100a32a104a97a108a-6a32a102a+9a+6a-3a+2a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a+3a-8a32a97a110a100a32a104a97a108a-6a32a102a+9a+6a-3a+2a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a104a114a101aa32a97a110a100a32a104a97a108a-6a32a102a+9a+6a-3a+2a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+9a+6a-3a32a97a110a100a32a104a97a108a-6a32a102a+9a+6a-3a+2a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+3a118a101a32a97a110a100a32a104a97a108a-6a32a102a+9a+6a-3a+2a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a115a105a120a32a97a110a100a32a104a97a108a-6a32a102a+9a+6a-3a+2a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a115a101a118a101a+9a32a97a110a100a32a104a97a108a-6a32a102a+9a+6a-3a+2a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a101a+4a-2a^a116a32a97a110a100a32a104a97a108a-6a32a102a+9a+6a-3a+2a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a110a-5a+5a-9a32a97a110a100a32a104a97a108a-6a32a102a+9a+6a-3a+2a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+9a+6a-3a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a111ava-9a32a97a110a100a32a102a+9a+6a-3a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a+3a-8a32a97a110a100a32a102a+9a+6a-3a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a104a114a101aa32a97a110a100a32a102a+9a+6a-3a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+9a+6a-3a32a97a110a100a32a102a+9a+6a-3a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+3a118a101a32a97a110a100a32a102a+9a+6a-3a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a115a105a120a32a97a110a100a32a102a+9a+6a-3a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a115a101a118a101a+9a32a97a110a100a32a102a+9a+6a-3a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a101a+4a-2a^a116a32a97a110a100a32a102a+9a+6a-3a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a110a-5a+5a-9a32a97a110a100a32a102a+9a+6a-3a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a104a97a108a-6a32a102a+3a-3a116a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a111ava-9a32a97a110a100a32a104a97a108a-6a32a102a+3a-3a116a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a+3a-8a32a97a110a100a32a104a97a108a-6a32a102a+3a-3a116a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a116a104a114a101aa32a97a110a100a32a104a97a108a-6a32a102a+3a-3a116a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+9a+6a-3a32a97a110a100a32a104a97a108a-6a32a102a+3a-3a116a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a102a+3a118a101a32a97a110a100a32a104a97a108a-6a32a102a+3a-3a116a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a115a105a120a32a97a110a100a32a104a97a108a-6a32a102a+3a-3a116a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a115a101a118a101a+9a32a97a110a100a32a104a97a108a-6a32a102a+3a-3a116a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a101a+4a-2a^a116a32a97a110a100a32a104a97a108a-6a32a102a+3a-3a116a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a110a-5a+5a-9a32a97a110a100a32a104a97a108a-6a32a102a+3a-3a116a104a32a116a105a+4a-8a115a32a116a+3a101a+9a+6a+5a10a111ava-9a32a104a117a-7a100a114a101ava

This is an improved version of Beta Decays program.

05AB1E, 127 123 120 115 bytes
“¡×€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿áÓÁÏ‰ª†ìdßàŒšdï¿dŸ¯een¥Šd“¤'…§:#©`…«¹¿œÖƒ#“‰ª„í¦ƒ†ì³ä“#ε…ÿ„Æ«¹NÈi„Š£ ì]«vyTG®Nè'€ƒ‚yª]„€µ°¡»

Try it online!
“¡× (...) Šd“         # dictionary string "zero one two ... sixd sevend eighteen nined"
¤                     # get the last letter ("d") without popping
 '…§                  # dictionary string "teen"
    :                 # replace (changes all "d" to "teen" in the initial string)
     #                # split on spaces
      ©               # save this list to the register
       `              # dump all items on the stack
…«¹¿œÖƒ               # dictionary string "twenty thirty fourty"
       #              # split on spaces
“‰ª„í¦ƒ†ì³ä“          # dictionary string "third three fourth four fifth"
            #         # split on spaces
ε              ]      # for each:
 …ÿ„Æ«¹               #  append " times twenty"
       NÈi     ]      #  if the iteration count is even:
          „Š£ ì       #   prepend "half "
                «     # merge those two lists ([20, 30, 40] and [50, 60, 70, 80, 90])
v            ]        # for y in this list of names:
 y                    #  put y on the stack
  TG         ]        #  for N from 1 to 9:
    ®Nè               #   get the Nth element in the register
       '€ƒ‚           #   append "and"
           yª         #   append y
„€µ°¡                 # dictionary string "one hundred"
     »                # join the stack with newlines

That's 230 bytes, with 115 wide (16-bit) characters.

@JohnTromp no, that’s 115 8-bit characters. See 05AB1E’s codepage.

Ok; I stand corrected.

JavaScript (ES6), 346 bytes
Only a small idea to ETHproductions' solution:
Replace f(..) with a[..] to be able to call f recursively to concat the output.
f=x=>(a="1one1two1three1four1five1six1seven1eight1nine1ten1eleven1twelve1thir11fif111eigh".split(1),x<1?"zero":f(x-1)+(x<13?a[x]:x<20?(a[x]||a[x-10])+"teen":x>99?"one hundred":(x%10?a[x%10]+" and ":"")+(x<50?"twen1thir1for".split(1)[x/10-2|0]+"ty":(x%20>9?"half "+"third1forth1fifth".split(1)[x/20-2.5|0]:a[x/20|0])+" times twenty")))+"\n"
f(100)

Still far away from optimal...

Java 8 7, 512 490 + 19(import) bytes
Needs an import import java.util.*;
<T>void y(List<T>l,T...a){for(T t:a)l.add(t);}List x(){String b="teen",c="twenty",d="half ",e=" times "+c;String[]a={"zero","one","two","three","four","five","six","seven","eight","nine"},f={c,"thirty","fourty",d+"third"+e,a[3]+e,d+"fourth"+e,a[4]+e,d+"fifth"+e};List<String>g=new ArrayList<>(Arrays.asList(a));y(g,"ten","eleven","twelve","thir"+b,a[4]+b,"fif"+b,a[6]+b,a[7]+b,"eigh"+b,a[9]+b);for(String h:f){y(g,h);for(int i=1;i<=9;i++)y(g,(a[i]+" and "+h));}y(g,"one hundred");return g;}

Ungolfed:
<T> void y(List<T> l, T... a) {
    for (T t : a) {
        l.add(t);
    }
}

List x() {
    String b = "teen", c = "twenty", d = "half ", e = " times " + c;
    String[] a = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"},
        f = {c, "thirty", "fourty", d + "third" + e, a[3] + e, d + "fourth" + e, a[4] + e, d + "fifth" + e};
    List<String> g = new ArrayList<>(Arrays.asList(a));
    y(g, "ten", "eleven", "twelve", "thir" + b, a[4] + b, "fif" + b, a[6] + b, a[7] + b, "eigh" + b, a[9] + b);

    for (String h : f) {
        y(g, h);
        for (int i = 1; i <= 9; i++) {
            y(g, (a[i] + " and " + h));
        }
    }

    y(g, "one hundred");
    return g;
}

To run this, simply call <instance>.x();. This now returns the list containing all numbers.
Try it here!

Python 2, 359 349 345 Bytes
a='one two three four five six seven eight nine'.split()
c=['ten','eleven','twelve']+[i+'teen'for i in['thir',a[3],'fif',a[5],a[6],'eigh',a[8]]]
p=' times twenty'
h='half '
x=[p[7:],'thirty','forty',h+'third'+p,a[2]+p,h+'forth'+p,a[3]+p,h+'fifth'+p]
f=['zero']+a+c
for i in x:f+=[i];f+=[b+' and '+i for b in a]
for i in f+['one hundred']:print i

Explanation:
Create a list of the first 9 numbers.
Create a list of the next 10 numbers.
Create a list of the endings - twenty, thirty, forty, half third times twenty etc
Join the first two lists with zero
Append to the list each of the numbers from 50 onwards.
Print out list
Ungolfed code:
firstNumbers=['one','two','three','four','five','six','seven','eight','nine']
teenNumbers=['ten','eleven','twelve','thirteen','fourteen','fifteen','sixteen','seventeen','eighteen','nineteen']
endings=['twenty','thirty','forty','half third times twenty','three times twenty','half forth times twenty','four times twenty','half fifth times twenty']
joined=['zero']+firstNumbers+teenNumbers
for ending in endings:
    joined.append(ending)
    for number in firstNumbers:
        joined.append(number + 'and' + ending)
joined.append('one hundred')
for line in joined:
    print line

Some golfing: teen line - remove space after in; move q into the only place it is used; do for i in f+['one hundred']:print i

@JonathanAllan The score actually measured it with the q='and' - I'd noticed, just forgot to change it here! Thanks!

Python 2, with num2words, 206 bytes
Even with num2words it takes quite a few bytes!
This is a full program.
from num2words import num2words as w
for i in range(1,101):d=i/10;e=w(i).split('-');print' and '.join(e[1:]+[10>d>4 and((d%2 and'half '+{5:'third',7:'forth',9:'fifth'}[d]or w(d/2))+' times twenty')or e[0]])

Here is a mocked version on ideone
(By mocked I mean that since the online interpreter does not have num2words I replaced w with a lambda which looks up num2word's output in a list)
ungolfed and with 'fourth' rather than the allowed 'forth' (which saves a byte):
from num2words import num2words
for i in range(1,101):
    d = i / 10 # i div 10
    e = num2words(i).split('-') # i in English words with a "-" separator, split into parts
    if d > 4 and d < 10:
        if d % 2:
            p = 'half '+ {5:'third', 7:'fourth', 9:'fifth'}[d] + ' times twenty'
        else:
            p = num2words(d / 2) + ' times twenty'
    else:
        p = e[0]
    print' and '.join(e[1:]+[p])

Note that the separator used by num2words(100) is a space, whereas for the other numbers it is a "-", so we don't need to do anything fancy for that case other than stop it from being "five times twenty".

Aside
If the challenge were to actually produce the numbers in Danish one could take the lang_DK.py from the github page and use:
from num2words import*
[num2words(i,lang='dk')for i in range(1,101)]

for 68 bytes, yielding:
['et', 'to', 'tre', 'fire', 'fem', 'seks', 'syv', 'otte', 'ni', 'ti', 'elleve', 'tolv', 'tretten', 'fjorten', 'femten', 'seksten', 'sytten', 'atten', 'nitten', 'tyve', 'enogtyve', 'toogtyve', 'treogtyve', 'fireogtyve', 'femogtyve', 'seksogtyve', 'syvogtyve', 'otteogtyve', 'niogtyve', 'tredive', 'enogtredive', 'toogtredive', 'treogtredive', 'fireogtredive', 'femogtredive', 'seksogtredive', 'syvogtredive', 'otteogtredive', 'niogtredive', 'fyrre', 'enogfyrre', 'toogfyrre', 'treogfyrre', 'fireogfyrre', 'femogfyrre', 'seksogfyrre', 'syvogfyrre', 'otteogfyrre', 'niogfyrre', 'halvtreds', 'enoghalvtreds', 'tooghalvtreds', 'treoghalvtreds', 'fireoghalvtreds', 'femoghalvtreds', 'seksoghalvtreds', 'syvoghalvtreds', 'otteoghalvtreds', 'nioghalvtreds', 'treds', 'enogtreds', 'toogtreds', 'treogtreds', 'fireogtreds', 'femogtreds', 'seksogtreds', 'syvogtreds', 'otteogtreds', 'niogtreds', 'halvfjerds', 'enoghalvfjerds', 'tooghalvfjerds', 'treoghalvfjerds', 'fireoghalvfjerds', 'femoghalvfjerds', 'seksoghalvfjerds', 'syvoghalvfjerds', 'otteoghalvfjerds', 'nioghalvfjerds', 'firs', 'enogfirs', 'toogfirs', 'treogfirs', 'fireogfirs', 'femogfirs', 'seksogfirs', 'syvogfirs', 'otteogfirs', 'niogfirs', 'halvfems', 'enoghalvfems', 'tooghalvfems', 'treoghalvfems', 'fireoghalvfems', 'femoghalvfems', 'seksoghalvfems', 'syvoghalvfems', 'otteoghalvfems', 'nioghalvfems', 'ethundrede']

Bash (using rev and sed), 299 276  bytes
I'm using bash's curly braces-expansion. However the braces are expanded in the wrong order, so I print all the words in reverted order and then fix the order of the letters using rev. After that, I still need some adjustments using sed:
printf '%s\n' orez {,{neet,yt{newt,riht,rof},ytnewt\ semit\ {drihtX,eerht,htruofX,ruof,htfifX}}Y}{,eno,owt,eerht,ruof,evif,xis,neves,thgie,enin} derdnuh\ eno |rev |sed -r 's,^Yte,t,;s,^Y,,;12s,.*,eleven,;13s,o.*,elve,;1,20{s,reeY,ir,;s,veY,f,;s,(t|)Y,,};s,Y, and ,;s,X,half ,'

A bit less unreadable:
printf '%s\n' orez {,{neet,yt{newt,riht,rof},\
ytnewt\ semit\ {drihtX,eerht,htruofX,ruof,htfifX}}Y}\
{,eno,owt,eerht,ruof,evif,xis,neves,thgie,enin} \
    derdnuh\ eno \
    |rev \
    |sed -r 's,^Yte,t,;
            s,^Y,,;
            12s,.*,eleven,;
            13s,o.*,elve,;
            1,20{s,reeY,ir,;s,veY,f,;s,(t|)Y,,};
            s,Y, and ,;
            s,X,half ,'

PHP , 318 Bytes
for($i=~0;$i++<100;)echo([0=>zero,10=>ten,eleven,twelve,thirteen,15=>fifteen,18=>eighteen,100=>"one hundred"][$i]??["",one,two,three,four,five,six,seven,eight,nine][$i%10].($i>20&&$i%10?" and ":"").["",teen,twenty,thirty,forty,"half third",three,"half fourth",four,"half fifth"][$i/10].($i>49?" times twenty":"")).",";

first pick with the Null coalescing operator ?? the exceptions.
this version with 314 Bytes is without the , at the end
zero<?php for($i=0;$i++<100;)echo",".([10=>ten,eleven,twelve,thirteen,15=>fifteen,18=>eighteen][$i]??["",one,two,three,four,five,six,seven,eight,nine][$i%10].($i>20&&$i%10?" and ":"").["",teen,twenty,thirty,forty,"half third",three,"half fourth",four,"half fifth"][$i/10].($i>49?" times twenty":""));?>,one hundred

ink, 286 273 bytes
zero
-(c){
-c>9 and c<20:
{ten|eleven|twelve|{thir|four|fif|six|seven|eigh|nine}teen}
-c%10:
{&one|two|three|four|five|six|seven|eight|nine}{c>9: and {t}}
-1:
~temp t="{twenty|thirty|forty|{&half {third|fourth|fifth}|{three|four}} times twenty}"
{t}
}
{c<99:->c}one hundred

Try it online!

-13 bytes by removing a useless "five times twenty" case, special-casing zero to be able to simplify the mod check, and simplifying the teens (which now also include ten)

Ink has sequences - they look like {a|b|c} and evaluate to a different value each time, until there's no next value at which point they stick with the last one. By combining and nesting these, we can get pretty advanced with very little in the way of actual conditionals.
A sequence that begins with {& instead of just { is a cycle - those loop and that's how we count units and how we alternate between "half nth times twenty" and "n times twenty" for the tens.
We keep track of the name for the tens in a variable t which we only update every tenth pass through the loop. On the passes where we update the variable, we print only the variable, on other passes we use cycles to print the unit followed by and {t}.
With a handful exceptions - below ten we skip printing the tens (no three and zero) and the teens are irregular enough that they get a sequence all to themselves.
c is a labelled gather. Gathers by themselves don't do anything, but they can be diverted to as a form of control flow, and they keep track of how many times they've been visited - we use this readcount to special-case the teens, to know when we need to update the tens variable, and to know when to stop looping, wrap everything up and print one hundred.
I know I could save a byte by using "forth" instead of "fourth", but I'm choosing not to.
Ungolfed
zero // Print "zero"
- (c)
{
- c > 9 and c < 20:
    // The teens get a sequence of their own because they don't fit into the other numbers' pattern.
    {ten|eleven|twelve|{thir|four|fif|six|seven|eigh|nine}teen}
- c % 10: // Otherwise, unless we're meant to print a multiple of ten
    // Print the unit - this is a cycle, so it loops when it's been run through nine times.
    {&one|two|three|four|five|six|seven|eight|nine}
    {c > 9:<> and {t}} // If we're past nine (and, since we didn't enter the "teens" section earlier, past nineteen), also print " and " and the contents of the variable t.
- else:
    // Set the variable t to the multiple of ten we want. Note the cycle to alternate between "half nth" and "n"
  ~ temp t="{zero|ten|twenty|thirty|forty|{&half {third|fourth|fifth}|{three|four}} times twenty}"

    {t} // Print the contents of t
}
{c < 99: -> c} // If we've done all this fewer than a hundred times, we go back to the top.
one hundred // Print "one hundred"
// Out of content, end of program

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:
“HHeelllloo,, EEaarrtthh!!”
Much like this challenge, write a program or function that takes no input and prints or returns the string
Hello, Earth!

with an optional trailing newline.
The catch is that your program must be an even number of characters long, and each two character chunk of your program must consist of identical characters.
For example, a valid program might look like
AAbb==11++♥♥

[[--  2222]]

because every two character chunk (AA, bb, ==, 11, etc.) is made of two identical characters (even the newlines).
A program such as
AAbB==11++♥♥

[[--  2222]]

would not be valid because the bB chunk is not made of identical characters.
The only exception to the rule is that \r\n should be treated a single, generic "newline" character since replacing it with \r\r\n\n wouldn't work or make sense for some languages and systems.
The shortest code in bytes wins. The example is 30 bytes long (not 15, not 13).

You are banning most non esolangs

@RohanJhunjhunwala That's the way it goes.

-1 for trivial challenge masked by source-layout/restricted-source (something new users are heavily bashed for). Also I dislike the narrow language restrictions

@Downgoat I think this a perfectly valid/interesting challenge, and I don't see any language restrictions.

@ConorO'Brien you may vote how you like. I am entitled as so too, I always comment when I downvote

@Downgoat s/downvote/downgoat most non esolang like languages are arbitrarily disqualified like this. I support the downgoat. +1 to your comments

@RohanJhunjhunwala To be clear, no languages have been disqualified, it just may be impossible in many. And I think it's good once in a while to have a challenge that lets real esolangs shine. Most challenges are invariably full of mainstream and golfing language answers as there is no need for anything more exceptional.

@HelkaHomba I understand that no language has been explicitly banned, but I feel most good challenges should at least remain theoretically possible in most Turing Complete challenges. It is nothing personal.

"Hello, Earth!" has an odd number of characters. That'll make it harder...

Not trying to start/prolong a discussion, and you're certainly entitled to vote as you see fit, but new users usually create yet another incarnation of perform task T without using the characters XYZ or the built-in B, which is utterly repetitive and on occasions unclear.

@Sp3000: It´s not an exact duplicate. The other challenge has the subsequent restriction only on certain positions.

@Titus I think you may have misread the other specification. The wording is a bit more convoluted than in this challenge, but it's also saying that every pair of characters needs to be identical.

@MartinEnder: Oh right. I misread 2n as 2^n.

Lenguage, 1354616599400377002855073561913010716386821416114463012 bytes
It's 1354616599400377002855073561913010716386821416114463012 zeroes:
0000000000000000000000000000000000000000000000000000000000000000000000000000000000...00000000

It's this BF program:
-[------->+<]>-.-[->+++++<]>++.+++++++..+++.[->+++++<]>+.------------.++[->++<]>+.+[------>+<]>.--[--->+<]>---.++.------------.--[--->+<]>-.

Converted into binary:
001110001001001001001001001010000011111010001100001110001010000000000000000011111010000000100000000000000000000000100100000000000100110001010000000000000000011111010000100001001001001001001001001001001001001100000000110001010000000011111010000100000110001001001001001001010000011111010100001001110001001001010000011111010001001001100000000100001001001001001001001001001001001001100001001110001001001010000011111010001100

Converted into a decimal number:
1354616599400377002855073561913010716386821416114463012

With that many zeroes. Hooray for lenguage!

I had a 70 byte fish answer but didn't finish before this was closed...

@Blue Do you mean the shell?

@EriktheGolfer it was pretty much the same as the fish answer of the duped questions, just like this is kind of like the unary answer of the duped question.

@Blue I mean, is it ><> or is it fish? I guess it's ><>, but that's not called 'Fish', it's the Esolang page that has technical limitations.

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


text:
Conjugate a Turkish verb
Input

verb, a string that matches the regular expression ([a-pr-vyzıöüçğş]*[aeıioöuü][bcçdfgğhj-nprsştvyz]+|([a-pr-vyzıöüçğş]*[aeıioöuü]){2})(mak|mek)
plural, a truthy or falsy value
person, an integer having value either 1, 2, or 3
tense, an integer having value either 1, 2, or 3

Output
The conjugated form of the Turkish verb verb, in personst/nd/rd person, plural if plural is TRUE and singular if it is not, in

If tense is 1, the simple present;
If tense is 2, the continuing present;
If tense is 3, the future.

Rules
Turkish verbs are conjugated in three elements, which are in order:

The stem, formed by removing mak or mek from the end of the infinitive;
The sign of the tense, which is:

For the simple present:

-r if the stem ends in a vowel;
-ir according to vowel harmony rules (see below) if the stem contains more than one syllable (i.e. vowel), or is from one of the following irregular verbs: almak, bilmek, bulmak, durmak, gelmek, görmek, kalmak, olmak, ölmek, sanmak, vermek, varmak, vurmak;
-er according to vowel harmony rules if the stem contains one syllable and is not listed in the irregular verbs above.

For the continuing present, -iyor, where the i changes according to vowel harmony rules. Stems that end in a vowel drop this vowel before adding this suffix, whereupon the suffix harmonizes with the next-to-last vowel in the word (guaranteed to exist by the regular expression).
For the future:

-ecek according to vowel harmony rules if the stem ends in a consonant;
-yecek according to vowel harmony rules if the stem ends in a vowel.

The personal suffix to indicate the performer of the action, in all cases according to vowel harmony rules:
    |Singular|Plural|
|---|--------|------|
|1st|    -im |   -iz|
|2nd|   -sin |-siniz|
|3rd| (none) |  -ler|

The final k of the future tense becomes ğ before -im and -iz, so for example (almak, TRUE, 1, 3) would yield alacağız.

Vowel harmony rules
Turkish vowels are divided into two groups: back (a ı o u) and front (e i ö ü) by where in the mouth they are pronounced. The suffixes of a word change vowels according to the vowels of the root.
All suffixes listed above that have i as a vowel instead use:

-ı if the last vowel before the suffix is ı or a (both these vowels are back and unrounded);
-i if the last vowel before the suffix is i or e (both these vowels are front and unrounded; note here Turkish's distinction between dotted and dotless I);
-u if the last vowel before the suffix is u or o (both these vowels are back and rounded); or
-ü if the last vowel before the suffix is ü or ö (both these vowels are front and rounded).

Take careful note of the present continuous suffix -iyor. The i harmonizes, but the o does not change. The personal suffixes will thus harmonize with the o.
All the suffixes listed above that have e as a vowel instead use:

-e if the last vowel before the suffix is a front vowel; or
-a if the last vowel before the suffix is a back vowel.

Irregular verbs
The verbs gitmek, tatmak, ditmek, gütmek, and etmek change the final t to a d before any endings that begin with a vowel (which includes all the endings in this challenge). Any verb that ends in -etmek likewise changes the t to a d, and appends -er for the simple present (though this is not so for the other verbs).
Test cases
gütmek, FALSE, 1, 2 -> güdüyorum
almak, TRUE, 3, 3 -> alacaklar
boğmak, TRUE, 2, 1 -> boğarsınız
ölmek, FALSE, 3, 1 -> ölür
boyamak, TRUE, 1, 2 -> boyuyoruz
affetmek, FALSE, 2, 1 -> affedersin
söylemek, TRUE, 3, 1 -> söylerler
söylemek, FALSE, 3, 2 -> söylüyor
söylemek, FALSE, 1, 3 -> söyleyeceğim

Could you provide a test case for the -etmek rule?

@Arnauld Done. In doing so I discovered I made an error in the specification, which I have appended to the "irregular verbs" section.

This could do with a lot more test cases, since the spec is quite complex.

@Dave I added 3 more, which took me long enough on mobile. I'll add even more later.

Javascript (ES6), 466 456 451 446 bytes
(v,p,w,t)=>(R=g=>g.exec(s),T=r=>s=s.slice(0,-1)+r,Z=s=>s.replace(/\d/g,c=>l=['ıuiü'[(n='aıoueiöü'.search(l))>>1],'ae'[n>>2]][c]),(s=v.slice(k=l=0,-3)).replace(/[aıoueiöü]/g,c=>(L=l,l=c,k++)),(R(/^(gi|ta|di|gü)t$/)||(R(/et$/)&&(k=1)))&&T`d`,((E=R(/[aıoueiöü]$/))&&t==2?(l=L,T``):s)+Z([(E?'':k<2&!R(/^((k?a|bi|bu|ge|o|ö)l)|dur|gör|san|v[aeu]r$/))+'r','0yor',(E?'y1c1':'1c1')+'ğkk'[--w]][t-1])+Z('0m|0z|s0n|s0n0z||l1r'.split`|`[w+w+p],t-2||(l='o')))

Ungofled and commented
// Parameters:
//   - 'v' = verb
//   - 'p' = plural flag
//   - 'w' = person
//   - 't' = tense
(v, p, w, t) => (
  // R() - Helper function to execute a regular expression on the stem.
  R = g => g.exec(s),

  // T() - Helper function to replace the last character of the stem with 'r'.
  T = r => s = s.slice(0, -1) + r,

  // Z() - Function that applies vowel harmony to the string 's', assuming
  //       '0' = 'i' and '1' = 'e' and using the last encountered vowel 'l'.
  Z = s => s.replace(
    /\d/g,
    c => l = [
      'ıuiü' [(n = 'aıoueiöü'.search(l)) >> 1],
      'ae' [n >> 2]
    ][c]
  ),

  // Computes:
  //   - 's' = stem
  //   - 'k' = number of vowels in stem
  //   - 'l' = last vowel in stem
  //   - 'L' = penultimate vowel in stem
  (s = v.slice(k = l = 0, -3)).replace(/[aıoueiöü]/g, c => (L = l, l = c, k++)),

  // Applies ending 't' => 'd' for irregular verbs and those ending in -et(mek).
  (R(/^(gi|ta|di|gü)t$/) || (R(/et$/) && (k = 1))) && T `d`,

  // Computes 'E' = truthy value if the stem ends in a vowel.
  // If 'E' is truthy and the tense is the continuing present, drops this vowel.
  ((E = R(/[aıoueiöü]$/)) && t == 2 ? (l = L, T ``) : s) +

  // Appends sign of tense with vowel harmony.
  Z([
    // t = 1: simple present -> either '-er', '-ir' or '-r'
    (E ? '' : k < 2 & !R(/^((k?a|bi|bu|ge|o|ö)l)|dur|gör|san|v[aeu]r$/) + 'r',

    // t = 2: continuing present -> always '-iyor'
    '0yor',

    // t = 3: future -> either '-yecek', '-ecek', '-yeceğ' or '-eceğ'
    (E ? 'y1c1' : '1c1') + 'ğkk' [--w]
  ][t - 1]) +

  // Appends personal suffix with vowel harmony,
  // forcing last vowel to 'o' for continuing present.
  Z(
    '0m|0z|s0n|s0n0z||l1r'.split `|` [w + w + p],
    t - 2 || (l = 'o')
  )
)

Test cases

let f =
(v,p,w,t)=>(R=g=>g.exec(s),T=r=>s=s.slice(0,-1)+r,Z=s=>s.replace(/\d/g,c=>l=['ıuiü'[(n='aıoueiöü'.search(l))>>1],'ae'[n>>2]][c]),(s=v.slice(k=l=0,-3)).replace(/[aıoueiöü]/g,c=>(L=l,l=c,k++)),(R(/^(gi|ta|di|gü)t$/)||(R(/et$/)&&(k=1)))&&T`d`,((E=R(/[aıoueiöü]$/))&&t==2?(l=L,T``):s)+Z([(E?'':k<2&!R(/^((k?a|bi|bu|ge|o|ö)l)|dur|gör|san|v[aeu]r$/))+'r','0yor',(E?'y1c1':'1c1')+'ğkk'[--w]][t-1])+Z('0m|0z|s0n|s0n0z||l1r'.split`|`[w+w+p],t-2||(l='o')))

console.log(f("gütmek", false, 1, 2));    // -> güdüyorum
console.log(f("almak", true, 3, 3));      // -> alacaklar
console.log(f("boğmak", true, 2, 1));     // -> boğarsınız
console.log(f("ölmek", false, 3, 1));     // -> ölür
console.log(f("boyamak", true, 1, 2));    // -> boyuyoruz
console.log(f("affetmek", false, 2, 1));  // -> affedersin
console.log(f("söylemek", true, 3, 1));   // -> söylerler
console.log(f("söylemek", false, 3, 2));  // -> söylüyor
console.log(f("söylemek", false, 1, 3));  // -> söyleyeceğim

Does this account for the d-mutation on all verbs ending in -etmek? I don't know JavaScript but from what I can gather it looks like it's just lumped in with the others.

@EMBLEM - This should be fixed.

sed, 583 bytes
sed -E 's/^((bul|dur|k?al|ol|san|v[au]r)ma|(bil|gel|gör|öl|ver)me)k( . .) 1/\2\3Ir\4/;s/etmek( . .) 1/edEr\1/;s/etmek /ed /;s/^((ta)tma|([dg]i|gü)tme)k /\2\3d /;s/m[ae]k / /;s/([aıoueiöüEI])/V\1/g;s/(V.)( . .) 1/\1r\2/;s/(V.+V.+)( . .) 1/\1VIr\2/;s/( . .) 1/VEr\1/;s/(V.)?( . .) 2/VIyVor\2/;s/(V.)( . . 3)/\1y\2/;s/( . .) 3/VEcVEk\1/;s/k( . 1)/ğ\1/;s/ 0 1/VIm/;s/ 1 1/VIz/;s/ 0 2/sVIn/;s/ 1 2/sVInVIz/;s/ 0 3//;s/ 1 3/lVEr/;:l
s/([ıa][^V]*V)I/\1ı/;s/([ie][^V]*V)I/\1i/;s/([uo][^V]*V)I/\1u/;s/([üö][^V]*V)I/\1ü/;s/([aıou][^V]*V)E/\1a/;s/(V[^aEI][^V]*V)E/\1e/;t l
s/V//g'

Like my answer to the closely-related Dactylic Hexameter question, this is really just translating the rules as given into regular expressions.
Usage:
Takes input in the form:
word [01] [123] [123]

So the test cases are:
printf 'gütmek 0 1 2
almak 1 3 3
boğmak 1 2 1
ölmek 0 3 1
boyamak 1 1 2
affetmek 0 2 1
söylemek 1 3 1
söylemek 0 3 2
söylemek 0 1 3' | sed -E '<...>';

Breakdown:
sed -E "
# special cases for simple present tense
 s/^((bul|dur|k?al|ol|san|v[au]r)ma|(bil|gel|gör|öl|ver)me)k( . .) 1/\2\3Ir\4/;

# stemming
# always uses -er rule if simple present
 s/etmek( . .) 1/edEr\1/;
 s/etmek /ed /;
 s/^((ta)tma|([dg]i|gü)tme)k /\2\3d /;
 s/m[ae]k / /;

# mark vowels for easier expressions later
 s/([aıoueiöüEI])/V\1/g;

# simple present
 s/(V.)( . .) 1/\1r\2/;
 s/(V.+V.+)( . .) 1/\1VIr\2/;
 s/( . .) 1/VEr\1/;

# continuing present
 s/(V.)?( . .) 2/VIyVor\2/;

# future
 s/(V.)( . . 3)/\1y\2/;
 s/( . .) 3/VEcVEk\1/;

# personal suffix
 s/k( . 1)/ğ\1/;
 s/ 0 1/VIm/;
 s/ 1 1/VIz/;
 s/ 0 2/sVIn/;
 s/ 1 2/sVInVIz/;
 s/ 0 3//;
 s/ 1 3/lVEr/;

# vowel harmony
 :l
 s/([ıa][^V]*V)I/\1ı/;
 s/([ie][^V]*V)I/\1i/;
 s/([uo][^V]*V)I/\1u/;
 s/([üö][^V]*V)I/\1ü/;

 s/([aıou][^V]*V)E/\1a/;
 s/(V[^aEI][^V]*V)E/\1e/;
# keep looping until all vowels are known
 t l

# unmark vowels
 s/V//g
"

Results for test cases:
güdüyorum
alacaklar
boğarsınız
ölür
boyuyoruz
affedersin
söylerler
söylüyor
söyleyeceğim

You are correct about affedersin. I switched pronouns several times while writing that

Take note of case 2; it should be alacaklar, not ler.

@EMBLEM fixed; cost me 2 more bytes though (but what's 2 bytes in 600?)

You can remove sed -E '', since you specified sed as being the language and not bash, so consider the script as sed source code. You could then run it like: printf ...|sed -Ef filename, adding 1 byte more for the E flag, saving 8 bytes in the end. Btw, never knew until today that -E is equivalent to -r!


text:
Tips for golfing in SageMath
SageMath is an open-source mathematics software system, built on Python 2. Its extensive math library support makes it a strong choice for golfing in math-based challenges.
What tips do you have for golfing in SageMath? One tip per answer, please. Tips should be specifically for SageMath, and not general golfing tips ("remove unnecessary whitespace"). Tips that apply to Python in general should go in the Python tips post.

Only 7 answers to date have used SageMath on PPCG, if anyone wants to have a look at them, they are listed here.


text:
4-way intersection generator
Here is an ASCII-art of a 4-way intersection:
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |
-----+-----+-----
     |     |
- - -|     |- - -
     |     |
-----+-----+-----
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |

(Note how the horizontal roads are 3 rows tall, while the vertical roads are 5 columns wide. This is for aesthetic reasons, because of the rectangular font.)
Your challenge is to produce this ASCII art. However, as I'm sure you all know, not every intersection has a road travelling off in every single direction. This particular intersection goes NESW, but some intersections might go, for example, NW:
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |
-----+-----+
     |     |
- - -|     |
     |     |
-----+-----+

Or it might go SWE:
-----+-----+-----
     |     |
- - -|     |- - -
     |     |
-----+-----+-----
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |

Or it may even go E, just a single direction (although you can hardly call this an intersection, but try to avoid being overly pedantic):
     +-----+-----
     |     |
     |     |- - -
     |     |
     +-----+-----

You need to write a program or function that can easily generate any of these combinations. More specifically, your challenge is to write a program or function that takes a string of directions, consisting of NESW, as input, and outputs or returns this ASCII art of an intersection with roads pointing in those directions. These directions may appear in any order, but the input will not contain any characters except for N, E, S, or W. If you like, you may request inputs to be lowercase instead, but you must specify this in your answer. You may also assume that all inputs will contain at least one direction.
The last example had leading spaces on each line, because there is no road going west. If you do not have a road going west, these leading spaces are optional. This:
+-----+-----
|     |
|     |- - -
|     |
+-----+-----

Would also be an acceptable output. Similarly, if N or S is gone, empty lines in there place are optional. One trailing newline is allowed, and trailing spaces are allowed as long as the output is visually the same.
You may take input and output in any reasonable format, such as STDIN/STDOUT, command line args, files, function arguments/return values, etc.
As usual, this is code-golf, so try to get the shortest possible answer in whatever language you happen to use!
Sample IO:
NESW:

     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |
-----+-----+-----
     |     |
- - -|     |- - -
     |     |
-----+-----+-----
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |

NS:

|  |  |
|     |
|  |  |
|     |
|  |  |
+-----+
|     |
|     |
|     |
+-----+
|  |  |
|     |
|  |  |
|     |
|  |  |

S:

+-----+
|     |
|     |
|     |
+-----+
|  |  |
|     |
|  |  |
|     |
|  |  |

EW:

-----+-----+-----
     |     |
- - -|     |- - -
     |     |
-----+-----+-----

SE:
+-----+-----
|     |
|     |- - -
|     |
+-----+-----
|  |  |
|     |
|  |  |
|     |
|  |  |

Are trailing spaces also allowed (if there's no E, for instance)? Are leading and trailing blank lines allowed if there's no N or S?

@GregMartin Yes, those are allowed. See my edit.

vaguely related, you reminded me of this code I mostly wrote, for road intersections in a roguelike game: https://github.com/CleverRaven/Cataclysm-DDA/blob/master/src/mapgen_functions.cpp#L1080-L1347

Javascript (ES6), 190 187 185 bytes
This is an attempt to build this ASCII art character per character by iterating on a 17x15 matrix. Therefore, the output is always made of 15 rows of 17 columns with the intersection of the roads centered in the middle.
p=>eval("for(y=15,s='';y--;s+=`\n`)for(x=17;x--;)s+=' |-+'[+[a=y>4,b=y<10,c=x>4,d=x<12].every((c,i)=>c|p.search('SNEW'[i])+1)&&!((z=x-8||y&1|a&b)&&z*z-9)+2*!((z=y-7||x&1|c&d)&&z*z-4)]")

Ungolfed and commented
for(y = 15, s = ''; y--; s += `\n`)   // iterate on y, from 14 to 0 / append line feeds
  for(x = 17; x--;)                   // iterate on x, from 16 to 0
    s += ' |-+' [                     // append next character to string
      +[ a = y > 4,                   // a = outside South area?
         b = y < 10,                  // b = outside North area?
         c = x > 4,                   // c = outside East area?
         d = x < 12 ]                 // d = outside West area?
      .every((c, i) =>                // for each area, see if either:
        c |                           //   - we're currently outside it
        p.search('SNEW' [i]) + 1      //   - or it's an allowed area (p = function param.)
      )                               // if all tests pass, add a:
      &&                              //   - vertical bar (encoded as 1) if:
      !((z = x - 8 || y & 1 | a & b)  //     - x=8, y is even and we're not in the middle
      && z * z - 9)                   //     - OR x=5 OR x=11 (<=> (x-8)*(x-8) = 9)
      + 2 *                           //   - horizontal bar (encoded as 2) if:
      !((z = y - 7 || x & 1 | c & d)  //     - y=7, x is even and we're not in the middle
      && z * z - 4)                   //     - OR y=5 OR y=9 (<=> (y-7)*(y-7) = 4)
    ]                                 // (vertical + horizontal = 3, which leads to '+')

Matrix
Below is the matrix with the coordinates used in the code.

Demo
The following snippet allows to try any road configuration.

let f =
p=>eval("for(y=15,s='';y--;s+=`\n`)for(x=17;x--;)s+=' |-+'[+[a=y>4,b=y<10,c=x>4,d=x<12].every((c,i)=>c|p.search('SNEW'[i])+1)&&!((z=x-8||y&1|a&b)&&z*z-9)+2*!((z=y-7||x&1|c&d)&&z*z-4)]")

function update() {
  document.getElementById("o").innerHTML = f(document.getElementById("s").value);
}
update();
<input id="s" size=4 value="NSEW" oninput="update()">

PowerShell v3+, 226 204 192 191 bytes
param([char[]]$a)($n=0..4|%{($x=' '*5*($b=87-in$a))+('|  |  |',($w='|     |'))[$_%2]})*(78-in$a)
($z=($y='-'*5)*$b+"+$y+"+$y*($c=69-in$a))
$x+$w
'- - -'*$b+$w+'- - -'*$c
$x+$w
$z
$n*(83-in$a)

Takes input as a string of capital letters, explicitly casts it as a char array. Constructs the "North" segment via looping from 0 to 4. Each loop, constructs a string of 5 spaces (if W/87 is present in the input), stores that in $x, then either |     | (stored in $w) or |  |  |, depending upon whether we're currently even or odd. That array of strings is stored into $n, and multiplied by whether N/78 is -in the input. That will determine if $n is placed on the pipeline or not.
Then, we construct the middle portion. The first line, $z is the "top" of the east-west route, using the same logic for W and E/69, and surrounded in parens to also place a copy on the pipeline. We use helper variable $y to save a byte on the ----- sections.
The next line is just the appropriate number of spaces (i.e., $x) string-concatenated with the correct-width pipes (i.e., $w). Then, the middle striped line, again with W and E logic and $w filling in the middle. Then $x+$w and $z again.
Finally, since the South road is the same as the north, put $n on the pipeline if S/83 is -in $a.
All of those resultant strings are gathered from the pipeline and output is implicit at the end of program execution. Abuses the default Write-Output delimiter to insert a newline between elements.

Examples
PS C:\Tools\Scripts\golfing> .\4-way-intersection.ps1 'EN'
|  |  |
|     |
|  |  |
|     |
|  |  |
+-----+-----
|     |
|     |- - -
|     |
+-----+-----

PS C:\Tools\Scripts\golfing> .\4-way-intersection.ps1 'SNW'
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |
-----+-----+
     |     |
- - -|     |
     |     |
-----+-----+
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |

PS C:\Tools\Scripts\golfing> .\4-way-intersection.ps1 'WE'
-----+-----+-----
     |     |
- - -|     |- - -
     |     |
-----+-----+-----

C++ 317 280 276 bytes
int i(char*j){for(int y=0;y<15;++y)for(int x=0;x<18;++x)putchar(x-17?y<5&!strchr(j,'N')|y>9&!strchr(j,'S')|x<5&!strchr(j,'W')|x>11&!strchr(j,'E')?' ' :x==5|x==11?y==5|y==9?'+':'|':y==5|y==9?x==5|x==11?'+':'-':x==8&y%2|y==7&x%2?' ':x==8&(y/5-1)?'|':y==7&(x/6-1)?'-':' ':'\n');}

Ungolfed:
int i (char* j)
{
  for (int y=0; y<15; ++y)
    for (int x=0; x<18; ++x)
      putchar(
        x-17 ?
        y<5 & !strchr(j,'N') |
        y>9 & !strchr(j,'S') |
        x<5 & !strchr(j,'W') |
        x>11 & !strchr(j,'E') ? ' ' :
        x==5 | x==11 ? y==5 | y==9 ? '+' : '|' :
        y==5 | y==9 ? x==5 | x==11 ? '+' : '-' :
        x==8 & y%2 | y==7 & x%2 ? ' ' :
        x==8 & (y / 5 - 1) ? '|' :
        y==7 & (x / 6 - 1) ? '-' :
        ' ' : '\n');
}

Holy nested ternary operators, Batman!

We always knew they'd be good for something.

Replacing strchr with index will shave off few more. Define x and y together outside for loops.

Batch, 351 344 341 bytes
@echo off
set/pi=
set t=
if not "%i:n=%"=="%i%" call:l
set l=-----
set r=%l%
if "%i:w=%"=="%i%" set l=%t%
if "%i:e=%"=="%i%" set r=
for %%s in (%l%+-----+%r% "%t%|%t%|" "%l:--=- %|%t%|%r:--=- %" "%t%|%t%|" %l%+-----+%r%) do echo %%~s
if "%i:s=%"=="%i%" exit/b
:l
call :m
call :n
:n
echo %t%^|%t%^|
:m
echo %t%^|  ^|  ^|

Note: The line set t= ends in five spaces, and the line if "%i:e=%"=="%i%" set r= ends in a space. Takes case-insensitive input from STDIN. Edit: Saved 7 bytes by eliminating the d variable. Saved 3 bytes by using a for loop to print the middle section. If I'm allowed separate command-line parameters instead, then for 326 319 316 bytes:
@echo off
set t=%*
set/an=s=e=w=5,%t: ==%=0
set t=
call:%n%
set r=-----%t%
call set l=%%r:~%w%,5%%
call set r=%%r:~%e%%%
for %%s in (%l%+-----+%r% "%t%|%t%|" "%l:--=- %|%t%|%r:--=- %" "%t%|%t%|" %l%+-----+%r%) do echo %%~s
goto %s%
:0
call :1
call :2
:2
echo %t%^|%t%^|
:1
echo %t%^|  ^|  ^|
:5

Python 3, 186 bytes
S=' -- -  -- -  --'
lambda d:'\n'.join(S[r//4:15*('W'in d):3]+'||+  -  -| -  -  -||+'[r%4::3]+S[r//4:15*('E'in d):3]for r in[0,1,0,1,0,6,1,9,1,6,0,1,0,1,0][5-5*('N'in d):10+5*('S'in d)])

An anonymous lambda called with a string of directions, e.g. 'NWS'
Explanation to follow

sed 234
s,$,@+-----+@|     |@!     !@|     |@+-----+@,
:l;tl
/N/s,^,#,;t
:r
/S/s,@$,#,;t
/E/{s,!@,|- - -@,;s,+@,+-----@,g}
/W/{s,@!,@- - -|,;s,@+,@-----+,g;s,@|,@     |,g}
y,@!NSEW,\n|    ,
q
:
s,#,@|  |  |@|     |@|  |  |@|     |@|  |  |,
tr

It just builds the different parts if the proper character is on the line.
Uses @ instead of \n and subs \n back in at the end.
The north and south parts are identical, so I use what's basically a function to insert them.

Python 2, 290 bytes
t,s,r,i=[],[],range(5),raw_input()
for n in r:t+=[" "*5*("W"in i)+"|  "+("|"," ")[n%2]+"  |"]
exec"s+=['-'*5];s[:1]+=' '*5,;"*2;s[:2]+="- - -",
if"N"in i:print'\n'.join(t)
print'\n'.join([s[n]*("W"in i)+("|     |","+-----+")[`n`in"04"]+s[n]*("E"in i)for n in r])
if"S"in i:print'\n'.join(t)

m,t,s=[],[],[] could be m=t=s=[].

range(5) could be saved into a variable and used twice, instead of typing range(5) twice.

What is m for?

@TuukkaX, for some reason having t=s=[] messes everything up

@OliverNi, oh nothing I forgot to remove it :p

I'm now certain that by doing m=t=s=[], they all point to the same reference.

Wow, thats useful reference information. No pun intended.

GolfScript, 154 bytes
{a?1+}:x;'-'5*:e;' '5*:b;"+"e+"+"+:f;{b'|'b'|'b n}:k;{'W'x{e}{b}if\'E'x{e}{}if n}:y;{x{b"|  |  |
"+:c k c k c}{}if}:z;1/:a;'N'z f y k'|'b+'|'+ y k f y'S'z

Try it online!

Impressive, no idea how this has no votes.

Pyth (385 380 373 353 bytes)
Golfed:
K"     |  |  |\n     |     |\n"?}\Nz++KKPKk?}\Wz?}\Ez+++*5\-*2+\+*5\-"\n     |     |\n- - -|     |- - -\n     |     |\n"+*5\-*2+\+*5\-++*2+*5\-\+"\n     |     |\n- - -|     |\n     |     |\n"*2+*5\-\+?}\Ez+"     "+*2+\+*5\-"\n     |     |\n     |     |- - -\n     |     |\n     +-----+-----"++"     +-----+\n"*3"     |     |\n""     +-----+"?}\Sz++KKPKk

Ungolfed:
K"     |  |  |\n     |     |\n"  //sets K to first two lines of north
?}\Nz                            //if north in the input
  ++KKPK                         //then: return K + K + K[:-1]
  k                              //else: return ""
?}\Wz                            //if West in input
  ?}\Ez                          //if East in input
    +++*5\-*2+\+*5\-"\n     |     |\n- - -|     |- - -\n     |     |\n"+*5\-*2+\+*5\-    //then: Return E+W string
    ++*2+*5\-\+"\n     |     |\n- - -|     |\n     |     |\n"*2+*5\-\+         //else: Return W string
  ?}\Ez                          //else: if east in input (and not W)
    +"     "+*2+\+*5\-"\n     |     |\n     |     |- - -\n     |     |\n     +-----+-----" //return East without West String
    ++"     +-----+\n"*3"     |     |\n""     +-----+" \\Return empty left and right intersection
?}\Sz                            //if south in input
  ++KKPK                         //return north string
  k                              //return ""

Of course, if there are any improvements please tell me.
Saved 5 bytes thanks to Maltysen
You can try it here

you can use K instead of N and then when assigning for the first time, you don't have to use an =, saving you a byte

also, N[:-1] is P

Groovy (274 Bytes)
Ungolfed
r{
    l->
    t='+-----+'
    s='     ';
    m='|     |'
    x='-----'
    v=(1..5).collect{s}
    nsR=(1..5).collect{[s,((it%2)?'|  |  |':m),s]}
    ewR=[x,s,'- - -',s,x]
    c=[l[3]?ewR:v,[t,m,m,m,t],l[1]?ewR:v]
    (l[0]?nsR.collect{it}:[])+((0..4).collect{x->((0..2).collect{y->c[y][x]})})+(l[2]?nsR.collect{it}:[])
}

Golfed
def i(l) {t='+-----+';s='     ';m='|     |';x='-----';v=(1..5).collect{s};n=(1..5).collect{[s,((it%2)?'|  |  |':m),s]};e=[x,s,'- - -',s,x];c=[l[3]?e:v,[t,m,m,m,t],l[1]?e:v];(l[0]?n.collect{it}:[])+((0..4).collect{x->((0..2).collect{y->c[y][x]})})+(l[2]?n.collect{it}:[])}

Try it: https://groovyconsole.appspot.com/script/5082600544665600