Contar ediciones contabilizando el período de gracia

23

Cuando edita una publicación en SE, todas las ediciones posteriores dentro de un período de gracia de 5 minutos se combinan en ella. Dada una lista de veces que edita una publicación, cuente las ediciones que no están en un período de gracia.

Digamos que editas en minutos [0,3,4,7,9,10,11,12]. Esto resulta en 3 ediciones a veces [0,7,12], con el resto sucediendo en sus períodos de gracia.

0:  [3,4]
7:  [9,10,11]
12: []
  • La primera edición es en el minuto 0. Las ediciones en los minutos 3 y 4 están dentro de su período de gracia de 5 minutos, por lo que no cuentan.
  • La segunda edición es en el minuto 7. Las ediciones en los minutos 9, 10, 11 están dentro de su período de gracia.
  • La tercera edición en el minuto 12 está más allá del límite del período de gracia de 5 minutos que comienza en el minuto 7.

Entonces, la salida es 3.

La lista de veces en minutos será una lista de números enteros crecientes. El primer número siempre será 0 para la publicación inicial, que contamos como una edición.

Casos de prueba:

[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]

Salidas:

1
2
3
3
3
3
4
5
5
6

Para facilitar la copia, aquí están las entradas, salidas y pares de entrada / salida:

[[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)]

Tabla de clasificación:

Mostrar fragmento de código

code-golf  sequence  counting  subsequence  code-golf  arithmetic  code-golf  string  interpreter  code-golf  number  sequence  code-golf  quine  code-golf  sequence  code-golf  ascii-art  kolmogorov-complexity  alphabet  code-golf  kolmogorov-complexity  code-golf  string  code-golf  string  kolmogorov-complexity 
— xnor
fuente
Aunque es realmente molesto si su edición no alcanza el período de gracia, porque entonces tiene que usar su nuevo período de gracia para que parezca que tiene la intención de editarlo de esa manera todo el tiempo ...
— Neil

Respuestas:

20

JavaScript, 36 bytes

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

Pruébalo en línea!

Cómo funciona

En cada llamada recursiva, eliminamos todos los elementos de la matriz que están a más de 4 minutos del primer elemento.
Hay un pequeño truco con nombre de variable $. La verificación $>fprimero convierte la matriz en una cadena y luego la compara con la representación de cadena de la función fy luego las compara lexicográficamente. El primer carácter de la matriz en cadena es un dígito y, por lo tanto, solo es un nombre de variable de un carácter cuyo índice ascii es más pequeño que los índices de todos los dígitos $. Reemplazar $con cualquier otro nombre de variable siempre regresará false.

3
Me encanta este sitio debido a respuestas como estas.
— Cristian Lupascu
1
Muy buen truco!
— Arnauld
1
¡Oh, eso sí que es un gran truco!
— Shaggy
8

Mathematica, 46 40 37 33 bytes

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

Explicación

i=1;j=0

Establecer ia 1y ja 0.

... /@#

Asignar a todos los elementos de la entrada ...

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

Si (element) - j < 5es falso, incremente iy establezca jel elemento (evaluación de cortocircuito).

;i

Salida i.

— JungHwan Min
fuente
5

Casco , 8 bytes

Γ(→₀f>+4

Pruébalo en línea!

Explicación

Γ(→₀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.
— Zgarb
fuente
5

Python 2 , 58 bytes

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

Pruébalo en línea!

  • Guardado 2 bytes gracias a @Mr. Xcoder

49 bytes

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

Usando el método recursivo que se muestra en la solución @ ThePirateBay .

  • Guardado un byte gracias a @Mr. Xcoder
  • Ahorró 2 bytes gracias a @Halvard Hummel.

Pruébalo en línea!

— millas
fuente
and 1+f(...)puede ser reemplazado por and-~f(...)49 bytes
— Mr. Xcoder
@ Mr.Xcoder Oh, no puedo olvidar todos esos trucos bit a bit.
— millas
x=a[:1]es equivalente a x=[0], ya que la pregunta establece explícitamente que el primer elemento es siempre 0( 62 bytes )
— Sr. Xcoder
1
— Halvard Hummel
3

J , 20 bytes

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

Pruébalo en línea!

Explicación

[:#(,}.~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
— millas
fuente
3

MATLAB, 34 bytes

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

Función anónima que ingresa una matriz y genera un número.

Esto utiliza la uniquetolfunción, específicamente su forma y = uniquetol(x, t), que proporciona yelementos únicos xcon tolerancia t. Al hacerlo, la función parece seguir un enfoque "vago": ordenarx , elegir su primera entrada y seguir omitiendo las entradas mientras estén dentro de la tolerancia de la última entrada elegida. Eso es exactamente lo que se necesita aquí.

La uniquetolfunción escala automáticamente la tolerancia especificada por el valor absoluto máximo en a. Es por eso que necesitamos la división aquí. x+1se usa en lugar dex evitar la división por 0.

Verificación de casos de prueba:

>> 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
— Luis Mendo
fuente
1
TIL sobre uniquetol... Introducido en R2015a . Tengo R2014b :( Buena respuesta :)
— Stewie Griffin
@Stewie Sabía que existía, pero creo que esta es la primera vez que lo uso
— Luis Mendo
2

05AB1E , 20 19 18 15 14 11 bytes

v®y‹iy4+©\¼

Explicación:

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

Pruébalo en línea!

Editar

  • -3 bytes gracias a Riley y el uso de counter_variable
  • no hay necesidad de counter_variable después de todo
  • -3 bytes nuevamente gracias a Riley y el uso de register_c
— Cyril Gandon
fuente
Puede usar la variable contador para guardar 3 bytes:¼4¹vDy‹i¼y4+}}¾
— Riley
oooooh, hay una variable de contador, ¡eso es útil! ¡¡Gracias!!
— Cyril Gandon
1
11 bytes:v®y‹iy4+©\¼
— Riley
2

Casco, 6 bytes

Lüo<+5

Pruébalo en línea!

  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
— nimi
fuente
¡No me di cuenta de que üfunciona así! Eso es muy útil.
— Zgarb
@Zgarb: primero intenté ġpero no funciona, mientras que de Haskell groupByobras: length.groupBy((>).(+5)). Entonces me encontré con üque también conduce a una más corta equivalente Haskell: nubBy.
— nimi
1

MATL , 13 12 bytes

`ttX<4+>)t}@

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

`        % 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
— Luis Mendo
fuente
1

Pyth , 14 bytes

L&lbhyfg-Thb5b

Esta es una función recursiva. Llámalo con y[0 1 2 3 4 5 6 7 8), dónde [...)está tu lista.

Alternativamente, ¡ Pruébalo aquí! o Verificar todos los casos de prueba.

Explicación

Esto es más o menos equivalente a la solución Python. Una traducción daría los siguientes resultados:

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

Desglose de código

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.
— Sr. Xcoder
fuente
Estoy tratando de encontrar una solución alternativa con .U. Las sugerencias son bienvenidas
— Sr. Xcoder
1

C # .NET, 63 bytes

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

Explicación:

Pruébalo aquí

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
— Kevin Cruijssen
fuente
0

Retina , 32 26 bytes

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

Pruébalo en línea! Explicación:

.+
$*11

Convierta a unario, pero agregue 1, porque 0 es un concepto complicado en Retina.

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

Cuente el número de ediciones, pero incluya todas las ediciones de gracia en cada coincidencia.

— Neil
fuente
0

Kotlin, 52 bytes

Publicando como una función, si esto no es aceptable, lo cambiaré a un método

Sumisión

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

Embellecido

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

Prueba

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

— jrtapsell
fuente
0

PowerShell , 74 bytes

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

Solución iterativa. Largo debido a la valla en el forbucle que requiere un control adicional al final. Sugerencias de golf bienvenidas.

Tomamos la entrada $args[0]como una matriz literal, quitamos el primer elemento $xy el resto en $y. Entonces, mientras haya elementos todavía en$y , hacemos un bucle.

En cada iteración, verificamos si la marca de tiempo actual $xestá 5o más lejos de la $lmarca de tiempo de edición ast. Si es así, incrementamos nuestro contador $i++y configuramos nuestra marca de tiempo para que sea actual. Luego, en la iteración del bucle, quitamos el siguiente elemento en$x y dejamos el resto en$y .

Una vez que estamos fuera del ciclo, sacamos $i, más1 para la edición inicial, más si la marca de tiempo final está a más de cinco de la última edición (con el valor booleano implícitamente convertido a entero). Ese resultado se deja en la tubería y la salida es implícita.

Pruébalo en línea!

— AdmBorkBork
fuente
0

R , 52 bytes

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

Pruébalo en línea!

Función anónima simple que elimina de forma iterativa elementos de la lista que están a menos de 5 del primer elemento hasta que la lista esté vacía, luego devuelve el contador.

— Giuseppe
fuente
0

Clojure, 53 bytes

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

Esto realiza un seguimiento de los "tiempos de inicio de edición" y luego devuelve su recuento distinto.

— NikoNyrh
fuente
0

Japt , 14 bytes

Ê©1+ßUf_aUg)>4

Intentalo

Explicación

Entrada implícita de matriz U

Ê

Obtener la longitud de U.

©

AND lógico ( &&): solo ejecuta lo siguiente si Êes verdadero (no es cero).

ß

Llamada recursiva

Uf_

Filter ( f) Upasando cada elemento a través de una función.

aUg

Obtenga la diferencia ( a) entre el elemento actual y el primer elemento ( g) de U.

>4

Mayor de 4?

1+

Añadir 1.

Salida implícita del entero resultante.

— Lanudo
fuente
0

Jalea , 11 bytes

+4Ḣ<x@µÐĿL’

Pruébalo en línea!

Explicación

+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 bytes

;I4<1;x@;ð/L

Pruébalo en línea!

Explicación

;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
— millas
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.