Garland Sözleri

Bir çelenk kelimesi , bir çelenk gibi birbirine asılabilen bir kelimedir, çünkü başladığı harflerle aynıdır. Bu mektup grupları bile örtüşebilir!

Örneğin, undergroundsıralı bir garland kelimesidir 3, çünkü aynı 3 karakterle başlar ve biter und. Bu, birlikte gibi sinirli olabileceği anlamına gelir undergroundergrounderground....

alfalfabu da bir garland kelime! Bu 4. mertebeden. Başlıyor ve bitiyor alfa. Birlikte şöyle sinirli olabilir: alfalfalfalfa.

Garlandifiye olarak adlandırdığım bir süreç n, bir garland kelimesinin sırasını belirlediğinizde , orijinal kelimeyi alıp garland nzamanı olarak döngü yapmak için gereken segmenti eklersiniz . Öyleyse, onionsıralı bir 2garland kelimesi olduğu için, almak onioniçin ilk 2harfleri keserek alın ionve bitiş 2zamanlarına ekleyin onionionion.

Amaç

Standart girdiden veya işlev argümanından girdi alan ve düzeltilmiş sözcüğü çıktısını alan veya geri döndüren bir program veya işlev yapın.

Tüm kelimeler küçük harf olacaktır ve bir kelime için mümkün olan en yüksek sıradır length(word) - 1.

Örnek G / Ç

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

Bu kod golf , yani en az bayt sayısı kazanır.

Pyth, 19 18 bayt

+z*>Kf!xz>zT1zl>zK

Çevrimiçi deneyin: Gösteri veya Test koşum

açıklamalar:

+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 bayt

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

Daha iyisini umuyordum, ama peki. s.findyerinde yerine düzgün çalışıyor not s.startswith.

Retina , 58 bayt

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

Her satır kendi dosyasına gitmelidir ancak kodu -sbayrakla bir dosya olarak çalıştırabilirsiniz .

Dört ikame çifti aşağıdakileri yapar:

• Yinelenen sözcük böylece çakışmaları da arayabiliriz.
• Ayrılmış kelimeyi orderkarakter sayısına ekleyin .
• Son bölüm orderzamanlarını ekleyin .
• Orijinal sözcüğü ve en son eklenen kısmı saklayın ve diğer her şeyi bırakın.

Dize, örnek için belirtir onion:

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

Haskell, 64 bayt

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

Testler:

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

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

Giriş çıkış:

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

Okunabilirlik için aralıklı ve sekmeli:

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

Önerilerinizi bekliyoruz.

Sed: 87 84 karakter

(83 karakter kod + 1 karakter komut satırı seçeneği.)

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

Örnek çalışma:

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 bayt

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.

Sadece bir şeyle başlatmak için ..

Burada çevrimiçi deneyin

Matlab: 97 89 82 bayt

Düzenli ifadeyi lookbehind ve bir yakalama grubuyla kullanan işlev:

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

Yani sumboş dize girişi (dönüştürmek işlemek için gereklidir []içine 0).

Örnekler:

> 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 bayt

Regex ikamesi temelli bir dil olan REGXY'yi kullanır.

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

Genel Bakış: Birkaç düzenli ifade uygulanır. Örnek bir çalışma şöyle görünür:

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

Detaylı açıklama Aşağıda, regex'lerin satır dökümü satır satır verilmiştir:

//$'#/

Bu, ilk boş dizgeyle eşleşen (yani dizenin başlangıcı) eşleşen ve eşleşmenin sağındaki her şeyle ( $') bir kargaşanın yerine geçen bir regex ikamesidir . Örneğin, oniondönüşecek onion#onion.

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

Bu satır, # ( (.+)) 'dan hemen önce gelen # # karakterinden önce gelen karakter grubunu arayarak üst üste gelen bölümü bulur \1. \ K sadece 'birşeyle eşleştiğimi unut' anlamına gelir, yani ikame işleminde değiştirilmeyecektir. Örtüşme çevirerek tespit edildikten sonra bu etkin bir şekilde bu araçlar sadece pozisyona bir # eklemek onion#onioniçine onion#on#ion.

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

İlk 'a' sadece regex için bir etikettir. Bundan sonra ilk # 'i tek bir karakter ( .) bulur ve bundan sonraki her şeyi ( ) izleriz .*#. Bunu, eşleşmenin sağındaki her şeyle değiştiririz, yani son belirteç ($ '), ardından bir # ( $1), ardından ikinci belirteç daha az karakter izler (bunu her bir yinelemeyi azaltarak bir sayaç olarak kullanırız). # İyon soğan no durumda, ilgili bir geriye iki işaret parantez içinde gösterilmektedir, ve kesit, tüm normal ifade stoktaki boru arasındadır: onion|(#)o(n#)|ion. Daha sonra eşleştiğimiz bitleri (borular arasında) $'(eşleşmenin sağındaki her şey, yani 'iyon'), ardından $ 1 (#), sonra $ 2 (n #) ile değiştiririz, yani sonuçta onion|(ion)(#)(n#)|ion(dirsekler göster değiştirme dizesindeki üç belirteç).

Eğer regex ilk değişimle uyuşmazsa (borudan önceki her şey), sayacımızı sıfıra düşürmeliyiz, yani ikinci belirtecin içinde hiçbir karakter yoktur. Bunun yerine, kalıbın ikinci kısmına bakarız #.*. Bu sadece ilk # dan sonra her şeyin yerini alır $'$1$2. Bu değişiklikle oluşturulan hiçbir geri referans olmadığından ve eşleşmenin sağında hiçbir şey olmadığından ( .*dizenin sonuna kadar eşleşir) eşleşmeyi sonlandırıp sonucu döndürürüz.

//a

Bu, önceki satırın yalnızca bir göstergesidir ve regex sübstitüsyonunu daha fazla eşleşene kadar yürütmeye devam etmemizi sağlar.

jq 1.5: 91 karakter

(87 karakter kod + 4 karakter komut satırı seçeneği.)

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

Örnek çalışma:

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

rs , 51 48 bayt

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

BU, RETINA VE SED ALIN !!!!! ;)

@Randomra sayesinde 3 byte kesin.

Canlı demo ve test vakaları.

Not jackhammertest durumu söz konusu değildir. Web arayüzündeki boşlukların işlenmesinde yanlış çıktı yazdırmasına neden olan bir hata var . Çevrimdışı sürümü rsdoğru şekilde işler.

51 bayt sürümü:

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

Canlı demo ve orijinal için test durumları.

JavaScript (ES6), 95 bayt

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

gösteri

Firefox sadece şimdilik:

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 bayt

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

[Orijinal cevabımı sildim, çünkü şimdi ES6'yı öğrendim ve bu mücadeleye özyinelemeli bir çözüm bulmak istiyordum]

Örnek

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 bayt

JavaScript cevabımla aynı yaklaşım.

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

Golf: 195 bayt - 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 bayt

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

İnanılmaz bir gün sonra bir şeye geri dönmenin yardımı olabilir

Ungolfed:

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

Birinin test etmek için JS'deki koda ihtiyacı olması durumunda. Not: Verimliliği artırmak için dizgiyi uç noktadan geçirdim:

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