text:
Symmetric Numbers
write a function to tell if a number is symmetric or not.
for example:
input:
151
output:
True
input:
142
output:
False
and so on:
1111 True,
2390 False,
1226221 True

My question is not a duplicate, your's involve matrix and mine is different

Your question is largely the same; the older question asks "is it a palindrome in base X" whereas yours asks "is it a palindrome in base 10", so answers to the duplicate question would automatically be competitive here, with very little modification.

The challenge this was marked as a duplicate of only requires to convert the input to another base. This is just a special case with base $10$. By convention, when trivial modifications can be made to port the majority of answers from one challenge to the other while they are still competitive, marking one challenge as a duplicate of the other is recommended.

Either way, welcome to Programming Puzzles & Code Golf! Don't let the fact that your first challenge was marked as a dupe discourage you from posting in the future! In fact, to avoid such situations we have a Sandbox, where you can show your challenge to others prior to posting on the main site to receive feedback.

Python 2, 23 bytes
lambda n:`n`==`n`[::-1]

Try it online!


text:
Toggle some bits and get a square
Given an integer \$N>3\$, you have to find the minimum number of bits that need to be inverted in \$N\$ to turn it into a square number. You are only allowed to invert bits below the most significant one.
Examples

\$N=4\$ already is a square number (\$2^2\$), so the expected output is \$0\$.
\$N=24\$ can be turned into a square number by inverting 1 bit: \$11000 \rightarrow 1100\color{red}1\$ (\$25=5^2\$), so the expected output is \$1\$.
\$N=22\$ cannot be turned into a square number by inverting a single bit (the possible results being \$23\$, \$20\$, \$18\$ and \$30\$) but it can be done by inverting 2 bits: \$10110 \rightarrow 10\color{red}0\color{red}00\$ (\$16=4^2\$), so the expected output is \$2\$.

Rules

It is fine if your code is too slow or throws an error for the bigger test-cases, but it should at least support \$3 < N < 10000\$ in less than 1 minute.
This is code-golf!

Test cases
    Input | Output
----------+--------
        4 | 0
       22 | 2
       24 | 1
       30 | 3
       94 | 4
      831 | 5
      832 | 1
     1055 | 4
     6495 | 6
     9999 | 4
    40063 | 6
   247614 | 7        (smallest N for which the answer is 7)
  1049310 | 7        (clear them all!)
  7361278 | 8        (smallest N for which the answer is 8)
100048606 | 8        (a bigger "8")

Or in copy/paste friendly format:
[4,22,24,30,94,831,832,1055,6495,9999,40063,247614,1049310,7361278,100048606]

Almost half of the answers don't execute for 100048606 on TIO, is that a problem?

@MagicOctopusUrn Thanks, I've updated the rules to make it more clear that supporting $N\ge 10000$ is optional.

This would be a nice [tag:fastest-code] question as well (without the input size restriction)

@qwr Yes, probably. Or if you want to go hardcore: given $k$, find the smallest $N$ such that $f(N) = k$.

@Arnauld I felt this challenge should have an OEIS sequence: A358701

@HugoPfoertner Cool! Instead of "user Arnauld" from Code Golf, you may also use a direct reference to my OEIS account -- but whatever you choose is fine with me.

Links to user accounts in the LINKS section are problematic, but it should work under CODE. Hope this is ok for you. I'm curious if someone from the OEIS community will try an extension.

In the meantime, the sequence A358701 has actually received an additional term. Michael S. Branicky found $a(9)=743300286$, almost certainly using a Python program. You can also use this as a test if you want to determine the efficiency of the programs presented here.

Ruby, 74 bytes
->n{(1..n).map{|x|a=(n^x*x).to_s 2;a.size>Math.log2(n)?n:a.count(?1)}.min}

Try it online!
This simply generates the sequence \$\left[1^2, 2^2, \ldots, n^2\right]\$ (which is far more than enough), XORs it with \$n\$, and then takes either the number of 1s in its binary representation if the number of bits is less than or equal to \$\log_2n\$, or \$n\$ otherwise. It then takes the minimum number of bits flipped. Returning \$n\$ instead of the number of bits flipped when the highest bit flipped is greater than \$\log_2n\$ prevents these cases from being chosen as the minimum, as \$n\$ will always be greater than the number of bits it has.
Thanks to Piccolo for saving a byte.

You can save a byte by using (n^x*x).to_s 2;... instead of (n^x*x).to_s(2);...

@Piccolo Can't believe I missed that, thanks!

Jelly, 12 bytes
²,BẈEðƇ²^B§Ṃ

Try it online!
Check out a test suite!
Monadic link. Should be golfable. But I am too dumb to think of a way to get rid of the ³s. It's my first answer in which I successfully use filtering / mapping / looping in general along with a dyadic chain \o/
Explanation

²,BẈEðƇ²^B§Ṃ – Full program / Monadic link. Call the argument N.
     ðƇ      – Filter-keep [1 ... N] with the following dyadic chain:
²,BẈE        – The square of the current item has the same bit length as N.
²            – Square.
 ,           – Pair with N.
  B          – Convert both to binary.
   Ẉ         – Retrieve their lengths.
    E        – And check whether they equate.
       ²^    – After filtering, square the results and XOR them with N.
         B   – Binary representation of each.
          §  – Sum of each. Counts the number of 1s in binary.
           Ṃ – Minimum.

Husk, 20 bytes
▼mΣfo¬→S↑(Mo¤ż≠↔ḋİ□ḋ

Try it online!
Explanation
▼mΣf(¬→)S↑(M(¤ż≠↔ḋ)İ□ḋ) -- example input n=4
        S↑(           ) -- take n from n applied to (..)
                     ḋ  -- | convert to binary: [1,0,0]
                   İ□   -- | squares: [1,4,9,16,...]
           M(     )     -- | map with argument ([1,0,0]; example with 1)
                 ḋ      -- | | convert to binary: [1]
             ¤  ↔       -- | | reverse both arguments of: [1] [0,0,1]
              ż≠        -- | | | zip with inequality (absolute difference) keeping longer elements: [1,0,1]
                        -- | : [[1,0,1],[0,0,0],[1,0,1,1],[0,0,1,0,1],[1,0,1,1,1],....
                        -- : [[1,0,1],[0,0,0],[1,0,1,1],[0,0,1,0,1]]
    f(  )               -- filter elements where
       →                -- | last element
      ¬                 -- | is zero
                        -- : [[0,0,0]]
 mΣ                     -- sum each: [0]
▼                       -- minimum: 0

▼mΣfo¬←ṠMz≠ȯfo£İ□ḋπŀ2Lḋ saves 2 bytes. RIP you perfect square score.

@Mr.Xcoder: Shame about the score.. But I got rid of some more, now targetting 16 ;P

Perl 6, 65 bytes
{min map {+$^a.base(2).comb(~1) if sqrt($a+^$_)!~~/\./},^2**.msb}

Try it online!
I feel a little dirty for testing for a perfect square by looking for a period in the string representation of the number's square root, but...anything to shave off bytes.

05AB1E, 20 15 14 bytes
Lnʒ‚b€gË}^b1öß

-5 bytes thanks to @Mr.Xcoder using a port of his Jelly answer.
Try it online or verify all test cases (the biggest four test cases are removed, because they'll timeout after 60 sec).
Explanation:
L          # Create a list in the range [1, (implicit) input-integer]
           #  i.e. input=22 → [0,1,2,...,20,21,22]
 n         # Take the square of each
           #  i.e. [0,1,2,...,20,21,22] → [0,1,4,...,400,441,484]
  ʒ     }  # Filter this list by:
   ,       #  Pair the current value with the (implicit) input-integer
           #   i.e. 0 and 22 → [0,22]
           #   i.e. 25 and 22 → [25,22]
    b      #  Convert both to binary strings
           #   i.e. [0,22] → ['0','10110']
           #   i.e. [25,22] →  ['10000','11001']
     €g    #  Take the length of both
           #   i.e. ['0','10110'] → [1,5]
           #   ['10000','11001'] → [5,5]
       Ë   #  Check if both are equal
           #   i.e. [1,5] → 0 (falsey)
           #   i.e. [5,5] → 1 (truthy)
^          # After we've filtered, Bitwise-XOR each with the (implicit) input-integer
           #  i.e. [16,25] and 22 → [6,15]
 b         # Convert each to a binary string again
           #  i.e. [6,15] → ['110','1111']
  1ö       # Convert each to base-1, which effectively is a vectorized sum of their
           # digits, to get the amount of 1-bits in each binary string
           #  i.e. ['110','1111'] → [2,4]
ß          # Pop and leave the minimum of this list
           #  i.e. [2,4] → 2
           # (which is output implicitly as result)

Okay then, a valid 15-byter: Lnʒ‚b€gË}^b€SOß. It breaks your test suite unfortunately, though

@Mr.Xcoder Thanks! And my test suite almost always breaks after I golf something.. XD But it's fixed now as well.

I guess I'm not good at writing test suites in 05AB1E ¯\(ツ)/¯, it's nice that you have fixed it :)

Java (JDK 10), 110 bytes
n->{int i=1,s=1,b,m=99,h=n.highestOneBit(n);for(;s<h*2;s=++i*i)m=(s^n)<h&&(b=n.bitCount(s^n))<m?b:m;return m;}

Try it online!

You can save 1 byte by using bitwise and & instead of logical and &&

Gaia, 18 bytes
Near-port of my Jelly answer.
s¦⟪,b¦l¦y⟫⁇⟪^bΣ⟫¦⌋

Try it online!
Breakdown

s¦⟪,b¦l¦y⟫⁇⟪^bΣ⟫¦⌋ – Full program. Let's call the input N.
s¦                 – Square each integer in the range [1 ... N].
  ⟪      ⟫⁇        – Select those that fulfil a certain condition, when ran through
                     a dyadic block. Using a dyadic block saves one byte because the
                     input, N, is implicitly used as another argument.
   ,               – Pair the current element and N in a list.
    b¦             – Convert them to binary.
      l¦           – Get their lengths.
        y          – Then check whether they are equal.
           ⟪   ⟫¦  – Run all the valid integers through a dyadic block.
            ^      – XOR each with N.
             bΣ    – Convert to binary and sum (count the 1s in binary)
                 ⌋ – Minimum.

Wolfram Language (Mathematica), 67 bytes
Min@DigitCount[l=BitLength;#~BitXor~Pick[s=Range@#^2,l@s,l@#],2,1]&

Try it online!
Takes \$\{1, 2, \ldots, n\}\$ and squares them. Then, the numbers with same BitLength as the input are Picked, and BitXored with the input. Next, the Minimum DigitCount of 1s in binary is returned.

Brachylog, 56 41 bytes
It's not gonna break any length records but thought i'd post it anyway
⟨⟨{⟦^₂ᵐḃᵐ}{h∋Q.l~t?∧}ᶠ{ḃl}⟩zḃᶠ⟩{z{∋≠}ᶜ}ᵐ⌋

Try it online!

Just realized zipping is a thing. I'll shorten it after i come back from diner

@Arnauld Yeah, the main problem was that for each i in range(0,n+1) i recalculated the range, squared it and to binary. Putting this outside recuired a few more bytes but it's way faster now

x86-64 assembly, 37 bytes
Bytecode:
53 89 fb 89 f9 0f bd f7 89 c8 f7 e0 70 12 0f bd
d0 39 f2 75 0b 31 f8 f3 0f b8 c0 39 d8 0f 42 d8
e2 e6 93 5b c3

Nicely, this computes even the highest example in less than a second.
Heart of the algorithm is xor/popcount as usual.
    push %rbx
    /* we use ebx as our global accumulator, to see what the lowest bit
     * difference is */
    /* it needs to be initialized to something big enough, fortunately the
     * answer will always be less than the initial argument */
    mov %edi,%ebx
    mov %edi,%ecx
    bsr %edi,%esi
.L1:
    mov %ecx,%eax
    mul %eax
    jo cont     /* this square doesn't even fit into eax */
    bsr %eax,%edx
    cmp %esi,%edx
    jnz cont    /* can't invert bits higher than esi */
    xor %edi,%eax
    popcnt %eax,%eax
    cmp %ebx,%eax   /* if eax < ebx */
    cmovb %eax,%ebx
cont:
    loop .L1
    xchg %ebx,%eax
    pop %rbx
    retq

Suggest replacing at least one of your movs with an xchg

As far as I can tell there's only one that would save a byte (mov %ecx,%eax) and I can't let %ecx die there.

answer will always be less than the initial argument why, what env?---See the mov

PARI/GP 136 bytes
t(n)=b=#digits(n\2,2);for(j=0,b,v=concat(vector(b-j),vector(j,i,1));forperm(v,p,if(issquare(bitxor(n,fromdigits(Vec(p),2))),return(j))))

Test
T=[4, 22, 24, 30, 94, 831, 832, 1055, 6495, 9999, 40063, 247614, 1049310, 7361278, 100048606];
for (i=1, #T, print(T[i]," | "t(T[i])))
4 | 0
22 | 2
24 | 1
30 | 3
94 | 4
831 | 5
832 | 1
1055 | 4
6495 | 6
9999 | 4
40063 | 6
247614 | 7
1049310 | 7
7361278 | 8
100048606 | 8
> ##
***   last result computed in 736 ms.

Test with OEIS A358701(9):
t(743300286)
9
##
last result computed in 3,813 ms.

Charcoal, 31 bytes
ＮθＩ⌊ＥΦＥθ↨×ιι²⁼ＬιＬ↨θ²ΣＥ↨θ²¬⁼λ§ιμ

Try it online! Link is to verbose version of code. Explanation:
Ｎθ                              Input N
       θ                        N
      Ｅ                         Map over implicit range
          ιι                    Current value (twice)
         ×                      Multiply
        ↨   ²                   Convert to base 2
     Φ                          Filter over result
               ι                Current value
                  θ             N
                 ↨ ²            Convert to base 2
              Ｌ Ｌ               Length
             ⁼                  Equals
    Ｅ                           Map over result
                       θ        N
                      ↨ ²       Convert to base 2
                     Ｅ          Map over digits
                           λ    Current base 2 digit of N
                             ι  Current base 2 value
                              μ Inner index
                            §   Get digit of value
                          ⁼     Equals
                         ¬      Not (i.e. XOR)
                    Σ           Take the sum
   ⌊                            Take the minimum
  Ｉ                             Cast to string
                                Implicitly print

Jelly, 20 bytes
BL’Ø.ṗŻ€©Ḅ^⁸Æ²a§ɼ¹ƇṂ

Try it online!

Python 2, 82 bytes
lambda n:min(bin(i*i^n).count('1')for i in range(n)if len(bin(i*i^n))<len(bin(n)))

Try it online!

Japt -g, 20 bytes
This can be golfed down.
op f_¤Ê¥¢lÃ®^U ¤¬xÃn

Try it online!

C (gcc),  93  91 bytes
g(n){n=n?n%2+g(n/2):0;}m;i;d;f(n){m=99;for(i=0;++i*i<2*n;m=g(d=i*i^n)<m&d<n/2?g(d):m);n=m;}

Try it online!

Edit: I think my original solution (Try it online!) is not valid, because one of the variables, m, global to save a few bytes by not specifying type, was initialized outside of f(n) and therefore had to be reinitialized between calls

Ungolfed and commented code :
g(n){n=n?n%2+g(n/2):0;} // returns the number of bits equal to 1 in n
m; //miminum hamming distance between n and a square
i; //counter to browse squares
d; //bitwise difference between n and a square
f(n){m=99; //initialize m to 99 > size of int (in bits)
    for(
        i=0;
        ++i*i<2*n; //get the next square number, stop if it's greater than 2*n
        g(d=i*i^n)<m&&d<n/2&&(m=g(d)) //calculate d and hamming distance
//      ^~~~~~~~~~~^ if the hamming distance is less than the minimum
//                    ^~~~^ and the most significant bit of n did not change (the most significant bit contains at least half the value)
//                           ^~~~~~~^ then update m
       );
    n=m;} // output m

Edits:

Saved 2 bytes thanks to ceilingcat

Why d<n/2? I tried some case d>=n/2 but they end up different d

JavaScript (Node.js), 79 bytes
x=>g=(i=z=x)=>i?g(i-1,t=i*i^x,u=(N=i=>i&&i%2+N(i>>1))(t),z=z<u|t>x&i*i>x?z:u):z

Try it online!
If t and t^x are both larger than x then t is longer than x

source: Stack Exchange

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

sort: votes


text:
Minecraft Language Files Updater
In 1.13, Minecraft language files were switched from being a simple multi-line key=value format to JSON.
Challenge
Write a program converting from the original format returning a JSON string. Input can be taken using any standard input method, output must be json from any standard output method
The original format contains lines with key=value pairs, for example
tile.dirt.name=Dirt
advMode.nearestPlayer=Use "@p" to target nearest player

build.tooHigh=Height limit for building is %s blocks

Should be converted to one large JSON object with key=value
{
    "tile.dirt.name": "Dirt",
    "advMode.nearestPlayer": "Use \"@p\" to target nearest player",
    "build.tooHigh": "Height limit for building is %s blocks"
}

Some details

Any valid JSON is allowed as long as it contains only the correct key/value pairs. Trailing commas are allowed because Minecraft allows them.
The only things that must be escaped are quotes. (No newlines, backslashes, or other json-breaking things existed in the language file prior to 1.13)
Empty lines should be ignored
Lines contain exactly one equals

Test Cases
Input:
tile.dirt.name=Dirt
advMode.nearestPlayer=Use "@p" to target nearest player

build.tooHigh=Height limit for building is %s blocks

Output:
{
    "tile.dirt.name": "Dirt",
    "advMode.nearestPlayer": "Use \"@p\" to target nearest player",
    "build.tooHigh": "Height limit for building is %s blocks"
}

Input:
translation.test.none=Hello, world!
translation.test.complex=Prefix, %s%2$s again %s and %1$s lastly %s and also %1$s again!
translation.test.escape=%%s %%%s %%%%s %%%%%s
translation.test.invalid=hi %
translation.test.invalid2=hi %  s
translation.test.args=%s %s
translation.test.world=world

Output:
{
  "translation.test.none": "Hello, world!",
  "translation.test.complex": "Prefix, %s%2$s again %s and %1$s lastly %s and also %1$s again!",
  "translation.test.escape": "%%s %%%s %%%%s %%%%%s",
  "translation.test.invalid": "hi %",
  "translation.test.invalid2": "hi %  s",
  "translation.test.args": "%s %s",
  "translation.test.world": "world",
}

Input:
stat.mineBlock=%1$s Mined
stat.craftItem=%1$s Crafted
stat.useItem=%1$s Used
stat.breakItem=%1$s Depleted

Output:
{
    "stat.mineBlock": "%1$s Mined",
    "stat.craftItem": "%1$s Crafted",
    "stat.useItem": "%1$s Used",
    "stat.breakItem": "%1$s Depleted"
}

How does tile.dirt.name become "block.minecraft.dirt"?

@Pavel uuh... whoops. Fixed that. That was unintentional

Is it guaranteed that each non-empty line contains exactly 1 =?

@user202729 yes

I'd be willing to bet that you actually need a solution to this problem and intend to use one to convert your files. :)

What if the input contains \"?

No, Minecraft automatically does that

I'd know, I'm an Ubernerd of the highest level.

@ppperry it doesn't contain backslashes

Do we only need to handle English json?

@l4m2 english only is fine

Python 3, 91 77 bytes
-14 Bytes thanks to OMᗺ
I thought that the printout of a Python dictionary would be close enough to JSON to make it a very competitive language for this challenge.  However, the string representation of python dictionaries is different enough from JSON that I had better luck using python's built-in JSON library. I'll bet this can be done more succinctly in JavaScript.
import json
f=lambda x:json.dumps(dict(i.split("=")for i in x.split("\n")if i))

Try it Online!

Edit:
Bash + Sed, 68 63 bytes
Bug fix thanks to OMᗺ and Night 2
-5 Bytes thanks to OMᗺ
I realized that it might be more byte efficient to directly convert the text to JSON without bundling it in an object, as was my approach for the python solution.  Per byte, sed is the most powerful language for regex replacement that I know of.
echo {`echo "$1"|sed 's/"/\\\"/g;s/\(.*\)=\(.*\)/"\1":"\2",/'`}

Try it Online!
Explanation
echo {`                                  #  prints the leading curly brace
       echo "$1"|sed                     # feeds the input into sed
       's/"/\\"/g;                       # replaces " with \"
       s/\(.*\)=\(.*\)/"\1":"\2",/'      # surrounds the left and right hand sides of the equals with quotes and joins them with a colon
`}                                       # prints the closing curly brace

If you're answering in two different languages, feel free to post that as two separate answers.

For the bash+sed answer, try using the -r flag for sed (+3 bytes) so that you do not need to escape the capturing groups (-4 bytes) https://tio.run/##LYq7CgIxEEX7/YphUHygCVoqCxYWNoKNXQqzZtwNxo1kRkHUb4@62Jx74ZzKcpMzHZsIz0M32Jvhi8nBNMGANWpjDOp6yXqoxqPyB41mhgs0c5zoweGdcxYfSDmfRLX2QuX6@wrr7tvoSLVkE7Hsgn1QKvdMgKsrgkQQm2oS@Adw7YqiqG4@OCUxbnzdlBv6UiD4ixc4xQSd9m0NnqHPUIV4PPMH

Vim, 44 bytes
O{<Esc>:%s/"/\\"/g|%s/\v(.*)\=(.*)/"\1":"\2",
o}

Explanation:
O{<Esc>                                           Prepend {
       :%s/"/\\"/g                                Escape all "
                  |%s/\v(.*)\=(.*)/"\1":"\2",     Json-ify lines
o}                                                Append }

Rust, 150 bytes
|s:String|s.replace('"',"\\\"").split('\n').filter(|l|l.len()>0).map(|l|format!("\"")+&l.replace('=',"\":\"")+"\",").fold(format!("{{"),|r,n|r+&n)+"}"

Try it online!
Is it longer than Java?

Retina 0.8.2, 35 bytes
"
\"
=
": "
G`.
.+
    "$&",
^
{¶
$
¶}

Try it online! Would be 34 bytes in Retina 1 as you can use L$`.+ instead of G`. and .+. Explanation:
"
\"

Escape the quotes.
=
": "

Fix up the key/value separator. (If the value might contain a =, use 1`= at a cost of 2 bytes.)
G`.

Remove empty lines.
.+
    "$&",

Wrap each line in quotes. (The inner quotes were added earlier.)
^
{¶
$
¶}

Wrap the entire output in {}s.

Perl 5 -nl -M5.010, 58 54 bytes
BEGIN{say'{'}s'"'\"'g;/=/&&say qq|"$`": "$'",|}{say'}'

Try it online!

58 byte version:
BEGIN{say'{'}s'"'\"'g;s/(.*)=(.*)/"$1": "$2",/;END{say'}'}

Try it online!

Both versions add a comma after every key:value pair, which is technically not compliant JSON (the final comma before the closing } should be omitted and will fail most strict JSON validators). Here's a quick 58-byte rewrite which produces valid (if uglier for human readers) JSON:
``$c||='{';s'"'\"'g;/=/&&say qq|$c"$`":"$'"|;$c=','}{say'}'``

I expect you can find something a bit shorter/more elegant.

@mousetrapper That's a nice way to avoid the BEGIN. OP explicitly allows trailing commas though: "Trailing commas are allowed because Minecraft allows them.". Feel free to post that as a new answer, mentioning the difference.

Ah, yes, good point, missed that sentence in the original post. The default assignment only makes sense if you're trying to vary the first character, otherwise your BEGIN is still shorter in the case where you just want to emit the '{'. I like your END-avoiding technique. I knew that -n placed an  effective while(<>){} loop around your code; I had no idea just how literal that was.

I was pretty surprised too, when I first found that out. It's one of those Perl features that straddles the line between a weird hack and a brilliant way to do TIMTOWDI. I had forgotten about it though, so credit for it in this instance goes to Dennis in the Perl 5 golfing tips thread.

Husk, 22 bytes
String manipulation is not really Husk's strength, but it did pretty well:
`J"{}"J',mȯJ':msx'=fI¶

Try it online!
                      ¶  -- split on newlines
                    fI   -- filter by identity (ie. remove empty strings)
         m(        )     -- with each line
                x'=      -- | split on '='
              ms         -- | show each (ie. enclose in quotes and escape quotes)
           J':           -- | join with ':'
      J',                -- join these with ','
`J"{}"                   -- join the string "{}" with the result

Ironically, there is something called a "Husk" in Minecraft!

JavaScript, 66 63 62 bytes
s=>JSON.stringify(o=/(.+)=(.+)/g,s.replace(o,(_,a,b)=>o[a]=b))

f=
s=>JSON.stringify(o=/(.+)=(.+)/g,s.replace(o,(_,a,b)=>o[a]=b))

console.log(
  f(`tile.dirt.name=Dirt
advMode.nearestPlayer=Use "@p" to target nearest player

build.tooHigh=Height limit for building is %s blocks`)
)

-3 bytes thanks to @redundancy
-1 byte thanks to @l4m2

63 bytes on TIO

https://tio.run/##dVLBTt0wELznK7aIiESkRuXup6rlAJVokRAnQLBJNsHgeCPv8uB9/cMJQRx4vYzsmdmxd@1HXKM00Y36PXBL285uxa7@XP77a0SjC73rNgXbo8IclnaCo74SE2n02FDBVXFXYVWXdsXXeGvrstwqWBCwK2g4CHsynvuiK6SsDm7CQZllWtyrS3zropqAA9mTtMqwXZ@nG5hAGEn0wuOGor0Sgr2f4x4og2LsSWExwDg7sqx@dr41ynzq@gd7SgkVvBucQscRZjk1Ak4gF6g9N09yv9wjYhCP6jgYTZkmcKAU4T1X8MLRt9@yL56Gh9HTq72I1LnXKoXmx/sC2KML0wkYWsh/JMajqN98UOiF3/nZuSOYpMGRbJ4K8gUWzOWr24U1etfaBwf5f9XjWQbYUZ@GKXbK36HNrdsZl0mJoprBBfo1zc/OfZynbZvNShOx0zOl4V35PW0/tGehTyW950LXkfDpUzhJX4pSzXTe9g0

@l4m2 Stringified RegExp objects? Learned something new today

Haskell, 75 71 bytes
-4 bytes thanks to Laikoni (using do-notation over list-comprehension)!
Works with multiple = on one line:
f s='{':do{(a,_:b)<-span(/='=')<$>lines s;show a++':':show b++","}++"}"

Try it online!
Explanation
The term span(/='=')<$>lines s splits the string on the first =, leaving us with ("<initial part>","=<remaining line>"). Doing a pattern-match (a,_:b) ensures that the line was not empty and at the same time removes the leading =.
Now we only need to show both a and b (enclosing it in quotes and escaping quotes), do some formatting (: and , characters) and finally enclose it in {}.

71 bytes using do: Try it online!

Ruby, 56 bytes
->x{x.split(?\n).map{|i|i.split(?=)}.to_h.to_json}

+6 bytes for -rjson interpreter flag.
Try it online!

@Piccolo did you pass the -rjson flag?

@pfg Wow, I really dropped the ball on that haha. I had not only forgotten to use -rjson, but also assumed without actually checking that the error was the same one that I had gotten earlier involving to_h

C (gcc), 243 219 bytes
Thanks to ceilingcat for the suggestion.
I decided to use a state machine to handle the three cases (newline, key, value) and it turned out pretty well. Also, I got to abuse the fall-through feature of switch and the macro stringizing operator!
Although the challenge didn't require it, I also escaped the \ character per the JSON spec. If that character will never be in the input, then &&c-92 can be removed for 5 more bytes.
#define p(s)printf(#s,c)
#define a(i)case i:
c,s;f(){for(p({);(c=getchar())>0;)switch(s){a(0)if(c<11)break;s++,p(\42);a(1)c==61?s++,p(":"):p(%c);break;a(2)c-34&&c-92?c==10?p(\42\54),s=0:p(%c):p(\\%c);}s-2||p(\42);p(});}

Try it online!

Original submission: 243 bytes
The original submission kept unneeded spacing as in the provided JSON examples.
#define p(s)printf(s,c)
#define a(i)case i:
c,s;f(){for(p("{\n");(c=getchar())>0;)switch(s){a(0)if(c<11)break;s++,p("  \"");a(1)c==61?s++,p("\": \""):p("%c");break;a(2)c-34&&c-39?c==10?p("\",\n"),s=0:p("%c"):p("\\%c");}s==2&&p("\"\n");p("}");}

Try it online!

Retina 0.8.2, 43 bytes
¶¶
¶
"
\"
=
": "
m`$|^
"
m`^

$
¶}
^
{¶

Try it online!

JavaScript (ES6), 66 bytes
s=>`{${s.replace(/"/g,'\\"').replace(/(.*)=(.*)/g,'"$1":"$2",')}}`

Assumes there's only one = per line
Testing snippet

f=s=>`{${s.replace(/"/g,'\\"').replace(/(.*)=(.*)/g,'"$1":"$2",')}}`
<textarea id="i" onkeyup="o.innerText=f(i.value)"></textarea><pre id="o">

Should be 66 bytes. \ might've been parsed as \ when counting length.

@redundancy I really should stop using "code".length in the javascript console to count the length

Perl 6, 48 bytes
{to-json %(.lines.grep(?*)>>.split("=",2).flat)}

2 bytes less if we can assume exactly 1 equals sign on a non-empty line.
Try it online!
Ungolfed:
{                   # An anonymous block, taking 1 string which ends in $_.
    to-json         # Convert a Perl 6 number, string, list or hash to JSON and return it.
    %(              # Force to hash (dictionary)
        .lines      # Break $_ (implicitly assumed) into a list of lines.
        .grep(?*)   # Pick only those that are True (non-empty).
        >>.         # For each element in the list, call the following method ...
        split("=",2) # ... split the string at =, making at most 2 chunks.
        .flat       # That gives a list of 2-element lists. Flatten it.
    )               # List is converted into the hash like this: { first element => second element, third => fourth, ... }
}                   # Implicitly return

By the way, the to-json routine is deprecated, as the compiler will tell you, but who cares.

Python 2, 81 bytes
lambda s:'{'+re.sub(r'(.*)=(.*)',r'"\1":"\2",',re.sub('"',r'\"',s))+'}'
import re

Try it online!

Ruby, 59 + 5 = 64
Needs -rjson (+5)
->c{Hash[*c.split(?\n).map{|l|l.split ?=}.flatten].to_json}

Explanation:
->c{                                                      } # anonymous function with param c
    Hash[*                                       ]          # converts ["a", "b", "c", "d"] into {"a": "b", "c": "d"}
          c.split(?\n)                                      # splits c into lines
                      .map{|l|          }                   # map lines so each element represents
                              l.split ?=                    # an array of itself but split by =
                                         .flatten           # merges 2d array to 1d (also gets rid of empty elements for newlines
                                                  .to_json  # converts hash to json

V, 30 bytes
O{␛Í"/\\"
ggòeÉ"vyf=Plp$pa,òo}

Expects one input at a time. The TIO snippet runs all given test cases as a
single input.
I'm new to V's extended mappings, so tips are always welcome!
Try it online!
Explanation
O{␛                  # insert { on a new line above
   Í                 # global substitution across all lines
    "/\\"            #   " => \"
gg                   # go to first line
  ò                  # recursively...
   e                 #   forward to end of word; if at end of line, applies to next word below
    É"               #   prepend " to first non-whitespace char
      vy             #   copy current character (i.e. ")
        f=Plp        #   paste " before and after the next =
             $pa,    #   paste " at end of line and append ,
                 ò   # ...end
                  o} # insert } on a new line below

C (gcc), 172 170 bytes
#define p(s)printf(#s,c)
c,s;f(){for(p({);read(0,&c,1);)s-2?c>10|s&&(s||(s+=p(\42)),c==61?s++,p(":"):p(%c)):c-34&&c-92?c==10?s=!p(\42\54):p(%c):p(\\%c);s-2||p(\42);p(});}

Try it online!
Based on @ErikF's implementation but without switch/case.
Slightly ungolfed version
#define p(s)printf(#s,c)
c,s;
f(){
 for(p({);read(0,&c,1);)
  s-2?
   c>10|s&&(
    s||
     (s+=p(\42)),
    c==61?
     s++,
     p(":")
    :
     p(%c)
   )
  :
   c-34&&c-92?
    c==10?
     s=!p(\42\54)
    :
     p(%c)
   :
    p(\\%c);
 s-2||p(\42);
 p(});
}

R, 118 bytes
function(s){cat(paste("{",gsub("(.*)=(.*)","\"\\1\":\"\\2\",",gsub("\"","\\\\\"",gsub("\n{2,}","\n",s)),perl=T),"}"))}

Try it online!

Dart, 142 114 108 bytes
f(s)=>"""{${s.replaceAll('"','\\"').replaceAllMapped(RegExp(r'(.*)=(.*)'),(m)=>'"${m[1]}":"${m[2]}",')}}""";

Try it online!
-28 bytes by getting rid of the json.encode function and using regular string building
-6 bytes by removing the 'new' keyword and a few spaces

C (gcc), 119 bytes
#define p(s)printf(#s,c)
s;f(c){for(p({);~(c=getchar())|s;)c<11?s=s&&!p(","):c-61?s++||p(\42),p(\\u%04x):p(":");p(});}

Try it online!

PHP, 87 bytes
preg_match_all("/^(.*)=(.*)$/m",$argn,$m);echo json_encode(array_combine($m[1],$m[2]));

Run as pipe with -nR or try it online.
Insert \s before $/m for Windows linebreaks; \s* if linebreaks are uncertain.
Insert U after $/m if values contain =.

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


text:
Display a clock face
Display the 12 numbers on a clock face exactly like this:
           12
     11           1

 10                   2

9                       3

  8                   4

      7           5
            6

To better see the grid, here's one with dots:
...........12............
.....11...........1......
.........................
.10...................2..
.........................
.........................
9.......................3
.........................
.........................
..8...................4..
.........................
......7...........5......
............6............

Note that the grid is stretched in width by a factor of two to make it look more square.
Also note that two-digit numbers are aligned with their ones digit in place. The 9 digit should be flush against the left.
Return or print the result as a multiline string (not a list of lines). Any trailing spaces are optional. The final newline also optional.

Are the spaces on the right (after 12, 1, 2, ...) or between rows necessary ?

@CreaZyp154 The trailing spaces are optional

Charcoal, 40 bytes
Ｆ¹²«Ｍ⁻↔⁻¹⁴⊗÷×⁴ι³¦⁸⁻⁴↔⁻⁷÷×⁴﹪⁺³ι¹²¦³Ｐ←⮌Ｉ⊕ι

Try it online! Link is to verbose version of code. Explanation: Computes the offsets between each digit mathematically. Charcoal is 0-indexed (thus the ⊕ to output \$ 1 \ldots 12 \$), so the formulae for the horizontal and vertical offsets are as follows:
$$ \begin{align} \delta x &= \left \lvert 14 - 2 \left \lfloor \frac {4i} 3 \right \rfloor \right \rvert - 8 \\ \delta y &= 4 - \left \lvert 7 - \left \lfloor \frac {4i'} 3 \right \rfloor \right \rvert \end{align} $$
where \$ i' = i + 3 \pmod {12} \$.

JavaScript (Node.js), 91 bytes
Not a very clever approach, but I've failed to find anything shorter at the moment.
_=>`K12
E11K1

A10S2

9W3

B8S4

F7K5
L6`.replace(/[A-Z]/g,c=>''.padEnd(Buffer(c)[0]&31))

Try it online!

I love the use of Buffer() as alternative to charCodeAt()

@Downgoat Which makes me wonder if we should have a Tips for golfing in Node.js question, for Node specific features. Not sure it's worth it, though.

Maybe add a separate answer that contains all the Node specific features, or at least a list linking all the different answers?

05AB1E, 39 33 31 bytes
Thanks to Magic Octopus Urn for saving 6 bytes!
Code
6xsG12N-N•°£•NèØú«тR∞Nè¶×]\6».c

Some 33 byte alternatives:
711ćŸā•Σ°w•₂вú‚øJƵt3в¶×‚ø»6xŠ».c¦
6xsŸ5L•Σ°w•₂вúõ¸ì‚ζJï2ÝÂ«Ć¶×)ø».c
6xsG¶12N-N•Θ{©•₂вNèú«ƵB∞Nè¶×]6J.c
6xsG12N-N•Θ{©•₂вNèú«тR∞Nè¶×]6s».c

Uses the 05AB1E encoding. Try it online!

Nice answer! I like the use of ÿ with .V, very original! And funny how you've used 12¤ to get both 12 and 2 on the stack. I probably would have just used 12Y, but I guess how is irrelevant, since both have 12 and 2 on the stack. If I would have tried this challenge in 05AB1E I would have ended way higher in byte-count.. Guess I still have much to learn. ;)

@KevinCruijssen Oh yeah, I forgot about Y. That would have been an easier option hahaha.

I don't know if I'm fixing the 6 in under 6 bytes: 6xsŸ5L•δ;Ì’•2ôúð.ø‚ζJ012∞S¶×‚ζJ.c but you're welcome to anything of use in here.

@MagicOctopusUrn Nice trick with the zip, I did not think of that.

@adnan props on 6xŠ» too, I would've never thought of that.

NB: this can be changed to the rewrite by just replacing ∞ with º.

6502 machine code (C64), 82 76 73 bytes
00 C0 A2 0E BD 38 C0 29 03 A8 A9 0D 20 25 C0 BD 38 C0 4A 4A A8 A9 20 20 25 C0
BD 29 C0 20 D2 FF CA 10 E1 60 20 D2 FF 88 10 FA 60 36 35 37 34 38 33 39 32 30
31 31 31 31 32 31 31 2C 1A 4C 0B 5C 03 4C 00 06 2C 00 15 00 2C

-6 bytes, thanks to Arnauld for the clever idea :)
another -3 bytes after Arnauld's idea not to treat leading 1 digits specially

The idea here is to only store the digits of all the numbers in the order they are needed. Additional info required is the number of newlines to prepend and the number of spaces in front.
The maximum number of newlines is 3, so we need 2 bits for this, and the maximum number of spaces is 23, therefore 5 bits are enough. Therefore, for each digit to print, we can squeeze this info in a single "control byte".
So, the data for this solution takes exactly 30 bytes: 15 single digits and 15 associated "control bytes".
Online demo
Usage: SYS49152 to start.
Commented disassembly:
         00 C0                          ; load address
.C:c000  A2 0E       LDX #$0E           ; table index, start from back (14)
.C:c002   .mainloop:
.C:c002  BD 38 C0    LDA .control,X     ; load control byte
.C:c005  29 03       AND #$03           ; lowest 3 bits are number of newlines
.C:c007  A8          TAY                ; to Y register for counting
.C:c008  A9 0D       LDA #$0D           ; load newline character
.C:c00a  20 25 C0    JSR .output        ; repeated output subroutine
.C:c00d  BD 38 C0    LDA .control,X     ; load control byte
.C:c010  4A          LSR A              ; and shift by two positions for ...
.C:c011  4A          LSR A              ; ... number of spaces
.C:c012  A8          TAY                ; to Y register for counting
.C:c013  A9 20       LDA #$20           ; load space character
.C:c015  20 25 C0    JSR .output        ; repeated output subroutine
.C:c018  BD 29 C0    LDA .digits,X      ; load current digit
.C:c01b  20 D2 FF    JSR $FFD2          ; output
.C:c01e  CA          DEX                ; decrement table index
.C:c01f  10 E1       BPL .mainloop      ; still positive -> repeat
.C:c021  60          RTS                ; and done.
.C:c022   .outputloop:
.C:c022  20 D2 FF    JSR $FFD2          ; output a character
.C:c025   .output:
.C:c025  88          DEY                ; decrement counting register
.C:c026  10 FA       BPL .outputloop    ; still positive -> branch to output
.C:c028  60          RTS                ; leave subroutine
.C:c029   .digits:
.C:c029  36 35 37 34 .BYTE "6574"
.C:c02d  38 33 39 32 .BYTE "8392"
.C:c031  30 31 31 31 .BYTE "0111"
.C:c035  31 32 31    .BYTE "121"
.C:c038   .control:
.C:c038  31 2C 1A 4C .BYTE $31,$2C,$1A,$4C
.C:c03c  0B 5C 03 4C .BYTE $0B,$5C,$03,$4C
.C:c040  00 06 2C 00 .BYTE $00,$06,$2C,$00
.C:c044  15 00 2C    .BYTE $15,$00,$2C

Could you save 2 bytes by using a subroutine doing JSR $FFD2 / DEY / BNE loop / LDA .control,X / RTS called for both newlines and spaces? I think it would be +10 bytes long and save -12 bytes in the main code.

Actually, I think you can save more bytes if the subroutine is doing JSR $FFD2 / DEY / BPL loop / LDA .control,X / RTS and the entry point is the DEY. This way, you don't have to test 0 in the main code.

Thanks nice idea, will edit later. The latter however won't work, I need a case that skips the whole loop.

If Y=0, DEY / BPL / RTS will exit immediately without processing any JSR $FFD2. (Note that with that scheme, the entry point of the subroutine must be DEY.)

@Arnauld Yep, that's clever :) Used this idea now, thanks!

I like the way you stored the extra "1" in the control byte. However, this is currently costing 9 bytes (BPL / LDA / JSR and the AND $7F). Encoding them as 3 extra 'standard' digits would cost only 6 bytes.

@Arnauld plus load LDA digit2,X and output JSR $FFD2 which is 6 bytes as well? Or do you have a better idea here?

Ah now I get what you mean. Indeed, this should work :)

Maybe ... it still avoids two times explicit 0 checking (4 bytes) and one instance of JSR/DEY/BNE (6 bytes) at the expense of 2 times JSR (6 bytes) and one RTS (1 byte) ... should still be better, but I'll double-check :)

@Arnauld after quite some experimentation, I think it's shortest to keep the subroutine while using your suggestion of storing all digits :)

Perl 6, 76 74 70 bytes
"K12
E11K1

A10S2

9W3

B8S4

F7K5
L6"~~say S:g{<:Lu>}=" "x$/.ord-64

Try it online!
Port of Arnauld's answer until I can come up with something shorter.

Java 8 11, 141 138 bytes
v->{for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())System.out.print(x<59?" ".repeat(x-48):(char)(x>76?10:x-17));}

Try it online (NOTE: String.repeat(int) is emulated as repeat(String,int) for the same byte-count, because Java 11 isn't on TIO yet.)
Explanation is similar as below, but it uses " ".repeat(x-48) for the spaces instead of format with "%"+(x-48)+"s".

Java 8, 141 bytes
v->{for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())System.out.printf("%"+(x>58?"c":x-48+"s"),x>76?10:x>58?x-17:"");}

Try it online.
Explanation:
v->{                        // Method with empty unused parameter and no return-type
  for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())
                            //  Loop over the bytes of the above String:
    System.out.printf("%"+  //   Print with format:
     (x>58?                 //    If the character is a letter / not a digit:
       "c"                  //     Use "%c" as format
      :                     //    Else:
       x-48+"s"),           //     Use "%#s" as format, where '#' is the value of the digit
     x>76?                  //    If the byte is 'N':
      10                    //     Use 10 as value (newline)
     :x>58?                 //    Else-if the byte is not a digit:
      x-17                  //     Use 48-58 as value (the 0-9 numbers of the clock)
     :                      //    Else:
      "");}                 //     Use nothing, because the "%#s" already takes care of the spaces

Further explanation 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

All the digits will be replaced with that amount of spaces. (For 11 spaces it's therefore 92.)
All 'N' are new-lines
All ['A','J'] are clock digits ([0,9])

HTML + JavaScript (Canvas), 13 + 161 = 174 bytes
Arbitrary canvas positioning uses 6 bytes.

with(C.getContext`2d`)with(Math)for(font='9px monospace',textAlign='end',f=x=>round(sin(x*PI/6)*6)*measureText(0).width*2,x=13;--x;)fillText(x,f(x)+80,f(9-x)+80)
<canvas id=C>

With grid for comparison:

with(C.getContext`2d`)with(Math){
    for(font='9px monospace',textAlign='end',f=x=>round(sin(x*PI/6)*6)*measureText(0).width*2,x=13;--x;)fillText(x,f(x)+80,f(9-x)+80)
    for(globalAlpha=0.2,y=-6;y<=6;y++)fillText('.'.repeat(25),6*measureText('.').width*2+80,y*measureText(0).width*2+80)
}
<canvas id=C>

Explanation of Positioning Formula
See my JavaScript with SVG answer.

I don't think this counts because since this is ASCII-art we are supposed to generate the exact byte-stream specifies in the challenge while this renders an image that looks like output.

R, 75 68 bytes
write("[<-"(rep("",312),utf8ToInt('*`®÷ĥĹĚä—M'),1:12),1,25)

Try it online!
Compressed the digits positions.
Did this after spending lots of time trying to come up with a trigonometric answer (see history of edits).
Inspired by this other R answer buy J.Doe - upvote it !
Saved 7 bytes thanks to J.Doe.

68 bytes -  changed hash to avoid arithmetic and altered the write call to use the default separator.

@J.Doe It makes more sense this way. Of course not having documented my golf I have no clue why I did a convoluted hash in the first place...

Python 2, 97 bytes
for i in range(7):w=abs(3-i);print'%*d'%(1-~w*w,12-i),'%*d'%(24-3**w-2*w,i)*(w<3),'\n'*min(i,5-i)

Try it online!
Computes all spacings and newlines in the loop

Haskell, 88 87 bytes
f=<<"k12{e11k1{{a10s2{{{9w3{{{b8s4{{f7k5{l6"
f c|c>'z'="\n"|c>'9'=' '<$['a'..c]|1<2=[c]

The encode-spaces-as-letters method (first seen in @Arnauld's answer) in Haskell. Using { and expanding it to \n is one byte shorter than using \n directly.
Try it online!

R, 168 159 125 bytes
The naive solution of writing the numbers at the prescribed points in a text matrix. Points are stored as UTF-8 letters decoded via utf8ToInt
"!"=utf8ToInt
write("[<-"(matrix(" ",25,13),cbind(!"LMFGSBCWAYCWGSM",!"AABBBDDDGGJJLLM")-64,-64+!"ABAAAA@BICHDGEF"),1,25,,"")

Dropped 9 bytes with JayCe's suggestion to use write and avoid defining the matrix.
Dropped another 34 bytes with JayCe's storage suggestion.

Hello and welcome to PPCG! I think the dots are supposed to help visualize the pattern, but not part of the output.

Welcome to PPCG! you can asve some bytes not defining m and using write: TIO. PS: you are not obliged to include a TIO link in your answer but it formats the answer nicely for you, see link icon on top of TIO page.

You can store the points in a string and overload the ! operator to get to 125 chars. Really nice solution!

Jelly, 32 bytes
⁶ẋ“¿×¿ Œ4ç4Œ!¿Ø‘ż“øn0œ’Œ?D¤Fs25Y

A full program which prints the result.
Try it online!
How?
(I have not yet thought of/found anything shorter than “¿×¿ Œ4ç4Œ!¿Ø‘ which seems long to me for this part - bouncing / base-decompression / increments, nothing seems to save!)
⁶ẋ“¿×¿ Œ4ç4Œ!¿Ø‘ż“øn0œ’Œ?D¤Fs25Y - Main Link: no arguments
⁶                                - space character
  “¿×¿ Œ4ç4Œ!¿Ø‘                 - code-page indices list = [11,17,11,32,19,52,23,52,19,33,11,18]
 ẋ                               - repeat (vectorises) -> [' '*11, ' '*17, ...]
                          ¤      - nilad followed by link(s) as a nilad:
                 “øn0œ’          -   base 250 number = 475699781
                       Œ?        -   first natural number permutation which would be at
                                 -   index 475699781 if all permutations of those same
                                 -   natural numbers were sorted lexicographically
                                 -   = [12,11,1,10,2,9,3,8,4,7,5,6]
                         D       -   to decimal lists = [[1,2],[1,1],[1],[1,0],[2],[9],[3],[8],[4],[7],[5],[6]]
                ż                - zip together = [[' '*11, [1,2]], [' '*17, [1,1]], ...]
                           F     - flatten = [' ',' ',...,1,2,' ',' ',...,1,1,...]
                            s25  - split into chunks of 25 (trailing chunk is shorter)
                               Y - join with new line characters
                                 - implicit print

LOL I'm actually surprised this is the naive approach.

Rust, 96 bytes
||format!(r"{:13}
     11{:12}

 10{:20}

9{:24}

  8{:20}

{:7}{:12}
{:13}",12,1,2,3,4,7,5,6)

Try it online!

brainfuck, 240 235 bytes
++++++++++[>++>+>+++>+++++>++>++[<]>-]>>>++...........>-.+.<<.>.....>-..<...........>.<<..>.>.-.>-[<<.>>-]<++.<<...>>+++++++.>>+++[<<<.>>>-]<<------.<<...>..>+++++.<<<-[>>.<<-]>>>----.<<..>......>+++.<...........>--.<<.>............>+.

Try it online!
Commented code
++++++++++                              Put 10 in cell 0
[>++>+>+++>+++++>++>++[<]>-]            Loop 10 times incrementing to leave 0 20 10 30 50 20 20 in memory
>>>++                                   30 plus 2 = 32 (ascii space)
...........>-.+.                        print 11spaces followed by 12 (ascii 49 50)
<<.>.....>-..<...........>.             print 1newline 5spaces 11 11spaces 1
<<..>.>.-.>-[<<.>>-]<++.                print 2newlines 1space 10 19spaces 2
<<...>>+++++++.>>+++[<<<.>>>-]<<------. print 3newlines         9 23spaces 3
<<...>..>+++++.<<<-[>>.<<-]>>>----.     print 3newlines 2spaces 8 19spaces 4
<<..>......>+++.<...........>--.        print 2newlines 6spaces 7 11spaces 5
<<.>............>+.                     print 1newline  12spaces 6

A rare example where the text is repetitive enough that the brainfuck program is less than twice 1.6 times the length of the output!
2 bytes saved by suggestion from Jo King: >>>>>>- -> [<]>-
3 bytes saved by moving the third 20-place downcounter from far right of the ascii codes 10 30 50 to immediately to the left of them. Saves <<>> when filling the gap between 8 and 4 but adds 1 byte to the line >>>++ .
Original version
++++++++++                              Put 10 in cell 0
[>+>+++>+++++>++>++>++<<<<<<-]          Loop 10 times incrementing to leave 0 10 30 50 20 20 20 in memory
>>++                                    30 plus 2 = 32 (ascii space)
...........>-.+.                        print 11spaces followed by 12 (ascii 49 50)
<<.>.....>-..<...........>.             print 1newline 5spaces 11 11spaces 1
<<..>.>.-.>-[<<.>>-]<++.                print 2newlines 1space 10 19spaces 2
<<...>>+++++++.>>+++[<<<.>>>-]<<------. print 3newlines         9 23spaces 3
<<...>..>+++++.>>>-[<<<<.>>>>-]<<<----. print 3newlines 2spaces 8 19spaces 4
<<..>......>+++.<...........>--.        print 2newlines 6spaces 7 11spaces 5
<<.>............>+.                     print 1newline  12spaces 6

C (gcc), 145 137 125 bytes
Only the tab positions are hard-coded: all the line spacings and clock values are generated in the loop.
Thanks again to ceilingcat for the suggestions.
i,j,k;f(char*t){for(i=7;i--;t=memset(t+sprintf(t,"%*d%*d"+3*!j,"NHDA"[j]-65,6+i,"AMUY"[j]-65,6-i),10,k=j+i/4)+k)j=i>3?6-i:i;}

Try it online!

Suggest "\r\7\3"[j] instead of "NHDA"[j]-65

PHP, 97 bytes
<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

Try it online!
This is a hard coded compressed string. I couldn't find a solution shorter than this!

Can you put the binary compressed string in the source file and skip the base64_decode? I tried this and I get a 'gzinflate(): data error', but it might be possible if the source file was written witha hex editor instead of a text editor.

@bdsl actually I did that before and you don't need a HEX editor, you can just use PHP itself file_put_contents($path, '<?=gzinflate("'.gzdeflate($clockString,9).'");');, but I'm not sure how to post a code with binary data inside it. A file like that is 70 bytes.

C (gcc), 125 109 105 bytes
x,*d=L"<;1:2938475640P`P05";main(i){for(;i=d[12];printf("%*d",i/4,*d++-48))for(x=i&3;x--;)puts("");}

-16 bytes (-3 for better loop arrangement, -13 for directly including the non-printable chars) thanks to Jonathan Frech.
-4 bytes by replacing a division for a shift and abusing the fact that on many systems (like the one hosting TIO), sizeof(wchar_t) == sizeof(int) -- won't work on windows :) Thanks ErikF for the idea.

Try it online!
This is a port of my general idea from the 6502 solution to C. It's a bit modified: Instead of having a flag for a leading 1, the character is printed as a decimal by subtracting 48, so 10 - 12 are encoded as : to <.

109 bytes.

@JonathanFrech nice loop rearrangement, I wonder how I missed that one :o But really didn't expect gcc to accept non-printable characters in the source :)

As long as the character can be represented in UTF-8, it's technically acceptable by the compiler. Whether that's a good thing rather depends on what you're doing :-)

Speaking of Unicode, you can save 3 more bytes by using wide characters: Try it online!

Nice trick ... would break on windows because it assumes wchar_t==int, but will edit later ;)

That's why I like code golfing: I get to abuse UB and use all those "things you shouldn't do" that you pick up over time!

@ErikF used your idea now :) In fact, I've seen it in your submission and just forgot later.

One last thing I saw: replace i>>2 with i/4 to save another byte (and possibly move main to the footer for another 3): Try it online!

@ErikF thanks again, used the division! Although I guess it's allowed to submit a function that only works a single time, this "feels" somehow wrong :o

Powershell, 94 88 82 bytes
Direct Powershell format operator. {i,w} means a placeholder for a parameter with index i, width of the placeholder is w with right align.
"{11,13}
{10,7}{0,12}

 10{1,20}

9{2,24}

  8{3,20}

{6,7}{4,12}
{5,13}"-f1..12

Powershell, 88 bytes
Port of Arnauld's Javascript answer
-6 bytes thanks to @AdmBorkBork
[RegEx]::Replace("K12
E11K1

A10S2

9W3

B8S4

F7K5
L6",'[A-Z]',{' '*("$args"[0]-64)})

To better see the grid, use '.' instead ' '.

Why not string multiplication instead of .PadLeft for 88 bytes -- Try it online!

That's a clever use of -f. Why don't you include links to Try it online! so others can see how your code works?

I have the error This site can’t be reached only. Sorry.

Ah, that's a shame. It's a good resource. :-(

Pyke, 37 bytes
3B 32 35 75 07 0d 13 0c 22 14 35 18 44 74 5F 74 2B 46 6F 68 32 C4 52 7D 74 2A 31 32 25 31 32 7C 60 52 2D 29 73

Try it here! (raw bytes)
;25Dt_t+Foh2.DR}t*12%12|`R-)s

Try it here! (Human readable)
                              - o = 0
;25                           - set line width to 25 characters
                              -      `[13, 19, 12, 34, 20, 53, 24]`
                              -       (In hex version, encoded in base 256, regular version in input field)
    t_t                       -     reversed(^[1:])[1:]
   D   +                      -    ^^ + ^
        Foh2.DR}t*12%12|`R-)  -   for i in ^:
         o                    -            o++
          h                   -           ^+1
           2.DR               -          divmod(^, 2)
               }t             -         (remainder*2)-1
                 *            -        quotient * ^
                  12%         -       ^ % 12
                     12|      -      ^ or 12 (12 if 0 else ^)
                        `     -     str(^)
                         R-   -    ^.rpad(i) (prepend spaces such that length i)
                            s -  sum(^)
                              - output ^ (with newlines added)

brainfuck, 315 313 bytes
saved 2 bytes thanks to ovs!
++++[>++++<-]>[>+++>+++>+++>+++>>++>+++>+++>+++<<<<<<<<<-]>+++++>++++>+++>++>++++++++++>>+++++++>+><<<...........>>.<<<<.>.>.....>>..<<...........>>.<<<..>.>>.>.<<<...................<<.>...>>++.<.......................<<<.>>...>..>-.<...................<<<<.>>>..>......>-.<...........<<<<<.>>>>.>............>-.

Try it online!
all in one code block:
++++[>++++<-]>[>+++>+++>+++>+++>>++>+++>+++>+
++<<<<<<<<<-]>+++++>++++>+++>++>++++++++++>>+
++++++>+><<<...........>>.<<<<.>.>.....>>..<<
...........>>.<<<..>.>>.>.<<<................
...<<.>...>>++.<.......................<<<.>>
...>..>-.<...................<<<<.>>>..>.....
.>-.<...........<<<<<.>>>>.>............>-.

You can use ++++[>++++<-]> for the 16 at the beginning.

@ovs Ah, of course, thanks!!

Lol, you have >< in your code

JavaScript with SVG, 188 bytes
Arbitrary line height of 120% uses 4 bytes.

with(Math)for(s='<pre><svg viewBox=-8-8+16+16 style=font-size:1;text-anchor:end>',f=x=>round(sin(x*PI/6)*6),x=13;--x;)s+=`<text x=${f(x)*2}ch y=${f(9-x)*1.2}>${x}</text>`
document.write(s)

With grid for comparison:

with(Math)for(s='<pre><svg viewBox=-8-8+16+16 style=font-size:1;text-anchor:end>',f=x=>round(sin(x*PI/6)*6),x=13;--x;)s+=`<text x=${f(x)*2}ch y=${f(9-x)*1.2}>${x}</text>`
for(y=-6;y<=6;y++)s+=`<text x=12ch y=${y*1.2} style=fill:#0002>${'.'.repeat(25)}</text>`
document.write(s)

Explanation of Positioning Formula
Let f(x) = round(sin(x * π/6) * 6).
Assuming the origin is the center of the clock, the grid coordinates of the right-most digit of any given clock number x is
[f(x) * 2, f(9 - x)].

Attache, 69 bytes
{ReplaceF["l12
f11l1

b10t2

9x3

c8t4

g7l5
m6",/"\\l",sp&`*@STN]}

Try it online!
This encodes each run of spaces as: NTS[count of spaces]; NTS is the "numeric to short" builtin, which allows numbers to be expressed as strings. E.g., NTS[95] = $R1 and NTS[170297] = $XQO. STN is the inverse of this builtin.
This answer replaces (ReplaceF) all occurences of letters (/\l/) in the input with the result of the function sp&`*@STN, which firsts decodes the letter and then repeats sp (a space) that many times.

Swift, 178 165 bytes
var b="";for c in"L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6"{let i=c.unicodeScalars.first!.value;if c=="n"{b+="\n"}else if i>64{for _ in 0..<(i-65){b+=" "}}else{b+="(c)"}};print(b)

Based on what Downgoat posted, I've reduced this to 165 bytes:
print("L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6".unicodeScalars.map{let x=Int($0.value);return x==110 ?"\n":(x>64 ?String(repeating:" ",count:x-65):"($0)")}.joined())
Expanded out, with $0 converted to a named variable:
print("L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6".unicodeScalars.map { c in
    let x = Int(c.value)
    return x == 110 ? "\n" : (x>64 ? String(repeating:" ", count: x-65) : "(c)")
}.joined())

The input string is encoded as follows: Uppercase letters (A-Z) represent blocks of spaces, offset by 65. So A means 0 spaces, B means 1 space, the first L means 11 spaces, etc. ns are converted to newlines. All other characters are printed as-is.
Run it online here (thanks, mbomb007)

Welcome to PPCG! Many of us use Try It Online (TIO) for online interpreters to include a hyperlink to the program in our answers. Here is the one for your answer: https://tio.run/##JY1BC4IwGIb/yvpOSjScqRW2DgV1sVMeOgQx14SBfMacdhB/@1p2eeF5eV7e7qNrmzg3CEMqDpDXrSGSaISCxXhmrGAZ4pFFZYyIu/va52lbJoiXTZHiNYOxUdb7lkvao5btS92kaITpaK1NZxd0EE2vcl0TyTkgjNWSwwNhUk2niK/99pAl4@/46YFElO4DX66yNJxlAtMs/5eBDD3nb@OVoAqd@wI

Here's a golf of your answer that's 172 bytes. It uses a function instead: {"L12NF11L1NNB10T2NNN9X3NNNC8T4NNG7L5NM6".unicodeScalars.map({(c)->String in let x=c.value;return x==78 ? "\n" : x>64 ?String(repeating:" ",count:x-65) : "\(c)"}).joined()} (swift 3 (-swift-version 3 on repl) because swift 4 dropped subtraction it looks like)

@Downgoat I reduced it another 3 bytes and made it compatible with Swift 4. See updated post.

vim, 103 bytes
25a <ESC>r30r9O0i <C-v><ESC>15l2xA <C-v><ESC><ESC>0"aDddqbYp<C-x>e<C-a>q2@a@b4@a@b6@aggqbYP<C-a>e<C-x>q@axr 2hr2@b4@a@b6@ayyjpr lr yyj2p2j2p2jp

<ESC> is 0x1b, <C-a> is 0x01, <C-x> is 0x18, and <C-v> is 0x16.
This includes all trailing spaces because I didn't notice they were optional until I'd finished for the additional challenge.
Annotated
25a <ESC>r30r9                            # create the 9...3 line
o0i <C-v><ESC>15l2xA <C-v><ESC><ESC>"a0D  # create macro a that moves 2 spaces from the middle to the ends
                                          # 15 is a magic number that lets the same macro work for the 6 and 12 lines
dd                                        # delete empty line
qb                                        # record macro b to...
  Yp                                      #    duplicate line (down)
  <C-x>e<C-a>                             #    adjust numbers
q
2@a                                       # adjust spacing for line 8..4
@b4@a                                     # create line 7..5
@b6@a                                     # create line 6
gg                                        # move cursor to first line
qb                                        # record macro b to...
  YP                                      #    duplicate line (up)
  <C-a>e<C-x>                             #    adjust numbers
q
@axr 2hr2                                 # adjust spacing for 2-digit numbers
@b4@a                                     # 11..1
@b6@a                                     # 12
yyjpr lr yy                               # add a line of all spaces below 12, and copy to default register
j2p2j2p2jp                                # add the rest of the blank lines

Try it online!

Red, 151 bytes
foreach[a b c d][13 12 1""7 11 12 1 1""1""3 10 20 2 1""1"^/"0 9 24 3 1""1"^/"3 8 20 4 1""1""7 7 12 5 13 6 1""][print rejoin[pad/left b a pad/left d c]]

Try it online!

T-SQL, 132 bytes
PRINT SPACE(11)+'12
     11           1

 10'+SPACE(20)+'2

9'+SPACE(23)+'3

  8'+SPACE(19)+'4

      7           5
            6'

Only 12 bytes shorter than the trivial solution (PRINT of the entire string as-is).
Found a variation I like that is much longer (235 226 bytes), but much more SQL-like:
SELECT CONCAT(SPACE(PARSENAME(value,4)),PARSENAME(value,3),
              SPACE(PARSENAME(value,2)),PARSENAME(value,1))
FROM STRING_SPLIT('11.1..2,5.11.11.1,. .. ,1.10.20.2,. .. ,. .. ,.9.23.3,
                   . .. ,. .. ,2.8.19.4,. .. ,6.7.11.5,12.6.. ',',')

STRING_SPLIT breaks it into rows at the commas, and PARSENAME splits each row at the dots. The 1st and 3rd are used for how many spaces to print, the 2nd and 4th are used for what to display.
(line breaks in this one are just for readability)

Python 3, 112 88 87 bytes
A solution using string interpolation.
print(f'''{12:13}
{11:7}{1:12}

 10{2:20}

9{3:24}

  8{4:20}

{7:7}{5:12}
{6:13}''')

Try it online!
-25 bytes thanks to ovs and Herman L.

And if you use Hermans formatting string you can get this to ~85 bytes.

One more byte with {11:7}.

Pure Bash, 123
printf does the heavy-lifting here:
n=" 0 a 0 a"
printf -vo %*s%*s\\n 0 a 13 12 7 11 12 1 $n 3 10 20 2$n$n 1 9 24 3$n$n 3 8 20 4$n 7 7 12 5 13 6
echo "${o//a}"

Try it online!

Perl 6, 116 bytes
my@a=["  "xx 13]xx 13;($_=pi/6*++$;@a[0+|6*(1.1-.cos);0+|6*(1.1+.sin)]=fmt ++$: "%2s")xx 12;@a>>.join>>.&{say S/.//}

Try it online!
(Ta @JoKing for saving 26 bytes)
Perl 6, 142 bytes
my@a=[[[32,32]xx 13]xx 13];for 1..12 {$_=$^b*pi/6;@a[round 6*(1-.cos);round 6*(1+.sin)]=[" $b".ords.tail(2)]}
{say S/^.//}(.[*;*].chrs) for @a

Try it online!
I wanted to do something... different. So this one calculates the positions of all the digits, via pairs of characters, strips off the initial space and prints the lines.
Easily modifiable for different parameters, e.g. a 45 character wide version with 17 digits.

116 bytes

@JoKing: Ta, I've pasted that in & made it a wiki.

C (gcc), 135 123 110 bytes
This uses a simple encoding where any c between 'a' and 'z' represents c-'a'+1 repeated spaces, '`' represents a newline, and all other characters are left unchanged.
f(i){char*s="k12`e11k1``a10s2```9w3```b8s4``f7k5`l6`";for(;i=*s;s++)i>96?printf("%*s",i-96,""):putchar(i%86);}

Try it online!

Suggest *s=L"...";f(i){ instead of f(i){char*s="...";

Deadfish~, 290 bytes
{iii}ii{c}c{ii}dddcic{dddd}c{ii}iiccccc{ii}dddcc{dd}iii{c}c{ii}dddc{dddd}icc{ii}iic{ii}dddcdc{d}dddddd{c}ccccccccc{ii}ddc{dddd}ccc{iiiii}dddc{dd}ddddd{cc}ccc{ii}dc{dddd}dccc{ii}iicc{ii}iiiic{dd}dddd{c}ccccccccc{ii}c{dddd}ddcc{ii}iicccccc{ii}iiic{dd}ddd{c}c{ii}ic{dddd}dddc{ii}ii{c}cc{ii}iic

Try it online!

Canvas, 49 bytes
12∙11∙1７«１╋¶10∙2‾⁶２╋¶¶9∙3‾⁹３╋¶¶8∙4‾⁵３╋¶7∙5‾¹２╋6）ｒ

Try it here!

Vyxal Cm, 32 bytes
6d6(12n-»§⟩»niǎnS꘍J₁SṘmni⌊¶*)_6W

Try it Online!
Bubblegum, 52 bytes
00000000: e000 9200 2c5d 0010 6c02 2323 71ec 327c  ....,]..l.##q.2|
00000010: cf28 700c 02f9 d7eb 5929 59a9 e1c8 62ab  .(p.....Y)Y...b.
00000020: 6d60 3fad 8aea 9fc7 e472 69f0 37f4 133e  m`?......ri.7..>
00000030: ff8e e100                                ....

Try it online!

Perl 5, 73 bytes
Port of Arnauld's answer.
say"K12
E11K1

A10S2

9W3

B8S4

F7K5
L6"=~s,[A-Z]," "x(ord($&)-64),erg

Try it online!
As a one-liner:
perl -E'say"K12\nE11K1\n\nA10S2\n\n\n9W3\n\n\nB8S4\n\nF7K5\nL6"=~s,[A-Z]," "x(ord($&)-64),erg'

Another approach, but longer:
map$s.=$_%26?{12,12,32,11,44,1,80,10,100,2,157,9,181,3,237,8,257,4,293,7,
305,5,325,6}->{$_}||" ":"\n",1..338;
say$s

Python, 99, 91
print"%13d\n%7d%12d\n\n%3d%20d\n\n\n9%24d\n\n\n%3d%20d\n\n%7d%12d\n%13d"%(12,11,1,10,2,3,8,4,7,5,6)
print"""%13d
%7d%12d

%3d%20d

9%24d

%3d%20d

%7d%12d
%13d"""%(12,11,1,10,2,3,8,4,7,5,6)

Thanks to Jo King
Spaces hardcoded in -- I'm sure its possible to golf the \ns down, by repeating but I don't know how...

You can use a multi-line string. Try it online!

Javascript, 93 bytes

console.log((

_=>`F 12
A11F 1

 10FE2

9FCB3

  8FE4

B7F 5
AC6`.replace(/[A-F]/g,c=>''.padEnd('0x'+c-5))

)())

Port of Arnauld's answer to general JS

05AB1E, 47 42 bytes
•1)âÝÈÝ‰ʒ%и&ñjÓU‰÷JêĆ+•₆B'X¶:AuðAuÇ31&×‡.c

Try it online!
•...•₆B'X¶:AuðAuÇ31&×‡.c  # trimmed program
•...•                     # push 1902039976984631753317213270923121051329258518010...
      B                   # in base...
     ₆                    # 36...
          :               # with all...
       'X                 # literal...
          :               # s replaced by...
         ¶                # newline...
          :               # s...
                     ‡    # with each...
           Au             # letter...
                     ‡    # replaced by the corresponding...
              Au          # letter...
                Ç         # 's codepoint...
                   &      # bitwise and...
                 31       # literal...
             ð            # " "...
                    ×     # s...
                      .c  # with each line centered more to the left
                          # implicit output


text:
Scoring 6,5,4 (AKA Ship, Captain, and Crew)
Inspired and looted from this dice challenge by Arnauld
Input
You are given a 5x1 or 1x5 (your choice) dice matrix which consist of binary 3x3 sub-matrices.
Goal
Given a valid dice matrix, you are to score it using the rules of 6,5,4 which are as follows:

If the roll contains 6,5,4, add the other two dice together and that is your score. E.g. 4,X,5,6,Y = X+Y
Otherwise, the score is 0. E.g. 5,5,5,4,1 = 0

Wiki article for the game
Dice patterns
$$\begin{align}
&1:\pmatrix{\color{gray}0,\color{gray}0,\color{gray}0\\\color{gray}0,1,\color{gray}0\\\color{gray}0,\color{gray}0,\color{gray}0}
&&2:\pmatrix{1,\color{gray}0,\color{gray}0\\\color{gray}0,\color{gray}0,\color{gray}0\\\color{gray}0,\color{gray}0,1}\text{or}\pmatrix{\color{gray}0,\color{gray}0,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,\color{gray}0,\color{gray}0}\\
&3:\pmatrix{1,\color{gray}0,\color{gray}0\\\color{gray}0,1,\color{gray}0\\\color{gray}0,\color{gray}0,1}\text{or}\pmatrix{\color{gray}0,\color{gray}0,1\\\color{gray}0,1,\color{gray}0\\1,\color{gray}0,\color{gray}0}
&&4:\pmatrix{1,\color{gray}0,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,\color{gray}0,1}\\
&5:\pmatrix{1,\color{gray}0,1\\\color{gray}0,1,\color{gray}0\\1,\color{gray}0,1}
&&6:\pmatrix{1,\color{gray}0,1\\1,\color{gray}0,1\\1,\color{gray}0,1}\text{or}\pmatrix{1,1,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,1,1}
\end{align}$$
Rules

The matrix is guaranteed to only contain valid faces but will include the 2,3 and 6 permutations. You can also take it in either orientation in whatever way is convenient. Please state the chosen orientation in your answer.
Output the calculated score
Standard Loopholes are forbidden
This is code-golf.

Examples
// 2,5,2,4,6: Output should be: 4
[ [ 0,0,1 ],
  [ 0,0,0 ],
  [ 1,0,0 ],
  [ 1,0,1 ],
  [ 0,1,0 ],
  [ 1,0,1 ],
  [ 0,0,1 ],
  [ 0,0,0 ],
  [ 1,0,0 ],
  [ 1,0,1 ],
  [ 0,0,0 ],
  [ 1,0,1 ],
  [ 1,1,1 ],
  [ 0,0,0 ],
  [ 1,1,1 ] ]

// 1,6,2,4,6: Output should be: 0
[ [ 0,0,0, 1,0,1, 1,0,0, 1,0,1, 1,1,1  ],
  [ 0,1,0, 1,0,1, 0,0,0, 0,0,0, 0,0,0  ],
  [ 0,0,0, 1,0,1, 0,0,1, 1,0,1, 1,1,1  ] ]

// 5,6,6,4,6: Output should be: 12
[ [ 1,0,1, 1,0,1, 1,1,1, 1,0,1, 1,1,1  ],
  [ 0,1,0, 1,0,1, 0,0,0, 0,0,0, 0,0,0  ],
  [ 1,0,1, 1,0,1, 1,1,1, 1,0,1, 1,1,1  ] ]

// 3,3,4,5,6: Output should be: 6
[ [ 0,0,1, 1,0,0, 1,0,1, 1,0,1, 1,1,1  ],
  [ 0,1,0, 0,1,0, 0,0,0, 0,1,0, 0,0,0  ],
  [ 1,0,0, 0,0,1, 1,0,1, 1,0,1, 1,1,1  ] ]

// 2,5,2,5,6: Output should be: 0
[ [ 0,0,1, 1,0,1, 1,0,0, 1,0,1, 1,1,1  ],
  [ 0,0,0, 0,1,0, 0,0,0, 0,1,0, 0,0,0  ],
  [ 1,0,0, 1,0,1, 0,0,1, 1,0,1, 1,1,1  ] ]

Suggested test case: One where the value 5 is present two times, like [2,5,2,5,6]. My current solution works for all four of your test cases (by using a very bad method of sorting the values and removing the sub-list [4,5,6]), which of course fails when 5 is present two times.

The core idea is good, however the way it has been drafted strikes me as falling under one of our categories of things to avoid when writing challenges, namely "adding unnecessary fluff". Parsing the dice does not seem to be the main part of the challenge, but it may well take half the code.

@KevinCruijssen added

@JonathanAllan It's a game about dice so I gave them dice. I do agree that making them validate faces would be fluffy hence it's not part of the challenge. Dice matrices also allow for interesting solutions because just scoring 654 with integers is not very hard or all that unique.

@Veskah and yet all 12 answers split or mould and sum to get the integers and then use those as if they were provided.

@JonathanAllan I'll keep it in mind for the future but won't change the specs now.

@Veskah yes definitely don't change the specs now! Here's to many more fun challenges :)

05AB1E, 15 bytes
3ôO<O©3LsK_P®O*

Try it online! or Check out a test suite!
Uses the same trick as Chas Brown and Lynn use: decrementing each integer in each 3x3 sub-matrix rather than subtracting 15 at the end. Expects input in column format.
How it works
3ôO<OD3LsK_PsO* – Full program.
3ô              – Split the input in 3x3 matrices representing dice faces.
  O<O           – Sum each, subtract one and sum each again.
                  This works because after the first O there are 3 elements in each
                  list and there are 5 lists in total, so 3 * 5 = 15 = 4 + 5 + 6.
     ©          – Copy this to the register.
      3LsK      – Push [1, 2, 3] and perform set subtraction. In this scenario, we
                  have already subtracted 3 from each list, so [1, 2, 3] represent
                  the actual dice values [4, 5, 6]. If the resulting list is empty,
                   that means that those values do exist in our roll. Therefore:
          _P    – Produce a list of zeros of that length and take the product
                  (4,5,6 isn't in the dice roll if the list is empty
                  and this method assures that in this case the product is 1, else 0)
            ®O* – Sum what's in the register and multiply by that.

Perl 6, 48 46 bytes
Thanks to Ramillies for -2 bytes
{(^3+4⊂.flat.rotor(9)>>.sum)*(.flat.sum-15)}

Try it online!
An anonymous code block that takes the matrix vertically and returns an integer.
Explanation:
{                                          } # Anonymous code block
                             (.flat.sum-15)  # Get the total sum of the array minus 15
                            * # Multiply by:
 (^3+4⊂                    )    # Whether 4,5,6 is a sub-array of:
       .flat.rotor(9)>>.sum     # The value of each dice

I think you can save 1 byte if you take one List of Lists instead of a bunch of Arrays and use .flat instead of .[*;*], like this

Python 2, 81 bytes
f=lambda a,r=[]:a and f(a[3:],r+[sum(sum(a[:3],[]))-3])or({1,2,3}<=set(r))*sum(r)

Try it online!
All input is expected to be in the column form.

Jelly, 14 bytes
s3§’§µ3Rœ-⁸ṆaS

Try it online!
Accepts a column of dice.
                  With the input (a 15×3 binary matrix):
s3                 Split into threes: now we have 5 dice, each a 3×3 matrix.
  §                Sum-each. Now we have a list of triples.
   ’               Decrement: turn each triple [x,y,z] into [x−1,y−1,z−1].
    §              Sum-each. Now we have a list of dice pip sums minus 3.
     µ            With these sums X:
      3Rœ-⁸        Subtract them from {1, 2, 3} as a multiset.
           Ṇ       Is the result empty? (This means {1, 2, 3} ⊆ X.)
            aS     If so, yield sum(X). Else the result stays 0.

Just like Chas Brown’s Python answer, this offsets each dice value by −3 so that we don’t need to subtract 15 (4+5+6) from the very last sum.

MATL, 12 bytes
9es3-I:ymp*s

Try it online!
Takes input in horizontal orientation as a 3x15 matrix. @Chas Brown's trick of subtracting 3 early (instead of 15 later) saved multiple bytes in different ways.
9e      % reshape input to have 9 rows - each dice matrix is linearized into a column
s       % sum each column (to get dice values)
3-      % subtract 3 from each value, let's call this array A
I:      % form range 1 to 3
y       % bring a copy of array A to the top of stack
m       % check if each of 1, 2, 3 are members of A
        %  returns a logical array of 3 boolean values
p       % product of that result - 0 if any were not members, 1 if they all were
*       % multiply the original array A by this result
s       % sum

Brachylog, 23 22 bytes
+ᵐ-₁ᵐḍ₅+ᵐJo⊇~⟦₁3∧J+|∧0

+3 bytes but prints out 0 instead of false if no 4,5,6 (Fatalize)
-2 4 bytes (sundar)

One of my first branchylog programs. Can probably be golfed more. Prints false if there is no 4,5,6. idk how to make it output 0.
Try it online!

I haven't read the challenge, but if you want your program to output 0 instad of false, appending |∧0 at the end should do the job.

I think you can save 2 bytes by postponing the ḍ₅: Try it online!

2 more bytes can be saved by using the ~ operator and avoiding needing I: Try it online! (note that I have also added the |∧0 here).

R, 56 bytes
function(m)sum(x<-by(c(m),0:44%/%9,sum)-3)*all(1:3%in%x)

Try it online!

-6 bytes thanks to JayCe
-1 byte thanks to Giuseppe

this is awesome ! save 3 bytes

also I think you can do c(m) to flatten m instead of m[1:45]

@JayCe: of course, thanks a lot !

56 bytes using inline assignment

05AB1E, 30 29 22 bytes
3ôOOJ456vyõ.;}Dg<iSOë0

Takes the dice-matrices below each other.
Try it online or verify all test cases.
Explanation:
3ô              # Split into sub-lists of 3, so we now have our dices
                #  i.e. [[A],[B],[C],[D],[E],[F],...] → [[[A],[B],[C]],[[D],[E],[F]],...]
  OO            # Sum each row, and then sum the total
                #  i.e. [[0,0,1],[0,0,0],[1,0,0]] → [1,0,1] → 2
    J           # Join everything together to a single string
                #  [5,4,2,5,6] → '54256'
     456v    }  # For each `y` in [4,5,6]:
         yõ.;   #  Replace the first occurrence with an empty string
                #  i.e. '54256' → '52'
D               # Duplicate the result
 g              # Take the length
                #  i.e. '52' → 2
  <i            # If the length is exactly 2 (and thus we've successfully removed [4,5,6]):
    SO          #  Split the string into digits again, and sum them as result
  ë             # Else:
    0           #  The result is 0 instead

Pyth, 20 bytes
*-ssQ15}j456TySsMc5s

Expects input as a column of dice (as in test case 1). Try it online here, or verify all test cases at once here.
*-ssQ15}j456TySsMc5sQ   Implicit: Q=eval(input()), T=10
                        Trailing Q inferred
                   sQ   Flatten input into a single array
                 c5     Chop into 5 pieces
               sM       Take the sum of each piece
              S         Sort
             y          Take the power set
       }                Does the above contain...
        j456T           ... [4,5,6]? 1 if so, 0 otherwise <a>
  ssQ                   Deep sum of input (total pips)
 -   15                 Subtract 15 <b>
*                       Multiply <a> and <b>, implicit print

JavaScript (ES6), 78 bytes
Takes input as a column of dice.
a=>!(a+0).replace(/.{18}/g,s=>(t+=n=s.split`1`.length,a|=1<<n),t=-20)|a>223&&t

Try it online!
How?
By doing a + 0, we implicitly flatten and coerce the input array to a string and add a trailing "0", which gives exactly 5x18 = 90 characters.
For instance, the first test case leads to:
0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,1,0,1,1,1,1,0,0,0,1,1,10
\____dice #1____/ \____dice #2____/ \____dice #3____/ \____dice #4____/ \____dice #5____/

For each dice substring s of 18 characters, we compute the number n of pips + 1 and we update the total number of pips t with:
t += n = s.split`1`.length

We re-use the input array a as a bitmask to keep track of each dice that was encountered at least once:
a |= 1 << n

If the roll contains at least one 4, one 5 and one 6, the bitmask a will have the following bits set:
11100000 (224 in decimal)

We test this by doing a > 223. If successful, we return t. Because we count one extra pip for each dice and because we don't want to count 4+5+6 in the result, t is initialized to -(5 + (4+5+6)) = -20.

Dyalog APL, 28 27 bytes
{+/⍵×∧/∨/⍉⍵∘.=⍳3}¯3+(+/¨,¨)

Try it online!
Takes a 1x5 matrix of 3x3 dice matrices as input.
+/¨,¨ adds up the pip values of each of the dice. Then subtract 3, use ∨/⍉⍵∘.=⍳3 to check if there is at least one instance each of (1, 2, 3), AND the results together with ∧/ and multiply the result (0 or 1) by the sum of the adjusted dice values (+/⍵).

Retina 0.8.2, 45 bytes
¶

M!`.{9}
%M`1
O`
¶

G`4.*5.*6
.
$*
1{15}

1

Try it online! Takes vertical dice. Explanation:
¶

M!`.{9}

Reshape the dice into 5 individual rows.
%M`1

Get the values of each row.
O`

Sort them into order.
¶

Join them into a single string.
G`4.*5.*6

Ensure that the three required dice are present.
.
$*

Convert each die to unary.
1{15}

Subtract the matching 4, 5 and 6.
1

Sum and convert to decimal.

Jelly, 18 bytes
s3§§µṬṚḄ>55×S_15»0

A monadic link
Try it online!

Octave, 54 bytes
@(M)sum(prod(ismember(1:3,v=sum(reshape(M,9,5))-3))*v)

Try it online!
Port of my MATL answer.

Ruby, 78 bytes
->a{s=->x{x.flatten.sum};t=4,5,6;q=a.each_slice(3).map(&s);(t&q==t)?s[a]-15:0}

Try it online!


text:
crossed out 44 is still regular 44 ;(
Introduction
On March 24th, 2015 @isaacg golfed his Pyth answer from 44 to 42 bytes. Since a crossed out 44 (44) looks a lot like a regular 44, @Optimizer made the following comment:

striked out 44 is still normal 44 :(

After that, on October 21st, 2015, @Doorknob♦ golfed his Ruby answer from 44 to 40 (and later 38) bytes and added the following part to his answer, with a link to that original comment of @Optimizer:

crossed out 44 is still regular 44 ;(

This was the start of an answer-chaining meme, where every crossed out 44 (and in some occasions 4 or 444) linked back to the previous one.
Then on April 8th, 2017 (I'm not sure if this was the first answer to do so, but it's the earliest one I could find), @JonathanAllan golfed his Python answer from 44 to 39. He however used <s> 44 </s> so the 44 would look like this:  44 , and added the following to his answer:

Crossed out  44  is no longer 44 :)

And that was basically the (beginning of the) end of the meme.
Challenge
As for this challenge: Given a list of positive integers and a date, output the list comma-and-space separated where every number except for the last one is placed between <s>...</s> tags.
In addition, if any of the crossed out numbers is in the sequence [4, 44, 444, 4444, ...] (A00278 on oeis.org):

If the date is before April 8th, 2017: Also output the exact (all lowercase and with semicolon emoticon) text crossed out N is still regular N ;( (N being the crossed out number from the sequence) on a second line.
If the date is April 8th, 2017 or later: The crossed out number N from the sequence should have the leading and trailing   added. No need for any additional lines of output.

Examples:
Input: list = [50, 48, 44, 41], date = January 1st, 2017
Output:
<s>50</s>, <s>48</s>, <s>44</s>, 41
crossed out 44 is still regular 44 ;(

Input: list = [500, 475, 444, 301, 248], date = June 2nd, 2018
Output:
<s>500</s>, <s>475</s>, <s> 444 </s>, <s>301</s>, 248

Challenge rules:

You can assume the input-list is a sorted list from largest to smallest, only containing positive integers. In reality a byte-count can also go up due to bug-fixes, but for the sake of this challenge we pretend it only goes down.
You can assume only a single number from the sequence [4, 44, 444, 4444, ...] is present in the input-list (if any).
The output format is either printed to STDOUT, or returned as a string (or character array/list/2D-array if that's preferable). A trailing newline is of course optional.
The output format is strict. <s>...</s> is mandatory;  ...  is mandatory; ", " (comma and space) is mandatory; and \ncrossed out ... is still regular ... ;( exactly is mandatory (on a separated line).
You may take the input-date as date-objects; timestamps; loose integers for year, month, and day; a single number in the format yyyyMMdd; integer days since December 31st, 1899 (which would be 42832 for April 8th, 2017); or any other reasonable input-format. The date if-statement isn't the major part of this challenge.
The input integer-list can also be a list of strings if you want.
You don't have to add the <sup>...</sup> tags to the crossed out ... is still regular ... ;( line as is usually done with the actual meme answers.
You can assume the input-list will never contain byte-counts outside the [1, 50000] range (so you'll only have these five {4, 44, 444, 4444, 44444} to worry about).

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, adding an explanation for your answer is highly recommended.

Test cases:
Input: [50, 48, 44, 41] and January 1st, 2017
Output:
<s>50</s>, <s>48</s>, <s>44</s>, 41
crossed out 44 is still regular 44 ;(

Input: [500, 475, 444, 301, 248] and  June 2nd, 2018
Output:
<s>500</s>, <s>475</s>, <s> 444 </s>, <s>301</s>, 248

Input: [8, 6, 4] and December 5th, 2017
Output:
<s>8</s>, <s>6</s>, 4

Input: [8, 6, 4, 3, 2] and September 15th, 2015
Output:
<s>8</s>, <s>6</s>, <s>4</s>, <s>3</s>, 2
crossed out 4 is still regular 4 ;(

Input: [119, 99, 84, 82, 74, 60, 51, 44, 36, 34] and February 29th, 2016
Output:
<s>119</s>, <s>99</s>, <s>84</s>, <s>82</s>, <s>74</s>, <s>60</s>, <s>51</s>, <s>44</s>, <s>36</s>, 34
crossed out 44 is still regular 44 ;(

Input: [404, 123, 44] and March 4th, 2016
Output:
<s>404</s>, <s>123</s>, 44

Input: [4, 3] and April 8th, 2017
Output:
<s> 4 </s>, 3

Input: [44] and October 22nd, 2017
Output:
44

Input: [50000, 44444, 1500] and August 1st, 2018
Output:
<s>50000</s>, <s> 44444 </s>, 1500

Input: 50, 38, 23 and September 8th, 2001
Output:
<s>50</s>, <s>38</s>, 23

Your last test case is missing its date?

@Neil Ah oops.. Fixed. Date doesn't really matter for that one, but added one regardless. Thanks for noticing.

I can confirm that I had not noticed anyone use the non-breaking space for this specific purpose and that was why I wrote the "no longer" text.

(I can also confirm that I had used it prior to using it with 44 - I believe that is when I first used them)

As we can take input as days since 1889-12-31, can we also take days since 2017-04-08?

Also, can we take the byte-counts as a list of strings instead of integers?

@TFeld Sure. I guess it helps with surrounding it with strings <s> and </s> and a regex-check for 4+ can be used in that case. But yes, taking the list as strings is fine by me.

poke: integer days since arbitrary fixed dates (e.g. 2017-04-07) is fine? (as asked above)

Your fifth test case appears to be incorrect - should be crossed out 44, not 4.

@darrylyeo Fixed

@TFeld Sorry for the late response, somehow missed it. And sorry, but no. That's pushing it a bit too far tbh. Then you'd only have to check <0 or >=0.

Jelly,  444 , 94, 93 bytes
Ñȧ$“ ”,¤j$€io.ɗ¦@Ṗj@€“<s>“</s>”oj⁾,
⁴>⁽A€
“¢⁻$gẆẠ⁷Ṭ]ḳṁṛż?=çỊI×V»Ỵjṭ⁷ẋÇ¬ȧẠƲ
ṖḟÐḟ”4Ḣµñ³,Ç

A full program. The inputs are a list of strings and a date taken as integer days since January the first 1970 (making 17264 April the eighth 2017)
Try it online!
How?
Ñȧ$“ ”,¤j$€io.ɗ¦@Ṗj@€“<s>“</s>”oj⁾,  - Link 1: L = list of characters ("4...4") OR integer (0),
                                          -         R = list of lists of characters (the strings provided to the program)
  $                                       - last 2 links as a monad:
Ñ                                         -   call next Link (2) as a monad
                                          -   ...gets: is date input to program greater than 2017-04-07?
 ȧ                                        -   AND (if so gets the value of L, else 0), say X
                    ¦@                    - sparse application (with swa@pped @rguments)...
                      Ṗ                   - ...with right argument = popped R (without it's rightmost entry)
                   ɗ                      - ...to: last 3 links as a dyad
                i                         -          first index of X in popped R (0 if no found, so 0->0)
                  .                       -          literal 0.5
                 o                        -          OR (change any 0 to 0.5)
                                          -        ...i.e. index of "4...4" if L was one or 0.5, an invalid index
              $€                          - ...do: for €ach... last 2 links as a monad:
            ¤                             -          nilad followed by link(s) as a nilad:
   “ ”                               -            literal list of characters = " "
           ,                              -            pair (with itself) = [" ", " "]
             j                            -            join (with the item) e.g.: " 444 " or [" ", 0, " "]
                          “<s>“</s>”      - literal list of lists of characters = ["<s>", "</s>"]
                       j@€                - for €ach... join (with swa@pped @rguments)
                                    o     - OR with R (vectorises, so adds the popped entry back onto the right-side)
                                      ⁾,  - literal list of characters = ", "
                                     j    - join

⁴>⁽A€ - Link 2: greater than 2017-04-07?
⁴     - program's 4th argument (2nd input)
  ⁽A€ - literal 17263 (days(2017-04-07 - 1970-01-01))
 >    - greater than?

“¢⁻$gẆẠ⁷Ṭ]ḳṁṛż?=çỊI×V»Ỵjṭ⁷ẋÇ¬ȧẠƲ - Link 3: L = list of characters ("4...4") OR integer (0)
“¢⁻$gẆẠ⁷Ṭ]ḳṁṛż?=çỊI×V»           - compressed list of characters = "crossed out \n is still regular \n ;("
                     Ỵ           - split at newlines = ["crossed out ", " is still regular ", " ;("]
                      j          - join with L
                        ⁷        - literal newline character
                       ṭ         - tack (add to the front)
                              Ʋ  - last 4 links as a monad:
                          Ç      -   call last Link (2) as a monad
                           ¬     -   NOT
                             Ạ   -   All (1 if L is "4...4", 0 if L is 0)
                            ȧ    -   AND
                         ẋ       - repeat (i.e. get the list of characters to print or an empty list)

ṖḟÐḟ”4Ḣµñ³,Ç - Main Link: list of strings, integer (days since 1970-01-01)
Ṗ            - pop (list of strings without it's rightmost entry)
  Ðḟ         - filter discard if:
 ḟ           -   filter discard any which are in...
    ”4       -   ...literal character '4'
      Ḣ      - head (yields 0 if list is now empty)
       µ     - new monadic chain, call that X
         ³   - program's 3rd argument (1st input) - call that Y)
        ñ    - call next Link (1) as a dyad (i.e. f1(X, Y))
           Ç - call last Link (3) as a monad (ie. f3(X))
          ,  - pair
             - implicit (smashing) print

You forgot to remove the input from another challenge in your TIO. ;) Nice answer regardless. Would you mind adding an explanation? And rofl at that 444-byte count. I don't believe it one bit that you started with that, unless you added comments. ;p

Opps, thanks. I'll add an explanation shortly.

444 version no comments, numbers rather than compressed strings

...ah the 444 version has a bug - its using days since 1969-12-31 not since 1970-01-01 as the golfed version does >_< (naive fix is still 444)

Python 2, 208 204  203 201 197 bytes
Takes input as a list of strings, and an int of yyyymmDD
def f(l,d):
 A=a=d>20170407;r=[]
 for n in l[:-1]:x=set(n)=={'4'};S=' '*x*a;r+=['<s>'+S+n+S+'</s>'];A=x*n or A
 print', '.join(r+l[-1:])+'\ncrossed out %s is still regular %s ;('%(A,A)*(a*A<A)

Try it online!

Excel VBA, 217 bytes
VBE immediate window function that takes input array from range [A:A], and date  from range [B1] and outputs to the console.
c=[Count(A:A)]:d=[B1]>42832:For i=1To c-1:n=Cells(i,1):l=InStr(44444,n):s=IIf(d*l," ",""):v=IIf((d=0)*l,n,v):?"<s>"s;""&n;s"</s>, ";:Next:?""&Cells(i,1):?IIf(v,"crossed out "&v &" is still regular "&v &" ;(","");

Ungolfed and Commented
c=[Count(A:A)]                  ''  Get numer of elements
d=[B1]>42832                    ''  Check if date is after 7 Apr 2017,
For i=1To c-1                   ''  Iterate over index
n=Cells(i,1)                    ''  Get array val at index
l=InStr(44444,n)                ''  Check if val is all 4s
s=IIf(d*l," ","")          ''  If after 7 Aug 2017, and All 4s, let `s` be " "
v=IIf((d=0)*l,n,v)              ''  If all 4s, and not after date, let v hold n, else hold v
?"<s>"s;""&n;s"</s>, ";         ''  Print striked vales, with " ", if applicable
Next                            ''  Loop
?""&Cells(i,1)                  ''  Print last value in array
                                ''  (below) Print meme, if needed
?IIf(v,"crossed out "&v &" is still regular "&v &" ;(","");

-2 bytes for changing date format to YYYYMMDD
-1 byte for comparing to 42832 (int value for 07 Apr 2017), Thanks @Neil
-2 bytes for removing 1, from the InStr statement, Thanks @SeaDoggie01

I guess For i=1To~-c instead of For i=1To c-1 isn't possible in Excel VBA? If I recall correctly Bitwise not is Not instead of ~, or are both possible? (Note that I know next to nothing of Excel VBA, so I'm probably saying something stupid here. ;p)

@KevinCruijssen Yeah, bitwise not is Not , so no ~ :(

I think you can save more bytes by changing the date format back to date and comparing against 42832 (the integer value of 2017-04-07).

I think you can save 2 bytes by removing the "1," from the instr (it's optional)

Haskell, 227 bytes
i[]=1>0;i('4':s)=i s;i(_:_)=0>1
f l d=m l++c where a=head$filter i l;t d|d<42832=("","\ncrossed out "++a++" is still regular "++a++" ;(")|1>0=(" ","");(b,c)=t d;w n|i n=b++n++b|1>0=n;m[n]=n;m(x:s)="<s>"++w x++"</s>, "++m s

Try it online!
Run f with list l and date d. 42832 is the changing date.

Would it be possible to add a TIO-link with test code?

@KevinCruijssen in Russia it's banned

Oh, didn't knew that. Well, I don't know Haskell too well, otherwise I would have tested it myself a bit. But the code itself seems logical, so +1 from me nonetheless.

@KevinCruijssen you can copy code to TIO, make link and add it to post

@KevinCruijssen TIO is banned by mistake, but I'm too lazy to use proxy/contact ISP about it

i=all(=='4') saves quite a few bytes. Also a let in a pattern guard, that is f l d|let a= .... =m l++c, is shorter than a where.

Ruby, 208 184 180 bytes
TIO-test
Thanks for @KevinCruijssen for saving 2 bytes!
->n,d{*h,t=n;i=20170408>d;f=?\n;h.map{|u|o=u.digits|[]==[4];f=o&&i ?f+"crossed out #{u} is still regular #{u} ;(":f;o&&!i ?"<s> #{u} </s>":"<s>#{u}</s>"}*", "+", #{t}"+f}

It's a lambda function that takes a list of numbers and an integer as a date in the format of YYYYmmdd.

Would it be possible to add a TIO-link with test code? And switching formats so it's an integer input would indeed save some bytes. :)

@KevinCruijssen Added link ;)

Thanks! +1 from me. You can save 2 bytes by removing the spaces after the ?. Also, for your TIO, you can split your actual submission code and test code with the header/footer, like this. :)

Retina 0.8.2, 130 bytes
$
;42833
O`;.{5}
\b(4+),(?=.*;42833;)
&$1&,
&

.{12}$

\b(4+),.*
$&¶crossed out $1 is still regular $1 ;(
(.+?),
<s>$1</s>,

Try it online! Link includes test cases. Uses Excel date stamps (days since 1899-12-31 but including 1900-02-49). 141 bytes for a version that takes ISO dates:
$
;2017-04-08
O`;.{10}
\b(4+),(?=.*;2017-04-08;)
&$1&,
&

.{22}$

\b(4+),.*
$&¶crossed out $1 is still regular $1 ;(
(.+?),
<s>$1</s>,

Try it online! Link includes test cases. Explanation:
$
;2017-04-08

Append the cut-off date to the input.
O`;.{10}

Sort the dates. If the given date is on or after the cut-off date then the first date will be the cut-off date.
\b(4+),(?=.*;2017-04-08;)
&$1&,
&

In that case, wrap the 4+ in   (using two stages as it saves a byte).
.{22}$

Delete the dates as they have done their job.
\b(4+),.*
$&¶crossed out $1 is still regular $1 ;(

If there's an unspaced 4+, then append the meme.
(.+?),
<s>$1</s>,

Strike out all of the obsolete byte counts.

You can save 5 bytes by taking the date-format without -.

@KevinCruijssen I could save even more bytes by asking for it as an Excel date (days since 1899-12-31). How far can I go with this?

Hmm.. You know what, that's also fine by me. How the if-statement for the date April 8th, 2017 is done I don't really care. It's not the major part of this challenge.

That would be 42832 for April 8th, 2017 I assume?

@KevinCruijssen My Excel says that's the 7th.

Oh.. miscalculated then. I used a simple Java script to look at the difference between April 8th 2017 and December 31st 1899. Anyway, let me know when you've change it including the number for all test cases, then I'll add them in the challenge description as well. :)

@KevinCruijssen No, Excel miscalculated, as it doesn't use the century rule for leap years.

@KevinCruijssen I've updated my answer to include the Excel date stamps.

JavaScript (Node.js), 173 bytes
a=>d=>a.map(x=>--i<1?x:`<s>${(b=/^4+$/.exec(x)?(c=x,d)<14915808e5?n=[]:" ":"")+x+b}</s>`,n="",c=0,i=a.length).join`, `+(n&&`
crossed out ${c} is still regular ${c} ;(`)

Try it online!
Using curry syntax f(array)(js_timestamp)

JavaScript, 194 bytes
(a,d,l=a.pop(),n=a.find(x=>/^4+$/.exec(x)),s=a.map(n=>`<s>${n}</s>, `).join``+l)=>d<1491609600?n?s+`
crossed out ${n} is still regular ${n} ;(`:s:s.replace(/>(4+)</g,(_,m)=>`> ${m} <`)

f=
(a,d,l=a.pop(),n=a.find(x=>/^4+$/.exec(x)),s=a.map(n=>`<s>${n}</s>, `).join``+l)=>d<1491609600?n?s+`
crossed out ${n} is still regular ${n} ;(`:s:s.replace(/>(4+)</g,(_,m)=>`> ${m} <`)

const date = s => Date.parse(s) / 1000
for(const output of [
 f([50, 48, 44, 41], date('January 1, 2017')),
 f([500, 475, 444, 301, 248], date('June 2, 2018')),
 f([8, 6, 4], date('December 5, 2017')),
 f([8, 6, 4, 3, 2], date('September 15, 2015')),
 f([119, 99, 84, 82, 74, 60, 51, 44, 36, 34], date('February 29, 2016')),
 f([404, 123, 44], date('March 4, 2016')),
 f([4, 3], date('April 8, 2017')),
 f([44], date('October 22, 2017')),
 f([50000, 44444, 1500], date('August 1, 2018')),
 f([50, 38, 23], date('September 8, 2001')),
]) console.log(output)

authors: Евгений Новиков