Seus programas:

Você escreverá dois programas (ambos no mesmo idioma). O programa de armazenamento pega uma sequência de STDIN e a armazena em algum lugar persistente (veja abaixo) e sai sem erro. O programa de recuperação não recebe entrada, recupera a sequência que foi armazenada e a imprime em STDOUT.

Teste objetivo de persistência:

Você deve poder executar o programa de armazenamento em sua máquina local, depois ligar e ligar a máquina local e depois chamar o programa de recuperação em sua máquina local. Você pode esconder a string da maneira que desejar (mesmo na Web), desde que passe no teste de reinicialização.

Casos de teste:

Armazenamento e recuperação:

echo foo | Store
Retrieve
foo

Lojas repetidas devem substituir (como um método set ()):

echo foo | Store
echo bar | Store
Retrieve
bar

A recuperação repetida não é destrutiva (como um método get ()):

echo foo | Store
Retrieve
foo
Retrieve
foo

Recuperação antes de qualquer invocação do Armazenamento:

Você não precisa se preocupar com isso. Seu programa de recuperação pode assumir que o programa de armazenamento foi executado em algum momento no passado.

Flexibilidade de entrada / saída.

As pessoas me pediram para expandir isso de STDIN / STDOUT estrito para as regras de IO padrão. Não posso, porque introduziria muitas brechas. Algumas opções de IO padrão já têm a entrada armazenada de maneira persistente, por exemplo, "programas podem receber entrada de um arquivo". Eu gostaria de ser mais flexível do que apenas STDIN e STDOUT, mas sem abrir as comportas.

No segmento de regras de IO padrão, eu estou escolhendo aqueles que não quebram o desafio:

• Os programas podem receber informações por meio de prompts da GUI e de linha de comando, se você desejar

• Os programas podem ser exibidos exibindo-os na tela Isso inclui caixas de diálogo da GUI

• Os programas podem receber informações via argumentos da linha de comando

• Os programas podem ser enviados para STDERR, mas ainda não podem realmente gerar erros.

Se você usar uma alternativa, ela deve ser interativa. O usuário não deveria ter que fazer nenhum outro trabalho além de canalizar a entrada para o seu programa, digitando-a em um prompt fornecido pelo programa ou digitando a entrada como um argumento de linha de comando do seu programa. O usuário não precisa fazer nada além de executar o programa de recuperação para ver a saída exibida na tela ou enviada para STDOUT ou STDERR.

Premissas permitidas:

• Seus dois programas serão executados no mesmo diretório
• Seus programas têm permissões de leitura e gravação para esse diretório
• Os arquivos criados sobreviverão à reinicialização (não em um diretório temporário)
• Uma nova linha à direita que não fazia parte da sequência é permitida. Nenhum outro espaço em branco à direita

Isso é código-golfe, e sua pontuação é a soma de bytes dos dois programas.

zsh, 4 bytes

Armazenar: >f(lê de STDIN e grava em um arquivo chamado f)
Recuperar: <f(grava o conteúdo de fem STDOUT)

TI-BASIC (Z80), 1 byte ?

Armazenar:  (basta digitar a sequência)
Recuperar: Ans(byte 27)

Mas se isso não for válido:

TI-BASIC (Z80), 7 6 bytes

-1 graças a Jakob.

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

JS do navegador, 44 bytes

Loja :

localStorage.a=prompt()

Recuperar :

alert(localStorage.a)

Shell POSIX sh / bash / ... 8 bytes

loja:

dd>f

pegue:

dd<f

Python 3 , 46 bytes

armazenamento, 45 bytes:

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

O programa de recuperação é construído pelo comando loja, um arquivo chamado f. ( 1 byte para o nome do arquivo )

Lote, 16 bytes

COPY CON A
TYPE A

Powershell - 4 bytes

Armazenamento:

ac

(alternativa também sc)

Recuperação

gc

Edit: Acabei de notar que a saída não é permitida nenhuma entrada do usuário ... por isso salta de 4 para 6 ou 8 bytes

Armazenamento:

ac f

(alternativa também sc f) para a versão de 8 bytes

ac

(e especifique fcomo caminho) para a versão de 6 bytes

Recuperação

gc f

Ferrugem, 136 bytes

Armazenar (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())

Agradecimentos

• -1 byte graças ao Esolanging Fruit

Bater, 12 11 10 bytes

loja, 7 6 5 bytes

cat ->f# não há necessidade -, stdin é o padrão

cat >f# não há necessidade de espaço, >separa também

cat>f

recuperar, 5 bytes

cat f

HP 49G RPL, 48 bytes

Para salvar :2: A DUP PURGE STO:, 26,5 bytes

Para restaurar :2: A RCL:, 21,5 bytes

Se pudermos deixar a bateria de reserva, obteremos:

HP 49G RPL, 0 bytes

Para salvar :, 0 bytes

Para restaurar :, 0 bytes, uma vez que o HP 49G deixa a pilha intocada nas reinicializações.

APL (APLX) , 5 bytes

Loja: ⍞⍈1
Recupere:⍇1

⍞ obter linha da
⍈1 gravação stdin para o próximo componente disponível do número de arquivo 1

⍇1 leia o primeiro * último componente do número de arquivo 1

* A documentação diz primeiro, mas a experimentação mostra por último .

bash, 10 bytes (não concorrente)

touch $@
ls

Os nomes de arquivos Unix podem conter qualquer caractere, exceto NULe /, e seus nomes podem ter até 255 bytes de comprimento, portanto, será possível armazenar apenas cadeias de caracteres com esse comprimento (considere uma limitação do meio de armazenamento) e que não contenham '/ ' neles. Essa é uma razão pela qual não é concorrente; outra é que isso pressupõe que o diretório em que está sendo executado esteja vazio (ou que saída estranha lsseja permitida). Eu ainda queria postar isso porque parecia uma maneira legal e não óbvia de armazenar informações.

Outro na mesma linha, que não teria as mesmas limitações de comprimento e caráter, seria:

35 33 bytes

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

Isso permite o /caractere na string e suporta muitos outros caracteres (exatamente quantos dependem da implementação).

(-2 bytes sobre isso graças ao charlatão @ Vacas)

Python 3, 56 bytes

Armazenar (33 bytes)

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

Recuperar (23 bytes)

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

Imprime com uma nova linha à direita.

Japonês, 46 30 bytes

^{-16 bytes graças a Shaggy .}

Uma das primeiras vezes que tentei usar o Japt. O JS eval pode às vezes ser inquieto. Usa o navegador window.localStorage.

Armazenar (16 bytes)

Ox`lo¯lSÈSge.P=U

Recuperar (14 bytes)

Ox`lo¯lSÈSge.P

Haskell, 46 bytes

Armazenar (26 bytes):

getContents>>=writeFile"t"

Recuperar (20 bytes):

readFile"t">>=putStr

Ruby (26 bytes)

Conjunto (16 bytes)

IO.write'a',gets

Obter (10 bytes)

IO.read'a'

MATLAB (30 bytes)

Conjunto (22 bytes)

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

Pode cortar 4 bytes alterando para input(''), mas isso exigirá que a entrada esteja entre aspas simples:'input string'

Obter (8 bytes)

load a;a

C (GCC), 98 bytes

Armazenar (46 bytes)

A entrada é via primeiro argumento de linha 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);}

Inportabilidade

• Requer que vários tipos de ponteiros se encaixem int.

Agradecimentos

• -2 bytes graças ao ceilingcat
• -10 bytes graças a Peter Cordes

APL (Dyalog Unicode) , 18 bytes

Loja: ⍞⎕NPUT⎕A 1 Experimente online!
Recuperar: ⊃⎕NGET⎕A Experimente online!

⍞ get line from stdin
⎕NPUT coloque-o em um arquivo nativo chamado
⎕A alfabeto maiúsculo 1 e sobrescreva se o arquivo existir

⊃ a primeira parte (os dados, as próximas partes são do tipo de codificação e final de linha) de
⎕NGET obter o arquivo nativo com
⎕A o alfabeto maiúsculo

R (27 bytes)

armazenamento (21 bytes)

x=readLines('stdin')

carga (6 bytes)

cat(x)

Para que isso funcione, o primeiro script precisa ser chamado com a opção de linha de comando --savee o segundo com --restore(embora no modo interativo isso não seja necessário: essas opções são o padrão).

Isso poderia ser reduzido em 7 bytes, não fosse o fato de um bug no R impedir o argumento padrão de readLinefuncionar no modo não interativo. No modo interactivo, que é não necessário, e a solução, por conseguinte, utiliza apenas 20 bytes .

Java (JDK 10) , 204 bytes

Aviso: Substitui as preferências que os programas java armazenaram para o seu nome de usuário!

Loja, 94 bytes:

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

Experimente online!

Recupere 110 bytes:

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

Experimente online!

java S foo
java R
foo

Isso funciona usando a entrada como argumento e armazenando-a no repositório de preferências do usuário fornecido pelo java.util.prefs . Ele substitui o nó raiz do usuário para economizar um byte ao nomear um nó. Se você quiser testá-lo de forma não destrutiva, execute-o com um nome de usuário descartável ou altere a chave de "" para o nome do nó.

C #, 157 bytes

Conjunto, 74 bytes:

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

Obter, 83 bytes:

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

-1 Bytes graças ao VisualMelon
-2 Bytes graças ao LiefdeWen

Perl 5, 48 26 23 bytes

Gravação, 20 + 1 (-n) bytes

-3 bytes graças ao mob

open f,">>f";print f

Na verdade, não tenho certeza sobre isso, mas atende aos critérios. Para entradas passadas, apenas as opções cli foram contadas, e é com isso que eu vou.

Leitura, 0 + 2 bytes

perl -pe "" f

Anexo , 23 + 16 = 39 bytes

Simplesmente escreve STDIN no arquivo Ae depois lê o arquivo A.

store.@:

$A&FileWrite!AllInput[]

retrieve.@:

Echo!FileRead!$A

Testando

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

Armazenar, 27 bytes

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

Recuperar, 24 bytes

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

RUBI

Armazenar (24 bytes)

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

Recuperar (16 bytes)

p File.read('a')

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

Loja, 27 23 bytes

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

Recuperar, 27 23 bytes

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

Isso basicamente envolve a resposta de Jofel em um programa em C.

Nota: Os ddcomandos emitem algumas estatísticas para stderr, portanto, você verá alguma saída adicional quando executá-la ingenuamente no shell. No entanto, uma vez que o desafio só diz que a corda armazenado deve ser apresentado em stdout, não stderr, eu levá-la de que está autorizado a ter saída adicional em stderr... De qualquer forma, suprimindo stderrsaída é tão fácil como a substituição ddcom cat, aumentando a contagem de bytes do dois programas por um, cada um.

PHP, 26 + 1 + 21 = 48 bytes

Store.php:

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

Corra com echo <input> | php -nF Store.php.

Retrieve.php:

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

Corra com php -n Retrieve.php.

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

Compila com apenas alguns avisos no meu gcc.

store.c

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

Provavelmente posso jogar fora o include, mas não consegui descobrir como. Segfaults se você não passar nada, mas tanto faz.

Peter Cordes: -1

read.c

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

Lote - 11 bytes

%12>f
type f

A entrada é recebida como argumento da linha de comando e persiste (com a mensagem de erro criada na tentativa de execução, pois o CMD tenta executar o parâmetro) em f.

Lote - 7 bytes (não competitivo)

'>%1
dir

Há uma infinidade de caracteres inválidos em um nome de arquivo, portanto, isso não funcionaria para algumas seqüências de caracteres, mas isso salva um caractere arbitrário no nome do arquivo fornecido pelo parâmetro. Para lê-lo, apenas lista todos os arquivos no diretório, incluindo nossa string.