Sus programas:

Escribirás dos programas (ambos en el mismo idioma). El programa de almacenamiento toma una cadena de STDIN y la almacena en algún lugar persistente (ver más abajo) y luego sale sin error. El programa de recuperación no toma ninguna entrada, recupera la cadena que estaba almacenada y la imprime en STDOUT.

Prueba objetiva de persistencia:

Debería poder ejecutar el programa de almacenamiento en su máquina local, luego reiniciar su máquina local y luego llamar al programa de recuperación en su máquina local. Puede guardar la cadena como desee (incluso en la web) siempre que pase esta prueba de reinicio.

Casos de prueba:

Almacenamiento y recuperación:

echo foo | Store
Retrieve
foo

Las tiendas repetidas deberían sobrescribirse (como un método set ()):

echo foo | Store
echo bar | Store
Retrieve
bar

La recuperación repetida no es destructiva (como un método get ()):

echo foo | Store
Retrieve
foo
Retrieve
foo

Recuperación antes de cualquier invocación de Almacenamiento:

No necesita preocuparse por esto. Su programa de recuperación puede suponer que el programa de almacenamiento se ha ejecutado en algún momento en el pasado.

Flexibilidad de entrada / salida.

La gente me ha pedido que amplíe esto de estricto STDIN / STDOUT a las reglas estándar de E / S. No puedo porque introduciría demasiadas lagunas. Algunas opciones estándar de E / S ya tienen la entrada almacenada de forma persistente, por ejemplo, "los programas pueden recibir información de un archivo". Me gustaría ser más flexible que simplemente STDIN y STDOUT estrictos, pero sin abrir las compuertas.

Del hilo de reglas estándar de IO estoy seleccionando los que no rompen el desafío:

• Los programas pueden recibir información a través de indicaciones de la GUI y de la línea de comandos si lo desea

• Los programas pueden aparecer mostrándolos en la pantalla Esto incluye cuadros de diálogo de GUI

• Los programas pueden recibir información a través de argumentos de línea de comandos

• Los programas pueden salir a STDERR pero aún no pueden arrojar errores.

Si usa una alternativa, debe ser interactiva para el usuario. El usuario no debería tener que hacer ningún otro trabajo además de canalizar su entrada a su programa, escribiéndola en un indicador que proporcione su programa, o escribiendo la entrada como una línea de comando arg de su programa. El usuario no debería tener que hacer nada más que ejecutar su programa de recuperación para ver la salida mostrada en la pantalla o enviada a STDOUT o STDERR.

Suposiciones permitidas:

• Sus dos programas se ejecutarán en el mismo directorio.
• Sus programas tienen permisos de lectura y escritura para ese directorio
• Los archivos que cree sobrevivirán al reinicio (no en un directorio temporal)
• Se permite una nueva línea final que no era parte de la cadena. Ningún otro espacio en blanco al final

Este es el código de golf, y su puntaje es la suma de bytes de ambos programas.

zsh, 4 bytes

Almacenar: >f(lee de STDIN y escribe en un archivo llamado f)
Recuperar: <f(escribe el contenido de fSTDOUT)

TI-BASIC (Z80), 1 byte ?

Almacenar:  (solo ingrese la cadena)
Recuperar: Ans(byte 27)

Pero si eso no es válido:

TI-BASIC (Z80), 7 6 bytes

-1 gracias a Jakob.

Almacenar: Prompt Str0(bytes DD AA 09)
Recuperar: disp Str0(bytes ED AA 09)

Navegador JS, 44 bytes

Tienda :

localStorage.a=prompt()

Recuperar :

alert(localStorage.a)

POSIX shell sh / bash / ... 8 bytes

Tienda:

dd>f

obtener:

dd<f

Python 3 , 46 bytes

tienda, 45 bytes:

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

El programa de recuperación es creado por el comando store, un archivo llamado f. ( 1 byte para el nombre del archivo )

Lote, 16 bytes

COPY CON A
TYPE A

Powershell - 4 bytes

Almacenamiento:

ac

(alternativa también sc)

Recuperación

gc

Editar: Acabo de notar que la salida no tiene permitida ninguna entrada del usuario ... por lo que salta de 4 a 6 u 8 bytes

Almacenamiento:

ac f

(alternativa también sc f) para la versión de 8 bytes

ac

(y especificar fcomo ruta) para la versión de 6 bytes

Recuperación

gc f

Óxido, 136 bytes

Almacenar (84 bytes)

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

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

Recuperar (52 bytes)

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

Expresiones de gratitud

• -1 byte gracias a Esolanging Fruit

Golpetazo, 12 11 10 bytes

Tienda, 7 6 5 bytes

cat ->f# no es necesario -, stdin es predeterminado

cat >f# no necesita espacio, también se >separa

cat>f

recuperar, 5 bytes

cat f

HP 49G RPL, 48 bytes

Para guardar: :2: A DUP PURGE STO26,5 bytes

Para restaurar: :2: A RCL21,5 bytes

Si podemos dejar la batería de respaldo, obtenemos:

HP 49G RPL, 0 bytes

Para guardar: 0 bytes

Para restaurar: 0 bytes, ya que el HP 49G deja la pila intacta en los reinicios.

APL (APLX) , 5 bytes

Tienda: ⍞⍈1
Recuperar:⍇1

⍞ obtener línea de
⍈1 escritura estándar al siguiente componente disponible del archivo número 1

⍇1 lea el primer * último componente del archivo número 1

* La documentación dice primero pero la experimentación muestra lo último .

bash, 10 bytes (no competitivos)

touch $@
ls

Los nombres de archivo de Unix pueden contener cualquier carácter, excepto NULy /, y sus nombres pueden tener hasta 255 bytes de longitud, por lo que solo podrá almacenar cadenas de esa longitud (considere que es una limitación del medio de almacenamiento) y que no contengan '/ ' en ellos. Esa es una razón por la que esto no compite, otra es que esto supone que el directorio en el que se ejecuta está vacío (o que lsse permite una salida extraña de ). Todavía quería publicar esto porque parecía una forma genial y no obvia de almacenar información.

Otro en una línea similar, que no tendría las mismas limitaciones de longitud y carácter sería:

35 33 bytes

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

Esto permite el /carácter en la cadena y admite muchos más caracteres (exactamente cuántos depende de la implementación).

(-2 bytes en esto gracias a @Cows quack)

Python 3, 56 bytes

Almacenar (33 bytes)

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

Recuperar (23 bytes)

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

Imprime con una nueva línea final.

Japt, 46 30 bytes

^{-16 bytes gracias a Shaggy .}

Una de las primeras veces que intenté usar Japt. La evaluación JS puede ser inquieta a veces. Utiliza el navegador window.localStorage.

Almacenar (16 bytes)

Ox`lo¯lSÈSge.P=U

Recuperar (14 bytes)

Ox`lo¯lSÈSge.P

Haskell, 46 bytes

Tienda (26 bytes):

getContents>>=writeFile"t"

Recuperar (20 bytes):

readFile"t">>=putStr

Rubí (26 bytes)

Conjunto (16 bytes)

IO.write'a',gets

Obtener (10 bytes)

IO.read'a'

MATLAB (30 bytes)

Conjunto (22 bytes)

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

Puede reducir 4 bytes cambiando a input(''), pero esto requerirá que la entrada esté entre comillas simples:'input string'

Obtener (8 bytes)

load a;a

C (GCC), 98 bytes

Almacenar (46 bytes)

La entrada es a través del primer argumento de línea de comando.

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

Recuperar (52 bytes)

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

Falta de portabilidad

• Requiere que encajen varios tipos de punteros int.

Expresiones de gratitud

• -2 bytes gracias a ceilingcat
• -10 bytes gracias a Peter Cordes

APL (Dyalog Unicode) , 18 bytes

Tienda: ¡ ⍞⎕NPUT⎕A 1 Pruébelo en línea!
Recuperar: ¡ ⊃⎕NGET⎕A Pruébelo en línea!

⍞ obtener línea de stdin
⎕NPUT póngalo en un archivo nativo llamado
⎕A alfabeto en mayúsculas 1 y sobrescriba si el archivo existe

⊃ la primera parte (los datos, las siguientes partes son codificación y tipo de final de línea) de
⎕NGET obtener el archivo nativo
⎕A del alfabeto en mayúsculas

R (27 bytes)

tienda (21 bytes)

x=readLines('stdin')

carga (6 bytes)

cat(x)

Para que esto funcione, el primer script debe invocarse con la opción de línea de comando --savey el segundo con --restore(aunque en modo interactivo esto no es necesario: estas opciones son las predeterminadas).

Esto podría acortarse en 7 bytes si no fuera por el hecho de que un error en R impide que el argumento predeterminado de readLinefuncione en modo no interactivo. En el modo interactivo, es que no es necesario, y la solución, por tanto, sólo utiliza 20 bytes .

Java (JDK 10) , 204 bytes

Advertencia: ¡ Sobrescribe las preferencias que haya almacenado cualquier programa Java para su nombre de usuario!

Tienda, 94 Bytes:

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

Pruébalo en línea!

Recupere 110 bytes:

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

Pruébalo en línea!

java S foo
java R
foo

Esto funciona tomando la entrada como un argumento y almacenándola en el almacén de respaldo de preferencias del usuario provisto por java.util.prefs . Sobrescribe el nodo raíz del usuario para guardar un byte al nombrar un nodo. Si desea probarlo de manera no destructiva, ejecútelo desde un nombre de usuario desechable o cambie la clave de "" a un nombre de nodo.

C #, 157 bytes

Conjunto, 74 bytes:

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

Obtenga 83 bytes:

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

-1 Bytes gracias a VisualMelon
-2 Bytes gracias a LiefdeWen

Perl 5, 48 26 23 bytes

Escritura, 20 + 1 (-n) bytes

-3 bytes gracias a la mafia

open f,">>f";print f

En realidad, no estoy seguro de esto, pero cumple con los criterios. Para entradas pasadas, solo se contaron las opciones cli, así que eso es lo que voy a hacer.

Lectura, 0 + 2 bytes

perl -pe "" f

Agregado , 23 + 16 = 39 bytes

Simplemente escribe STDIN en el archivo A, luego lee el archivo A.

store.@:

$A&FileWrite!AllInput[]

retrieve.@:

Echo!FileRead!$A

Pruebas

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

Tienda, 27 bytes

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

Recuperar, 24 bytes

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

RUBÍ

Almacenar (24 bytes)

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

Recuperar (16 bytes)

p File.read('a')

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

Tienda, 27 23 bytes

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

Recuperar, 27 23 bytes

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

Esto básicamente envuelve la respuesta de jofel en un programa en C.

Nota: Los ddcomandos generan algunas estadísticas stderr, por lo que verá algunos resultados adicionales cuando lo ejecute ingenuamente en el shell. Sin embargo, ya que el desafío sólo dice que la cadena almacenada debe ser presentada en stdout, no stderr, lo tomo que se le permite tener salida adicional en stderr... De todos modos, la supresión de stderrla producción es tan fácil como cambiar ddcon cat, el aumento de la cantidad de bytes de la dos programas por uno, cada uno.

PHP, 26 + 1 + 21 = 48 bytes

Store.php:

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

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

Retrieve.php:

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

Corre con php -n Retrieve.php.

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

Compila con solo algunas advertencias en mi gcc.

store.c

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

Probablemente pueda incluir el golf, pero no pude entender cómo. Segfaults si no le pasa nada, pero lo que sea.

Peter Cordes: -1

leer.c

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

Lote: 11 bytes

%12>f
type f

La entrada se recibe como un argumento de línea de comandos y persiste (con el mensaje de error creado al intentar la ejecución, ya que CMD intenta ejecutar el parámetro) en f.

Lote: 7 bytes (no competitivo)

'>%1
dir

Hay una gran cantidad de caracteres no válidos en un nombre de archivo, por lo que esto no funcionaría para algunas cadenas, pero esto esencialmente guarda un carácter arbitrario en el nombre de archivo dado por el parámetro. Para leerlo, solo enumera todos los archivos en el directorio, incluida nuestra cadena.