I tuoi programmi:

Scriverai due programmi (entrambi nella stessa lingua). Il programma di archiviazione prende una stringa da STDIN e la memorizza in un posto persistente (vedi sotto) e quindi esce senza errori. Il programma di recupero non accetta input, recupera la stringa memorizzata e la stampa su STDOUT.

Test oggettivo di persistenza:

Dovresti essere in grado di eseguire il programma di archiviazione sul tuo computer locale, quindi spegnere e riaccendere il tuo computer locale, quindi chiamare il programma di recupero sul tuo computer locale. Puoi riporre la stringa come preferisci (anche sul Web) purché superi questo test di riavvio.

Casi test:

Archiviazione quindi recupero:

echo foo | Store
Retrieve
foo

I negozi ripetuti dovrebbero sovrascrivere (come un metodo set ()):

echo foo | Store
echo bar | Store
Retrieve
bar

Il recupero ripetuto è non distruttivo (come un metodo get ()):

echo foo | Store
Retrieve
foo
Retrieve
foo

Recupero prima di qualsiasi invocazione di archiviazione:

Non devi preoccuparti di questo. Il programma di recupero può presupporre che il programma di archiviazione sia stato eseguito in un determinato momento in passato.

Flessibilità di input / output.

La gente mi ha chiesto di estenderlo dal rigoroso STDIN / STDOUT alle regole IO standard. Non posso perché introdurrebbe troppe scappatoie. Alcune opzioni IO standard hanno già l'input memorizzato in modo persistente, ad esempio "i programmi possono prendere input da un file". Mi piacerebbe essere più flessibile dei rigorosi STDIN e STDOUT, ma senza aprire le porte.

Dal thread delle regole IO standard sto selezionando quelli che non rompono la sfida:

• I programmi possono ricevere input tramite prompt della GUI e prompt della riga di comando, se lo si desidera

• I programmi possono essere visualizzati visualizzando sullo schermo Ciò include le finestre di dialogo della GUI

• I programmi possono accettare input tramite argomenti della riga di comando

• I programmi possono essere inviati a STDERR ma non riescono ancora a generare errori.

Se usi un'alternativa, deve essere interattiva per l'utente. L'utente non dovrebbe fare nessun altro lavoro oltre a reindirizzare il proprio input al programma, digitarlo in un prompt fornito dal programma o digitare input come arg della riga di comando del programma. L'utente non dovrebbe fare altro che eseguire il programma di recupero per vedere l'output visualizzato sullo schermo o inviato a STDOUT o STDERR.

Presupposti consentiti:

• I tuoi due programmi verranno eseguiti nella stessa directory
• I tuoi programmi dispongono delle autorizzazioni di lettura / scrittura per quella directory
• I file creati sopravvivranno al riavvio (non in una directory temporanea)
• È consentita una nuova riga finale che non faceva parte della stringa. Nessun altro spazio bianco finale

Questo è code-golf e il tuo punteggio è la somma dei byte di entrambi i programmi.

zsh, 4 byte

Store: >f(legge da STDIN e scrive su un file chiamato f)
Retrieve: <f(scrive il contenuto su fSTDOUT)

TI-BASIC (Z80), 1 byte ?

Store:  (basta inserire la stringa)
Recupera: Ans(byte 27)

Ma se questo non è valido:

TI-BASIC (Z80), 7 6 byte

-1 grazie a Jakob.

Negozio: Prompt Str0(byte DD AA 09)
Recupera: disp Str0(byte ED AA 09)

Browser JS, 44 byte

Negozio :

localStorage.a=prompt()

Recuperare :

alert(localStorage.a)

Shell POSIX sh / bash / ... 8 byte

memorizzare:

dd>f

ottenere:

dd<f

Python 3 , 46 byte

negozio, 45 byte:

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

Il programma di recupero è creato dal comando store, un file chiamato f. ( 1 byte per il nome del file )

Lotto, 16 byte

COPY CON A
TYPE A

Powershell - 4 byte

Conservazione:

ac

(alternativa anche sc)

Recupero

gc

Modifica: ho appena notato che l'output non ha alcun input da parte dell'utente ... quindi passa da 4 a 6 o 8 byte

Conservazione:

ac f

(anche alternativa sc f) per la versione a 8 byte

ac

(e specifica fcome percorso) per la versione a 6 byte

Recupero

gc f

Ruggine, 136 byte

Store (84 byte)

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

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

Recupera (52 byte)

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

Ringraziamenti

• -1 byte grazie a Esolanging Fruit

bash, 12 11 10 byte

memorizzare, 7 6 5 byte

cat ->f# non è necessario -, stdin è predefinito

cat >f# non c'è bisogno di spazio, >separa pure

cat>f

recuperare, 5 byte

cat f

HP 49G RPL, 48 byte

Per salvare: :2: A DUP PURGE STO26,5 byte

Per ripristinare :2: A RCL:, 21,5 byte

Se possiamo lasciare nella batteria di backup, otteniamo:

HP 49G RPL, 0 byte

Per salvare :, 0 byte

Per ripristinare :, 0 byte, poiché l'HP 49G lascia invariato lo stack durante i riavvii.

APL (APLX) , 5 byte

Negozio: ⍞⍈1
Recupera:⍇1

⍞ ottenere la linea da stdin
⍈1 scrivere al prossimo componente disponibile del numero file 1

⍇1 leggi il primo * ultimo componente del file numero 1

* La documentazione dice per prima, ma la sperimentazione mostra per ultima .

bash, 10 byte (non concorrenti)

touch $@
ls

I nomi dei file Unix possono contenere qualsiasi carattere tranne NULe /, e i loro nomi possono essere lunghi fino a 255 byte, quindi questo sarà in grado di memorizzare solo stringhe fino a quella lunghezza (considera che una limitazione del supporto di archiviazione) e che non contengono '/ ' in loro. Questo è uno dei motivi per cui non è in competizione, un altro è che ciò presuppone che la directory su cui è in esecuzione sia vuota (o che lssia consentito l' output estraneo da ). Volevo ancora pubblicare questo perché sembrava un modo interessante e non ovvio per archiviare informazioni.

Un altro su una vena simile, che non avrebbe la stessa lunghezza e limiti di carattere sarebbe:

35 33 byte

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

Ciò consente al /carattere nella stringa e supporta molti più caratteri (esattamente quanti dipendono dall'implementazione).

(-2 byte su questo grazie al ciarlatano @Cows)

Python 3, 56 byte

Store (33 byte)

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

Recupera (23 byte)

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

Stampa con una nuova riga finale.

Japt, 46 30 byte

^{-16 byte grazie a Shaggy .}

Una delle prime volte che ho provato ad usare Japt. A volte JS eval può essere irrequieto. Utilizza il browser window.localStorage.

Store (16 byte)

Ox`lo¯lSÈSge.P=U

Recupera (14 byte)

Ox`lo¯lSÈSge.P

Haskell, 46 byte

Negozio (26 byte):

getContents>>=writeFile"t"

Recupera (20 byte):

readFile"t">>=putStr

Rubino (26 byte)

Imposta (16 byte)

IO.write'a',gets

Ottieni (10 byte)

IO.read'a'

MATLAB (30 byte)

Imposta (22 byte)

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

Può radere 4 byte cambiando in input(''), ma ciò richiederà che l'input sia tra virgolette singole:'input string'

Ottieni (8 byte)

load a;a

C (GCC), 98 byte

Store (46 byte)

L'input avviene tramite il primo argomento della riga di comando.

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

Recupera (52 byte)

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

Unportability

• Richiede l'inserimento di diversi tipi di puntatore int.

Ringraziamenti

• -2 byte grazie a ceilingcat
• -10 byte grazie a Peter Cordes

APL (Dyalog Unicode) , 18 byte

Store: ⍞⎕NPUT⎕A 1 provalo online!
Recupera: ⊃⎕NGET⎕A provalo online!

⍞ get line from stdin
⎕NPUT inseriscilo in un file nativo chiamato
⎕A alfabeto maiuscolo 1 e sovrascrivi se il file esiste

⊃ la prima parte (i dati, le parti successive sono codifica e tipo di fine riga) per
⎕NGET ottenere il file nativo con
⎕A l'alfabeto maiuscolo

R (27 byte)

archivio (21 byte)

x=readLines('stdin')

carico (6 byte)

cat(x)

Affinché ciò funzioni, il primo script deve essere richiamato con l'opzione della riga di comando --savee il secondo con --restore(anche se in modalità interattiva questo non è necessario: queste opzioni sono predefinite).

Questo potrebbe essere ridotto di 7 byte se non fosse per il fatto che un bug in R impedisce all'argomento predefinito di readLinefunzionare in modalità non interattiva. In modalità interattiva, è non è necessario, e la soluzione utilizza quindi solo 20 byte .

Java (JDK 10) , 204 byte

Attenzione: sovrascrive tutte le preferenze memorizzate da qualsiasi programma java per il tuo nome utente!

Negozio, 94 byte:

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

Provalo online!

Recupera 110 byte:

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

Provalo online!

java S foo
java R
foo

Funziona prendendo l'input come arg e memorizzandolo nel back-store delle preferenze dell'utente fornito da java.util.prefs . Sovrascrive il nodo principale dell'utente per salvare un byte nella denominazione di un nodo. Se si desidera testarlo in modo non distruttivo, eseguirlo da un nome utente usa e getta o modificare la chiave da "" a un nome nodo.

C #, 157 byte

Set, 74 byte:

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

Ottieni, 83 byte:

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

-1 Byte grazie a VisualMelon
-2 Byte grazie a LiefdeWen

Perl 5, 48 26 23 byte

Scrivi, 20 + 1 (-n) byte

-3 byte grazie al mob

open f,">>f";print f

In realtà non sono sicuro di questo punto di vista, ma soddisfa i criteri. Per le voci passate, sono state contate solo le opzioni cli, quindi è quello con cui sto andando.

Lettura, 0 + 2 byte

perl -pe "" f

Attache , 23 + 16 = 39 byte

Scrive semplicemente STDIN sul file A, quindi legge il file A.

store.@:

$A&FileWrite!AllInput[]

retrieve.@:

Echo!FileRead!$A

analisi

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

Store, 27 byte

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

Recupera, 24 byte

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

RUBINO

Store (24 byte)

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

Recupera (16 byte)

p File.read('a')

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

Store, 27 23 byte

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

Recupera, 27 23 byte

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

Questo fondamentalmente avvolge la risposta di Jofel in un programma C.

Nota: i ddcomandi generano alcune statistiche stderr, quindi vedrai un output aggiuntivo quando lo esegui in modo ingenuo nella shell. Tuttavia, poiché la sfida dice solo che la stringa memorizzata deve essere presentata stdout, no stderr, suppongo che sia consentito avere un output aggiuntivo su stderr... Comunque, sopprimere l' stderroutput è facile come sostituirlo ddcon cat, aumentando il conteggio dei byte del due programmi per uno, ciascuno.

PHP, 26 + 1 + 21 = 48 byte

Store.php:

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

Corri con echo <input> | php -nF Store.php.

Retrieve.php:

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

Corri con php -n Retrieve.php.

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

Compilare con solo alcuni avvisi sul mio gcc.

store.c

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

Probabilmente riuscirò a capire cosa includere, ma non sono riuscito a capire come. Segfault se non gli passi nulla, ma qualunque cosa.

Peter Cordes: -1

read.c

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

Lotto - 11 byte

%12>f
type f

L'input viene ricevuto come argomento della riga di comando e persiste (con il messaggio di errore creato al tentativo di esecuzione, poiché CMD tenta di eseguire il parametro) in f.

Lotto - 7 byte (non competitivo)

'>%1
dir

Esistono numerosi caratteri non validi in un nome file, quindi questo non funzionerebbe per alcune stringhe, ma essenzialmente questo salva un carattere arbitrario nel nome file dato dal parametro. Per leggerlo, elenca solo tutti i file nella directory, inclusa la nostra stringa.