पार किया गया 44 अभी भी नियमित है 44 ;;


18

परिचय

मार्च 24 वें, 2015 @isaacg golfed उसकी Pyth जवाब 44 42 बाइट्स से। चूंकि एक पार किया हुआ 44 ( 44 ) एक नियमित 44 की तरह दिखता है, @ ऑप्टिमाइज़र ने निम्नलिखित टिप्पणी की:

स्ट्राइक 44 अभी भी सामान्य है 44 :(

उसके बाद, 21 अक्टूबर, 2015 को, @ दरवाज़े ♦ golfed उसकी रूबी जवाब 44 से 40 (और बाद में 38) बाइट्स और की है कि मूल टिप्पणी के लिंक के साथ अपने जवाब के लिए निम्न हिस्सा कहा, करने के लिए @Optimizer :

पार किया गया 44 अभी भी नियमित है 44 ;;

यह एक उत्तर-पीछा करने वाली मेम की शुरुआत थी , जहां प्रत्येक ने 44 को पार किया (और कुछ अवसरों में 4 या 444) पिछले एक से जुड़ा हुआ था।

फिर अप्रैल 8 वीं, 2017 (मुझे यकीन है कि अगर यह ऐसा करने के लिए पहले जवाब था नहीं कर रहा हूँ, लेकिन यह जल्द से जल्द एक मैं मिल सकता नहीं है) पर, @JonathanAllan golfed उसके अजगर जवाब 44 से 39. करने के लिए लेकिन उन्होंने इस्तेमाल किया <s>&nbsp;44&nbsp;</s>तो 44 होगा इस तरह देखो:  44  , और उसके जवाब में निम्नलिखित जोड़ा:

पार किया & nbsp; 44 & nbsp; अब 44 नहीं है :)

और वह मूल रूप से (मेम की) शुरुआत थी।

चुनौती

इस चुनौती के लिए: सकारात्मक पूर्णांक और एक तिथि की सूची को देखते हुए, सूची अल्पविराम और अंतरिक्ष को अलग कर दिया, जहां पिछले एक को छोड़कर हर संख्या <s>...</s>टैग के बीच रखी गई है ।

इसके अलावा, यदि कोई पार की गई संख्या अनुक्रम में है [4, 44, 444, 4444, ...]( A00278 oeis.org पर ):

  • यदि दिनांक 8 अप्रैल, 2017 से पहले है: दूसरी पंक्ति पर सटीक (सभी लोअरकेस और अर्धविराम इमोटिकॉन के साथ) पाठ crossed out N is still regular N ;(( Nक्रम से पार की गई संख्या) का उत्पादन करें।
  • यदि तारीख 8 अप्रैल, 2017 या उसके बाद है: Nअनुक्रम से पार की गई संख्या में अग्रणी और अनुगामी &nbsp;जोड़ा जाना चाहिए । आउटपुट की किसी भी अतिरिक्त लाइनों की आवश्यकता नहीं है।

उदाहरण:

इनपुट: list = [50, 48, 44, 41], date = January 1st, 2017
आउटपुट:

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

इनपुट: list = [500, 475, 444, 301, 248], date = June 2nd, 2018
आउटपुट:

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

चुनौती नियम:

  • आप मान सकते हैं कि इनपुट-लिस्ट सबसे बड़ी से लेकर सबसे छोटी तक की एक क्रमबद्ध सूची है, जिसमें केवल सकारात्मक पूर्णांक हैं। वास्तव में बग-फिक्स के कारण एक बाइट-काउंट भी बढ़ सकता है, लेकिन इस चुनौती के लिए हम इसे केवल दिखावा करते हैं।
  • आप मान सकते हैं कि अनुक्रम से केवल एक ही संख्या [4, 44, 444, 4444, ...]इनपुट-सूची में मौजूद है (यदि कोई हो)।
  • आउटपुट फॉर्मेट या तो STDOUT में प्रिंट किया जाता है, या स्ट्रिंग के रूप में लौटाया जाता है (या वर्ण सरणी / सूची / 2D-सरणी, यदि वह बेहतर हो तो)। एक अनुगामी न्यूलाइन निश्चित रूप से वैकल्पिक है।
  • आउटपुट स्वरूप सख्त है। <s>...</s>अनिवार्य है; &nbsp;...&nbsp;अनिवार्य है; ", "(अल्पविराम और स्थान) अनिवार्य है; और \ncrossed out ... is still regular ... ;(वास्तव में अनिवार्य है (एक अलग लाइन पर)।
  • आप दिनांक-ऑब्जेक्ट के रूप में इनपुट-दिनांक ले सकते हैं; timestamps; वर्ष, माह, और दिन के लिए ढीले पूर्णांक; प्रारूप में एक भी संख्या yyyyMMdd; 31 दिसंबर, 1899 के बाद से पूर्णांक दिन (जो 428328 अप्रैल, 2017 के लिए होगा); या कोई अन्य उचित इनपुट-प्रारूप। अगर तारीख-बयान इस चुनौती का प्रमुख हिस्सा नहीं है।
  • यदि आप चाहें तो इनपुट पूर्णांक-सूची भी तार की एक सूची हो सकती है।
  • आपको <sup>...</sup>टैग को crossed out ... is still regular ... ;(लाइन में जोड़ने की ज़रूरत नहीं है जैसा कि आमतौर पर वास्तविक मेम के उत्तरों के साथ किया जाता है।
  • आप मान सकते हैं कि इनपुट-लिस्ट में [1, 50000]रेंज के बाहर बाइट-काउंट्स कभी नहीं होंगे (इसलिए आपको {4, 44, 444, 4444, 44444}चिंता करने के लिए केवल ये पांच ही होंगे )।

सामान्य नियम:

  • यह , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
  • मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति दी जाती है। तुम्हारा फोन।
  • डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
  • साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

परीक्षण के मामलों:

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

आपका अंतिम परीक्षण मामला इसकी तारीख याद कर रहा है?
नील

1
@ नील आह उफ़ .. फिक्स्ड। तारीख वास्तव में उस एक के लिए मायने नहीं रखती है, लेकिन एक की परवाह किए बिना जोड़ा गया। ध्यान देने के लिए धन्यवाद।
केविन क्रूज़सेन

1
मैं यह पुष्टि कर सकता हूं कि मैंने इस विशिष्ट उद्देश्य के लिए किसी को भी गैर-ब्रेकिंग स्पेस का उपयोग करने पर ध्यान नहीं दिया था और यही कारण है कि मैंने "अब नहीं" पाठ लिखा था।
जोनाथन एलन

(मैं यह भी पुष्टि कर सकता हूं कि मैंने इसे 44 के साथ उपयोग करने से पहले इस्तेमाल किया था - मुझे विश्वास है कि जब मैंने पहली बार उनका इस्तेमाल किया था)
जोनाथन एलन

जैसा कि हम दिनों से इनपुट ले सकते हैं 1889-12-31, क्या हम भी दिन ले सकते हैं 2017-04-08?
TFeld

जवाबों:


6

जेली ,  444  , 94 , 93 बाइट्स

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

एक पूरा कार्यक्रम। इनपुट्स तार की एक सूची है और जनवरी 1970 के बाद से पूर्णांक दिनों के रूप में ली गई तारीख है (17264 अप्रैल को आठवें 2017 को बनाते हुए)

इसे ऑनलाइन आज़माएं!

कैसे?

Ñȧ$“&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

1
आप अपने TIO में किसी अन्य चुनौती से इनपुट निकालना भूल गए। ;) अच्छा जवाब की परवाह किए बिना। क्या आप एक स्पष्टीकरण जोड़ना चाहेंगे? और उस 444-बाइट की गिनती में रोफ़ करें। जब तक आपने टिप्पणी नहीं दी, मैं इसे एक सा नहीं मानता, जो आपने इसके साथ शुरू किया था। ; पी
केविन क्रूज़सेन

विपक्ष, धन्यवाद। मैं जल्द ही एक स्पष्टीकरण जोड़ूंगा।
जोनाथन एलन

1
444 संस्करण कोई टिप्पणी नहीं, संपीड़ित तारों के बजाय संख्या
जोनाथन एलन

... आह 444 संस्करण एक बग है - अपने दिन का उपयोग कर के बाद से 1969/12/31 नहीं के बाद से 1970-01-01 रूप golfed संस्करण करता है> _ <(अनुभवहीन ठीक अभी भी 444 है)
जोनाथन एलन

4

पायथन 2 , 208 204  203 201 197 बाइट्स

इनपुट को स्ट्रिंग्स की एक सूची के रूप में लेता है, और एक इंट का 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)

इसे ऑनलाइन आज़माएं!


3

एक्सेल VBA, 217 बाइट्स

VBE तत्काल विंडो फ़ंक्शन जो रेंज से इनपुट सरणी लेता है [A:A], और रेंज से दिनांक [B1]और कंसोल को आउटपुट करता है।

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

Ungolfed और टिप्पणी की

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,"&nbsp;","")          ''  If after 7 Aug 2017, and All 4s, let `s` be "&nbsp;"
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 बाइट्स YYYYMMDD

-1 42832(के लिए अंतर मान 07 Apr 2017) के लिए बाइट , धन्यवाद @ नील

कथन 1,से हटाने के लिए -2 बाइट्स InStr, धन्यवाद @ SeaDoggie01


मुझे लगता है कि For i=1To~-cइसके बजाय For i=1To c-1एक्सेल VBA में संभव नहीं है? अगर मुझे सही ढंग से याद है कि बिटवाइज़ के Notबजाय नहीं है ~, या दोनों संभव हैं? (ध्यान दें कि मैं एक्सेल VBA के आगे कुछ भी नहीं जानता, इसलिए मैं शायद यहाँ कुछ बेवकूफ कह रहा हूँ; पी;)
वीबीए के

@ केविनक्रूजसेन हाँ, बिटवाइस नहीं है Not , इसलिए नहीं~ :(
टेलर स्कॉट

1
मुझे लगता है कि आप दिनांक प्रारूप को वापस तिथि में बदलकर और तुलना 42832(2017-04-07 के पूर्णांक मान) के द्वारा अधिक बाइट्स बचा सकते हैं ।
नील

मुझे लगता है कि आप
इंस्ट्र

2

रेटिना 0.8.2 , 130 बाइट्स

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

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

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। एक्सेल तिथि टिकटों का उपयोग करता है (1899-12-31 के बाद से लेकिन 1900-02-49 सहित)। एक संस्करण के लिए 141 बाइट्स जो आईएसओ तिथियां लेता है:

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

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

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

$
;2017-04-08

कट-ऑफ डेट को इनपुट में जोड़ें।

O`;.{10}

तारीखें क्रमबद्ध करें। यदि दी गई तिथि कट-ऑफ तिथि के बाद या उसके बाद है तो पहली तिथि कट-ऑफ तिथि होगी।

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

उस मामले में, लपेट 4+में &nbsp;(दो चरणों का उपयोग कर के रूप में यह एक बाइट बचाता है)।

.{22}$

तारीखों को हटा दें क्योंकि उन्होंने अपना काम किया है।

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

यदि कोई जगह नहीं है 4+, तो मेम को संलग्न करें।

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

सभी अप्रचलित बाइट काउंट को स्ट्राइक करें।


आप बिना दिनांक-स्वरूप को ले कर 5 बाइट्स बचा सकते हैं -
केविन क्रूज़सेन

@ केविनक्रूजसेन मैं इसे एक्सेल तारीख (1899-12-31 के बाद के दिनों) के रूप में पूछकर और भी अधिक बाइट्स बचा सकता था। मैं इसके साथ कितनी दूर जा सकता हूं?
नील

हम्म .. तुम्हें पता है क्या, मेरे द्वारा भी ठीक है। कैसे अगर तारीख के लिए बयान April 8th, 2017किया जाता है तो मुझे वास्तव में परवाह नहीं है। यह इस चुनौती का प्रमुख हिस्सा नहीं है।
केविन क्रूज़सेन

यह 42832for अप्रैल २०१ 8th के लिए होगा , मुझे लगता है?
केविन क्रूज़सेन

@ केविनक्रूजसेन माय एक्सेल का कहना है कि यह 7 वां है।
नील

1

रूबी, 208 184 180 बाइट्स

TIO परीक्षण

2 बाइट बचाने के लिए @ केविनक्रूजसेन के लिए धन्यवाद!

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

यह एक लंबो फ़ंक्शन है जो प्रारूप में दिनांक के रूप में संख्याओं और पूर्णांक की सूची लेता है YYYYmmdd


क्या परीक्षण कोड के साथ टीआईओ-लिंक जोड़ना संभव होगा ? और स्वरूपण स्विच करना तो यह एक पूर्णांक इनपुट है वास्तव में कुछ बाइट्स को बचाएगा। :)
केविन क्रूज़सेन

@KevinCruijssen जोड़ा लिंक;)
पीटर लेनकेफी

धन्यवाद! मुझ से +1। आप रिक्त स्थान को हटाने के बाद 2 बाइट्स बचा सकते हैं ?। इसके अलावा, अपने TIO के लिए, आप अपने वास्तविक सबमिशन कोड और टेस्ट कोड को हेडर / फुटर के साथ विभाजित कर सकते हैं, जैसे । :)
केविन क्रूज़सेन

1

जावास्क्रिप्ट, 194 बाइट्स

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


1

हास्केल , 227 बाइट्स

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

इसे ऑनलाइन आज़माएं! fसूची lऔर दिनांक के साथ चलाएँ d। 42832 बदलती तारीख है।


क्या परीक्षण कोड के साथ टीआईओ-लिंक जोड़ना संभव होगा ?
केविन क्रूज़सेन

रूस में @KevinCruijssen पर प्रतिबंध लगा दिया गया है
Новиков

ओह, वह नहीं जानता था। ठीक है, मैं हास्केल को भी अच्छी तरह से नहीं जानता, नहीं तो मैं खुद ही इसका परीक्षण कर लेता। लेकिन कोड ही तार्किक लगता है, इसलिए मुझे फिर भी +1।
केविन क्रूज़सेन

@KevinCruijssen आप TIO पर कोड कॉपी कर सकते हैं, लिंक बना सकते हैं और इसे पोस्ट में जोड़ सकते हैं
гвгений Новиков

@KevinCruijssen TIO गलती से प्रतिबंधित है, लेकिन मैं इसके बारे में प्रॉक्सी / संपर्क ISP का उपयोग करने के लिए बहुत आलसी हूं
ijвгений Новиков

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.