Kata Garland

Sebuah kata karangan bunga adalah kata yang dapat dirangkai seperti karangan bunga, karena berakhir dengan huruf yang sama dimulai dengan. Kelompok-kelompok surat ini bahkan dapat tumpang tindih!

Misalnya, undergroundadalah kata urutan karangan bunga 3, karena dimulai dan diakhiri dengan 3 karakter yang sama und,. Ini berarti bisa dirangkai seperti undergroundergrounderground....

alfalfaadalah kata karangan bunga juga! Ini urutan 4. Dimulai dan diakhiri dengan alfa. Hal ini dapat dirangkai seperti: alfalfalfalfa.

Sebuah proses yang saya sebut garlandifying adalah di mana begitu Anda menentukan urutan nkata garland, Anda mengambil kata aslinya dan menambahkan segmen yang diperlukan untuk memilikinya loop sebagai nkali garland . Jadi, karena onionmerupakan perintah 2kata karangan bunga, Anda akan mengambil onion, memotong 2huruf pertama untuk mendapatkan iondan menambahkannya ke waktu akhir 2untuk mendapatkan onionionion.

Objektif

Buat program atau fungsi yang mengambil input dari input standar atau argumen fungsi dan mencetak atau mengembalikan kata, dikalibrasi.

Semua kata akan menjadi huruf kecil, dan urutan tertinggi untuk sebuah kata adalah length(word) - 1.

Contoh I / O

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

Ini adalah kode-golf , jadi paling tidak jumlah byte yang menang.

Pyth, 19 18 byte

+z*>Kf!xz>zT1zl>zK

Cobalah secara online: Demonstrasi atau Uji harness

Penjelasan:

+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

Berharap lebih baik, tapi oh well. s.findbekerja dengan rapi di sini di not s.startswith.

Retina , 58 byte

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

Setiap baris harus menuju ke file sendiri tetapi Anda dapat menjalankan kode sebagai satu file dengan -sbendera.

Keempat pasangan substitusi melakukan hal berikut:

• Gandakan kata sehingga kami dapat mencari tumpang tindih juga.
• Tambahkan kata split pada orderjumlah karakter.
• Tambahkan bagian orderwaktu terakhir .
• Simpan kata asli dan bagian yang ditambahkan terakhir dan letakkan yang lainnya.

Status string untuk contoh 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

Tes:

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

Input output:

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

Spasi dan tab untuk dibaca:

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

Saran diterima.

Sed: 87 84 karakter

(83 karakter kode + 1 opsi baris perintah karakter.)

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

Contoh dijalankan:

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.

Hanya memulainya dengan sesuatu ..

Cobalah online di sini

Matlab: 97 89 82 byte

Fungsi yang menggunakan ekspresi reguler dengan tampilan di belakang dan grup tangkap:

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

Itu sumdiperlukan untuk menangani input string kosong (konversi[] ke 0).

Contoh:

> 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

Menggunakan REGXY , bahasa berbasis pengganti regex

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

Tinjauan Umum: Sejumlah ekspresi reguler diterapkan. Contoh run akan terlihat seperti:

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

Penjelasan terperinci Berikut ini adalah rincian baris demi baris dari regex:

//$'#/

Ini adalah pengganti regex yang cocok dengan string kosong pertama (yaitu awal string) dan menggantinya dengan segala yang ada di kanan pertandingan ( $') diikuti oleh hash. Misalnya, itu akan berubah onionmenjadi onion#onion.

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

Baris ini menemukan bagian yang tumpang tindih dengan mencari sekelompok karakter tepat sebelum # ( (.+)) yang sama di sisi lain dari # ( \1). \ K hanya berarti 'lupa bahwa saya cocok dengan apa pun', artinya itu tidak akan benar-benar diganti dalam substitusi. Ini secara efektif, ini berarti kita hanya menambahkan # ke posisi setelah tumpang tindih ditemukan, berubah onion#onionmenjadi onion#on#ion.

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

Inisial 'a' hanyalah label untuk regex. Setelah ini, kami menemukan # pertama diikuti oleh satu karakter ( .) dan menangkap semuanya setelah ini sampai # berikutnya ( .*#). Kami mengganti ini dengan semua yang ada di kanan pertandingan, yaitu token terakhir ($ '), diikuti oleh # ( $1), diikuti oleh token kedua kurang dari karakter (kami memperlakukan ini sebagai penghitung, mengurangi setiap iterasi). Dalam kasus bawang # di # ion, dua token kita backreference pada ditunjukkan dalam tanda kurung, dan bagian seluruh pertandingan regex adalah antara pipa: onion|(#)o(n#)|ion. Kami kemudian mengganti bit yang kami cocokkan (antara pipa) dengan $'(semua yang ada di kanan pertandingan, yaitu 'ion'), kemudian $ 1 (the #), kemudian $ 2 (n #), artinya kami berakhir dengan onion|(ion)(#)(n#)|ion(tanda kurung menunjukkan tiga token dalam string pengganti).

Jika regex gagal mencocokkan pada pergantian pertama (semuanya sebelum pipa), kita harus menurunkan penghitung kita menjadi nol, artinya tidak ada karakter di dalam token kedua. Sebagai gantinya, kita melihat bagian kedua dari pola #.*,. Ini hanya menggantikan semuanya setelah # pertama dengan $'$1$2. Karena tidak ada referensi yang dibuat oleh pergantian ini, dan tidak ada apa-apa di sebelah kanan pertandingan ( .*cocok sampai akhir string), kami mengakhiri pertandingan dan mengembalikan hasilnya.

//a

Ini hanya sebuah penunjuk ke baris sebelumnya, memastikan kami terus menjalankan penggantian regex hingga gagal mencocokkan lagi.

jq 1,5: 91 karakter

(87 karakter kode + 4 opsi opsi baris perintah.)

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

Contoh dijalankan:

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

rs , 51 48 byte

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

BAWA BAHWA, RETINA DAN SED !!!!! ;)

Potong 3 byte berkat @randomra.

Demo langsung dan uji kasus.

Perhatikan bahwa jackhammertest case tidak ada. Ada bug dalam penanganan spasi di antarmuka web yang menyebabkannya mencetak hasil yang salah. Versi offline rsmenanganinya dengan benar.

Versi 51-byte:

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

Demo langsung dan uji kasus untuk yang asli.

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}

Demo

Firefox hanya untuk saat ini:

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)

[Menghapus jawaban asli saya, karena saya sekarang telah belajar ES6 dan tertarik untuk menemukan solusi rekursif untuk tantangan ini]

Contoh

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

Pendekatan yang sama dengan jawaban JavaScript saya.

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

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

Luar biasa bagaimana kembali ke sesuatu yang terjadi sehari setelahnya dapat membantu

Tidak Disatukan:

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

Dalam kasus seseorang membutuhkan kode di JS untuk mengujinya. Catatan: Saya melintasi string dari ujung untuk meningkatkan efisiensi:

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