sfondo

Sono attualmente in un AP Comp Sci A: classe Java e voglio iniziare alcuni dei miei amici sul golf del codice. Ho una sfida dal corso e vorrei vedere in quanti byte la community può fare questa sfida.

Dettagli della sfida:

Dati due stringhe di input, la stringa principale e la stringa pivot, attenere alla seguente procedura:

Se la stringa pivot è esattamente una volta come sottostringa della stringa principale, la parte della stringa principale che precede la stringa pivot deve essere scambiata con la parte che segue, preservando allo stesso tempo l'ordine all'interno di tali sottotitoli .

Per esempio:

Se la stringa pivot è vuota o la stringa pivot non viene trovata nella stringa principale, il programma non deve avere un comportamento definito.

Se esiste più di un'istanza della stringa pivot, la divisione dovrebbe avvenire nella prima e solo nella prima istanza del pivot.

Esempi: data la stringa principale OneTwoThreeTwoOnee la stringa pivot Two, l'output dovrebbe essere ThreeTwoOneTwoOne.

Data la stringa principale 1Two2Two3Two4e pivot Two, l'output dovrebbe essere 2Two3Two4Two1.

Data la stringa principale OneTwoThreee la stringa pivot "Two", l'output dovrebbe essere ThreeTwoOne. Data la stringa principale the rabbit is faster than the turtlee la stringa pivot

 is faster than 

(notare il singolo spazio finale e precedente), l'output dovrebbe essere the turtle is faster than the rabbit.

Data la stringa principale 1-2-3-4-5-6e il perno -, l'output dovrebbe essere 2-3-4-5-6-1.

Epilogo:

Questa è la mia prima domanda in assoluto sul code golf, quindi se hai suggerimenti o critiche costruttive, sentiti libero di dirlo.

Inoltre, il mio codice per questo progetto (scritto in Java perché il corso si concentra su questo) può essere trovato sotto. Se hai qualche consiglio, mi piacerebbe vederli. Sono attualmente 363 byte, ma scommetto che voi ragazzi potete trovare soluzioni molto migliori e più piccole.

import java.util.Scanner;interface Main{static<T>void D(T f){System.out.println(f);}static void main(String[]A){Scanner s=new Scanner(System.in);D("Enter the first String:");String a=s.nextLine();D("Enter the pivot String:");String p=s.nextLine();if(p.isEmpty()|!a.contains(p)){D("Error: Pivot String not found.");return;}String w[]=a.split(p,2);D(w[1]+p+w[0]);}}

Nota: il testo per gli input e nel caso in cui la stringa pivot non venga trovata è obbligatorio per l'assegnazione originale, ma non per questa sfida.

Mathematica, 42 byte

Reverse@StringSplit[##,2]~StringRiffle~#2&

Provalo online!

Gelatina , 6 byte

œṣṙ1j⁴

Provalo online!

Spiegazione

œṣṙ1j⁴  Main Link
œṣ      Split around sublists equal to the pivot
  ṙ1    Rotate left by one
    j⁴  Rejoin on the pivot

Python 2 , 37 39 byte

lambda a,b:b.join(a.split(b,1)[::-1])

Dov'è ala stringa principale ed bè la stringa pivot.

Provalo online!

Wolfram Language (Mathematica) , 34 byte

p#2<>p<>#&@@StringSplit[#,p,2]&

Provalo online!

Una funzione senza nome, al curry che dovrebbe essere chiamata prima con il pivot e con la seconda stringa principale. Ad esempio, se hai assegnato la funzione a un nome f:

f["-"]["1-2-3-4-5-6"]

Ohm v2 , 4 byte

ïλ⁴j

Provalo online!

Perl 5 , 20 + 2 ( -pl) = 22 byte

<>=~/$_/;$_="$'$_$`"

Provalo online!

Prende la stringa pivot sulla prima riga, quindi l'intera stringa sulla seconda.

Python 2 , 53 44 byte

grazie a ThePlasmaRailgun per alcuni byte

p,m=input()
k=m.split(p,1)
print k[1]+p+k[0]

Provalo online!

Python 2 , 37 byte

lambda a,b:b.join(a.split(b,1)[::-1])

Provalo online!

C # (compilatore Visual C #) , 56 byte

(m,p)=>(m+p+m).Substring(m.IndexOf(p)+p.Length,m.Length)

Provalo online!

Alice , 18 byte

/?.?.Qz
\IoI%!oo@/

Provalo online!

Spiegazione

/...
\...@/

Questo è solo un framework per il codice della modalità Ordinale lineare (elaborazione delle stringhe). Spiegando il flusso di controllo a zigzag, otteniamo:

I.I.!zo?o?%Qo

I.  Read the first string, duplicate it.
I   Read the second string (the pivot).
.!  Store a copy of the pivot on the tape.
z   Drop. Removes everything up to and including the pivot from the first string,
    so we get only the stuff after the pivot.
o   Output that.
?o  Retrieve the pivot from the tape and output it.
?%  Retrieve the pivot again and split the input around (all occurrences of)
    the pivot.
Q   Reverse the stack.
o   Output the top of the stack (i.e. the chunk in front of the first pivot).

SOGL V0.12 , 9 5 byte

ΘK+,∑

Provalo qui!

Spiegazione:

Θ      split the 2nd input on the 1st one
 K     get the 1st element
  +    and add it to the end
   ,∑  join on the 1st input

Retina , 24 23 byte

carri armati a Martin Ender per -1 byte

(.*)¶(.*?)\1(.*)
$3$1$2

Provalo online!

Python 2 , 48 byte

lambda s,p:p.join(s.split(p)[1:]+s.split(p)[:1])

Provalo online!

Pyth , 8 byte

jQ.<cEQ1

Provalo qui!

Spiegazione

jQ.<cEQ1 - Full program.

    cEQ  - Split the second input by the first input.
  .<   1 - Cyclically rotate by 1 place to the left.
jQ       - Join on the first input.

Carbone , 13 byte

≔⪪θηθ⪫Ｅθ§θ⊕κη

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  θ             First input
   η            Second input
 ⪪              Split
≔   θ           Assign result
      Ｅθ        Map over result
           κ    Current index
          ⊕     Incremented
        §θ      Circularly index into result
     ⪫      η   Join
                Implicitly print

R , 63 58 57 byte

function(M,P)sub(sub("_",P,"(.+?)(_)(.+)"),"\\3\\2\\1",M)

Provalo online!

Mè la stringa principale, Pè il perno.

La risposta di Retina di ovs indicava che avrei potuto riparare il mio precedente tentativo di approccio regex

(.+)(Pivot string)(.+)

aggiungendo ?al primo gruppo di acquisizione.

Java 8, 47 byte

x->y->x.replaceAll("(.*?)("+y+")(.*)","$3$2$1")

Provalo online

JavaScript (ES6), 41 40 byte

(s,p,[a,...r]=s.split(p))=>r.join(p)+p+a

Casi test

let f =

(s,p,[a,...r]=s.split(p))=>r.join(p)+p+a

console.log(f('the rabbit is faster than the turtle', ' is faster than '))
console.log(f('1-2-3-4-5-6', '-'))

J , 14 byte

#@[}.{.@ss|.,~

Come funziona:

L'argomento sinistro è il perno, quello destro - la stringa da invertire

            ,~   appends the pivot to the string
     {.@ss       finds the positions of the pivot in the string and takes the first one
          |.     rotates the appended string to the left, so that the pivot is at the start
#@[              finds the length of the pivot string (n)
   }.            drops n characters from the begining of the rotated string

Provalo online!

C,  106  100 byte

i,l;f(s,p)char*s,*p;{l=strlen(p);for(i=0;strncmp(s+i,p,l);++i);printf("%s%s",s+i+l,p);write(1,s,i);}

Provalo online!

SNOBOL4 (CSNOBOL4) , 53 byte

	P =INPUT
	INPUT ARB . R P REM . L
	OUTPUT =L P R
END

Provalo online!

Accetta input come Pivot, quindi Main, separati da una nuova riga.

Questo è fondamentalmente l'equivalente SNOBOL della mia risposta R .

Perl 6 , 31 byte

->$_,$b {S/(.*?)$b(.*)/$1$b$0/}

Provalo

PHP, 62 byte

<?=![,$s,$p]=$argv,preg_filter("(^(.*)$p(.*)$)U","$2$p$1",$s);

richiede PHP 7.1; potrebbe non riuscire se il pivot contiene caratteri speciali regex ( \+*?[^]$(){}=!<>|:-).
nessuna modifica se Pivot è vuoto, output vuoto se Pivot non è in input.
Corri con-n .

versione sicura, 77 byte:

<?=preg_filter("(^(.*)".preg_quote($p=$argv[1])."(.*)$)U","$2$p$1",$argv[2]);

nessuna modifica se Pivot è vuoto, output vuoto se Pivot non è in input.
Corri con-n .

versione non regex, 71 byte:

$a=explode($p=$argv[2],$argv[1]);$a[]=array_shift($a);echo join($p,$a);

genera avvisi se il Pivot è vuoto; nessuna modifica se Pivot non è in input.

Corri con -nr.

Provali online .

Rosso , 63 byte

f: func[p s][rejoin[copy find/tail s p p copy/part s find s p]]

Provalo online!

Rapido , 131 byte

import Foundation
func f(s:String,d:String){var c=s.components(separatedBy:d);print((c+[c[0]]).suffix(from:1).joined(separator:d))}

Spiegazione (non golfizzato)

import Foundation                     // Import String.components
func f(s:String,d:String){
    var c=s.components(separatedBy:d) // Split the input string by the separator
    print((c+[c[0]])                  // Add the last element of c ([A,B,C] -> [A,B,C,A])
        .suffix(from:1)               // Remove the first element  ([A,B,C,A] -> [B,C,A])
        .joined(separator:d))         // Join with the separator
}

C (gcc) , 76 byte

f(s,t)char*s,*t;{char*p=strstr(s,t);printf("%s%s%.*s",p+strlen(t),t,p-s,s);}

Provalo online!

C ++ 11, 64 byte

[s,p,&a]{int f=s.find(p);a=s.substr(f+p.size())+p+s.substr(0,f);}

Una lambda, che cattura le stringhe s, p e a, con a come riferimento (in-out).

Codice di prova

#include <iostream>
#include <string>

std::string Test(std::string s, std::string p) {
    std::string a;
[s,p,&a]{int f=s.find(p);a=s.substr(f+p.size())+p+s.substr(0,f);}();
    return a; 
}

int main() {
    std::string 
        s = "OneTwoThreeTwoOne",
        p = "Two",
        r = "ThreeTwoOneTwoOne";
    auto a = Test(s,p);
    std::cout << ((a==r)?"OK":"Failed") << ": " << a << std::endl; 

    return 0;
}

Pulito , 83 byte

import StdEnv;f s c=(\p=p takeWhile++[hd s,c:p dropWhile])\g=reverse(tl(g((<>)c)s))

A Stringin Clean è normalmente {#Char}- un unboxed ( #) Chararray ( {}). Questa funzione accetta [Char]invece di String, che è una seconda versione valida di String.

La firma della funzione completa è f :: [.t] .t -> [.t] | [.t <= Char].

Provalo online!

Japt , 8 7 byte

£Zg°Y}V

Provalo qui