задача

Учитывая строку английских названий цифр, «свернутых» вместе, вот так:

zeronineoneoneeighttwoseventhreesixfourtwofive

Разбейте строку обратно на цифры:

zero nine one one eight two seven three six four two five

правила

Ввод всегда является строкой. Он всегда состоит из одного или нескольких строчных английских имен, сложенных вместе, и ничего больше.
- Английские цифры называются zero one two three four five six seven eight nine.
Вывод может быть списком строк или новой строкой, где цифры разделены не алфавитными, непустыми строками. (Ваш вывод также может иметь такие строки в начале или в конце, и разделители не обязательно должны быть согласованными. Поэтому даже что-то подобное {{ zero0one$$two );является правильным (если абсурдным) ответом zeroonetwo.)
Самый короткий ответ в байтах побеждает.

Контрольные примеры

three -> three
eightsix -> eight six
fivefourseven -> five four seven
ninethreesixthree -> nine three six three
foursixeighttwofive -> four six eight two five
fivethreefivesixthreenineonesevenoneeight -> five three five six three nine one seven one eight
threesevensevensixninenineninefiveeighttwofiveeightsixthreeeight -> three seven seven six nine nine nine five eight two five eight six three eight
zeroonetwothreefourfivesixseveneightnine -> zero one two three four five six seven eight nine

code-golf string

— Линн
источник

28

Это отличный вызов! Задача чрезвычайно проста для понимания и проверки, но правильный подход к использованию не очень очевиден. И выбор правильного подхода может иметь огромное значение в оценке. +1 :)

— DJMcMayhem

1

Подумав об этом, я вспомнил похожее, но более простое испытание для анархии в гольф: да ! Это вызвало некоторые удивительные C-ответы. Я надеюсь увидеть один из них в ближайшее время :)

— Линн

Я не думаю, что мой ответ «С» квалифицируется как таковой, но, надеюсь, это отправная точка для других с более извращенным чувством юмора, чем я.

— Майкл Дорган

Я почти уверен, что видел такой же вызов, но там, где вы должны напечатать фактическое число. Я почти уверен, что это также было опубликовано вами, Линн; но я потерял связь, подцепи меня?

— Волшебная Осьминог Урна

3

@MichaelDorgan (или любые другие C-кодеры), вы можете взглянуть на алгоритм, который я использовал в своем ответе Befunge. Прямое преобразование этого в C дало мне 104-байтовое решение, которое, я думаю, превосходит все существующие ответы на C. Я готов поспорить, что это может быть улучшено кем-то с большими навыками игры в гольф.

— Джеймс Холдернесс

29

Сетчатка , 20 байт

!`..[eox]|[tse]?....

Попробуйте онлайн!

— Уриэль
источник

17

C (gcc) , 89 80 76 75 72 71 70 69 байт

f(char*s){*s&&f(s+printf(" %.*s",""[(*s^s[2])%12],s)-1);}

Попробуйте онлайн!

(89) Кредит гастропнеру для хэша XOR.
(76) Благодарим Тоби Спейта за идею использования 1-го и 3-го.
(75) Благодарим Майкла Доргана за '0'→ 48.
(72) Благодарим Майкла Доргана и Линн за литералы с управляющими символами.
(69) Кредит Линн для x?y:0→x&&y

f (char *s) {        /* K&R style implicit return type. s is the input. */
    *s&&f(           /* Recurse while there is input. */
        s+printf(    /* printf returns the number of characters emitted. */
            " %.*s", /* Prefix each digit string with a space. Limit
                      * how many bytes from the string to print out. */
            ""
                     /* Magic hash table, where the value represents
                      * the length of the digit string. The string
                      * is logically equivalent to
                      * "\04\01\05\03\04\05\05\04\04\01\03\03" */
            [(*s^s[2])%12],
                     /* The XOR hash (mod 12) */
            s)       /* The current digit. */
            -1);}    /* Subtract 1 for the space. */

— jxh
источник

11

Python 2 , 50 байт

import re
re.compile('..[eox]|[tse]?....').findall

Попробуйте онлайн!

-3 спасибо Линн .
-4 благодаря Уриэль «s ответ регулярное выражение» s.

— Эрик Аутгольфер
источник

3

Приятно! import re;re.compile('…').findallследует сохранить пару байтов. Я ожидал, что это превратится в регулярное выражение в гольф :)

— Линн

@ Линн Подожди, подожди, пока я закончу! :-P РЕДАКТИРОВАТЬ: Это 3 байта, на самом деле.

— Эрик Outgolfer

@Lynn Кроме того, вы должны вместо этого превратить это в регулярное выражение code-golf . ;)

— Эрик Outgolfer

Я держусь за ответ C, который будет очень интересным!

— Линн

9

Befunge, 87 85 81 76 байт

<*"h"%*:"h"$_02g-v1$,*<v%*93,:_@#`0:~
"@{&ruX;\"00^ !: _>_48^>+:"yp!"*+%02p0

Попробуйте онлайн!

У Befunge нет никаких инструкций по манипуляции со строками, поэтому мы создаем своего рода хэш из последних трех встреченных символов по мере их обработки.

По сути, этот хэш состоит из трех цифр, числа base-104. Каждый раз, когда читается новый символ, мы модифицируем хеш с 104 ^2, чтобы избавиться от самого старого символа, умножим его на 104, чтобы освободить место для нового символа, затем добавим значение ASCII нового символа мод 27 (чтобы убедиться, что это не переполняется).

В целях сравнения мы берем это значение mod 3817, записываем его в память (таким образом, обрезая его до 8 бит), что приводит к меньшим числам, которые Befunge легче обрабатывать. Затем мы должны сравнить хэши, равные 0, 38, 59, 64, 88, 92, 114, 117 и 123. Если они совпадают с любым из них, мы знаем, что столкнулись с последовательностью символов, которая отмечает конец число, поэтому мы выводим дополнительный пробел и сбрасываем хэш на ноль.

Если вам интересно, почему base 104 или mod 3817, эти значения были тщательно выбраны, чтобы список хэшей, который нам нужно было сравнить, мог быть представлен как можно меньшим количеством байтов.

— Джеймс Холдернесс
источник

Честно говоря, для меня это выглядит как бакемоджи (ばけもじ). Ух ты. Описание алгоритма хорошо, хотя, и я буду его рассматривать.

— Майкл Дорган

^, Я помню, как видел этот термин как моджибаке (もじばけ). Как вы нашли эти цифры (база 104, мод 3187), @JamesHolderness?

— Захари

@ Zacharý Я написал небольшой скрипт на Python, который тестировал различные комбинации баз и модов, чтобы найти те, которые будут давать правильные результаты при запуске со всеми ожидаемыми входными данными. После того, как я узнал, какие комбинации работают, я запустил полученные хэш-результаты через генератор чисел Befunge, чтобы выяснить, какой из них генерирует самый короткий код.

— Джеймс Холдернесс

6

Java (OpenJDK 8) , 55 46 43 байта

Экономия 9 байтов благодаря Forty3 / FrownyFrog

Экономия 3 байта благодаря Титу

s->s.replaceAll("one|tw|th|f|z|s|.i"," $0")

Попробуйте онлайн!

Редактировать: Спасибо за прием и объяснение лямбды!

— Лука Х
источник

3

Привет, добро пожаловать в PPCG! Отличный первый ответ, и он действительно работает. Вот ссылка TIO для этого. Лямбды могут быть созданы несколькими способами. Вот еще один TIO с несколькими лямбдами с добавленными комментариями, чтобы вы могли сами увидеть, как их создавать. (Я предлагаю скопировать его в Eclipse, чтобы вы могли видеть выделение кода.) Кроме того, советы по игре в гольф на Java и советы по игре в гольф на всех языках могут быть интересными для чтения. Приятного пребывания! :)

— Кевин Круйссен

@KevinCruijssen спасибо! Я искренне удивлен, что Java короче, чем JavaScript. Обычно, когда я читаю проблемы, JS намного короче.

— Luca H

JavaScript должен быть на 2 байта короче ( gвместо суффикса регулярное выражение All).

— Нил

@Neil здесь длиннее, потому что f=(s)=>вместо него используется s->, что на 4 байта короче.

— Лука Х

1

@LucaH - согласно предложению FrownyFrog, вы можете уменьшить несколько двухбуквенных строк до одного символа: z | f | s вместо ze | fo | fi | si | se /

— Forty3

6

C (gcc) , 179 159 146 139 137 116 107 103 102 байта

Редактировать 1: (Добавлены предложения от Mr. Xcoder - спасибо! - Моя версия макроса была того же размера, что и ваша, но мне больше нравится ваша.)

Редактировать 2: измененный персонаж сравнивается с вызовамиstrchr()

Редактировать 3: K & R в объявлениях вар (Eww!)

Редактировать 4: когда одного макроса недостаточно ...

Редактировать 5: Переделать с новым алгоритмом, предложенным выше. Спасибо Джеймсу Холдернессу за эту прекрасную идею!

Редактировать 6: Удалено 0, установленное так, как кажется, что оно происходит автоматически - Используемые техники мастер-кода с кодом (запятые, трюк с printf и т. Д.) - спасибо gastropner !

Редактировать 7: Используйте memchr и исправил ошибку, указанную Джеймсом Холдернессом .

Редактировать 7: использовать &&при окончательной проверке, чтобы заменить ?- спасибо JXH .

c,h;f(char*s){while(c=*s++)putchar(c),h=h%10816*104+c%27,memchr("&;@X\\ru{",h%3817,9)&&putchar(h=32);}

Попробуйте онлайн!

Без гольфа (Честно говоря, это все еще игра в гольф)


int c;
int h;
void f(char*s)
{
    while(c=*s++)
        putchar(c),
        h=h%10816*104+c%27,
        memchr("&;@X\\ru{",h%3817,9)?putchar(h=32):1;
}

Старое, прямое решение grep-esqe:

#define p putchar
#define q c=*s++
c,x;f(char*s){while(q){p(c);x=strchr("tse",c);p(q);p(q);if(!strchr("eox",c)){p(q);if(x)p(q);}p(' ');}}

Старая, более чистая версия.

// Above code makes a macro of putchar() call.

void f(char *s)
{
    char c;
    while(c = *s++)
    {
        putchar(c);
        int x = strchr("tse", c);

        putchar(*s++);
        putchar(c=*s++);

        if(!strchr("eox", c))
        {
            putchar(*s++);
            if(x)
            {
                putchar(*s++);
            }
        }       
        putchar(' ');
    }
}

Попробуйте онлайн!

— Майкл Дорган
источник

Мы можем макрокомандировать putchar и тому подобное для нескольких байтов, но в общем, все еще думаем о лучшем алгоритме, если это возможно.

— Майкл Дорган

159 байт по #defineИнгам putcharи удаления пары лишних скобок.

— г-н Xcoder

2

Немного некрасиво, но вместо этого используется 136 байт#define p putchar( (обратите внимание на открытые скобки).

— Том Карпентер

1

109 байтовc,h=0;f(char*s){while(c=*s++)putchar(c),h=h%10816*104+c%27,c=h%3817,printf(" "+!(c&&strchr("&;@X\\ru{",c)));}

— гастропнер

Ах, трюк с printf, который я видел ниже, плюс удаление пары скобок и скобок. Мастер уровня кода гольф включен :)

— Майкл Дорган

5

JavaScript, 66 57 52 44 41 байт

s=>s.replace(/one|t[wh]|.i|[fsz]/g," $&")

Довольно наивно, но это работает.

Хороший улов FrownyFrog для использования 2 символов ... за исключением "одного", при котором проверка с двумя символами может испортить зеронин. Редактировать: сингл fи sбыли хорошие уловки FrownyFrog, что я пропустил мои первые два гольфа.

Спасибо, Нил, за предложение неназванной лямбды и возможность использовать один символ для, zполучает 52.

Титус придумал меньший RegEx. Я чувствую, что в конце концов мы движемся к регулярному выражению Уриэля.

— Forty3
источник

Это сломается, если вы используете два символа и нажимаете «вкл» до конца?

— FrownyFrog

Я думаюz|tw|th|f|s|ei|ni|on

— FrownyFrog

1

@FrownyFrog o на первом месте, поэтому он распознается первым.

— Уриэль

1

on|t[wh]|.i|[fsz](-4 байта)

— Тит

2

@Titus - К сожалению, on|будет соответствовать zeronineрендерингzer onine

— Forty3

5

Сетчатка , 24 23 байта

!`..[eox]|[fnz]...|.{5}

Попробуйте онлайн! Редактировать: 1 байт сохранен благодаря @FrownyFrog.

— Нил
источник

1

будет .....-> .{5}работать?

— FrownyFrog

5

C 103 99 байт

char*r="f.tzuonresn.xgv";f(char*s){*s&&f(s+printf("%.*s ",(strrchr(r,s[2])-strchr(r,*s))%10,s)-1);}

Это работает для любой кодировки символов (включая неуклюжие, такие как EBCDIC), потому что она не использует числовое значение входных символов. Вместо этого он находит первую и третью буквы в магической строке. Расстояние между ними указывает, сколько букв нужно продвигать с каждым отпечатком.

Тестовая программа

#include <stdio.h>
int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        f(argv[i]);
        puts("");
    }
}

— Тоби Спейт
источник

1

Некоторые байты могут быть сохранены с помощью рекурсии: tio.run/##XY/…

— jxh

4

J , 37 35 байт

rplc'twthsiseeinionzef'(;LF&,)\~_2:

Попробуйте онлайн!

— FrownyFrog
источник

2

Классное альтернативное решение! Я пытался, f=:[:>'..[eox]|[tse]?....'&rxallи это работало в интерпретаторе, но не работает в TIO.

— Гален Иванов

это действительно умно, молодец

— Иона

@GalenIvanov TIO имеет последнюю версию, это может быть регрессия в J.

— FrownyFrog

4

C (gcc) , 106 байтов 104 102 байта

-2 байта благодаря @jxh -2 байта благодаря потолку

c;f(char*s){for(char*t=" $&=B*,29/?";*s;)for(c=4+(index(t,(*s^s[1])+35)-t)/4;c--;)putchar(c?*s++:32);}

Попробуйте онлайн!

XOR действительно наш самый большой союзник.

— gastropner
источник

Как трюк с ++. Хороший хэш.

— Майкл Дорган

1

s[1]будет короче.

— JXH

@jxh Хороший! Обновлено.

— гастропнер

3

Сетчатка , 28 байт

t[ewh]|[zfs]|(ni|o)ne|ei
 $&

Попробуйте онлайн!

— овс
источник

3

Pyth , 35 27 23 байта

Спасло много байтов, перенеся подход Уриэля .

:Q"..[eox]|[tse]?...."1

Попробуй это здесь! Начальный подход.

— Мистер Xcoder
источник

3

Пип , 27 байт

aR`[zfs]|one|[ent][iwh]`s._

Принимает ввод в качестве аргумента командной строки. Попробуйте онлайн!

Простая замена регулярных выражений, вставляет пробел перед каждым совпадением [zfs]|one|[ent][iwh].

Прыжок на подножку ~~кражи,~~ заимствуя регулярное выражение Уриэля, дает 23 байта (с -sфлагом):

a@`..[eox]|[tse]?....`

— DLosc
источник

Вы можете использовать более короткое регулярное выражение .

— Эрик Outgolfer

3

Желе , 23 21 байт

ḣ3OP%953%7%3+3ɓḣṄȧṫḊÇ

Полная программа печати, разделенная переводом строки. Примечание: как только это будет сделано, он многократно печатает пустые строки «навсегда» (до огромного предела рекурсии или ошибки сегмента)

Попробуйте онлайн! (Вывод TIO накапливается, локальная реализация будет печатать построчно)

Как?

Начиная со списка символов, программа неоднократно:

находит длину первого слова в списке символов с использованием некоторой порядковой математики;
печатает слово плюс перевод строки; а также
убирает слово из заголовка списка символов

Длина первого слова определяется путем проверки первых трех символов текущего списка символов (обязательно является частью первого слова). Программа преобразует их в порядковые, умножает их вместе, умножает результат на 953, делит на семь, делит на три и добавляет три:

word   head3  ordinals       product  %953  %7  %3  +3 (=len(word))
zero   zer    [122,101,114]  1404708   939   1   1   4
two    two    [111,110,101]  1233210    28   0   0   3
one    one    [116,119,111]  1532244   773   3   0   3
three  thr    [116,104,114]  1375296   117   5   2   5
four   fou    [102,111,117]  1324674     4   4   1   4
five   fiv    [102,105,118]  1263780   102   4   1   4
six    six    [115,105,120]  1449000   440   6   0   3
seven  sev    [115,101,118]  1370570   156   2   2   5
eight  eig    [101,105,103]  1092315   177   2   2   5
nine   nin    [110,105,110]  1270500   151   4   1   4

ḣ3OP%953%7%3+3ɓḣṄȧṫḊÇ - Main link, list of characters           e.g. "fiveeight..."
ḣ3              - head to index three                                "fiv"
  O             - ordinals                                           [102,105,118]
   P            - product                                            1263780
    %953        - modulo by 953                                      102
        %7      - modulo by seven                                    4
          %3    - modulo by three                                    1
            +3  - add three                                          4

              ɓ - dyadic chain separation swapping arguments...
... ḣṄȧṫḊÇ ...
    ḣ         - head to index                                        "five"
     Ṅ        - print the result plus a line-feed and yield the result
       ṫ      - tail from index                                      "eeight..."
      ȧ       - and (non-vectorising)                                "eeight..."
        Ḋ     - dequeue                                               "eight..."
         Ç    - call the last link (Main*) as a monad with this as input
              -       * since it's the only link and link indexing is modular.

— Джонатан Аллан
источник

1

Я не уверен, разрешено ли это . (Серьезно, что вы делаете, когда два мета-ответа с большим количеством голосов говорят противоположность друг другу?)

— Орджан Йохансен

OP явно заявляет: «Ваш вывод также может иметь такие строки в начале или конце», и эта программа на самом деле печатает по ходу, так что вывод создается до любого принудительного завершения в любом случае.

— Джонатан Аллан

Конечно, но я не думаю, что OP рассматривал бесконечную конечную строку. И мета-вопрос явно касается случая, когда вывод печатается первым.

— Орджан Йохансен

Я думаю, что это соответствует духу требования (если, например, оно напечатало бесконечные пустые строки, а затем слова, которые, как я могу утверждать, этого не сделали)

— Джонатан Аллан

Итак, я предполагаю, что это ставит меня в лагерь Мартина «если это программа и может оправдать ...» :)

— Джонатан Аллан

3

С 168 ,145,144141 байт

РЕДАКТИРОВАТЬ: пробовал init 'я' до 1, как это

а, б, основная (я)

Избавиться от
начальных пробелов, но он ломается при вводе, начиная с трех, семи или восьми

141

#define s|a%1000==
a,i;main(b){for(;~scanf("%c",&b);printf(" %c"+!!i,b),a|=b%32<<5*i++)if(i>4|a%100==83 s 138 s 116 s 814 s 662 s 478)a=i=0;}

Попробуйте онлайн

144

a,i;main(b){for(;~(b=getchar());printf(" %c"+!!i,b),a=a*21+b-100,++i)if(i>4|a==204488|a==5062|a==7466|a==23744|a==21106|a==6740|a==95026)a=i=0;}

Попробуйте онлайн

168

i,a;main(b){for(;~scanf("%c",&b);printf(" %c"+!!i,b),a|=b<<8*i++)if(i>4|a==1869768058|a==6647407|a==7305076|a==1920298854|a==1702259046|a==7891315|a==1701734766)a=i=0;}

Попробуйте онлайн!

Ungolfed

i,a;main(b){
for(;~scanf("%c",&b); // for every char of input
printf(" %c"+!!i,b), // print whitespace if i==0 , + char
a|=b<<8*i++ // add char to a for test
)
if(
i>4| // three seven eight
a==1869768058|      // zero
a==6647407|        // one
a==7305076|       // two
a==1920298854|   //four
a==1702259046|  //five
a==7891315|    //six
a==1701734766 //nine
) a=i=0; //reset i and a
}

константы int становятся ненужными большими, сдвигая << 8,
но в случае, если вы можете как-то сравнить со строками, это должно быть наиболее естественным

146 Использование сравнения строк

#define s|a==*(int*)
a,b;main(i){for(;~(b=getchar());printf(" %c"+!!i,b),a|=b<<8*i++)if(i>4 s"zero"s"one"s"two"s"four"s"five"s"six"s"nine")a=i=0;}

Использование сравнения строк

Запутанный

#define F(x)if(scanf(#x+B,&A)>0){printf(#x,&A);continue;}
B;A;main(i){for(;i;){B=1;F(\40e%4s)F(\40th%3s)F(\40se%3s)F(\40o%2s)B=2;F(\40tw%1s)F(\40si%1s)B=1;F(\40%4s)i=0;}}

— PrincePolka
источник

2

Желе , 44 байта

Ṛ¹Ƥz⁶ZUwÐ€“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳ¤$€Ẏḟ1Ṭœṗ

Попробуйте онлайн!

— Эрик Аутгольфер
источник

3

Извини, ты дважды переиграл.

— Захари

2

Довольно длинный. Добро пожаловать в гольф это вниз.

R , 109 байт

function(x)for(i in utf8ToInt(x)){F=F+i;cat(intToUtf8(i),if(F%in%c(322,340,346,426,444,448,529,536,545))F=0)}

Попробуйте онлайн!

— djhurio
источник

Любой способ использовать символы Unicode вместо цифр?

— Майкл Дорган

Хорошее приложение intToUtf8! 90 байтов были бы возможны при использовании другого подхода с использованием регулярного выражения:function(x,p=paste,z=p("(",p(c("zero",broman::numbers),collapse="|"),")"))gsub(z,"\\1 ",x)

— Michael M

2

Haskell , 81 байт

f[c]=[c]
f(h:t)=[' '|s<-words"z one tw th f s ei ni",and$zipWith(==)s$h:t]++h:f t

Попробуйте онлайн!

Объяснение:

f(h:t)=                      h:f t -- recurse over input string
   [' '|s<-               ]++      -- and add a space for each string s
      words"z one tw th f s ei ni" -- from the list ["z","one","tw","th","f","s","ei","ni"]
      ,and$zipWith(==)s$h:t        -- which is a prefix of the current string

— Laikoni
источник

2

Python 3 (без регулярных выражений) , 85 байт

i=3
while i<len(s):
	if s[i-3:i]in'ineiveroneghtwoureesixven':s=s[:i]+' '+s[i:]
	i+=1

Попробуйте онлайн!

— Alex
источник

2

Добро пожаловать в PPCG!

— Лайкони

Это хорошо, но полная программа должна включать код для ввода.

— Джонатан Аллан

Итак, в качестве полной программы 104 байта . Однако вы можете сохранить 4, используя, while s[i:]а затем вы можете уменьшить его до 93 байт , передав рекурсив lambda(функции должны только возвращать выходные данные, а не печатать их сами).

— Джонатан Аллан

2

Excel, 181 байт

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"z"," z"),"on"," on"),"tw"," tw"),"th"," th"),"f"," f"),"s"," s"),"ei"," ei"),"ni"," ni")

Размещает пространство перед: z, on, tw, th, f, s, ei,ni

— Wernisch
источник

2

Сборка Z80, 46 45 байт

; HL is the address of a zero-terminated input string
; DE is the address of the output buffer

Match5: ldi                                 ; copy remaining characters
Match4: ldi
Match3: ld a,32 : ld (de),a : inc de        ; and add space after a matched word.

Uncollapse:

        ld a,(hl) : ldi : or a : ret z      ; copy first byte (finish if it was zero)
        ex af,af'                           ; and save its value for later.

        ldi : ld a,(hl) : ldi               ; copy second and third bytes

        cp 'e' : jr z,Match3                ; is the third letter 'e' or 'o' or 'x'?
        cp 'o' : jr z,Match3
        cp 'x' : jr z,Match3

        ex af,af'                           ; now look at the first letter

        cp 'e' : jr z,Match5                ; is it 't' or 's' or 'e'?
        sub 's' : jr z,Match5
        dec a : jr z,Match5
        jr Match4

(Было забавно адаптировать классное регулярное выражение Уриэля к среде, не поддерживающей регулярные выражения).

— introspec
источник

1

Желе , 40 39 байт

“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳe€€@ŒṖẠ€TḢịŒṖK

Попробуйте онлайн!

Как это устроено

“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳe€€@ŒṖẠ€TḢịŒṖK
“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»                 = the compressed string of the digit names
                        Ḳ                = split at spaces
                         e€€@ŒṖ          = check whether each member of each partition of the argument is a digit.
                               Ạ€        = A function that checks whether all values of an array are true, applied to each element.
                                 T       = Finds the index of each truthy element 
                                  Ḣ      = Grab the first element, since we have a singleton array
                                    ịŒṖ  = The previous command gives us the index, partition that splits the input into digits. This undoes it and gives us the partition.
                                       K = Join the array of digits with spaces

— Zachary
источник

1

QuadS , 21 20 байт

..[eox]|[tse]?....
&

Попробуйте онлайн!

Это порт моего ответа сетчатки .

— Уриэль
источник

1

APL (Dyalog Unicode) , 25 байтов

'..[eox]|[tse]?....'⎕S'&'

Попробуйте онлайн!

— Эрик Аутгольфер
источник

1

Python 3 , без регулярных выражений, 83 68 65 63 байта

-15 благодаря Lynn (рефакторинг в единственную функцию)
-3 еще благодаря Lynn (избегайте индексации в список с более арифметикой)
... что приведет к другому сохранению 2 байтов (избегая скобок с отрицательными модулями) :)

def f(s):h=ord(s[0])*ord(s[1])%83%-7%-3+5;print(s[:h]);f(s[h:])

Функция, которая печатает слова, разделенные символами новой строки, а затем вызывает IndexError.

Попробуйте онлайн! (подавляет исключения, чтобы разрешить несколько запусков в наборе тестов)

— Джонатан Аллан
источник

Я вернусь к этому намного позже и пойму, что это может быть 68 байт:def f(s):h=[4,5,3][ord(s[0])*ord(s[1])%83%7%3];print(s[:h]);f(s[h:])

— Линн

Ух ты, h(s)а h(s)как я не заметил ?! Спасибо, Линн!

— Джонатан Аллан

Я не уверен, как я продолжаю возвращаться к этому вопросу и замечать новые вещи, но h=(ord(s[0])*ord(s[1])%83%7+1)%3+3составляет 65 байтов! :)

— Линн

Хех, спасибо, Линн, это позволило еще двум байтам сыграть в гольф!

— Джонатан Аллан

0

Желе , 36 байт

œṣj⁶;$}
W;“€ɗİẒmṫṃ¦¦ạỊɦ⁼Fḷeṭḷa»s2¤ç/

Попробуйте онлайн!

Алгоритм:

for x in ['ze', 'ni', 'on', 'tw', 'th', ...]:
    replace x in input by space+x

Могу поспорить, мы можем сделать еще лучше.

— Линн
источник

0

Mathematica, 125 байт

(s=#;While[StringLength@s>2,t=1;a="";While[FreeQ[IntegerName/@0~Range~9,a],a=s~StringTake~t++];Print@a;s=StringDrop[s,t-1]])&

Попробуйте онлайн!

TIO выводит сообщение об ошибке «CountryData» (???).
Я не знаю, почему это происходит, но на Mathematica все работает нормально

— J42161217
источник

0

Perl 6 , 42 30 байт

*.comb(/<{(0..9).Str.uninames.lc.words}>/)

Проверь это

{m:g/..<[eox]>||<[tse]>?..../}

Проверьте это
(Перевод из других ответов)

— Брэд Гилберт b2gills
источник

0

q / kdb +, 59 51 байт

Решение:

{asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x}

Пример:

q){asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x}"threesevensevensixninenineninefiveeighttwofiveeightsixthreeeight"
"three"
"seven"
"seven"
"six"
"nine"
"nine"
"nine"
"five"
"eight"
"two"
"five"
"eight"
"six"
"three"
"eight"

Объяснение:

Быстрое решение, возможно, лучшее и более подходящее для игры в гольф.

{asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x} / ungolfed solution
{                                                 } / lambda with implicit x as input
                                             cut x  / cut x at indices given by left
 asc[                                       ]       / sort ascending
                string`z`one`tw`th`f`s`ei`ni        / string list ("z","one",...)
          x ss/:                                    / string-search left with each right
     raze                                           / reduce down list

Примечания:

46 байтов при простом гольфе, заменяя q вызовов на k, но все же здоровенное решение.

asc[(,/)x ss/:($)`z`one`tw`th`f`s`ei`ni]cut x:

— streetster
источник

Развернуть цифры

задача

правила

Контрольные примеры

Сетчатка , 20 байт

C (gcc) , 89 80 76 75 72 71 70 69 байт

Python 2 , 50 байт

Befunge, 87 85 81 76 байт

Java (OpenJDK 8) , 55 46 43 байта

C (gcc) , 179 159 146 139 137 116 107 103 102 байта

JavaScript, 66 57 52 44 41 байт

Сетчатка , 24 23 байта

C 103 99 байт

Тестовая программа

J , 37 35 байт

C (gcc) , 106 байтов 104 102 байта

Сетчатка , 28 байт

Pyth , 35 27 23 байта

Пип , 27 байт

Желе , 23 21 байт

Как?

С 168 ,145,144141 байт

Желе , 44 байта

R , 109 байт

Haskell , 81 байт

Python 3 (без регулярных выражений) , 85 байт

Excel, 181 байт

Сборка Z80, 46 45 байт

Желе , 40 39 байт

Как это устроено

QuadS , 21 20 байт

APL (Dyalog Unicode) , 25 байтов

Python 3 , без регулярных выражений, 83 68 65 63 байта

Желе , 36 байт

Mathematica, 125 байт

Perl 6 , 42 30 байт

q / kdb +, 59 51 байт