Correlati: dimmi quanti problemi di matematica devo fare!

Sfida

Dato un elenco intero strettamente ascendente strettamente positivo L e un intero 3 ≤ N ≤ lunghezza di L, sostituire gli interi medi delle corse consecutive consecutive di L di lunghezza ≥ N con un singolo trattino -.

Regole

• Gli spazi bianchi orizzontali sono irrilevanti.
• Se lo desideri, puoi conservare i caratteri introduttore, separatore e terminatore del formato elenco predefinito della tua lingua. Vedi esempi di formato , di seguito.

Esempi di dati

Tutti questi esempi usano L = 3 5 6 7 8 10 11 12 14 16 17 18 19 20 21 22 24.

N = 3 → 3 5 - 8 10 - 12 14 16 - 22 24

N = 4 → 3 5 - 8 10 11 12 14 16 - 22 24

N = 5 → 3 5 6 7 8 10 11 12 14 16 - 22 24

N = 8 → 3 5 6 7 8 10 11 12 14 16 17 18 19 20 21 22 24

Esempi di formato

Per gli input
 L = [3,5,6,7,8,10,11,12,14,16,17,18,19,20,21,22,24]e N = 3
tutte le righe sottostanti sono esempi di risposte valide, sia come elenchi effettivi sia come stringhe:

[3,5,"-",8,10,"-",12,14,16,"-",22,24]
[3,5,-,8,10,-,12,14,16,-,22,24]
[3,5-8,10-12,14,16-22,24]
3,5-8,10-12,14,16-22,24

Lo stesso vale con altri formati di elenco, come {1 2 3}e così via (1; 2; 3). In dubbio? Chiedere!

Python 2 , 132 115 byte

^{-17 byte grazie a Leaky Nun}

x,n=input()
o=[]
i=1
while x:
 t=x[0]
 while[t+i]==x[i:i+1]:i+=1
 o+=[[t,'-',t+i-1],x[:i]][i<n];x=x[i:];i=1
print o

Provalo online!

Gelatina ,  26 25  23 byte

-2 byte grazie a Erik the Outgolfer (portando l'istruzione if nel collegamento principale)

Ḣ;Ṫj”-
IỊ¬1;œṗ⁸¹ÇL<¥?€F

Un collegamento diadico che restituisce un elenco nel [3,5,"-",8,10,"-",12,14,16,"-",22,24]formato.

Provalo online! (il piè di pagina si separa con spazi, per stampare il formato di esempio dei dati).

Come?

Ḣ;Ṫj”- - Link 1, format a run: list R
Ḣ      -     head
  Ṫ    -     tail
 ;     -     concatenate
    ”- -     literal '-'
   j   -     join

IỊ¬1;œṗ⁸¹ÇL<¥?€F - Main link: list L, number N
I                - incremental differences
 Ị               - insignificant? (<=1)
  ¬              - not
   1;            - prepend a 1
       ⁸         - chain's left argument, L
     œṗ          - partition (L) at truthy indexes
              €  - for €ach row, R, in L:
             ?   -   if:
            ¥    -   condition: last two links as a dyad:
          L      -     length of R
           <     -     is less than N?
        ¹        -   then: identity - do nothing, yields R
         Ç       -   else: call the last link (1) as a monad with argument  R
               F - flatten into a single list

Pyth, 23 byte

sm?<ldvzd[hd\-ed).ga=hZ

Provalo online

Come funziona

sm?<ldvzd[hd\-ed).ga=hZkQ

                        Q    autoinitialized to eval(input())
                 .g          group by k ↦
                    =hZ          Z += 1, returning new value (Z is autoinitialized to 0)
                   a   k         absolute difference with k
 m                           map d ↦
  ?                              if
    ld                               length of d
   <  vz                             less than eval(z) (z is autoinitialized to input())
        d                        then d
         [hd\-ed)                else [d[0], '-', d[-1]]
s                            concatenate

Japt , 24 byte

óÈÄ¥Yîl ¨V?Zv +'-+Zo :Z

Provalo online!

Spiegazione

óÈ   Ä ¥ YÃ ®   l ¨ V?Zv +'-+Zo :Z
óXY{X+1==Y} mZ{Zl >=V?Zv +'-+Zo :Z}   Ungolfed
                                      Implicit: U = input array, V = input integer
óXY{      }                           Group U into runs such that for each pair X, Y:
    X+1==Y                              Y is exactly 1 more than X.
            mZ{                   }   Map each run Z to:
               Zl >=V?                  If Z has at least V items:
                      Zv     Zo           Z.unshift() and Z.pop() (the first and last items)
                         +'-+             joined with a hyphen.
                                :       Otherwise:
                                 Z        just Z.
                                      Implicit: output result of last expression

Mathematica, 128 byte

(s=#2;t=r=1;While[t<Length@s,If[s[[t+1]]-s[[t]]==1,r++,r=1];If[r==#,s[[t-#+3;;t]]="-";r--];t++];s//.{b___,a_,a_,c___}:>{b,a,c})&

ingresso

[3, {} 3,5,6,7,8,10,11,12,14,16,17,18,19,20,21,22,24]

produzione

{3, 5, "-", 8, 10, "-", 12, 14, 16, "-", 22, 24}

Provalo online!

APL, 38 byte

{∊⍺{⍺>≢⍵:⍵⋄2⌽'-',2↑¯1⌽⍵}¨⍵⊂⍨1,1≠2-⍨/⍵}

PHP 7, 137 136 134 117 110 108 byte

for($a=$argv,$i=2;$n=$a[$i++];$k<$a[1]||array_splice($a,$i,$k-2,"-"))for($k=print"$n ";$a[$i+$k]-++$k==$n;);

Prende Ldal primo argomento, elenca gli elementi dopo. Corri con -nro provalo online .

Sostituisci $L=($a=$argv)con $a=$argv,$L=(+1 byte) per PHP <7.

abbattersi

for($a=$argv,$i=2;              # import input
    $n=$a[$i++];                # loop $n through list elements
    $k<$a[1]||                      # 3. if streak length ($k) is >=L ($a[1])
        array_splice($a,$i,$k-2,"-")    # then replace with "-"
)
for($k=print"$n ";                  # 1. print element and space
    $a[$i+$k]-++$k==$n;);           # 2. find consecutive numbers

Retina , 101 byte

\d+
$*
\b(1+) (?=1\1\b)
$1X
T`X` `\b((X)|1)+\b(?=.*¶(?<-2>1)+(?(2)(?!))11)
T`X`-
-1+(?=-)|¶1+

1+
$.&

Provalo online! Prende l'elenco separato da spazi Lsulla prima riga e l'intero Nsulla seconda riga. Spiegazione: Il primo stadio converte l'input in unario. Il secondo stadio cambia lo spazio tra numeri interi consecutivi in ​​un X. Il terzo stadio cerca sequenze di numeri interi consecutivi la cui lunghezza è inferiore Ne cambia la loro Xschiena in spazi. Il quarto stadio cambia la Xs in -(questo era di 3 byte in meno rispetto all'utilizzo di -s in primo luogo). Il quinto stadio cancella tutti gli interi ancora rimasti nel mezzo di una corsa, così come N, mentre lo stadio finale converte di nuovo in decimale.

Rubino, 68 byte

->n,l{l.slice_when{|x,y|x<y-1}.map{|x|x[n-1]?x.minmax.uniq*?-:x}*?,}

Restituisce una stringa come ad esempio 3,5-8,10-12,14,16-22,24.

Provalo online!

J , 40 byte

;@((](,_,{:)/)^:(<:#)&.>]<;.1~1,1<}.-}:)

Provalo online!

Utilizza _invece di -.

Spiegazione

;@((](,_,{:)/)^:(<:#)&.>]<;.1~1,1<}.-}:)  Input: integer N (LHS), array L (RHS)
                                  }.      Behead L
                                     }:   Curtail L
                                    -     Subtract elementwise to get the increments
                                1<        Test if greater than 1
                              1,          Prepend a 1
                        ]                 Get L
                         <;.1~            Partition L into boxes using the previous array
                     & >                  Operate on each box (partition) with N
              ^:                            If
                   #                          The length of the partition
                 <:                           Is greater than or equal to N
   (](     )/)                                Reduce (right-to-left) it using
         {:                                     Tail
       _,                                       Prepend _
      ,                                         Append to LHS
                     &.>                    Box the result
;@                                        Raze - join the contents in each box

Gelatina, 39 37 36 byte

IỊṣ0;€1ṁ@
ÇL€<Ɠ¬TịÇḊ€Ṗ€F;€”-FyµŒgQ€F

Provalo online

Accetta l'array tramite argomenti e l'intero tramite STDIN. Il collegamento TIO utilizza il piè di pagina, ÇGquindi l'output è separato dallo spazio.

Come? (Array: a, Integer: n)

(`f`)
IỊṣ0;€1ṁ@
I          Deltas of `a`
 Ị         Insignificant (x -> abs(x)<=1) applied to each element
  ṣ0       Split at occurrences of `0`.
    ;€1    Append `1` to each element
       ṁ@  `a` shaped like that
ÇL€<Ɠ¬TịÇḊ€Ṗ€F;€”-FyµŒgQ€F
Ç                            `f`
 L€                          Length of each element
   <Ɠ                        x -> x < n applied to each element
     ¬                       Logical not of each element (because Jelly doesn't have <= nor >= atoms)
      T                      Nonzero indexes
       ịÇ                    Index `f` at those indexes
         Ḋ€Ṗ€                x -> x[1:-1] applied to each element
             F               Flatten
              ;€”-           Append a hyphen to each element
                  F          Flatten
                   y         Translate (replaces all elements to be deleted with a hyphen)
                    µ        Start a new monadic link
                     Œg      Group runs of equal elements
                       Q€    Uniquify each element (make runs of hyphens one hypen)
                         F   Flatten, yet again.

Immagino di essere caduto ... piatto su questo.

JavaScript (ES6), 126 119 byte

(e,c)=>{for(i=0,R='';i<e.length;R+=(R&&',')+(u-m>=c?m+'-'+--u:e.slice(z,i))){m=u=e[i],z=i;while(e[++i]==++u);}return R}

Una funzione anonima. Accetta l'input nell'ordine Array L, Integer Ne restituisce il risultato come una stringa separata da virgola.

M=(e,c)=>{for(i=0,R='';i<e.length;R+=(R&&',')+(u-m>=c?m+'-'+--u:e.slice(z,i))){m=u=e[i],z=i;while(e[++i]==++u);}return R}
console.log(M(eval(prompt()),+prompt()))

Dyalog APL v16.0, 82 80 78 76 75 65 62 byte

{S/⍨1,⍨2≠/S←'-'@(⍸⊃∨/(-0,⍳⍺-3)⌽¨⊂(⍴⍵)↑∧/¨(⍺-1),/¯1⌽1=-2-/⍵)⊢⍵}

Wow, questo è ... cattivo. Probabilmente c'è una soluzione molto più breve con lo stencil.

Provalo online!

Suggerimenti di golf benvenuti!