Desafio

Mark é um aluno que recebe suas Nnotas de forma concatenada em uma única linha.

O desafio é separar suas marcas, sabendo que cada marca só pode ser 0ou 1ou 2ou 3ou 4ou 5ou 6ou 7ou 8ou 9ou 10.

Entrada

N número natural e uma linha.

Saída

Um conjunto de números naturais.

Exemplo

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]

Regras

• Quando várias saídas são possíveis, dê apenas uma saída.
• Somente a marca do valor 10está em duas casas decimais, outras estão em uma casa decimal.
• A entrada e saída podem ser fornecidas em qualquer formato conveniente
• Não há necessidade de lidar com entradas inválidas
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Braquilog , 23 21 bytes

-2 bytes graças a Fatalize

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

Experimente online!

A entrada é um par [Line, N].

Este é o meu primeiro programa Brachylog, então provavelmente há muito espaço para melhorias.

É muito lento quando o comprimento da linha> 7.

Explicação:

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 se não há zeros à esquerda. Ele converte a string em número inteiro e depois volta para a string e compara com a string original.

Perl 6 , 25 bytes

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

Experimente online!

Bloco de código anônimo que pega um número e uma string e retorna como um objeto Match.

Explicação:

->\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

Python 3 , 47 bytes

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

Experimente online!

Pega a "linha única" como uma bytestring com bytes brutos \x00 - \x09 . Se não for aceitável:

Python 3 , 56 bytes

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

Experimente online!

Toma "uma linha" como bytestring.

V , 17 , 12 bytes

\ÓòÀGjí1“î…0

Experimente online!

Eu estava contente com 17 bytes, mas 05AB1E veio com 13, e não pude deixar um desafio sem resposta. : 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

Solução alternativa:

\ÓòÀGjç1î0/J

Infelizmente, isso substitui 10por1 0

Ruby , 57 bytes

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

Experimente online!

Pode não ser a abordagem mais eficiente, mas parece uma idéia divertida substituir temporariamente 10um hexágono A, o que aliás também é uma marca alta (se considerarmos o sistema de classificação AF :))

Haskell , 68 bytes

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

Experimente online!

Avidamente leva 10 segundos, desde que haja mais dígitos do que marcas restantes.

JavaScript, 57 52 bytes

n=>g=s=>s[n]?g(s.replace(x=10,`x`)):[...s].map(eval)

Experimente Online

Python 3 , 71 68 59 bytes

abaixo outros 9 bytes graças ao ovs.

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

Experimente online!

Eu estava inicialmente tentando usar str.partition()recursivamente, mas replaceme deu um tapa na cara pouco tempo depois. Alguém pode melhorar isso?

Além disso, aqui está um link TIO que eu usei para transformar os casos de teste em algo mais copiável / colável

Haskell , 98 bytes

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

Experimente online ou teste tudo!

Explicação

A função sfaz todas as divisões possíveis, por exemplo: "1010"torna - se [[1,0,1,0],[10,1,0],[1,0,10],[10,10]], observe como as divisões mais longas terminam no início (porque 1:0:yvem antes 10:y).

Com isso em mente, podemos pegar todos esses valores e filtrar os pontos yonde y == take n ytambém mantém divisões menores que o necessário. Por exemplo, com 4deixamos a lista igual [[1,0,1,0],[10,1,0],[1,0,10],[10,10]].

Agora podemos apenas obter o primeiro elemento dessa lista porque as entradas sempre serão válidas (por exemplo 5!"1010", [1,0,1,0]também dariam , mas não precisamos lidar com isso).

Nota: De alguma forma, eu contei errado. Tem y==take n yo mesmo comprimento de length y==n: S

Perl 5 -plF , 39 bytes

$a=<>;$_="@F";s/1 0/10/ while$a-1<y/ //

Experimente online!

Limpo , 128 bytes

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]

Experimente online!

05AB1E , 13 bytes

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

Experimente online! ou como testes

Explicação

.œ              # 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

JavaScript (Nó Babel) ,  70 69  59 bytes

Toma entrada como (n)(line).

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

Experimente online!

Comentado

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 bytes

Guardado 5 bytes graças a @ guest271314

Toma entrada como (n)(line).

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

Experimente online!

Comentado

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

Java (OpenJDK 8) , 78 bytes

Um bom one-liner usando a API de fluxos.

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

Experimente online!

Como funciona

(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

R , 63 bytes

Enquanto o comprimento da string for maior que n, substitua os próximos 10 que você alcançar por um ":"(o caractere ASCII após 9). Em seguida, divida em números, obtendo o valor ASCII de cada caractere na sequência.

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

Experimente online!

Vermelho , 91 bytes

func[n s][while[n < length? s][replace s"10""a"]foreach c s[prin[either c =#"a"[10][c]""]]]

Experimente online!

Geléia , 18 bytes

Ḍ⁵⁻ƊƝr1ŒpS‘⁼ɗƇḢk⁸Ḍ

Experimente online!