शीर्ष दस तत्व आप इस सरणी में विश्वास नहीं करेंगे

Question

उर्फ: एक क्लिक से उत्पन्न उत्पन्न करें।

पूर्णांक की एक सरणी को देखते हुए, इसकी व्यवस्था और लंबाई के आधार पर कुछ क्रिंग-योग्य clickbait उत्पन्न करें:

• यदि यह 20 तत्व या उससे कम है, तो आप एक शीर्ष X सूची बना सकते हैं। पैरामीटर: सरणी की लंबाई।
• प्राइम नंबर सेलिब्रिटी होते हैं, इसलिए कभी भी उनमें से दो एक दूसरे के बगल में होते हैं, यह गॉसिप के रूप में होगा। पैरामीटर: वे जिस क्रम में दिखाई देते हैं, उसके क्रम में दो आसन्न primes।
• यदि कोई संख्या सरणी में दो या अधिक बार दिखाई देती है, तो यह चौंकाने वाला और अविश्वसनीय है और सभी को इसके बारे में सुनना होगा। यदि कई संख्याएं दो बार दिखाई देती हैं, तो प्रत्येक के लिए एक समाचार बनाएं। इसे केवल एक बार अनूठे नंबर पर प्रिंट करें। पैरामीटर: कुल उपस्थिति द्वारा मापा संख्या की घटना।
• यदि आप क्रमिक रूप से बढ़ते क्रम में 3+ तत्वों को क्रमबद्ध रूप से बढ़ाते हुए देखते हैं , तो बताएं कि वे किस प्रकार क्रमबद्ध हैं और आगे क्या होता है, इस बारे में चिढ़ें। इसे केवल एक बार सीधा करें। पैरामीटर: सीधे की लंबाई।

ये संबंधित क्लिकबाइट हैं जिनका आपको उपयोग करना चाहिए:

The Top {{N}} Array Elements
{{N1}} And {{N2}} Were Spotted Together, You Won't Believe What They Did
These {{N}} Elements Will Blow Your Mind
{{N}} Elements Sort Themselves, Find Out What Comes Next

याद रखें, आप एक सस्ती मीडिया कंपनी का प्रतिनिधित्व करते हैं, इसलिए आपको इसे दूध देने और हर संभव शीर्षक को प्रिंट करने की आवश्यकता होगी। यदि 2 समान शीर्षक हैं, तो उन दोनों को प्रिंट करें।

उदाहरण के लिए, यदि आपको यह सरणी दी जाती है ...

1,2,3,4,2,1,1,5,6

आपको इन सभी का उत्पादन मनमाने क्रम में करना चाहिए:

The Top 9 Array Elements
2 And 3 Were Spotted Together, You Won't Believe What They Did
These 2 Elements Will Blow Your Mind
These 3 Elements Will Blow Your Mind
4 Elements Sort Themselves, Find Out What Comes Next

इस शीर्षक की कमी पर ध्यान दें :

3 Elements Sort Themselves, Find Out What Comes Next

कोड गोल्फ के रूप में, बाइट्स में सबसे छोटा जवाब जीत जाता है।

Comments

@ अर्नुलड वहां कोई अचानक कमी नहीं है, इसलिए पहले 3 शीर्षक प्रिंट करें।

— निसा

आमतौर पर मैं डाउनवोट नहीं करता हूं, लेकिन -1 केवल एक क्लिक-टाइट शीर्षक का उपयोग करने के लिए एक चुनौती बनाने के लिए और "ए, बी और सी, ओह और डी भी" प्रकार की चुनौती के लिए पूरी तरह से अनावश्यक आउटपुट स्वरूप। चुनौतियों को लिखते समय आपको चीजों को पढ़ने से बचना चाहिए ।

— ।

@ बीएमओ शायद आपको सैंडबॉक्स को अधिक बार पढ़ना चाहिए। यह काफी अवधि के लिए था, जब आपने अपनी राय दी होगी। इसके अलावा, इस साइट पर कई चुनौतियां क्लिकबैट का उपयोग करती हैं, ऐसा नहीं है कि ऐसा करने की एकमात्र चुनौती है

— कॉनर ओ'ब्रायन

पर्याप्त किनारे मामले हैं जो मैं आपको एक संदर्भ कार्यान्वयन लिखने का सुझाव देता हूं जो सटीक तर्क उत्तरों का प्रदर्शन करता है।

— लिन

@ ConorO'Brien: शायद मुझे चाहिए, अगर मैंने वहाँ देखा तो मैंने वहाँ अपनी राय रखी। लेकिन मुझे लगा कि मैं अपने पतन का एक कारण बताऊंगा क्योंकि चुपचाप किसी को भी किसी काम का नहीं है। क्लिक-बायट के बारे में, मुझे लगता है कि एक अच्छी चुनौती के लिए एक आकर्षक शीर्षक और एक चुनौती के बीच एक बड़ा अंतर है जो केवल क्लिक-बाय शीर्षक का उपयोग करने के लिए किया गया है।

— ।

Answer 1

जेली , 142 बाइट्स

I>-ṣ0ṖS€ỊÐḟ‘ɓĠL€ḟ1,ɓ¹ƝÆPẠ$ÐfW;ɓLẋ<¥21W;ż@€"“æƥu®ụ³Km&|°ẓz“ṿ$¥{d3ɓFȤSJẎVḍnṃ*¹0Ḟ¬ȤɲƝċƲạB'ɼɓ.€⁺Ƒ“¢ßUṡʠx\~⁻ḅėʠAƓḳ¶e<“½ė!Ƙ¥Ḍ3]⁷ṀƭȮþċ⁽?ṫĠƁÆȦØ⁾Ż»ṣ€⁷¤

एक मोनाडिक लिंक पूर्णांक की एक सूची को स्वीकार करता है, जिसमें क्लिकबिट्स (जिनमें से प्रत्येक वर्ण और पूर्णांक की एक सूची है) की सूची लौटाता है। एक पूर्ण कार्यक्रम के लिए प्रिंटिंग लाइन-फीड अलग किए गए क्लिकबैट ẎYको अंत में जोड़ें ।

इसे ऑनलाइन आज़माएं! (पाद लेख क्लिकबैट की एक सूची बनाता है और फिर उन्हें नई-नई पंक्तियों के साथ अलग करता है।)
... याप्रश्न में दिए गए उदाहरण कोदेखें।

कैसे?

इस लिंक के 99 दाएं-सबसे बाइट्स एक निलाद (शून्य तर्कों वाला एक फ़ंक्शन, अर्थात एक स्थिर) बनाते हैं:

“...“...“...“...»ṣ€⁷¤
                    ¤ - nilad followed by link(s) as a nilad:
“...“...“...“...»     - list of compressed strings (the four clickbait-texts with the
                      -   integers replaced with line-feed characters)
                   ⁷  - literal line-feed character
                 ṣ€   - split-at for €ach (read to interweave with the integers)

आइए इन पाठ-भागों को लेबल करें X, जैसे अब लिंक है:

I>-ṣ0ṖS€ỊÐḟ‘ɓĠL€ḟ1,ɓ¹ƝÆPẠ$ÐfW;ɓLẋ<¥21W;ż@€"X - Link: list of integers Z
                                             - # get the monotonically increasing runs:
I                                            - incremental differences of Z
 >-                                          - greater than -1 (vectorises)
   ṣ0                                        - split at zeros
     Ṗ                                       - pop (discard final run)
      S€                                     - sum each (length - 1 for all runs)
         Ðḟ                                  - filter discard if:
        Ị                                    -   insignificant (discard any 0s or 1s)
           ‘                                 - increment (yielding all run-lengths >= 3)
            ɓ                                - new dyadic chain with that on the right
                                             - # get the multiplicities:
             Ġ                               - group indices of Z by value
              L€                             - length of €ach
                ḟ1                           - filter discard 1s
                  ,                          - pair with right (the run-lengths)
                   ɓ                         - new dyadic chain with that on the right
                                             - # get the prime-pairs
                     Ɲ                       - for each pair in Z
                    ¹                        -   identity (do nothing)
                          Ðf                 - filter keep if:
                         $                   -   last two links as a monad:
                      ÆP                     -     is prime? (vectorises)
                        Ạ                    -     all?
                            W                - wrap in a list
                             ;               - concatenate with right ([multiplicities,runs])
                              ɓ              - new dyadic chain with that on the right
                                             - # get top count as a list
                               L             - length
                                   21        - literal 21
                                  ¥          - last two links as a dyad
                                 <           -   less than? (1 if 20 or less, else 0)
                                ẋ            -   repeat ([length] if 20 or less, else [])
                                     W       - wrap in a list (i.e. [[length]] or [[]])
                                      ;      - concatenate with right ([[prime pairs],[multiplicities],[run-lengths]])
                                             - ...now we have [[length],[prime pairs],[multiplicities],[run-lengths]]
                                          "X - zip with X (the text-parts)
                                         €   -   for each (item in the current list):
                                       ż@    -     interleave with swapped arguments

Comments

प्रभावशाली! : P ने वाक्यों का उपयोग भी नहीं किया ... वाह

— NL628

ऐसा इसलिए है क्योंकि जेली में संकुचित तार होने की क्षमता है। “...“...“...“...»कोड के हिस्से में वाक्य संख्या के स्थान पर लाइन फीड के साथ होते हैं - इस तरह

— जोनाथन एलन

यह एक पूरी बात है, जेली ...

— खुल्द्रेसथ ना'बरिया

सबसे लंबा जेली गोल्फ मैंने देखा है। यहाँ मेरा जवाब करीब आता है, लेकिन अभी भी 16 बाइट्स से छोटा है

— dylnan

@dylnan मैं है एक कुछ जेली golfs जो अब कर रहे हैं, एक जोड़े जिनमें से मुझे लगता है कि कर रहे हैं अधिक प्रभावशाली

— जोनाथन एलन

Answer 2

जावा 10, 467 457 456 453 बाइट्स

a->{int l=a.length,i=0,p=0,P=0,m[]=new int[999],t;String e=" Elements ",r=l<21?"The Top "+l+" Array"+e+"\n":"";for(;i<l;r+=i>0&&p(p)>1&p(t=a[i-1])>1?p+" And "+t+" Were Spotted Together, You Won't Believe What They Did\n":"",m[a[i++]]++)if(p<(p=a[i]))P++;else{r+=P>2?P+e+"Sort Themselves, Find Out What Comes Next\n":"";P=1;}for(;l-->0;r+=m[l]>1?"These "+m[l]+e+"Will Blow Your Mind\n":"");return r;}int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

मान लें कि इनपुट-सरणी में मान शामिल होंगे 0 < N < 1000( [1,999])।

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

a->{                     // Method with integer-array parameter and String return-type
  int l=a.length,        //  Length of the input-array
      i=0,               //  Index-integer
      p=0,               //  Previous item, starting at 0
      P=0,               //  Sequence-counter, starting at 0
      m[]=new int[999],  //  Element-counter array, starting filled with 0s
      t;                 //  Temp-integer to reduce the byte-count
  String e=" Elements ", //  Temp-String " Elements " to reduce byte-count
         r=l<21?         //  If the size of the input-array is 20 or less:
            "The Top "+l+" Array"+e+"\n"
                         //    Start the result-String with 'length' gossip-line
           :             //   Else:
            "";          //    Start the result-String empty
  for(;i<l               //  Loop over the input-array
      ;                  //    After every iteration:
       r+=i>0&&          //     If this is not the first item,
           p(p)>1&p(t=a[i-1])>1?
                         //     and the current and previous items are both primes:
             p+" And "+t+" Were Spotted Together, You Won't Believe What They Did\n":"",
                         //      Append the 'two primes' gossip-line
       m[a[i++]]++)      //     Increase the counter of the current value by 1
    if(p<(p=a[i])        //   If the previous item is smaller than the current:
      P++;               //    Increase the sequence-counter by 1
    else{                //   Else:
      r+=P>2             //    If the sequence-counter is 3 or larger:
          P+e+"Sort Themselves, Find Out What Comes Next\n":"";
                         //     Append the 'sequence' gossip-line
      P=1;}              //    Reset the sequence-counter to 1
  for(;l-->0;            //  Loop over the Element-counter array
      r+=m[l]>1?         //   If this element occurred at least two times:
          "These "+m[l]+e+"Will Blow Your Mind\n":"");
                         //    Append the 'occurrence' gossip-line
  return r;}             //  Return the result

// Separated method to check if the given number is a prime
// If `n` is a prime, it remains the same; if not: either 1 or 0 is returned
int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

Answer 3

• अभी भी गोल्फ लेकिन मदद की बहुत सराहना की जाएगी

जावास्क्रिप्ट (Node.js) , 397 बाइट्स

a=>a.map(x=>(l<=x?s++:(s>2&&r.push(s+" Elements Sort Themselves, Find Out What Comes Next"),s=1),P(x)&&P(l)&&r.push(l+` And ${x} Were Spotted Together, You Won't Believe What They Did`),c[l=x]=-~c[x]),c=[s=l=r=[]])&&c.map((x,i)=>x>1&&c.indexOf(x)==i&&r.push(`These ${x} Elements Will Blow Your Mind`))&&[...r,...a[20]?[]:[`The Top ${a.length} Array Elements`]]
P=(n,i=1)=>n>1&&++i*i>n||n%i&&P(n,i)

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

Comments

आप की तरह एक एकल वर्ण की जगह को बचा सकता है '!'के साथ ' Elements '(या समान)?

— जोनाथन एलन

आप सही तरीके से एक दाहिने हाथ को बढ़ाने में विफल रहे हैं, जिसमें कोई भी कमी नहीं है (जो लिंक आपको आउटपुट नहीं देना चाहिए, "6 एलिमेंट्स सॉर्ट थेम्सवेल्स, फाइंड आउट कम्स नेक्स्ट", जैसा कि कोई "नेक्स्ट" नहीं है)

— जोनाथन मनन

अभावThe Top * Array Elements

— l4m2

अच्छी तरह से यह भी मेरे मूल उत्तर में कम y कोड मैं इस तरह से किया था। निर्धारित होगा। @ l4m2 धन्यवाद

— DanielIndie

मुझे 100% यकीन नहीं है, क्योंकि चुनौती विवरण में वाक्य दो तरीकों से व्याख्या कर सकता है, लेकिन दो बार [5,10,5,10]आउटपुट नहीं होना चाहिए These 2 Elements Will Blow Your Mind? मुझे लगता है कि चुनौती वाला भाग " केवल एक बार अद्वितीय संख्या के अनुसार इसे प्रिंट करें। " का अर्थ संख्या है 5और 10, संख्या नहीं N=2। लेकिन शायद ओपी को सत्यापित करने के लिए कहें। यदि दूसरा, आपका कार्यान्वयन सही है और अन्य तीन उत्तर गलत हैं। यदि पहला केवल आपका कार्यान्वयन गलत है।

— केविन क्रूज़सेन

Answer 4

जावास्क्रिप्ट (Node.js) , 351 350 349 347 बाइट्स

a=>a.map((x,i)=>c[s=x>=l?-~s:++s>2&&(t+=s+` Elements Sort Themselves, Find Out What Comes Next
`),P(x)&P(l)&&(t+=l+` And ${x} Were Spotted Together, You Won't Believe What They Did
`),l=x]=-~c[x],t=a[20]?'':`The Top ${a.length} Array Elements
`,c=[s=l=P=(n,i=n)=>n%--i?P(n,i):1/i])+c.map(x=>x>1&&(t+=`These ${x} Elements Will Blow Your Mind
`))&&t

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