Vòng hoa từ

Một từ vòng hoa là một từ có thể được xâu chuỗi lại với nhau như một vòng hoa, bởi vì nó kết thúc bằng cùng một chữ cái mà nó bắt đầu bằng. Những nhóm chữ này thậm chí có thể chồng lên nhau!

Ví dụ, undergroundlà một từ theo thứ tự vòng hoa 3, bởi vì nó bắt đầu và kết thúc với cùng 3 ký tự , und. Điều này có nghĩa là nó có thể được xâu chuỗi lại với nhau như thế undergroundergrounderground....

alfalfalà một từ vòng hoa, quá! Đó là thứ tự 4. Nó bắt đầu và kết thúc với alfa. Nó có thể được xâu chuỗi lại với nhau như vậy : alfalfalfalfa.

Một quá trình mà tôi gọi là garlandifying là khi bạn xác định thứ tự ncủa từ vòng hoa, bạn lấy từ gốc và thêm phân đoạn cần thiết để có vòng lặp như một nlần vòng hoa . Vì vậy, vì onionlà một 2từ vòng hoa đặt hàng , bạn sẽ lấy onion, cắt bỏ các 2chữ cái đầu tiên để nhận ionvà thêm nó vào thời điểm kết thúc 2để có được onionionion.

Mục tiêu

Tạo một chương trình hoặc hàm lấy đầu vào từ đầu vào tiêu chuẩn hoặc đối số hàm và in ra hoặc trả về từ, được tô màu.

Tất cả các từ sẽ là chữ thường và thứ tự cao nhất có thể cho một từ là length(word) - 1.

Ví dụ I / O

"onion"       --> "onionionion"
"jackhammer"  --> "jackhammer"
"abracadabra" --> "abracadabracadabracadabracadabracadabra"
""            --> ""
"zvioz"       --> "zviozvioz"
"alfalfa"     --> "alfalfalfalfalfalfa"
"aaaa"        --> "aaaaaaa"

Đây là mã golf , vì vậy số byte ít nhất sẽ thắng.

Pyth, 19 18 byte

+z*>Kf!xz>zT1zl>zK

Dùng thử trực tuyến: Trình diễn hoặc thử nghiệm khai thác

Giải thích:

+z*>Kf!xz>zT1zl>zK   implicit: z = input string
     f      1        find the first number T >= 1, which satisfies:
         >zT            all but the first T chars of z
       xz               index of ^ in z
      !                 == 0
    K                store in K
                     the order is length(z) - K
   >K        z       the last K chars
  *                  repeated
              l>zK   len(all but the last K chars) times
+z                   insert z at the beginning

Python, 60 byte

f=lambda s,i=1:s.find(s[i:])and f(s,i+1)or(len(s)-i)*s[:i]+s

Hy vọng cho tốt hơn, nhưng oh tốt. s.findlàm việc gọn gàng ở đây thay cho not s.startswith.

Võng mạc , 58 byte

.+
$0#$0
(.*)(.+)#.*\1$
$0#$1#$2-
+`\w#(\w*)-
#$1-$1
#.*-
<empty line>

Mỗi dòng nên đi đến tệp riêng của nó nhưng bạn có thể chạy mã dưới dạng một tệp có -scờ.

Bốn cặp thay thế làm như sau:

• Từ trùng lặp để chúng ta có thể tìm kiếm trùng lặp quá.
• Nối từ chia thành ordersố lượng ký tự.
• Nối các phần orderthời gian cuối cùng .
• Giữ từ gốc và phần cuối cùng được thêm vào và bỏ mọi thứ khác.

Chuỗi trạng thái cho ví dụ onion:

onion
onion#onion
onion#onion#on#ion-
onion#onion##ion-ionion
onionionion

Haskell, 64 byte

g s=[b>>a|(a,b)<-map(`splitAt`s)[1..],and$zipWith(==)s b]!!0++s

Các xét nghiệm:

λ: g "onion"       == "onionionion"
True
λ: g "jackhammer"  == "jackhammer"
True
λ: g "abracadabra" == "abracadabracadabracadabracadabracadabra"
True
λ: g ""            == ""
True
λ: g "zvioz"       == "zviozvioz"
True
λ: g "alfalfa"     == "alfalfalfalfalfalfa"
True
λ: g "aaaa"        == "aaaaaaa"
True

Java, 160 157 byte

static void g(String s){int i=s.length(),o;for(String p=s;i-->0;)if(s.endsWith(s.substring(0,i))){for(o=i;o-->0;)p+=s.substring(i);System.out.print(p);i=0;}}

Đầu ra đầu vào:

 g("abracadabra"); --> "abracadabracadabracadabracadabracadabra"

Khoảng cách và được gắn thẻ để dễ đọc:

static void g(String s){
int i=s.length(),o;
for(String p=s;i-->0;)
    if(s.endsWith(s.substring(0,i))){
        for(o=i;o-->0;)
            p+=s.substring(i);
        System.out.print(p);
        i=0;
    }
}

Gợi ý chào mừng.

Sed: 87 84 ký tự

(Mã 83 ký tự + 1 ký tự tùy chọn dòng lệnh.)

h
s/(.*)./& \1/
T
s/(.+) \1.*/ \1 \1/
t
g
q
:
s/^([^ ]+)(.*)[^ ]$/\1 \1\2/
t
s/ //g

Chạy mẫu:

bash-4.3$ sed -r 'h;s/(.*)./& \1/;T;s/(.+) \1.*/ \1 \1/;t;g;q;:;s/^([^ ]+)(.*)[^ ]$/\1 \1\2/;t;s/ //g' <<< 'underground'
undergroundergroundergrounderground

CJam, 24 23 byte

q_:Q,{~)Q>Q\#!},W>~_Q>*

q_:Q                       e# Read the input, take a copy and store it in Q too
    ,{        },           e# Take the length of the input and filter [0 .. len - 1] array
      ~)                   e# Same as number * -1
        Q>                 e# Take last number characters. Call this string S
          Q\#!             e# See if Q starts with S. After the filter, we will only have
                           e# those numbers from [0 .. len - 1] array which are valid orders
                W>~        e# Take the last order number, if exists.
                   _Q>*    e# Garlandify the input order times.

Chỉ cần bắt đầu nó với một cái gì đó ..

Dùng thử trực tuyến tại đây

Matlab: 97 89 82 byte

Hàm sử dụng biểu thức chính quy với lookbehind và nhóm chụp:

function t=f(s)
n=sum(regexp(s,'(.*$)(?<=^\1.+)'))-1;t=[s(repmat(1:n,1,end-n)) s];

Điều đó sumlà cần thiết để xử lý đầu vào chuỗi rỗng (chuyển đổi []thành 0).

Ví dụ:

> f('onion'), f('jackhammer'), f('abracadabra'), f(''), f('zvioz'), f('alfalfa'), f('aaaa')
ans =
onionionion
ans =
jackhammer
ans =
abracadabracadabracadabracadabracadabra
ans =
   Empty string: 1-by-0
ans =
zviozvioz
ans =
alfalfalfalfalfalfa
ans =
aaaaaaa

REGXY, 53 49 byte

Sử dụng REGXY , một ngôn ngữ dựa trên thay thế regex

//$'#/
/.(.+)#\1\K/#/
a/(#).(.*#)|#.*/$'$1$2/
//a

Tổng quan: Một số biểu thức thông thường được áp dụng. Một ví dụ chạy sẽ giống như:

onion (input)
onion#onion (line 1 regex)
onion#on#ion (line 2 regex - find the repeated section and separate with #)
onionion#n#ion (line 3 regex - the length of the middle token is the garland order, remove a character and append the third token onto the original string on the left)
onionionion##ion (line 4 regex is a pointer to line 3 - repeat the previous again)
onionionion##ion (line 4 regex is a pointer to line 3 - strip everything after and including the #)

Giải thích chi tiết Sau đây là phân tích từng dòng của biểu thức chính:

//$'#/

Đây là sự thay thế regex khớp với chuỗi trống đầu tiên (nghĩa là bắt đầu chuỗi) và thay thế nó bằng mọi thứ ở bên phải của kết quả khớp ( $') theo sau là hàm băm. Ví dụ, nó sẽ biến onionthành onion#onion.

/.(.+)#\1\K/#/

Dòng này tìm phần trùng lặp bằng cách tìm một nhóm ký tự ngay trước dấu # ( (.+)) giống nhau ở phía bên kia của # ( \1). \ K chỉ có nghĩa là 'quên rằng tôi phù hợp với bất cứ điều gì', có nghĩa là nó sẽ không thực sự được thay thế trong sự thay thế. Này có hiệu quả, phương tiện này, chúng ta chỉ cần thêm một # để vị trí sau sự chồng chéo đã được tìm thấy, quay onion#onionvào onion#on#ion.

a/(#).(.*#)|#.*/$'$1$2/

Chữ 'a' ban đầu chỉ là nhãn cho biểu thức chính quy. Sau này, chúng ta tìm thấy # đầu tiên theo sau bởi một ký tự ( .) và nắm bắt mọi thứ sau này cho đến # ( .*#) tiếp theo . Chúng tôi thay thế điều này bằng mọi thứ ở bên phải của trận đấu, tức là mã thông báo cuối cùng ($ '), theo sau là # ( $1), theo sau là mã thông báo thứ hai trừ một ký tự (chúng tôi coi đây là bộ đếm, giảm mỗi lần lặp). Trong trường hợp củ hành # trên # ion, hai mã thông báo mà chúng tôi phản hồi được hiển thị trong ngoặc đơn và phần toàn bộ khớp chính thức nằm giữa các ống : onion|(#)o(n#)|ion. Sau đó, chúng tôi thay thế các bit mà chúng tôi khớp (giữa các ống) bằng $'(mọi thứ ở bên phải của trận đấu, tức là 'ion'), sau đó là $ 1 (#), sau đó là $ 2 (n #), nghĩa là chúng tôi kết thúc bằng onion|(ion)(#)(n#)|ion(dấu ngoặc hiển thị ba mã thông báo trong chuỗi thay thế).

Nếu regex không khớp trong lần thay thế đầu tiên (mọi thứ trước đường ống), chúng tôi phải giảm bộ đếm xuống 0, nghĩa là không có ký tự nào trong mã thông báo thứ hai. Thay vào đó, chúng tôi xem xét phần thứ hai của mẫu , #.*. Điều này chỉ đơn giản là thay thế mọi thứ sau # đầu tiên với $'$1$2. Vì không có phản hồi được tạo bởi sự thay thế này và không có gì ở bên phải của trận đấu ( .*khớp cho đến khi kết thúc chuỗi), chúng tôi chấm dứt trận đấu và trả về kết quả.

//a

Đây chỉ là một con trỏ đến dòng trước đó, đảm bảo chúng tôi tiếp tục thực hiện thay thế regex cho đến khi nó không khớp nữa.

jq 1,5: 91 ký tự

(Mã 87 ký tự + tùy chọn dòng lệnh 4 ký tự.)

.+. as$t|[range(1;length)|select($t[:.]==$t[-.:])]|(max//0)as$i|[range($i)|$t[$i:]]|add

Chạy mẫu:

bash-4.3$ jq -R -r -f judy.jq <<< 'underground'
undergroundergroundergrounderground

rs , 51 48 byte

(.+)/\1 \1
(.+)(.+) .+\1$/\1(\2)^^((^^\1_))
 .*/

HÃY THỬ, RETINA VÀ SED !!!!! ;)

Cắt bỏ 3 byte nhờ @randomra.

Bản demo và trường hợp thử nghiệm trực tiếp.

Lưu ý rằng jackhammertrường hợp thử nghiệm là không có. Có một lỗi trong việc xử lý các khoảng trắng trong giao diện web khiến nó in ra đầu ra không chính xác. Phiên bản ngoại tuyến của rsxử lý chính xác.

Phiên bản 51 byte:

(.+)/\1 \1
^(.+)(.+) (.+)\1$/\1(\2)^^((^^\1_))
 .*/

Bản demo trực tiếp và trường hợp thử nghiệm cho bản gốc.

JavaScript (ES6), 95 byte

f=s=>{for(e=i=s.length;i&&e;)s+=s.slice(--i).repeat(!(e=!s.endsWith(s.slice(0,i)))*i);return s}

Bản giới thiệu

Firefox chỉ dành cho bây giờ:

f = s => {
  for (e = i = s.length; i && e;) s += s.slice(--i).repeat(!(e = !s.endsWith(s.slice(0, i))) * i);
  return s
}

console.log = x => X.innerHTML += x + '\n';

console.log(f('onion'));
console.log(f('jackhammer'));
console.log(f('abracadabra'));
console.log(f(''));
console.log(f('zvioz'));
console.log(f('alfalfa'));
console.log(f('aaaa'));

<pre id=X></pre>

JavaScript (ES6), 82 byte

g=(s,i=t=s.length)=>s.endsWith(c=s.slice(0,--i))?c+s.slice(i-t).repeat(i+1):g(s,i)

[Đã xóa câu trả lời ban đầu của tôi, vì giờ tôi đã học ES6 và quan tâm đến việc tìm giải pháp đệ quy cho thử thách này]

Thí dụ

g=(s,i=t=s.length)=>s.endsWith(c=s.slice(0,--i))?c+s.slice(i-t).repeat(i+1):g(s,i)

console.log(g('onion'));
console.log(g('jackhammer'));
console.log(g('abracadabra'));
console.log(g(''));
console.log(g('zvioz'));
console.log(g('alfalfa'));
console.log(g('aaaa'));

CoffeeScript + ES6, 77 byte

Cách tiếp cận tương tự như câu trả lời JavaScript của tôi.

f=(s,e=i=s.length)->s+=s[i..].repeat !(e=!s.endsWith s[...i])*i while--i&&e;s

C

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

int main(int argc, char **argv) {
    char *str   = NULL;
    char *p     = NULL;
    int len     = 0 ;
    int i       = 0;
    int j       = 0;
    int k       = 0;
    int loop    = 0;

    if (argc == 1 )
        return 0;

    str = argv[1];
    len = strlen(str);

    if (len %2) {
        loop = len/2 + 1;
    }
    else {
        loop = len/2;
    }


    p = &str[len/2];
    for (i = 0; i < loop ; i++) {
        if (str[k] == *(p++)) {
            k++;
        }
        else
            k = 0;
    }

    printf("k = %d\n", k);
    printf("%s", str);
    p = &str[k];
    for (j =0; j < k ; j++) {
        printf("%s", p);
    }
    return 0;
}

Đã đánh gôn: 195 byte - GCC

main(int c,char**a){
char *s=a[1],*p;int i=0,j=0,k=0,z,l=strlen(a[1]);
z=l%2?-~(l/2):l/2;p=&s[l/2];
for(;i<z;i++)k=s[k]==*(p++)?-~k:0;
printf("k=%d\n",k);puts(s);p= &s[k];
for(;j<k;j++)puts(p);}

Groovy 75 57 55 byte

f={w->x=w;w.find{x-=it;!w.indexOf(x)};w+(w-x)*x.size()}

Thật tuyệt vời khi trở lại một thứ gì đó vào ngày hôm sau có thể giúp ích

Ung dung:

f = {w ->

//Set x equal to w
    x=w

//Loop through the characters of w until we return true
    w.find {

//set x equal to x minus the first instance of the current character, i.e.     the word minus the first character
        x-=it

//Returns the index of the first occurance of the string of chars x, when this is 0 (false) we want to return true, so negate it
        !w.indexOf(x)
    }

//When we've escaped the loop, if we've found a match return the word plus the word minus the match multiplied by the lengh of the match.
    w+(w-x)*x.size()     
}

Trong trường hợp ai đó cần mã trong JS để kiểm tra nó. Lưu ý: Tôi duyệt qua chuỗi từ cuối để tăng hiệu quả:

"use strict";

var garlandify = function(inputString){
    var stringLength = inputString.length;  
    var savedString = inputString;

    for( var i=1; i<stringLength; i++ ){
         var endIndex = Math.abs(i) * -1;       
         if( inputString.startsWith( inputString.substr(endIndex) ) ){
              for( var j=1; j<=i; j++){
                  savedString += inputString.substr(i, stringLength );
              }
              console.log(savedString);         
         }  
    }
};

garlandify("onion");