I dieci principali elementi che non crederai sono in questa matrice


10

AKA: Genera Clickbait da un array.

Data una matrice di numeri interi, genera un clickbait degno di una cringe in base alla sua disposizione e lunghezza:

  • Se è composto da 20 elementi o meno, puoi creare un elenco X in alto. Parametri: lunghezza dell'array.
  • I numeri primi sono celebrità, quindi ogni volta che due di loro sono uno accanto all'altro passerà come gossip. Parametri: i due numeri primi adiacenti nell'ordine in cui compaiono nella matrice.
  • Se un numero appare due o più volte nell'array, allora è scioccante e incredibile e tutti devono sentirne parlare. Se più numeri compaiono due volte, crea una notizia per ognuno. Stampalo solo una volta per numero univoco. Parametri: occorrenza del numero misurato dall'aspetto totale.
  • Se vedi più di 3 elementi in ordine monotonicamente crescente , seguito da una diminuzione improvvisa, allora racconta come vengono ordinati e prendono in giro ciò che accade dopo. Fallo solo una volta per scala. Parametri: lunghezza della scala.

Questi sono i rispettivi clickbait che dovresti usare:

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

Ricorda, rappresenti una media company economica, quindi dovrai mungerlo e stampare ogni possibile titolo. Se ci sono 2 titoli identici, stampali entrambi.

Ad esempio, se ti viene assegnato questo array ...

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

Dovresti produrre tutti questi, in ordine arbitrario:

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

Nota la mancanza di questo titolo:

3 Elements Sort Themselves, Find Out What Comes Next

Come codice golf, vince la risposta più breve in byte.


1
@Arnauld non c'è alcuna diminuzione improvvisa lì, quindi basta stampare i primi 3 titoli.
Nissa,

1
Di solito non voto in basso, ma -1 per creare una sfida solo per usare un titolo esca e un formato di output completamente inutile per una sfida di tipo "do A, B e C, oh e anche D". Dovresti davvero leggere le cose da evitare quando scrivi le sfide .
ბიმო

8
@BMO Forse dovresti leggere la sandbox più spesso. Questo è stato lì per una durata considerevole, quando potresti aver espresso le tue opinioni. Inoltre, molte sfide su questo sito usano clickbait, non è che questa sia l'unica sfida per farlo lol
Conor O'Brien,

6
Ci sono abbastanza casi limite che ti suggerisco di scrivere un'implementazione di riferimento che dimostri che dovrebbero seguire le risposte logiche esatte.
Lynn,

5
@ ConorO'Brien: Probabilmente avrei dovuto, se l'avessi visto lì avrei espresso la mia opinione lì. Ma ho pensato di dare una ragione al mio downvote perché il downvoting in silenzio non è di alcuna utilità per nessuno. Per quanto riguarda l'esca a scatto, penso che ci sia una differenza enorme tra un titolo accattivante per una buona sfida e una sfida che è stata fatta solo per usare un titolo a scatto.
ბიმო

Risposte:


5

Gelatina , 142 byte

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

Un collegamento monadico che accetta un elenco di numeri interi, che restituisce un elenco di elenchi di clickbait (ognuno dei quali è un elenco di caratteri e numeri interi). Per un programma completo di stampa di clickbaits separati da un feed di riga, basta aggiungere ẎYalla fine.

Provalo online! (Il piè di pagina crea un unico elenco di clickbait e poi le separa con nuove righe.)
... oppure vedi l'esempio fornito nella domanda.

Come?

I 99 byte più a destra di questo collegamento formano un nilad (una funzione con zero argomenti, cioè una costante):

“...“...“...“...»ṣ€⁷¤
                    ¤ - 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)

Etichettiamo queste parti di testo come X, ora il link è:

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

Degno di nota! : P Non ho nemmeno usato le frasi ... wow
NL628

2
Questo perché Jelly ha la capacità di avere stringhe compresse. Le frasi sono lì nella “...“...“...“...»parte del codice, con feed di riga al posto dei numeri - in questo modo
Jonathan Allan

1
È tutta una lotta Jelly ...
Khuldraeseth na'Barya,

La jelly golf più lunga che abbia mai visto. La mia risposta qui si avvicina ma è ancora più breve di 16 byte
dylnan il

@dylnan Io ho un paio di campi da golf gelatina che sono più, un paio dei quali secondo me sono più impressionante
Jonathan Allan

2

Java 10, 467 457 456 453 byte

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

Presuppone che l'array di input conterrà valori 0 < N < 1000( [1,999]).

Provalo online.

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

1
  • giocherò ancora a golf ma sarà molto apprezzato l'aiuto

JavaScript (Node.js) , 397 byte

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)

Provalo online!


Potresti salvare sostituendo un singolo personaggio come '!'con ' Elements '(o simile)?
Jonathan Allan,

Non sei riuscito a gestire correttamente una corsa monotonicamente crescente della mano destra senza alcuna riduzione finale (il link che dai non dovrebbe generare "6 Elements Sort Theself stessi, Scopri cosa viene dopo", in quanto non esiste "Next")
Jonathan Allan

MancanzaThe Top * Array Elements
l4m2

bene questo codice y ancora più breve nella mia risposta di origine l'ho fatto in questo modo. sarà risolto. @ l4m2 grazie
DanielIndie,

Non sono sicuro al 100%, perché la frase nella descrizione della sfida può essere interpretata in due modi, ma non dovrebbe [5,10,5,10]produrre il These 2 Elements Will Blow Your Minddoppio? Penso che la parte della sfida " Stampa questo solo una volta per numero univoco " indica i numeri 5e 10non il numero N=2. Ma forse chiedere a OP di verificare. Se il secondo, l'implementazione è corretta e le altre tre risposte non sono corrette. Se la prima solo l'implementazione non è corretta.
Kevin Cruijssen,

1

JavaScript (Node.js) , 351 350 349 347 byte

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

Provalo online!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.