Повторите N-е элементы

18

У нас не было строки вопроса в течение некоторого времени (5 дней, чтобы быть точным), поэтому давайте перейдем к одному.

Получив строку sи положительное целое число n, возьмите каждый nэлемент th s, повторите его nраз и поместите обратно вs .

Например, если n = 3и s = "Hello, World!", каждый третий символ Hl r!. Затем вы повторяете каждый символ nраз для производства HHHlll rrr!!!. Затем вы заменяете исходные буквы повторяющимися версиями, чтобы получить конечный продуктHHHellllo, Worrrld!!!

Вы должны выполнить эту задачу в кратчайшие сроки на вашем языке!

правила

  • Это код-гольф поэтому выигрывает самый короткий код в байтах
  • n гарантированно будет меньше, чем длина s и больше 0
  • Первый символ s- это то, откуда nвзяты эти символы, и он всегда повторяется.n раз
  • sбудет состоять только из печатного ASCII (код указывает 0x20 (space)на 0x7E (~))

Контрольные примеры

s, n => output

"Hello, World!", 3 => "HHHellllo,   Worrrld!!!"
"Code golf", 1 => "Code golf"
"abcdefghijklm", 10 => "aaaaaaaaaabcdefghijkkkkkkkkkklm"
"tesTing", 6 => "ttttttesTingggggg"
"very very very long string for you to really make sure that your program works", 4 => "vvvvery    veryyyy verrrry loooong sssstrinnnng foooor yoooou toooo reaaaally    makeeee surrrre thhhhat yyyyour    proggggram    workkkks"
code-golf  string 
— Caird Coneheringaahing
источник
Можем ли мы принять входные данные sкак массив символов?
— Кевин Круйссен,
2
" и положить его обратно вs " <- это строгое требование (перезаписать исходную строку) или нормально просто выводить конечный результат?
— Феликс Пальмен
@KevinCruijssen Да, вы можете
— Caird Coneheringaahing
1
@FelixPalmen это было просто, как я это объяснил. Вы можете использовать любой метод, который вы хотите
— caird coinheringaahing
@cairdcoinheringaahing хорошо, спасибо, уже сделал это.
— Феликс Пальмен

Ответы:

10

Желе , 3 байта

Ḣs×

Ввод принимается как s, n .

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

Как это устроено

Ḣs×  Main link. Argument: s, n

Ḣ    Head; yield s.
     This pops the list, leaving [n] as the main link's argument.
 s   Split s into chunks of length n.
  ×  Multiply each chunk by [n], repeating its first element n times.
— Деннис
источник
Разве это не 6 байтов в кодировке UTF-8? E1 B8 A2 73 C3 97
— CoDEmanX
5
В UTF-8 да. Тем не менее, Jelly использует пользовательскую кодовую страницу , где каждый из символов, которые он понимает, занимает только один байт.
— Деннис
7

Желе ,  6  5 байт

-1 байт благодаря дырявой монахине (используйте умножение строк в Python.)

×Jm¥¦

Полная программа, принимающая два аргумента командной строки, строку и число и печатающая результат.

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

Как?

×Jm¥¦ - Main link: list of characters, s; number, n   e.g. ['g','o','l','f','e','r'], 2
    ¦ - sparse application:
   ¥  - ...to indices: last two links as a dyad:
 J    -      range of length of s                          [1,2,3,4,5,6]
  m   -      modulo slicing by n (every nth entry)         [1,3,5]
×    - ...action: multiply  ["gg",'o',"ll",'f',"ee",'r']
      - implicit print                                 >>> ggollfeer
— Джонатан Аллан
источник
— Утренняя монахиня
Да, попытался xзабыл ×; Благодарю.
— Джонатан Аллан
Разве это не 8 байтов в кодировке UTF-8? C3 97 4A 6D C2 A5 C2 A6
— CoDEmanX
2
@CoDEmanX использует пользовательскую кодовую страницу
— MD XF
@MDXF спасибо за выставку!
— Джонатан Аллан
4

JavaScript (ES6), 46 байт

Принимает ввод в синтаксисе карри (s)(n).

s=>n=>s.replace(/./g,(c,i)=>c.repeat(i%n?1:n))

Контрольные примеры

Показать фрагмент кода

— Arnauld
источник
3

05AB1E , 8 7 байт

-1 байт благодаря @Emigna

ôʒć²×ì?

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

объяснение

ôʒć²×ì?    Arguments s, n  ("Hello, World!", 3)
ô          Split s into pieces of n  (["Hel", "lo,", ...])
 ʒ         Filter (used as foreach)
  ć          Extract head  ("Hel" -> "el", "H" ...)
   ²×ì       Repeat n times and prepend  ("el", "H" -> "HHHel" ...)
      ?      Print without newline
— kalsowerus
источник
Сохранить байт сôʒć²×ì?
— Emigna
@ Emigna спасибо, я знал, что должен быть способ избавиться от закрытия}
— kalsowerus
Странное использование фильтра, когда он не использует результат, но на самом деле это имеет значение ...
— Волшебный осьминог Урна
@MagicOctopusUrn, да, фильтр все еще лучше foreach в 05AB1E
— kalsowerus
@kalsowerus vy- это один foreach, εдругой. Как ни странно, εне работает.
— Волшебная Осьминога Урна
2

PowerShell , 51 байт

param($a,$n)-join($a|%{($_,("$_"*$n))[!($i++%$n)]})

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

charВводит как -array $aи число $n. Зацикливается, $aи каждая итерация либо выводит текущую букву $_или текущую букву, умноженную на $n, основанную на индексе, в псевдо-троичную. Индекс выбирает между двумя на основе увеличения $iи затем по модулю $n. Эти буквы затем -joinобъединяются, и строка остается на конвейере; вывод неявный.

— AdmBorkBork
источник
2

Алиса , 25 байт

/
KI /!Iw?&.?t&O?&wWOI.h%

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

объяснение

/         Switch to Ordinal.
I         Read first line of input (i.e. n).
/         Switch to Cardinal.
!         Convert input to its integer value and store it on the tape.
I         Read first character from input string.
w         Push current IP address onto the return address stack. This
          effectively marks the beginning of the main loop.

  ?         Retrieve n.
  &.        Duplicate current character n times (once more than we need,
            but who cares about a clean stack...).
  ?t        Retrieve n and decrement.
  &O        Output n-1 copies of the current character.
  ?         Retrieve n.
  &w        Push the current IP address onto the return address stack n
            times. This marks the beginning of a loop that is executed n 
            times.

    W         Discard one copy of the return address from the stack,
              effectively decrementing the loop counter.
    O         Output the last character. On the first iteration, this is
              the final copy of the repeated character, otherwise it's just
              the single character we read on the last iteration.
    I         Read a character for the next iteration.
    .h%       Compute c % (c+1) on that character, which is a no-op for
              for valid characters, but terminates the program at EOF when
              c becomes -1.

K         Jump to the address on top of the return address stack. As long
          as there are still copies of the address from the inner loop, we
          perform another iteration of that, otherwise we jump back to the
          beginning of the outer loop.
— Мартин Эндер
источник
2

R , 82 76 75 байт

function(s,n)cat(rep(S<-el(strsplit(s,'')),c(n,rep(1,n-1))+!seq(S)),sep='')

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

Функция; принимает строку sи целое число nи печатает повторенную версию в стандартный вывод.

Объяснение:

function(s,n){
 S <- el(strsplit(s,""))                  # characters
 r     <- c(n,rep(1,n-1))                 # [n, 1, 1,...,1], length n
 repeats <- r+!seq(S)                     # extends R to length of S
 cat(rep(S, repeats), sep="")             # print out
}

R , 55 байт

function(S,n)cat(rep(S,c(n,rep(1,n-1))+!seq(S)),sep="")

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

Тот же алгоритм, что и выше, но со Sсписком отдельных символов.

— Giuseppe
источник
1

Japt , 8 байт

ËùDV*EvV

Проверьте это онлайн!

объяснение

 Ë    ùDV*EvV
UmDE{DùDV*EvV}   Ungolfed
                 Implicit: U = s, V = n
UmDE{        }   Replace each char D and (0-)index E in U by this function:
          EvV      Take 1 if the index is divisible by V; 0 otherwise.
        V*         Multiply this by V. This gives V for every Vth index; 0 for others.
     DùD           Pad D with itself to this length. This gives V copies of D for every
                   Vth index; 1 copy of D for others.
                 Implicit: output last expression

Я должен кредитовать идею использовать ùдля @Shaggy ответа «s здесь . Я не знаю, что я когда-либо думал об этом сам ...

— ETHproductions
источник
Теперь вы понимаете, почему так хотелось добавить заполнение строк :) Отличное решение. Я пытался найти что-то, с чем можно было бы поработать ë, от хохота и хихиканья, но с треском провалился!
— Лохматый
1

J, 17 байт

(#@]$[,1#~<:@[)#]
  • (...) # ]все в паранах создает строку для встроенного глагола J «copy». Так, например, если левый аргумент равен 3, он создает строку, 3 1 1повторяемую по мере необходимости, чтобы равняться количеству символов в правом аргументе ], который содержит строку. То есть #решает проблему напрямую, предполагая, что мы можем дать ей правильный левый аргумент: 4следует 4 1 1 1повторить и так далее.
  • Исследуя #@]$[,1#~<:@[, мы видим, что он использует глагол формы J$ в середине - это основной глагол этой фразы ...
  • Слева от $is #@], что означает длину #правого аргумента ].
  • Справа от него $- [,1#~<:@[поезд из 5 глаголов. Первый выполненный поезд ...
  • 1#~<:@[, что означает, что 1 скопированная #~(пассивная форма копирования) на один меньше, чем <:левый аргумент [. Этот результат передается на финальную ветвь:
  • [, ...то есть взять левый аргумент и добавить только что вычисленный результат, который представляет собой строку 1s.

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

— Ион
источник
]#~[^0=(|i.@#)за 14 байт
— миль
Это довольно умно. Ваши улучшения моих постов - лучшая часть этого сайта для меня.
— Иона
1

Perl 5, 37 , 29 +1 (-p) байт

-8 байт благодаря комментарию Тома.

$n=<>;s/./"@-"%$n?$&:$&x$n/ge

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

— Науэль Фуйе
источник
Сейчас я не могу придумать лучшего подхода, но у меня возникло несколько идей: $n=<>;вместо BEGINблока и иметь nследующую строку ввода и заменить $-[0]на, "@-"так как для сравнения оценивается только первое число. Кроме того, если вы принимаете ввод nчерез via, -iвы можете просто использовать $^Iвместо объявления и использования $n, но, поскольку это нестандартно, оно может не летать ... :)
— Dom Hastings
1

6502 подпрограммы машинного кода , 50 байтов

A0 01 84 97 88 84 9E 84 9F B1 FB F0 20 A4 9F 91 FD C6 97 D0 10 A6 FF CA F0
05 C8 91 FD D0 F8 84 9F A5 FF 85 97 E6 9E A4 9E E6 9F D0 DC A4 9F 91 FD 60

Это позиционно-независимая подпрограмма, ожидающая указатель на входную строку (0-концевая a-C-строка) в $fb/ $fc, указатель на выходной буфер в $fd/ $feи count ( n) в$ff . Он использует простую индексацию, поэтому максимальная длина вывода составляет 255 символов (+ 0 байт) из-за 8-битной архитектуры.

Пояснение (комментируется разборка):

 .rep:
A0 01       LDY #$01            ; init counter to next repetition sequence
84 97       STY $97
88          DEY                 ; init read and write index
84 9E       STY $9E             ; (read)
84 9F       STY $9F             ; (write)
 .rep_loop:
B1 FB       LDA ($FB),Y         ; read next character
F0 20       BEQ .rep_done       ; 0 -> finished
A4 9F       LDY $9F             ; load write index
91 FD       STA ($FD),Y         ; write next character
C6 97       DEC $97             ; decrement counter to nex rep. seq.
D0 10       BNE .rep_next       ; not reached yet -> next iteration
A6 FF       LDX $FF             ; load repetition counter
 .rep_seqloop:
CA          DEX                 ; and decrement
F0 05       BEQ .rep_seqdone    ; if 0, no more repetitions
C8          INY                 ; increment write index
91 FD       STA ($FD),Y         ; write character
D0 F8       BNE .rep_seqloop    ; and repeat for this sequence
 .rep_seqdone:
84 9F       STY $9F             ; store back write index
A5 FF       LDA $FF             ; re-init counter to next ...
85 97       STA $97             ; ... repetition sequence
 .rep_next:
E6 9E       INC $9E             ; increment read index
A4 9E       LDY $9E             ; load read index
E6 9F       INC $9F             ; increment write index
D0 DC       BNE .rep_loop       ; jump back (main loop)
 .rep_done:
A4 9F       LDY $9F             ; load write index
91 FD       STA ($FD),Y         ; and write terminating0-byte there
60          RTS                 ; done.

Пример программы с машинным кодом C64, использующей ее :

Это программа на ассемблере стиля ca65 для C64, использующая эту подпрограмму (импортируется как rep):

REP_IN          = $fb
REP_IN_L        = $fb
REP_IN_H        = $fc

REP_OUT         = $fd
REP_OUT_L       = $fd
REP_OUT_H       = $fe

REP_N           = $ff

.import         rep


.segment "LDADDR"
                .word   $c000

.code
                jsr     $aefd           ; consume comma
                jsr     $ad9e           ; evaluate expression
                sta     REP_IN_L        ; store string length
                jsr     $b6a3           ; free string
                ldy     #$00            ; loop over string
readloop:       cpy     REP_IN_L        ; end of string?
                beq     termstr         ; then jump to 0-terminate string
                lda     ($22),y         ; read next character
                sta     in,y            ; store in input buffer
                iny                     ; next
                bne     readloop
termstr:        lda     #$00            ; load 0 byte
                sta     in,y            ; store in input buffer

                jsr     $b79b           ; read 8bit unsigned int
                stx     REP_N           ; store in `n`
                lda     #<in            ; (
                sta     REP_IN_L        ;   store pointer to
                lda     #>in            ;   to input string
                sta     REP_IN_H        ; )
                lda     #<out           ; (
                sta     REP_OUT_L       ;   store pointer to
                lda     #>out           ;   output buffer
                sta     REP_OUT_H       ; )
                jsr     rep             ; call function

                ldy     #$00            ; output result
outloop:        lda     out,y
                beq     done
                jsr     $ffd2
                iny
                bne     outloop
done:           rts


.bss
in:             .res    $100
out:            .res    $100

Онлайн демо

Использование: sys49152,"[s]",[n] напримерsys49152,"Hello, World!",3

Важно: если программа была загружена с диска (как в онлайн-демонстрации), newсначала введите команду! Это необходимо, потому что при загрузке машинной программы перегружаются некоторые основные указатели C64.

— Феликс Палмен
источник
1

Java 8, 100 76 байт

s->n->{int i,k=0;for(char c:s)for(i=k++%n<1?n:1;i-->0;)System.out.print(c);}

-24 байта благодаря @ OliverGrégoire .

Объяснение:

Попробуй это здесь.

s->n->{                    // Method with char-array and int parameters and no return-type
  int i,k=0;               //  Index-integers
  for(char c:s)            //  Loop (1) over the characters of the input array
    for(i=k++%n<1?         //   If `k` is divisible by the input `n`:
         n                 //    Change `i` to `n`
        :                  //   Else:
         1;                //    Change `i` to 1
        i-->0;)            //   Inner loop (2) from `i` down to 0
      System.out.print(c); //    And print the current character that many times
                           //   End of inner loop (2) (implicit / single-line body)
                           //  End of loop (1) (implicit / single-line body)
}                          // End of method
— Кевин Круйссен
источник
К сожалению, я не видел, что уже была отправка, поэтому я удалил свою. Вот оно, сокращено до 76 байтов: n->s->{int i,k=0;for(char c:s)for(i=k++%n<1?n:1;i-->0;)System.out.print(c);}(с char[], а не String.)
— Оливье Грегуар
Правило большого пальца: если вам нужно объявить ровно одну строку, которая будет возвращена, ее нужно просто распечатать.
— Оливье Грегуар
@ OlivierGrégoire Упс .. Да, я знаю это эмпирическое правило, просто забыла применить его на этот раз .. И спасибо за сохраненные байты!
— Кевин Круйссен
1

MATL , 10 7 байт

-3 байта благодаря Луису Мендо!

tq:ghY"

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

Принимает ввод как, nа затем Sкак массив строк / символов.

    % (implicit input)
    % stack: n
t   % duplicate
    % stack: n n
q   % decrement
    % stack: n n-1
:   % range
    % stack: n [1 2 ... n-1]
g   % convert to logical (nonzero->1, zero->0)
    % stack: n [1 1 ... 1]
h   % horizontal concatenate
    % stack: [n 1 1 ... 1]
Y"  % run-length decoding, taking the string as first input and recycling 
    % the lengths [n 1 1 ... 1] as needed
    % (implicit output as string)

— Giuseppe
источник
1

Haskell , 51 46 байт

Спасибо @Laikoni за то, что сэкономили мне 5 байтов!

n&s=do(m,c)<-zip[0..]s;c<$[0..(n-1)*0^mod m n]

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

Объяснение / Ungolfed

Оператор c <$ [a..b]заменяет каждый элемент списка [a,a+1...b]на c- так что это просто игра в гольф replicate:

do(m,c)<-zip[0..]s;                                  -- with all (m,c) in the enumerated ([(0,a),(1,b)..]) input string, replace with
                   replicate (1 + (n-1)*0^mod m n) c -- either n or 1 times the character c (note that the list begins with 0, that's where the 1+ comes from)
— ბიმო
источник
0

V , 13 байт

"aDJòylÀpÀll

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

Это действительно тупой обходной путь. òlhÀälÀlÀ<M-->lдолжно работать, но я не могу за жизнь мне понять , почему, тем более , что вручную Doing lhÀälÀlÀ<M-->lповторяется кучу раз делает работу.

HexDump:

00000000: 1822 6144 4af2 796c c070 c06c 6c         ."aDJ.yl.p.ll

Объяснение:

<C-x>               " Decrement the number
       D            " Delete that number...
     "a             "   Into register 'a'
        J           " Remove the blank line
         ò          " Recursively...
          yl        "   Yank the letter under the cursor
            Àp      "   And paste it 'a' times
              Àl    "   Move 'a' times to the right ('l' for right)
                l   "   Move to the right one more time
                    " (implicit) end the loop
— DJMcMayhem
источник
'l' for right... Я полагаю, это что-то вроде Vim? Иначе ... почему ?
— AdmBorkBork
2
@AdmBorkBork да l, прямо в Vim. это может быть орфографически задом наперед, но это геометрически правильно: lэто самый правый буквенный ключ среднего ряда.
— Иона
@DJMcMayhem Верно. Я сделал это правильно.
— Иона
0

Python 3 , 58 байт

Работаю над игрой в гольф.

Я знаю, что уже есть другие ответы на Python, но я подумал, что опубликую и этот, увидев, что он довольно неплох по сравнению с остальными, несмотря на то, что это полноценная функция, а не лямбда.

Принимает ввод как параметры функции и печатает в STDOUT.

def f(s,n,i=0):
 for c in s:print(end=[c,c*n][i%n<1]);i+=1

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

На один байт меньше (57) я кодировал лямбду, однако подобные ответы уже были опубликованы другими пользователями:

lambda s,n:''.join([c,c*n][i%n<1]for i,c in enumerate(s))
— FlipTack
источник
0

Brain-Flak (Брейнхак) , 122 + 3 (-A ) = 125 байт

Я уверен, что это слишком долго, но я потратил довольно много времени на поиски и не смог найти никаких улучшений.

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

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

— H.PWiz
источник
0

05AB1E , 12 11 байт

vX‚RNIÖèy×?

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

объяснение

v             # for each letter in the input string
       è      # index into
 X‚           # the list [input_int,1]
   R          # reversed
    NIÖ       # with letter_index % input_int == 0
        y×    # repeat the current letter this many times
          ?   # print
— Emigna
источник
0

К (ок) , 23 19 байт

Решение:

{,/(1|y*~y!!#x)#'x}

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

Примеры:

> {,/(1|y*~y!!#x)#'x}["Hello, World!";3]
"HHHellllo,   Worrrld!!!"
> {,/(1|y*~y!!#x)#'x}["Code golf";1]
"Code golf"
> {,/(1|y*~y!!#x)#'x}["abcdefghijklm";10]
"aaaaaaaaaabcdefghijkkkkkkkkkklm"

Объяснение:

{,/(1|y*~y!!#x)#'x} / the solution
{                 } / lambda function with x and y as implicit parameters
   (          )     / do everything in brackets together
            #x      / count x, #"Hello, World!" -> 13
           !        / til, !13 -> 0 1 2 3 4 5 6 7 8 9 10 11 12
         y!         / y modulo, 3!0 1 2 3 4 5 6 7 8 9 10 11 12 -> 0 1 2 0 1 2 0 1 2 0 1 2 0
        ~           / not, ~0 1 2 0 1 2 0 1 2 0 1 2 0 -> 1 0 0 1 0 0 1 0 0 1 0 0 1
      y*            / multiply by y, 3*1 0 0 1 0 0 1 0 0 1 0 0 1 -> 3 0 0 3 0 0 3 0 0 3 0 0 3
    1|              / min of 1 and, 1|3 0 0 3 0 0 3 0 0 3 0 0 3 -> 3 1 1 3 1 1 3 1 1 3 1 1 3
                #'x / take each parallel, 1 2 3#'"abc" -> "a", "bb", "ccc"
 ,/                 / flatten the list, "a", "bb", "ccc" -> "abbccc"

Примечания:

  • -4 байта с другим подходом
— streetster
источник
0

Excel VBA, 71 байт

Функция анонимного непосредственного окна VBE, которая берет входные данные из диапазона [A1:B1]и выводит в непосредственное окно VBE.

For i=1To[Len(A1)]:[C1]=i:?[Rept(Mid(A1,C1,1),B1^(Mod(C1,B1)=1))];:Next
— Тейлор Скотт
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.