Ihre Programme:

Sie schreiben zwei Programme (beide in derselben Sprache). Das Speicherprogramm nimmt eine Zeichenfolge aus STDIN und speichert sie an einem persistenten Ort (siehe unten). Anschließend wird es ohne Fehler beendet. Das Abrufprogramm nimmt keine Eingabe vor, ruft den gespeicherten String ab und druckt ihn an STDOUT aus.

Objektiver Persistenztest:

Sie sollten in der Lage sein, das Speicherprogramm auf Ihrem lokalen Computer auszuführen, den lokalen Computer aus- und wieder einzuschalten und dann das Abrufprogramm auf Ihrem lokalen Computer aufzurufen. Sie können den String so lange aufbewahren, wie Sie möchten (auch im Internet), bis Sie diesen Neustarttest bestanden haben.

Testfälle:

Speicherung und Wiederauffindung:

echo foo | Store
Retrieve
foo

Wiederholte Speicher sollten überschreiben (wie bei einer set () -Methode):

echo foo | Store
echo bar | Store
Retrieve
bar

Wiederholtes Abrufen ist nicht destruktiv (wie eine get () - Methode):

echo foo | Store
Retrieve
foo
Retrieve
foo

Abruf vor jedem Aufruf von Storage:

Sie brauchen sich darüber keine Sorgen zu machen. Ihr Abrufprogramm kann davon ausgehen, dass das Speicherprogramm zu einem bestimmten Zeitpunkt in der Vergangenheit ausgeführt wurde.

Flexibilität bei Ein- und Ausgängen.

Die Leute haben mich gebeten, dies von strengen STDIN / STDOUT auf die Standard-IO-Regeln zu erweitern. Ich kann nicht, weil es zu viele Schlupflöcher einführen würde. Bei einigen Standard-E / A-Optionen ist die Eingabe bereits dauerhaft gespeichert, z. B. "Programme können Eingaben aus einer Datei übernehmen". Ich möchte flexibler sein als nur STDIN und STDOUT, aber ohne die Schleusen zu öffnen.

Aus dem Standard-Thread für E / A-Regeln nehme ich diejenigen heraus, die die Herausforderung nicht brechen:

• Programme können Eingaben über GUI-Eingabeaufforderungen und Befehlszeilenaufforderungen vornehmen, wenn Sie dies wünschen

• Programme können durch Anzeigen auf dem Bildschirm ausgegeben werden. Dies schließt GUI-Dialoge ein

• Programme können Eingaben über Befehlszeilenargumente annehmen

• Programme werden möglicherweise in STDERR ausgegeben, können jedoch keine Fehler auslösen.

Wenn Sie eine Alternative verwenden, muss diese benutzerinteraktiv sein. Der Benutzer sollte keine andere Arbeit ausführen müssen, als seine Eingaben in Ihr Programm weiterzuleiten, sie in eine Eingabeaufforderung einzugeben, die Ihr Programm bereitstellt, oder Eingaben als Befehlszeilenargument Ihres Programms einzugeben. Der Benutzer sollte nichts anderes tun müssen, als das Abrufprogramm auszuführen, um die Ausgabe auf dem Bildschirm anzuzeigen oder an STDOUT oder STDERR zu senden.

Zulässige Annahmen:

• Ihre beiden Programme werden im selben Verzeichnis ausgeführt
• Ihre Programme haben Lese- und Schreibrechte für dieses Verzeichnis
• Von Ihnen erstellte Dateien überstehen den Neustart (nicht in einem temporären Verzeichnis)
• Eine abschließende Zeile, die nicht Teil der Zeichenfolge war, ist zulässig. Kein anderes Leerzeichen

Dies ist Code-Golf, und Ihre Punktzahl ist die Summe der Bytes aus beiden Programmen.

zsh, 4 Bytes

Store: >f(liest aus STDIN und schreibt in eine Datei mit dem Namen f)
Retrieve: <f(schreibt den Inhalt fin STDOUT)

TI-BASIC (Z80), 1 Byte ?

Speichern:  ( Geben Sie einfach die Zeichenfolge ein.)
Abrufen: Ans(Byte 27)

Aber wenn das nicht stimmt:

TI-BASIC (Z80), 7 6 Bytes

-1 danke an Jakob.

Speichern: Prompt Str0(Bytes DD AA 09)
Abrufen: disp Str0(Bytes ED AA 09)

Browser JS, 44 Bytes

Geschäft :

localStorage.a=prompt()

Abrufen :

alert(localStorage.a)

POSIX-Shell sh / bash / ... 8 Bytes

Geschäft:

dd>f

bekommen:

dd<f

Python 3 , 46 Bytes

Speicher, 45 Bytes:

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

Das Abrufprogramm wird mit dem Befehl store erstellt, einer Datei mit dem Namen f. ( 1 Byte für den Dateinamen )

Batch, 16 Bytes

COPY CON A
TYPE A

Powershell - 4 Bytes

Lager:

ac

(alternativ auch sc)

Wiederauffinden

gc

Bearbeiten: Ich habe gerade bemerkt, dass die Ausgabe keine Benutzereingaben zulässt ... also springt sie von 4 auf entweder 6 oder 8 Bytes

Lager:

ac f

(alternativ auch sc f) für die 8-Byte-Version

ac

(und fals Pfad angeben ) für die 6-Byte-Version

Wiederauffinden

gc f

Rust, 136 Bytes

Speichern (84 Bytes)

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

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

Abrufen (52 Byte)

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

Danksagung

• -1 Byte dank Esolanging Fruit

Bash, 12 11 10 Bytes

Geschäft, 7 6 5 Bytes

cat ->f# nicht nötig -, Standard ist stdin

cat >f# kein Platzbedarf, auch >getrennt

cat>f

abrufen, 5 Bytes

cat f

HP 49G RPL, 48 Byte

Speichern: :2: A DUP PURGE STO26,5 Byte

Wiederherstellung: :2: A RCL21,5 Byte

Wenn wir in der Pufferbatterie belassen können, erhalten wir:

HP 49G RPL, 0 Byte

Speichern: 0 Bytes

So stellen Sie Folgendes wieder her:, 0 Byte, da der Stapel beim HP 49G nach einem Neustart unberührt bleibt.

APL (APLX) , 5 Bytes

Speichern: ⍞⍈1
Abrufen:⍇1

⍞ Holen Sie sich die Zeile von stdin
⍈1 write zur nächsten verfügbaren Komponente der Datei Nummer 1

⍇1 Lesen Sie die erste * letzte Komponente der Datei Nummer 1

* Die Dokumentation sagt zuerst, aber das Experimentieren zeigt zuletzt .

Bash, 10 Bytes (nicht konkurrierend)

touch $@
ls

Unix-Dateinamen können mit Ausnahme von NULund beliebige Zeichen enthalten/ , und ihre Namen können bis zu 255 Byte lang sein, sodass nur Zeichenfolgen bis zu dieser Länge gespeichert werden können (dies ist eine Einschränkung des Speichermediums). ' in ihnen. Dies ist einer der Gründe, warum dies nicht konkurriert. Ein anderer Grund ist, dass das Verzeichnis, in dem es ausgeführt wird, leer ist (oder dass eine externe Ausgabe von lszulässig ist). Ich wollte das immer noch posten, weil es einfach eine coole und nicht offensichtliche Art war, Informationen zu speichern.

Eine andere in ähnlicher Weise, die nicht die gleichen Längen- und Zeichenbeschränkungen hätte, wäre:

35 33 Bytes

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

Dies ermöglicht das /Zeichen in der Zeichenfolge und unterstützt viel mehr Zeichen (wie viele genau von der Implementierung abhängen).

(-2 Bytes dazu dank @Cows quack)

Python 3, 56 Bytes

Speichern (33 Bytes)

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

Abrufen (23 Byte)

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

Druckt mit einem nachgestellten Zeilenumbruch.

Japt, 46 30 Bytes

^{-16 Bytes dank Shaggy .}

Eines der ersten Male habe ich versucht, Japt zu verwenden. Die JS-Bewertung kann manchmal zappelig sein. Verwendet den Browser window.localStorage.

Speichern (16 Bytes)

Ox`lo¯lSÈSge.P=U

Abrufen (14 Byte)

Ox`lo¯lSÈSge.P

Haskell, 46 Bytes

Speichern (26 Bytes):

getContents>>=writeFile"t"

Abrufen (20 Byte):

readFile"t">>=putStr

Rubin (26 Bytes)

Set (16 Bytes)

IO.write'a',gets

Get (10 Bytes)

IO.read'a'

MATLAB (30 Bytes)

Set (22 Bytes)

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

Kann durch Ändern von in 4 Byte sparen input(''), erfordert jedoch Eingaben in einfachen Anführungszeichen:'input string'

Get (8 Bytes)

load a;a

C (GCC) 98 Bytes

Speichern (46 Bytes)

Die Eingabe erfolgt über das erste Befehlszeilenargument.

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

Abrufen (52 Byte)

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

Unportabilität

• Erfordert, dass mehrere Zeigertypen passen int.

Danksagung

• -2 Bytes dank Ceilingcat
• -10 Bytes dank Peter Cordes

APL (Dyalog Unicode) , 18 Byte

Laden: ⍞⎕NPUT⎕A 1 Online ausprobieren!
Abrufen: ⊃⎕NGET⎕A Probieren Sie es online!

⍞ get line from stdin
⎕NPUT fügt es in eine native Datei mit dem Namen "
⎕A Uppercase Alphabet" ein 1 und überschreibt, falls die Datei existiert

⊃ Der erste Teil (die Daten, die nächsten Teile sind Codierung und Zeilenende-Typ)
⎕NGET der nativen Datei erhält
⎕A das Großbuchstaben

R (27 Bytes)

speichern (21 Bytes)

x=readLines('stdin')

Laden (6 Bytes)

cat(x)

Damit dies funktioniert, muss das erste Skript mit der Befehlszeilenoption --saveund das zweite mit aufgerufen werden --restore(obwohl dies im interaktiven Modus nicht erforderlich ist: Diese Optionen sind die Standardeinstellungen).

Dies könnte um 7 Bytes verkürzt werden, wenn nicht ein Fehler in R verhindert, dass das Standardargument readLinevon im nicht interaktiven Modus arbeitet. Im interaktiven Modus ist dies nicht erforderlich und die Lösung verwendet daher nur 20 Byte .

Java (JDK 10) , 204 Bytes

Warnung: Überschreibt alle Einstellungen, die Java-Programme für Ihren Benutzernamen gespeichert haben!

Speicher, 94 Bytes:

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

Probieren Sie es online!

110 Bytes abrufen:

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

Probieren Sie es online!

java S foo
java R
foo

Dies funktioniert, indem Eingaben als Argument genommen und in dem von java.util.prefs bereitgestellten Backing-Store für Benutzereinstellungen gespeichert werden . Der Stammknoten des Benutzers wird überschrieben, um beim Benennen eines Knotens ein Byte zu sparen. Wenn Sie es zerstörungsfrei testen möchten, führen Sie es entweder mit einem Einweg-Benutzernamen aus oder ändern Sie den Schlüssel von "" in einen Knotennamen.

157 Bytes

Set, 74 Bytes:

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

Get, 83 Bytes:

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

-1 Bytes dank VisualMelon
-2 Bytes dank LiefdeWen

Perl 5, 48 26 23 Bytes

Schreiben Sie 20 + 1 (-n) Bytes

-3 Bytes dank Mob

open f,">>f";print f

Da bin ich mir eigentlich nicht sicher, aber es erfüllt die Kriterien. Bei früheren Einsendungen wurden nur die CLI-Optionen gezählt.

Lesen Sie 0 + 2 Bytes

perl -pe "" f

Attache , 23 + 16 = 39 Bytes

Schreibt einfach STDIN in die Datei Aund liest dann die Datei A.

store.@:

$A&FileWrite!AllInput[]

retrieve.@:

Echo!FileRead!$A

Testen

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 Bytes

Speicher, 27 Bytes

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

Abrufen von 24 Byte

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

RUBIN

Speichern (24 Bytes)

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

Abrufen (16 Byte)

p File.read('a')

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

Speicher, 27 23 Bytes

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

Abrufen, 27 23 Bytes

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

Dies schließt die Antwort von jofel in ein C-Programm ein.

Hinweis: Der ddBefehl gibt einige Statistiken an aus stderr, sodass Sie zusätzliche Ausgaben sehen, wenn Sie ihn naiv in der Shell ausführen. Da die Abfrage jedoch nur besagt, dass der gespeicherte String angezeigt werden muss stdout, nicht stderr, nehme ich an, dass zusätzliche Ausgabe zulässig ist stderr... Wie auch immer, das Unterdrücken der stderrAusgabe ist so einfach wie das Ersetzen dddurch catund Erhöhen der Bytezahl von Zwei Programme nacheinander.

PHP, 26 + 1 + 21 = 48 Bytes

Store.php:

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

Laufen Sie mit echo <input> | php -nF Store.php.

Retrieve.php:

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

Laufen Sie mit php -n Retrieve.php.

C (gcc) , 7767 + 25 = 92 Bytes

Kompiliert mit nur wenigen Warnungen auf meinem GCC.

store.c

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

Kann wahrscheinlich Golf spielen, aber ich konnte nicht herausfinden, wie. Segfaults, wenn Sie nichts weitergeben, aber was auch immer.

Peter Cordes: -1

read.c

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

Batch - 11 Bytes

%12>f
type f

Die Eingabe wird als Befehlszeilenargument empfangen und bleibt bestehen (mit der Fehlermeldung, die beim Ausführungsversuch erzeugt wird, da CMD versucht, den Parameter auszuführen) f.

Batch - 7 Bytes (nicht wettbewerbsfähig)

'>%1
dir

Ein Dateiname enthält eine Vielzahl ungültiger Zeichen, sodass dies bei einigen Zeichenfolgen nicht funktioniert. Auf diese Weise wird jedoch im Wesentlichen ein beliebiges Zeichen in dem durch den Parameter angegebenen Dateinamen gespeichert. Zum Lesen werden nur alle Dateien im Verzeichnis aufgelistet, einschließlich unserer Zeichenfolge.