Reto

Mark es un estudiante que recibe sus Ncalificaciones de forma concatenada en una sola línea.

El desafío es separar sus marcas, sabiendo que cada marca solo puede ser 0o 1o 2o 3o 4o 5o 6o 7o 8o 9o 10.

Entrada

N Número natural y una línea.

Salida

Un conjunto de números naturales.

Ejemplo

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]

Reglas

• Cuando son posibles varias salidas, proporcione solo una salida.
• Solo la marca de valor 10está en dos decimales, otros están en un decimal.
• La entrada y la salida se pueden dar en cualquier formato conveniente
• No es necesario manejar entradas inválidas
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Brachylog , 23 21 bytes

-2 bytes gracias a Fatalize

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

Pruébalo en línea!

La entrada es un par [Line, N].

Este es mi primer programa Brachylog, por lo que probablemente haya mucho margen de mejora.

Es muy lento cuando la longitud de la línea> 7.

Explicación:

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 

(*) ịṫ?comprueba que no hay ceros a la izquierda. Convierte la cadena a entero y luego nuevamente a cadena y se compara con la cadena original.

Perl 6 , 25 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma un número y una cadena y regresa como un objeto Match.

Explicación:

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

Pruébalo en línea!

Toma la "una línea" como una cadena de bytes con bytes sin procesar \x00 - \x09. Si no es aceptable:

Python 3 , 56 bytes

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

Pruébalo en línea!

Toma "una línea" como cadena de bytes.

V , 17 , 12 bytes

\ÓòÀGjí1“î…0

Pruébalo en línea!

Estaba contento con 17 bytes, pero 05AB1E llegó con 13, y no podía dejar que un desafío quedara sin respuesta. :RE

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

Solución alternativa:

\ÓòÀGjç1î0/J

Desafortunadamente, esto reemplaza 10con1 0

Ruby , 57 bytes

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

Pruébalo en línea!

Puede que este no sea el enfoque más golfista, pero parece una idea divertida sustituir temporalmente 10un hexadecimal A, que por cierto también es una calificación alta (si consideramos el sistema de calificación 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!_=[]

Pruébalo en línea!

Avariciosamente, toma 10s siempre que haya más dígitos que marcas restantes.

JavaScript, 57 52 bytes

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

Pruébalo en línea

Python 3 , 71 68 59 bytes

abajo otros 9 bytes gracias a los ovs.

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

Pruébalo en línea!

Inicialmente estaba tratando de usar str.partition()recursivamente, pero el uso replaceme golpeó en la cara no mucho después. ¿Alguien puede mejorar en esto?

Además, aquí hay un enlace TIO que utilicé para convertir los casos de prueba en algo más copiable / pegable

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

¡Pruébalo en línea o prueba todo!

Explicación

La función srealiza todas las divisiones posibles, por ejemplo: se "1010"convierte en [[1,0,1,0],[10,1,0],[1,0,10],[10,10]], observe cómo terminan las divisiones más largas al principio (porque 1:0:yviene antes 10:y).

Con eso en mente, podemos tomar todos estos valores y filtrar los ycorreos electrónicos donde se y == take n ymantienen las divisiones que son más cortas de lo requerido. Por ejemplo con 4dejamos la lista igual [[1,0,1,0],[10,1,0],[1,0,10],[10,10]].

Ahora podemos obtener el primer elemento en esa lista porque las entradas siempre serán válidas (por ejemplo 5!"1010", [1,0,1,0]también darían , pero no necesitamos manejarlo).

Nota: de alguna manera conté mal ... y==take n ytiene la misma longitud quelength y==n : S

Perl 5 -plF , 39 bytes

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

Pruébalo en línea!

Limpio , 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]

Pruébalo en línea!

05AB1E , 13 bytes

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

.œ              # 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 (nodo de 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)

Pruébalo en línea!

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 gracias a @ guest271314

Toma entrada como (n)(line).

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

Pruébalo en línea!

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

Un buen one-liner usando la API de streams.

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

Pruébalo en línea!

Cómo 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

Si bien la longitud de la cadena es mayor que n, sustituya los siguientes 10 que alcanza por a ":"(el carácter ASCII después de 9). Luego se divide en números tomando el valor ASCII de cada carácter en la cadena.

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

Pruébalo en línea!

Rojo , 91 bytes

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

Pruébalo en línea!

Jalea , 18 bytes

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

Pruébalo en línea!