Helloellolloloo Worldorldrldldd

50

Crea un programma che prenda la parola inserita e la aggiunga sul retro di se stessa meno la sua prima lettera, quindi si ripete fino a quando tutte le lettere sono scomparse. Ad esempio, catsarebbe diventato catatte hellosarebbe diventato helloellolloloo.

Inserisci una
delle 26 lettere dell'alfabeto inglese. Possono esserci più parole separate da spazi e la modifica dovrebbe essere applicata ad ogni parola.

Output
Le parole inserite, con ciascuna parola posta dopo se stessa con la prima lettera mancante, quindi con la seconda lettera mancante e così via fino a quando non ci sono più lettere da aggiungere.

Altri esempi:

ill eel uscite illlll eelell

laser bat uscite laserasersererr batatt

darth vader uscite dartharthrththh vaderaderdererr

Questo è il codice golf, quindi vince il codice più corto.

Chiarimento:
è possibile trattare l'input o l'output come un elenco. Puoi separare le parole usando newline anziché spazio. È possibile aggiungere uno spazio finale all'input.

code-golf  string 
— qazwsx
fonte
22
onestamente, le parole multiple sono un po 'fastidiose. Tutto ciò che serve è richiedere una divisione, applicare la funzione su ogni parola e quindi ricollegarsi. È anche abbastanza debilitante per molti esolang che devono controllare manualmente uno spazio
— Jo King,
4
Possiamo prendere l'input come un elenco di parole e l'output in quanto tale?
— Quintec,
4
Di quali lunghezze hai bisogno per gestire?
— MickyT,
5
È corretto separare le parole da una nuova riga nell'output (anziché uno spazio)?
— JayCe,
10
1.Si prega di aggiornare le specifiche con le nuove quote (I / O array, spazio finale, ecc.) 2.Si prega di informare le soluzioni esistenti nel caso in cui qualcuno possa risparmiare byte sfruttandole.
— Shaggy,

Risposte:

34

Japt -m, 6 3 byte

Input e output sono matrici di parole.

£sY

Provalo

Spiegazione

        :For each word in the input array
£       :Map each letter at index Y
 sY     :  Slice the current word from index Y
— ispido
fonte
1
È davvero compatto. Bello!
— qazwsx,
9
@qazwsx: ora il 50% più compatto!
— Shaggy,
1
Non è £due byte in UTF-8?
— Vi.
7
@Vi, non sto usando UTF-8 qui.
— Shaggy,
36

Brainfuck , 60 56 byte

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

Provalo online!

Richiede uno spazio finale e stampa uno spazio iniziale. Entrambi questi potrebbero essere elusi, ma ciò finisce a 112 byte .

Spiegazione

,[  Loop over each byte of input
  Tape: 32 w o r-32 d'
  >++++++++[-<----<++++>>]   Subtract 32 from the character and add 32 to the previous char
  Tape: 32 w o r d-32 0'
  <[>>]<   If the last character was a space
  Tape: 32 w o r d-32 0'
  or
  Tape: 32 w o r d' space-32
  [
    [<]>.   Move to the end of the word and print out the space
    [   Loop over each letter
      [-]    Remove the first letter (initially space)
      >[.>]  Print the rest of the word
      <[<]>  Move back to the first letter
    ]
    Tape: clear
  ]
,]  Get the next byte of input
— Jo King
fonte
21

Haskell, 36 21 byte

map$concat.scanr(:)""

Provalo online!

Modifica: -15 byte, a causa del nuovo formato IO (elenco di parole anziché parole separate da spazio)

— Nome del modello
fonte
Potresti radere 5 caratteri sostituendoli scanr (:) ""con tails.
— Frerich Raabe,
1
@FrerichRaabe: sì, ma ciò richiederebbe un valore import Data.Listche aggiunge 17 byte al punteggio.
— nimi,
18

Perl -p, 36 25 23 byte

s!\b|\S!$'=~s/ .*//r!eg

Provalo online!

Questo è un singolo regsub. Innanzitutto, corrisponde a tutti i confini di parole o caratteri non spaziali:

[][H][e][l][l][o] [][W][o][r][l][d]

Nota che ognuna di queste corrispondenze dovrebbe essere sostituita con il resto della parola:

[→Hello][H→ello][e→llo][l→lo][l→o][o→] (...)

Possiamo farlo con la variabile speciale $', che memorizza la parte della stringa dopo la corrispondenza. Tuttavia, dobbiamo applicare il regsub nidificato s/ .*//ad esso, che rimuove tutto oltre il primo spazio $', al fine di eliminare le parole rimanenti nell'input.

Grazie a @nwellnhof per 2 byte.

— Maniglia
fonte
È possibile sostituire [^ ]con \S.
— nwellnhof,
17

Python 3 , 49 byte

d=lambda s:' '.join(n+d(n[1:])for n in s.split())

Provalo online!

Questo sfrutta il fatto che "".split()restituisce un array vuoto in modo che funga da controllo per il caso base nella ricorsione.

— Cameron Aavik
fonte
17

Gelatina , 3 byte

ḊƬ€

Provalo online!

Non sono più necessari gli Ks poiché ora è consentito l'input / output dell'array.

ḊƬ€
  €   For each word:
Ḋ       Remove the first letter
 Ƭ      until there are none left.
— dylnan
fonte
Penso che tu abbia bisogno ḊƬẎ)(o ḊƬF), se preferisci).
— Erik the Outgolfer,
@EriktheOutgolfer Non credo. Ogni parola è rappresentata da un array separato nell'output
— dylnan,
1
Non sono sicuro se puoi affermarlo, poiché gli array sono nidificati e nella domanda non è specificato nulla per consentirlo.
— Erik the Outgolfer,
15

APL (Dyalog), 19 9 byte

{⌽∊,\⌽⍵}¨

grazie a @ H.PWiz per fare jogging nel mio cervello

Questo funziona perché tutte le stringhe in APL sono array di caratteri.

{⌽∊,\⌽⍵}¨ 
        ¨ - for each string
      ⍵} - string argument - ex. "hello"
     ⌽ - reverse - "olleh"
   ,\ - scan magic - "o" "ol" "oll" "olle" "olleh"
  ∊ - enlist(join together) "oolollolleolleh"
{⌽ - reverse - "helloellolloloo"

TIO

— Quintec
fonte
15

JavaScript (ES6), 33 byte

Salvato 1 byte grazie a @ShieruAsakoto

Formato I / O: matrice di parole.

a=>a.map(g=w=>w&&w+g(w.slice(1)))

Provalo online!

JavaScript (ES6), 35 byte

Formato I / O: matrice di parole.

a=>a.map(w=>w.replace(/./g,"$&$'"))

Provalo online!

— Arnauld
fonte
2
44:s=>s.replace(/\S+/g,g=s=>s&&s+g(s.slice(1)))
— Shieru Asakoto,
1
Grazie per il mio "qualcosa di nuovo" per oggi; mai saputo di $'(o $<backtick>).
— Shaggy,
13

R , 82 75 67 byte

write(sapply(x<-scan(,""),substring,1:(y=max(nchar(x))),y),1,y,,"")

Provalo online!

Diversi byte salvati grazie a JayCe

Separa l'output con newline.

L' sapply(...)espressione genera un vettore matrice / colonna delle sottostringhe appropriate, riempiendo con ""il necessario. writequindi stampa gli elementi della matrice, yper riga, separandoli con "".

— Giuseppe
fonte
4
Ha golfato un approccio diverso mentre si tiene in braccio un bambino assonnato; aggiungerà una spiegazione in seguito.
— Giuseppe,
2
Se la lunghezza delle parole è limitata, ad esempio 99 caratteri o ~ 1e6, puoi bussare a un mucchio di byte con ...substring,1:1e6,1e6)...o simili
— MickyT
2
Se riesci a separare le parole da una nuova riga: tio . L'ho chiesto in un commento. Può funzionare con il commento di @ MickyT
— JayCe,
@JayCe sembra che potrebbero essere 67 byte prima di incorporare il suggerimento di MickyT
— Giuseppe,
8

brainfuck , 94 93 byte

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

Provalo online!

  • Salvato un byte grazie a Nitrodon - giocare .[-]>[.>]<[<]>a golf a [.>]<[<]>[-]>.

Spiegazione

[[[ (dynamic) tape layout: ... NUL STR ... STR CHR FLG BUF SPC NUL ... ]]]

load a 32 into SPC
-[-[-<]>>+<]>-

while FLG
<<+[

 read a word
 [
  clear FLG; read CHR
  [-]<,
  copy CHR to BUF (using FLG as a temporary)
  [->+>+<<]>[-<+>]
  subtract SPC from BUF and save SPC
  >>[-<->>+<]
  move tape layout one to the right
  <
 ]

 strip trailing space; set FLG to true
 << [>>+<<[-]]
 to STR's first character
 <[<]>
 print word in all reduced forms
 [
  [.>]<[<]>[-]>
 ]

 print SPC; move to FLG
 >>>>.<<
]

Provalo online!

Attribuzione

La raccolta costante di Brainfuck di Esolang è stata utilizzata per il carico spaziale iniziale.

— Jonathan Frech
fonte
Questo non sembra terminare. È previsto?
— Jo King,
1
@JoKing Sì. In alcune implementazioni supererebbe il limite del nastro, uscendo per errore.
— Jonathan Frech,
6

05AB1E , 5 byte

€.síJ

Provalo online!

Spiegazione

€.s        # push suffixes of each
   í       # reverse each
    J      # join suffixes
— Emigna
fonte
1
Alternativa noiosa a 5 byte: í€ηJí(poiché i prefissi sono integrati a 1 byte invece di 2 byte come i suffissi; tuttavia richiede comunque un inverso aggiuntivo ciascuno all'inizio, quindi il conteggio dei byte rimane 5).
— Kevin Cruijssen,
6

Vim , 47 byte (38 battute di tasto)

Inizia con il tuo input come unica riga in un buffer Vim.

:s/<Space>/\r/g<CR>ggqaywPlxqqb99@aj0q99@bgg99J

Spiegazione

Questo mette ogni parola su una propria riga, scorre su ogni riga, quindi si ricongiunge a tutte. Si interrompe se le parole sono più lunghe di 99 caratteri o se l'input ha più di 99 parole.

  1. :s/<Space>/\r/g<CR> sostituisce gli spazi con nuove linee ( \r)
  2. gg posiziona il cursore all'inizio della prima riga
  3. qainizia a registrare la macro a :
    • yw strappa il resto della parola
    • P lo mette dietro il cursore
    • lx rimuove la prima lettera di quest'ultima parola
    • qinterrompe la registrazione della macro a
  4. qbinizia a registrare la macro b :
    • 99@aesegue macro a novanta-nove volte (introduce il limite di caratteri)
    • j0 posiziona il cursore all'inizio della riga successiva
    • qinterrompe la registrazione della macro b
  5. 99@besegue la macro b novantanove volte (introduce il limite di parole)
  6. gg posiziona il cursore sulla prima riga
  7. 99J unisce le seguenti novantanove righe con spazi (limite di parole di nuovo)

Per altri 2 byte (2 tasti) è possibile estendere il limite di parole a 999. Altri 4 byte, 9999, ecc.

— chambln
fonte
6

Buccia , 6 4 byte

-2 byte grazie a Jonathan Allan (prendendo input come elenco)!

moΣṫ

Provalo online!

Spiegazione

Prende l'input come un elenco di stringhe e mappa la seguente funzione:

Σṫ  -- example argument: "abc"
 ṫ  -- tails: ["abc","bc","c"]
Σ   -- concat: "abcbcc"
— ბიმო
fonte
La divisione e l'unione potrebbero non essere più necessarie, al momento tale specifica è in un commento.
— Jonathan Allan,
5

Retina 0.8.2 , 15 byte

 
¶
.
$&$%'
¶

Provalo online! Nota: spazi finali. Spiegazione:

Dividi sugli spazi.

.
$&$%'

Aggiungi il suo suffisso a ogni lettera. Ciò %significa che otteniamo solo il suffisso della parola.

Unisciti agli spazi.

— Neil
fonte
5

Pepe , 167 153 byte

REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree

Provalo online!

— non definito
fonte
5

Codice assembly x86 a 16 bit, 24 byte

     47             inc    di
     B020           mov    al,20h
l1:  3806           cmp    [si],al
     7212           jb     l5 ;less means end of string
     7401           je     l2  ;equal means space was seen
     4F             dec    di ;overwrite extra space
l2:  E80300         call   l3
     46             inc    si ;move to next character in word
     75F1           jne    l1
l3:  56             push   si
l4:  3806           cmp    [si],al
     A4             movsb      ;copy character
     77FB           ja     l4  ;until either zero or space is seen
     5E             pop    si
l5:  C3             ret

Chiama con si = puntatore alla stringa di origine, di = puntatore al buffer di output.
La stringa di origine richiede un byte zero per terminarla.
Il codice è lo stesso in 16 o 32 o 64 bit (si / di diventa esi / edi o rsi / rdi).
Il codice a 32 bit ha due byte in più a causa della chiamata espansa.
Il codice a 64 bit è ancora tre byte più grande perché l'inc / dec di rsi / rdi attira un prefisso (ma se si sa che si trovano nello spazio di memoria a 32 bit, allora possono essere di nuovo esi / edi per evitare quella penalità) .

— Peter Ferrie
fonte
4

MATL , 18 16 byte

"@gXH"HX@Jh)]0&h

L'input è un array di parole di celle. Provalo online!

Spiegazione

"         % Implicit input: cell array of strings. For each cell
  @g      %   Push content of current cell, that is, a word
  XH      %   Copy into clipboard H
  "       %   For each letter
    H     %     Push word
    X@    %     Push iteration index
    Jh)   %     Index from that until the end into current word
  ]       %   End
  0       %   Push 0. Will be cast to char. Char(0) is displayed as space
  &h      %   Concatenate horizontally all elements so far. Implicit display
— Luis Mendo
fonte
4

K4 / K (oK) , 9 byte

Soluzione:

,/'(1_)\'

Provalo online!

Spiegazione:

,/'(1_)\' / the solution
        ' / apply to each
       \  / scan
   (  )   / do this together
    1_    / drop first
,/'       / flatten (,/) each (')
— streetster
fonte
4

C ++ (clang) , 174 byte

#include<map>
#include<string.h>
std::string r(std::string w){while(auto x=strchr(w.c_str(),32))return r(w.substr(0,x-w.c_str()))+" "+r(x+1);return w!=""?w+r(w.substr(1)):w;}

Provalo online!

È il mio primo invio, e non sapevo se restituire la stringa invece di stamparla sia ok :)

— QJot
fonte
2
Benvenuti in PPCG! Sì, restituire una stringa va bene. Spero che rimani in giro!
— Jo King,
È possibile utilizzare la simmetria dell'operatore di disuguaglianza per rimuovere uno spazio e quindi salvare un byte - return w!=""?può essere return""!=w?.
— Jonathan Frech,
3

Carbone , 14 byte

⪫Ｅ⪪Ｓ ⭆ι✂ιμＬι¹

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

   Ｓ            Input string
  ⪪             Split on spaces
 Ｅ              Map over each word
      ι         Current word
     ⭆          Map over each character and join
        ι       Current word
         μ      Current index
           ι    Current word
          Ｌ     Length
            ¹   Literal 1
       ✂        Slice
⪫               Join with spaces
                Implicitly print
— Neil
fonte
3

Pip -s , 11 byte

J_@>,#_Mq^s

Prende l'elenco di parole separato dallo spazio da stdin. Provalo online!

Spiegazione

             s is space (implicit)
        q    Read a line of stdin
         ^s  Split it on spaces
       M     Map this lambda function to each word:
 _            The word...
  @>          sliced starting at index...
    ,#_       range(len(word))
              This creates len(word) slices ["word" "ord" "rd" "d"]
J             Join those into a single string
             The resulting list of modified words is printed; the -s flag uses space
             as the separator
— DLosc
fonte
3

C #, 111 90 byte

b=>string.Join(" ",(b.Split(' ').Select(x=>string.Concat(x.Select((y, i)=>x.Substring(i))))))

Provalo online!

Modificando l'input e l'output in array, ho salvato alcuni byte:

b=>b.Select(x=>string.Concat(x.Select((y,i)=>x.Substring(i)))).ToArray()

Provalo online!

— LiefdeWen
fonte
3

K (oK) , 17 13 byte

{,/|:'|,\|x}'

Provalo online!

Prefisso funzione anonima; L'input viene considerato come un elenco di stringhe, che a loro volta sono elenchi di caratteri.

Grazie @streetster per 4 byte.

Come:

{,/|:'|,\|x}' //Main function, argument x → ("ill";"eel")
            ' // For each element of the argument
         |x}  // Flip it. x → ("lli";"lee")
       ,\     // Concatenate each element, keeping intermediates. x → (("l";"ll";"lli");("l";"le";"lee")
      |       // Flip it again. x → (("lli";"ll";"l");("lee";"le";"l"))
   |:'        // Now flip each element. x → (("ill";"ll";"l");("eel";"el";"l"))
{,/           // Concatenation scan. x → ("illlll";"eelell")
— J. Sallé
fonte
È possibile restituire un elenco, anche dare un'occhiata alla mia soluzione oK
— vie il
@streetster oh, bello. Sto ancora imparando K, quindi le mie soluzioni non saranno così brevi o eleganti come vorrei. Grazie per il testa a testa!
— J. Sallé,
Appiattire prima del contrario consente di omettere il "retro-ciascuno", riducendolo a 10 byte: {|,/,\|x}'
— hoosierEE
3

Lisp comune , 179 byte

(defun r(s)(cond((endp s)nil)((eql(first s)#\Space)(princ " ")(r(rest s)))(t(q s)(r(rest s)))))(defun q (l)(cond((eql(first l)#\Space)t)((endp l)t)(t(princ(first l))(q(rest l)))))

Provalo online!

Questo è il mio primo tentativo di giocare a golf, le modifiche sono benvenute

— JRowan
fonte
Ciao e benvenuto in PPCG. La rimozione di spazi bianchi può farti risparmiare 29 byte .
— Jonathan Frech,
@Johnathan Frech grazie ho appena aggiornato senza spazi
— JRowan,
Penso che ti siano mancati quattro spazi superflui.
— Jonathan Frech,
Molto probabilmente puoi anche usare carinvece di firste cdrinvece di restgiocare a golf ulteriormente la tua presentazione.
— Jonathan Frech,
Na, sto bene adesso, ahah, forse tornerò e farò casino più tardi. Sto solo imparando lisp ora il mio insegnante ha detto di non usare mai la macchina e il cd, quindi erano fuori di testa mentre lo facevo
— JRowan,
3

Lua , 70 byte

for i=1,#arg do x=arg[i]for i=1,#x do io.write(x:sub(i))end print()end

Provalo online!

Spiegazione

Gli argomenti in Lua sono memorizzati nella tabella a argpartire dall'indice 1. L'operatore unario #restituisce la dimensione della tabella e la funzione s:sub(a,b)restituisce una sottostringa basata sulla stringa sdelimitata da numeri interi ae b, se b non viene passata, restituirà il resto della stringa.

Ho dovuto usare io.write()invece di print()evitare l'interruzione di linea e aggiunto print()alla fine per il motivo opposto.

— Marcio Medeiros
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.