Wygeneruj hasło

26

Bardzo trudno zapamiętać moje hasło, więc wymyśliłem sposób na wygenerowanie hasła.

Generuję moje hasło ze słowa lub zdania, wykonując następujące kroki:

  1. Zacznij od lewej do prawej

  2. Znajdź liczbę każdej litery

  3. Ułóż literę z jej liczbą w kolejności

    • Na końcu pojawią się litery o większej powtarzalności

    • Listy o tym samym powtórzeniu zostaną uporządkowane alfabetycznie

  4. Liczby i litery specjalne będą ignorowane, w tym spacje (np. 9, 4, @, (, * itd. Są ignorowane)

  5. Grupuj litery ignorując wielkość liter. W danych wyjściowych użyj przypadku ostatniego wystąpienia na wejściu

  6. Liczba liter może być dowolną liczbą, np. 5H17M345K
  7. Jeśli wejściowe są wszystkie cyfry lub litery specjalne, wówczas wyjściowy będzie pusty ciąg znaków, np. Wpisz „12 $ * 34 ^!” następnie wyślij „”
  8. gdy kolejność dla tego samego wystąpienia alfabetycznie nie ma znaczenia, np. 1a1B1c

Przykład:

Input: Kitkat Tango
(2k / 1i / 3T / 2a / 1n / 1g / 1o)
Output: 1g1i1n1o2a2k3T

Inny przykład:

Input: Database Partitions Task
(1D / 5a / 4T / 1b / 3s / 1e / 1P / 1r / 2i / 1o / 1n / 3s / 1k)
Output: 1b1D1e1k1n1o1P1r2i3s4T5a

Uwaga: litery z 1 powtórzeniem są na początku uporządkowane alfabetycznie, a następnie z większą liczbą powtórzeń

To jest , wygrywa najkrótszy kod.

asmgx
źródło
16
Czy list może pojawić się więcej niż 9 razy?
Kudłaty
3
@manatwork: Ale to nie jest niejasne (zauważ, że ich odpowiedź nie zakładała, że ​​litery pojawiają się mniej niż 10 razy), po prostu próbuje poluzować ograniczenia wprowadzania.
ბიმო
4
upewnij się, że dodałeś te wyjaśnienia do właściwego pytania, aby użytkownicy nie musieli przeszukiwać komentarzy
Jo King,
2
Komentarze nie stanowią specyfikacji. Musisz zaktualizować wyzwanie, aby 1.dodać co najmniej 1 przypadek testowy, który zawiera więcej niż 9 wystąpień jednej lub więcej liter, 2.określ, że dane wyjściowe muszą być ciągiem (chociaż zdecydowanie zalecałbym, aby nie być tak ścisłym; nie dodaje niczego do wyzwania ), 3.określ, że musimy być w stanie obsłużyć dane wejściowe nie zawierające liter, i 4.wyjaśnij, czy musimy obsłużyć pusty ciąg znaków jako dane wejściowe.
Kudłaty
1
Gdy to zrobisz, będziesz musiał przetestować wszystkie istniejące rozwiązania i poinformować je, jeśli będą musiały wprowadzić jakiekolwiek zmiany. Znalazłem już sporo rozwiązań, które zawodzą w punkcie 1. Ponadto w przyszłości możesz rozważyć skorzystanie z naszej piaskownicy w celu rozwiązania takich problemów przed opublikowaniem wyzwania.
Kudłaty

Odpowiedzi:

7

Japt v2.0a0 -P, 14 bajtów

f\l üv ñÊ®ÌiZÊ

Spróbuj

f\l üv ñÊ®ÌiZÊ     :Implicit input of string
                   > e.g., "Kitkat Tango"

f                  :Split to an array of characters
 \l                :  Matching RegEx /[a-z]/gi
                   > ["K","i","t","k","a","t","T","a","n","g","o"]

    ü              :Sort & group (Preserves original order within each group)
     v             :  By lowercase
                   > [["a","a"],["g"],["i"],["K","k"],["n"],["o"],["t","t","T"]]

       ñ           :Sort
        Ê          :  By length
                   > [["g"],["i"],["n"],["o"],["a","a"],["K","k"],["t","t","T"]]

         ®         :Map each Z
          Ì        :  Last element of Z
                   >   ["g","i","n","o","a","k","T"]
           i       :  Prepend
            ZÊ     :    Length of Z
                   >   ["1g","1i","1n","1o","2a","2k","3T"]

                   :Implicitly join & output
                   > "1g1i1n1o2a2k3T"
Kudłaty
źródło
10

05AB1E , 19 17 16 bajtów

Zaoszczędził 1 bajt dzięki Kevinowi Cruijssenowi

áΣl}.γl}éεgyθJ}J

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

á                  # keep only letters in input
 Σl}               # sort by lower-case
    .γl}           # group by lower-case
        é          # sort by length (stable)
         ε    }    # map each to
          g        # its length
             J     # joined with
           yθ      # the last letter
               J   # join to string
Emigna
źródło
Możesz zapisać bajt, zmieniając (paruj z) na «(konkat / scal), aby jedno z dwóch Js (złączeń) mogło zostać usunięte.
Kevin Cruijssen
@KevinCruijssen: Wow. Czuję się teraz głupio :) Dlaczego po prostu nie przeprowadziłem się do Jśrodka? Edycja: Właściwie potrzebowałem ich jako pary w wersji 19-bajtowej i nie pomyślałem o zmianie, kiedy zrobiłem 17: P
Emigna
W Jzależności od odpowiedzi na to pytanie
Shaggy
7

Perl 6 , 66 63 bajtów

{[~] map {+$_~.tail},sort {+$_,.lc},m:g/<:L>/.classify(&lc){*}}

Wypróbuj online!

Wyjaśnienie

{                                                             }  # Anon block
                                    m:g/<:L>/  # Match all letters
                                             .classify(&lc)  # Group by lowercase
                                                           {*}  # Get hash values
                     sort {+$_,.lc},  # Sort by array length and lowercase
     map {         },  # Map to
          +$_~.tail  # Concat array length and last letter
 [~]  # Join
nwellnhof
źródło
6

Siatkówka , 67 66 41 39 bajtów

\P{L}

O$`.
$l$0
ir`\1*(.)
$.0$1
N`\d+.

-25 bajtów i drobna poprawka dzięki @Neil .
-2 bajty dzięki @Neil i @Shaggy razem.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

Usuń wszystko oprócz wielkich i małych liter:
tj. Kitkat Tango 123!KitkatTango

\P{L}

Segregowanie poszczególne litery wielkości liter ( dzięki @MartinEnder na to ):
tzn KitkatTangoaagiKknottT

O$`.
$l$0

Uchwycić każdy kawałek wielkości liter wielokrotne sąsiednie litery:
tj aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Poprzedzić długość każdego meczu i tylko zachować ostatnią literę każdego fragmentu:
tj [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Posortuj liczby i grupy liter według liczb:
2a1g1i2k1n1o3T1g1i1n1o2a2k3T

N`\d+.

Po czym wynik jest dorozumiany.

Kevin Cruijssen
źródło
Jesteś pewien, że to błąd? Czy to nie tylko sortowanie leksykograficzne? ( "aA" < "aa")
Kudłaty
1
@Shaggy Nie jestem pewien, czy to możliwe. Ponieważ znaki „ \wi .O`\w.zostały użyte do wskazania, że ​​sortujemy pary znaków. Nie jestem pewien, czy możemy posortować każdą parę znaków, ale sortuj ją tylko na podstawie pierwszej postaci. Ale cóż, sugestia Martina, aby posortować każdą postać na podstawie podstawienia (która jest małą odmianą meczu) działa jak urok. :)
Kevin Cruijssen
1
Czy można to zrobić w 41 bajtach, czy coś mi brakuje?
Neil
2
@Shaggy Właściwie czytanie dalej, \P{L}może działać, co oszczędza 2 bajty.
Neil
4

Wolfram Language (Mathematica) , 102 96 93 87 bajtów

""<>Map@ToString/@Sort[(r=Reverse)/@Tally[r@#/." "->Nothing,Equal@@ToLowerCase@{##}&]]&

Wypróbuj online!

Tally[r@#/." "->Nothing,Equal@@ToLowerCase@{##}&]      Start with a char list
        #/." "->Nothing                                Remove spaces
      r@                                               Reverse the result
Tally[                 ,Equal@@ToLowerCase@{##}&]
                                             Make a list of letters and multiplicities,
                                             where two letters are considered the same if
                                             their lowercase values are equal. Then:

""<>Map@ToString/@Sort[(r=Reverse)/@ ... ]&
                       (r=Reverse)           Reverse each {letter, freq} to {freq,letter}.
                                             Then the standard Wolfram order function sorts
                                               lower frequencies first, with ties broken by
                                               by letters earlier in the alphabet,
                  Sort[                  ]     exactly what we want.

    Map@ToString/@                           @ has higher precedence than /@, so
                                               this effectively does Map[Map[ToString]].
""<>                                         StringJoin the nested list into a single string.
lirtosiast
źródło
4

Pyth, 27 24 22 bajtów

ssrD0m,lded.gr0k@+Gr1G

Wypróbuj online tutaj .

ssrD0m,lded.gr0k@+Gr1GQ   Implicit: Q=eval(input()), G=lowercase alphabet
                          Trailing Q inferred
                   r1G    Uppercase alphabet
                 +G       Concatenate with lowercase alphabet
                @     Q   Keep those characters in Q which are also in the above
           .g             Group the remaining characters, as k, using:
             r0k             Convert k to lowercase
                              (Grouping preserves relative order)
     m                    Map the sorted groups, as d, using:
       ld                   Length of d
      ,                     Pair the above with...
         ed                 ... last element of d
   D                      Sort the above...
  r 0                     ... by their lowercase values
ss                        Flatten, then concatenate the result of the above into a string, implicit print

Edycja: Golfowane 3 bajty, sortując według postaci przed grupą, poprzednia wersja: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Edycja 2: Grałem w golfa o kolejne 2 bajty, formatując dane wyjściowe przed złożeniem zamówienia, poprzednia wersja: sm+ldedlD.gr0krD0f}r0TGQ

Edycja 3: Zmieniłem filtr, zmieniając filtr dzięki @FryAmTheEggman. Musiałem również naprawić błąd, gdy OP wyjaśnił, że pojedyncza litera może pojawić się więcej niż 9 razy, co dodało bajt z powrotem na: o (Poprzednia wersja:srD0m+lded.gr0kf}r0TGQ

Sok
źródło
@FryAmTheEggman świetne połączenie, dziękuję!
Sok
4

APL (Dyalog Extended) , 28 bajtów SBCS

Anonimowa ukryta funkcja prefiksu.

(∊⍤∧⌊(⊂⍕⍤≢,⊢/)⍤⊢⌸⊢)'\PL'R''

Wypróbuj online!

'\PL' non-Letters
⎕R PCRE R eplaced z
''  pustych strunach

()  Zastosuj następującą funkcję ukrytą:

 z małymi literami jako klawiszami
 …  zastosuj poniższą funkcję ukrytą do każdego klawisza i odpowiadającego mu zestawu wartości, a mianowicie
 argumentu:

  () Zastosuj następującą ukrytą funkcję
   do
    listy wartości:

   ⊢/ ostatnia wartość

   … , Wstaw do tego następujące:

     stringification
     z
     tally

    załącz (traktuj listę znaków jako pojedynczy ciąg)

ε nlist (Spłaszczenie)  wersja posortowane rosnąco-tego

Adám
źródło
1
@Shaggy Thanks. Naprawiono na +1 bajt.
Adám
3

Perl 5, 74 68 66 bajtów

-6 bajtów zmienia się -pna -ni używa sayzamiast $_=join"", -2 bajtów dzięki Abigail używa \pLzamiast[a-z]

s/\pL/($h{lc$&}+=1).=$&/gie;say sort{$a-$b||lc$a cmp lc$b}values%h

TIO

59 bajtów, w przypadku gdy nie ma więcej niż 9 wystąpień każdego znaku

s/\pL/($h{lc$&}+=1).=$&/gie;say sort{lc$a cmp lc$b}values%h
Nahuel Fouilleul
źródło
@Abigail, dziękuję, w drugim programie był to niedopatrzenie po aktualizacji
Nahuel Fouilleul
3

Python 2 , 116 bajtów

def f(s):a=s.lower();return''.join(`n`+s[a.rfind(c)] for n,c in sorted((a.count(c),c)for c in set(a)if c.isalpha()))

Wypróbuj online!

TFeld
źródło
Wynik dla Database Partitions Tasknie jest równy1b1D1e1k1n1o1P1r2i3s4T5a
mdahmoune
@mdahmoune dzięki, powinno zostać naprawione.
TFeld
In the output, use the case of the last occurrence in the inputbędziesz potrzebować rfindzamiast findtego. ...] formoże jednak ...]forto zrównoważyć.
ArBo
3

Python 3 , 105 bajtów

s=input()
t=s.upper()
for n,c in sorted((t.count(i),i)for i in{*t}if'@'<i<'['):print(n,end=s[t.rfind(c)])

Wypróbuj online!

-1 dzięki ArBo .

Erik the Outgolfer
źródło
3

Haskell , 114/113 105 bajtów

-9 bajtów dzięki Laikoni (przy użyciu listy i (||)zamiast filterz elem& shorten, lengthaby pozbyć się brzydkich zip)!

f s=id=<<[show(h r)++[last r]|l<-[1..h s],a<-['A'..'Z'],r<-[[x|x<-s,x==a||x==[a..]!!32]],h r==l]
h=length

Wypróbuj online!

ბიმო
źródło
107 bajtów: wypróbuj online!
Laikoni
1
105: Wypróbuj online!
Laikoni
@Laikoni: Teraz krótszy niż w przypadku importu, bardzo miło !!
ბიმო
3

Czerwony , 220 196 206 bajtów

func[s][a: charset[#"a"-#"z"#"A"-#"Z"]trim/all form sort/skip collect[foreach c sort
unique reverse rejoin parse s[collect[any[keep[a]| skip]]][i: 0
foreach d s[if(c% 32)=(d% 32)[i: i + 1]]keep i keep c]]2]

Wypróbuj online!

Dzięki Shaggy za znalezienie błędu.

Galen Iwanow
źródło
1
@Shaggy Dziękujemy za zwrócenie uwagi, postaram się to naprawić.
Galen Iwanow
2

Galaretka , 15 bajtów

fØẠµŒlĠLÞịµL,Ṫ)

Pełny program wypisujący hasło zgodnie ze specyfikacją (jako monadyczny link daje listę list zawierających każdą liczbę całkowitą i znak).

Wypróbuj online!

Jonathan Allan
źródło
2

Łuska , 15 bajtów

Żadnych problemów z importu przy użyciu łuskę, więc możemy skorzystać z różnych przydatnych funkcji, takich jak groupOn, sortOn, toLoweritp:

ṁ§:osL→ÖLSġÖ_f√

Wypróbuj online lub wypróbuj je wszystkie!

Wyjaśnienie

ṁ§:(sL)→ÖLSġÖ_f√  -- example input: "Kitkat Tango"
              f√  -- `filter isAlpha`: "KitkatTango"
          S  _    -- apply _ to .. then ..
            Ö     -- | sortOn: `sortOn toLower`
           ġ      -- | groupOn: `groupOn toLower`
                  -- .. compose: `groupOn toLower . sortOn toLower`
                  -- `sortOn toLower` (stable): "aagiKknottT"
                  -- `groupOn toLower`: ["aa","g","i","Kk","n","o","ttT"]
        ÖL        -- `sortOn length` (stable): ["g","i","n","o","aa","Kk","ttT"]
ṁ                 -- map and flatten (`concatMap`)
 §                -- | fork argument ..
       →          -- | | `last`: ['g','i','n','o','a','k','T']
   (sL)           -- | | `show . length`: ["1","1","1","1","2","2","3"]
  :               -- | .. and `snoc`: ["1g","1i","1n","1o","2a","2k","3T"]
                  -- : "1g1i1n1o2a2k3T"
ბიმო
źródło
2

JavaScript (Node.js) , 127 bajtów

s=>[...s].sort(o=(x,y)=>p(0+x,36)-p(0+y,36),p=parseInt).join``.match(/([a-z])\1*/ig).map(x=>(l=x.length)+x[l-1]).sort(o).join``

Wypróbuj online!

  • parseInt(numberAsString, radix)spróbuje parsować liczbę całkowitą na początku łańcucha. Na przykład parseInt('120px', 10)wyświetli 120. Gdy parsowanie nie powiodło się, zwraca NaNzamiast tego. Łączymy '0'z początkiem każdej postaci, aby ona powróciła0 wszelkie znaki inne niż cyfry. Za pomocą tego algorytmu możemy sortować te same litery razem i znaki inne niż alfa.
  • Po sorti join, "Hello world!123"by stać " !123deHllloorw". Dopasowanie do /([a-z])\1*/igzignoruje dowolny znak inny niż alfa i podzieli ciąg na części o takich samych literach. `.
  • mapprzekonwertować "aaa"na"3a" wymagane w pytaniu.
  • Drugi sort używa tej samej funkcji, co pierwszy. Dzięki systemowi liczbowemu "3b"byłby mniejszy niż "12a"w bazie 36, tak jak się spodziewamy: najpierw porównuje liczby (n div 36 ), a później porównuje literęn mod 36 ).
  • Wreszcie joinje razem.

JavaScript (Node.js) , 146 bajtów

f=(s,...a)=>(s=s.replace(/[^a-z]/ig,''))?f(s.replace(RegExp(s[c=0],'ig'),x=>(l=++c+x,'')),...a,l):a.sort((x,y)=>p(x,36)-p(y,36),p=parseInt).join``

Wypróbuj online!

tsh
źródło
Dlaczego nie zgłosić krótszego rozwiązania jako głównego rozwiązania? Ponadto może być o 2 bajty krótszy, ponieważ nie jest rekurencyjny.
Kudłaty
@Shaggy Ah, całkowicie zapomniałem usunąć f=. Pierwszy był krótszy. Ale dostaje 4 bajty więcej, ponieważ OP zapytał, że wyjście może być pustym ciągiem. I właśnie ich tam trzymałem ...
tsh
1
@Shaggy OK, po prostu dowiedz się, że drugi może być jeszcze krótszy. I umieściłem to jako pierwsze.
tsh
2

Java 10, 223 209 301 bajtów

s->{int i=32,t;String M[]=new String[i],r,R="";for(var c:s)M[c%32]+=c>64&c<91|c>96&c<123?c:R;for(;i-->0;M[i]=(t=r.length()-4)>0?t+r.split(R)[t+3]:R)r=M[i]+R;java.util.Arrays.sort(M);for(var p:M)R+=p;return R;}

+92 bajtów jako poprawka dla danych wejściowych zawierających więcej niż 9 pojedynczych liter. Zobaczę, czy mogę to jeszcze raz obniżyć, stosując inne podejście.

Wypróbuj online.

Wyjaśnienie:

s->{                        // Method with character-array parameter and String return-type
  int i=32,                 //  Index-integer, starting at 32
      t;                    //  Temp-integer, uninitialized
  String M[]=new String[i], //  Create a String-array of size 32, filled with null by default
         R="",              //  Result-String, starting empty
         r;                 //  Temp-String, uninitialized
  for(var c:s)              //  Loop over the characters of the input-array:
    M[c%32]+=               //   Append the string at index code-point of `c` modulo-32 with:
     c>64&c<91|c>96&c<123?  //    If the character is a letter:
      c                     //     Append the character
     :                      //    Else:
      R;                    //     Append an empty String
  for(;i-->0                //  Loop `i` in the range (32, 0]:
      ;                     //    After every iteration:
       M[i]=                //     Replace the String at index `i` with:
        (t=r.length()-4)    //      Set `t` to the length of String `r` minus 4
                            //      (the minus 4 is for the prepended "null")
         >0?                //      If this length minus 4 is larger than 0:
          t                 //       Set the String to this length minus 4
          +r.split(R)[t+3]  //       Appended with the last character of `r` as String
         :                  //      Else:
          R)                //       Make the String at index `i` empty
    r=M[i]                  //   Set `r` to the `i`'th String
          +R;               //  Converted to String
                            // (null becomes "null", to prevent NullPointerException-errors)
  java.util.Arrays.sort(M,  //  Now sort the array of Strings on:
   (a,b)->                  //   For each pair of two Strings:
     new Byte(              //    Convert the first String to a number
      (0+a).replaceAll("\\D",""))
                            //    after we've added a leading 0 and removed all non-digits
    .compareTo(             //   And compare it to:
     new Byte(              //    The second String converted to a number
      (0+b).replaceAll("\\D",""))));
                            //    after we've added a leading 0 and remove all non-digits
  for(var p:M)              //  Loop over the Strings of the array:
    R+=p;                   //   And append each to the result-String `R`
  return R;}                //  And finally return the result-String `R`
Kevin Cruijssen
źródło
1
@ Shaggy Dang .. naprawiony kosztem 92 bajtów ..>. <Zobaczę, czy mogę ponownie
zagrać w
Ojej! Przepraszam za to!
Kudłaty
2

Scala , 103 bajty

_.filter(_.isLetter).groupBy(_%32).values.map(l=>l.size+""+l.last).toSeq.sortBy(_.toLowerCase).mkString

Wypróbuj online!

hucko
źródło
2

Swift 4.2.1 / Xcode 10.1 , 1054 1050 1048 370 368 364 bajtów

s.map{String($0)}.filter{$0.rangeOfCharacter(from:.letters) != nil}.reversed().reduce(into:[String:Int]()){d,s in if let l=[s.uppercased(),s.lowercased()].first(where:{d[$0] != nil}){d[l]=d[l]!+1}else{d[s]=1}}.sorted{let c=$0.value-$1.value;return c==0 ?$0.key.compare($1.key,options:.caseInsensitive) == .orderedAscending:c<0}.map{"\($0.value)\($0.key)"}.joined()

Wypróbuj online!

@KevinCruijssen również usunął niektóre spacje.

Roman Podymov
źródło
Cześć, witamy w PPCG! Nie wiem, Swift, ale wydaje się, że zapomniałeś usunąć niektóre przestrzenie, a można też golf wszystko falseaby 0>1i truedo 1>0. Wypróbuj online 1027 bajtów . Prawdopodobnie dużo więcej można zagrać w golfa, podobnie jak duplikat, if let v=$0.key.escaped(asASCII:0>1).lowercased().unicodeScalars.first?.value{return v<$1.key.value}else{return 0>1}który masz, ale zostawię to komuś, kto tak naprawdę zna Swift.
Kevin Cruijssen
1
Ponadto, jeśli jeszcze go nie widziałeś: Porady dotyczące gry w golfa we wszystkich językach i Porady dotyczące gry w golfa w Swift mogą być interesujące do przeczytania. Jeszcze raz witamy i życzymy udanego pobytu! :)
Kevin Cruijssen
Witaj @KevinCruijssen. Dzięki za wskazówki, usunąłem truei falsez mojej odpowiedzi.
Roman Podymov
1
Fajnie, grałeś dużo w golfa od początkowych 1000 bajtów. :) Widzę jeszcze 6 spacji, które można usunąć po / przed wszystkimi =przypisaniami: Wypróbuj online 364 bajty . Miłego pobytu! :)
Kevin Cruijssen
1

Węgiel drzewny , 30 bajtów

F⌈Eβ№↧θιFβ¿⁼№↧θκ⊕ι⁺⊕ι§Φθ⁼↧λκ±¹

Wypróbuj online!Link jest do pełnej wersji kodu. Wyjaśnienie:

F⌈Eβ№↧θι

Przeprowadź alfabet małymi literami i znajdź najwyższą liczbę znaków w danych wejściowych pisanych małymi literami. Pętla powyżej domyślnego zakresu. (Pętla faktycznie przechodzi od 0do, n-1więc muszę zwiększać zmienną pętli przy każdym użyciu).

Fβ

Ponownie zapętlaj małe litery.

¿⁼№↧θκ⊕ι

Jeśli liczba bieżącej litery jest równa wartości zewnętrznej pętli ...

⁺⊕ι§Φθ⁼↧λκ±¹

Połącz bieżącą liczbę z ostatnim wystąpieniem bieżącej litery i niejawnie wydrukuj.

Neil
źródło
1

NodeJS, 299 bajtów, -6 bajtów dzięki @tsh

Nie tak piękna, ale działa!

(x,l={},g=p=>p.charCodeAt(),q=p=>p.toLowerCase())=>Object.entries([...x[R='replace'](/[^a-z]/gi,'')].reduce((m,n)=>(r=q(n),l[r]=g(n)>96?1:0,{...m,[r]:-~m[r]}),{})).sort((a,b)=>a[1]^b[1]?a[1]-b[1]:g(q(a[0]))-g(q(b[0]))).map(([m,n])=>[n,m]).join``[R](/,/g,'')[R](/[a-z]/g,v=>l[v]?q(v):v.toUpperCase())

JavaScript (ES8) (Firefox lub Chrome), 294 bajty, -1 bajt dzięki @tsh

Dzięki nowej .flatmetodzie mogę zapisać 10 bajtów:

(x,l={},g=p=>p.charCodeAt(),q=p=>p.toLowerCase())=>Object.entries([...x[R='replace'](/[^a-z]/gi,'')].reduce((m,n)=>(r=q(n),l[r]=g(n)>96?1:0,{...m,[r]:-~m[r]}),{})).sort((a,b)=>a[1]^b[1]?a[1]-b[1]:g(q(a[0]))-g(q(b[0]))).map(([m,n])=>[n,m]).flat().join``[R](/[a-z]/g,v=>l[v]?q(v):v.toUpperCase())

Spróbuj tego online: https://repl.it/repls/ConcernedHorribleHypotheis

Chau Giang
źródło
Witam i witam w PPCG. Byłoby miło, gdybyś zapewnił sposób przetestowania swojego zgłoszenia, na przykład link do tłumacza online.
Jonathan Frech
@JathanathanFrech Właśnie dodałem przypadki testowe, dziękuję!
chau giang
.replacex 3 razy -> [R='replace]i [R]x 2 razy
tsh
.charCodeAt(0)-> .charCodeAt()( 0domyślnie)
tsh
@tsh Dziękuję bardzo za wszystkie dobre wskazówki, właśnie zaktualizowałem swoją odpowiedź!
chau giang
1

R , 131 129 bajtów

cat(paste0(N<-by(X<-utf8ToInt(gsub('[^a-z]','',scan(,''),T)),G<-X%%32,length),L<-intToUtf8(by(X,G,tail,1),T))[order(N,L)],sep='')

Wypróbuj online!

digEmAll
źródło
1

Julia 1.0 , 158 bajtów

¬t=(c=Dict();C=Dict();for i=eachmatch(r"\w",t);l=i.match;k=lowercase(l);c[k]=get(c,k,0)+1;C[k]=l;end;*(["$v$(C[k])" for (v,k)=sort([(v,k) for (k,v)=c])]...))

Oryginalna wersja bez golfa z tą samą logiką:

function password(text)
    letter_counts = Dict()
    cases = Dict()

    for i in eachmatch(r"\w", text)
        letter = i.match[1]
        letter_key = lowercase(letter)
        letter_counts[letter_key] = get(letter_counts, letter_key, 0) + 1
        cases[letter_key] = letter
    end

    sorted_counts = sort([(value, key) for (key, value) in letter_counts])

    return string(["$v$(cases[k])" for (v,k) in sorted_counts]...)
end

Wypróbuj online!

niczky12
źródło
0

Perl 6, 86 82 bajtów

{[~] flat map *[0,2],sort map {+$^b,$^a,$b[*-1]},kv classify &lc,.comb: /<alpha>/}
bb94
źródło