Nombre de modifications tenant compte du délai de grâce

23

Lorsque vous modifiez une publication sur SE, toutes les modifications ultérieures dans un délai de grâce de 5 minutes y sont fusionnées. Étant donné la liste des fois où vous modifiez un message, comptez les modifications qui ne sont pas dans un délai de grâce.

Disons que vous modifiez en quelques minutes [0,3,4,7,9,10,11,12]. Il en résulte parfois 3 modifications [0,7,12], le reste se produisant pendant leurs périodes de grâce.

0:  [3,4]
7:  [9,10,11]
12: []
  • La première modification est à la minute 0. Les modifications aux minutes 3 et 4 sont dans sa période de grâce de 5 minutes, et donc ne comptent pas.
  • La deuxième modification est à la minute 7. Les modifications aux minutes 9, 10, 11 sont dans sa période de grâce.
  • Le troisième montage à la minute 12 est juste après le bord de la période de grâce de 5 minutes commençant à la minute 7.

Donc, la sortie est 3.

La liste des temps en minutes sera une liste d'entiers croissants. Le premier nombre sera toujours 0 pour la publication initiale, que nous comptons comme une modification.

Cas de 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]

Les sorties:

1
2
3
3
3
3
4
5
5
6

Pour faciliter la copie, voici les entrées, les sorties et les paires d'entrée / sortie:

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

Classement:

Afficher l'extrait de code

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
source
Bien que ce soit vraiment ennuyeux si votre montage ne fait pas la période de grâce, car vous devez alors utiliser votre nouvelle période de grâce pour lui donner l'impression que vous vouliez la modifier de cette façon tout au long de la vie ...
— Neil

Réponses:

20

JavaScript, 36 octets

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

Essayez-le en ligne!

Comment ça marche

Dans chaque appel récursif, nous supprimons tous les éléments du tableau qui sont distants de plus de 4 minutes du premier élément.
Il y a une petite astuce avec le nom de variable $. La vérification $>fconvertit d'abord le tableau en chaîne, puis le compare à la représentation sous forme de chaîne de la fonction f, puis les compare lexicographiquement. Le premier caractère du tableau stringified est un chiffre et donc seulement un nom de variable à un caractère dont l'indice ascii est plus petit que les indices de tous les chiffres $. Le remplacement $par un autre nom de variable reviendra toujours false.

3
J'adore ce site à cause de réponses comme celles-ci.
— Cristian Lupascu
1
Très bon truc!
— Arnauld
1
Oh, maintenant, c'est un excellent truc!
— Shaggy
8

Mathematica, 46 40 37 33 octets

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

Explication

i=1;j=0

Réglez isur 1et jsur 0.

... /@#

Mappez sur tous les éléments de l'entrée ...

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

Si (element) - j < 5est faux, incrémentez iet réglez jsur l'élément (évaluation de court-circuit).

;i

Sortie i.

— JungHwan Min
source
5

Husk , 8 octets

Γ(→₀f>+4

Essayez-le en ligne!

Explication

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

Python 2 , 58 octets

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

Essayez-le en ligne!

  • Enregistré 2 octets grâce à @Mr. Xcoder.

49 octets

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

Utilisation de la méthode récursive présentée dans la solution de @ ThePirateBay .

  • Enregistré un octet grâce à @Mr. Xcoder.
  • Enregistré 2 octets grâce à @Halvard Hummel.

Essayez-le en ligne!

— miles
source
and 1+f(...)peut être remplacé par and-~f(...)pour 49 octets
— M. Xcoder
@ Mr.Xcoder Oh, je ne peux pas oublier toutes ces astuces au niveau du bit.
— miles
x=a[:1]est équivalent à x=[0], puisque la question indique explicitement que le premier élément est toujours 0( 62 octets )
— M. Xcoder
1
— Halvard Hummel
3

J , 20 octets

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

Essayez-le en ligne!

Explication

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

MATLAB, 34 octets

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

Fonction anonyme qui entre un tableau et sort un nombre.

Cela utilise la uniquetolfonction, en particulier sa forme y = uniquetol(x, t), qui donne ycontenant des éléments uniques de xavec tolérance t. Ce faisant, la fonction semble suivre une approche "paresseuse": trier x, sélectionner sa première entrée et continuer à ignorer les entrées tant qu'elles respectent la tolérance de la dernière entrée sélectionnée. C'est exactement ce dont nous avons besoin ici.

La uniquetolfonction met automatiquement à l'échelle la tolérance spécifiée par la valeur absolue maximale en a. C'est pourquoi nous avons besoin de la division ici. x+1est utilisé au lieu dex éviter la division par 0.

Vérification des cas de 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
— Luis Mendo
source
1
TIL about uniquetol... Introduit dans R2015a . J'ai R2014b :( Belle réponse :)
— Stewie Griffin
@Stewie Je savais qu'il existait, mais je pense que c'est la première fois que je l'utilise
— Luis Mendo
2

05AB1E , 20 19 18 15 14 11 octets

v®y‹iy4+©\¼

Explication:

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

Essayez-le en ligne!

modifier

  • -3 octets grâce à Riley et à l'utilisation de counter_variable
  • pas besoin de counter_variable après tout
  • -3 octets à nouveau grâce à Riley et à l'utilisation de register_c
— Cyril Gandon
source
Vous pouvez utiliser la variable de compteur pour enregistrer 3 octets:¼4¹vDy‹i¼y4+}}¾
— Riley
oooooh, il y a une variable de compteur, c'est pratique! Merci!!
— Cyril Gandon
1
11 octets:v®y‹iy4+©\¼
— Riley
2

Husk, 6 octets

Lüo<+5

Essayez-le en ligne!

  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
source
Whoa, je n'avais pas réalisé des ütravaux comme ça! C'est très pratique.
— Zgarb
@Zgarb: J'ai d' abord essayé , ġmais ça ne marche pas, alors que Haskell groupByœuvres: length.groupBy((>).(+5)). Ensuite , j'ai trouvé üqui conduit aussi à un équivalent Haskell plus courte: nubBy.
— nimi
1

MATL , 13 12 octets

`ttX<4+>)t}@

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

Pyth , 14 octets

L&lbhyfg-Thb5b

Il s'agit d'une fonction récursive. Appelez-le avec y[0 1 2 3 4 5 6 7 8), où [...)est votre liste.

Alternativement, essayez-le ici! ou Vérifiez tous les cas de test.

Explication

C'est à peu près équivalent à la solution Python. Une traduction donnerait les résultats suivants:

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

Répartition du code

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.
— M. Xcoder
source
J'essaie de trouver une solution de contournement avec .U. Les suggestions sont les bienvenues
— M. Xcoder
1

C # .NET, 63 octets

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

Explication:

Essayez-le ici.

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

Rétine , 32 26 octets

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

Essayez-le en ligne! Explication:

.+
$*11

Convertissez en unaire, mais ajoutez 1, car 0 est un concept délicat dans la rétine.

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

Comptez le nombre de modifications, mais incluez toutes les modifications de grâce dans chaque correspondance.

— Neil
source
0

Kotlin, 52 octets

Publier en tant que fonction, si ce n'est pas acceptable je vais le changer en méthode

Soumission

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

Embellie

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

Tester

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

PowerShell , 74 octets

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

Solution itérative. Longue en raison de la clôture de la clôture sur la forboucle nécessitant un contrôle supplémentaire à la fin.Suggestions de golf bienvenues.

Nous prenons l'entrée $args[0]comme un tableau littéral, décollons le premier élément $xet le reste dans $y. Ensuite, tant qu'il y a encore des éléments dans$y , nous bouclons.

À chaque itération, nous vérifions si l'horodatage actuel $xest 5ou plus éloigné de l' $lhorodatage ast edit. Si c'est le cas, nous incrémentons notre compteur $i++et définissons notre horodatage comme étant à jour. Ensuite, à l'itération de la boucle, nous décollons l'élément suivant $xet laissons le reste dans$y .

Une fois que nous sommes sortis de la boucle, nous sortons $i, plus1 pour l'édition initiale, plus si l'horodatage final est à plus de cinq de la dernière édition (avec la valeur booléenne implicitement convertie en entier). Ce résultat est laissé sur le pipeline et la sortie est implicite.

Essayez-le en ligne!

— AdmBorkBork
source
0

R , 52 octets

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

Essayez-le en ligne!

Fonction anonyme simple qui supprime de manière itérative des éléments de la liste qui sont à moins de 5 du premier élément jusqu'à ce que la liste soit vide, puis renvoie le compteur.

— Giuseppe
source
0

Clojure, 53 octets

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

Cela permet de garder une trace des «heures de début de modification», puis renvoie leur nombre distinct.

— NikoNyrh
source
0

Japt , 14 octets

Ê©1+ßUf_aUg)>4

Essayez-le

Explication

Entrée implicite du tableau U

Ê

Obtenez la longueur de U.

©

ET logique ( &&) - n'exécute ce qui suit que si Êest véridique (non nul).

ß

Appel récursif.

Uf_

Filter ( f) Uen passant chaque élément à travers une fonction.

aUg

Obtenez la différence ( a) entre l'élément courant et le premier élément ( g) de U.

>4

Plus de 4?

1+

Ajoutez 1.

Sortie implicite de l'entier résultant.

— Hirsute
source
0

Gelée , 11 octets

+4Ḣ<x@µÐĿL’

Essayez-le en ligne!

Explication

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

;I4<1;x@;ð/L

Essayez-le en ligne!

Explication

;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
— miles
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.