Il tuo compito oggi sarà quello di prendere un file esistente e aggiungere zeri ad esso fino a raggiungere una certa dimensione.

È necessario scrivere un programma o una funzione che assume il nome di un file nella directory corrente fe un numero di byte b. Pur mantenendo il contenuto originale di f, è necessario scrivere zero (byte null, non ascii 0s) alla fine in modo che la sua nuova dimensione sia bbyte.

Si può presumere che fabbia solo ASCII alfanumerici nel suo nome, che si disponga di autorizzazioni complete su di esso, che inizialmente non sia più grande di b, ma possa essere grande quanto be che vi sia spazio libero su disco infinito.

Non si può presumere che fsia vuoto o che non contenga già byte nulli.

Altri file esistenti non devono essere modificati e non dovrebbero esistere nuovi file al termine dell'esecuzione.

Casi test

Contenuto di f | b | Contenuti risultanti di f
12345 | 10 | 1234500000
0 | 3 | 000
[vuoto] | 2 | 00
[vuoto] | 0 | [vuoto]
123 | 3 | 123

Bash + coreutils, 13

truncate -s$@

Input dalla riga di comando: il primo parametro è la dimensione del file e il secondo è il nome file.

Da man truncate:

Se un FILE è più corto, viene esteso e la parte estesa (foro) legge zero byte.

Provalo online .

Groovy, 54 47 43 41 byte

{a,b->(c=new File(a))<<'\0'*(b-c.size())}

-6 grazie all'idea di manatwork di rimuovere il loop; questa era la mia idea originale, non so perché pensassi che non avrebbe funzionato e ho optato per un ciclo ... Funziona sicuramente, appena provato.

Ungolfed:

{
    a,b->                    // Two inputs: a is the File name, b is the desired size.
    File c = new File(a)     // Make and store the file.
    c << '\0'*(b-c.size())   // Append the difference between b and c.size() in nullbytes.
}
                             // Usually a close would be required, but, in Groovy,
                             // because private data isn't so protected, if a File
                             // Object goes out of scope, the attached Stream is 
                             // automatically flushed to disk.

APL (Dyalog) , 33 17 byte

⎕⎕NRESIZE⍞⎕NTIE¯1

Provalo online!

Python 2 , 59 57 54 byte

^{-5 byte grazie a chepner}

def g(n,b):f=open(n,'a');f.write('\0'*b);f.truncate(b)

PHP, 66 byte

for($p=fopen($f=$argv[1],a);filesize($f)<$argv[2];)fputs($p,"\0");

Accetta input dagli argomenti della riga di comando; corri con -nr.

Questi 55 byte potrebbero, ma molto probabilmente non funzioneranno:

fseek($p=fopen($argv[1],"w+"),$argv[2]);fputs($p,"\0");

Java (Oracle JRE), 55 byte

f->b->new java.io.RandomAccessFile(f,"rw").setLength(b)

La specifica di setLength(int)dice che i byte aggiunti non sono definiti, ma praticamente Oracle JRE aggiunge solo il 0byte (ecco perché l'ho specificato).

La risorsa viene automaticamente chiusa da JVM, quindi non è necessario farlo da soli.

Test

public class Pcg125661 {
  interface F {
    B f(String f);
  }
  interface B {
    void b(int b) throws java.io.IOException;
  }
  public static void main(String[] args) throws java.io.IOException {
    F a = f->b->new java.io.RandomAccessFile(f,"rw").setLength(b);
    a.f("a").b(100);
  }
}

AHK, 48 byte

FileGetSize,s,%1%
2-=s
Loop,%2%
FileAppend,0,%1%

1e 2sono i primi due parametri in uno script AHK.
FileGetSizefunziona in byte per impostazione predefinita.
Non è eccitante, ma è semplice: ottieni la dimensione, sottrala dalla dimensione desiderata e aggiungi molti zeri.

Perl 6 , 40 byte

{$_=$^a.IO;.open(:a).put("\0"x($^b-.s))}

$^ae $^bsono i parametri della funzione: il nome del file e la lunghezza, rispettivamente.

Python 2 , 68 byte

def g(f,b):
 with open(f,'r+')as c:c.write('\x00'*(b-len(c.read())))

Provalo online! (Quando si stampa il contenuto del file, il codice sostituisce i byte null con 0 ASCII per la visibilità.)

PowerShell, 69 byte

param($f,$s)@(gc $f -en by)+,[byte]0*($s-(gi $f).length)|sc $f -en by
#     ^ filename
#        ^desired size
#                 ^ get content as byte stream
#           ^force it to an array even if there's 0 or 1 byte
#                          ^append a byte array of nulls..
#                                       ^..desired size - file size
#                            write to file with -encoding byte ^

$fper il file, $sper la dimensione di destinazione, salva come .ps1 ed esegui

.\Add-NullBytesToFile.ps1 .\test.txt 10

È una shell, quindi dovrebbe esserci un loop davvero piccolo che aggiunge 1 byte con >>reindirizzamento dell'output e append, giusto? Beh, no, perché >>emette solo la codifica multibyte UCS2-LE, quindi non c'è modo di aggiungere un singolo byte a un file con esso .. a meno che tu non stia usando PSv5.1 e puoi cambiarlo ma ciò rende troppo lungo per essere competitivi :

$PSDefaultParameterValues['Out-File:Encoding']='utf8';while((gi $f).length-lt$c){[byte]0>>$f}

Forse esiste un approccio .Net Framework? Dovrebbe esserci, ma non riesco a farlo scrivere effettivamente alcun byte o errore. Ma è più lungo comunque:

param($f,$s)[io.file]::WriteAllBytes($f,[byte[]](,0)*($c-(gi $f).length), $True)

Mathematica 50 byte

Import / Export

Export[#,Import[#,c="Byte"]~Join~Table[0,{#2}],c]&

uso

%["test1", 5]

q, 29 byte

Funzione che accetta il nome del file in formato :/foo/bar.baze lunghezza come numero intero.

{hopen[x](0|y-hcount x)#0x00}

Esempio:

{hopen[x](0|y-hcount x)#0x00}[`:test.txt;100]

C, 56 byte

fseek(f,0,2);int i;for(;ftell(f)<b;)putc(0,f);fclose(f);

Il programma trova la dimensione del file e quanti byte aggiungere. Il file quindi aggiunge fs - bbyte extra alla fine.

C #, 90 byte

using System.IO;s=>n=>File.AppendAllText(s,new string('\0',(int)new FileInfo(s).Length-n))