갈랜드 단어

환 단어는 그것이로 시작하는 같은 문자로 끝나는 때문에, 화환처럼 함께 중독 될 수있는 단어입니다. 이 문자 그룹은 겹칠 수도 있습니다!

예를 들어, undergroundorder of garland 단어 3는 동일한 3 자로 시작하고 끝나기 때문에 und. 이것은 같이 묶일 수 있음을 의미합니다 undergroundergrounderground....

alfalfa갈 랜드 단어입니다! 순서 4입니다 alfa.로 시작하고 끝납니다 . 다음과 같이 함께 묶을 수 있습니다 alfalfalfalfa.

내가 화환이라고 부르는 과정은 n화환 단어 의 순서를 결정 하면 원래 단어를 가져 와서 화환 n시간으로 반복하는 데 필요한 세그먼트를 추가하는 것 입니다. 따라서 onion주문 2화환 단어이므로, onion첫 2글자를 잘라내어 ion끝 2시간에 추가합니다 onionionion.

객관적인

표준 입력 또는 함수 인수 에서 입력을 받아서 단어를 출력하거나 반환 하는 프로그램이나 함수 를 만드십시오 .

모든 단어는 소문자이며 단어의 가능한 가장 높은 순서는 length(word) - 1입니다.

예제 I / O

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

이것은 code-golf 이므로 바이트 수가 가장 적습니다.

Pyth, 19 18 바이트

+z*>Kf!xz>zT1zl>zK

온라인으로 사용해보십시오 : 데모 또는 테스트 장치

설명 :

+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

파이썬, 60 바이트

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

더 나아지기를 바라고 있었지만 아. s.find대신에 깔끔하게 작동합니다 not s.startswith.

망막 , 58 바이트

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

각 줄은 자체 파일로 이동해야하지만 -s플래그를 사용하여 코드를 하나의 파일로 실행할 수 있습니다 .

네 개의 대체 쌍은 다음을 수행합니다.

• 중복 단어도 검색 할 수 있도록 단어를 복제합니다.
• 단어를 order여러 문자로 나누십시오 .
• 마지막 부분을 추가하십시오 order.
• 원래 단어와 마지막에 추가 한 부분을 유지하고 다른 것은 모두 삭제하십시오.

예제의 문자열 상태는 다음과 onion같습니다.

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

하스켈, 64 바이트

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

테스트 :

λ: 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

자바, (160) 157 바이트

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("abracadabra"); --> "abracadabracadabracadabracadabracadabra"

가독성을위한 간격과 탭 :

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;
    }
}

제안을 환영합니다.

sed : 87 84 자

(83 자 코드 + 1 자 명령 행 옵션)

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

샘플 실행 :

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 바이트

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.

무언가로 시작하기 만하면됩니다 ..

여기에서 온라인으로 사용해보십시오

MATLAB : 97 89 82 바이트

lookbehind 및 캡처 그룹과 함께 정규식을 사용하는 함수 :

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

즉 sum빈 문자열 입력 (변환 처리하기 위해 필요 []로를 0).

예 :

> 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 바이트

정규식 대체 기반 언어 인 REGXY 사용

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

개요 : 많은 정규식이 적용됩니다. 예제 실행은 다음과 같습니다.

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 #)

자세한 설명 다음은 정규 표현식을 한 줄씩 세분화 한 것입니다.

//$'#/

이것은 첫 번째 빈 문자열 (즉, 문자열의 시작)과 일치하는 정규 표현식 대체이며 일치하는 오른쪽의 모든 항목 ( $')과 해시로 대체됩니다 . 예를 들어 onion로 바뀝니다 onion#onion.

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

이 줄은 # ( (.+)) 바로 앞의 # ( ) 바로 앞에있는 문자 그룹을 찾아 겹치는 섹션을 찾습니다 \1. \ K는 단지 '내가 일치하는 것을 잊어 버린다'는 것을 의미하며, 대체에서 실제로 대체되지는 않습니다. 이것은 효과적으로 겹침이 발견 된 후 위치에 #을 추가하여 onion#onion로 변함 을 의미 onion#on#ion합니다.

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

초기 'a'는 정규식의 레이블 일뿐입니다. 그런 다음 첫 번째 # 다음에 단일 문자 ( .)를 찾은 후 다음 # ( .*#) 까지이 후 모든 것을 캡처 합니다. 우리는 이것을 매치 오른쪽에있는 모든 것, 즉 마지막 토큰 ($ '), # ( $1), 뒤에 두 번째 토큰이 아닌 문자로 바꿉니다 (이것은 카운터로 취급하여 매 반복마다 감소시킵니다). onion # on # ion의 경우, 우리가 역 참조하는 두 개의 토큰은 괄호 안에 표시되며 전체 정규 표현식과 일치하는 섹션은 파이프 사이에 onion|(#)o(n#)|ion있습니다. 우리는 다음과 (파이프 사이) 우리가 일치하는 비트를 대체 $'우리가 결국 의미, 다음 (경기의 오른쪽, 즉 '이온'에 이르기까지) $ 1합니다 (#), 다음 $ 2 (N #) onion|(ion)(#)(n#)|ion괄호 표시 ( 대체 문자열에있는 세 개의 토큰).

정규식이 첫 번째 교대에서 (파이프 전의 모든 항목) 일치하지 않으면 카운터를 0으로 줄여야합니다. 즉, 두 번째 토큰 안에 문자가 없습니다. 대신 패턴의 두 번째 부분을 봅니다 #.*. 이것은 단순히 첫 번째 # 이후의 모든 것을으로 대체합니다 $'$1$2. 이 대체에 의해 생성 된 역 참조가없고 일치 오른쪽에 아무것도 없습니다 ( .*문자열 끝까지 일치). 일치를 종료하고 결과를 반환합니다.

//a

이것은 이전 줄을 가리키는 포인터이므로 더 이상 일치하지 않을 때까지 정규식 대체를 계속 실행할 수 있습니다.

jq 1.5 : 91 자

(87 자 코드 + 4 자 명령 행 옵션)

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

샘플 실행 :

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

rs , 51 48 바이트

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

레티 나와 세드 !!!!! ;)

@randomra 덕분에 3 바이트를 잘라냅니다.

라이브 데모 및 테스트 사례.

있습니다 jackhammer테스트 케이스가 아니다. 웹 인터페이스에서 공백을 처리 할 때 잘못된 출력을 인쇄 하는 버그가 있습니다 . 오프라인 버전에서 rs올바르게 처리합니다.

51 바이트 버전 :

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

원본에 대한 라이브 데모 및 테스트 사례.

자바 스크립트 (ES6), 95 바이트

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

데모

현재 Firefox 만 해당 :

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>

자바 스크립트 (ES6), 82 바이트

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

[이제 ES6을 배우고이 과제에 대한 재귀 솔루션을 찾는 데 관심이 있었기 때문에 원래의 답변을 삭제했습니다.]

예

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 바이트

내 JavaScript 답변과 동일한 접근 방식입니다.

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

씨

#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;
}

골프 : 195 바이트-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);}

그루비 75 57 55 바이트

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

그 다음날 무언가로 돌아 오는 방법이 놀랍습니다.

언 골프 드 :

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()     
}

누군가가 그것을 테스트하기 위해 JS의 코드가 필요한 경우. 참고 : 효율성을 높이기 위해 문자열을 끝에서 통과했습니다.

"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");