Chương trình của bạn:

Bạn sẽ viết hai chương trình (cả hai cùng một ngôn ngữ). Chương trình lưu trữ lấy một chuỗi từ STDIN và lưu nó ở đâu đó liên tục (xem bên dưới) và sau đó thoát mà không có lỗi. Chương trình truy xuất không có đầu vào, lấy chuỗi được lưu trữ và in nó thành STDOUT.

Thử nghiệm khách quan về tính bền bỉ:

Bạn sẽ có thể chạy chương trình lưu trữ trên máy cục bộ của mình, sau đó cấp nguồn cho máy cục bộ của bạn, sau đó gọi chương trình truy xuất trên máy cục bộ của bạn. Bạn có thể bỏ chuỗi theo cách bạn muốn (ngay cả trên web) miễn là bạn vượt qua bài kiểm tra khởi động lại này.

Các trường hợp thử nghiệm:

Lưu trữ sau đó truy xuất:

echo foo | Store
Retrieve
foo

Cửa hàng lặp lại sẽ ghi đè (như phương thức set ()):

echo foo | Store
echo bar | Store
Retrieve
bar

Lặp lại truy xuất là không phá hủy (như phương thức get ()):

echo foo | Store
Retrieve
foo
Retrieve
foo

Truy xuất trước bất kỳ yêu cầu lưu trữ nào:

Bạn không cần phải lo lắng về điều này. Chương trình truy xuất của bạn có thể cho rằng chương trình lưu trữ đã được chạy tại một số điểm trong quá khứ.

Linh hoạt đầu vào / đầu ra.

Mọi người đã yêu cầu tôi mở rộng điều này từ STDIN / STDOUT nghiêm ngặt sang các quy tắc IO tiêu chuẩn. Tôi không thể bởi vì nó sẽ giới thiệu quá nhiều sơ hở. Một số tùy chọn IO tiêu chuẩn đã có đầu vào được lưu trữ một cách liên tục, ví dụ: "các chương trình có thể lấy đầu vào từ một tệp". Tôi muốn linh hoạt hơn là chỉ STDIN và STDOUT nghiêm ngặt, nhưng không mở lũ.

Từ chuỗi quy tắc IO tiêu chuẩn, tôi chọn những thứ không phá vỡ thử thách:

• Các chương trình có thể nhận đầu vào thông qua lời nhắc GUI và lời nhắc dòng lệnh nếu bạn muốn

• Các chương trình có thể xuất ra bằng cách hiển thị nó trên màn hình Điều này bao gồm các hộp thoại GUI

• Các chương trình có thể nhận đầu vào thông qua các đối số dòng lệnh

• Các chương trình có thể xuất ra STDERR nhưng thực tế vẫn không thể đưa ra lỗi.

Nếu bạn sử dụng thay thế, nó phải tương tác với người dùng. Người dùng không cần phải thực hiện bất kỳ công việc nào khác ngoài việc đưa đầu vào của họ vào chương trình của bạn, nhập nó vào một dấu nhắc mà chương trình của bạn cung cấp hoặc nhập dữ liệu dưới dạng một dòng lệnh của chương trình của bạn. Người dùng không cần phải làm gì khác hơn là chạy chương trình truy xuất của bạn để xem đầu ra được hiển thị trên màn hình hoặc được gửi đến STDOUT hoặc STDERR.

Giả định được phép:

• Hai chương trình của bạn sẽ được chạy trong cùng một thư mục
• Các chương trình của bạn có quyền đọc-ghi cho thư mục đó
• Các tệp bạn tạo sẽ tồn tại khi khởi động lại (không phải trong thư mục tạm thời)
• Một dòng mới không phải là một phần của chuỗi được cho phép. Không có khoảng trắng khác

Đây là môn đánh gôn và điểm của bạn là tổng số byte của cả hai chương trình.

zsh, 4 byte

Lưu trữ: >f(đọc từ STDIN và ghi vào một tệp có tên f)
Lấy: <f(ghi nội dung của fSTDOUT)

TI-BASIC (Z80), 1 byte ?

Lưu trữ:  (chỉ cần nhập chuỗi)
Lấy: Ans(byte 27)

Nhưng nếu điều đó không hợp lệ:

TI-BASIC (Z80), 7 6 byte

-1 cảm ơn Jakob.

Lưu trữ: Prompt Str0(byte DD AA 09)
Truy xuất: disp Str0(byte ED AA 09)

Trình duyệt JS, 44 byte

Cửa hàng :

localStorage.a=prompt()

Lấy :

alert(localStorage.a)

Vỏ POSIX sh / bash / ... 8 byte

cửa hàng:

dd>f

được:

dd<f

Python 3 , 46 byte

lưu trữ, 45 byte:

open(*'fw').write('print(%r)'%open(0).read())

Chương trình truy xuất được xây dựng bởi lệnh store, một tệp có tên f. ( 1 byte cho tên tệp )

Mẻ, 16 byte

COPY CON A
TYPE A

Powershell - 4 byte

Lưu trữ:

ac

(cũng thay thế sc)

Lấy lại

gc

Chỉnh sửa: Tôi chỉ nhận thấy đầu ra không cho phép bất kỳ đầu vào của người dùng nào ... vì vậy nó nhảy từ 4 đến 6 hoặc 8 byte

Lưu trữ:

ac f

(cũng thay thế sc f) cho phiên bản 8 byte

ac

(và chỉ định flà đường dẫn) cho Phiên bản 6 byte

Lấy lại

gc f

Rust, 136 byte

Lưu trữ (84 byte)

use std::{fs::*,io::*};

||{let mut v=vec![];stdin().read_to_end(&mut v);write("a",v)}

Truy xuất (52 byte)

||print!("{}",std::fs::read_to_string("a").unwrap())

Sự nhìn nhận

• -1 byte nhờ vào Esolanging Fruit

Bash, 12 11 10 byte

cửa hàng, 7 6 5 byte

cat ->f# không cần -, stdin là mặc định

cat >f# không cần không gian, cũng >tách biệt

cat>f

lấy, 5 byte

cat f

HP 49G RPL, 48 byte

Để lưu : :2: A DUP PURGE STO, 26,5 byte

Để khôi phục : :2: A RCL, 21,5 byte

Nếu chúng ta có thể để lại pin dự phòng, chúng ta sẽ nhận được:

HP 49G RPL, 0 byte

Để lưu : , 0 byte

Để khôi phục : , 0 byte, vì HP 49G khiến cho ngăn xếp không bị ảnh hưởng trong quá trình khởi động lại.

APL (APLX) , 5 byte

Cửa hàng: ⍞⍈1
Lấy:⍇1

⍞ lấy dòng từ stdin
⍈1 ghi vào thành phần có sẵn tiếp theo của tệp số 1

⍇1 đọc thành phần đầu tiên * cuối cùng của tập tin số 1

* Tài liệu nói đầu tiên nhưng thử nghiệm cho thấy cuối cùng .

bash, 10 byte (không cạnh tranh)

touch $@
ls

Tên tệp Unix có thể chứa bất kỳ ký tự nào ngoại trừ NULvà /, và tên của chúng có thể dài tới 255 byte, do đó, điều này sẽ chỉ có thể lưu trữ các chuỗi có độ dài đến mức đó (xem xét rằng giới hạn của phương tiện lưu trữ) và không chứa '/ ' trong chúng. Đó là một lý do khiến điều này không cạnh tranh, một lý do khác là giả định thư mục mà nó chạy trên đó trống (hoặc lscho phép đầu ra không liên quan từ đó được cho phép). Tôi vẫn muốn đăng bài này vì nó có vẻ là một cách hay và không rõ ràng để lưu trữ thông tin.

Một cái khác trên một tĩnh mạch tương tự, sẽ không có cùng độ dài và giới hạn ký tự sẽ là:

35 33 byte

mkdir -p $@
find|sed '$!d;s/..//'

Điều này cho phép /ký tự trong chuỗi và hỗ trợ nhiều ký tự hơn (chính xác có bao nhiêu phụ thuộc vào việc thực hiện).

(-2 byte về điều này nhờ vào quẻ @Cows)

Python 3, 56 byte

Lưu trữ (33 byte)

open(*'aw').write(open(0).read())

Truy xuất (23 byte)

print(open('a').read())

In với một dòng mới.

Japt, 46 30 byte

^{-16 byte nhờ Shaggy .}

Một trong những lần đầu tiên tôi thử sử dụng Japt. Đôi khi, eval JS có thể bồn chồn. Sử dụng trình duyệt window.localStorage.

Lưu trữ (16 byte)

Ox`lo¯lSÈSge.P=U

Lấy (14 byte)

Ox`lo¯lSÈSge.P

Haskell, 46 byte

Lưu trữ (26 byte):

getContents>>=writeFile"t"

Lấy (20 byte):

readFile"t">>=putStr

Ruby (26 byte)

Đặt (16 byte)

IO.write'a',gets

Nhận (10 byte)

IO.read'a'

MATLAB (30 byte)

Đặt (22 byte)

a=input('','s');save a

Có thể tắt 4 byte bằng cách thay đổi thành input(''), nhưng điều này sẽ yêu cầu đầu vào phải ở trong dấu ngoặc đơn:'input string'

Nhận (8 byte)

load a;a

C (GCC), 98 byte

Lưu trữ (46 byte)

Đầu vào là thông qua đối số dòng lệnh đầu tiên.

main(c,v)char**v;{fputs(v[1],fopen("a","w"));}

Truy xuất (52 byte)

c,d;r(){for(d=open("a",0);read(d,&c,1);)putchar(c);}

Không có khả năng

• Yêu cầu một số loại con trỏ phù hợp int.

Sự nhìn nhận

• -2 byte nhờ trần
• -10 byte nhờ Peter Cordes

APL (Dyalog Unicode) , 18 byte

Cửa hàng: ⍞⎕NPUT⎕A 1 Hãy thử trực tuyến!
Lấy: ⊃⎕NGET⎕A Hãy thử trực tuyến!

⍞ lấy dòng từ stdin
⎕NPUT đặt nó vào một tệp gốc gọi là
⎕A bảng chữ cái in hoa 1 và ghi đè nếu tệp tồn tại

⊃ phần đầu tiên (dữ liệu, các phần tiếp theo là mã hóa và loại kết thúc dòng) của
⎕NGET tệp gốc
⎕A bảng chữ cái viết hoa

R (27 byte)

lưu trữ (21 byte)

x=readLines('stdin')

tải (6 byte)

cat(x)

Để làm việc này, tập lệnh đầu tiên cần được gọi với tùy chọn dòng lệnh --savevà tập lệnh thứ hai với --restore(mặc dù trong chế độ tương tác, điều này không cần thiết: các tùy chọn này là mặc định).

Điều này có thể rút ngắn 7 byte vì thực tế là lỗi trong R ngăn không cho đối số mặc định hoạt readLineđộng ở chế độ không tương tác. Trong chế độ tương tác, không cần thiết và do đó, giải pháp chỉ sử dụng 20 byte .

Java (JDK 10) , 204 byte

Cảnh báo: Ghi đè mọi tùy chọn mà bất kỳ chương trình java nào đã lưu trữ cho tên người dùng của bạn!

Cửa hàng, 94 byte:

interface S{static void main(String[]a){java.util.prefs.Preferences.userRoot().put("",a[0]);}}

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

Lấy 110 byte:

interface R{static void main(String[]a){System.out.print(java.util.prefs.Preferences.userRoot().get("",""));}}

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

java S foo
java R
foo

Điều này hoạt động bằng cách lấy đầu vào làm đối số và lưu trữ nó trong kho lưu trữ tùy chọn người dùng được cung cấp bởi java.util.prefs . Nó ghi đè nút gốc của người dùng để lưu một byte khi đặt tên nút. Nếu bạn muốn kiểm tra nó không hủy cấu trúc, hãy chạy nó từ tên người dùng bị vứt bỏ hoặc thay đổi khóa từ "" thành tên nút.

C #, 157 byte

Đặt, 74 byte:

class P{static void Main(string[]a){System.IO.File.WriteAllLines("a",a);}}

Nhận, 83 byte:

class P{static void Main(){System.Console.Write(System.IO.File.ReadAllText("a"));}}

-1 Byte nhờ VisualMelon
-2 Byte nhờ LiefdeWen

Perl 5, 48 26 23 byte

Viết, 20 + 1 (-n) byte

-3 byte nhờ mob

open f,">>f";print f

Tôi thực sự không chắc chắn về điều này một cách khôn ngoan, nhưng nó đáp ứng các tiêu chí. Đối với các mục trong quá khứ, chỉ có các tùy chọn cli được tính, vì vậy đó là những gì tôi sẽ làm.

Đọc, 0 + 2 byte

perl -pe "" f

Tùy viên , 23 + 16 = 39 byte

Đơn giản chỉ cần viết STDIN vào tệp A, sau đó đọc tệp A.

store.@:

$A&FileWrite!AllInput[]

retrieve.@:

Echo!FileRead!$A

Kiểm tra

C:\Users\conorob\Programming\attache (master -> origin)
λ echo testing | attache store.@

C:\Users\conorob\Programming\attache (master -> origin)
λ attache retrieve.@
testing

Lua, 57 53 51 byte

Lưu trữ, 27 byte

io.open("x","w"):write(...)

Truy xuất, 24 byte

print(io.open"x":read())

RUBY

Lưu trữ (24 byte)

File.write('a', ARGV[0])

Lấy (16 byte)

p File.read('a')

C (Unix / GNU), 23 + 23 = 46 byte

Lưu trữ, 27 23 byte

main(){system("dd>f");}

Truy xuất, 27 23 byte

main(){system("dd<f");}

Điều này về cơ bản kết thúc câu trả lời của jofel vào một chương trình C.

Lưu ý: Các ddlệnh xuất ra một số thống kê stderr, vì vậy bạn sẽ thấy một số đầu ra bổ sung khi bạn ngây thơ chạy nó trong trình bao. Tuy nhiên, kể từ khi thách thức chỉ nói rằng chuỗi lưu trữ phải được trình bày trên stdout, không stderr, tôi mang nó rằng nó được phép có công suất tăng thêm trên stderr... Dù sao, đàn áp stderrđầu ra dễ dàng như thay thế ddvới cat, làm tăng số lượng byte của hai chương trình một, mỗi.

PHP, 26 + 1 + 21 = 48 byte

Cửa hàng.php:

<?fputs(fopen(s,w),$argn);

Chạy với echo <input> | php -nF Store.php.

Lấy.php:

<?=fgets(fopen(s,r));

Chạy với php -n Retrieve.php.

C (gcc) , 77 67 + 25 = 92 byte

Biên dịch chỉ với một vài cảnh báo trên gcc của tôi.

cửa hàng

#include<stdio.h>
main(int c,char**v){fputs(v[1],fopen("f","w"));}

Có thể chơi golf bao gồm, nhưng tôi không thể tìm ra cách. Segfaults nếu bạn không vượt qua nó bất cứ điều gì, nhưng bất cứ điều gì.

Peter Cordes: -1

đọc

main(){system("cat f");}

Mẻ - 11 byte

%12>f
type f

Đầu vào được nhận dưới dạng đối số dòng lệnh và vẫn tồn tại (với thông báo lỗi được tạo khi thử thực thi, do CMD cố gắng thực hiện tham số) trong f.

Batch - 7 byte (không cạnh tranh)

'>%1
dir

Có rất nhiều ký tự không hợp lệ trong tên tệp, do đó, điều này sẽ không hoạt động đối với một số chuỗi, nhưng về cơ bản, nó lưu một ký tự tùy ý vào tên tệp được cung cấp bởi tham số. Để đọc nó, nó chỉ liệt kê tất cả các tệp trong thư mục, bao gồm cả chuỗi của chúng tôi.