ОБНОВЛЕНИЕ : подчинение Исаака Pyth является победителем!

Многие из вас, должно быть, слышали, что в городе есть более прохладная версия JavaScript (см. ES6), в которой есть метод String.prototype.repeat, позволяющий

"Hello, World!".repeat(3)

и получить

"Hello, World!Hello, World!Hello, World!"

в качестве выхода.

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

т.е. входная строка может быть представлена ​​как точное nповторение времен меньшей строки. Вывод (как оператор возврата функции или STDOUT) должен быть правдивым, если строка может быть, или ложным, если строка не может быть представлена ​​как повторение строки меньшего размера.

Некоторые примеры ввода:

"asdfasdfasdf"  // true
"asdfasdfa"     // false
"ĴĴĴĴĴĴĴĴĴ"     // true
"ĴĴĴ123ĴĴĴ123"  // true
"abcdefgh"      // false

Обратите внимание, что последний ввод ложен, поэтому nдолжен быть больше1

Полные правила

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

Пиф , 9

/:+zz1_1z

Или

}z:+zz1_1

Оба являются близкими переводами ответа Python @ xnor, за исключением того, что они принимают ввод из STDIN и распечатывают его. Первый эквивалентен:

z = input()
print((z+z)[1:-1].count(z))

0 для False, 1 для True.

Вторая строка эквивалентна:

z = input()
print(z in (z+z)[1:-1])

Ложь за ложь, правда за правда.

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

Python (24)

lambda s:s in(s+s)[1:-1]

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

Regex (на ECMAScript), 11 байт

Похоже, работа для регулярных выражений!

^([^]+)\1+$

Проверьте это здесь.

Я выбрал ECMAScript, потому что это единственный вариант (я знаю), который [^]соответствует любому символу. Во всех остальных случаях мне понадобится флаг для изменения поведения .или использование на [\s\S]три символа длиннее.

В зависимости от того, как мы рассчитываем флаг, который мог бы , конечно , быть байт короче. Например, если мы посчитаем pattern + flags (например, игнорируя разделители), эквивалент PCRE / Perl будет

/^(.+)\1+$/s

Что составляет 10 байт, игнорируя разделители.

Проверьте это здесь.

Это соответствует только строкам, которые состоят как минимум из двух повторений некоторой подстроки.

Вот полная 26-байтовая функция ES6, но я утверждаю, что регулярные выражения в общем случае допустимы:

f=s->/^([^]+)\1+$/.test(s)

CJam, 9

q__+)@+#)

Похоже на идею Кснора.

q      " Read input. ";
__+    " Duplicate twice and concatenate them together. ";
)      " Remove the last character of the longer string. ";
@+     " Insert that character at the beginning of the shorter string. ";
#)     " Find the shorter string in the longer string, and increase by one. ";

APL, 11

2<+/x⍷,⍨x←⍞

Пояснение
⍞ берет строковый ввод из экранных присвоений
x←переменной, x
,⍨объединяет строку с самим
x⍷поиском xв результирующей строке. Возвращает массив, состоящий из 1 в начальной позиции совпадения и 0 в другом месте.
+/суммирует
2<проверку массива, если сумма больше 2 (так как будет 2 тривиальных совпадения)

CJam, 10 байтов

Я поймал ошибку CJam. Мой первый ответ, так что, вероятно, можно сыграть в гольф еще:

q__+(;);\#

Выходы -1 для FALSE и число> = 0 для TRUE

GolfScript, 10 байт

..+(;);\?)

Еще одна реализация умной идеи xnor.

Python - 59 57

lambda s:any([s*n==s[:n]*len(s)for n in range(2,len(s))])

Чистый bash, 30 байтов

Простой порт умного ответа @ xnor :

[[ ${1:1}${1:0: -1} =~ "$1" ]]

Код выхода 0 для ИСТИНА и 1 для ЛОЖЬ:

$ for s in 'Hello, World!Hello, World!Hello, World!' 'asdfasdfasdf' 'asdfasdfa' 'ĴĴĴĴĴĴĴĴĴ' 'ĴĴĴ123ĴĴĴ123' 'abcdefgh'; do echo "./isrepeated.sh "\"$s\"" returns $(./isrepeated.sh "$s"; echo $?)"; done
./isrepeated.sh "Hello, World!Hello, World!Hello, World!" returns 0
./isrepeated.sh "asdfasdfasdf" returns 0
./isrepeated.sh "asdfasdfa" returns 1
./isrepeated.sh "ĴĴĴĴĴĴĴĴĴ" returns 0
./isrepeated.sh "ĴĴĴ123ĴĴĴ123" returns 0
./isrepeated.sh "abcdefgh" returns 1
$ 

Заметка =~ в [[ ... ]]это регулярное выражение оператора в Баш . Тем не менее «Любая часть шаблона может быть заключена в кавычки, чтобы заставить его быть сопоставленным как строка» . Поэтому, как часто бывает в случае с bash, очень важно получить правильное цитирование - здесь мы просто хотим проверить соответствие строки, а не совпадение с регулярным выражением.

TI-BASIC - 32

Я думал, что попробую токенизированный язык. Выполнить со строкой в ​​Ans, возвращает 0, если false, и длину повторяемой строки, если true.

inString(sub(Ans+Ans,1,2length(Ans)-1),sub(Ans,length(Ans),1)+Ans

Удивительно, как это однострочно.

ECMAScript 6 (189)

(function(){var S=String.prototype,r=S.repeat;S.isRepeated=function(){return!1};S.repeat=function(c){var s=new String(r.call(this,c));if(c>1)s.isRepeated=function(){return!0};return s}}());

< console.log("abc".isRepeated(),"abc".repeat(10).isRepeated());
> false true

Конечно, это единственное правильное решение? Например, слово (строка) nanaне обязательно создается из"na".repeat(2)

ECMAScript 6 (34 36 )

Другой ES6 ответ, но без использования repeatи с использованием трюка XNOR в :

f=i=>(i+i).slice(1,-1).contains(i)

Должен запускаться в консоли браузера с поддержкой ES6, такого как Firefox.

С 85

l,d;f(s){return l=strlen(s),strstr(d,strcpy(strcpy(d=alloca(l*2+1),s)+l,s)-1)-d-l+1;}

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

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

объяснение:

int length, 
    duplicate;
int is_repetition(char *input)
{
    // length = "abc" -> 3
    length = strlen(input);
    // alloca because the function name is as long as "malloc" 
    // but you don't have to call free() because it uses the stack
    // to allocate memory
    // duplicate = x x x x x x + x
    duplicate = alloca(length*2 + 1);
    // duplicate = a b c 0 x x + x
    strcpy(duplicate, input);
    // duplicate = a b c a b c + 0
    strcpy(duplicate + length, input);
    if (strstr(duplicate,duplicate + length - 1) != duplicate + length - 1)
        // repetition
        // e.g. abab -> abababab -> aba[babab]
        // -> first occurence of [babab] is not aba[babab]
        // but a[babab]ab -> this is a repetition
        return 1;
    else
        // not repetition
        // e.g. abc -> abcabc -> ab[cabc]
        // -> first occurence of [cabc] is ab[cabc]
        // it matches the last "cabc"
        return 0;
}

ECMAScript 6 (59 62 67 73 )

Не победитель, но кажется, что в ES6 должен быть хотя бы один ответ на этот вопрос, который фактически использует repeatфункцию:

f=i=>[...i].some((_,j)=>i.slice(0,j).repeat(i.length/j)==i)

Должен запускаться в консоли браузера с поддержкой ES6, такого как Firefox.

Это делает много ненужных итераций, но зачем делать это дольше, чтобы избежать этого, верно?

• Редактирование № 1: Сохранение нескольких байтов путем преобразования его в функцию. Спасибо Оптимизатору!
• Редактирование # 2: Спасибо hsl за трюк с оператором распространения, чтобы сохранить больше байтов!
• Правка № 3: И спасибо Робу У. за еще 3 байта!

Желе , 3 байта

ṙJċ

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

То же, что и этот ответ (может быть, более поздний вызов - это обобщение?).

Java 8, 28 байт

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

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

Объяснение:

Проверяет, соответствует ли input-String регулярному выражению, где String#matchesнеявно добавляет, ^...$чтобы соответствовать всей String.
Объяснение самого регулярного выражения:

^(s?)(.+)\1+$
^                Begin of the string
 (s?)            Enable DOTALL-mode, where `.` also matches new-lines
     (           Open capture group 1
      .+          One or more characters
        )        Close capture group 1
         \1+     Plus the match of the capture group 1, one or more times
            $    End of the string

Таким образом, он в основном проверяет, повторяется ли подстрока два или более раз (с поддержкой новых строк).