Contar edições que representam o período de carência

23

Quando você edita uma postagem no SE, quaisquer outras edições dentro de um período de carência de 5 minutos são mescladas a ela. Dada uma lista de vezes que você edita uma postagem, conte as edições que não estão em um período de cortesia.

Digamos que você edite em minutos [0,3,4,7,9,10,11,12]. Isso resulta em três edições às vezes [0,7,12], com o restante acontecendo nos períodos de carência.

0:  [3,4]
7:  [9,10,11]
12: []
  • A primeira edição é no minuto 0. As edições nos minutos 3 e 4 estão dentro do período de carência de 5 minutos e, portanto, não contam.
  • A segunda edição é no minuto 7. As edições nos minutos 9, 10, 11 estão dentro do período de cortesia.
  • A terceira edição no minuto 12 está além do limite do período de carência de 5 minutos, começando no minuto 7.

Então, a saída é 3.

A lista de tempos em minutos será uma lista de números inteiros crescentes. O primeiro número será sempre 0 para a postagem inicial, que contamos como uma edição.

Casos de teste:

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

Saídas:

1
2
3
3
3
3
4
5
5
6

Para facilitar a cópia, aqui estão as entradas, saídas e pares de entrada / saída:

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

Entre os melhores:

Mostrar snippet 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
fonte
Embora seja muito chato se a sua edição não faz o período de carência, porque então você tem que usar o seu novo período de carência para fazer parecer como se você significou para editá-lo dessa forma o tempo todo ...
— Neil

Respostas:

20

JavaScript, 36 bytes

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

Experimente online!

Como funciona

Em cada chamada recursiva, excluímos todos os elementos da matriz que estão a mais de 4 minutos do primeiro elemento.
Há um pequeno truque com o nome da variável $. A verificação $>fprimeiro converte a matriz em uma sequência e, em seguida, compara-a com a representação de sequência da função fe, em seguida, compara-as lexicograficamente. O primeiro caractere da matriz stringified é um dígito e, portanto, apenas o nome da variável de um caractere cujo índice ascii é menor que os índices de todos os dígitos $. Substituir $por qualquer outro nome de variável sempre retornará false.

3
Eu amo este site por causa de respostas como estas.
— Cristian Lupascu
11
Truque muito bom!
— Arnauld
11
Oh, agora, isso é um grande truque!
— Shaggy
8

Mathematica, 46 40 37 33 bytes

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

Explicação

i=1;j=0

Defina icomo 1e jpara 0.

... /@#

Mapeie para todos os elementos da entrada ...

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

Se (element) - j < 5for falso, aumente ie defina jpara o elemento (avaliação de curto-circuito).

;i

Saída i.

— JungHwan Min
fonte
5

Casca , 8 bytes

Γ(→₀f>+4

Experimente online!

Explicação

Γ(→₀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
fonte
5

Python 2 , 58 bytes

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

Experimente online!

  • Economizou 2 bytes graças a @Mr. Xcoder.

49 bytes

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

Usando o método recursivo mostrado na solução do @ ThePirateBay .

  • Guardou um byte graças a @Mr. Xcoder.
  • Economizou 2 bytes graças a @Halvard Hummel.

Experimente online!

— milhas
fonte
and 1+f(...)pode ser substituído por and-~f(...)49 bytes
— Mr. Xcoder 7/17
@ Mr.Xcoder Oh, não posso esquecer todos esses truques bit a bit.
— milhas
x=a[:1]é equivalente x=[0], uma vez que a questão refere explicitamente que o primeiro elemento é sempre 0( 62 bytes )
— Sr. Xcoder
11
— Halvard Hummel
3

J , 20 bytes

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

Experimente online!

Explicação

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

MATLAB, 34 bytes

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

Função anônima que insere uma matriz e gera um número.

Isso usa a uniquetolfunção, especificamente sua forma y = uniquetol(x, t), que fornece yelementos únicos xcom tolerância t. Ao fazer isso, a função parece seguir uma abordagem "lenta": classifique x, escolha sua primeira entrada e continue pulando as entradas enquanto elas estiverem dentro da tolerância da última entrada selecionada. É exatamente isso que é necessário aqui.

A uniquetolfunção escala automaticamente a tolerância especificada pelo valor absoluto máximo em a. É por isso que precisamos da divisão aqui. x+1é usado em vez de xevitar a divisão por 0.

Verificação de casos de teste:

>> 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
fonte
11
TIL sobre uniquetol... Introduzido em R2015a . Eu tenho resposta R2014b :( agradável :)
— Stewie Griffin
@Stewie eu sabia que existia, mas acho que esta é a primeira vez que eu usá-lo
— Luis Mendo
2

05AB1E , 20 19 18 15 14 11 bytes

v®y‹iy4+©\¼

Explicação:

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

Experimente online!

Editar

  • -3 bytes graças a Riley e o uso de counter_variable
  • afinal, não há necessidade de counter_variable
  • -3 bytes novamente graças a Riley e o uso de register_c
— Cyril Gandon
fonte
Você pode usar a variável do contador para salvar 3 bytes:¼4¹vDy‹i¼y4+}}¾
— Riley
oooooh, existe uma variável de contador, útil! Obrigado!!
— Cyril Gandon
11
11 bytes:v®y‹iy4+©\¼
— Riley
2

Casca, 6 bytes

Lüo<+5

Experimente 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
— nimi
fonte
Whoa, eu não percebi que üfunciona assim! Isso é muito útil.
— Zgarb 7/09/17
@Zgarb: A primeira vez que tentou ġ, mas ele não funciona, enquanto que de Haskell groupByobras: length.groupBy((>).(+5)). Então eu achei üque também leva a uma Haskell mais curto equivalentes: nubBy.
— nimi
1

MATL , 13 12 bytes

`ttX<4+>)t}@

Experimente online! Ou verifique todos os casos de teste .

Explicação

`        % 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
fonte
1

Pitão , 14 bytes

L&lbhyfg-Thb5b

Esta é uma função recursiva. Chame-o com y[0 1 2 3 4 5 6 7 8), onde [...)está sua lista.

Como alternativa, experimente aqui! ou Verifique todos os casos de teste.

Explicação

Isso é aproximadamente equivalente à solução Python. Uma tradução daria os seguintes resultados:

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

Repartição do 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.
— Mr. Xcoder
fonte
Estou tentando encontrar uma solução alternativa com .U. Sugestões são bem
— Mr. 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;}

Explicação:

Experimente aqui.

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
fonte
0

Retina , 32 26 bytes

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

Experimente online! Explicação:

.+
$*11

Converta para unário, mas adicione 1, porque 0 é um conceito complicado na Retina.

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

Conte o número de edições, mas inclua todas as edições gratuitas em cada partida.

— Neil
fonte
0

Kotlin, 52 bytes

Publicando como uma função, se isso não for aceitável, mudarei para um método

Submissão

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

Embelezado

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

Teste

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
fonte
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)

Solução iterativa. Longo por causa de uma vedação no forloop que requer uma verificação adicional no final.Sugestões de golfe são bem-vindas.

Tomamos a entrada $args[0]como uma matriz literal, destacamos o primeiro elemento $xe o restante em$y . Então, desde que ainda haja elementos $y, fazemos um loop.

A cada iteração, verificamos se o registro de data $xe hora atual está 5ou mais distante do $lregistro de data e hora de edição ast. Nesse caso, incrementamos nosso contador $i++e configuramos nosso carimbo de data / hora para ser atual. Então, na iteração do loop, separamos o próximo elemento para$x e deixar o restante no $y.

Quando saímos do loop, produzimos $i, mais 1para a edição inicial, mais se o carimbo de data e hora final está a mais de cinco da última edição (com o valor booleano implicitamente convertido em número inteiro). Esse resultado é deixado no pipeline e a saída é implícita.

Experimente online!

— AdmBorkBork
fonte
0

R , 52 bytes

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

Experimente online!

Função anônima simples que remove iterativamente os elementos da lista que estão a menos de 5 do primeiro elemento até que a lista esteja vazia e retorna o contador.

— Giuseppe
fonte
0

Clojure, 53 bytes

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

Isso controla os "horários de início da edição" e retorna sua contagem distinta.

— NikoNyrh
fonte
0

Japonês , 14 bytes

Ê©1+ßUf_aUg)>4

Tente

Explicação

Entrada implícita da matriz U

Ê

Obtenha o comprimento de U.

©

AND lógico ( &&) - execute apenas o seguinte se Êfor verdade (diferente de zero).

ß

Chamada recursiva.

Uf_

Filtre ( f) Upassando cada elemento por uma função.

aUg

Obtenha a diferença ( a) entre o elemento atual e o primeiro elemento ( g) de U.

>4

Maior que 4?

1+

Adicionar 1.

Saída implícita do número inteiro resultante.

— Shaggy
fonte
0

Gelatina , 11 bytes

+4Ḣ<x@µÐĿL’

Experimente online!

Explicação

+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

Experimente online!

Explicação

;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
— milhas
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.