Đăng từ đây .

Thách thức này rất "chắt lọc" từ câu hỏi này . Đặc biệt cảm ơn @Akababa!

Trong tác vụ này, bạn nên chèn dấu chấm than ở đầu chuỗi và sau mỗi ký tự.

Quy tắc

• Sẽ luôn có một đầu vào chuỗi không trống. Đầu vào cũng sẽ không chứa các tab. Bạn có thể giả định rằng đầu vào chỉ chứa các ký tự và dòng mới có thể in ASCII không mở rộng.
• Đầu vào sẽ không chứa các dòng mới, miễn là ngôn ngữ của bạn không thể phát hiện ra một dòng mới.
• Đây là một cuộc thi golf-code ; câu trả lời ngắn nhất sẽ giành chiến thắng.

Ví dụ

• 4 dòng mới dẫn đến 5 dấu chấm than được phân cách bằng dòng mới. Rất khó để đặt nó dưới dạng văn bản Markdown, vì vậy điều này được nêu thay thế.

1 2 3 4 5 6
129591 129012 129127 129582

0

Đầu ra

! 1! 2! 3! !4! 5! 6!
! 1! 2! 9! 5! 9! 1! ! 1! 2! 9! 0! 1! 2! ! 1! 2! 9! 1! 2! 7! ! 1! 2! 9! 5! 8! 2!
!
! 0!

asd afjoK ak: e
kPrLd
    fOJOE;
    KFO
KFkepjgop sgpaoj faj

Đầu ra

! a! s! d! ! a! f! j! o! K! ! a! k!:! e!
! k! P! r! L! d!
! ! ! ! ! f! O! J! O! E!;!
! ! ! ! ! K! F! O!
! K! F! K! E! P! J! G! O! P! ! s! g! p! a! o! j! ! ! ! f! a! j!

Một trường hợp thử nghiệm cơ sở chỉ có một ký tự:

một

Đầu ra

! a!

(Tự động hoàn tất! Đùa thôi, không có chuyện đó đâu.) Chứa dấu chấm than:

!!
!!
!!
!!
!!

Đầu ra:

!!!!!
!!!!!
!!!!!
!!!!!
!!!!!

QuadR , 1 byte

Cảm ơn A__ vì đã giảm một nửa số byte!

!

Hãy thử trực tuyến!

Thay thế không có gì với !

Python 3 , 27 byte

lambda s:f"!{'!'.join(s)}!"

Hãy thử trực tuyến!

Thành thật mà nói, tôi hy vọng ai đó có thể chỉ cho tôi một cách hay để làm điều này với số byte nhỏ hơn.

Python 3 , 26 byte

lambda s:s.replace('','!')

Hãy thử trực tuyến!

Võng mạc 0.8.2 , 2 byte

!

Hãy thử trực tuyến! Cuối cùng, một thử thách mà Retina đã tích hợp sẵn!

Haskell, 18 byte

('!':).(>>=(:"!"))

-1 byte nhờ @nimi

Hãy thử trực tuyến!

Python 2 , 27 byte

lambda s:'!%s!'%'!'.join(s)

Hãy thử trực tuyến!

JavaScript (ES6), 19 byte

Đưa đầu vào như một mảng các ký tự.

s=>`!${s.join`!`}!`

Hãy thử trực tuyến!

JavaScript (ES6),  23  20 byte

Đã lưu 3 byte nhờ @ShieruAsakoto

Đưa đầu vào dưới dạng một chuỗi.

s=>[,...s,,].join`!`

Hãy thử trực tuyến!

JavaScript (ES6), 22 byte

Được đề xuất bởi @tjjfvi

Đưa đầu vào dưới dạng một chuỗi.

s=>s.replace(/|/g,"!")

Hãy thử trực tuyến!

R , 25 byte

function(x)gsub("","!",x)

Hãy thử trực tuyến!

Một hàm chấp nhận và trả về một vectơ ký tự.

Mã máy 8086, định dạng .COM (MS-DOS 2+), 32 byte

(-1 tùy thuộc vào trình giả lập: xem bên dưới)

Để có kết quả tốt nhất, hãy chuyển hướng đầu vào tiêu chuẩn từ một tệp, vì việc gõ sẽ cho đầu ra trông kỳ quặc do không có bộ đệm; Ngoài ra, các dòng mới trông hơi lạ bởi vì chúng được lưu trữ dưới dạng CR LFvà CRphần này làm rối loạn đầu ra.

Chương trình này hoạt động tốt trong một mô phỏng MS-DOS thực tế (ví dụ PCjs) nhưng dường như DOSBox có vấn đề với Ctrl + Z EOF (xem các bình luận trong danh sách lắp ráp), vì vậy KHÔNG NÊN thử nhập dữ liệu bằng bàn điều khiển trong DOSBox trừ khi bạn thêm kiểm tra thêm!

BB 01 00 53 59 BA 0B 01 B4 40 CD 21 4A 4B B4 3F CD 21 85 C0 74 09 B4 40 43 41 CD 21 49 EB EE C3

Một số bit thú vị:

• Tôi đã lưu một số không gian dữ liệu bằng cách sử dụng lại bộ nhớ đã được thực thi ( 21Htrong trường hợp INT 21Hxảy ra !)

• Tôi gần như có thể sử dụng một mẹo thú vị mà tôi tìm thấy trên trang "Sức mạnh tiềm ẩn của Hướng dẫn BCD" cho phép tôi sử dụng AAAthay vì một tiêu chuẩn TESTđể so sánhAL với 0, tiết kiệm một byte. Thật không may, điều này không được ghi chép đầy đủ nên tôi không thể dựa vào nó: ví dụ, PCjs không điều chỉnh bất cứ thứ gì ngoại trừ cờ mang và phụ mang. :-(

Mã hội (chế độ lý tưởng TASM):

IDEAL
MODEL   TINY

CODESEG
ORG 100H

;; DOSBox (tested with 0.74-2) didn't seem to handle Ctrl-Z as EOF
;; so uncomment the ";;" lines to run it there.
MAIN:
    MOV     BX,1
    PUSH    BX
    POP     CX
    MOV     DX,OFFSET MAIN_1+1  ; The 21H in INT 21H
    MOV     AH,40H
MAIN_1:
    INT     21H
    DEC     DX
    ;;PUSH  DX
    ;;POP   SI
IO_LOOP:
    DEC     BX
    MOV     AH,3FH
    INT     21H
    ;;; This should work on an non-emulated PC. 
    ;;;AAA      ; AL=0?
    TEST    AX,AX
    JZ      DONE
    ;;CMP   [BYTE PTR SI],1AH
    ;;JZ    DONE
    MOV     AH,40H
    INC     BX
    INC     CX
    INT     21H
    DEC     CX
    JMP     IO_LOOP
DONE:
    RET
ENDS
END MAIN

Brainfuck , 24 22 byte

-2 byte nhờ JoKing.

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

Hãy thử trực tuyến!

Pepe , 47 byte

REREEeRErEErREeeEeeeeEREEeeREEeereeREEEEeeEReee

Hãy thử trực tuyến!

Giải trình:

REREEeRE # Push 0,then input (str),then 0 -> (R)
         # The zeroes are pushed to correct the inserting
rEE # Begin loop labelled 0 -> (r)
  rREeeEeeeeE # Push "!" -> (R)
              # r flag inserts it instead of pushing
  REEeeREEee # Move pointer pos 2 steps forward -> (R)
ree # Loop while (R) != 0
REEEEeeE # Remove characters of (R) that are in stack of (r)
         # Removes the 0 in (R)
Reee # Output (R)

Mê cung ,  19 11 10  9 byte

33
..
",@

Hãy thử trực tuyến!

Làm sao?

Chúng tôi đi vào Mê cung ở góc trên bên trái, bên phải với vô số số không ...

                         I / O    stack
                                  0,0,0,...
3 - pop * 10 + 3                  3,0,0,0,...
  - 2 neighbours, forward
3 - pop * 10 + 3                  33,0,0,0,...
  - 2 neighbours, forward
. - pop & print chr          !    0,0,0,...
  - T junction from the side
  -   TOS==0, forward
, - read chr or -1       L        76,0,0,0,...   or   -1,0,0,0
  - T junction from the base
  -   if TOS > 0 right:
" -     no-op                     76,0,0,0,...
  -     2 neighbours, forward
. -     pop & print chr      L    0,0,0,...
  -     T junction from the side
  -       TOS==0, forward
3 -       ...back to the start
  -   elif TOS == -1 left:
@ -     exit                                          we're out!


  * right, but on the first occasion (from above) we hit the wall and turn
    around, so that's like a left

May mắn thay, chúng ta không cần phải xử lý các bản in không in được, nếu không, byte 0 đầu tiên sẽ khiến chúng ta quay vòng ,và chơi tàn phá.

sed , 12 byte

s/\b\|\B/!/g

Hãy thử trực tuyến!

-3 byte nhờ vào Quack Quack

Zsh , 32 byte

for c ('' ${(s::)1})echo -nE $c!

Hãy thử trực tuyến!

(s::)chia thành các ký tự, ''thêm một phần tử trống vào đầu và sau đó echo -nE $c!lặp lại mỗi phần tử theo sau bởi một !.

Perl 5 -p0, 17 6 byte

s,,!,g

Hãy thử trực tuyến!

Câu trả lời ban đầu của tôi là -pvà $_='!'.s,.,$&!,gr. Cảm ơn @Nahuel Fouilleul vì đã cắt 11 byte và @Grimy cho tiền -p0boa.

6502, 12 byte (13 byte nếu Apple II)

6502

Mã máy giả định rằng một cặp vị trí trang 0 được kết nối với phần cứng đầu vào ký tự ($ FE) và đầu ra (FF). Nhiều hệ thống dựa trên 6502 tạo điều kiện cho I / O theo cách này, mặc dù địa chỉ I / O thường không ở trang không.

Để đơn giản, tôi đã sử dụng Py65 , một trình giả lập hệ thống máy vi tính 6502 được viết bằng Python.

Đây là một bãi chứa bộ nhớ từ Py65. Bạn có thể tải đoạn mã sau ở bất cứ đâu trong trang 0 để nó không trùng với $ FE và $ FF.

       PC  AC XR YR SP NV-BDIZC
6502: 0000 00 00 00 ff 00110010
.mem 0:b
0000:  a9  21  85  ff  a5  fe  f0  fc  85  ff  d0  f4

Chạy trong cửa sổ lệnh Windows, bạn có thể dán (Ctrl + V) bất kỳ văn bản nào bạn muốn hoặc bạn chỉ cần gõ. Nếu gõ, nhấn Ctrl + J cho một dòng mới (cùng char ASCII). Nhấn Ctrl + C để ngắt bộ xử lý và quay lại dấu nhắc lệnh Py65.

Đương nhiên, mã lắp ráp dễ đọc hơn.

       PC  AC XR YR SP NV-BDIZC
6502: 0000 00 00 00 ff 00110010
.d 00:0b
$0000  a9 21     LDA #$21
$0002  85 ff     STA $ff
$0004  a5 fe     LDA $fe
$0006  f0 fc     BEQ $0004
$0008  85 ff     STA $ff
$000a  d0 f4     BNE $0000

Để rõ ràng, đây là mã lắp ráp ở định dạng CBA65 .

; ASSEMBLE:
; cba65 bangit
;
; LOAD/RUN
; python3 py65/monitor.py -i 00fe -o 00ff -l bangit.bin
; goto 0000

        .FILES  BIN=256

; I/O LOCATIONS
GETC    .EQU    $FE             ; (1) MOVING PY65'S GETC TO ZP SHAVES 1 BYTE
PUTC    .EQU    $FF             ; (1) MOVING PY65'S PUTC TO ZP SHAVES 2 BYTES

        .ORG    $0000

VROOM   LDA     #'!'
        STA     PUTC
VROOM2  LDA     GETC
        BEQ     VROOM2
        STA     PUTC
        BNE     VROOM

        .END

Táo II

Mã ở trên giả sử null cho biết không có đầu vào, vì vậy tiếp tục bỏ phiếu cho đến khi giá trị khác null được trả về.

Để so sánh, Apple I và Apple II báo hiệu sự sẵn có của một ký tự mới bằng cách đặt bit 7 của địa chỉ I / O bàn phím, sau đó cần phải xóa sau khi tìm nạp ký tự. Trên các hệ thống đó, I / O ký tự thường được thực hiện bằng cách gọi các thói quen giám sát hệ thống thay vì truy cập trực tiếp vào phần cứng.

Bằng cách gọi RDKEY ($ FD0C) và COUT ($ FDED), tương đương Apple II ở trên có thể được mã hóa thành 13 byte và có thể chạy được ở bất cứ đâu trong RAM. Đây là mã tôi đã chạy trong trình giả lập Apple // e, a2ix trên Android 9.

Nhấn Return có tác dụng tương tự như một dòng mới.

*300L

0300-   A9 A1       LDA   #$A1
0302-   20 ED FD    JSR   $FDED
0305-   20 0C FD    JSR   $FD0C
0308-   20 ED FD    JSR   $FDED
030B-   F0 F3       BEQ   $0300

Bạn có để ý rằng thay vì giá trị ASCII bình thường # $ 21 cho dấu chấm than, # $ A1 được sử dụng thay thế không? Đó là bởi vì việc gửi các giá trị ASCII tiêu chuẩn tới COUT khiến chúng được hiển thị ở "chế độ nghịch đảo", màu đen trắng. Hiển thị ASCII màu trắng bình thường trên nền đen yêu cầu thêm # $ 80 vào giá trị ký tự trong bộ tích lũy trước khi gọi COUT. Vì RDKEY trả về các ký tự với tập hi-bit, các chương trình lắp ráp thường xóa bit của ký tự để lấy giá trị ASCII của nó trước khi sử dụng.

Bash , 36 byte

while read -n1 c;do printf \!$c;done

Hãy thử trực tuyến!

Điều này được tính vào dòng mới chấm dứt đầu vào cuối cùng! dấu.

MarioLANG , 95 94 90 89 69 byte

++++++
======< >)
>+++++++",+[
=======<.==<
>+++++++!(.-
========#===

Hãy thử trực tuyến!

Lần đầu tiên dùng thử MarioLANG, đó là rất nhiều niềm vui!

Cảm ơn Jo King vì -20 byte

Giải trình:

Vì vậy, đúng như tên gọi, MarioLANG được tạo ra để thực hiện giống như một trò chơi của Super Mario Bros. Nó hoạt động tương tự như BF, với bộ nhớ được sắp xếp trong một băng các ô. Có các toán tử để tăng, giảm, in (dưới dạng ascii hoặc số) và đọc vào ô nhớ hiện tại và toán tử để di chuyển sang trái hoặc phải dọc theo băng.

Mario (con trỏ lệnh) luôn bắt đầu ở ô trên cùng bên trái của chương trình, với hướng chuyển động dự định của anh ta được đặt ở bên phải. Nếu Mario không có vật thể giống sàn bên dưới anh ta (=, "hoặc #), anh ta sẽ ngã cho đến khi chạm vào vật thể giống sàn. Nếu Mario rời khỏi không gian chương trình, chương trình sẽ kết thúc do Game Over :(

Chương trình cụ thể này về cơ bản có thể được chia thành hai nửa: thiết lập và vòng lặp.

   Setup                          Loop
-----------------------------------------------
                       |
++++++                 |          
======<                |          >)
>+++++++               |          ",+[
=======<               |          .==<
>+++++++               |          !(.-
========               |          #===

Trong phần Cài đặt, chúng ta chỉ cần tăng ô nhớ đầu tiên cho đến khi đạt 33 - giá trị ASCII cho "!". Vừa đủ dễ; Nếu điều này có thể được đánh gôn, đó hoàn toàn là vấn đề về hình dạng. Mario bắt đầu từ trên cùng bên trái, nhặt 10 đồng xu, bắt đầu rơi khi nhặt thứ 11, chuyển hướng, sau đó lặp lại. Anh ta nhặt được 11 đồng tiền cuối cùng mà không chuyển hướng; anh ta kết thúc phần thiết lập ở dưới cùng "+".

Trong phần vòng lặp, Mario bắt đầu bằng cách đến một thang máy. Các "!" Người điều khiển làm cho anh ta ngừng chuyển động, để anh ta vẫn ở trên thang máy. Trên đường lên, nó in ký tự ASCII tương ứng thành giá trị của ô nhớ hiện tại (giá trị này luôn là 33, "!"), Sau đó chuyển sang ô tiếp theo trong bộ nhớ. Mario lên đến đỉnh và đặt hướng sang phải. Anh ta ngã và đọc một ký tự từ đầu vào là giá trị ASCII của nó (hoặc -1 nếu không có ký tự). Chúng tôi tăng lên vì biện pháp kiểm soát duy nhất trong MarioLANG là bỏ qua một hướng dẫn nếu ô nhớ hiện tại có giá trị bằng 0. Nếu có, chúng tôi bỏ qua việc thay đổi hướng của Mario, vì vậy anh ta sẽ đi ngay khỏi tầng tiếp theo của mình. Nếu không, chúng ta đặt hướng sang trái; đi bên trái của sàn bên dưới làm giảm ô hiện tại trở về giá trị trước đó của nó,

Phiên bản trước (89 byte):

+++++++++++>,
==========@"+
+++++++++++)[
@==========.==<
+++++++++++!(.-
===========#===

Perl 6 , 16 11 byte

{S:g/<(/!/}

Hãy thử trực tuyến!

Thay thế tất cả các kết quả khớp bằng 0 bằng dấu chấm than. Các chế độ không chính xác không được phép, vì vậy chúng tôi sử dụng điểm đánh dấu để chụp không có gì thay thế

C # (Trình biên dịch tương tác Visual C #) , 28 byte

s=>$"!{String.Join("!",s)}!"

Hãy thử trực tuyến!

05AB1E , 4 byte

€'!Ć

I / O như một danh sách các nhân vật.

Hãy thử trực tuyến.

Giải trình:

€'!  '# Prepend a "!"-item before each character in the (implicit) input-list
   Ć  # Enclose (append the first character of the list at the end of it)
      # (after which the result is output implicitly)

Befunge-98 (PyFunge) , 7 byte

'!,#@~,

Hãy thử trực tuyến!

Hình tam giác , 15 13 byte

B\3;#*~.,</@<

Hãy thử trực tuyến!

-2 byte sau khi nhớ rằng Tam giác có toán tử tạm dừng có điều kiện.

Tôi tin rằng nó là ngắn như nó được trên cái này. Tam giác không có toán tử thay đổi hướng có điều kiện, nhưng chúng không may hoạt động khác với các điều kiện khác. Trong khi tất cả những người khác kiểm tra xem ToS <= 0, các điều kiện thay đổi hướng sẽ kiểm tra ToS! = 0. Nếu đây không phải là trường hợp, chúng ta sẽ có 10 byte ở dạng Bq3~#*/@<<.

Ung dung:

    B
   \ 3
  ; # *
 ~ . , <
/ @ <
----------------------------------------------------
B3*              - Push 11 and 3, then pop both and push their product.
    <,<          - Change directions 3 times (to save 2 bytes on last line)
        @/       - Print Top of Stack value as a character, do not pop
          ~;\    - Push a character from input to ToS. Halt if ToS <= 0. Change Direction.
              #  - Print ToS as a character and pop

Phiên bản trước (15 byte):

B.3\.*#).(/?~@<

Đơn giản , 23 byte

Đây là một ngôn ngữ tôi đã viết, và nó được cho là dành cho các mẫu, nhưng tốt.

!{@eachargv.0}{@echo_}!

Nên tự giải thích, một khi bạn thấy mã không được mã hóa:

!{@each argv.0 as char} {@echo char}!{@/}

Và một lời giải thích:

• !- In !ký tự
• {@each argv.0 as char}- Vòng lặp thông qua mỗi ký tự, với giá trị được đặt thành biến char( tùy chọn , biến mặc định là _).
  argv.0là tham số đầu tiên được truyền cho render()phương thức của trình biên dịch.
• {@echo char}!- xuất ra charbiến và một !ký tự bằng chữ .
  Đối với phiên bản golf, biến mặc định _được sử dụng thay thế.
• {@/}- đóng vòng lặp ( tùy chọn )

Nguyên chất Giải pháp PureTemplate :

{@fn x}!{@eachargv.0}{@echo_}!{@/}{@/}

Tạo một hàm xtạo ra kết quả tương tự.

Bạn có thể sử dụng nó như thế này:

{@call x "this is an example"}

Bạn có thể thử tất cả những điều này trên: http://sandbox.onlinephpfifts.com/code/f6baff8d411fc8227ece81eccf05b6e7d3586bfa

Trên dòng 908, bạn có thể sử dụng các biến $golfed, $ungolfedvà$fn để kiểm tra tất cả các phiên bản.

Tuy nhiên, nếu được phép sử dụng một mảng ký tự, mã được đơn giản hóa (20 byte):

!{@echoj"!" argv.0}!

Và vô lương tâm:

!{@echo separator "!" argv.0}!

Về cơ bản, xuất tất cả các mục trong mảng, được nối bởi "!" , được bao quanh bởi chữ !.
Do những hạn chế trong lớp trình biên dịch, không gian là bắt buộc (trong phiên bản golf).

Mã này cũng cực kỳ khó sử dụng hơn trong SimpleTemplate thuần túy (sử dụng hàm làm ví dụ):

{@fn x}!{@echoj"!" argv.0}!{@/}

{@// alternative: @call str_split into a "a char array"}
{@set a "a", " ", "c", "h", "a", "r", " ", "a", "r", "r", "a", "y"}

{@call x a}

Có @callthể gọi một hàm tồn tại trong PHP, có nghĩa là nó không phải là một giải pháp SimpleTemplate thuần túy .

Ruby , 17 16 byte

->s{s.gsub'',?!}

Hãy thử trực tuyến!

Cảm ơn Ink Value cho -1 byte

Gema , 11 ký tự

\A=\!
?=?\!

không may ! bắt đầu một bình luận trong Gema, vì vậy phải được thoát.

Chạy mẫu:

bash-5.0$ echo -ne '1 2 3 4 5 6\n129591 129012 129127 129582\n\n0' | gema '\A=\!;?=?\!'
!1! !2! !3! !4! !5! !6!
!1!2!9!5!9!1! !1!2!9!0!1!2! !1!2!9!1!2!7! !1!2!9!5!8!2!
!
!0!

Hãy thử trực tuyến!

Thạch , 5 byte

Ż”!ṁż

Một chương trình đầy đủ chấp nhận một chuỗi, trong đó in kết quả.

Hãy thử trực tuyến!

Làm sao?

Ż”!ṁż - Main Link: list of characters, s   e.g. "abc"
 ”!   - character '!'                           '!'
   ṁ  - mould like:
Ż     -   s with a zero prepended              "!!!!"
    ż - zip together with s                    ["!a","!b","!c",'!']
      - implicit (smashing) print              !a!b!c!

Japt , 4 byte

rP'!

Thử nó

r      Replace
 P     all empty strings "" with
  '!   An exclamation mark (If '!' wasn't a special character in Japt I could remove the quote)

Japt , 4 byte

rP'!

Thử nó

Japt -P , 7 byte

Thật không may !là một nhân vật dành riêng, đòi hỏi các dấu ngoặc kép.

ï'! i'!

Thử nó

Không có nhiều điều để giải thích: ïlà sản phẩm và tiền thưởng của Cartesian i.

Perl 5 + -p, 11 byte

s/^|.\K/!/g

Hãy thử trực tuyến!