Найди мои полифонты!

19

Для целей этой задачи, полифонт определяется как непрерывный фрагмент строки, который содержит только гласные и имеет длину не менее 2. Учитывая непустую строку в качестве входных данных, ваша задача состоит в том, чтобы вывести все содержащиеся в нем полифтонги ,

Например, "abeoic"имеет следующие смежные срезы (разделенные пробелом):

a b e o i c ab be eo oi ic abe beo eoi oic abeo beoi eoic abeoi beoic abeoic

Удаляя те, которые содержат что-либо, кроме гласных, или имеют длину меньше 2, мы получаем желаемые полифонты:

eo oi eoi

Ваши материалы должны соответствовать следующим правилам:

  • Вы можете выбрать строчные или прописные буквы для ввода / вывода, но регистр вывода должен соответствовать регистру ввода.

  • Гласные aeiou(для строчных AEIOUбукв) и (для прописных). y/ Yне считается гласным.

  • Ввод будет содержать только печатный ASCII.

  • Если полифонт появляется несколько раз, вы можете выбрать его вывод только один раз или выводить все его вхождения.

  • Разрешен любой разумный формат и метод ввода / вывода (списки символов также хороши как для ввода, так и для вывода).

Тестовые случаи

Ввод -> Выход (в нижнем регистре)

r67 ^^ () * 6536782! 87 -> []
программирование головоломок и кода игры в гольф -> []
ааа ... я победил! -> ['аа', 'аа', 'ааа']
abeoic -> ['eo', 'oi', 'eoi']
yah eioo ala -> ['ei', 'io', 'oo', 'eio', 'ioo', 'eioo']
@yabeeeayio__e -> ['ee', 'ee', 'ea', 'io', 'eee', 'eea', 'eeea']
0ioen0aaiosnjksd -> ['io', 'oe', 'aa', 'ai', 'io', 'ioe', 'aai', 'aio', 'aaio']

Обратите внимание, что для тестовых случаев 3 и 6 вы можете вывести 'aa'и, 'ee'соответственно, только один раз (см. Четвертое правило).

Это код-гольф , выигрывает самая короткая подача в байтах на каждом языке!

code-golf  string 
— Мистер Xcoder
источник
Обратите внимание, что это было изначально опубликовано как CMC (Chat Mini Challenge) в «Девятнадцатом байте» , но Адам сказал, что он подходит для Main , поэтому я в итоге опубликовал это.
— г-н Xcoder
Я твой третий тестовый случай, 'aa'появляется дважды. Нужно ли выводить одну и ту же строку несколько раз, если она появляется в разных местах, или можно выводить только уникальные полифонты?
— Джонатан Фрех
@JonathanFrech Хорошо, я думаю, что вывод уникальных полифтонгов в порядке. Буду редактировать.
— г-н Xcoder
Имеет ли значение порядок вывода?
— овс
1
@Xophmeister Для целей этой задачи полифонт определяется как - я знаю, что это неправильное лингвистическое определение :-)
— Mr. Xcoder

Ответы:

7

Python 2 , 102 97 байт

спасибо @JonathanFrech за -5 байтов

w=input();l=range(len(w)+1)
print{w[a:b]for a in l for b in l if b-a>1<set(w[a:b])<=set('aeiou')}

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

ввод / вывод в нижнем регистре

— овс
источник
1
Я думаю, что вам не нужно ...AEIOU', так как вы можете принимать только строчные буквы в качестве входных данных.
— Джонатан Фрех
— Джонатан Фрех
@JonathanFrech print([w[a:b]for a in l for b in l[a+2:]if{*w[a:b]}<={*'aeiou'}])работает на 93.
— Линн
@Lynn И ваше решение выдает 96 байт Python 2 .
— Джонатан Фрех
6

JavaScript (ES6), 77 75 байт

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

w=>(r=[],g=s=>w.match(s)&&[...'aeiou'].map(c=>g(s+c),s[1]&&r.push(s)))``&&r

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

Показать фрагмент кода

Как?

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

w => (                      // given the input w
  r = [],                   // r = array of results
  g = s =>                  // g = recursive function taking s
    w.match(s) &&           // if w contains s:
    [...'aeiou'].map(c =>   //   for each vowel c:
      g(s + c),             //     do a recursive call with s + c
      s[1] &&               //     if s is at least 2-character long:
      r.push(s)             //       push it into r
    )                       //   end of map()
)``                         // initial call to g() with s = ''
&& r                        // return r
— Arnauld
источник
6

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

M!&`[aeiou]+
r!&`..+

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

Это печатает все вхождения полифтонга.

объяснение

У Retina есть способ получить все совпадающие совпадения, но на самом деле это означает, что он будет искать по одному совпадению с каждой позиции. Таким образом, если есть несколько совпадений из одной и той же позиции, это вернет только один из них. Единственный способ действительно получить все перекрывающиеся совпадения - это использовать эту функцию дважды, один раз сопоставляя слева направо и один раз справа налево (чтобы сначала мы получили максимально возможное совпадение из каждой возможной начальной позиции, а затем мы также получили все совпадения для возможные конечные позиции).

Итак, актуальная программа:

M!&`[aeiou]+

Получить все перекрывающиеся серии гласных. Что это действительно означает, так это получить все суффиксы всех гласных серий.

r!&`..+

Теперь получите все префиксы длиной не менее 2, сопоставляя их справа налево. Здесь Mподразумевается, потому что это последняя строка программы.

— Мартин Эндер
источник
Можете ли вы объяснить код?
— Адам
!&`[aeiou]{2,}это так близко к правильному , есть ли способ сделать его более жадным, чтобы он соответствовал io?
— AdmBorkBork
1
@ Adám Добавил объяснение.
— Мартин Эндер
@AdmBorkBork Мое объяснение объясняет, почему это не может работать. Retina не работает с реальным движком регулярных выражений, поэтому самое большее, что &можно сделать, это попытаться найти совпадение с каждой позиции, чтобы вы не могли иметь несколько совпадений разной длины из одной и той же позиции. Вот почему мне нужен второй этап.
— Мартин Эндер
Хорошее объяснение, спасибо.
— AdmBorkBork
5

QuadS , 20 + 1 = 21 байт

⊃,/⍵
[aeiou]+
1↓,\⍵M

с oфлагом

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

В порядке происходящего:

[aeiou]+ на каждом матче этого PCRE

,\⍵M префиксы матча

1↓ опустить первый (в котором есть один гласный)

,/⍵ объединить все списки префиксов

⊃ раскрыть (потому что сокращения /включают)

Это эквивалентно неявной функции Dyalog APL:

{⊃,/⍵}'[aeiou]+'⎕S{1↓,\⍵.Match}⍠'OM'1

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

— Адам
источник
4

Java (OpenJDK 8) , 138 135 134 байтов

s->{String e,x="";for(int i=0,j,y=s.length();i<=y;i++)for(j=y;j>i;x+=e.matches("[aeiou]{2,}")?e+" ":"")e=s.substring(i,j--);return x;}

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

— Роберто Грэм
источник
i<y-1Может быть i<=yи String#matchesнеявные проверки всей строки, поэтому вам не нужны ^ и $. +1 за то, что избил меня до этого. Собирался опубликовать свой собственный 138-байтовый ответ (но с этими изменениями я предложил твой короче). :)
— Кевин Круйссен
3

Желе , 9 байт

ẆḟÐḟØcḊÐf

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

объяснение

ẆḟÐḟØcḊÐf  Main Link
Ẇ          Get all (contiguous) sublists
  Ðḟ       Filter; remove all elements where the result is truthy:
 ḟ  Øc     Filter; remove all vowels; if it's truthy, then it contains non-vowels
       Ðf  Filter; keep elements where the result is truthy:
      Ḋ    Dequeue; return all but the first element (truthy if the length was at least 2)

-4 байта благодаря мистеру Xcoder

— HyperNeutrino
источник
11 байтов путем замены L>1$$на L’$.
— Мистер Xcoder
На самом деле вы можете заменить L’$с Ḋна 9 байт . Эквивалент будет ẆṫLḊḟÐḟØc.
— г-н Xcoder
3

C (gcc) , 104 байта (99 байтов только со строчными или только заглавными буквами)

Да, это утечки - и что? 

#include<string.h>
a;f(char*s){*s&&f(s+1);for(a=strspn(s=strdup(s),"AEIOUaeiou");a>1;)s[a--]=0,puts(s);}

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

— Хаген фон Айцен
источник
3
Кажется, что работает без#include , и вам нужно обрабатывать только один регистр букв, так что вы можете сократить его до 80 байтов.
— Steadybox
— floorcat
3

R , 137 байт

переиграл Марка !

function(S)(x=unlist(sapply((s=el(strsplit(S,"[^aeiou]")))[nchar(s)>1],function(x)substring(x,1:(n=nchar(x)),rep(n:1,e=n)))))[nchar(x)>1]

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

function(S){
 s <- el(strsplit(S,"[^aeiou]"))            # split on non-vowels
 s <- s[nchar(s)>1]                         # vowel groups of length at least 2
 p <- function(x){                          # generates all substrings of inputs
  n <- nchar(x)
  start <- 1:n
  stop <- rep(n:1, n)                       # this will generate dups
  substring(x, start, stop)

 }
 q <- unlist(sapply(s, p))                  # all substrings
 q <- q[nchar(q)>1]                         # all length-2 or more substrings
}

— Giuseppe
источник
Вам не нужно unique.
— г-н Xcoder
«Разрешен любой разумный формат и метод ввода / вывода (списки символов также хороши как для ввода, так и для вывода)». Я не пробовал, но я подозреваю, что это может быть намного короче, если вы используете списки персонажей с самого начала.
— user2390246
@ user2390246 возможно. Я не уверен, что это обязательно помогло бы, но это, вероятно, только потому, что подход к выделению серий гласных был бы совсем другим, и я не могу обернуть это прямо сейчас.
— Джузеппе
2

PowerShell , 93 88 байт

param($a)0..($b=$a.count-1)|%{($i=$_)..$b|%{-join$a[$i..$_]}}|?{$_-match'^[aeiou]{2,}$'}

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

Использует ввод / вывод в нижнем или верхнем регистре (или сочетание!).

Заимствует код из моего ответа на покомпонентных подстроках , чтобы получить все подстроки, а затем вытаскивает то , что регулярное выражение -matchпротив ^[aeiou]{2,}$- то есть те, которые по крайней мере , две гласные в длине и только гласные. Эти строки остаются в конвейере и вывод неявный.

— AdmBorkBork
источник
2

Haskell , 148 137 130 123 118 байт

Спасибо @Laikoni за -11 байтов, еще -7 байтов, указав мне на подсказки для игры в гольф, еще -7 байтов и еще -5 байтов, в общей сложности колоссальные -30 байтов.

Это выглядело как хорошая подгонка для Хаскелла, но результат, похоже, не совпадает. Я полагаю, что Хаскелл был хорошим выбором в конце концов. Я все еще раздражен тем, как subsequencesработает, хотя.

import Data.List
v=(`elem`"aeiou")
p s=nub$do x<-groupBy((.v).(&&).v)s;[y|y@(c:_:_)<-subsequences x,v c,y`isInfixOf`x]

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

— Xiyng
источник
1
Добро пожаловать в гольф Haskell! Возможно, вас заинтересует наша коллекция советов по игре в гольф , руководство по правилам игры в гольф и раздел «Монады и мужчины» , наш чат на Haskell.
— Лайкони
1
Некоторые примечания к вашему ответу: Количество строк в новой строке равно количеству байтов ;, но повышает читаемость кода. Вы всегда используете eвместе с v, так что вы можете напрямую объявить e=(Elem "aeiou"). y!!0короче head y. Есть concatMapвместо concat.map, но еще короче - (=<<)из списка монада, которая имеет тот же эффект.
— Лайкони
1
Вы можете импортировать Data.Listsвместо Data.List. У первого есть все функции последнего, но также есть дополнительные вещи, такие как powerslice, который дает список всех непрерывных подпоследовательностей.
— Ними
1
В понимании списка, вы можете сравнить, y@(h:_:_)чтобы сбросить length y>1и сократить v(y!!0)до v h.
— Лайкони
1
У меня есть еще два туза в рукаве: (1) (\x y->v x&&v y)можно сократить, преобразовав в без очков, либо вручную, используя этот совет, либо с помощью pointfree.io . (2) Монаду со списком также можно использовать с doобозначениями, то есть так do x<-l;[...]же, как l>>=(\x->[...]). Кстати, в TIO вы можете поместить свой mainзаголовок или поле нижнего колонтитула, чтобы количество байтов совпадало с фактической отправкой.
— Лайкони
2

Perl, 45 байт

local $,=" ";print $_=~/(?=([AEIOU]{2,}))/ig;
— Джинн Рикерби
источник
Добро пожаловать в PPCG! Хороший первый пост!
— Rɪᴋᴇʀ
1
В случае, если вы задаетесь вопросом о понижении голосов, оно было автоматически размещено учетной записью бота Сообщества, поскольку ваше сообщение было отредактировано. Извините, мы ничего не можем поделать, это глупое поведение. Надеемся, что откаты должны вызвать автоматический откат понижения.
— HyperNeutrino
2

R , 120 байт 110 байт

function(x){k=nchar(x);i=k:1;e=expand.grid(i,i[-1]);grep("^[aeiou]+$",mapply(substr,x,e[,2],e[,2]+e[,1]),v=T)}

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

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

function(x){                  #initalize the anonymous function where input is stored in x
  k=nchar(x)                  #set k to the number of characters in x
  i=k:1                       #create vector of integers from k to 1
  e=expand.grid(i,i[-1])      #create matrix of full outer join on i 
                              #except in the second column, limit i to being less than k
  grep("^[aeiou]+$",          #search for strings made of only vowels
       mapply(substr,         #map the substring function
              x,              #with x as the string to subset
              e[,2],          #start at the second column of the outer join
              e[,2]+e[,1]     #end at the sum of the sum of the first and second columns
       ),
       v=T                    #if a match is found, return it's value
  )
}                             #by default, R returns the last line of a function
— отметка
источник
Хороший подход на 105 байт , я добавлю комментарий к своему решению, отметив, что вы превзошли меня :)
— Giuseppe
Я буду честен, я был очень рад, что смог найти альтернативное решение для вас :) Обычно вы уже опережаете меня или выясняете весь код, который я оставил на столе.
— Марк
1

JavaScript (ES6), 105 байт

s=>eval('a=[];l=i=s.length;while(i--){j=l;while(j--)if(/^[aeiou]{2,}$/.test(t=s.slice(i,j)))a.push(t)}a')

Вероятно, есть еще много игры в гольф.

let f=
s=>eval('a=[];l=i=s.length;while(i--){j=l;while(j--)if(/^[aeiou]{2,}$/.test(t=s.slice(i,j)))a.push(t)}a')
console.log(JSON.stringify(f('r67^^()*6536782!87')))
console.log(JSON.stringify(f('programming puzzles and code golf')))
console.log(JSON.stringify(f('aaand... i won!')))
console.log(JSON.stringify(f('abeoic')))
console.log(JSON.stringify(f('yah eioo ala')))
console.log(JSON.stringify(f('@yabeeeayio__e')))
console.log(JSON.stringify(f('0ioen0aaiosnjksd')))
Развернуть фрагмент

— Патрик Робертс
источник
1

05AB1E , 10 байтов

Œʒg≠}ʒžMм_

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

Пояснения:

Œʒg≠}ʒžMм_  
Π           Push all substrings (abeoic => a, b, e, ..., eoi, eoc, ... abeioc)
 ʒ  }        Filter elements for which result is 1
  g≠            Push 1 if length is != 1, 0 otherwise
     ʒ       Filter elements for which result is 1
      žMм       Remove all occurences of 'aeiou' from element
         _      Negative bool: push 1 if length == 0, 0 otherwise
— scottinet
источник
Хороший ответ! Я имелŒʒžMм_}ʒg≠
— г-н Xcoder
@ Mr.Xcoder Спасибо. У меня тоже было ŒD1ùKʒžMм_по 10 байт. Я пытаюсь найти способ
— сыграть
1

C 105 75 байт

Функция, принимающая указатель на ввод нижнего регистра и создающая разделенные пробелами строки в стандартном выводе:

i;f(char*p){for(i=strspn(p,"aeiou");i>1;)printf("%.*s ",i--,p);*p&&f(p+1);}

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

#include <stdio.h>

int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        char *in = argv[i];
        printf("'%s' -> [ ", in);
        f(in);
        puts("]");
    }
}

демонстрация

'r67^^()*6536782!87' -> [ ]
'programming puzzles and code golf' -> [ ]
'aaand... i won!' -> [ aaa aa aa ]
'abeoic' -> [ eoi eo oi ]
'yah eioo ala' -> [ eioo eio ei ioo io oo ]
'@yabeeeayio__e' -> [ eeea eee ee eea ee ea io ]
'0ioen0aaiosnjksd' -> [ ioe io oe aaio aai aa aio ai io ]

объяснение

#include <string.h>
#include <stdio.h>

void find_polyphthongs(char *p)
{
    /* from longest polyphthong substring down to 2 */
    for (int i = strspn(p,"aeiou");  i >= 2;  --i) {
        /* print exactly [p .. p+i] */
        printf("%.*s ", i, p);
    }

    /* tail-recurse to next char */
    if (*p) {
        find_polyphthongs(p+1);
    }
}

Используя GCC в Debian Linux, я, кажется, сходит с рук несовместимыми неявными объявлениями strchr()и printf(). Другие платформы могут требовать <stdio.h>и <string.h>быть включены.

Попробуйте онлайн (требуется Javascript).

— Тоби Спейт
источник
Не f(p)char*p;может быть f(char*p)?
— Джонатан Фрех
Совершенно верно - я изначально имел выход на хранение вызывающего распределённый: f(s,d)char*s,*d.
— Тоби Спейт
— Джонатан Фрех
1

APL (Дьялог) , 53 байта

Это Dfn( д Прям ая е unctio п ). Использование есть p '<argument>'. Справедливое предупреждение: это не очень эффективно и время ожидания для input > 8 charactersTIO, но работает нормально, когда достаточно времени.

p←{(G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵}

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

Спасибо @ Adám за 16 байтов!

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

Это легче понять, если мы разбиваем код на более мелкие части:

  • Часть 1 G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵: эта часть функции принимает длину (правого) аргумента и смешивает вектор aeiouс самим собой много раз, получая все возможные комбинации[2, length(right arg)] гласных.
  • Часть 2 (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: эта часть проверяет, какие элементы из G являются членами подстрок ввода. Это возвращает логический вектор, с 1's' на индексах комбинаций гласных, которые присутствуют во входных данных, и 0там, где их нет. Полученный вектор затем отображается ( /) G, возвращая элементы, соответствующие истинным значениям.

Все это затем назначается p. p←не включается в число байтов, потому что это не обязательно , просто облегчает использование функции.

— Ж. Салле
источник
Гольф дальше. Кроме того, вы не должны использовать ⊆для фильтрации. Использование /.
— Адам
1

Рубин 2.4, 100 байт

(2..(b=(a=gets).size-1)).to_a.flat_map{|i|(0..(b-i)).to_a.map{|j|a[j,i]}}.select{|k|k=~/^[aeiou]+$/}

Это моя первая попытка игры в гольф, и я уверен, что есть много способов сократить этот код.

— Alex
источник
0

T-SQL (SQL Server 2014), 281 байт

;with s as(select substring(@,1,1)C,stuff(@,1,1,'')D,1 R union all select substring(D,1,1),stuff(D,1,1,''),R+1from s where len(D)>0),c as(select R i,C w from s where C LIKE'[aeiou]'union all select R,w+C from c join s ON i+1=R where s.C LIKE'[aeiou]')select w from c where len(w)>1

Ввод дает

declare @ varchar(max) = 'abeoic'

Использует общее табличное выражение sдля разделения ввода на упорядоченные отдельные буквы, а затем второе общее табличное выражениеc для генерации всех упорядоченных комбинаций, выбрасывая не гласные.

SQL Fiddle

— Брайан Дж
источник
0

PHP, 139 байт

function y($s){$p=[];$l=strlen($s);for($i=2;$i<=$l;$i++)for($j=0;$j<=$l-$i;$j++)strspn($a=substr($s,$j,$i),'aeiou')==$i&&$p[]=$a;return$p;}

Онлайн демо

function yreadable($s)
{
    $p = [];
    $l = strlen($s);
    for($i=2; $i<=$l; $i++)
        for($j=0; $j<=$l-$i; $j++)
            strspn($a=substr($s,$j,$i),'aeiou')==$i
            && $p[] = $a;
    return $p;
}

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

Выберите подстроки (начиная с длины 2), состоящие из соседних символов, и двигайтесь вдоль строки. Соберите все подстроки, которые содержат только гласные. Повторите с более длинными подстроками.

Для строки 'abcdef' это сгенерированные и проверенные подстроки:

'ab','bc','cd','de','ef'
'abc','bcd','cde','def'
'abcd','bcde','cdef'
'abcde','bcdef',
'abcdef'
— Progrock
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.