Codice più corto nella tua lingua per rendere persistente una stringa durante un riavvio


48

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:

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.


9
quindi giusto echo $@>xed cat xè valido?
Adám,

1
Le tue specifiche non menzionano la possibilità di memorizzare più volte, ma hai un caso esemplificativo che lo fa. Possiamo assumere un ambiente pulito per ogni invocazione di Store?
Adám,

4
@EriktheOutgolfer Perché non dovrebbe essere valido? Anche se c'è una scappatoia discussa sul meta che non impedisce a una sfida di permetterlo specificatamente.
dylnan,

6
Le restrizioni del web di solito riguardano l'estrazione di roba dal web come scappatoia per uscire dal lavoro di creazione di quella roba. In questo caso, se è sul web è perché hai fatto il lavoro di metterlo lì.
Jared K,

3
Qualcuno deve scrivere una risposta per un computer con memoria a nucleo magnetico.
Segna il

Risposte:


88

zsh, 4 byte

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


8
Penso che abbiamo un vincitore.
Adám,

@Adám a meno che non ci sia un token per scrivere l'input nel file in 1 byte: P
FreezePhoenix

1
@FreezePhoenix Probabilmente non ce n'è nessuno a meno che tu non scriva una nuova lingua ora che non è consentita ...
Chromium

4
@Chromium verifica la risposta Z80: alcune lingue esistenti possono scrivere da un programma a 0 byte.
Cœur il

55

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)


1
Sei sicuro che sono 5 byte?
FreezePhoenix,

6
@FreezePhoenix TI-Basic utilizza i token.
Adám,

3
Hmm ... Perché non prendere l'input Anse persisterlo nella stessa variabile? Un programma di archiviazione vuoto e solo Ansper il recupero dovrebbe funzionare: 1 byte!
Jakob,

9
@Arthur Sì, Anspersiste. In effetti, persiste molto stato, tra cui (penso) tutte le variabili utente, le equazioni e la cronologia. Dal punto di vista dell'utente, lo spegnimento è fondamentalmente l'equivalente della calcolatrice TI di uno stato di sospensione per un PC, quindi non disturba molto.
Jakob,

2
@JaredK Sono assolutamente d'accordo che la soluzione a 1 byte profuma di abuso di regole (anche se sono stato io a suggerirlo). Tuttavia, direi che il programma del negozio esce, poiché altri programmi possono essere eseguiti dopo di esso (sebbene interferiscano con il funzionamento della soluzione). La mia interpretazione del tuo "test oggettivo di persistenza" era che i programmi sarebbero stati eseguiti direttamente prima e dopo il ciclo di accensione. Se ciò non è corretto, forse potresti richiedere che la soluzione a 1 byte sia contrassegnata come non competitiva?
Jakob,

23

Browser JS, 44 byte

Negozio :

localStorage.a=prompt()

Recuperare :

alert(localStorage.a)

Leggerà prompt()da STDIN?
pipe

9
Un browser Web grafico ha un STDIN? No. prompt()visualizza un avviso che richiede di inserire il testo e restituisce il risultato.
Dev

5
@Dev Naturalmente un browser web grafico ha un STDIN, proprio come ogni altro processo. Se non puoi usarlo da una lingua specifica è un'altra domanda e se la risposta è "No", allora forse posso essere usato in questa sfida.
pipe

5
@Dev I metodi I / O predefiniti includono input tramite prompt della GUI e output tramite display della GUI . A meno che OP non intendesse sostituire lo standard, questo dovrebbe essere valido. Chiarirò.
Esolanging Fruit,

2
Ho modificato la sfida per consentire più IO, ma la sto solo espandendo in un sottoinsieme limitato dei metodi IO predefiniti. Questa risposta è nel mio sottoinsieme. Mi piace.
Jared K,

19

Shell POSIX sh / bash / ... 8 byte

memorizzare:

dd>f

ottenere:

dd<f

2
Bello, batte anche cat...
cmaster

12

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 )


2
Sicuramente puoi usare input()?
Artemis Fowl,

@ArtemisFowl input()riceve solo fino alla prima nuova riga. open(0).readlegge tutto STDIN
Jo King il

Probabilmente hai pubblicato quando le cose erano ancora ambigue, ma così com'è questa risposta non soddisfa le specifiche attuali. Inizialmente intendevo che il requisito STDIN / STDOUT fosse rigoroso, con valori predefiniti non consentiti. L'ho espanso, ma solo a un sottoinsieme delle impostazioni predefinite. Il programma di recupero, se non utilizza STDOUT, deve comunque visualizzare l'output sullo schermo. Se consentissi i valori predefiniti completi, la soluzione per ogni lingua sarebbe "accetta input in un file", "restituisce output in un file", zero byte.
Jared K,

@JaredK Non penso che tu abbia capito come funziona. Il storeprogramma legge l'input da STDIN e quindi memorizza un programma Python che stampa questo input f. Esempio: STORE viene chiamato con un input di abc. Quindi scrive print('abc')a f. Se ora chiami f(RECUPERA), stampa abcsu STDOUT.
Ovs,

@JaredK Ti ho chiesto in un commento se a STORE era permesso modificare RETRIEVE.
Ovs,


8

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

8

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
È possibile salvare un byte modificando l'importazione in use std::{io::*,fs::*}e quindi utilizzando writeinvece di std::fs::write.
Esolanging Fruit,

Che ne dici write("a",String::from_iter(stdin().chars()))?
Bergi,

@Bergi Nice. Ma si charsinnesca error[E0658]: use of unstable library feature 'io'nella ruggine stabile.
Jakob,

Hm, sembra chars()deprecato a favore di String::from_utf8(stdin().bytes()). (Ho anche usato i documenti notturni, non sono sicuro che sia il colpevole)
Bergi

@Bergi Ho provato alcune varianti con bytes()o chars()ma nessuna di queste era molto breve perché l'elemento iteratore è racchiuso io::Result.
Esolanging Fruit,

8

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

1
Non è necessario -nel programma del negozio.
Konrad Rudolph,

2
Non è necessario nemmeno lo spazio tra "gatto" e ">"!
psmears,

Dovresti essere in grado di fare lo stesso del post di zsh per scrivere e usare >f. <fTuttavia, non sono sicuro che sia valido per la lettura.
allo

@allo Almeno su Cygwin, >ffunziona come echo '' > f(svuotare il file se esiste, creando se non lo fa), mentre <fsembra essere una no-op.
Sundar - Ripristina Monica il

7

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.


La soluzione a zero byte dovrebbe funzionare per una varietà di caluclatori. Uscirò dai miei 42 anni quando torno a casa.
SIGSTACKFAULT

Penso che la tua soluzione a zero byte, e le altre in esecuzione su calcolatrici che si riavviino in modo non distruttivo, non riescano a soddisfare due parti della domanda: "Farai due programmi". Quello che hai è un singolo programma che sopravvive al riavvio. E "Store legge da STDIN e quindi esce senza errori." Il tuo programma sta ancora aspettando che l'utente prema un tasto. Lo stack e lo stato di esecuzione del programma sono ancora modificabili. Penso che ciò significhi che è ancora in esecuzione e non è uscito.
Jared K,

@JaredK La domanda non prevedeva mai che i due programmi non potessero essere identici. Per quanto riguarda la parte uscente: tradizionalmente in RPL l'input ai programmi è dato nello stack. Questo è l'input standard.
Jason,

1
Lo stack sopravviverebbe a un ciclo di accensione? Forse uno spegnimento graduale tramite i pulsanti della calcolatrice, ma suppongo che non rimuova la batteria. Quindi forse dipende da cosa sia un ciclo di accensione.
utente

1
@utente No, lo stack non sopravvive al soft (ON + C) o al hard reset (ON + A + F) (distinto da soft-power off, Right Shift + ON), a differenza della memorizzazione nella porta 2, che è la memoria flash ( e sopravvive al ripristino soft e hard). Poiché la risposta TI-BASIC sembrava usare quella definizione, ho incluso la risposta dello stack per completezza.
Jason,

6

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

Sessione Store APLXAPLX Recupera sessione

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


6

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)


1
IIRC, credo che un gruppo di Berkeley negli anni '90 abbia creato un sistema di database che memorizzava i dati delle colonne delle tabelle come nomi di file (fino a 255 caratteri). Penso che le righe e le tabelle fossero directory principali.
David R Tribble,

Nella risposta di 35 byte, è possibile modificare la seconda istruzione in s/..//. Non $è necessario perché tutte le altre righe vengono eliminate in modo da poter essere applicate solo all'ultima riga e ^possono essere eliminate poiché la sostituzione viene applicata solo sulla prima corrispondenza.
Kritixi Lithos,

@Cowsquack Done. Grazie per aver spiegato perché anche il cambiamento funziona.
Sundar - Ripristina Monica il

È necessario utilizzare "$@", non è $@, per evitare di essere bruciato da spazi bianchi, *, ?o ~caratteri.
Anders Kaseorg,

5

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.


Perché non input()invece di open(0).read()e omettere end=da print?
MoxieBall,

@MoxieBall Non sono sicuro del motivo per cui inputnon è stato utilizzato, ma l'omissione end=comporterebbe l'aggiunta di una nuova riga alla fine della stringa (ovvero, non la stringa originale) (forse)

@NickA Sembra che una nuova riga venga stampata nella domanda, comunque, quindi non credo che dovrebbe importare ...
MoxieBall

Sono impazzito o fa 23 + 33 = 56 (non 54)? Inoltre, perché non usare input()?
Artemis Fowl,

1
@ArtemisFowl Buona cattura. Per quanto riguarda input, presumo che la stringa da persistere possa contenere newline.
Jakob,

4

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

+1 per essere il primo a usare qualcosa di diverso dal file IO standard che mi piace.
Jared K,

1
Benvenuto in Japt! :)
Shaggy,

1
A proposito, puoi bypassare setIteme getItemcompletamente con localStorage.key. Imposta valore , recupera valore
Shaggy

@Shaggy Grazie! Il tuo evita anche i personaggi di controllo più strani.
LegionMammal978,

4

Haskell, 46 byte

Negozio (26 byte):

getContents>>=writeFile"t"

Recupera (20 byte):

readFile"t">>=putStr

3

Rubino (26 byte)

Imposta (16 byte)

IO.write'a',gets

Ottieni (10 byte)

IO.read'a'

3

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

3

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


1
Ciò richiede un'implementazione C in cui intpuò contenere un puntatore, affinché la dichiarazione implicita di int fopen()funzionare. (ad esempio la maggior parte dei sistemi a 32 bit, o utilizzare gcc -m32se si è su x86-64 per creare un eseguibile a 32 bit.) E BTW, ho provato a usare le chiamate di sistema sendfilee Linux copy_file_range(2), ma non funzionano da / verso un TTY.
Peter Cordes,

1
Dal momento che stai scrivendo funzioni, non programmi, forse potresti giustificare prendere la stringa di input come funzione arg permettendo fputs(fopen()), e read(open(),buf,-1). (La domanda ora consente un argomento da riga di comando come input.)
Peter Cordes,

La funzione 'splice' di Linux copia da una pipe in un file (e viceversa). Se stdin / out sono pipe, salverà una chiamata di funzione, a spese di più parametri.
CSM,

2

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


2

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 .


1
Penso che sarebbe molto più efficiente usarlo qdirettamente, essendo il primo programma x=scan(); q("y")e il secondo xo a cat(x)seconda di quanto rigoroso vogliamo essere su come vengono stampate le stringhe. Secondo le solite regole del code golf devi anche contare gli argomenti della riga di comando, quindi aggiungi byte per --savee --restore(di cui la mia formulazione non ha bisogno)
JDL

@JDL scannon funziona per contenuti arbitrari ed scan(w='character')è più lungo di readLines(). qnon è necessario (ma q('y')non funzionerebbe, devi scriverlo yes). Ho pensato di utilizzare solo xil secondo programma, ma ciò violerebbe i requisiti, per quanto li capisco.
Konrad Rudolph,

1
puoi usare scan(w=""), non è necessario precisare il tipo, scanlo dedurrà dal tipo di argomento specificato. Per me, q ("y") funziona come una chiusura che induce al salvataggio, ma forse dipende dalla tua versione di R, e possibilmente dal fatto che tu stia usando Rstudio o meno.
JDL,

@JDL scan: Oh, pulito, la documentazione non ne parla! Sfortunatamente scaneseguirà comunque un po 'di analisi, quindi non funzionerà con tutti gli input. Comunque, scan('stdin',w='')sembra avere la stessa identica lunghezza di readLines('stdin'). q: R 3.4.4 dice "Errore in q (" y "): valore non riconosciuto di" salva "".
Konrad Rudolph,

Ah, è una cosa di Rstudio - l'ho provato in Rstudio e separatamente al terminale e ha funzionato solo in Rstudio.
JDL

2

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.


Buona idea! Dato che stai usando Java 10, puoi accorciarli rendendoli espressioni lambda. Inoltre, se il conteggio dei byte non include, zè necessario rimuoverlo dai programmi e dal TIO. Prendi in considerazione di mettere un avvertimento in cima alla presentazione invece di avvertire le persone. Di sicuro il TIO dovrebbe avere le tue soluzioni a 94 e 110 byte.
Jakob,

Grazie! Ho apportato le modifiche suggerite. Non ne sono certo, ma non credo che le espressioni lambda possano soddisfare le regole IO personalizzate per questa domanda.
Jared K,

D'oh. Hai ragione, me ne sono dimenticato.
Jakob,

2

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


Rimuovi quello spazio dopo "a",, e dubito che questo sarà battuto :)
VisualMelon

È possibile salvare un altro byte utilizzando WriteAllLinese il secondo parametroa
LiefdeWen

2

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

1
Perché hai segnato -necon 1 (dovrebbe avere eanche un ), ma -pecon 2? Puoi usare -Ee sayinvece di print.
simbabque

Grazie per avermelo informato -E, non avevo familiarità con quello. Per quanto riguarda il motivo per cui non ci sono andato -ne, è perché per quello, sto effettivamente correndo da un file. Quindi, sembrerebbe che perl -n w.plse questo va contro gli standard della comunità PCG, posso modificare la mia risposta di conseguenza.
Geoffrey H.

No, va bene. Aggiungiamo un malus per ulteriori argomenti da riga di comando, quindi va bene.
simbabque

2
">>","f"-> ">>f"salva 3 caratteri
mob

1

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

1

Lua, 57 53 51 byte

Store, 27 byte

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

Recupera, 24 byte

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

1

RUBINO

Store (24 byte)

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

Recupera (16 byte)

p File.read('a')

4
La domanda richiede la memorizzazione di input da STDIN, non gli argomenti
Ferrybig

Da allora ho modificato per consentire alternative IO compresi gli argomenti.
Jared K,

1
File.write'a',getse p File.read'a'sono un po 'più brevi;)
DarkWiiPlayer

1

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.


A seconda del compilatore potresti anche essere in grado di rimuovere il inttipo restituito main. Nel vecchio stile ANSI C intè il tipo restituito predefinito.
Jakob,

@Jakob Ah, sì, certo. Mi sono affidato coscienziosamente alla dichiarazione implicita system()e mi sono dimenticato di quello di main()- ahi. Grazie per
averlo

1

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.


1

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");}

int*f=fopendovrebbe funzionare, ovvero mentire al compilatore sul tipo di puntatore. Ma solo se esegui la compilazione per un sistema a 32 bit (ovvero uno in cui intpuò contenere un puntatore, come gcc -m32, o semplicemente gccsu un sistema a 32 bit). Puoi anche dichiarare main come main(int c,char**v), o forse int**vperché non stai dereferenziando.
Peter Cordes,

Le main(int c,char**v)opere Ho anche capito che posso farlo fputs(v[1],fopen("f","w"), anche se per qualche motivo ha ancora bisogno di stdio.
SIGSTACKFAULT

Dovrebbe funzionare se si compila un eseguibile a 32 bit. Per x86-64, il compilatore troncherà il intvalore restituito a 32 bit, quindi lo estenderà come un puntatore. Se il reso FILE*è a 32 bit bassi, funzionerebbe, ma non è il caso su Linux x86-64.
Peter Cordes,

Se ci si trova su un sistema in cui tutte le dimensioni dei puntatori sono uguali (piuttosto probabile), è possibile evitare l'inclusione dichiarando fopenmanualmente. Andando vecchia scuola con gli argomenti di risparmiare alcuni byte troppo: *fopen();main(c,v)int**v;{fputs(v[1],fopen("f","w"));}.
Gastropner

1

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.


1
L'output della soluzione sembra su STDOUT, che è valido. STDERR è solo un'altra opzione, non richiesta. Le virgolette attorno all'input non gli impediscono di competere. L'unica domanda è se devono essere conteggiati nel conteggio dei byte. Penso di no, dal momento che non sono specifici alla domanda. Sembrano una piastra standard per Batch per prendere un arg della riga di comando, che non è così diverso dalle lingue che necessitano di flag della riga di comando standard. Forse qualcun altro con conoscenza Batch entrerà in azione. Per ora li lasci fuori dal conteggio dei byte. Benvenuti in Code Golf! :)
Jared K,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.