Flippign Lettesr Aroudn

33

Nella chat, spesso digitiamo velocemente e non osserviamo realmente l' ordine delle lettere prima di pubblicare un messaggio. Dato che siamo pigri, abbiamo bisogno di un programma che scambia automaticamente le ultime due lettere con le nostre parole, ma poiché non vogliamo rispondere troppo tardi, il codice deve essere breve.

Il tuo compito, se desideri accettarlo, è scrivere un programma che capovolga le ultime due lettere di ogni parola in una data stringa (così la parola Thansksi trasforma in Thanks). Una parola è una sequenza di due o più lettere dell'alfabeto inglese delimitate da un singolo spazio.

  • La stringa / elenco di caratteri che ricevi come input è garantito per contenere solo caratteri alfabetici e spazi (ASCII [97 - 122], [65 - 90] e 32).

  • Puoi prendere input e fornire output attraverso qualsiasi metodo standard , in qualsiasi linguaggio di programmazione , tenendo presente che queste scappatoie sono vietate per impostazione predefinita.

  • L'output può avere uno spazio finale e / o una nuova riga finale.

  • L'input conterrà sempre solo parole (e lo spazio bianco corrispondente) e sarà composto da almeno una parola.

Si tratta di code-golf, quindi l'invio più breve (segnato in byte), in ogni lingua vince!

Casi test

Si noti che le stringhe sono racchiuse tra virgolette per la leggibilità.

Ingresso -> Uscita

"Grazie" -> "Grazie"
"Youer welcoem" -> "Sei il benvenuto"
"Questa è una mela" -> "Thsi si na appel"
"Flippign Lettesr Aroudn" -> "Lanciare lettere intorno"
"LA BELLA CHIAMATA ENTRATA CON LETTERE DI SCAMBIO" -> "LA BELLA SCALA CON LE LETTERE DI SCAMBIO"

Oppure, per comodità della suite di test, ecco gli ingressi e le uscite corrispondenti separatamente:

thansk
Benvenuto
Questa è una mela
Flippign Lettesr Aroudn
LA BELLA CHIAMATA ENTRATA CON LETTERE DI SCAMBIO R

Grazie
Prego
Questo è un appel
Lanciando Lettere Intorno
la bizzarra balaustra con letteR scambiate

Grazie a DJMcMayhem per il titolo. Questa era originariamente una CMC .

code-golf  string 
— Mr. Xcoder
fonte
Possiamo produrre una serie di parole?
— Shaggy,
@Shaggy No, l'output deve essere una stringa (o un elenco di caratteri per impostazione predefinita)
— Mr. Xcoder
Possiamo richiedere uno spazio finale su ciascun input?
— FlipTack,
@FlipTack Era consentito nella versione iniziale, ma ho rimosso quella regola prima che una qualsiasi delle risposte che sarebbero state utilizzate fosse stata pubblicata. (in parte perché alcuni utenti in chat mi hanno detto che lo sto rendendo troppo facile altrimenti, e sono d'accordo con loro). No, non è permesso.
— Mr. Xcoder,
1
@Fabian Una parola è una sequenza di due o più lettere
— Mr. Xcoder,

Risposte:

16

V , 4 5 byte

òeXp

Provalo online!

|| indica il cursore

Il buffer inizia con |w|ord and more wordse il cursore si trova sul primo carattere.

ricorsivamente ò

vai al secondo edi una parola

wor|d| and more words

rimuove Xil carattere a sinistra del cursore

wo|d| and more words

plo mette sul personaggio successivo

wod|r| and more words

Termine implicito ò, ripetere lo stesso processo per altre parole fino a raggiungere la fine del buffer

— Kritixi Lithos
fonte
2
La lingua giusta per l'attività :)
— DJMcMayhem
Intendi "ripetutamente" invece di "ricorsivamente"?
— NieDzejkob,
@NieDzejkob Il V wiki usa la parola "ricorsivamente" per descrivere il òcomando github.com/DJMcMayhem/V/wiki/Normal-Mode-Commands
— Kritixi Lithos
10

Gelatina , 7 byte

Ḳœ?@€2K

Un collegamento monadico che prende e restituisce elenchi di personaggi

Provalo online!

Come?

Ḳœ?@€2K - Link: list of characters
Ḳ       - split at spaces
     2  - literal two
    €   - for €ach:
   @    -   with sw@pped arguments:
 œ?     -     nth permutation (the 2nd permutation has the rightmost elements swapped)
      K - join with spaces
— Jonathan Allan
fonte
È un bel abuso di permutazioni. Alternativa
— Mr. Xcoder il
@ Mr.Xcoder Ḳ2œ?ЀKfunziona anche e utilizza una sola rapida.
— Dennis,
7

Brain-Flak , 122 byte

{(({})[((((()()){}){}){}){}])((){[()](<{}>)}{}){{}<>(({}({}))[({}[{}])])(<>)}{}({}<>)<>}<>(({}({}))[({}[{}])]){({}<>)<>}<>

Provalo online!

La peggior lingua per il lavoro :)

Leggibile Versione leggermente più leggibile:

{
    (({})[((((()()){}){}){}){}])((){[()](<{}>)}{})

    {
        {}
        <>

        (({}({}))[({}[{}])])

        (<>)
    }
    {}

    ({}<>)<>

}<>

(({}({}))[({}[{}])])

{

    ({}<>)
    <>
}<>
— DJMcMayhem
fonte
Non riesco a credere che questo sia più lungo della versione Brainfuck ...
— Pureferret,
@pureferret Brak-flak tende ad essere più lungo di brainfuck. Principalmente causa richiede due byte per comando primitivo, dove il cervello-flak richiede due.
— DJMcMayhem
6

Python 3 , 50 byte

print(*(w[:-2]+w[:-3:-1]for w in input().split()))

Provalo online!

Questa risposta abusa del comportamento di stampa di Python 3: più argomenti vengono stampati con un unico spazio tra loro. Certo, non possiamo semplicemente dargli più argomenti perché non sappiamo quante parole saranno presenti nell'input. Quindi usiamo l' operatore splat . Fondamentalmente

print(*[a,b,c])

è esattamente la stessa cosa di

print(a,b,c)

Gli abusi che rendono un programma completo più breve di una funzione / lambda in cui dovremmo usare ' '.joino qualcosa di simile.

— DJMcMayhem
fonte
Sembra che Python 2 salvi 2 byte scrivendo for w in input().split():print w[:-2]+w[:-3:-1],. In Python 3, l'estrazione degli ultimi due caratteri funzionerebbe bene con l' print(*(''.join(a)+c+b for*a,b,c in input().split()))eccezione che adeve essere rifatta in una stringa.
— xnor
5

Matlab (R2016b), 51 50 byte

Ho salvato 49 50 (!) Byte grazie a @Giuseppe.

function s(a),regexprep(a,'(\w)(\w)( |$)','$2$1 ')

E la mia risposta precedente:

Matlab (R2016b), 100 byte

(Solo per divertimento: P)

function s(a),a=regexp(a,' ','split');for i=1:length(a),fprintf('%s ',a{i}([1:end-2 end end-1])),end

Spiegazione:

function s(a) % Defining as a function...
a=regexp(a,' ','split'); % Splits the input string at the spaces
for i=1:length(a) % Loops through each word
    fprintf('%s ',a{i}([1:end-2 end end-1])) % And prints everything with the last two characters swapped.
end
— Thiago Oleinik
fonte
1
le parole di un carattere non possono accadere, poiché una parola è definita come almeno due caratteri.
— Giuseppe,
sarebbe regexpreplavorare qui? Qualcosa del genere regexprep(a,'(\w*)(\w)(\w)','\1\3\2')?
— Giuseppe,
D = Questo. Era. Epico! Penso che dovresti pubblicare questa risposta, poiché è totalmente diversa dalla mia. L'unica cosa è che Matlab fa riferimento alle partite con $1e non \1, quindi sarebbe regexprep(a,'(\w*)(\w)(\w)','$1$3$2').
— Thiago Oleinik,
1
dovresti postarlo come risposta separata / in questa risposta; è sempre bello vedere se un regex sarebbe di aiuto o meno in una sfida con le stringhe! Inoltre, chiaramente non capisco il motore regex di MATLAB, quindi non sarebbe del tutto giusto per me prendermi il merito.
— Giuseppe,
1
function s(a),regexprep(a,'(\w)(\w)( |$)','$2$1 ')è ancora un altro byte più breve!
— Giuseppe,
5

C,  62   58  54 byte

Grazie a @Dennis per aver salvato  quattro  otto byte!

f(char*s){s[1]>32||(*s^=s[-1]^=*s^=s[-1]);*++s&&f(s);}

Provalo online!

— Steadybox
fonte
ah, lo scambio basato su xor
— Snowbody,
4

Prolog (SWI) , 60 byte

[A,B]+[B,A].
[A,B,32|U]+[B,A,32|Y]:-U+Y,!.
[A|U]+[A|Y]:-U+Y.

Provalo online!

Spiegazione

Per prima cosa definiamo il caso base:

p([A,B],[B,A]).

Ciò significa che le ultime due lettere verranno sempre scambiate.

Quindi definiamo cosa succede se ci troviamo proprio accanto a uno spazio:

p([A,B,32|U],[B,A,32|Y]):-p(U,Y),!.

Due stringhe corrispondono se prima di uno spazio le lettere prima dello spazio vengono scambiate e il resto se le stringhe corrispondono. Quindi usiamo !per tagliare.

Il nostro ultimo caso è se non siamo accanto a uno spazio che le prime due lettere devono corrispondere.

p([A|U],[A|Y]):-p(U,Y).
— Mago del grano
fonte
4

Wolfram Language , 117 byte

StringReplace[RegularExpression["\\b[[:alpha:]]{2,}\\b"]:>StringDrop[StringInsert["$0",StringTake["$0",{-1}],-3],-1]]

Provalo online!

Applicato alle stringhe di prova.

StringReplace[
  RegularExpression["\\b[[:alpha:]]{2,}\\b"] :> 
   StringDrop[StringInsert["$0", StringTake["$0", {-1}], -3], -1]] /@
 {"Thansk", "Youer welcoem", "This is an apple", 
  "Flippign Lettesr Aroudn", "tHe oDd chALlEneg wiht swappde lettesR"} // Column

Thanks
Youre welcome
Thsi si na appel
Flipping Letters Around
teH odD chALlEnge with swapped letteRs
— Edmund
fonte
4
Benvenuti in PPCG!
— Steadybox,
@Steadybox Grazie.
— Edmund,
4

R , 111 51 41 byte

Per gentile concessione di @Giuseppe, un approccio regex che fa esplodere il mio vecchio metodo.

cat(gsub("(.)(.)\\b",'\\2\\1',scan(,"")))
— rturnbull
fonte
1
regex sono molto più efficienti qui: provalo online!
— Giuseppe,
(non che io non apprezzi il coraggio che ci vuole per fare un approccio di manipolazione delle corde puro in R)
— Giuseppe,
— Giuseppe,
@Giuseppe Caspita, bel lavoro! Li ho modificati nella mia risposta, anche se se preferisci creare la tua risposta, per favore, vai avanti!
— rturnbull,
1
nah, non ti preoccupare. Ho cercato altri 10 byte: porting un altro approccio regex e 70 byte del tuo vecchio approccio
— Giuseppe,
4

APL (Dyalog Classic) , 28 byte

1↓∊((¯2↓⊢),2↑⌽)¨' '(,⊂⍨⊣=,)⍞

⎕MLe ⎕IOsono entrambi 1,

Provalo online!

Spiegazione

  • ... (,⊂⍨⊣=,) ... Dividi (mantenendo i bordi e aggiungendo un bordo all'inizio) ...
  • ... ⍞ ... l'ingresso ...
  • ... ' ' ... ... negli spazi.
  • ... ( ... )¨ ... Quindi, per ogni elemento di quello:
    • ... , ... Concatenare ...
    • ... (¯2↓⊢) ... ... ogni articolo tranne gli ultimi due ...
    • ... 2↑⌽ ... ... con il contrario degli ultimi due elementi.
  • 1↓∊ ... Infine, restituisci tutto tranne il primo elemento del risultato appiattito.
— Zaccaria
fonte
ritorna tutto tranne il primo
— Adám,
3

J , 20 19 11 byte

Ringraziamo @Bolce Bussiere

1&A.&.>&.;:

Provalo online!

       &.;:      on words
    &.>          on each
  A.             apply the permutation
1&               number 1, swap the last two elements
— FrownyFrog
fonte
1
13 byte con(1&A.&.>)&.;:
— Bolce Bussiere il
@BolceBussiere perfetto
— FrownyFrog
Potresti aggiungere una spiegazione? Mi chiedo se posso portarlo su K per ridurre il numero di byte imbarazzante della mia soluzione!
— streetster
3

Alice , 24 byte

/0RR'.%$1\' o
\ix*o ne@/

Provalo online!

Spiegazione

/...\' o
\.../

Questo forma un loop in cui il corpo del loop è uno snippet ordinale lineare ed eseguiamo ' oin modalità Cardinale tra ogni due iterazioni di loop. Quest'ultimo stampa solo uno spazio.

Spiegando la struttura a zigzag del codice ordinale, il corpo del loop lineare si presenta in questo modo:

iR*' %e10xRo.n$@

Abbattere questo:

i     Read all input. On subsequent iterations, this will push an empty string.
R     Reverse.
*     Join. On the first iteration, this joins the input to an implicit empty string,
      which does nothing. On subsequent iterations, it will join the empty string to
      the word on top of the string, thereby getting rid of the empty string.
' %   Split around spaces. On the first iteration, this will split the input
      into individual words. On subsequent iterations, this does nothing.
e10   Push "10".
x     Use this to permute the (reversed) word on top of the stack. In
      particular, the word is rearranged with the same permutation that is
      required to sort the string "10", which means the first two letters
      get swapped (which correspond to the last two letters of the actual
      word).
R     Reverse the swapped word.
o     Print it.
.n$@  If there are no words left on the stack, terminate the program.
— Martin Ender
fonte
Ho appena notato che lo scambio di lettere può essere fatto in tre byte ( h~Z) anziché in quattro ( e10x), ma non vedo un modo per regolare il layout per salvare effettivamente un byte complessivo con quello.
— Martin Ender,
2

Brainfuck , 109 100 byte

Modifica: non è necessario gestire le parole di una lettera

,[>++++[-<-------->],]>+[-<[>++++[<++++++++>-]<[->>+<<]<]<<[->>+<<]>[[-<+>]>]<<[>+>+>]-<]>>>>>>>[.>]

Provalo online!

Stampa uno spazio finale

Come funziona

,[>++++[-<-------->],] Puts input on the tape and subtracts 32 from each character
                       This separates each word

>+[- Start the loop
   <[>++++[<++++++++>-]<[->>+<<]<] Add 32 to each letter of the word
                                   Skip this on the first iteration for the last word

   <<[->>+<<]>[[-<+>]>] Swaps the last two letters of the word
   <<[>+>+>]- If there is another word to the left continue loop
              Also set up to add a space to the end of the word
 <] End loop
 >>>>>>>[.>] Print the modified string

Versione precedente, 109 byte

,[>++++[-<-------->],]>+[-<[>++++[<++++++++>-]<[->>+<<]<]<<[[->>+<<]>[[-<+>]>]<<[<]]>[>]<[>+>+>]-<]>>>>>>[.>]

Provalo online!

— Jo King
fonte
1

PHP , 119 107 byte

Modifica: grazie a totalmente umano 

<?php foreach(explode(" ",trim(fgets(STDIN)))as$w)echo substr($w,0,strlen($w)-2).strrev(substr($w,-2))," ";

Provalo online!

— Zerquix18
fonte
1
Non riesci a creare $wordun nome di variabile a carattere singolo?
— totalmente umano il
@totallyhuman Yup! Ho scritto la versione completa e poi l'ha compressa, ma non me ne sono accorta. Grazie.
— Zerquix18,
I tag aperti di PHP possono essere omessi nella risposta salvandoti 6 byte.
— Daniel W.
Mi chiedo se fgets(STDIN)può essere omesso o sostituito $xanche da , come non tutte le risposte contano l'input delle loro risposte
— Daniel W.
trim()dovrebbe essere inutile.
— Tito
1

Haskell , 41 byte

foldr(%)" "
a%(b:' ':r)=b:a:' ':r
a%s=a:s

Provalo online!

Output con uno spazio finale.

Il ripetuto ' ':rsembra dispendioso. Ma ha a%(b:t@(' ':r))=b:a:tla stessa lunghezza ed a%(b:t)|' ':_<-t=b:a:tè più lungo di un byte.

Haskell , 41 byte

f(a:b:t)|t<"A"=b:a:f t|1>0=a:f(b:t)
f e=e

Provalo online!

— XNOR
fonte
1

sed , 20 17 + 1 (-r) = 18 byte

s/(.)(.)\b/\2\1/g

Provalo online!

— Noskcaj
fonte
Il collegamento TIO non corrisponde al codice inserito. Il collegamento TIO è più lungo di alcuni byte.
— Xcali,
Whoops, risolto il collegamento
— Noskcaj il
È possibile rimuovere |$. Non sta facendo niente. (Per fare ciò che ti aspetti di aver bisogno (.)(.)(\b|$), ma non è necessario perché \bcorrisponde già alla fine della stringa.)
— Giordania,
Whoops, voleva liberarsene. Grazie,
— Noskcaj, il
1

PHP, 65 byte

richiede PHP 7.1 (o successivo)

for(;$s=$argv[++$i];$s[-1]=$s[-2],$s[-2]=$c,print"$s ")$c=$s[-1];

prende la frase come argomenti della riga di comando separati. Corri con -nr.

lavorando su una singola stringa, 77 + 1 byte :

foreach(explode(" ",$argn)as$s){$c=$s[-1];$s[-1]=$s[-2];$s[-2]=$c;echo"$s ";}

Esegui come pipe con -nR.

... o provali online .

— Titus
fonte
1

Java 8, 35 byte

s->s.replaceAll("(.)(.)\\b","$2$1")

Risposta di Google Sheets di Port of @TaylorScott , dopo che ho giocato a golf due byte. EDIT: Vedo che ora è un porto della risposta Retina di Neil dopo i miei due byte giocati a golf.

Spiegazione:

Provalo online.

s->                           // Method with String as both parameter and return-type
   s.replaceAll("(.)(.)       //  Replace any two characters,
                       \\b",  //  with a word-boundary after it (space or end of String)
                "$2$1")       //  With the two characters swapped
— Kevin Cruijssen
fonte
1

Fogli Google, 33 byte

Funzione del foglio di lavoro anonima che accetta input dalla cella A1e output nella cella chiamante

=RegExReplace(A1,"(.)(.)\b","$2$1

-2 byte Grazie a @KevinCruijssen per l'uso di (.)over(\w)

— Taylor Scott
fonte
Entrambi (\w)possono giocare a golf (.)se non sbaglio. Il \bè già un'indicazione di cercare solo parole. (Non del tutto sicuro, ma funziona in Java.)
— Kevin Cruijssen,
@KevinCruijssen - Hai assolutamente ragione, può essere. Grazie!
— Taylor Scott,
1

JavaScript (Node.js) , 38 36 32 byte

s => s.replace (/ (.) (.) (| $) / g, "$ 2 $ 1") 
s=>s.replace(/(.)(.)\b/g,"$2$1")

Provalo online!

Approccio RegExp per gentile concessione di @Giuseppe (anche se ci ho pensato in modo indipendente), assumendo parole separate da un solo spazio

-2 per considerare solo 1 spazio e aggiungere spazio finale

-4 Grazie @Shaggy

— Shieru Asakoto
fonte
Non importa se ci sono più spazi, penso
— l4m2
@ l4m2 Ma se ci sono più spazi, diventerà 38 per s=>s.replace(/(.)(.)( +|$)/g,"$2$1$3").
— Shieru Asakoto,
@ l4m2 A proposito, la mia risposta originale eras=>s.replace(/(.)(.)(\s|$)/g,"$2$1$3")
— Shieru Asakoto il
ab abc abcd abcde abcdef FA ab_, bc_, cd_, de_, ___, ef_,___
— l4m2
1
F=s=>s.replace(/(.)(.)(?!\w)/g,"$2$1")stessa lunghezza
— l4m2
1

K (oK) , 23 22 byte

" "/{x@prm[!#x]1}'" "\

Provalo online!

Esempio:

" "/{x@prm[!#x]1}'" "\"Hello World"
"Helol Wordl"

Spiegazione:

La soluzione Port of FrownyFrog per salvare 1 byte .

Tornerò su questo.

" "/{prm[x]1}'" "\ / the solution
              " "\ / split input on " "
    {       }'     / apply lambda to each
     prm[x]        / permute input x
           1       / and take the 2nd result
" "/               / join with " "

Soluzione precedente:

  • " "/-2{(x_y),|x#y}'" "\ 23 byte
— streetster
fonte
1

05AB1E , 7 byte

#vy`sðJ

Provalo online!

-1 grazie a Magic Octopus Urn .

Stampa uno spazio finale.

— Erik the Outgolfer
fonte
Si tratta di 11 byte
— Daniel W.
2
@DanFromGermany No, 05AB1E ha una tabella codici in cui può essere rappresentata come 8 byte.
— Erik the Outgolfer,
Puoi eseguire il programma rappresentato in 8 byte?
— Daniel W.
@DanFromGermany Sì, l'interprete 05AB1E può eseguire questo programma da un file nella codifica 05AB1E.
— Erik the Outgolfer,
1
@MagicOctopusUrn Non è un elenco, è dopo `.
— Erik the Outgolfer,
0

SNOBOL4 (CSNOBOL4) , 136 119 byte

	I =INPUT
B	I SPAN(&LCASE &UCASE) . Y ARBNO(' ') =:F(O)
	Y RPOS(2) REM . Z =REVERSE(Z)
	O =O Y ' '	:(B)
O	OUTPUT =O
END

Provalo online!

Stampa con uno spazio finale. Sai di aver fatto qualcosa di sbagliato quando una lingua è un backronym per StriNg Orientato e SymBOlic Language e il tuo codice è più lungo di Brain-Flak :( ora è leggermente migliore.

La linea Bprende Ie sostituisce (alphabetic characters saved as Y)(some number of spaces)con la stringa vuota.

La seguente riga estrae gli ultimi 2 caratteri di Ycome Ze sostituisce loro come Zinvertito, poi le concatena riga successiva O, Ye un singolo carattere di spazio.

Infine, stampa quando Inon corrisponde più al motivo richiesto in linea B.

— Giuseppe
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.