Introducción

El 24 de marzo de 2015, @isaacg mostró su respuesta de Pyth de 44 a 42 bytes. Dado que un 44 tachado ( 44 ) se parece mucho a un 44 regular, @Optimizer hizo el siguiente comentario:

trazado 44 sigue siendo normal 44 :(

Después de eso, el 21 de octubre de 2015, @ Doorknob ♦ mostró su respuesta de Ruby de 44 a 40 (y luego 38) bytes y agregó la siguiente parte a su respuesta, con un enlace a ese comentario original de @Optimizer :

^{tachado 44 sigue siendo regular 44; (}

Este fue el comienzo de un meme de encadenamiento de respuestas , donde todos tacharon 44 (y en algunas ocasiones 4 o 444) vinculados al anterior.

Luego, el 8 de abril de 2017 (no estoy seguro de si esta fue la primera respuesta para hacerlo, pero es la primera que pude encontrar), @JonathanAllan mostró su respuesta de Python del 44 al 39. Sin embargo, usó <s>&nbsp;44&nbsp;</s>el 44 se parece a esto:  44  , y agregó lo siguiente a su respuesta:

Tachado & nbsp; 44 & nbsp; ya no es 44 :)

Y ese fue básicamente el (principio del) final del meme.

Desafío

En cuanto a este desafío: dada una lista de enteros positivos y una fecha, genera la lista separada por comas y espacios donde cada número, excepto el último, se coloca entre las <s>...</s>etiquetas.

Además, si alguno de los números tachados está en la secuencia [4, 44, 444, 4444, ...]( A00278 en oeis.org ):

• Si la fecha es anterior al 8 de abril de 2017: también envíe el texto exacto (todo en minúscula y con emoticón de punto y coma) crossed out N is still regular N ;((que Nes el número tachado de la secuencia) en una segunda línea.
• Si la fecha es el 8 de abril de 2017 o posterior: el número tachado Nde la secuencia debe tener el inicio y el final  agregados. No se necesitan líneas de salida adicionales.

Ejemplos:

Entrada: list = [50, 48, 44, 41], date = January 1st, 2017
Salida:

<s>50</s>, <s>48</s>, <s>44</s>, 41
crossed out 44 is still regular 44 ;(

Entrada: list = [500, 475, 444, 301, 248], date = June 2nd, 2018
Salida:

<s>500</s>, <s>475</s>, <s>&nbsp;444&nbsp;</s>, <s>301</s>, 248

Reglas de desafío:

• Puede suponer que la lista de entrada es una lista ordenada de mayor a menor, que solo contiene enteros positivos. En realidad, un recuento de bytes también puede aumentar debido a las correcciones de errores, pero en aras de este desafío, pretendemos que solo disminuya.
• Puede suponer que solo un número de la secuencia [4, 44, 444, 4444, ...]está presente en la lista de entrada (si existe).
• El formato de salida se imprime en STDOUT o se devuelve como una cadena (o matriz de caracteres / lista / matriz 2D si eso es preferible). Una nueva línea final es, por supuesto, opcional.
• El formato de salida es estricto. <s>...</s>es obligatorio;  ... es obligatorio; ", "(coma y espacio) es obligatorio; y \ncrossed out ... is still regular ... ;(exactamente es obligatorio (en una línea separada).
• Puede tomar la fecha de entrada como objetos de fecha; marcas de tiempo; enteros sueltos para año, mes y día; un solo número en el formato yyyyMMdd; días enteros desde el 31 de diciembre de 1899 (que sería 42832para el 8 de abril de 2017); o cualquier otro formato de entrada razonable. La declaración if de fecha no es la mayor parte de este desafío.
• La lista de enteros de entrada también puede ser una lista de cadenas si lo desea.
• No tienes que agregar el <sup>...</sup> etiquetas a la crossed out ... is still regular ... ;(línea, ya que generalmente se hace con las respuestas reales de los memes.
• Puede suponer que la lista de entrada nunca contendrá recuentos de bytes fuera del [1, 50000]rango (por lo que solo tendrá {4, 44, 444, 4444, 44444}que preocuparse por estos cinco ).

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

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>&nbsp;444&nbsp;</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>&nbsp;4&nbsp;</s>, 3

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

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

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

Jalea ,  444  , 94 , 93 bytes

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

Un programa completo Las entradas son una lista de cadenas y una fecha tomada como días enteros desde enero del primer 1970 (lo que hace de 17264 el 8 de abril de 2017)

Pruébalo en línea!

¿Cómo?

Ñȧ$“&nbsp;”,¤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:
   “&nbsp;”                               -            literal list of characters = "&nbsp;"
           ,                              -            pair (with itself) = ["&nbsp;", "&nbsp;"]
             j                            -            join (with the item) e.g.: "&nbsp;444&nbsp;" or ["&nbsp;", 0, "&nbsp;"]
                          “<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

Python 2 , 208 204  203 201 197 bytes

Toma la entrada como una lista de cadenas y un int de yyyymmDD

def f(l,d):
 A=a=d>20170407;r=[]
 for n in l[:-1]:x=set(n)=={'4'};S='&nbsp;'*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)

Pruébalo en línea!

Excel VBA, 217 bytes

Función de ventana inmediata VBE que toma la matriz de entrada del rango [A:A]y la fecha del rango [B1]y las salidas a la consola.

c=[Count(A:A)]:d=[B1]>42832:For i=1To c-1:n=Cells(i,1):l=InStr(44444,n):s=IIf(d*l,"&nbsp;",""):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 &" ;(","");

No golfista y comentado

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 "&nbsp;", 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 para cambiar el formato de fecha a YYYYMMDD

-1 byte para comparar 42832(valor int para 07 Apr 2017), gracias @Neil

-2 bytes para eliminar 1,de la InStrdeclaración, gracias @ SeaDoggie01

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>, 

Pruébalo en línea! El enlace incluye casos de prueba. Utiliza sellos de fecha de Excel (días desde 1899-12-31 pero incluyendo 1900-02-49). 141 bytes para una versión que toma fechas ISO:

$
;2017-04-08
O`;.{10}
\b(4+),(?=.*;2017-04-08;)
&$1&,
&
 
.{22}$

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

$
;2017-04-08

Agregue la fecha de corte a la entrada.

O`;.{10}

Ordenar las fechas. Si la fecha dada es en o después de la fecha límite, entonces la primera fecha será la fecha límite.

\b(4+),(?=.*;2017-04-08;)
&$1&,
&
 

En ese caso, envuelva el 4+in  (usando dos etapas ya que guarda un byte).

.{22}$

Eliminar las fechas ya que han hecho su trabajo.

\b(4+),.*
$&¶crossed out $1 is still regular $1 ;(

Si hay un espacio sin espacio 4+, entonces agregue el meme.

(.+?),
<s>$1</s>, 

Elimine todos los recuentos de bytes obsoletos.

Ruby, 208 184 180 bytes

Prueba de TIO

¡Gracias por @KevinCruijssen por guardar 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>&nbsp;#{u}&nbsp;</s>":"<s>#{u}</s>"}*", "+", #{t}"+f}

Es una función lambda que toma una lista de números y un número entero como fecha en el formato de YYYYmmdd.

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)=>`>&nbsp;${m}&nbsp;<`)

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)=>`>&nbsp;${m}&nbsp;<`)


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)

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=("&nbsp;","");(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

Pruébalo en línea! Ejecutar fcon lista ly fecha d. 42832 es la fecha de cambio.

JavaScript (Node.js) , 173 bytes

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

Pruébalo en línea!

Usar sintaxis de curry f(array)(js_timestamp)