Il conteggio modifica la contabilità per il periodo di tolleranza


23

Quando modifichi un post su SE, tutte le altre modifiche entro un periodo di tolleranza di 5 minuti vengono unite in esso. Dato un elenco di volte in cui modifichi un post, conta le modifiche non in un periodo di tolleranza.

Di 'che modifichi in pochi minuti [0,3,4,7,9,10,11,12]. Ciò si traduce in 3 modifiche a volte [0,7,12], mentre il resto accade nei loro periodi di grazia.

0:  [3,4]
7:  [9,10,11]
12: []
  • La prima modifica è al minuto 0. Le modifiche ai minuti 3 e 4 sono entro il suo periodo di tolleranza di 5 minuti, quindi non contano.
  • La seconda modifica è al minuto 7. Le modifiche ai minuti 9, 10, 11 sono entro il suo periodo di tolleranza.
  • La terza modifica al minuto 12 è appena oltre il limite del periodo di tolleranza di 5 minuti a partire dal minuto 7.

Quindi, l'output è 3.

L'elenco dei tempi in minuti sarà un elenco di numeri interi in aumento. Il primo numero sarà sempre 0 per la pubblicazione iniziale, che contiamo come modifica.

Casi test:

[0]
[0,3,5,7]
[0,3,4,7,9,10,11,12]
[0,30,120]
[0,4,8,12,16]
[0,4,8,12,16,20]
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
[0,5,10,15,20]
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
[0,1,4,5,9,11,12,14,16,18,23,24,26,28,29,30]

Uscite:

1
2
3
3
3
3
4
5
5
6

Per facilitare la copia, ecco gli input, output e coppie input / output:

[[0], [0, 3, 5, 7], [0, 3, 4, 7, 9, 10, 11, 12], [0, 30, 120], [0, 4, 8, 12, 16], [0, 4, 8, 12, 16, 20], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], [0, 5, 10, 15, 20], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], [0, 1, 4, 5, 9, 11, 12, 14, 16, 18, 23, 24, 26, 28, 29, 30]]
[1, 2, 3, 3, 3, 3, 4, 5, 5, 6]
[([0], 1), ([0, 3, 5, 7], 2), ([0, 3, 4, 7, 9, 10, 11, 12], 3), ([0, 30, 120], 3), ([0, 4, 8, 12, 16], 3), ([0, 4, 8, 12, 16, 20], 3), ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], 4), ([0, 5, 10, 15, 20], 5), ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], 5), ([0, 1, 4, 5, 9, 11, 12, 14, 16, 18, 23, 24, 26, 28, 29, 30], 6)]

Classifica:


Anche se è davvero fastidioso se la tua modifica non fa il periodo di grazia, perché allora devi usare il tuo nuovo periodo di grazia per farlo sembrare come se volessi modificarlo in questo modo ...
Neil,

Risposte:


20

JavaScript, 36 byte

f=$=>$>f&&1+f($.filter(b=>b-$[0]>4))

Provalo online!

Come funziona

In ogni chiamata ricorsiva eliminiamo tutti gli elementi dall'array che distano più di 4 minuti dal primo elemento.
C'è un piccolo trucco con il nome della variabile $. Il controllo $>fconverte innanzitutto l'array in una stringa, quindi lo confronta con la rappresentazione in formato stringa della funzione fe quindi li confronta lessicograficamente. Il primo carattere dell'array con stringhe è una cifra e quindi solo un nome di variabile con un carattere il cui indice ascii è più piccolo degli indici di tutte le cifre $. La sostituzione $con qualsiasi altro nome di variabile restituirà sempre false.


3
Adoro questo sito per via di risposte come queste.
Cristian Lupascu,

1
Trucco molto bello!
Arnauld,

1
Oh, ora, è un grande trucco!
Shaggy,

8

Mathematica, 46 40 37 33 byte

(i=1;j=0;#-j<5||(i++;j=#)&/@#;i)&

Spiegazione

i=1;j=0

Impostare isu 1e jsu 0.

... /@#

Mappa su tutti gli elementi dell'input ...

#-j<5||(i++;j=#)&

Se (element) - j < 5è falso, incrementare ie impostare jsull'elemento (valutazione del corto circuito).

;i

Uscita i.


5

Buccia , 8 byte

Γ(→₀f>+4

Provalo online!

Spiegazione

Γ(→₀f>+4  Implicit input, a list of numbers.
Γ(        Deconstruct into head n and tail x (if empty, return 0).
    f>+4  Keep those elements of x that are greater than n+4.
   ₀      Call main function recursively on the result.
  →       Increment.

5

Python 2 , 58 byte

a=input()
x=[0]
for k in a:x+=[k]*(k-x[-1]>4)
print len(x)

Provalo online!

  • Salvato 2 byte grazie a @Mr. Xcoder.

49 byte

f=lambda a:a>[]and-~f([x for x in a if x-a[0]>4])

Utilizzando il metodo ricorsivo mostrato nella soluzione di @ ThePirateBay .

  • Salvataggio di un byte grazie a @Mr. Xcoder.
  • Salvato 2 byte grazie a @Halvard Hummel.

Provalo online!


and 1+f(...)può essere sostituito da and-~f(...)49 byte
Mr. Xcoder

@ Mr.Xcoder Oh, non posso dimenticare tutti quei trucchi bit per bit.
miglia

x=a[:1]equivale a x=[0], poiché la domanda afferma esplicitamente che il primo elemento è sempre 0( 62 byte )
Mr. Xcoder


3

J , 20 byte

[:#(,}.~5>(-{.))/@|.

Provalo online!

Spiegazione

[:#(,}.~5>(-{.))/@|.  Input: array A
                  |.  Reverse
                /@    Reduce from right-to-left
            {.          Head of RHS
           -            Subtract with LHS
        5>              Less than 5
     }.~                Drop that many from
    ,                   Join
[:#                   Length

3

MATLAB, 34 byte

@(x)nnz(uniquetol(x+1,4/max(x+1)))

Funzione anonima che immette un array e genera un numero.

Questo utilizza la uniquetolfunzione, in particolare la sua forma y = uniquetol(x, t), che fornisce yelementi unici xcon tolleranza t. Nel fare ciò, la funzione sembra seguire un approccio "pigro": ordina x, seleziona la sua prima voce e continua a saltare le voci fino a quando rimangono entro la tolleranza dell'ultima voce selezionata. Questo è esattamente ciò che è necessario qui.

La uniquetolfunzione ridimensiona automaticamente la tolleranza specificata in base al valore assoluto massimo in a. Questo è il motivo per cui abbiamo bisogno della divisione qui. x+1viene utilizzato invece di xevitare la divisione per 0.

Verifica dei casi di test:

>> f = @(x)nnz(uniquetol(x+1,4/max(x+1)));
>> inputs = {...
       [0] ...
       [0,3,5,7] ...
       [0,3,4,7,9,10,11,12] ...
       [0,30,120] ...
       [0,4,8,12,16] ...
       [0,4,8,12,16,20] ...
       [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19] ...
       [0,5,10,15,20] ...
       [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] ...
       [0,1,4,5,9,11,12,14,16,18,23,24,26,28,29,30] ...
   };
>> outputs = cellfun(f, inputs)
outputs =
     1     2     3     3     3     3     4     5     5     6

1
TIL about uniquetol... Introdotto in R2015a . Ho R2014b :( Bella risposta :)
Stewie Griffin,

@Stewie sapevo che esisteva, ma penso che sia la prima volta che lo uso
Luis Mendo,

2

05AB1E , 20 19 18 15 14 11 byte

v®y‹iy4+©\¼

Spiegazione:

v          # loop on input
 ®          # push register_c, start at -1
  y‹i         # if current item greater than last item
   y4+         # push new max on stack
    ©\          # push new max on register_c, and pop it from stack
     ¼           # increment counter_variable
                  # implicit print of counter_variable

Provalo online!

modificare

  • -3 byte grazie a Riley e all'uso di counter_variable
  • dopo tutto non c'è bisogno di counter_variable
  • -3 byte di nuovo grazie a Riley e all'utilizzo di register_c

È possibile utilizzare la variabile contatore per salvare 3 byte:¼4¹vDy‹i¼y4+}}¾
Riley

oooooh, c'è una contro variabile, è utile! Grazie!!
Cyril Gandon,


2

Buccia, 6 byte

Lüo<+5

Provalo online!

  o<+5        a function that takes two arguments and checks if
              the second is less than the the first plus 5
 ü            remove equal elements from the input list using the above
              function as the equality test
L             return the length of the remaining list

Whoa, non avevo realizzato üopere del genere! È molto utile.
Zgarb,

@Zgarb: ho provato ġma non funziona, mentre Haskell groupByopere: length.groupBy((>).(+5)). Poi ho trovato üche porta anche ad una più breve Haskell equivalente: nubBy.
nimi,



1

MATL , 13 12 byte

`ttX<4+>)t}@

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

`        % Do..while
  t      %   Duplicate. Takes input (implicitly) the first time
  tX<    %   Duplicate and get minimum, i.e the first entry
  4+     %   Add 4
  >      %   Greater than? Element-wise
  )      %   Keep entries that fulfill that
  t      %   Duplicate. This is used as loop condition
}        % Finally (execute at the end of the loop)
  @      %   Push number of iterations. This is the output
         % End (implicit). A new iteration is run if top of the stack is truthy

1

Pyth , 14 byte

L&lbhyfg-Thb5b

Questa è una funzione ricorsiva. Chiamalo con y[0 1 2 3 4 5 6 7 8), dov'è la [...)tua lista.

In alternativa, provalo qui! oppure Verifica tutti i casi di test.


Spiegazione

Questo è approssimativamente equivalente alla soluzione Python. Una traduzione darebbe i seguenti risultati:

def y(b):
 return (len(b) and y(filter(lambda T:T>=b[0]+5,b)) + 1)

Analisi del codice

L&lbhyfg-Thb5b   - Function called y that accepts a list parameter b.

L                - Define the function.
  lb             - The length of b...
 &               - ... Logical AND ...
    h            - Increment by 1.
     y           - The result given by calling the function recursively on the following:
      f      b     - b filtered...
        -Thb       - ... For the elements whose difference compared to the first element...
       g    5      - ... Is greater than or equal to 5.

Sto cercando di trovare una soluzione alternativa con .U. Suggerimenti sono benvenuti
Mr. Xcoder,


1

C # .NET, 63 byte

a=>{int e=0;foreach(int l in a)if(l-a[e]>4)a[++e]=l;return-~e;}

Spiegazione:

Provalo qui.

a=>{                   // Method with integer-array parameter and integer return-type
  int e=0;             //  Amount of edits (starting at 0)
  foreach(int l in a)  //  Loop over the input-array
    if(l-a[e]>4)       //   If the current value minus the current edit is larger than 4:
      a[++e]=l;        //    Raise the edit-count by 1 first,
                       //    and set the current value to this next current edit
                       //  End of loop (implicit / single-line body)
  return-~e;           //  Return the amount of edits + 1
}                      // End of method





0

Retina , 32 26 byte

.+
$*11
(1+)(¶1{1,4}\1)*\b

Provalo online! Spiegazione:

.+
$*11

Converti in unario, ma aggiungi 1, perché 0 è un concetto complicato in Retina.

(1+)(¶1{1,4}\1)*\b

Conta il numero di modifiche, ma includi tutte le modifiche di grazia in ogni corrispondenza.


0

Kotlin, 52 byte

Pubblicando come una funzione, se questo non è accettabile lo cambierò in un metodo

Presentazione

{var x=it[0]
var o=1
it.map{if(it>x+4){o++
x=it}}
o}

Abbellire

{
    // Last counted edit
    var x=it[0]
    // Current edit total
    var o = 1
    // For each edit
    it.map{
        // If it was 5 or more minutes ago
        if (it>x+4) {
            // Increase edit count
            o++
            // Make it the last counted edit
            x=it
        }
    }
    // Return the edit count
    o
}

Test

var r:(IntArray)->Int=
{var x=it[0]
var o=1
it.map{if(it>x+4){o++
x=it}}
o}

fun main(args: Array<String>) {
    println(r(intArrayOf(0)))
    println(r(intArrayOf(0,3,5,7)))
    println(r(intArrayOf(0,3,4,7,9,10,11,12)))
    println(r(intArrayOf(0,30,120)))
    println(r(intArrayOf(0,4,8,12,16)))
    println(r(intArrayOf(0,4,8,12,16,20)))
    println(r(intArrayOf(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19)))
    println(r(intArrayOf(0,5,10,15,20)))
    println(r(intArrayOf(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)))
    println(r(intArrayOf(0,1,4,5,9,11,12,14,16,18,23,24,26,28,29,30)))
}

TryItOnline


0

PowerShell , 74 byte

for($x,$y=$args[0];$y;$x,$y=$y){if($l-le$x-5){$i++;$l=$x}}$i+1+($l-le$x-5)

Soluzione iterativa. Lunga a causa della recinzione sul forcircuito che richiede un controllo aggiuntivo sull'estremità. Suggerimenti di golf benvenuti.

Prendiamo l'input $args[0]come un array letterale, stacciamo il primo elemento in $xe il rimanente in $y. Quindi, fintanto che ci sono ancora elementi $y, eseguiamo il loop.

Ogni iterazione, controlliamo se il timestamp corrente $xè 5o più lontano dal $ltim timestamp. In tal caso, incrementiamo il nostro contatore $i++e impostiamo il nostro timestamp in modo che sia aggiornato. Quindi, sull'iterazione del loop, stacciamo l'elemento successivo $xe lasciamo il rimanente dentro $y.

Una volta che siamo fuori dal ciclo, emettiamo $i, più 1per la modifica iniziale, oltre a se il timestamp finale è più di cinque di distanza dall'ultima modifica (con il valore booleano implicitamente cast su intero). Tale risultato è rimasto sulla pipeline e l'output è implicito.

Provalo online!


0

R , 52 byte

function(l){while(sum(l|1)){l=l[l-l[1]>=5]
F=F+1}
F}

Provalo online!

Semplice funzione anonima che rimuove in modo iterativo elementi dall'elenco a meno di 5 dal primo elemento fino a quando l'elenco è vuoto, quindi restituisce il contatore.


0

Clojure, 53 byte

#(count(set(reductions(fn[r v](if(<(- v r)5)r v))%)))

Ciò tiene traccia dei "tempi di inizio modifica", quindi restituisce il loro conteggio distinto.


0

Japt , 14 byte

Ê©1+ßUf_aUg)>4

Provalo


Spiegazione

Input implicito di array U

Ê

Ottieni la lunghezza di U.

©

Logical AND ( &&) - esegue solo quanto segue se Êè true (diverso da zero).

ß

Chiamata ricorsiva.

Uf_

Filtra ( f) Upassando ciascun elemento attraverso una funzione.

aUg

Ottieni la differenza ( a) tra l'elemento corrente e il primo elemento ( g) di U.

>4

Maggiore di 4?

1+

Aggiungi 1.

Output implicito dell'intero risultante.


0

Gelatina , 11 byte

+4Ḣ<x@µÐĿL’

Provalo online!

Spiegazione

+4Ḣ<x@µÐĿL’  Input: array A
      µÐĿ    Repeat until the results converge
+4             Add 4
  Ḣ            Head
   <           Greater than
    x@         Copy only the true values
         L   Length
          ’  Decrement

12 byte

;I4<1;x@;ð/L

Provalo online!

Spiegazione

;I4<1;x@;ð/L  Input: array A
         ð/   Reduce A from left-to-right using
;               Concatenate
 I              Increment
  4<            Greater than 4
    1;          Prepend 1
      x@        Times each of
        ;       Concatenate
           L  Length
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.