Проверьте, состоит ли строка целиком из одной и той же подстроки

24

Это взято из этого вопроса (с разрешения конечно). Я процитирую:

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

Некоторые примеры:

'aa' //true
'aaa' //true
'abcabcabc' //true
'aba' //false
'ababa' //false
'weqweqweqweqweqw' // false

В частности, проверка строки, состоящей строго из повторяющихся подстрок ( Update ), может вывести любое истинное или ложное представление, но без ошибок, пожалуйста. Строго алфавитно-цифровые строки. В противном случае стандартный код правил гольфа. Это Code Golf, поэтому выигрывает самый короткий ответ в байтах для каждого языка.

code-golf  decision-problem 
— ouflak
источник
4
Хм, я собирался закрыть этот вызов как обман этого , но я заметил, что другой забивает на счет персонажа. Так что, возможно, мы должны закрыть другой (он также имеет принятый ответ) вместо этого.
— Эрик Outgolfer
— Эрик Outgolfer

Ответы:

11

Брахилог , 4 3 байта

ġ=Ṁ

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

объяснение

ġ=Ṁ    Implicit input, say "abcabc"
ġ      Split into chunks of equal lengths (except maybe the last one): ["abc","abc"]
 =     Apply the constraint that all of the chunks are equal,
  Ṁ    and that there are multiple of them.

Программа печатает, true.если ограничения могут быть выполнены, и false.если нет.

— Zgarb
источник
Я просто пытался найти что-то похожее ~j↙или =Ṁcработать, пока не заметил, что вы опубликовали это час назад
— несвязанная строка
4
О да, это может быть на один байт короче:ġ=Ṁ
— Несвязанная строка
( Ṁпеременная ограничена списком из двух или более элементов)
— Несвязанная строка
1
@UnrelatedString Отлично, спасибо! Я не думал проверять страницу переменных.
— Згарб
1
Много замечательных ответов, и ответ LUA занимает особое место в моем сердце. Ответ Арно особенно приятен, поскольку исходный вопрос, на котором я это основывал (а не обман), на самом деле помечен Javascript. В основном, выбирая этот вариант только потому, что он кажется самым коротким для всех языков, и, поскольку это мой первый вопрос, я получаю значок.
— ouflak
19

JavaScript (ES6), 22 байта

Возвращает логическое значение.

s=>/^(.*)\1+$/.test(s)

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

Без регулярного выражения  33  29 байт

Возвращает либо null(ложь), либо объект (правда).

s=>(s+s).slice(1,-1).match(s)

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

NB: Технически, s преобразуется в регулярное выражение для match () , поэтому приведенный выше заголовок является ложью.

— Arnauld
источник
9

grep, 19

grep -qxE '(.+)\1+'

Тест

while read; do 
  <<<"$REPLY" grep -qxE '(.+)\1+' && t="true" || t="false"
  echo "$REPLY: $t"
done < infile

Выход:

aa: true
aaa: true
abcabcabc: true
aba: false
ababa: false
weqweqweqweqweqw: false
— Тор
источник
9

Japt , 6 байт

²é ¤øU

Сохранено один байт благодаря @Shaggy

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

        Implicit input, stored in variable 'U'
²       U+U, "abcabc" -> "abcabcabcabc"
 é      Rotate 1 char to the right "abcabcabcabc" -> "cabcabcabcab"
   ¤    Remove first two chars, "cabcabcabcab" -> "bcabcabcab"
    øU  Check if U is in the above
— Воплощение невежества
источник
Nice один :) Вы можете заменить p<space>с ²сохранить байт.
— лохматый
9

Java, 25 24 байта

-1 байт благодаря Оливье Грегуару!
Скучный регулярный ответ

s->s.matches("(.+)\\1+")

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

Это всего лишь один байт больше , чем питон ответ AAAAA Я привязанной сейчас :)

— Бенджамин Уркхарт
источник
3
Вы можете удалить финал, так $как matchesметод является точным совпадением, а не совпадением подстроки по умолчанию.
— Оливье Грегуар
Я забыл matchesдобавить свое собственное $к регулярному выражению. Благодарность!
— Бенджамин Уркхарт
7

Excel, 26 байт

=FIND(A1,A1&A1,2)<=LEN(A1)

Входы от А1, выходы в любую ячейку, которую вы положили эту формулу

— София Лехнер
источник
Вы можете сохранить 4 байта, если вы определили однобуквенное имя диапазона (например A) и задали его в качестве ввода.
— i_saw_drones
@i_saw_drones - я думаю, что это запрещено стандартными правилами ввода-вывода: вот ссылка на мета-ответ , который применим к этому методу; это в настоящее время в -36 голосов.
— София Лехнер
Извинения я не видел этот пост, хотя думаю об этом, не A1 также «переменной», поскольку он содержит входное значение? :)
— i_saw_drones
1
Я чувствовал бы это так, если бы я делал что-то особенное с тем фактом, что это А1, например, если бы я как-то полагался на то, что его ROW (_) равен 1. Так как это просто самый естественный способ предоставления функции Excel с произвольный вход.
— София Лехнер
7

R , 28 байт

grepl("(.+)\\1+$",scan(,''))

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

Простая версия Regex. R (иногда) очень похож на Python, так что это похоже на ответ регулярного выражения Python 2 от TFeld, хотя и короче!

Вопрос (если кто-нибудь знает ответ)

Я все еще не понимаю, почему это работает, так как подстрока может быть любой длины и всегда будет работать, и все еще работает, когда я добавляю букву в начале допустимой строки, например «cABABABABAB». Если я лично читаю регулярное выражение, я вижу (.+), что оно охватывает любую группу любой длины. И затем, \\1+$который повторяет захваченную группу любое количество раз до конца.

Так почему же он не захватывает только «AB» и не находит, что оно повторяется до конца строки, тем более, что не указано никаких ограничений относительно того, где может начинаться подстрока?

— Sumner18
источник
1
Интересно, что это, похоже, ошибка в движке регулярных выражений R. Добавление опции perl=TRUEделает ее совпадающей с CABABAB, как и следовало ожидать. Запуск grep -E '(.*)\1+$'в bash также соответствует cABABAB, хотя и grep -Eиспользует ERE, предполагается, что тот же вариант регулярного выражения R должен поддерживать.
— Grimmy
2
Я предполагаю, что это неправильно примененная оптимизация. Изменение .+в начале паттерна ^.+является важной оптимизацией, но если оно .+находится внутри паренсов, оно перестает быть действительным.
— Grimmy
6

Желе ,  5  4 байта

Теперь я вижу, что оптимальный способ - следовать методу xnor !

Ḋ;Ṗw

Монадическая ссылка, которая принимает список символов и выводит целое число - минимально возможную длину повторяющегося фрагмента или ноль, если таковой не существует. Обратите внимание, что ноль - это ложь, в то время как ненулевые числа являются истинными в желе.

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

Как?

Ḋ;Ṗw - Link: list of characters, S   e.g. "abcabcabc"   or "abababa"
Ḋ    - dequeue S                           "bcabcabc"       "bababa"
  Ṗ  - pop from S                         "abcabcab"       "ababab"
 ;   - concatenate                "bcabcabcabcabcab"       "bababaababab"
   w - first index of sublist     3  ^---here!             0  (not found)
— Джонатан Аллан
источник
4

Python 2 , 24 байта

lambda s:s in(s*2)[1:-1]

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

Бесстыдно украденный у Хнора ответ на оригинальный вопрос.

Более интуитивная версия:

Python 2 , 59 55 53 байта

lambda s:s in[len(s)/i*s[:i]for i in range(1,len(s))]

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

Скучная версия регулярного выражения:

Python 2 , 44 байта

lambda s:re.match(r'(.+)\1+$',s)>0
import re

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

— TFeld
источник
3

PowerShell, 23 24 байта

+1 байт, чтобы полностью соответствовать правилам

"$args"-match"^(.+)\1+$"

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

Довольно скучный. На основании других ответов Regex. К счастью, PowerShell не используется \в качестве экранирующего символа!

— Габриэль Миллс
источник
он возвращается trueнаaabcabc
— Mazzy
1
@ mazzy только что исправили!
— Габриэль Миллс
3

C # (интерактивный компилятор Visual C #) , 70 байт

Бесстыдная адаптация xnor ( 46 байт )

s=>(s+s).Substring(1,s.Length*2-2).Contains(s)

Мое решение не Regex:

s=>s.Select((x,y)=>y).Count(z=>s.Replace(s.Substring(0,z+1),"")=="")>1

Объяснение:

Замените каждую возможную подстроку, которая начинается с индекса 0, пустой строкой. Если результатом является пустая строка, строка полностью состоит из этой подстроки. Поскольку это включает в себя оценку всей строки с самим собой, количество ожидаемых результатов должно быть больше 1.

Пример: abcabc

Возможные подстроки, начинающиеся с индекса 0:

'a', 'ab', 'abc', 'abca', 'abcab', 'abcabc'

Если мы заменим их пустыми строками

Substring          Result

'a'         =>     'bcbc'
'ab'        =>     'cc'
'abc'       =>     ''
'abca'      =>     'bc'
'abcab'     =>     'c'
'abcabc'    =>     ''

Поскольку существует подстрока, отличная от 'abcabc', которая возвращает пустую строку, строка полностью состоит из другой подстроки ('abc')

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

— Innat3
источник
3

Python 3 , 62 60 56 54 байта

-4 байта спасибо ArBo

lambda s:s in(len(s)//l*s[:l]for l in range(1,len(s)))
  1. Перебирайте все возможные префиксы в строке.
  2. Попробуйте построить строку из префикса.
  3. Верните, удастся ли это с каким-либо префиксом вообще.

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

— movatica
источник
1
Хороший ответ! f=Может быть отброшено; анонимные функции обычно разрешены. Кроме того, переключившись на Python 2 и проверив членство в списке вместо anyконструкции, вы можете получить 55 байтов
— ArBo
1
Хороший улов со списком участников, спасибо! Я не буду переходить на Python 2, так как это похоже на переключение языка, что, очевидно, не имеет значения;) Кроме того, есть ли удобный способ проверить анонимную функцию в TIO, сохраняя количество байтов?
— моватика
1
@movatica В заголовке поместите `f =` (\ - символ продолжения строки в python)
— Артемида поддерживает Монику
Досадно, \ также является побегом. Здесь, без форматирования кода, это то, что вы должны поместить в заголовок: f = \
— Артемида поддерживает Монику
2

Japt , 10 байт

Возвращает положительное число, если правда, и 0, если ложь. Если вы хотите вывод bool, просто добавьте -¡флаг

å+ k@rXÃÊÉ

å+ k@rXÃÊÉ      Full program. Implicit input U.
                    e.g: U = "abcabcabc"
å+              Take all prefixes 
                         U = ["a","ab","abc","abca","abcab","abcabc","abcabca","abcabcab","abcabcabc"]
   k@           Filter U by:
     rXÃ        Values that return false (empty string)
                when replacing each prefix in U
                e.g: ["bcbcbc","ccc","","bcabc","cabc","abc","bc","c",""]
                                take ↑                             and ↑
                     U = ["abc","abcabcabc"]
         ÊÉ     Get U length and subtract 1. Then return the result

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

— Луис Фелипе Де Иисус Муньос
источник
2

Шелуха , 6 байт

Ṡ€ȯhtD

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

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

объяснение

Ṡ€      Find the argument in the result of applying the following function to the argument
  ȯhtD  Duplicate the argument, then remove the first and last elements.
— София Лехнер
источник
2
€htD¹избегает ȯ.
— Згарб
Это чудесно! Я думал о, λ€htD¹но я не понимал, что лямбды будут добавлены неявно
— София Лехнер
2

Mathematica 11.x, 74 байта

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&

где, повсюду, #представляет входную строку, и

StringCases[#,<pattern>]

находит подстроки входной строки, соответствующие шаблону

StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")

Этот шаблон требует совпадений, xдолжен начинаться с начала строки и должен удовлетворять условию, что (1) совпадение не является всей входной строкой и (2) если мы заменим вхождения совпадения во входной строке пустой строкой мы получаем пустую строку. Наконец, сравнивая список совпадений с пустым списком,

{}!=

является Trueли список совпадений не пусто , и Falseесли список матчей пуст.

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

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aa"]
(*  True  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aaa"]
(*  True  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["abcabc"]
(*  True  *)

а также

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aba"]
(*  False  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["ababa"]
(*  False  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["weqweqweqweqweqw"]
(*  False  *)
— Эрик Тауэрс
источник
2

Python 3, 84 байта

import textwrap
lambda s:any(len(set(textwrap.wrap(s,l)))<2 for l in range(1,len(s)))

Использует textwrap.wrap(благодаря этому ответу ) разделить строку на куски длиныn чтобы проверить каждую возможную длину повторяющейся подстроки. Разделенные части затем сравниваются друг с другом, добавляя их в набор. Если все части равны, и набор имеет длину 1, то строка должна быть повторяющейся строкой. Я использовал <2вместо того, ==1потому что он сохраняет байт, и длина входной строки гарантированно будет больше нуля.

Если нет, nдля которого повторяющиеся подстроки длины nсоставляют всю строку, тогда верните false для всей функции.

— Деля Эрриксон
источник
2

05AB1E , 5 байтов

Метод xnor из предыдущего вопроса также представляется оптимальным в 05AB1E.

«¦¨så

Попробуйте онлайн! или как тестовый набор

объяснение

«       # append input to input
 ¦¨     # remove the first and last character of the resulting string
   så   # check if the input is in this string
— Emigna
источник
1
Конечно .. Я собирался сделать ответ 05AB1E, когда увидел, что там никого не было. Коллега задал мне несколько вопросов и рассказал о своем отпуске. Я оглядываюсь на экран: один новый ответ. Тада, бей снова XD
— Кевин Круйссен
@KevinCruijssen: Это типично. Это случалось и со мной несколько раз;)
— Эминья
2

Чисто , 73 байта

Не использует регулярные выражения.

import StdEnv,Data.List
$s=or[isPrefixOf s(cycle t)\\t<-tl(tails s)|t>[]]

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

Определяет $ :: [Char] -> Bool.
Проверяет, является ли данная строка префиксом повторения любой подстроки, взятой с конца.

— Οurous
источник
2

C ++ (gcc) , 36 байт

#define f(x)(x+x).find(x,1)<x.size()

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

Еще один порт решения Xnor. Использует макрос для расширения аргумента в выражении. Предполагается, что аргумент имеет тип std::string.

— jxh
источник
1

Переменная QlikView, 27 байт

Это должно быть определено как переменная, которая затем позволяет вам передавать параметры, например, $1как ваше входное значение.

Возвращает 0или -1(эквивалентно TRUE()функции QlikView ).

=substringcount($1&$1,$1)>2
— i_saw_drones
источник
1

Свифт, 196 байт

func r(s:String)->Bool{guard let k=s.dropFirst().firstIndex(where:{$0==s.first}) else{return false};let v=s[...k].dropLast();var w=v;while s.hasPrefix(w) && s.count>=(w+v).count{w+=v};return s==w}

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

— onnoweb
источник
Я не использую Swift, но я уверен, что лишние пробелы могут быть удалены
— Бенджамин Уркхарт
193 байта, используя предложение @ benjamin.
— Артемида поддерживает Монику
@ArtemisFowl или даже 123 байта
— Роман Подымов
1

T-SQL, 47 байт

Используя метод @ Xnor :

DECLARE @ varchar(max)='ababab'

PRINT sign(charindex(@,left(@+@,len(@)*2-1),2))

Сохраняя старый ответ, так как он содержит некоторые хорошие игры в гольф (67 байт):

DECLARE @y varchar(max)='abababa'

,@ INT=0WHILE
replace(@y,left(@y,@),'')>''SET
@+=1PRINT @/len(@y)^1

Объяснение: Этот сценарий повторяет попытку замены ввода «@y» первыми символами «@» ввода «@y» на пустые значения, увеличивая при этом «@».

если вы замените 'ab' в 'ababab' ничем, у вас будет пустая строка

В конце концов, результат будет пустым. Если это происходит, когда переменная цикла равна длине varchar, критерий равен false / 0, потому что '@' = len (@y) (повторяющегося varchar не было).

iif(@=len(@y),0,1)

можно сыграть в эту игру

@/len(@y)^1

потому что длина '@y' не может быть 0, а '@' никогда не будет превышать длину @y.

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

— t-clausen.dk
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.