Lettres de signe de chapiteau

41

Chaque jour, vous mettez un nouveau mot sur une enseigne avec des lettres mobiles , vous n'achetez que les lettres dont vous avez besoin pour l'écrire. Vous réutilisez les lettres que vous avez achetées pour les mots précédents autant que possible. En fonction des mots que vous souhaitez écrire chaque jour dans l’ordre, imprimez les lettres que vous achetez chaque jour.

Exemple

Input:  ['ONE', 'TWO', 'THREE', 'SEVENTEEN']
Output: ['ENO', 'TW', 'EHR', 'EENSV']

Jour 1: Vous commencez sans lettres, pour ainsi écrire ONE, vous achetez toutes ses lettres E, N, O.
Jour 2: Le lendemain, vous voulez mettre en place TWO (en bas de la ONE). Vous avez déjà un Ode ONE, si vous achetez un montant supplémentaire TW.
Jour 3: À ce stade, vous avez ENOWT. Pour écrire THREE, il vous faut EHR. Notez que vous devez en acheter une seconde Een plus de celle que vous avez.
Jour 4: Pour écrire SEVENTEEN, vous avez besoin Edu total de 4 dont vous avez déjà deux (pas trois!), Vous en achetez donc deux de plus. Vous avez également la Tet l' un des N« s, de sorte que vous achetez les lettres restantes: EENSV.

Dans cet exemple, nous avons imprimé des lettres triées par ordre alphabétique, mais vous pouvez les afficher dans n'importe quel ordre.

Entrée: Une liste non vide de chaînes de lettres non vides A-Z. Vous pouvez utiliser des minuscules si vous préférez. Les listes de caractères conviennent aux chaînes.

Sortie: Créez ou imprimez les lettres supplémentaires que vous devez acheter chaque jour. Les lettres d'un jour peuvent être sorties dans n'importe quel ordre, mais les jours doivent être dans le bon ordre.

Les lettres de chaque jour doivent être séparées des autres jours pour que vous puissiez dire où se termine une journée. Un séparateur de fuite et / ou de tête est acceptable, dans la journée ou entre les jours. Notez qu'un jour peut ne pas avoir acheté de lettres, ce qui devrait être reflété dans la sortie (un espace ou une ligne vide est correct, même pour le dernier jour).

Cas de test

['ONE', 'TWO', 'THREE', 'SEVENTEEN']
['ENO', 'TW', 'EHR', 'EENSV']

['ONE', 'TWO', 'ONE', 'THREE']
['ENO', 'TW', '', 'EHR']

['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC']
['ABC', 'A', 'B', 'C', '']

['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']
['HORST', 'GLNO', 'OO', 'OOO', '', '']

Voici toutes les entrées et sorties sous forme de listes séparées:

[['ONE', 'TWO', 'THREE', 'SEVENTEEN'], ['ONE', 'TWO', 'ONE', 'THREE'], ['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC'], ['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']]
[['ENO', 'TW', 'EHR', 'EENSV'], ['ENO', 'TW', '', 'EHR'], ['ABC', 'A', 'B', 'C', ''], ['HORST', 'GLNO', 'OO', 'OOO', '', '']]

Et en tant que chaînes séparées par des espaces (les espaces de fin dans les sorties importent):

ONE TWO THREE SEVENTEEN
ONE TWO ONE THREE
ABC AABC ABBC ABCC AABBCC
SHORT LOONG LOOOONG LOOOOOOONG SHORT LOOONG

ENO TW EHR EENSV
ENO TW  EHR
ABC A B C 
HORST GLNO OO OOO

Classements

Afficher l'extrait de code

code-golf  string 
— Xnor
source
5
Un script de classement sauvage est apparu dans l'ère de l'utilisateur: o
— Quintec
Pouvons-nous afficher un tableau de caractères à acheter plutôt qu'une chaîne de caractères? Par exemple:[['E', 'N', 'O'], ...]
— Downgoat
La sortie est-elle SHORTLONGOOOOOvalide pour la dernière sortie? AKA n'utilisant pas de délimiteurs?
— Urne Magic Octopus
@Downgoat Oui, les listes de caractères sont corrects pour la sortie.
— xnor
@MagicOctopusUrn Non, vous avez besoin de délimiteurs, sinon vous ne pouvez pas savoir quelles lettres sont pour quel jour.
— xnor

Réponses:

10

Haskell, 54 à 49 octets

import Data.List
g x=zipWith(\\)x$scanl(++)""$g x

Essayez-le en ligne!

Nous construisons la liste de sortie en calculant par paire la différence de liste ( \\) de la liste d’entrée et l’addition cumulative de la liste de sortie (en commençant par "").

input list:                ONE       TWO       THREE        SEVENTEEN
cumulative append:         ""   +->  ONE  +->  ONETW   +->  ONETWHRE
list difference (output):  ONE -+    TW  -+    HRE    -+    SVEEN

Avec Data.Listet Data.Functiondans la portée (par exemple en utilisant l'environnement lambdabot), cela peut être réduit à 30 octets:

fix.(.scanl(++)"").zipWith(\\)

Edit: -5 octets grâce à @Sriotchilism O'Zaic.

— nimi
source
— Assistant de blé
10

Python 2 , 72 68 octets

-4 octets grâce à Jonathan Allan.

p=''
for r in input():
 for x in p:r=r.replace(x,'',1)
 print r;p+=r

Essayez-le en ligne!

Commenté

l=input()       # the list of words to write
p=''            # p contains all letters we own
for r in l:     # for each word ...
  for x in p:   # for each letter we own ...
    r=r.replace(x,'',1)   # remove one occurence from the current word
  print r       # print the remaining word
  p+=r          # add the remaining chars to p
— ovs
source
3
for r in input():enregistre 4 octets.
— Jonathan Allan
7

Perl 6 , 44 octets

{$!=@;.map:{kxxv $!=.comb.Bag∖($⊎=$!):}}

Essayez-le en ligne!

Sortie sous forme de liste de listes de caractères.

Explication

{                                      } # Anonymous codeblock
 $!=@;                                   # Initialise $! to an empty list
      .map:{                          }  # Map each item in the input to
                    .comb                # The string split to characters
                         .Bag            # In a Bag
                             ∖           # Set minus
                              ($⊎=$!)    # The accumulated Bag of results
                 $!=                     # And save the result for the next item
            kxxv                     : # Then decompose the Bag into a list
— Jo King
source
2
Un motif de vote négatif serait apprécié
— Jo King
Pas le vainqueur, mais je vais dire que ce format de sortie est trop loin. Quelque chose comme Bag(E(2), N, S, V)il faudrait en fait montrer deux E pour être OK.
— xnor le
3
Quoi vraiment? Ce n'est que le format d'impression par défaut. Le résultat renvoyé est une liste non ordonnée contenant ces caractères (et pouvant contenir plusieurs caractères identiques). Je mettrai à jour le format de sortie pour mieux refléter cela, mais le vote négatif semble ridicule.
— Jo King
Enquêteur, pourriez-vous s'il vous plaît expliquer, s'agit-il d'I / O ou d'autre chose? À propos du format de sac, je ne connais pas Perl, est-ce courant pour les E / S dans les golfs Perl? En regardant les documents (mis en cache parce que le site est en panne), ils me paraissent être plutôt des dictés avec des comptes, semblables à ceux de Python collections.Counterque je n'avais pas l'intention d'autoriser en sortie. Peut-on facilement parcourir les éléments du sac avec la multiplicité, lancer une liste / tableau, afficher avec la multiplicité, etc.?
— xnor le
3
Downvote était une erreur, était censé être en place.
— Jonathan Allan
7

Haskell , 44 octets

import Data.List
foldl1(\a x->a++',':(x\\a))

Essayez-le en ligne!

La sortie est une chaîne comme ONE,TW,HRE,SVEENavec des virgules entre les jours.

— Lynn
source
1
Quelle belle utilisation du format de sortie pour éviter de devoir plier le \`. And an unexpected cas de base de foldl1` aussi.
— xnor
7

JavaScript (Node.js) , 59 octets

a=>a.map(h=>([...t].map(c=>h=h.replace(c,'')),t+=h,h),t='')

Essayez-le en ligne!

Solution assez simple. Pour chaque mot h, supprimez les lettres que nous avons déjà.

Voici une version expliquée de ce code:

f = list => {
  // the string that accumulates all the letters already bought
  let accu = '';
  // for every word in the list
  return list.map( word => {
    // for every letter already bought 
    [...accu]
      // remove the letter from the word
      .map(char => {
        return word = word.replace(char,'')
      });
    // add not bought letters to accumulator
    accu += word;
    // the reduced word (without already bought letters) should be added to result map
    // this represents the letters to buy today
    return word
  }, accu)
}

console.log(f(['ONE', 'TWO', 'THREE', 'SEVENTEEN']))
console.log(f(['ONE', 'TWO', 'ONE', 'THREE']))
console.log(f(['ABC', 'AABC', 'ABBC', 'ABCC', 'AABBCC']))
console.log(f(['SHORT', 'LOONG', 'LOOOONG', 'LOOOOOOONG', 'SHORT', 'LOOONG']))
Développer l'extrait

— tsh
source
Vous pouvez économiser 1 octet en empruntant le seul truc qui vaille la peine de ma solution par ailleurs trop compliquée.
— Arnauld le
5

J , 29 octets

-29 octets grâce à FrownyFrog!

(],a.<@#~0>.-&(1#.a.=/;))/@|.

Essayez-le en ligne!

Poste originale

J , 58 octets

[:}.@>[:(],<@(/:~@({.@>@-.&(((e.<@#[){:)\));))&.>/<@a:,~|.

Essayez-le en ligne!

Merci à ngn pour son aide dans l’amélioration de "Soustraire des lettres tout en respectant les répétitions".

Pas un ajustement idéal pour J, mais un exercice éclairant.

Commençons par construire un verbe d'assistance wo("sans") qui supprime tous les chacters d'une chaîne à une autre, tout en respectant les répétitions. 

wo=.{.@>@-.&(((e. <@# [) {:)\)

Il existe une idée amusante: nous faisons en sorte que chaque instance répétée d’un caractère soit unique en la répétant le nombre de fois requis. Ainsi, si notre chaîne d'origine est la suivante ABBA:

┌─┬─┬──┬──┐
│A│B│BB│AA│
└─┴─┴──┴──┘

Un tiers Adeviendrait AAAet ainsi de suite. Ceci est accompli par la phrase ((e. <@# [) {:)\, qui prend chaque préfixe \, examine son dernier élément {:et construit un masque de tous les éléments de ce préfixe correspondant à e.cet élément final, puis filtre et encadre uniquement ces éléments <@#.

Avec nos entrées "unique-ified", nous pouvons maintenant utiliser en toute sécurité l'ensemble moins normal -. tout en respectant les répétitions.

Nous ouvrons ensuite chaque résultat et prenons seulement le premier élément pour "annuler" nos répétitions: {.@>

En branchant ce verbe auxiliaire, notre solution globale (qui le met simplement en ligne) devient:

[: }.@> [: (] , <@(/:~@wo ;))&.>/ <@a: ,~ |.

En gros, tout ce que nous faisons ici est de régler notre problème en une seule réduction. Nous commençons à inverser l’entrée |.et à y ajouter ,~un as a:, ou une boîte vide, qui sera la valeur initiale de notre résultat final, comme ceci:

┌─────────┬─────┬───┬───┬──┐
│SEVENTEEN│THREE│TWO│ONE│┌┐│
│         │     │   │   ││││
│         │     │   │   │└┘│
└─────────┴─────┴───┴───┴──┘

Nous collons le verbe suivant entre chaque élément pour effectuer la réduction:

(] , <@(/:~@wo ;))/

Cela dit: prenez la bonne entrée ](c'est-à-dire notre résultat) et ajoutez à celle , - ci l'entrée de gauche (c'est ONEà la première itération, TWOà la 2ème, etc.) sans wole raze de ;l'entrée de droite (c'est-à-dire sans lettres précédentes jusqu'à présent) utilisé), mais avant l’ajout, triez-le /:~et remettez -le en boîte <@.

À la fin de tout cela, nous aurons le résultat souhaité, une liste de boîtes, mais le tout dans une grande boîte supplémentaire, et toujours avec la boîte vide à l'avant. Ainsi , nous ouvrons pour enlever la boîte extérieure et de tuer le premier élément: }.@>.

— Jonas
source
[:}.@>|.(],a.<@#~0>.-&(1#.a.=/;))&.>/@,<@a:
— FrownyFrog le
Un simple (],a.<@#~0>.-&(1#.a.=/;))/@|.fonctionne également à moins que je manque un cas de bord.
— FrownyFrog le
Autant que je sache, le tri n’est nulle part dans les exigences.
— FrownyFrog
2
Mis à jour et maintenant que j'ai eu le temps de l'absorber, je voulais juste dire à nouveau: C'est sacrément gentil J!
— Jonas
4

JavaScript (ES6),  66 à  65 octets

a=>a.map(b=s=>[...s].filter(c=>x==(x=x.replace(c))?b+=c:0,x=b+0))

Essayez-le en ligne!

Commenté

bbXcXb

a =>                      // a[] = input
  a.map(b =               // initialize b to the callback function of this map()
                          // it will be coerced to a string that does not contain
                          // any letter in uppercase
    s =>                  // for each entry s in a[]:
    [...s].filter(c =>    //   for each character c in s:
      x == (              //     check whether x is changed when
        x = x.replace(c)  //     c is replaced with 'undefined'
      ) ?                 //     if so:
        b += c            //       append c to b and keep c
      :                   //     else:
        0,                //       discard c
      x = b + 0           //     coerce b to a string and save it in x
    )                     //   end of filter()
  )                       // end of map()
— Arnauld
source
4

C ++ (gcc) , 177 170 octets

-5 octets grâce au conseil de @ anatolyg, -2 octets aux petites choses que j'ai remarquées.

#import<random>
#define v std::vector<std::string>
v a(v p){std::vector<int>o(91),b;int j=-1;for(auto i:p){b=o;p[++j]="";for(int c:i)--b[c]<0?p[j]+=c,++o[c]:0;}return p;}

Explication

#import<random> ajoute les deux <string> et <vector>pour la moitié des octets.

Crée tout d'abord un vecteur 0 de 91 éléments (seuls les indices 65 à 90 permettent de stocker les occurrences de lettres), ainsi qu'un autre vecteur du même type, mais non défini sur une valeur. Parcourt chaque élément de l'entrée (les jours): récupère les lettres actuellement possédées, récupère les lettres nécessaires pour la journée, remplace l'entrée de l'index par le montant nécessaire et met à jour les lettres possédées. Retourne l'entrée remplacée.

Essayez-le en ligne!

— Neil A.
source
Vous pouvez faire #define v std::vector<std::stringet supprimer using namespace stdpour réduire le nombre d'octets de 6 octets.
— anatolyg
2

C # (compilateur interactif Visual C #) , 123 octets

a=>{var b="";for(dynamic i=0,e,f;i<a.Count;b+=a[i++]=f)foreach(var c in((e,f)=(b.ToList(),"")).f+a[i])f+=e.Remove(c)?"":c;}

Essayez-le en ligne!

Fonction anonyme qui sort en modifiant un tableau d’entrée.

// a: input array of strings
a=>{
  // b: cumulative letters
  var b="";
  for(
    // i: loop index of string
    // e: copy of cumulative letters for manipulation
    // f: characters missing from current string
    dynamic i=0,e,f;
    // iterate over each string in a
    i<a.Count;
    // add missing letters of the day to
    // cumulative missing letters and
    // update array for output
    b+=a[i++]=f
  )
    // iterate current string with character c
    foreach(var c in
      // tuplized variable assignment
      // e=b.ToList()
      //   set e to a copy of the cumulative letters
      // f=""
      //   initially there are no letters needed for the day
      ((e,f)=
      (b.ToList(),"")).f+a[i]
    )
      // conditionally add c to missing letters for the day
      f+=e.Remove(c)?"":c;
}
— Dana
source
2

R, 119 112 106 103 octets

-7 octets à partir de l'aliasing des deux noms de fonction plus longs et prenant à présent une entrée utilisateur de scan()
-6 octets à un appel seulementstrsplit() une fois au début
-3 octets pour supprimer à nouveau l'alias et attribuer deux variables en un seul appel

(Édite également le nombre d'octets qui était erronément bas auparavant)

a=scan(,'');b=a=strsplit(a,'');for(i in 2:length(a))b[[i]]=vecsets::vsetdiff(a[[i]],unlist(b[1:i-1]));b

Ceci est ma toute première soumission PPCG, quelle qu'elle soit! Donc, je n'ai aucune idée de ce que je fais à la fois en termes de golf et en termes d'affichage. Le résultat est une liste de vecteurs qui peuvent ou non répondre aux conditions du défi. :-P

Quant au code lui-même, il prend les entrées de l'utilisateur via scan()et compare les lettres de chaque nouveau jour aux lettres cumulées, comme dans d'autres solutions. S'il existe des alternatives plus courtes à unlistet strsplitpour la conversion de chaînes dans des vecteurs de caractères individuels qui serait cool de savoir. J'ai également utilisé la vsetdifffonction du vecsetspackage de Carl Withoft pour obtenir la différence entre les lettres nécessaires pour le lendemain et les lettres en cours possédées.

— qdread
source
1
non, c'est parfaitement bien. Je suis un peu réticent à utiliser des packages externes, mais c'est juste moi ... je préfère aborder les défis en code de base R;)
— digEmAll
1
— digEmAll
1
— digEmAll
1
— digEmAll
1
— digEmAll
2

PowerShell , 71 octets

$args|%{$w=$_;$p|% t*y|%{$w=$w-replace"^(.*?)$_(.*)",'$1$2'};$w;$p+=$w}

Essayez-le en ligne!

Prend les mots d’entrée $argset les itère. Chaque itération, nous définissons le mot actuel $w, puis en boucle sur notre liste $pde lettres déjà achetées. Chaque boucle interne, nous effectuons une expression rationnelle -replacesur notre commande actuelle $w, de sorte que nous ne remplacions que la première instance de la lettre de notre $ppolice. Une fois que nous avons parcouru toutes les lettres du groupe, nous publions ce qui reste $w(c.-à-d. Ce que nous devons acheter), puis nous plaquons ces lettres sur notre groupe $p+=$wpour le mot suivant.

— AdmBorkBork
source
2

Japt , 15 14 octets

£Q®X=rZPPÃQ±XX

L'essayer

£Q®X=rZPPÃQ±XX     :Implicit input of array
£                  :Map each X
 Q®                :  Map each Z in Q (initially a quotation mark)
   X=              :    Reassign to X
     rZ            :    Replace Z with
       P           :    The empty string
        P          :    With the default global flag disabled
         Ã         :  End map
          Q±X      :  Append X to Q
             X     :  Return X
— Hirsute
source
1
@Downvoter, s'il vous plaît avoir la décence de laisser un commentaire.
— Shaggy
1

Excel VBA, 127 octets

Function z(w)
z=""
For Each x In w.Cells
v=x.value
For y=1To Len(z)
v=Replace(v,Mid(z,y,1),"",1,1)
Next
z=z&v
Next
End Function

Prend la forme d'une gamme Excel.

— William Porter
source
1

C (gcc) , 118 octets

m(a,r,q,u)char**a,*r,*q,*u;{for(;*a;a++,memcpy(r,q,255))for(memcpy(q,r,255),u=*a;*u;u++)*u=r[*u]-->0?32:(q[*u]++,*u);}

Essayez-le en ligne!

En prime, le stock est stocké rau départ sous forme de tableau. Sort la liste d'entrée terminée par un caractère nul, terminée par un zéroa avec toutes les lettres usagées remplacées par des espaces.

— LambdaBeta
source
— ceilingcat
1

Swift 4.2 / Xcode 10.2 , 244 242 239 238 octets

a.reduce(([Character:Int](),[String]())){c,l in let b=l.reduce(into:[Character:Int]()){$0[$1,default:0]+=1}.map{($0,max(0,$1-(c.0[$0] ?? 0)))};return(c.0.merging(b){$0+$1},c.1+[b.map{String(Array(repeating:$0.0,count:$0.1))}.joined()])}.1

Essayez-le en ligne!

Les lettres ne sont pas classées par ordre alphabétique, les règles ne l'interdisent pas.

— Roman Podymov
source
1

Scala, 68 octets

(c:Seq[String])=>c./:(Seq(""))((a,n)=>a:+n.diff(a./:("")(_+_))).tail

Essayez-le en ligne!

/: est un raccourci pour l'opérateur foldLeft, a est l'agrégation, renvoie finalement le résultat souhaité, n est l'élément suivant

Non-golfé

def NewLettersPerDay(c: Seq[String]): Seq[String] = {
    c.foldLeft(Seq(""))((agg, next) => {
      val existingLetters = agg.reduce(_+_)
      val newDayLetters = next.diff(existingLetters)
      agg :+ newDayLetters
    }).tail
}
— sprague44
source
0

Charbon de bois , 18 octets

ＥθΦι¬⊙…θκ‹№…ιμλ№νλ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

 θ                  Input array
Ｅ                   Map over strings
   ι                Current string
  Φ                 Map over characters
       θ            Input array
      …             Truncated to length
        κ           Outer index
    ¬               Logical Not
     ⊙              Any element exists where
          №         Count of
              λ     Current letter in
            ι       Outermost word
           …        Truncated to
             μ      Current letter index
         ‹          Is less than
               №    Count of
                 λ  Current letter in
                ν   Innermost word
                    Implicitly print each day's bought letters on their own line
— Neil
source
0

Compatible PHP, UTF-8 (253 octets)

<?php $p=[];for($i=1;$i<$argc;$i++){$a=$p;$b=[];for($j=0;$j<mb_strlen($s=$argv[$i]);$j++){$k=1;if(isset($a[$c=mb_substr($s,$j,1)]))if($a[$c]){$k=0;$a[$c]--;}if($k){echo $c;if(isset($b[$c]))$b[$c]+=$k;else $b[$c]=$k;}}$p=array_merge($p,$b);echo PHP_EOL;}
— rexkogitans
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.