Il problema:

Questa sfida nasce da un vero problema che stavo riscontrando. Ho una configurazione a doppio monitor al lavoro e volevo usare la seguente immagine come sfondo:

Tuttavia, i miei monitor hanno cornici abbastanza significative e quando imposto il mio sfondo, sembra qualcosa del genere, in cui il molo appare (appiers?) Per essere rotto:

Sono stato in grado di risolverlo creando un'immagine con il centro ritagliato da esso, e poi allungandolo indietro alla dimensione originale, come nell'immagine qui sotto:

La sfida:

Scrivi un programma che contiene un'immagine e la "monitora" per utilizzarla con una configurazione a doppio monitor (ovvero elimina la sezione centrale dell'immagine, dove si trovano le cornici). Le regole sono le seguenti:

1. Deve essere un programma completo che accetta l'immagine, come percorso (argomento stringa, ecc.) O nella forma di una finestra di dialogo di selezione file.
2. Il programma deve prendere come input il numero di linee verticali (un pixel in larghezza) per ritagliare dal centro dell'immagine
3. Il ritaglio deve provenire dal centro (in larghezza) dell'immagine originale
4. L'immagine risultante deve essere ridimensionata alla dimensione originale dell'immagine di input. (Entrambe le metà possono essere ridimensionate individualmente, quindi concatenate o concatenate e quindi ridimensionate. Il ridimensionamento individuale produce un'immagine / un effetto migliore, ma difficilmente si nota nel mondo reale)
5. Le immagini di sfondo sono generalmente uniformi, quindi per semplificare questa sfida, le immagini di input avranno solo un numero pari di pixel e il numero di righe da rimuovere sarà pari.
6. Questa sfida è il golf del codice: vince il codice più corto in byte

In bocca al lupo!

Ottava, 85 byte

@(f,n)imsave(imresize((o=imread(f))(:,[1:(end-n)/2,(end+n)/2:end],:),size(o)(1:2)),f)

Definisce una funzione anonima con fil nome del file e nil numero di colonne da rimuovere. Poiché una funzione anonima richiede una singola espressione, viene utilizzata l'assegnazione in linea, una funzione non presente in MATLAB.

MATLAB, 98 byte

Come bonus, ho anche giocato una risposta compatibile MATLAB. È interessante notare che questo è solo 13 byte in più, poiché la versione Octave ha bisogno di molte parentesi per analizzare correttamente i compiti in linea.

function  m(f,n)
o=imread(f);imsave(imresize(o(:,[1:(end-n)/2,(end+n)/2:end],:),size(o(:,:,1))),f)

Matlab 2013, 150 byte

Ecco il mio tentativo in Matlab. Sicuramente non sarà il codice più breve, ma è un inizio.

Attenzione, questo sovrascrive l'immagine originale, quindi fai prima una copia.

Versione golfizzata

function  mi(f,n)
o=imread(f);
s=size(o);
imwrite([imresize(o(:,1:((s(2)-n)/2),:),[s(1),s(2)/2]) imresize(o(:,((s(2)+n)/2):end,:),[s(1),s(2)/2])], f);
end

Ungolfed Code, con miglioramenti per dimensioni dell'immagine dispari e numero dispari di colonne

function  monitorizeImage( filename, num_columns )

orig = imread(filename);
orig_size = size(orig);

f = factor(orig_size(2));
origsize_iseven = f(1)==2;

f = factor(num_columns);
num_columns_iseven = f(1)==2;

odd_even_size_mismatch = xor(origsize_iseven,num_columns_iseven);

img_resized = imresize(orig,[orig_size(1) orig_size(2)+odd_even_size_mismatch]);

leftimg = img_resized(:,1:((orig_size(2)+odd_even_size_mismatch-num_columns)/2),:);
leftimg = imresize(leftimg,[orig_size(1),floor(orig_size(2)/2)]);
rightimg = img_resized(:,((orig_size(2)-odd_even_size_mismatch+num_columns)/2):end,:);
rightimg = imresize(rightimg,[orig_size(1),floor(orig_size(2)/2)]);

monitorized_image = [leftimg rightimg];
monitorized_image = imresize(monitorized_image,[orig_size(1),orig_size(2)+ ~origsize_iseven]);

[~, ~, ext] = fileparts(filename); 

imwrite(monitorized_image,strcat(filename(1:end-length(ext)),'_',num2str(num_columns),ext));

end

Wolfram Language, 134 , 127 , 119 111 byte

f[i_,c_]:=(d=ImageDimensions@i;ImageAssemble[ImageTake[i,a=All,#]&/@{{0,e=-#&@@d/2-c/2},{-e,a}}]~ImageResize~d)

Crea una funzione fche accetta un'immagine come primo input (come simbolo in Mathematica o Wolfram Cloud) e un numero intero come secondo input.

Ungolfed :

f[image_,columns_]:=(  (*Define Function*)
    d=ImageDimensions[image];  (*Get image dimensions*)
    e=d[[1]]/2+columns/2;  (*Add half the image width to half the number of removed columns*)
    ImageResize[ImageAssemble[Map[ImageTake[i,All,#]&,{{0,-e},{e,All}}]],d]  (*Map the function onto a list with the desired column ranges and merge and scale the resulting image*)
)

Tecnicamente, non funzionerà correttamente se una delle dimensioni dell'immagine supera 362.880 pixel, ma suppongo che vada bene, dal momento che è molto al di fuori dell'ambito del problema (e alcuni computer). Fisso!

PHP, 206 byte

($c=imagecopyresized)($t=imagecreatetruecolor($w=imagesx($s=imagecreatefrompng($argv[1])),$h=imagesy($s)),$s,0,0,0,0,$v=$w/2,$h,$x=$v-$argv[2]/2,$h);$c($t,$s,$v,0,$w-$x,0,$v,$h,$x,$h);imagepng($t,$argv[3]);

accetta tre argomenti della riga di comando: nome del file di origine, numero di righe da ritagliare e destinazione del nome file. Corri con -r.

È possibile che si desideri utilizzare imagecopyresampledanziché imagecopyresized(+2 byte) per un risultato migliore.

ungolfed

$s=imagecreatefrompng($argv[1]);    # load source image
$w=imagesx($s);$h=imagesy($s);      # get image dimensions
$t=imagecreatetruecolor($w,$h);     # create target image
$v=$w/2;                            # $v = half width
$x=$v-$argv[2]/2;                   # $x = width of remaining halves
                                    # resize and copy halves:
imagecopyresized($t,$s, 0,0,    0,0,$v,$h,$x,$h);
imagecopyresized($t,$s,$v,0,$w-$x,0,$v,$h,$x,$h);
imagepng($t,$argv[3]);              # save target image

Potrei salvare altri 9 byte inviando il risultato PNG a STDOUT ... ma per cosa?