Vos programmes:

Vous allez écrire deux programmes (les deux dans la même langue). Le programme de stockage extrait une chaîne de STDIN d'une chaîne persistante (voir ci-dessous), puis se ferme sans erreur. Le programme de récupération ne prend aucune entrée, récupère la chaîne qui a été stockée et l’imprime sur STDOUT.

Test objectif de persistance:

Vous devriez pouvoir exécuter le programme de stockage sur votre ordinateur local, puis redémarrer votre ordinateur local, puis appeler le programme d'extraction sur votre ordinateur local. Vous pouvez cacher la chaîne comme vous le souhaitez (même sur le Web) tant que vous passez ce test de redémarrage.

Cas de test:

Stockage puis récupération:

echo foo | Store
Retrieve
foo

Les magasins répétés doivent écraser (comme une méthode set ()):

echo foo | Store
echo bar | Store
Retrieve
bar

La récupération répétée est non destructive (comme une méthode get ()):

echo foo | Store
Retrieve
foo
Retrieve
foo

Récupération avant toute invocation de stockage:

Vous n'avez pas besoin de vous inquiéter à ce sujet. Votre programme de récupération peut supposer que le programme de stockage a été exécuté à un moment donné dans le passé.

Flexibilité d'entrée / sortie.

Les gens m'ont demandé de développer cela de strict STDIN / STDOUT aux règles IO standard. Je ne peux pas parce que cela introduirait trop d'échappatoires. Certaines options IO standard ont déjà l’entrée stockée de manière persistante, par exemple "les programmes peuvent prendre l’entrée d’un fichier". Je voudrais être plus flexible que simplement STDIN et STDOUT, mais sans ouvrir les vannes.

Dans le fil standard des règles IO, je choisis ceux qui ne relèveront pas le défi:

• Les programmes peuvent recevoir des entrées via des invites graphiques et des invites de ligne de commande si vous le souhaitez.

• Les programmes peuvent sortir en l'affichant à l'écran Cela inclut les dialogues d'interface graphique

• Les programmes peuvent prendre des entrées via des arguments en ligne de commande

• Les programmes peuvent sortir sur STDERR mais ne peuvent toujours pas générer d' erreurs.

Si vous utilisez une alternative, elle doit être interactive avec l'utilisateur. L'utilisateur ne devrait pas avoir à effectuer d'autres tâches que celle de transférer son entrée dans votre programme, de le saisir dans une invite fournie par votre programme ou de saisir une entrée en tant qu'argument de ligne de commande de votre programme. L'utilisateur ne devrait pas avoir à faire autre chose que d'exécuter votre programme de récupération pour voir la sortie affichée à l'écran ou envoyée à STDOUT ou à STDERR.

Hypothèses autorisées:

• Vos deux programmes seront exécutés dans le même répertoire
• Vos programmes ont des autorisations en lecture-écriture pour ce répertoire
• Les fichiers que vous créez survivront au redémarrage (pas dans un répertoire temporaire)
• Une nouvelle ligne finale qui ne faisait pas partie de la chaîne est autorisée. Aucun autre espace de fuite

C'est du code-golf et votre score est la somme des octets des deux programmes.

zsh, 4 octets

Store: >f(lit à partir de STDIN et écrit dans un fichier appelé f)
Récupérer: <f(écrit le contenu de fSTDOUT)

TI-BASIC (Z80), 1 octet ?

Store:  (entrez simplement la chaîne)
Récupérer: Ans(octet 27)

Mais si cela n'est pas valide:

TI-BASIC (Z80), 7 à 6 octets

-1 merci à Jakob.

Store: Prompt Str0(octets DD AA 09)
Récupérer: disp Str0(octets ED AA 09)

Navigateur JS, 44 octets

Magasin :

localStorage.a=prompt()

Récupérer :

alert(localStorage.a)

Shell POSIX sh / bash / ... 8 octets

le magasin:

dd>f

obtenir:

dd<f

Python 3 , 46 octets

magasin, 45 octets:

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

Le programme de récupération est construit par la commande store, un fichier nommé f. ( 1 octet pour le nom du fichier )

Lot, 16 octets

COPY CON A
TYPE A

Powershell - 4 octets

Espace de rangement:

ac

(alternative aussi sc)

Récupération

gc

Edit: je viens de remarquer que la sortie n’est autorisée dans aucune entrée utilisateur ... elle passe donc de 4 à 6 ou 8 octets

Espace de rangement:

ac f

(alternative également sc f) pour la version 8 octets

ac

(et spécifiez fcomme chemin) pour la version à 6 octets

Récupération

gc f

Rouille, 136 octets

Magasin (84 octets)

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

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

Récupérer (52 octets)

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

Remerciements

• -1 octet grâce à Esolanging Fruit

Frapper, 12 11 10 octets

le magasin, 7 6 5 octets

cat ->f# pas besoin de -, stdin est la valeur par défaut

cat >f# pas besoin d'espace, >sépare aussi

cat>f

récupérer, 5 octets

cat f

HP 49G RPL, 48 octets

Pour enregistrer :2: A DUP PURGE STO:, 26,5 octets

Pour restaurer :2: A RCL:, 21,5 octets

Si nous pouvons laisser dans la batterie de secours, nous obtenons:

HP 49G RPL, 0 octet

Pour enregistrer: 0 octet

Pour restaurer :, 0 octet, car la HP 49G laisse la pile intacte lors des redémarrages.

APL (APLX) , 5 octets

Magasin: ⍞⍈1
Récupérer:⍇1

⍞ récupère la ligne de stdin
⍈1 write au prochain composant disponible du fichier n ° 1

⍇1 lire le premier * dernier composant du fichier numéro 1

* La documentation dit en premier, mais l'expérimentation montre la dernière .

bash, 10 octets (non compétitif)

touch $@
ls

Les noms de fichiers Unix peuvent contenir n’importe quel caractère sauf NULet /, et leurs noms peuvent aller jusqu’à 255 octets , ce qui permet de ne stocker que les chaînes jusqu’à cette longueur (considérez qu’il s’agit d’une limitation du support de stockage), et ne contiennent pas '/ 'en eux. C'est une des raisons pour lesquelles il s'agit d'une concurrence, une autre est que cela suppose que le répertoire sur lequel il est exécuté est vide (ou que la sortie superflue de celle-ci lsest autorisée). Je voulais toujours poster ceci parce que cela semblait juste une façon cool et non évidente de stocker des informations.

Un autre exemple similaire, qui n'aurait pas la même longueur ni les mêmes limites de caractères, serait:

35 33 octets

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

Cela autorise le /caractère dans la chaîne et supporte beaucoup plus de caractères (exactement combien dépend de l'implémentation).

(-2 octets sur ceci grâce à @Cows Quack)

Python 3, 56 octets

Magasin (33 octets)

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

Récupérer (23 octets)

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

Imprime avec une nouvelle ligne.

Japt, 46 30 octets

^{-16 octets grâce à Shaggy .}

Une des premières fois que j'ai essayé d'utiliser Japt. Le JS eval peut parfois être agité. Utilise le navigateur window.localStorage.

Magasin (16 octets)

Ox`lo¯lSÈSge.P=U

Récupérer (14 octets)

Ox`lo¯lSÈSge.P

Haskell, 46 octets

Magasin (26 octets):

getContents>>=writeFile"t"

Récupérer (20 octets):

readFile"t">>=putStr

Ruby (26 octets)

Set (16 octets)

IO.write'a',gets

Obtenir (10 octets)

IO.read'a'

MATLAB (30 octets)

Ensemble (22 octets)

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

Vous pouvez supprimer 4 octets en remplaçant par input(''), mais cela nécessitera que les entrées soient entre guillemets simples:'input string'

Obtenir (8 octets)

load a;a

C (GCC), 98 octets

Magasin (46 octets)

La saisie s'effectue via le premier argument de la ligne de commande.

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

Récupérer (52 octets)

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

L'inviolabilité

• Nécessite que plusieurs types de pointeurs soient intégrés int.

Remerciements

• -2 octets grâce à ceilingcat
• -10 octets grâce à Peter Cordes

APL (Dyalog Unicode) , 18 octets

Magasin: ⍞⎕NPUT⎕A 1 essayez-le en ligne!
Récupérer: ⊃⎕NGET⎕A essayez-le en ligne!

⍞ récupère la ligne de stdin et la
⎕NPUT met dans un fichier natif appelé
⎕A alphabet majuscule 1 et écrase si le fichier existe

⊃ la première partie (les données, les parties suivantes sont codées et les types de fin de ligne) pour
⎕NGET obtenir le fichier natif
⎕A l'alphabet majuscule

R (27 octets)

magasin (21 octets)

x=readLines('stdin')

charge (6 octets)

cat(x)

Pour que cela fonctionne, le premier script doit être appelé avec l'option de ligne de commande --saveet le second avec --restore(bien que ce ne soit pas nécessaire en mode interactif: ces options sont les options par défaut).

Cela pourrait être raccourci de 7 octets sans le fait qu’un bogue dans R empêche l’argument par défaut readLinede fonctionner en mode non interactif. En mode interactif, cela n’est pas nécessaire et la solution n’utilise donc que 20 octets .

Java (JDK 10) , 204 octets

Avertissement: écrase toutes les préférences que tous les programmes java ont stockées pour votre nom d'utilisateur!

Magasin, 94 octets:

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

Essayez-le en ligne!

Récupérer 110 octets:

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

Essayez-le en ligne!

java S foo
java R
foo

Cela fonctionne en prenant l'entrée comme argument et en la stockant dans le magasin de sauvegarde des préférences utilisateur fourni par java.util.prefs . Il écrase le nœud racine de l'utilisateur pour enregistrer un octet lors de l'attribution d'un nom à un nœud. Si vous souhaitez le tester de manière non désestructrice, exécutez-le à partir d'un nom d'utilisateur jetable ou remplacez la clé par "" par un nom de nœud.

C #, 157 octets

Ensemble, 74 octets:

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

Obtenez 83 octets:

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

-1 octet grâce à VisualMelon
-2 octets grâce à LiefdeWen

Perl 5, 48 26 23 octets

Write, 20 + 1 (-n) octets

-3 octets grâce à la mob

open f,">>f";print f

En fait, je ne suis pas certain de cela, mais cela répond aux critères. Pour les entrées passées, seules les options de la CLI ont été comptées, c'est donc ce que je vais faire.

Lecture, 0 + 2 octets

perl -pe "" f

Attaché , 23 + 16 = 39 octets

Il suffit d’écrire STDIN dans un fichier A, puis de le lire A.

store.@:

$A&FileWrite!AllInput[]

retrieve.@:

Echo!FileRead!$A

Essai

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 octets

Magasin, 27 octets

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

Récupérer, 24 octets

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

RUBIS

Magasin (24 octets)

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

Récupérer (16 octets)

p File.read('a')

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

Store, 27 23 octets

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

Récupérer, 27 23 octets

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

Ceci englobe fondamentalement la réponse de jofel dans un programme C.

Remarque: Les ddcommandes génèrent des statistiques dans la commande stderr. Vous verrez donc une sortie supplémentaire lorsque vous l'exécuterez naïvement dans le shell. Cependant, étant donné que le défi indique uniquement que la chaîne stockée doit être présentée stdout, non stderr, je suppose qu'il est autorisé à avoir une sortie supplémentaire sur stderr... Quoi qu'il en soit, la suppression de la stderrsortie est aussi simple que le remplacement ddpar cat, deux programmes par un, chacun.

PHP, 26 + 1 + 21 = 48 octets

Store.php:

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

Courez avec echo <input> | php -nF Store.php.

Retrieve.php:

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

Courez avec php -n Retrieve.php.

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

Compile avec seulement quelques avertissements sur mon gcc.

store.c

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

Peut probablement jouer au golf, mais je ne savais pas comment. Segfaults si vous ne passez rien, mais peu importe.

Peter Cordes: -1

read.c

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

Lot - 11 octets

%12>f
type f

L'entrée est reçue sous forme d'argument de ligne de commande et persiste (avec le message d'erreur créé lors de la tentative d'exécution, puisque CMD tente d'exécuter le paramètre) dans f.

Lot - 7 octets (non compétitif)

'>%1
dir

Un nom de fichier contient une pléthore de caractères non valides. Par conséquent, cela ne fonctionnerait pas pour certaines chaînes, mais cela sauvegarderait essentiellement un caractère arbitraire dans le nom de fichier indiqué par le paramètre. Pour le lire, il ne fait que répertorier tous les fichiers du répertoire, y compris notre chaîne.