Fractionner les marques de Mark

21

Défi

Mark est un étudiant qui reçoit ses Nnotes de manière concaténée sur une seule ligne.

L'enjeu est de séparer ses marques, sachant que chaque marque ne peut être que 0ou 1ou 2ou 3ou 4ou 5ou 6ou 7ou 8ou 9ou 10.

Contribution

N nombre naturel et une ligne.

Production

Un ensemble de nombres naturels.

Exemple

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]

Règles

  • Lorsque plusieurs sorties sont possibles, ne donnez qu'une seule sortie.
  • Seule la marque de valeur 10est sur deux décimales, les autres sont sur une décimale.
  • L'entrée et la sortie peuvent être données dans n'importe quel format pratique
  • Pas besoin de gérer une entrée invalide
  • Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
  • Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
  • Les failles standard sont interdites.
  • Il s'agit de donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) gagne.
mdahmoune
la source
Voici un extrait n, 'string'de code Python que j'ai utilisé pour obtenir les paires à partir du bloc de texte d'exemple copypasté:spl = [item.split('-')[0] for item in text.split('\n')]
Gigaflop
3
Plz quelques commentaires pour les votes
négatifs
Les downvotes ne nécessitent pas de laisser des commentaires pour une raison. Il n'y a rien qui puisse être amélioré dans ce défi.
user202729
Alors ne vous en faites pas.
user202729
Les sorties doivent-elles être dans le même ordre que l'entrée?

Réponses:

6

Brachylog , 23 21 octets

-2 octets grâce à Fatalize

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

Essayez-le en ligne!

L'entrée est une paire [Line, N].

Ceci est mon premier programme Brachylog, donc il y a probablement beaucoup de place pour l'amélioration.

Il est très lent lorsque la longueur de la ligne> 7.

Explication:

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 

(*) ịṫ?vérifie qu'il n'y a pas de zéros non significatifs. Il convertit la chaîne en entier, puis revient en chaîne et la compare à la chaîne d'origine.

fergusq
la source
Vous n'avez pas besoin d'entrer le nombre sous forme de chaîne, utilisez simplement un entier. Ceci évite la nécessité pour tous ceux et pour le premier contrôle zéro: h~c.{ℕ≤10}ᵛ&t~l. Cela est probablement plus lent, car la déconcaténation sur les entiers doit fonctionner même pour les entiers inconnus par le biais de contraintes, ce qui la rend inefficace.
Fatalize
(Notez également que l'utilisation de het tpour obtenir le premier / dernier élément est plus efficace que l'utilisation des deux (ce qui, dans la plupart des programmes, ne fonctionnera même pas)).
Fatalize
@Fatalize J'ai compris que la ligne d'entrée peut contenir des zéros non significatifs, il ne serait donc pas possible d'utiliser un entier comme entrée.
fergusq
C'est ennuyeux…
Fatalize
5

Perl 6 , 25 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui prend un nombre et une chaîne et renvoie en tant qu'objet Match.

Explication:

->\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
la source
5

Python 3 , 47 octets

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

Essayez-le en ligne!

Prend la "une ligne" comme un bytestring avec des octets bruts \x00 - \x09. Si ce n'est pas acceptable:

Python 3 , 56 octets

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

Essayez-le en ligne!

Prend "une ligne" comme bytestring.

Bubbler
la source
5

V , 17 , 12 octets

\ÓòÀGjí1“î…0

Essayez-le en ligne!

J'étais content avec 17 octets, mais 05AB1E est venu avec 13, et je ne pouvais pas laisser un défi sans réponse. :RÉ

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

Solution alternative:

\ÓòÀGjç1î0/J

Malheureusement, cela remplace 10par1 0

DJMcMayhem
la source
4

Rubis , 57 octets

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

Essayez-le en ligne!

Cela peut ne pas être l'approche la plus golfique, mais cela ressemble à une idée amusante de remplacer temporairement 10un hex A, qui est d'ailleurs une note élevée (si l'on considère le système de classement AF :))

Kirill L.
la source
4

Haskell , 68 octets

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

Essayez-le en ligne!

Goulûment, prenez 10 secondes tant qu'il reste plus de chiffres que de marques.

Nitrodon
la source
4

Python 3 , 71 68 59 octets

vers le bas encore 9 octets grâce à ovs.

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

Essayez-le en ligne!

J'essayais initialement de l'utiliser de str.partition()manière récursive, mais l'utilisation replacem'a frappé au visage peu de temps après. Quelqu'un peut-il améliorer cela?

En outre, voici un lien TIO que j'ai utilisé pour transformer les cas de test en quelque chose de plus copiable / collable

Gigaflop
la source
1
-3 octets: supprimer l'espace entre : [cet 'x' elseet10 for
mdahmoune
@mdahmoune Merci de l'avoir remarqué, j'ai du mal à me souvenir de ce qui peut être écrasé ensemble.
Gigaflop
8
Règle générale: en gros, tout sauf deux lettres peut être écrasé ensemble. Si vous obtenez une erreur de syntaxe, ajoutez des espaces aléatoires jusqu'à ce que cela fonctionne :)
Quintec
Il y a quelques exceptions comme <number>e, <letter><number>, f'.
user202729
3
59 octets en remplaçant 10 avec une et la lecture de chaque caractère en tant que base 11 int: lambda n,s:[int(c,11)for c in s.replace('10','a',len(s)-n)].
2018
3

Haskell , 98 octets

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

Essayez-le en ligne ou testez tout!

Explication

La fonction seffectue toutes les divisions possibles, par exemple: "1010"devient [[1,0,1,0],[10,1,0],[1,0,10],[10,10]], notez comment les divisions les plus longues finissent au début (car 1:0:yvient avant10:y ).

En gardant cela à l'esprit, nous pouvons prendre toutes ces valeurs et filtrer les ys là où y == take n ycela conserve également les divisions plus courtes que nécessaire. Par exemple avec4 nous laissons la liste la même [[1,0,1,0],[10,1,0],[1,0,10],[10,10]].

Maintenant, nous pouvons simplement obtenir le premier élément de cette liste, car les entrées seront toujours valides (par exemple 5!"1010", donnerait[1,0,1,0] aussi, mais nous n'avons pas besoin de le gérer).

Remarque: j'ai en quelque sorte mal compté .. y==take n yest de la même longueur que length y==n: S

ბიმო
la source
2

Nettoyer , 128 octets

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]

Essayez-le en ligne!

Οurous
la source
2

05AB1E , 13 octets

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

Essayez-le en ligne! ou comme suite de tests

Explication

.œ              # 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
la source
2

JavaScript (nœud Babel) ,  70 69  59 octets

Prend l'entrée comme (n)(line).

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

Essayez-le en ligne!

Commenté

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 octets

5 octets enregistrés grâce à @ guest271314

Prend l'entrée comme (n)(line).

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

Essayez-le en ligne!

Commenté

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
la source
Pourquoi la sortie pour N = 3 et line = '1010' est avec des types mixtes [1, 0, '10']?
mdahmoune
s.match()renvoie un tableau de chaînes mais a "10"peut être divisé en [1,0](2 entiers) dans la fonction de rappel de flatMap().
Arnauld
1
Nous pouvons tout contraindre à des entiers pour +1 octet .
Arnauld
59 octetseval(`[${s}]`.replace('1,0',10))
guest271314
@ guest271314 Merci! Belle prise.
Arnauld
2

Java (OpenJDK 8) , 78 octets

Un joli one-liner utilisant l'API streams.

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

Essayez-le en ligne!


Comment ça marche

(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
la source
2

R , 63 octets

Alors que la longueur de la chaîne est supérieure à n , remplacez les 10 suivants par un ":"(le caractère ASCII après 9). Puis divisez-vous en nombres en prenant la valeur ASCII de chaque caractère de la chaîne.

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

Essayez-le en ligne!

J.Doe
la source
1

Rouge , 91 octets

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

Essayez-le en ligne!

Galen Ivanov
la source