Їсти цукерки у правильному порядку


36

Що стосується того, щоб їсти цукерки, я дотримуюся більш високих стандартів, ніж типовий лайперсон. Існує тонкий баланс між "змішуванням його" і "збереженням найкращого для останнього".

У цьому виклику вам буде надано рядок символів, у якому кожен персонаж являє собою цукерку. Різні символи (залежно від регістру) представляють цукерки різних типів. Потім ваша програма повинна визначити правильний порядок споживання цукерок, грунтуючись на наведеній нижче процедурі. Ви можете написати або повну програму (STDIN / STDOUT), або іменовану функцію для виконання цього завдання.

Скажімо, що мій запас цукерок oroybgrbbyrorypoprr. По-перше, я сортую цукерки в палі того ж типу, з більшими кількостями вгорі, використовуючи нижчі значення символів ASCII як перемикач.

rrrrrr
oooo
bbb
yyy
pp
g

Потім я беру кожен ряд цукерок і однаково розміщую їх по проміжку. Наприклад, якщо є 3 шматки цукерки, один кладеться 1/3 шляху, 2/3 шляху і в кінці.

.r.r.r.r.r.r
..o..o..o..o
...b...b...b
...y...y...y
.....p.....p
...........g

Тоді, я йду вниз кожну колонку , щоб створити свій остаточний замовлення цукерки, rorbyroprbyorrobypg.

Вхідні дані

Рядок, в якому міститься цукерка. Вхідним для цього прикладу могло бути:

oroybgrbbyrorypoprr

Вихідні дані

Рядок із цукерками реорганізований у правильний порядок споживання.

rorbyroprbyorrobypg

Оцінка балів

Це код гольфу. Виграє найкоротша відповідь у байтах. Діють стандартні правила гольф-коду.


Ви просто додаєте більше місця, якщо цифри цукерок нерівні? Скажімо, у цьому випадку, якби у вас була ще одна цукерка, як виглядатиме сітка?
Ваджура

38
Нарешті хтось, хто ЗНАЄ, як їсти цукерки.
Майкл М.

12
Отже ... в основному цукерки дрімають.
COTO

9
Це насправді дуже близьке до того, як я їмо цукерки. :)
Еміль

3
Наскільки жадібною може стати одна людина? Чи існує обмеження на кількість цукерок, які потрібно їсти?
Алхімік

Відповіді:


12

CJam, 78 68 61 45 42 39 31 30 байт

l$:L{L\/,~}${:DM+:MD/,LD/,d/}$

Бере вхідний рядок через STDIN

Натхненний рекурсивним підходом, але трохи іншим. Не потрібно переносити чи прямокутник взагалі !.

Як це працює:

l$:L                              "Sort the input line and store it in L";
    {     }$                      "Sort the string based on this code block output";
     L\/,~                        "Sort based on number of occurrences of each";
                                  "character in the full string";
            {               }$    "Sort the sorted string again";
             :DM+:M               "Store each character in D, add to M and update M";
                   D/,            "Count occurrences of D in M";
                      LD/,        "Count occurrences of D in L";
                          d/      "Sort string based on the ratio of two occurrences";

(Сумно, що CJam більше не може завершити Pyth через потребу стільки роздуття, як синтаксис)

Спробуйте тут


4
Я не думаю, що вам потрібен LCM; будь-який кратний повинен працювати. Це повинно дозволити вам замінити {_@_@{_@\%}h;/*}на :.
Денніс

<facepalm> про це не думав.
Оптимізатор

Вітаємо вас удвічі!
isaacg

Я відчуваю сарказм у тому: D
Оптимізатор

11

Піт , 25

shCoc/NhN/zhNm>o_/zZSzdUz

Використовує весь новий алгоритм, натхненний цією відповіддю .

(implicit)          z = input()
(implicit)          print
s                   combine list of strings into one string
 h                  first list in
  C                 matrix transpose of (e.g. first characters in first list, etc.)
   o                order_by(lambda N:
    c                        float_div(
     /NhN                              N.count(N[0]),
     /zhN                              z.count(N[0])),
    m                        map(lambda d:
     >                           slice_head(
      o                                     order_by(lambda Z:
       _/zZ                                          -1*z.count(Z),
       Sz                                            sorted(z)),
      d                                     d),
     Uz                          range(len(z))

Крок за кроком:

  1. Спочатку ми сортували персонажів за їх спільністю, зв’язками, розірваними за алфавітом. Це o_/zZSz. oтакий же, як і Python's sorted(<stuff>,key=<stuff>), з лямбда-виразом для ключа, за винятком того, що він зберігає його як рядок.

  2. Тоді ми формуємо список префіксів цього рядка від довжини len(z)до довжини 1. >еквівалентний пітонному <stuff>[<int>:].

  3. Потім ми упорядковуємо цей список рядків префіксів за дробовим розташуванням, 0 - лівий край, а 1 - правий, першого символу префікса прямокутного макета, зазначеного в питанні. /NhNпідраховує, скільки разів перший символ у префіксі зустрічається у префіксі, при цьому /zhNдає кількість входів першого символу в префіксі в рядку як отвір. Це призначає кожному префіксу, який веде кожен символ у групі, різну частку, від 1/kправої більшості зустрічань цього символу до k/kбільшості зліва. Упорядкування списку префіксів за цим номером надає відповідне місце в макеті. Зв'язки розриваються, використовуючи попереднє замовлення, яке спочатку було підраховано, а за алфавітом, за бажанням.

  4. Нарешті, нам потрібно витягнути перший символ з кожної рядки префікса, об'єднати їх в один рядок та роздрукувати їх. Вилучення перших символів є hC. Cвиконує транспортування матриці за списком, фактично zip(*x)з Python 3. hвитягує перший рядок отриманої матриці. Це насправді єдиний рядок, оскільки наявність префіксу 1 символу перешкоджає формуванню будь-яких інших повних рядків. sпідсумовує символів у цьому кортежі в один рядок. Друк неявний.

Тест:

$ pyth -c 'shCoc/NhN/zhNm>o_/zZSzdUz' <<< 'oroybgrbbyrorypoprr'
rorbyroprbyorrobypg

Додаткові твори програми про oroybgrbbyrorypoprr:

Sub-Piece                  Output

Sz                         bbbgoooopprrrrrryyy
o_/zNSz                    rrrrrroooobbbyyyppg      (uses N because o uses N on first use.)
m>o_/zNSzdUz               ['rrrrrroooobbbyyyppg', 'rrrrroooobbbyyyppg', 'rrrroooobbbyyyppg', 'rrroooobbbyyyppg', 'rroooobbbyyyppg', 'roooobbbyyyppg', 'oooobbbyyyppg', 'ooobbbyyyppg', 'oobbbyyyppg', 'obbbyyyppg', 'bbbyyyppg', 'bbyyyppg', 'byyyppg', 'yyyppg', 'yyppg', 'yppg', 'ppg', 'pg', 'g']
oc/NhN/zhNm>o_/zZSzdUz     ['roooobbbyyyppg', 'obbbyyyppg', 'rroooobbbyyyppg', 'byyyppg', 'yppg', 'rrroooobbbyyyppg', 'oobbbyyyppg', 'pg', 'rrrroooobbbyyyppg', 'bbyyyppg', 'yyppg', 'ooobbbyyyppg', 'rrrrroooobbbyyyppg', 'rrrrrroooobbbyyyppg', 'oooobbbyyyppg', 'bbbyyyppg', 'yyyppg', 'ppg', 'g']
Coc/NhN/zhNm>o_/zZSzdUz    [('r', 'o', 'r', 'b', 'y', 'r', 'o', 'p', 'r', 'b', 'y', 'o', 'r', 'r', 'o', 'b', 'y', 'p', 'g')]
shCoc/NhN/zhNm>o_/zZSzdUz  rorbyroprbyorrobypg

Стара відповідь:

Піта , 34

ssCm*+t*u*G/zHS{-zd1]kd/zdo_/zNS{z

Ця програма працює, обчислюючи, скільки разів повторювати певний підпис. Схожий підсклад ['', '', '', '', ... , 'r']. Загальна довжина цього підспису - це добуток кількості зустрічей усіх інших цукерок, що є u*G/zHS{-zd1. Повний підпис складається з реплікації списку порожнього рядка, ]kякий багато разів, потім видаляючи та елемент із tі додаючи назву цукерки до кінця +d.

Потім цей підсклад реплікується стільки разів, скільки цукерки знайдені на вході /zd, гарантуючи, що кожен список цукерок має однакову довжину.

Тепер, коли ця функція відображається над усіма унікальними цукерками у відповідному відсортованому порядку ( o_/zNS{z), у нас є прямокутник, аналогічний тому, що йдеться у виписці, але з порожніми рядками замість періодів. Виконання транспонування матриці ( C) з подальшими двома ssпідсумками ( ) дає заключний рядок.

Підтвердження:

$ pyth programs/candy.pyth <<< 'oroybgrbbyrorypoprr'
rorbyroprbyorrobypg

4
Схоже, Pyth підтримує шифрування в самому синтаксисі мови!
Оптимізатор

Шифрування @Optimizer? Про що ти говориш?
isaacg

Приємно! Я, мабуть, ніколи не думав би перетворити цикл for на карту. Значно чистіше.
FryAmTheEggman

Подивіться на вихідний код. Це схоже на зашифроване повідомлення.
Оптимізатор

2
Чи можете ви навести покроковий приклад останнього алгоритму? Досить будь ласка :)
Оптимізатор

6

Перл 5 - 62

61 код + 1 прапор.

#!perl -n
print map/(.$)/,sort map/(.$)/*$_/$$1.~$_.$1,map++$$_.$_,/./g

Спочатку розділіть вхід на масив символів - /./g.

Додайте до кожної літери індекс появи, залишаючи підрахунки у змінних $a.. $zз map++$$_.$_. Тепер масив:

1o
1r
2o
1y
1b
1g
2r
2b
3b
2y
3r
3o
4r
3y
1p
4o
2p
5r
6r

Потім перетворіть його в об'єднаний ключ сортування: коефіцієнт $_/$$1, підрахунок вимикача крапки ~$_та вимикач значення ASCII $_. Це призведе до (тут із додатковими пробілами для наочності).

0.25 18446744073709551614 o
0.166666666666667 18446744073709551614 r
0.5 18446744073709551613 o
0.333333333333333 18446744073709551614 y
0.333333333333333 18446744073709551614 b
1 18446744073709551614 g
0.333333333333333 18446744073709551613 r
0.666666666666667 18446744073709551613 b
1 18446744073709551612 b
0.666666666666667 18446744073709551613 y
0.5 18446744073709551612 r
0.75 18446744073709551612 o
0.666666666666667 18446744073709551611 r
1 18446744073709551612 y
0.5 18446744073709551614 p
1 18446744073709551611 o
1 18446744073709551613 p
0.833333333333333 18446744073709551610 r
1 18446744073709551609 r

Це можна сортувати за лексикографічним (за замовчуванням) порядком. На завершення витягніть останній символ та роздрукуйте:print map/(.$)/


5

Python 3.x - 124 байти

C=input()
print("".join(s[1]for s in sorted(enumerate(C),key=lambda
t:((C[:t[0]].count(t[1])+1+1e-10)/C.count(t[1]),t[1]))))

Це набагато крутіший алгоритм, ніж метод прямокутника!
isaacg

4

Mathematica, 123 119 118 байт

f=FromCharacterCode[s=SortBy;#&@@@s[Join@@(s[Tally@ToCharacterCode@#,-Last@#&]/.{x_,n_}:>({x,#/n}&~Array~n)),{Last}]]&

Визначає названу функцію f. Безголівки:

f = FromCharacterCode[
   s = SortBy;
   # & @@@ s[
     Join @@ (
       s[
         Tally@ToCharacterCode@#,
         -Last@# &
         ] /. {x_, n_} :> ({x, #/n} &~Array~n)
       ),
     {Last}
     ]
   ] &

Використання вбудованих раціональних типів здавалось гарною ідеєю для цього. Звичайно, цього немає ніде CJam. В основному я представляю сітку, показану в виклику, як список пар. Перше, що знаходиться в парі - код символів, друге - це позиція у вигляді дробу, меншої або дорівнює 1 (остаточний стовпець дорівнює 1). Переконавшись у тому, що окремі символи вже в правильному порядку, мені просто потрібно це стабільно сортувати за вказаною дробою, щоб отримати бажаний результат.


3

Піт 45 47 48 51

Це також можна було б майже напевно пограти в гольф;)

Ko_/zNS{zFGK~Y]*+*t/u*GHm/zdK1/zG]k]G/zG)ssCY

Працює над створенням списку списків, де кожен внутрішній список - це ряд порожніх рядків та назва цукерки. Цей список переміщується, а потім приєднуються внутрішні списки, після чого ці списки з'єднуються.

Дякую @isaacg, що нагадав про суму!


2
sу списку рядків працює як j"".
isaacg

3

APL: 38

v⌷⍨⊂⍋⌽(n/-n),⍪∊+\¨n⍴¨÷n←{≢⍵}⌸v←{⍵[⍋⍵]}

Пояснення:

v←{⍵[⍋⍵]}    orders input string
n←{≢⍵}⌸v     counts how many times each element appears in v
∊+\¨n⍴¨÷n     makes incremental sums in each letter "group" 
⍋⌽(n/-n),⍪   appends number of elements in letter group and orders the obtained matrix
v⌷⍨⊂         orders vector v with computed indices

Можна перевірити на tryapl.org


2

R - 166 символів

library("plyr");s=function(a){l=table(strsplit(a,s="")[[1]]);l=ldply(l[order(-l,names(l))],function(n)data.frame(seq_len(n)/n));paste(l[order(l[[2]]),1],collapse="")}

безгольова версія

library("plyr")
s <- function(a) {
    tbl <- table(strsplit(a, split = "")[[1]])
    tbl <- tbl[order(-tbl, names(tbl))]
    tbl <- ldply(tbl, function(n) {data.frame(seq_len(n)/n)})
    paste(tbl[order(tbl[[2]]),1], collapse = "")
}

Пояснення:

  • Розділіть на окремих персонажів
  • Табличне число кожного символу
  • Сортуйте таблицю за найбільш частою, а потім за лексичним порядком
  • Індекс позицій для вибору на 1 / n, 2 / n, 3 / n, ... n-1 / n, 1 де n - кількість цукерок
  • Сортування назв цукерок за індексом (order стабільний у сортуванні, тому буде підтримуватися найчастіший / лексичний порядок імен, коли краватка в індексі, особливо важлива для останніх цукерок)
  • Об’єднайте назви цукерок разом, щоб зробити вихідний рядок

Матричний характер проблеми змусив мене подумати, що R може подумати в цьому, але найкраща буквальна інтерпретація алгоритму, яку я міг зробити, - це 211 символів:

l=function(a){l=table(strsplit(a,s="")[[1]]);l=l[order(-l,names(l))];o=Reduce(`*`,l);m=matrix("",nc=o,nr=length(l));for(r in seq_along(l)){x=l[r];for(c in seq_len(x)*o/x){m[r,c]<-names(x)}};paste(m,collapse="")}

неозорений:

l <- function(a) {
    tbl <- table(strsplit(a, split = "")[[1]])
    tbl <- tbl[order(-tbl, names(tbl))]
    o <- Reduce(`*`, tbl)
    m <- matrix("", ncol = o, nrow = length(tbl))
    for (r in seq_along(tbl)) {
        for (c in seq_len(tbl[r])*o/tbl[r]) {
            m[r,c] <- names(tbl[r])
        }
    }
    paste(m, collapse="")
}

2

Pyth, 29 байт

Це прямий переклад мого CJam answe r в Pyth

oc/|$Y.append(N)$YN/zNo_/zZSz

Спробуйте його онлайн тут


За цим рішенням стоїть досить довга історія, і @isaacg мені дуже допомогла в розумінні цієї нової мови.

В ідеалі це точний переклад мого коду CJam ( 17 байт ) від слова до слова :

oc/~kNN/zNo_/zZSz

що означає:

o         order_by(lambda N:
 c                 div(
  /                    count(
   ~kN                       k+=N,                #Update k (initially ""), add N
   N                         N),                  #Count N in updated k
  /zN                  count(z, N)),
 o                 order_by(lambda Z:
  _                         neg(
   /zZ                          count(z, Z)),
  Sz                        sorted(z)))

Але, на жаль, Python нічого не повертає в a += виклику, так що це був не дійсний код Python, таким чином, недійсний код Pyth також, як і в Pyth, лямбда може бути лише заявою повернення.

Потім я вивчив різні методи і нарешті виявив, що Python list.appendповертає Noneзначення, яке я можу використовувати. Створення коду ( 19 байт ):

oc/|aYNYN/zNo_/zZSz

що означає:

o         order_by(lambda N:
 c                 div(
  /                    count(
   |aYN                      (Y.append(N) or
    Y                         Y)                 #Update Y (initially []), append N
   N                         N),                 #Count N in updated Y
  /zN                  count(z, N)),
 o                 order_by(lambda Z:
  _                         neg(
   /zZ                          count(z, Z)),
  Sz                        sorted(z)))

Але, на жаль, підтримка a(append) була видалена з Pyth, і версія, яка має підтримку, не має підтримки дляo .

Оновлення: a підтримка була додана ще в Pyth, тому вищезгаданий 19-байтний код буде працювати в онлайн-компіляторі. Але оскільки це нова функція, яка була додана після ОП, я не ставлю це як мій показник, а 29-байтний код даю як своє рішення.

Тому мені довелося покладатися на сирий Python у такому випадку, роблячи код

o         order_by(lambda N:
 c                 div(
  /                    count(
   |$Y.append(N)$            (Y.append(N) or
    Y                         Y)                 #Update Y (initially []), append N
   N                         N),                 #Count N in updated Y
  /zN                  count(z, N)),
 o                 order_by(lambda Z:
  _                         neg(
   /zZ                          count(z, Z)),
  Sz                        sorted(z)))
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.