N 번째 요소 반복


18

우리는 한동안 (5 일 정확한) 문제 가 없었 으므로 한번가 봅시다.

문자열 s과 양의 정수가 주어지면의 n모든 n요소를 가져 와서 s반복 n하고 다시 넣습니다 s.

예를 들어 if n = 3s = "Hello, World!"이면 세 번째 문자는 모두 Hl r!입니다. 그런 다음 각 문자를 반복 n하여 생성 HHHlll rrr!!!합니다. 그런 다음 원래 문자를 반복 버전으로 바꾸어 최종 제품을 만듭니다.HHHellllo, Worrrld!!!

귀하의 언어로 가능한 가장 짧은 코드로이 작업을 수행해야합니다!

규칙

  • 이것은 이므로 바이트 단위의 가장 짧은 코드가 승리합니다.
  • n길이보다 작고 s0보다 커야합니다.
  • 의 첫 번째 문자는 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"

입력 s을 문자형 배열로 취할 수 있습니까 ?
Kevin Cruijssen

2
" <-에 다시 넣습니다s . <-이것은 엄격한 요구 사항입니까 (원래 문자열을 덮어 쓰는 것입니까) 아니면 최종 결과 만 출력해도 괜찮습니까?
Felix Palmen

@KevinCruijssen 예 당신은 할 수 있습니다
caird coinheringaahing

1
@FelixPalmen 그것은 단순히 내가 그것을 설명 한 방법이었습니다. 원하는 모든 방법을 사용할 수 있습니다
caird coinheringaahing

@cairdcoinheringaahing 좋은, 감사합니다, 이미 그랬습니다.
Felix Palmen

답변:


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.

UTF-8 인코딩에서 실제로 6 바이트가 아닙니까? E1 B8 A2 73 C3 97
CoDEmanX

5
UTF-8에서는 그렇습니다. 그러나 Jelly는 사용자 정의 코드 페이지를 사용합니다 . 여기서 이해하는 각 문자는 단일 바이트 만 사용합니다.
Dennis

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잊어 버렸다 ×; 감사.
Jonathan Allan

UTF-8 인코딩에서 실제로 8 바이트가 아닙니까? C3 97 4A 6D C2 A5 C2 A6
CoDEmanX

2
@CoDEmanX Jelly의 사용자 정의 코드 페이지 사용
MD XF

@MDXF 수비에 감사드립니다!
Jonathan Allan

4

자바 스크립트 (ES6), 46 바이트

카레 구문으로 입력을 (s)(n)받습니다.

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

테스트 사례




3

05AB1E , 8 7 바이트

@Emigna 덕분에 -1 바이트

ôʒć²×ì?

온라인으로 사용해보십시오!

설명

ôʒć²×ì?    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

바이트를 저장ôʒć²×ì?
Emigna

@Emigna 덕분에, 폐쇄를 제거하는 방법이 있어야한다는 것을 알았습니다}
kalsowerus

결과를 사용하지 않지만 실제로 차이를 만들 때 필터를 이상하게 사용합니다.
Magic Octopus Urn

@MagicOctopusUrn는 네 필터는 여전히 05AB1E에서 더 나은 foreach 문이다
kalsowerus

@kalsowerus vy는 하나의 foreach이고 ε다른 하나입니다. 이상하게도 ε작동하지 않습니다.
매직 문어 Urn

2

PowerShell , 51 바이트

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

온라인으로 사용해보십시오!

입력을 char배열 $a및 숫자 로 취합니다 $n. 루프 스루 $a및 각 반복 은 의사 삼항으로의 색인을 기반으로 현재 문자 $_또는 현재 문자에을 곱한 값을 출력합니다 $n. 지수는 증분 기반 $i과 모듈로 중 두 가지 중에서 선택합니다 $n. 그런 다음 해당 문자가 -join다시 연결되고 문자열이 파이프 라인에 남습니다. 출력은 암시 적입니다.



2

Alice , 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반복 된 버전을 stdout에 인쇄합니다.

설명:

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개별 문자 목록으로 사용됩니다.




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 의 대답은 여기 . 나는 내가 그것을 스스로 생각했을지도 모른다 ...


당신은 왜 문자열 패딩이 추가되는 것을보고 싶어하는지 알 수 있습니다 :) 좋은 해결책. 나는 ë똥과 낄낄 거림 을 위해 무언가를 얻으려고 했지만 비참하게 실패했습니다!
Shaggy

1

J, 17 바이트

(#@]$[,1#~<:@[)#]
  • (...) # ]parens의 모든 것은 J의 "복사"동사에 대한 문자열을 작성합니다. 예를 들어, 왼쪽 인수가 3이면 문자열 을 포함하는 3 1 1오른쪽 arg의 문자 수와 같도록 필요한만큼 반복되는 문자열을 작성 ]합니다. 다시 말해서, #올바른 왼쪽 주장을 할 수 있다고 가정하면 문제를 직접 해결합니다 . 반복 4해야합니다 4 1 1 1.
  • 검사 #@]$[,1#~<:@[, 우리는 동사 J의 형태를 사용하여 참조 $중간에 -이 구절의 주요 동사의 ...
  • 왼쪽에 $있다 #@]길이 의미 #권리 인수의를 ].
  • 의 오른쪽 $IS [,1#~<:@[, 기차, 동사 5. 첫 번째 열차는 ...
  • 1#~<:@[이는 왼쪽 arg #~보다 1이 적은 1 개의 복사 된 (수동적 인 복사 형태) 을 의미 합니다. 이 결과는 최종 포크로 전달됩니다.<:[
  • [, ...의미는 왼쪽 인수를 취하고 방금 계산 한 결과 ( 1s 문자열)를 추가합니다 .

온라인으로 사용해보십시오!


]#~[^0=(|i.@#)14 바이트 동안
마일

꽤 영리합니다. 내 게시물에 대한 개선 사항은이 사이트의 가장 중요한 부분입니다.
Jonah


1

펄 5, 37 , 29 +1 (-p) 바이트

Tom의 의견 덕분에 -8 바이트.

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

온라인으로 사용해보십시오


지금 더 나은 방법을 생각하지만, 나는 몇 가지 아이디어를 내놓았다 수 없습니다 : $n=<>;대신의 BEGIN블록이 n입력의 다음의 행 및 교체 $-[0]와 함께 "@-"첫 번째 수를 비교 평가하기 때문이다. 또한 nvia -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

이것에 (C 문자열 일명 0 말단) 상기 입력 스트링에 대한 포인터를 기대하는 위치 독립적 인 루틴 $fb/ $fc출력 포인터는 버퍼 $fd/ $fe카운트 ( n단위) $ff. 간단한 인덱싱을 사용하므로 8 비트 아키텍처로 인해 최대 출력 길이는 255 자 (+ 0 바이트)로 제한됩니다.

설명 (설명 분해) :

 .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 머신 코드 프로그램 예제 :

이 루틴을 사용하여 C64 용 ca65 스타일 어셈블러 의 프로그램입니다 (로 가져 오기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 BASIC 포인터가 손상되기 때문에 이것은 필수입니다.


1

자바 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);}

@ OliverGrégoire 덕분에 -24 바이트 .

설명:

여기에서 시도하십시오.

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.로)
Olivier Grégoire

경험적으로, 반환 될 문자열을 정확히 하나만 선언해야하는 경우 인쇄하는 것이 더 짧습니다.
Olivier Grégoire

@ OlivierGrégoire 죄송합니다. 그렇습니다. 나는 경험 법칙을 알고 있습니다. 이번에는 적용하는 것을 잊어 버렸습니다. 그리고 저장된 바이트에 감사드립니다!
Kevin Cruijssen

1

MATL , 10 7 바이트

Luis Mendo 덕분에 -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)


1

하스켈 , 51 46 바이트

5 바이트를 절약 해 준 @Laikoni에게 감사드립니다!

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

온라인으로 사용해보십시오!

설명 / 비 골프

운영자는 c <$ [a..b]리스트의 각 요소를 대체 [a,a+1...b]하여 c- 그냥 golfed 그래서 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작동해야하지만, 내 삶에는 왜 수동으로 lhÀälÀlÀ<M-->l여러 번 반복하는 것이 효과 있기 때문에 이해할 수 없습니다 .

16 진 덤프 :

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

'l' for right... 이거 Vim 인 것 같아요? 그렇지 않으면 ... ?
AdmBorkBork

2
@AdmBorkBork 네, 정답 l입니다. 직교 적으로 거꾸로 될 수도 있지만 기하학적으로 정확합니다. l가운데 행의 가장 오른쪽 문자 키입니다.
Jonah

@DJMcMayhem 맞습니다. 나는 그것을 올바르게 만들었다.
Jonah


0

파이썬 3 , 58 바이트

골프를 타기 위해 노력하고 있습니다.

나는 이미 다른 파이썬 답변이 있다는 것을 알고 있지만, 람다가 아닌 완전한 기능 임에도 불구하고 다른 것들과 비교할 때 점수가 너무 높기 때문에 이것을 게시한다고 생각했습니다.

입력을 함수 매개 변수로 취하고로 인쇄합니다 STDOUT.

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

온라인으로 사용해보십시오!

1 바이트 미만 (57)의 경우 람다를 코딩했지만 다른 사용자가 비슷한 답변을 이미 게시했습니다.

lambda s,n:''.join([c,c*n][i%n<1]for i,c in enumerate(s))


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


0

K (oK) , 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 바이트

0

Excel VBA, 71 바이트

범위에서 입력 [A1:B1]을 받고 VBE 즉시 창으로 출력하는 익명 VBE 즉시 창 기능 .

For i=1To[Len(A1)]:[C1]=i:?[Rept(Mid(A1,C1,1),B1^(Mod(C1,B1)=1))];:Next
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.