Segna i segni di Split

21

Sfida

Mark è uno studente che riceve i suoi Nvoti in modo concatenato in un'unica riga.

La sfida è quella di separare i suoi marchi, sapendo che ogni marchio può essere solo 0o 1oppure 2oppure 3oppure 4oppure 5oppure 6oppure 7oppure 8oppure 9oppure 10.

Ingresso

N numero naturale e una riga.

Produzione

Un insieme di numeri naturali.

Esempio

N, One line------------------> Set of marks
3, '843'---------------------> [8, 4, 3]
1, '0'-----------------------> [0]
2, '1010'--------------------> [10,10]
3, '1010'--------------------> [1,0,10] or [10,1,0] 
4, '1010'--------------------> [1,0,1,0]
9, '23104441070'-------------> [2, 3, 10, 4, 4, 4, 10, 7, 0]
12,'499102102121103'---------> [4, 9, 9, 10, 2, 10, 2, 1, 2, 1, 10, 3]
5, '71061'-------------------> [7, 1, 0, 6, 1]
11,'476565010684'------------> [4, 7, 6, 5, 6, 5, 0, 10, 6, 8, 4]
4, '1306'--------------------> [1, 3, 0, 6]
9, '51026221084'-------------> [5, 10, 2, 6, 2, 2, 10, 8, 4]
14,'851089085685524'---------> [8, 5, 10, 8, 9, 0, 8, 5, 6, 8, 5, 5, 2, 4]
11,'110840867780'------------> [1, 10, 8, 4, 0, 8, 6, 7, 7, 8, 0]
9, '4359893510'--------------> [4, 3, 5, 9, 8, 9, 3, 5, 10]
7, '99153710'----------------> [9, 9, 1, 5, 3, 7, 10]
14,'886171092313495'---------> [8, 8, 6, 1, 7, 10, 9, 2, 3, 1, 3, 4, 9, 5]
2, '44'----------------------> [4, 4]
4, '9386'--------------------> [9, 3, 8, 6]

Regole

  • Quando sono possibili più uscite, dare una sola uscita.
  • L'unico segno di valore 10è su due decimali, altri su un decimale.
  • L'input e l'output possono essere forniti in qualsiasi formato conveniente
  • Non è necessario gestire input non validi
  • È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
  • Se possibile, includi un collegamento a un ambiente di test online in modo che altre persone possano provare il tuo codice!
  • Sono vietate le scappatoie standard .
  • Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).
code-golf  string  array-manipulation 
— mdahmoune
fonte
Ecco uno snippet di Python che ho usato per ottenere le n, 'string'coppie dal blocco di testo di esempio copypasted:spl = [item.split('-')[0] for item in text.split('\n')]
— Gigaflop,
3
Per favore alcuni commenti per i voti
— negativi
I downgrade non richiedono di lasciare commenti per un motivo. Non c'è nulla che possa essere migliorato in questa sfida.
— user202729
Quindi non preoccuparti.
— user202729
Le uscite devono essere nello stesso ordine dell'ingresso?

Risposte:

6

Brachylog , 23 21 byte

-2 byte grazie a Fatalize

h~c.{ịℕ≤10&ịṫ?∧}ᵛ&t~l

Provalo online!

L'input è una coppia [Line, N].

Questo è il mio primo programma Brachylog, quindi probabilmente c'è molto margine di miglioramento.

È molto lento quando la lunghezza della linea> 7.

Spiegazione:

h~c.{ịℕ≤10&ịṫ?∧}ᵛ&t~l
h                         The first element in the input
 ~c                       is formed by concatenating
   .                      the elements in the output array
   .{         ∧}ᵛ     AND For every element in the output array holds that
     ị                      The element converted to an integer
      ℕ                       is a natural number
       ≤10                    and less than or equal to 10
          &ịṫ?              and it has no leading zeroes (*)
                 &t   AND The second element of the input
                   ~l     is the length of the output

(*) ịṫ?verifica che non vi siano zero iniziali. Converte la stringa in numero intero, quindi di nuovo in stringa e la confronta con la stringa originale.

— fergusq
fonte
Non è necessario inserire il numero come stringa, basta usare un numero intero. Questo riduce la necessità per tutti coloro ịche per il leader di controllo pari a zero: h~c.{ℕ≤10}ᵛ&t~l. Questo è probabilmente più lento, anche se la deconcatenazione su numeri interi deve funzionare anche per numeri interi sconosciuti tramite vincoli, il che lo rende inefficiente.
— Fatalizza il
(Si noti inoltre che l'utilizzo di he tper ottenere il primo / ultimo elemento è più efficiente dell'uso ∋per entrambi (che nella maggior parte dei programmi non funzionerà nemmeno)).
— Fatalizza il
@Fatalize Ho capito che la linea di input può contenere zero iniziali, quindi non sarebbe possibile utilizzare un numero intero come input.
— fergusq,
Bene, questo è fastidioso ...
— Fatalizza il
5

Perl 6 , 25 byte

->\a,\b{b~~/(10|.)**{a}/}

Provalo online!

Blocco di codice anonimo che accetta un numero e una stringa e restituisce come oggetto Match.

Spiegazione:

->\a,\b{                }  # Anonymous code block taking params a and b
        b~~/           /   # Match using b
            (10|.)           # 10 or a single digit
                  **{a}      # Exactly a times, being greedy
— Jo King
fonte
5

Python 3 , 47 byte

lambda s,n:[*s.replace(b'\1\0',b'\n',len(s)-n)]

Provalo online!

Prende "una riga" come bytestring con byte non elaborati \x00 - \x09. Se non è accettabile:

Python 3 , 56 byte

lambda s,n:[x-48for x in s.replace(b'10',b':',len(s)-n)]

Provalo online!

Prende "una riga" come bytestring.

— bubbler
fonte
5

V , 17 , 12 byte

\ÓòÀGjí1“î…0

Provalo online!

Ero contento di 17 byte, ma di 05AB1E arrivò con 13, e non potevo lasciare una sfida senza risposta. : D

\Ó                      " Put each character on it's own line
  ò                     " Recursively (repeat until an error happens)...
   ÀG                   "   Go to the "n"th line
     j                  "   Move down a line (this will error if there are exactly "n" lines)
      í                 "   Remove...
       1                "     a '1'
        <0x93>          "     START THE MATCH HERE
              î         "     a newline
               <0x85>   "     END THE MATCH HERE
                   0    "     a '0'

hexdump:

00000000: 5cd3 f2c0 476a ed31 93ee 8530            \...Gj.1...0

Soluzione alternativa:

\ÓòÀGjç1î0/J

Sfortunatamente, questo sostituisce 10con1 0

— DJMcMayhem
fonte
4

Rubino , 57 byte

->n,m{m.sub!"10",?A while m[n];m.chars.map{|c|c.to_i 16}}

Provalo online!

Questo potrebbe non essere l'approccio più golfistico, ma sembra un'idea divertente sostituire temporaneamente 10un esagono A, che per inciso è anche un punteggio elevato (se consideriamo il sistema di classificazione AF :))

— Kirill L.
fonte
4

Haskell , 68 byte

n!('1':'0':x)|n-2<length x=10:(n-1)!x
n!(s:x)=read[s]:(n-1)!x
n!_=[]

Provalo online!

Richiedere avidamente 10 secondi purché ci siano più cifre dei segni rimanenti.

— Nitrodon
fonte
4

Python 3 , 71 68 59 byte

giù di altri 9 byte grazie agli ovs.

lambda n,s:[int(c,11)for c in s.replace('10','a',len(s)-n)]

Provalo online!

Stavo inizialmente cercando di usare str.partition()ricorsivamente, ma l'uso replacemi ha colpito in faccia non molto tempo dopo. Qualcuno può migliorare su questo?

Inoltre, ecco un link TIO che ho usato per trasformare i casi di test in qualcosa di più copia / incollabile

— gigaflop
fonte
1
-3 byte: rilascia spazio tra : [ce 'x' elsee10 for
— mdahmoune,
@mdahmoune Grazie per averlo notato, ho difficoltà a ricordare cosa si può schiacciare insieme.
— Gigaflop,
8
Regola generale: praticamente qualsiasi cosa tranne due lettere può essere schiacciata insieme. Se ricevi un errore di sintassi, aggiungi spazi casuali fino a quando non funziona :)
— Quintec,
Ci sono alcune eccezioni come <number>e, <letter><number>, f'.
— user202729
3
59 byte sostituendo 10 con una lettura e ogni carattere come base 11 int: lambda n,s:[int(c,11)for c in s.replace('10','a',len(s)-n)].
— Ovs
3

Haskell , 98 byte

n!x=[y|y<-s x,y==take n y]!!0
s('1':'0':x)=do y<-s x;[1:0:y,10:y]
s(x:y)=(read[x]:)<$>s y
s _=[[]]

Provalo online o prova tutto!

Spiegazione

La funzione sesegue tutte le suddivisioni possibili, ad esempio: "1010"diventa [[1,0,1,0],[10,1,0],[1,0,10],[10,10]], nota come le suddivisioni più lunghe finiscono all'inizio (perché 1:0:yviene prima 10:y).

Tenendo presente ciò, possiamo prendere tutti questi valori e filtrare yi punti in cui y == take n yciò mantiene anche le divisioni più brevi del necessario. Per esempio con 4lasciamo la lista lo stesso [[1,0,1,0],[10,1,0],[1,0,10],[10,10]].

Ora possiamo semplicemente ottenere il primo elemento in quella lista perché gli input saranno sempre validi (es. 5!"1010"Darebbe [1,0,1,0]anche, ma non abbiamo bisogno di gestirlo).

Nota: in qualche modo ho contato male ... ha y==take n yla stessa lunghezza di length y==n: S

— ბიმო
fonte
2

Pulito , 128 byte

import StdEnv
@[]=[[]]
@['10':t]=[u++v\\u<-[[10],[1,0]],v<- @t];@[h:t]=[[digitToInt h:v]\\v<- @t]
?n l=hd[e\\e<- @l|length e==n]

Provalo online!

— Οurous
fonte
2

05AB1E , 13 byte

.œsù.ΔïTÝÃJ¹Q

Provalo online! o come una suite di test

Spiegazione

.œ              # partitions of the first input
  sù            # of a length equal to the second input
    .Δ          # find the first partition that returns true when:
      ï         # each element is converted to integer
       TÝÃ      # and only numbers in [0 ... 10] are kept
          J     # then join it together
           ¹Q   # and compare it to the first input for equality
— Emigna
fonte
2

JavaScript (nodo Babele) ,  70 69  59 byte

Accetta input come (n)(line).

n=>s=>(a=s.match(/10|./g)).flatMap(x=>x>9&&!a[--n]?[1,0]:x)

Provalo online!

Commentate

n => s =>                       // given n and s
  (a = s.match(/10|./g))        // split s into marks; a '1' followed by a '0' is always
                                // interpreted as '10'
  .flatMap(x =>                 // for each mark x:
    x > 9 &&                    //   if x = '10',
    !a[--n] ?                   //   then decrement n; if a[n] is undefined:
      [1, 0]                    //     yield [1, 0]
    :                           //   else:
      x                         //     yield the mark unchanged
  )                             // end of flatMap()

JavaScript (ES6),  64  59 byte

5 byte salvati grazie a @ guest271314

Accetta input come (n)(line).

n=>g=([...s])=>1/s[n]?g(eval(`[${s}]`.replace('1,0',10))):s

Provalo online!

Commentate

n =>                            // main function, taking n
  g = ([...s]) =>               // g = recursive function, taking s
                                //     (which is either a string or an array)
    1 / s[n] ?                  // if s[n] is defined (i.e. we have too many marks):
      g(                        //   do a recursive call to g:
        eval(                   //     build a new array by evaluating ...
          `[${s}]`              //       ... the string representation of s[] where the
          .replace('1,0', 10)   //       first occurrence of '1,0' is replaced with '10'
        )                       //     end of eval()
      )                         //   end of recursive call
    :                           // else:
      s                         //   return s
— Arnauld
fonte
Perché l'output per N = 3 e line = '1010' è con tipi misti [1, 0, '10']?
— mdahmoune,
s.match()restituisce un array di stringhe ma a "10"può essere suddiviso in [1,0](2 numeri interi) nella funzione di callback di flatMap().
— Arnauld,
1
Possiamo forzare tutto in numeri interi per +1 byte .
— Arnauld,
59 byteeval(`[${s}]`.replace('1,0',10))
— ospite271314
@ guest271314 Grazie! Bella presa.
— Arnauld,
2

Java (OpenJDK 8) , 78 byte

Un bel one-liner che utilizza l'API stream.

(n,l)->l.join(":",l.split("10",l.length()-n+1)).chars().map(i->i-48).toArray()

Provalo online!

Come funziona

(n,l)->                     // Lambda function taking int and string
  l.join(":",               // Join the following array with colons
    l.split("10",           // Split the original string on "10"...
      l.length()-n+1))      // But limit the parts to the difference between the length
                            // and expected length, to only remove  required number of 10s              
  .chars()                  // Convert to an intstream of codepoints
  .map(i->i-48)             // Remove 48 to get the numeric value of each codepoint
  .toArray()                // Return an int array
— Luke Stevens
fonte
2

R , 63 byte

Mentre la lunghezza della stringa è maggiore di n, sostituisci il prossimo 10 che raggiungi con un ":"(il carattere ASCII dopo 9). Quindi suddividere in numeri prendendo il valore ASCII di ciascun carattere nella stringa.

function(n,x){while(nchar(x)>n)x=sub(10,":",x);utf8ToInt(x)-48}

Provalo online!

— J.Doe
fonte
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.