Buenas tardes Golfgeneers.

Esta es una pregunta razonablemente larga y detallada. Dado lo que estaba pidiendo, tenía que serlo. Si tiene alguna pregunta, por favor hágala. Si hay algo que no está claro, avíseme para que pueda solucionarlo. Esto probablemente está en el lado más duro de codegolf.

Estamos construyendo una computadora liviana y necesitamos el sistema de archivos más liviano posible. Se elegirá el código más corto.

Estamos proporcionando un disco duro de última generación de 65536 bytes. Por el bien de este prototipo, será un archivo de imagen directo, que su programa puede asumir que existe, y está en la ubicación que más le convenga, es decir, un archivo binario que represente todo el disco duro. Puede suponer que esta imagen ya está 'formateada', es decir. si su programa depende de que algo esté en el archivo para funcionar, puede ser. Si necesita que el estado vacío inicial sea distinto de ceros, indique qué es.

No hay límite de memoria en cuanto a la RAM utilizada por su aplicación.

Los comandos de entrada y salida requerirán una interfaz con el disco duro real. Al igual que la imagen de disco, su programa puede suponer que el archivo de entrada existe y está donde quiera que esté. Del mismo modo, su programa puede emitir donde sea conveniente. Sin embargo, debe cerrar el archivo después de ejecutar el comando de entrada o salida.

No se le proporciona un formato que debe usar para la imagen del disco; puede desarrollar el suyo propio. Debe ser capaz de almacenar hasta 248 archivos. Cualquier archivo mayor de 256 bytes puede contar como un archivo nuevo en aras de este límite por cada 256 bytes o parte del mismo. Un archivo puede tener hasta 63488 bytes. Básicamente, debe ser tan capaz como un disco duro con 248 sectores de 256 bytes cada uno.

El razonamiento detrás de estos tamaños aparentemente es darle 2048 bytes de 'administración' - para almacenar detalles de los archivos. Cada archivo / carpeta debe ser accesible con un nombre de 4 caracteres alfanuméricos, que pueden ser sensibles a mayúsculas o minúsculas según su preferencia. Si su programa admite nombres de 4 o menos caracteres, entonces hay una bonificación de un multiplicador de 0.95.

Su programa debe aceptar, a través de stdin, los siguientes comandos. Los parámetros estarán separados por un espacio. El comando será terminado por una nueva línea.

• L: enumere los nombres para stdout de todos los archivos actuales y sus tamaños en bytes, separados por nuevas líneas.
• C ab - Copie el archivo a al nuevo archivo b.
• D a - Eliminar archivo a
• R ab - Renombra el archivo a con un nuevo nombre b
• I a: agrega el archivo de entrada (consulte la nota anterior) como archivo a
• O a - Emite el archivo a al archivo de salida

Los siguientes errores se pueden informar a STDOUT o STDERR como razones válidas para que un comando no se ejecute. Puede elegir imprimir solo ERR # donde # es el número del error:

• 1 - El archivo no existe
• 2 - El archivo ya existe
• 3 - Sin espacio *

* Tenga en cuenta que su programa no puede emitir esto solo porque no tiene espacio continuo. Si todavía tiene sectores disponibles, debe desfragmentar el disco para que funcione.

Un sistema de carpetas es opcional; sin embargo, obtendrá una bonificación de un multiplicador de 0.8 a su puntaje. Si admite más de 1 nivel de directorio, obtendrá una bonificación de un multiplicador de 0.7 (no además del 0.8). Para la bonificación, debes tener

• L, R, C y D solo funcionan dentro del directorio actual. L debe enumerar las carpetas en el directorio actual, así como los archivos.
• El nuevo comando M ab mueve el archivo a a la carpeta b. Si b es '.', Mueve el archivo al director principal
• El nuevo comando G a va a la carpeta a. Si a es '.', Va a la carpeta principal
• R también debe cambiar el nombre de las carpetas
• D también debe eliminar carpetas, y cualquier archivo / carpeta dentro de ellas
• C también debe copiar carpetas, y cualquier archivo / carpeta dentro de ellas

Los siguientes errores adicionales se pueden informar a STDOUT o STDERR como razones válidas para que un comando no se ejecute.

• 4 - La carpeta no existe
• 5 - Archivo, no se requiere carpeta - donde, I y O requieren nombres de archivo, y se proporcionó una carpeta

Tu puntaje es:

• El tamaño, en bytes, de su código fuente

• Multiplicado por

  • 0,95 si admite nombres de 4 o menos caracteres
  • 0.8 si admite un solo nivel de carpetas
  • 0.7 si admite varios niveles de carpetas
  • 0.95 si admite comandos (no necesariamente nombres de archivo) en minúsculas o mayúsculas

Buena suerte.

Ruby, puntaje 505.4 (560 caracteres)

x,a,b=gets.chomp.split
f=IO.read('F')
e=f[0,4*X=248].unpack 'A4'*X
s=f[4*X,2*X].unpack 's'*X
d=f[6*X..-1].unpack 'A'+s*'A'
u,v,w,y=[[N=nil,q=e.index(a),!t=e.index(""),"e[t]=a;s[t]=(d[t]=IO.binread('I')).size"],[!q,r=e.index(b),!t,"e[t]=b;d[t]=d[q];s[t]=s[q]"],[!q,N,N,"e[q]=d[q]='';s[q]=0"],[!q,r,N,"e[q]=b"],[!q,N,N,"IO.binwrite('O',d[q])"],[N,N,N,'X.times{|i|e[i]>""&&puts(e[i]+" #{s[i]}")}']]['ICDROL'=~/#{x}/i]
u&&$><<"ERR1\n"||v&&$><<"ERR2\n"||w&&$><<"ERR3\n"||eval(y)
d=d*""
d.size>63488&&$><<"ERR3\n"||IO.write('F',(e+s+[d]).pack('A4'*X+'s'*X+'A63488'))

Notas:

• El sistema de archivos se encuentra en el archivo Fen el directorio actual. Fdebe existir y puede ser creada / formateado mediante el siguiente comando: IO.write('F',(([""]*248)+([0]*248)+[""]).pack('A4'*248+'s'*248+'A63488')).
• El archivo de entrada siempre está Ien el directorio actual, el archivo de salida es O.
• Como no era necesario verificar los errores, asegúrese de escribir los comandos correctos (es decir, no hay comandos no compatibles, no faltan argumentos, nombres de archivo demasiado largos).
• La implementación del sistema de archivos es extremadamente simple: para cada comando, el disco duro completo se lee en la memoria y se reconstruye al finalizar (con éxito).

Bonificaciones:

• Los nombres de archivo pueden ser 1-4 caracteres
• Los comandos pueden ser mayúsculas o minúsculas

El código aún no está totalmente desarrollado, pero ya muestra que, para obtener una puntuación sustancialmente mejor, probaría un enfoque completamente diferente.

Sesión de prueba (solo se muestra STDIN / STDOUT pero, por supuesto, cada comando se antepone llamando al programa anterior):

> L
> I F001
> L
F001 558
> I F001
ERR2
> C F002 F003
ERR1
> C F001 F003
> L
F001 558
F003 558
> C F001 F003
ERR2
> R F002 F003
ERR1
> R F001 F003
ERR2
> R F001 F002
> L
F002 558
F003 558
> O F001
ERR1
> O F002
> L
F002 558
F003 558
> D F001
ERR1
> D F002
> L
F003 558
> C F003 F001
> L
F001 558
F003 558
> D F001
> L
F003 558
> D F003
> L

Tcl, puntaje 487,711 (772 bytes)

{*}[set a {interp alias {}}] s {} dict se f
{*}$a u {} dict un f
{*}$a h {} dict g
proc 0 {} {return -level 1}
proc p {n a b} {foreach l $n {proc $l $a "global f c;$b;S"}}
p L\ l {} {puts [join [dict k [h $f {*}$c]] \n]}
p C\ c a\ b {s {*}$c $b [h $f {*}$c $b]}
p D\ d a {u {*}$c $a}
p R\ r a\ b {s {*}$c $a [h $f {*}$c $b];u {*}$c $b}
p I\ i a {set i [open i rb];s {*}$c $a [read $i];close $i}
p O\ o a {set o [open o wb];chan puts $o [h $f {*}$c $a];close $o}
p M\ m a\ b {set d $c;if {$b eq "."} {set d [lrange $c 0 end-1]};s {*}$d $a [h $f {*}$c $a];u {*}$c $a}
p G\ g a {if {$a eq "."} {set c [lrange $c 0 end-1]} {lappend c $a}}
p S {} {puts [set o [open F wb]] $f;close $o;return}
set f [read [set i [open F rb]]]
close $i
set c {}
while 1 {{*}[split [gets stdin]]}

Bonificaciones (tengo que atraparlos a todos):

• admite nombres de archivo con 4 bytes o menos, o más. No me importa 0,95
• Soporta carpetas multinivel 0.7
• admite comandos en minúsculas y mayúsculas 0.95

Limitaciones conocidas:

• El sistema de archivos Fya debe existir. Vacío o espacio en blanco está bien.
• No verifico el tamaño del sistema de archivos, no me importa.
• El archivo de entrada es i, el archivo de salida es oy el sistema de archivos está enF
• Los errores bloquearán el programa.
• No se verifica si el archivo / directorio existe, podría ser un error.
• No hay diferencia entre un archivo y un directorio. Sí, puede escribir un directorio para generar y usar esto como sistema de archivos.
• El uso de un archivo como directorio que no sea un sistema de archivos válido generará un error.
• Sin validación de entrada. Los comandos no válidos pueden arrojar un error. O no:eval puts [expr 1+2]
• Ningún comando para crear un directorio (no fue mi idea), pero será creado implícitamente por I(tampoco es mi idea, y Gno crea)
• G no valida el directorio
• Los nombres de archivo pueden contener espacios, pero la interfaz no los admite.
• No se admite la modificación concurrente del mismo sistema de archivos.

Algunos hacks:

• eval puts $c -> directorio actual, separado por espacios.
• exit - sin comentarios.
• lappend c . -> cambia al subdirectorio .

Python 2.7 373 (413 bytes)

from pickle import*
E=exit;o=open;D,I,W='DIw'
def T(i):w[i]in d and E('ERR2')
d=load(o(D))
w=raw_input().split();b=w[0].upper()
if b=='L':
 for k in d:print k,len(d[k])
elif b==I:T(1);d[w[1]]=o(I).read()
else:
 a=w[1];a in d or E('ERR1')
 if b in'RC':T(2);d[w[2]]=(b<D and d.get or d.pop)(a)
 if b==D:d.pop(a)
 if b=='O':o(I,W).write(d[a])
d=dumps(d,-1)
x=65536-len(d)
x>-1or E('ERR3')
o(D,W).write(d+I*x)

El disco se guarda en formato Python pickle-Format: para crear un disco vacío, debe colocar estos dos bytes '}'. al principio y, opcionalmente, 65534 llenar bytes después. Admite nombres de archivo grandes arbitrarios (* 0.95), comandos en mayúsculas y minúsculas (* 0.95) y enlaces duros (:-).