Helloellolloloo Worldorldrldldd

50

Создайте программу, которая берет слово, которое вы вводите, и добавляет это слово на обороте минус его первую букву, а затем повторяется до тех пор, пока все буквы не исчезнут. Например, catстало бы catatt, и helloстал бы helloellolloloo.

Введите
любую из 26 букв английского алфавита. Может быть несколько слов, разделенных пробелами, и изменение должно применяться к каждому слову.

Выходные данные Вводимое
слово (слова), каждое слово ставится после него, пропущена первая буква, затем пропущена вторая буква и т. Д., Пока не останется больше букв для добавления.

Больше примеров:

ill eel выходы illlll eelell

laser bat выходы laserasersererr batatt

darth vader выходы dartharthrththh vaderaderdererr

Это код гольф, поэтому выигрывает самый короткий код.

Пояснение:
Вы можете рассматривать ввод или вывод как список. Вы можете разделить слова, используя новую строку вместо пробела. Вы можете добавить завершающий пробел для ввода.

code-golf  string 
— qazwsx
источник
22
честно говоря, несколько слов вещь немного раздражает. Все, что он делает, это требует разделения, применяет функцию к каждому слову, а затем присоединяется снова. Это также довольно изнурительно для большого количества esolangs, которые должны проверять пробел вручную
— Джо Кинг,
4
Можем ли мы принять ввод как список слов и вывод как таковой?
— Quintec
4
Какую длину слова нужно обрабатывать?
— MickyT
5
Можно ли разделять слова новой строкой в ​​выводе (вместо пробела)?
— JayCe
10
1.Пожалуйста, обновите спецификацию новыми допусками (массив ввода / вывода, завершающий пробел и т. Д.). 2.Пожалуйста, сообщите существующим решениям на случай, если кто-либо может сохранить байты, воспользовавшись ими.
— Лохматый

Ответы:

34

Japt -m, 6 3 байта

Ввод и вывод - это массивы слов.

£sY

Попробуй

объяснение

        :For each word in the input array
£       :Map each letter at index Y
 sY     :  Slice the current word from index Y
— мохнатый
источник
1
Это действительно компактно. Приятно!
— qazwsx
9
@qazwsx: Теперь 50% более компактным!
— лохматый
1
Разве £в UTF-8 нет двух байтов?
— Ви.
7
@Vi, я не использую UTF-8 здесь.
— Лохматый
36

брейкфук , 60 56 байт

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

Попробуйте онлайн!

Требуется завершающий пробел и печать начального пробела. Оба из них могут быть обойдены, но это заканчивается в 112 байтов .

объяснение

,[  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
— Джо Кинг
источник
21

Haskell, 36 21 байт

map$concat.scanr(:)""

Попробуйте онлайн!

Изменить: -15 байт из-за нового формата ввода-вывода (список слов вместо слов, разделенных пробелом)

— Ними
источник
Вы можете сбрить 5 символов, заменив scanr (:) ""на tails.
— Фрерих Раабе
1
@FrerichRaabe: да, но для этого нужно import Data.Listдобавить 17 байт к партитуре.
— Nimi
18

Perl -p, 36 25 23 байта

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

Попробуйте онлайн!

Это единственный regsub. Во-первых, он соответствует всем границам слов или непробельным символам:

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

Обратите внимание, что каждое из этих совпадений должно быть заменено остальной частью слова:

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

Мы можем сделать это с помощью специальной переменной $', которая хранит часть строки после совпадения. Однако нам нужно применить к нему вложенную regsub s/ .*//, которая удаляет все, что находится за первым пробелом в $', чтобы избавиться от оставшихся слов во входных данных.

Спасибо @nwellnhof за 2 байта.

— Дверная ручка
источник
Вы можете заменить [^ ]на \S.
— nwellnhof
17

Желе , 3 байта

ḊƬ€

Попробуйте онлайн!

Больше не нужны Ks, так как теперь разрешен ввод / вывод массива.

ḊƬ€
  €   For each word:
Ḋ       Remove the first letter
 Ƭ      until there are none left.
— dylnan
источник
Я думаю, что вам нужно ḊƬẎ)(или ḊƬF), если вы предпочитаете).
— Эрик Outgolfer
@EriktheOutgolfer Я так не думаю. Каждое слово представлено отдельным массивом в выводе
— dylnan
1
Я не уверен, что вы можете это утверждать, поскольку массивы являются вложенными, и в вопросе ничего не указано, чтобы это было разрешено.
— Эрик Outgolfer
15

APL (Dyalog), 19 9 байтов

{⌽∊,\⌽⍵}¨

спасибо @ H.PWiz за пробежку по мозгу

Это работает, потому что все строки в APL являются символьными массивами.

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

TIO

— Quintec
источник
15

JavaScript (ES6), 33 байта

Сохранено 1 байт благодаря @ShieruAsakoto

Формат ввода / вывода: массив слов.

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

Попробуйте онлайн!

JavaScript (ES6), 35 байт

Формат ввода / вывода: массив слов.

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

Попробуйте онлайн!

— Arnauld
источник
2
44:s=>s.replace(/\S+/g,g=s=>s&&s+g(s.slice(1)))
— Сиеру Асакото
1
Спасибо за мое "что-то новое" на сегодня; никогда не знал о $'(или $<backtick>).
— лохматый
13

R , 82 75 67 байт

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

Попробуйте онлайн!

Несколько байтов сохранено благодаря JayCe

Разделяет вывод символами новой строки.

sapply(...)Выражение генерирует матрицу / вектор - столбец соответствующих подстрок, дополняя с по ""мере необходимости. writeзатем печатает элементы матрицы в yкаждой строке, разделяя их с помощью "".

— Giuseppe
источник
4
Гольф другой подход, держа сонный ребенок; позже добавлю объяснение.
— Джузеппе
2
Если длина слов ограничена, например, 99 символов или ~ 1e6, тогда вы можете выбить кучу байтов с помощью ...substring,1:1e6,1e6)...или схожим значением
— MickyT
2
Если вы можете разделить слова новой строкой : tio . Я спросил это в комментарии. Может работать с комментариями @ MickyT
— JayCe
@JayCe выглядит так, что до включения предложения MickyT это может быть 67 байт
— Джузеппе
8

брейкфук , 94 93 байта

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

Попробуйте онлайн!

  • Сохраненный один байт благодаря Nitrodon - игра .[-]>[.>]<[<]>в гольф [.>]<[<]>[-]>.

объяснение

[[[ (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
 >>>>.<<
]

Попробуйте онлайн!

приписывание

Константная коллекция Эзоланга использовалась для начальной космической нагрузки.

— Джонатан Фрех
источник
Это не заканчивается. Это предназначено?
— Джо Кинг,
1
@ Шучу Да. В некоторых реализациях он превысил бы предел ленты, выйдя по ошибке.
— Джонатан Фрех,
6

05AB1E , 5 байтов

€.síJ

Попробуйте онлайн!

объяснение

€.s        # push suffixes of each
   í       # reverse each
    J      # join suffixes
— Emigna
источник
1
Скучная 5- í€ηJíбайтовая альтернатива: (поскольку префиксы являются встроенными 1-байтовыми, а не 2-байтовыми, как суффиксы; все же требуется дополнительный обратный-каждый, однако в начале, поэтому количество байтов остается 5).
— Кевин Круйссен
6

Vim , 47 байт (38 нажатий клавиш)

Начните с ввода в качестве единственной строки в буфере Vim.

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

объяснение

Это помещает каждое слово в отдельную строку, перебирает каждую строку, а затем объединяет их все. Разрывы, если слова длиннее 99 символов или если ваш ввод содержит более 99 слов.

  1. :s/<Space>/\r/g<CR> заменяет пробелы новыми строками ( \r)
  2. gg позиционирует курсор в начале первой строки
  3. qaначинает запись макроса A :
    • yw дергает остальное слово
    • P помещает его за курсор
    • lx удаляет первую букву последнего слова
    • qостанавливает запись макроса A
  4. qbначинается запись макроса б :
    • 99@aвыполняет макрос девяносто девять раз (вводит ограничение на количество символов)
    • j0 позиционирует курсор в начале следующей строки
    • qостанавливает запись макроса b
  5. 99@bвыполняет макрос b девяносто девять раз (вводит ограничение по слову)
  6. gg позиционирует курсор на первой строке
  7. 99J объединяет следующие девяносто девять строк с пробелами (снова ограничение по числу слов)

Для других 2 байтов (2 нажатия клавиш) вы можете расширить ограничение по словам до 999. Еще 4 байта, 9999 и т. Д.

— chambln
источник
6

Шелуха , 6 4 байта

-2 байта благодаря Джонатану Аллану (принимая входные данные в виде списка)!

moΣṫ

Попробуйте онлайн!

объяснение

Принимает ввод как список строк и отображает следующую функцию:

Σṫ  -- example argument: "abc"
 ṫ  -- tails: ["abc","bc","c"]
Σ   -- concat: "abcbcc"
— ბიმო
источник
Разделение и соединение, возможно, больше не требуются, в настоящее время такая спецификация находится в комментарии.
— Джонатан Аллан
5

Сетчатка 0.8.2 , 15 байт

 
¶
.
$&$%'
¶

Попробуйте онлайн! Примечание: завершающие пробелы. Объяснение:

Сплит на пространствах.

.
$&$%'

Добавьте его суффикс к каждой букве. Это %означает, что мы получаем только суффикс слова.

Присоединяйтесь с пробелами.

— Нил
источник
5

16-битный код сборки x86, 24 байта

     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

Вызов с si = указатель на исходную строку, di = указатель на выходной буфер.
Исходная строка требует нулевого байта для ее завершения.
Код одинаков в 16-, 32- или 64-битном формате (si / di становится либо esi / edi, либо rsi / rdi).
32-битный код на два байта больше из-за расширенного вызова.
64-битный код еще на три байта больше, потому что inc / dec rsi / rdi привлекает префикс (но если известно, что они находятся в пределах 32-битного пространства памяти, то они могут быть снова esi / edi, чтобы избежать этого штрафа) ,

— Питер Ферри
источник
4

MATL , 18 16 байтов

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

Ввод представляет собой массив слов. Попробуйте онлайн!

объяснение

"         % 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
— Луис Мендо
источник
4

C ++ (лязг) , 174 байта

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

Попробуйте онлайн!

Это мое первое представление, и я не знаю, нормально ли возвращать строку вместо печати :)

— QJot
источник
2
Добро пожаловать в PPCG! Да, возвращать строку в порядке. Надеюсь, вы остаетесь вокруг!
— Джо Кинг,
Вы можете использовать симметрию оператора неравенства, чтобы удалить пробел и, таким образом, сохранить байт - return w!=""?может быть return""!=w?.
— Джонатан Фрех
3

Древесный уголь , 14 байтов

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

Попробуйте онлайн! Примечание: место в конце. Ссылка на подробную версию кода. Объяснение:

   Ｓ            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
— Нил
источник
3

Пип -s , 11 байт

J_@>,#_Mq^s

Принимает разделенный пробелами список слов из stdin. Попробуйте онлайн!

объяснение

             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
источник
3

K (ок) , 17 13 байт

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

Попробуйте онлайн!

Префикс анонимной функции; Ввод принимается как список строк, которые в свою очередь являются списками символов.

Спасибо @streetster за 4 байта.

Как:

{,/|:'|,\|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")
— Ж. Салле
источник
Вы можете вернуть список, а также взглянуть на мое решение ОК
— StreetSter
@streetster О, хорошо. Я все еще изучаю K, поэтому мои решения не будут такими же короткими и элегантными, как хотелось бы. Спасибо за головы!
— Ж. Салле
Функция Flatten before reverse позволяет вам опускать «reverse-each», {|,/,\|x}'
— уменьшая
3

Common Lisp , 179 байт

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

Попробуйте онлайн!

Это моя первая попытка игры в гольф. Любые изменения приветствуются.

— JRowan
источник
Привет и добро пожаловать в PPCG. Удаление пробелов может сэкономить вам 29 байт .
— Джонатан Фрех
@Johnathan Frech спасибо, я только что обновил без пробелов
— JRowan
Я думаю, что вы пропустили четыре лишних пробела.
— Джонатан Фрех
Скорее всего, вы также можете использовать carвместо firstи cdrвместо того, restчтобы продолжить игру.
— Джонатан Фрех
Na, я хорошо с этим сейчас, ха-ха, может быть, плохо вернусь и возиться с этим позже. Сейчас я только учусь шутить, мой учитель сказал, что никогда не пользуюсь автомобилем и CDR, чтобы они были у меня в голове, пока я делал это
— JRowan
3

Луа , 70 байт

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

Попробуйте онлайн!

объяснение

Аргументы в Lua хранятся в таблице, argначиная с индекса 1. Унарный оператор #возвращает размер таблицы, а функция s:sub(a,b)возвращает подстроку на основе строки, sразделенной целыми числами, aи b, если b не передано, она возвращает остальную часть строки.

Я должен был использовать io.write()вместо того, print()чтобы избежать разрыва строки, и добавил print()в конце по противоположной причине.

— Марсио Медейрос
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.