introduction

Le 24 Mars, ici à 2015 @isaacg golfed sa réponse Pyth de 44 à 42 octets. Puisqu'un 44 barré ( 44 ) ressemble beaucoup à un 44 normal, @Optimizer a fait le commentaire suivant:

rayé 44 est toujours normal 44 :(

Après cela, le 21 octobre 2015, @ Doorknob ♦ a joué sa réponse Ruby de 44 à 40 (et plus tard 38) octets et a ajouté la partie suivante à sa réponse, avec un lien vers ce commentaire original de @Optimizer :

^{barré 44 est toujours régulier 44;}

Ce fut le début d' un mème de chaînage de réponses , où chaque barré 44 (et dans certains cas 4 ou 444) était lié au précédent.

Puis le 8 Avril 2017 (Je ne sais pas si cela a été la première réponse à le faire, mais il est le premier que je pouvais trouver), @JonathanAllan golfed sa réponse Python de 44 à 39. Il a cependant utilisé de <s>&nbsp;44&nbsp;</s>sorte que le 44 serait ressembler à ceci:  44  , et a ajouté ce qui suit à sa réponse:

Biffé & nbsp; 44 & nbsp; n'a plus 44 ans :)

Et c'était essentiellement la (début de la) fin du mème.

Défi

En ce qui concerne ce défi: étant donné une liste d'entiers positifs et une date, sortez la liste par virgule et espace séparés où chaque numéro, à l'exception du dernier, est placé entre les <s>...</s>balises.

De plus, si l'un des nombres barrés est dans la séquence [4, 44, 444, 4444, ...]( A00278 sur oeis.org ):

• Si la date est antérieure au 8 avril 2017: affichez également le texte exact (en minuscules et avec émoticône point-virgule) crossed out N is still regular N ;((correspondant Nau numéro barré de la séquence) sur une deuxième ligne.
• Si la date est le 8 avril 2017 ou plus tard: le nombre barré Nde la séquence doit avoir le début et la fin  ajoutés. Pas besoin de lignes de sortie supplémentaires.

Exemples:

Entrée: list = [50, 48, 44, 41], date = January 1st, 2017
sortie:

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

Entrée: list = [500, 475, 444, 301, 248], date = June 2nd, 2018
sortie:

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

Règles du défi:

• Vous pouvez supposer que la liste d'entrée est une liste triée du plus grand au plus petit, contenant uniquement des entiers positifs. En réalité, un nombre d'octets peut également augmenter en raison de corrections de bogues, mais pour ce défi, nous prétendons qu'il ne diminue que.
• Vous pouvez supposer qu'un seul numéro de la séquence [4, 44, 444, 4444, ...]est présent dans la liste d'entrée (le cas échéant).
• Le format de sortie est soit imprimé sur STDOUT, soit retourné sous forme de chaîne (ou tableau de caractères / liste / tableau 2D si cela est préférable). Une nouvelle ligne de fin est bien sûr facultative.
• Le format de sortie est strict. <s>...</s>est obligatoire;  ... est obligatoire; ", "(virgule et espace) est obligatoire; et \ncrossed out ... is still regular ... ;(est exactement obligatoire (sur une ligne séparée).
• Vous pouvez prendre la date d'entrée comme des objets de date; horodatages; entiers lâches pour l'année, le mois et le jour; un seul numéro dans le format yyyyMMdd; jours entiers depuis le 31 décembre 1899 (ce serait 42832le 8 avril 2017); ou tout autre format d'entrée raisonnable. La date if-statement n'est pas la partie principale de ce défi.
• La liste d'entiers en entrée peut également être une liste de chaînes si vous le souhaitez.
• Vous n'avez pas à ajouter les <sup>...</sup>balises à la crossed out ... is still regular ... ;(ligne comme cela se fait habituellement avec les réponses réelles aux memes.
• Vous pouvez supposer que la liste d'entrée ne contiendra jamais de décomptes d'octets en dehors de la [1, 50000]plage (vous n'aurez donc que ces cinq {4, 44, 444, 4444, 44444}à vous soucier).

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

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

Gelée ,  444  , 94 , 93 octets

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

Un programme complet. Les entrées sont une liste de chaînes et une date prise en jours entiers depuis le 1er janvier 1970 (faisant du 17264 au 8 avril 2017)

Essayez-le en ligne!

Comment?

Ñȧ$“&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 203 201 197 octets

Prend l'entrée comme une liste de chaînes et un entier 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)

Essayez-le en ligne!

Excel VBA, 217 octets

Fonction de fenêtre immédiate VBE qui prend le tableau d'entrée de la plage [A:A], la date de la plage [B1]et les sorties vers la 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,"&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 &" ;(","");

Non golfé et commenté

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 octets pour changer le format de date en YYYYMMDD

-1 octet pour comparer à 42832(valeur int pour 07 Apr 2017), merci @Neil

-2 octets pour la suppression 1,de la InStrdéclaration, merci @ SeaDoggie01

Retina 0.8.2 , 130 octets

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

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

Essayez-le en ligne! Le lien inclut des cas de test. Utilise des tampons dateurs Excel (jours depuis 1899-12-31 mais incluant 1900-02-49). 141 octets pour une version qui prend des dates 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>, 

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

$
;2017-04-08

Ajoutez la date limite à l'entrée.

O`;.{10}

Triez les dates. Si la date indiquée est la date limite ou postérieure, la première date sera la date limite.

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

Dans ce cas, l'envelopper 4+dans  ( en utilisant deux étapes , comme il enregistre un octet).

.{22}$

Supprimez les dates car ils ont fait leur travail.

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

S'il y a un espace 4+, ajoutez le mème.

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

Supprimez tous les comptages d'octets obsolètes.

Rubis, 208 184 180 180 octets

Test TIO

Merci pour @KevinCruijssen d'avoir enregistré 2 octets!

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

C'est une fonction lambda qui prend une liste de nombres et un entier comme date au format YYYYmmdd.

JavaScript, 194 octets

(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 octets

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

Essayez-le en ligne! Exécuter favec liste let date d. 42832 est la date changeante.

JavaScript (Node.js) , 173 octets

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} ;(`)

Essayez-le en ligne!

Utilisation de la syntaxe curry f(array)(js_timestamp)