Nhiệm vụ của bạn, nếu bạn muốn chấp nhận nó, là viết một chương trình xuất ra một số nguyên dương (cao hơn 0). Nếu mã nguồn được nhân đôi, đầu ra phải giữ nguyên. Phần khó khăn là nếu mã nguồn được gõ ba lần (ba lần?) Thì đầu ra sẽ được nhân với 3.

Quy tắc

• Bạn phải xây dựng một chương trình đầy đủ . Đó là, đầu ra của bạn phải được in thành STDOUT.

• Nguồn ban đầu phải dài ít nhất 1 byte.

• Cả hai số nguyên phải ở cơ sở 10 (xuất ra chúng trong bất kỳ cơ sở nào khác hoặc với ký hiệu khoa học đều bị cấm).

• Chương trình của bạn không được lấy đầu vào (hoặc có đầu vào trống, không sử dụng).

• Xuất ra các số nguyên với dấu cách / dấu cách hàng đầu được cho phép.

• Số 0 đứng đầu chỉ được phép nếu số chữ số phù hợp, ví dụ: 001 - 001 - 003 hoặc 004 - 004 - 012

• Bạn không thể giả sử một dòng mới giữa các bản sao của nguồn của bạn.

• Đây là mã golf , vì vậy mã ngắn nhất (nguyên bản) trong mỗi ngôn ngữ sẽ thắng!

• Lỗ hổng mặc định áp dụng.

Thí dụ

Giả sử mã nguồn của bạn là Abcvà đầu ra tương ứng của nó là 4. Nếu tôi viết AbcAbcthay thế và chạy nó, đầu ra vẫn phải 4. Tuy nhiên nếu tôi viết AbcAbcAbcvà chạy nó, đầu ra phải được 12.

Bị đánh cắp một cách đáng xấu hổ Xuất phát từ thử thách của ông Xcoder

Wumpus , 6 byte

{~)
@O

Hãy thử trực tuyến!
Hãy thử gấp đôi!
Hãy thử gấp ba lần!

In 1và 3.

Giải trình

Tôi đã tìm thấy một tấn các giải pháp 6 byte bằng cách tìm kiếm vũ phu, nhưng không có giải pháp nào cho 5 byte. Điều đó không nhất thiết có nghĩa là không có bất kỳ 5 byte nào nhưng có lẽ họ sẽ sử dụng các ký tự lạ hoặc thứ gì đó.

Cuối cùng tôi đã chọn giải pháp này vì nó không in bất kỳ số 0 đứng đầu nào (hầu hết chúng đều được) và nó có một số luồng điều khiển thú vị. Hãy bắt đầu với chương trình duy nhất:

Vì vậy, mã thực thi là:

{~)O@

{   Turn the IP left by 60°.
~   Swap two implicit zeros on the stack, does nothing.
)   Increment the top zero to 1.
O   Print it.
@   Terminate the program.

Vừa đủ dễ. Bây giờ chương trình nhân đôi. Vì dòng đầu tiên được nối vào dòng thứ hai, lưới mở rộng đến chiều rộng 5 (và chiều cao 3) làm thay đổi đáng kể luồng điều khiển:

IP đi xung quanh vòng lặp đó chính xác một lần, vì vậy mã được thực thi là:

{~){~)){~O@

{~) As before, we end up with a 1 on top of the stack.
{   Turn left by 60° again.
~   Swap the 1 with the 0 underneath.
))  Increment the zero to 2.
{   Turn left by 60° again.
~   Swap the 2 with the 1 underneath.
O   Print the 1.
@   Terminate the program.

Cuối cùng, chương trình tăng gấp ba lần khá giống với chương trình nhân đôi, nhưng chúng tôi nhận được một vài lệnh quan trọng hơn trên dòng thứ ba đó:

Vì vậy, mã thực thi là:

{~){~)){~~)O@

{~){~)){~
    As before. We end up with a 1 on top of the stack and a 2 underneath.
~   Swap the 1 with the 2 underneath.
)   Increment the 2 to a 3.
O   Print the 3.
@   Terminate the program.

Husk , 5 byte

KΣK+1

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

Lặp đi lặp lại hai lần!

Ba lần lặp đi lặp lại!

Giải trình

Thật khó để xây dựng một chương trình lặp lại ở Husk. Vì hệ thống loại cấm một chức năng có thể được áp dụng cho chính nó, tôi phải bằng cách nào đó cho phép phần đầu tiên đánh giá một chức năng và phần còn lại để đánh giá một giá trị và các loại tích hợp sẵn có được thiết kế để ngăn chặn điều này loại mơ hồ. Các mã thông báo của chương trình là

• K, mà xây dựng một hàm hằng. K a btương đương với a.
• Σ, lấy một số nguyên n và trả về số tam giác thứ n .
• +, trong đó thêm hai số.
• 1, đó là nghĩa đen 1.

Chương trình ban đầu được diễn giải như thế này:

   K Σ (K+) 1
== Σ 1
== 1

Đây (K+)là một chức năng vô nghĩa được ăn đầu tiên K.

Chương trình lặp lại hai lần được diễn giải như thế này:

   K Σ (K+1KΣK+) 1
== Σ 1
== 1

Hàm trong ngoặc đơn lại được ăn đầu tiên K.

Chương trình lặp lại ba lần được diễn giải như thế này:

   K (Σ (K (+1) (KΣK+) 1)) (KΣK+1)
== Σ (K (+1) (KΣK+) 1)
== Σ ((+1) 1)
== Σ (+1 1)
== Σ 2
== 3

Thạch , 7 5 byte

»‘µ*Ḃ

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

Hãy thử gấp đôi!

Hãy thử gấp ba lần!

Làm thế nào nó hoạt động

»‘µ*Ḃ            Main link. No arguments. Implicit argument: x = 0

 ‘               Increment; yield x + 1 = 1.
»                Take the maximum of x and 1. Yields 1.
  µ              Begin a new, monadic chain. Argument: y = 1
    Ḃ            Bit; yield 1 if y is odd, 0 if it is even. Yields 1.
   *             Power; yield y**1 = 1.

»‘µ*Ḃ»‘µ*Ḃ       Main link.

»‘µ*Ḃ            As before.
      ‘          Increment; yield y + 1 = 2.
     »           Take the maximum of 1 and 2. Yields 2.
       µ         Begin a new, monadic chain. Argument: z = 2
         Ḃ       Bit; yield 1 if z is odd, 0 if it is even. Yields 0.
        *        Power; yield z**0 = 1.

»‘µ*Ḃ»‘µ*Ḃ»‘µ*Ḃ  Main link.

»‘µ*Ḃ»‘µ*Ḃ       As before.
           ‘     Increment; yield z + 1 = 3.
          »      Take the maximum of 1 and 3. Yields 3.
            µ    Begin a new, monadic chain. Argument: w = 3
              Ḃ  Bit; yield 1 if w is odd, 0 if it is even. Yields 1.
             *   Power; yield w**1 = 3.

Haskell , 24 byte

main=print.div 3$4
 -1--

Bản in 1: Hãy thử trực tuyến!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Ngoài ra in 1: Hãy thử trực tuyến!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Bản in 3: Hãy thử trực tuyến!

Khối , 5 byte

)<@OP

Hãy thử trực tuyến: một lần , hai lần , ba lần .

Giải trình

Cubix là một ngôn ngữ dựa trên ngăn xếp có hướng dẫn được bao bọc bên ngoài khối lập phương. Điều quan trọng cần lưu ý là ngăn xếp ban đầu chứa đầy các số 0 vô hạn, cho phép chúng ta "kéo các giá trị ra khỏi không khí mỏng" với các toán tử thay vì đẩy chúng một cách rõ ràng.

Tôi phải thừa nhận rằng điều này đã được tìm thấy bởi một bác sĩ vũ phu; Tôi sẽ không bao giờ tự tìm thấy nó. Trên thực tế, @MartinEnder là người đã yêu cầu tôi thử dùng vũ lực, vì anh ta đã tìm kiếm giải pháp này mà không gặp may. Đây là giải pháp duy nhất mà bác sĩ vũ phu tìm thấy, và tôi tin rằng đó là giải pháp ngắn nhất và duy nhất trong Cubix.

Chương trình đơn

Xem nó chạy!

Chương trình ban đầu phù hợp với một khối đơn vị. Đây là mạng mở ra:

  )
< @ O P
  .

IP (con trỏ lệnh) bắt đầu ở mặt ngoài cùng bên trái (hướng <) đi về hướng đông. Các <tức khắc cho nó về phía tây, và nó kết thúc tốt đẹp xung quanh với P. Plà cấp số nhân và vì không có gì trên ngăn xếp, trình thông dịch rút ra hai 0 và tính 0 ⁰ , bằng 1 theo JavaScript. Osau đó in giá trị này và @kết thúc chương trình.

Chương trình đôi

Xem nó chạy!

)<@OP)<@OP

Chương trình 10 byte quá dài để vừa với một khối đơn vị, và do đó, nó được mở rộng thành một khối kích thước-2:

    ) <
    @ O
P ) < @ O P . .
. . . . . . . .
    . .
    . .

Như trước, IP bắt đầu ở phía trên bên trái của mặt trái nhất. Lần này, hướng dẫn đầu tiên là P, đẩy 1 như trước. Tiếp theo là ), tăng mục trên cùng, biến nó thành 2 . Sau đó <biến IP xung quanh và nó lại chạm vào ), biến 2 thành 3 .

Đây là nơi nó trở nên thú vị. Ptăng vật phẩm thứ hai từ trên xuống thành sức mạnh của vật phẩm thứ nhất, cho 0 ³ = 0 . Sau đó, IP quấn quanh mặt phải nhất và đi qua hai no-op .trước khi chạm vào mặt khác P. Ở đây, chúng ta thấy một cách giải quyết khác của Cubix: toán tử nhị phân (chẳng hạn như P) không xóa toán hạng của chúng khỏi ngăn xếp. Vì vậy, vì ngăn xếp là bây giờ [3, 0], chúng tôi tính toán 3 ⁰ = 1 , Okết quả đầu ra và @kết thúc chương trình.

Chương trình ba

Xem nó chạy!

)<@OP)<@OP)<@OP

Như với chương trình kép, bộ ba có thể vừa với khối kích thước-2:

    ) <
    @ O
P ) < @ O P ) <
@ O P . . . . .
    . .
    . .

Chương trình này bắt đầu theo cách tương tự như trước: Pđẩy 1 , )tăng, <trỏ IP về phía tây, )tăng lại và Pbây giờ đẩy 0 . IP sau đó được bọc xung quanh <ở phía bên phải, điều này không có gì vì IP đã được chỉ về phía tây.

Đây là một điểm khác biệt so với chương trình kép: )tăng 0 trên đỉnh của ngăn xếp thành 1 . Khi Pthực hiện lại phép thuật của mình, lần này nó tính 3 ¹ = 3 . Ođầu ra và @chấm dứt, và chúng tôi chứng minh một cách thuyết phục rằng lần thứ ba thực sự là cơ duyên.

Brain-Flak , 10 byte

<>([]{}())

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

Hãy thử gấp đôi!

Hãy thử gấp ba lần!

Giải trình:

#Toggle stacks
<>

#Push
(
    #Stack-height (initially 0) + 
    []

    #The TOS (initially 0) + 
    {}

    #1
    ()
)

Khi chúng ta chạy cái này một lần, nó sẽ đưa (0 + 0 + 1) == 1vào ngăn xếp thay thế. Lần thứ hai, nó đặt tương tự lên ngăn xếp chính. Tuy nhiên, hãy chạy lần thứ ba , nó đánh giá (1 + 1 + 1) == 3và đẩy nó sang ngăn xếp thay thế và in ngầm.

SQL, 25 24 23 byte

( -1 Byte Removed một nhân vật gõ sai mà luôn nhận xét ra và không làm gì cả )
( -1 Byte Thay đổi SELECTđể PRINTtheo khuyến cáo của Razvan Socol )

PRINT 2/*
*2+1--*/-1
--

Cách thức hoạt động:
Trong SQL, bạn có thể nhận xét các thẻ nhận xét, như vậy:

/*
'Comment'--*/

đấu với

--/*
'Not Comment'--*/

Mã trên 1 dòng với các bình luận bị loại trừ:
Lặp lại đầu tiên: SELECT 2-1Đầu ra: 1
Lặp lại thứ hai: SELECT 2-1*2+1Đầu ra: 1
Lặp lại thứ ba: SELECT 2-1*2+1*2+1Đầu ra:3

SOGL V0.12 , 7 5 4 byte

ē»«I

Hãy thử nó ở đây!

Hãy thử gấp đôi!

Hãy thử gấp ba lần!

Giải trình:

ē»«I
ē     push counter, then increment it.
      First time running this will push 0, then 1, then 2.
             TOS on each: 0  1  2
 »    floor divide by 2   0  0  1
  «   multiply by 2       0  0  2
   I  and increment       1  1  3

05AB1E , 6 5 byte

.gDÈ+

Hãy thử trực tuyến! hoặc thử gấp đôi! hoặc thử gấp ba lần!

Giải trình

.g     # push length of stack
  D    # duplicate
   È   # check if even
    +  # add

Đơn: 0 + (0 % 2 == 0) -> 1
Đôi: 1 + (1 % 2 == 0) -> 1
Ba:2 + (2 % 2 == 0) -> 3

> <> , 9 byte

\5 n;
\\1

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

Hãy thử gấp đôi!

Hãy thử gấp ba lần!

Tôi đã tìm thấy loại may mắn này, bằng cách sử dụng triết lý rằng "nếu bạn làm cho con đường của cá đủ lớn, cuối cùng thì một cái gì đó sẽ hoạt động". Các phiên bản gốc và nhân đôi in 5 và phiên bản tăng gấp ba in 1 rồi 5 để tạo 15 = 3 × 5. Dưới đây là các phiên bản được nhân lên, cho sự nhìn chăm chú của bạn:

\5 n;
\\1\5 n;
\\1

\5 n;
\\1\5 n;
\\1\5 n;
\\1

Python 2 ,  46 45  39 byte

Lấy cảm hứng từ câu trả lời của Halvard . Tôi mừng vì thử thách của mình đã truyền cảm hứng cho một thử thách mới, điều mà tôi thấy còn thú vị hơn nữa. Đã lưu 6 byte nhờ Kevin Cruijssen .

print open(__file__,"a").tell()/79*3|1#

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

Hãy thử gấp đôi!

Hãy thử gấp ba lần!

Cách thức hoạt động (lỗi thời)

k=open(__file__,"a").tell() # Read the source code in "append" mode and get its length.
                            # Assign it to a variable k.
;print k>>(k==90)#          # Print k, with the bits shifted to the right by 1 if k
                            # is equal to 90, or without being shifted at all overwise.
                            # By shifting the bits of a number to the right by 1 (>>1),
                            # we basically halve it.

Khi được nhân đôi, độ dài trở thành 90 , nhưng mã mới bị bỏ qua nhờ #, vì vậy hãy k==90đánh giá True. Booleans là các lớp con của số nguyên trong Python, do đó, k>>Truetương đương với k>>1, về cơ bản là k / 2 = 45 . Khi được nhân ba, mã mới lại bị bỏ qua, do đó độ dài mới là 135 , không bị dịch chuyển vì k==90đánh giá False, vì vậy k>>(k==90) ⟶ k>>(135==90) ⟶ k>>False ⟶ k>>0 ⟶ k, và k được in như hiện trạng.

Python 2 , 36 byte

Đây là một gợi ý của Aidan F. Pierce với 38 byte và tôi đã đánh gôn nó 2 byte. Tôi không đăng bài này là giải pháp chính vì tôi không tự mình nghĩ ra.

0and""
True+=1
print True>3and 3or 1

Hãy thử trực tuyến! Hãy thử gấp đôi! Hãy thử gấp ba lần!

R , 37 31 28 byte

Cảm ơn Giuseppe vì đã chơi golf 3 byte cuối cùng.

length(readLines())%/%2*2+1

(với một dòng mới).

Hãy thử một lần!

Hãy thử hai lần!

Hãy thử nó ba lần!

Điều này sử dụng readLines()mẹo từ câu trả lời của Giuseppe cho thử thách 8 bóng , trong đó stdinchuyển hướng đến tệp nguồn. Mã này về cơ bản chỉ đếm được có bao nhiêu dòng tồn tại bên dưới dòng đầu tiên và đầu ra 1nếu có 1 hoặc 3 dòng (tức là mã là đơn hoặc nhân đôi) hoặc 3nếu có 5 dòng (tức là mã được nhân ba).

Mất , 38 byte

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

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

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

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

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

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

Giải trình

Mất là một ngôn ngữ rất thú vị cho thử thách này. Kỹ thuật Lost thông thường là xây dựng một "cái bẫy". Một cái bẫy là một phần của chương trình được thiết kế để bắt tất cả các ips ở một nơi để ngăn xếp của chúng có thể bị xóa và chúng có thể được điều khiển để đi theo một hướng cụ thể. Điều này làm cho các chương trình viết trong Lost dễ quản lý hơn rất nhiều. Tuy nhiên, vì chương trình được nhân đôi, chúng ta cũng cần tránh trùng lặp bẫy. Điều này đòi hỏi chúng ta phải thiết kế một cái bẫy mới hoạt động đúng nhưng khi được nhân đôi thì chỉ có một cái bẫy hoạt động. Ý tưởng cơ bản của tôi ở đây là như sau

v<<<<>
>%?!^^

Trong khi ngăn xếp không trống, ?nó sẽ xóa một mục và khiến nó nhảy trở lại bắt đầu nếu mục đó khác không. Chìa khóa ở đây là khi cái này xếp chồng lên ^^s

v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^

Có nghĩa là cho dù bạn nhập như thế nào, bạn sẽ luôn thoát ra cùng một chỗ.

Từ đây, chúng ta có thể cố gắng thực hiện cùng một ý tưởng từ câu trả lời Klein của tôi .

\\<<<<<v<<<<>
2>((1+@>?!^%^

Xương sống của chương trình của chúng tôi là bên trái có một số 2s. Mỗi lần chúng tôi thêm một bản sao của chương trình, một bản khác 2sẽ được thêm vào xương sống của chương trình, nghĩa là thêm 2 bản được đẩy vào ngăn xếp. Khi nó đi ra khỏi đáy, nó nảy qua \\>và thực thi mã

((1+@

Điều này loại bỏ 2 mục ngăn xếp đầu tiên, thêm một mục vào bất cứ thứ gì còn lại và thoát. Khi xương sống của chúng tôi có 3 2 giây, chúng tôi sẽ thêm 1 và nhận 3, nếu chúng tôi có ít hơn 3 mục, chúng tôi sẽ chỉ loại bỏ toàn bộ ngăn xếp và trả về 1.

Bây giờ vấn đề duy nhất còn lại là !trong chương trình của chúng tôi có thể gây ra một vòng lặp vô hạn. Nếu ip bắt đầu !đi lên, nó sẽ nhảy và quay trở lại vị trí cũ. Điều này có nghĩa là chúng ta phải thêm một dòng khác bên dưới để ngăn chặn vòng lặp.

\\<<<<</<<<<>
2>((1+@>?!^%^
.........^

Điều này có một vấn đề nhỏ là đặt một số dấu gạch chéo vào giữa ^s của chúng ta trong bẫy. Tuy nhiên, khá kỳ diệu, mọi thứ đều diễn ra tốt đẹp. Ips của chúng tôi nảy xung quanh đúng cách để nó không tạo ra sự khác biệt.

Stax , 5 byte

|dhH^

Chạy và gỡ lỗi trực tuyến! · Tăng gấp đôi · tăng gấp ba

Giải trình

|dhH^
|d       Push Current stack depth `d`, originally 0
         Doubled -> 1, Tripled -> 2
  hH^    Map d to 2*(floor(d/2))+1
         Implicit print

C (gcc) , 95 91 85 byte

#ifndef a
#define a-1
main(){puts(3
#include __FILE__
?"1":"3");}
#define a
#endif
a

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

Japt , 8 6 5 byte

-1 byte nhờ @ETHproductions

°U-v

Giải trình:

°U-v
 U     # variable U=0                # U=0
°U     # ++U                         # U=1
  -    # minus:
   v   #   1 if U is divisible by 2  
       #     else
       #   0                         # U=1

Điều này đánh giá 1-0 = 1

Nhân đôi đánh giá để 2-1 = 1

Tăng gấp ba lần để 3-0 = 3

Tinh khiết Bash (không wchoặc utils bên ngoài khác), 27

trap echo\ $[a++&2|1] EXIT

• Hãy thử một lần.
• Hãy thử hai lần.
• Hãy thử nó ba lần.

Perl 5 , 18 15 13 12 11 byte

-3 byte nhờ nwellnhof

say 1|
+.7#

Sau khi thử trực tuyến!

Hai lần thử trực tuyến!

Ba lần thử trực tuyến!

> <> , 10 9 8 byte

562gn|

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

Hãy thử gấp đôi!

Hãy thử gấp ba lần!

Tôi chắc chắn có một giải pháp 8 byte ở đâu đó ngoài kia.

Không thể in ở cuối có giá trị ASCII 1 và chỉ được tìm nạp bởi glệnh et trên lần lặp thứ ba. Đối với hai đầu tiên nó in 05, và sau đó in 15.

C (gcc) , 107 byte

Trình đầu tiên của tôi trong C (gcc). Quá dài ...

i;
#ifdef c
#define c
#ifdef b
i=2;
#else
#define b
#endif
#else
#define c main(){putchar(i+49);}
#endif
c

Liên kết TIO: đơn , đôi , ba .

Mê cung , 12 11 9 byte

: #%! @
 7

TIO (1x) , TIO (2x) , TIO (3x)

JavaScript, 81 77 74 70 byte

^{Đã lưu 4 byte nhờ Shaggy}

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Giải pháp JS khá khập khiễng. Tiêu thụ các giá trị từ [3,1,1]mảng từ bên phải ( pop()). Đăng ký thời gian chờ để hiển thị giá trị hiện tại trong tương lai. Nếu thời gian chờ đã được đăng ký, hãy hủy nó. Dựa vào bản chất bẩn của var, mà vận thăng khai báo biến.

Hai lần:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Ba lần:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

C (gcc) , 53 52 byte

Lưu ý không gian sau #endif.

n;main(){putchar(n+49);}
#if __LINE__>7
n=2;
#endif 

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

Than , 12 byte

⎚≔⁺ι¹ιＩ⁻ι⁼ι²

Hãy thử trực tuyến! Liên kết là để mã dài dòng.

Hãy thử gấp đôi!

Hãy thử gấp ba lần!

Giải trình

⎚             Clear
 ≔⁺ι¹ι        Assign plus(i, 1) to i
       Ｉ      Cast (and implicitly print)
         ⁻ ⁼ι² Subtract equals(i, 2) from
          ι    i

JavaScript, 43 40 byte

var t=t?--t:~!setTimeout`t=alert(1|~t)`;

2 lần:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

3x:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

PowerShell , 54 48 45 44 byte

if(99-gt(gc $PSCOMMANDPATH|wc -c)){1;exit}3#

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

Hãy thử gấp đôi!

Hãy thử gấp ba lần!

Gets con đường gọi riêng của mình với $PSCOMMANDPATHvà thực hiện một get- content vào tệp. Ifsố lượng ký tự của tệp đó nhỏ hơn 99(được kiểm tra thông qua wc -ctừ coreutils), sau đó chúng tôi xuất ra 1và exit(nghĩa là dừng thực thi). Đó là tài khoản cho mã gốc và mã nhân đôi. Nếu không, chúng tôi đầu ra 3và thoát. Mã thực tế trong các phần được nhân đôi hoặc tăng gấp ba là vô nghĩa, vì chúng ta sẽ exittrước khi chúng ta nhận được nó, hoặc nó nằm sau một nhận xét #.

Đã lưu 6 byte nhờ Mr. Xcoder
Đã lưu 3 4 byte nhờ Pavel

C # (178 byte)

Console.WriteLine(1+2*4%int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]=(int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]??"0"))+1+""));

giải pháp C # điên rồ, nhưng tôi rất vui vì nó có thể ở một dòng trong C #. :)

Đối với tôi, phần khó nhất là có C # hợp lệ, có thể xác định hoặc tăng cùng một biến, vì vậy tôi đã kết thúc việc lạm dụng Trình quản lý cấu hình vì tôi cần một NameValueCollection và Trình quản lý cấu hình tĩnh toàn cầu là thứ duy nhất tôi có thể nghĩ đến mà tôi có thể cập nhật trong bộ nhớ. Môi trường biến đổi là một tùy chọn khác mà tôi đã tìm thấy nhưng nó không có bộ chỉ mục nên tôi không chắc làm thế nào để làm điều đó trong một dòng có thể được sao chép để tạo đầu ra cần thiết theo thông số kỹ thuật.

Bùa mê , 35 byte

^w3'\
    f
    1
/1@
/
 '54\w
/yyy

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

Làm việc trên cái này cho phép tôi tìm thấy một lỗi trong trình phân tích cú pháp của tôi xử lý các ký tự sửa đổi độ trễ mới, mặc dù kết quả cuối cùng kết thúc không bị ảnh hưởng bởi nó, vì cuối cùng tôi không cần chúng.

Các chức năng do thực tế là dòng cuối cùng không có dòng mới (hoặc đối với vấn đề đó, dấu cách), cho phép các IP trùng lặp xuất hiện ở một nơi khác. Cái trên cùng bên trái kết thúc bằng một vòng lặp lớn xung quanh lưới trong khi IP thứ hai thực hiện thao tác Reflection để thay thế \trên dòng thứ 6 bằng a . IP này sau đó sẽ lặp lại mãi mãi và không làm gì cả.

IP thứ ba cũng thực hiện cùng một sự thay thế này cùng một lúc, nhưng vì nó nằm trên dòng thứ 13 , bản sao của bộ phản xạ đó sẽ gửi nó lên trên và nó thực hiện 1f'3wchuỗi có ở góc trên bên phải, thay thế 1bằng một 3trên 14 dòng, ngay trước khi IP ban đầu thực hiện nó, làm cho chương trình tăng gấp ba lần sản lượng 3thay vì 1(các giá trị cũng có thể là 2và 6, 3và 9, 4và 12, hoặc 5và 15do sự sẵn có của a-fcác hằng số;1 và 3đã được lựa chọn tùy ý). Sau đó, nó được để lại trong một vòng lặp vô tận thực hiện nhiều lệnh phản chiếu mà không làm gì cả.

Hãy thử nó trong ba lần!

Perl 5, 28 25 byte

-3 byte nhờ @neil!

print"\e[D$a"if(++$a!=2);

Di chuyển con trỏ về phía sau (không làm gì khi bắt đầu dòng) và in giá trị của $alần thứ nhất và lần thứ ba (nghĩa là lần thứ ba in 1, con trỏ di chuyển và 3 được in trên vị trí của 1).

QBasic, 19 byte

CLS
x=2^x
?x-1OR 1

Nguồn nên bao gồm một dòng mới.

Giải trình

Chúng tôi muốn sản lượng 1, 1, 3. Quan sát rằng những con số này là một ít hơn lũy thừa của 2. Vì vậy:

CLS      ' CLear Screen of any output from previous copies of the code

x        ' Numeric variables are preset to 0...
 =2^x    ' so as this statement is repeated, the value of x goes 1, 2, 4

 x-1     ' Therefore x-1 goes 0, 1, 3...
    OR 1 ' and we bitwise OR it with 1 to change the 0 to 1...
?        ' and print.