Imprima la resolución de pantalla del dispositivo en el formato específico de [width]x[height](sin los corchetes). Por ejemplo, una salida podría ser 1440x900.

Aquí hay un probador en línea que puede usar para verificar su propia resolución de pantalla.

JavaScript (ES6), 32 bytes

(_=screen)=>_.width+"x"+_.height

Salidas como función return. Agregue f=al principio e invoque como f(). Utiliza la inicialización de parámetros para inicializar el parámetro _al screenobjeto. El resto se explica por sí mismo.

f=(_=screen)=>_.width+"x"+_.height
console.log(f())

Nota: Pasar un argumento a esta función hará que falle.

JavaScript (solución anterior), 35 bytes

with(screen)alert(width+"x"+height)

¡Nunca pensé que algún día lo usaría with! No creo que esto pueda jugarse más.

TI-BASIC, 30 32 29 bytes (¿no compite?)

* suspiro * TI-BASIC toma un byte extra por cada letra minúscula.

+2 gracias a @Timtech

-3 gracias a @Timtech

:If ΔX>.1
:Then
:Disp "96x64
:Else
:Disp "320x240

Esto solo funciona porque TI-BASIC solo puede ejecutarse en calculadoras con dos resoluciones de pantalla diferentes: 96 por 64 y 320 por 240. Solo pruebo para ver qué pantalla tengo configurando el Zoom en algo diferente dependiendo de la resolución de la pantalla. dando salida a la resolución correcta.

Estoy marcando esto como no competitivo por ahora, ya que está codificado.

JavaScript (ES6), 32 bytes

_=>(s=screen).width+'x'+s.height

console.log((_=>(s=screen).width+'x'+s.height)())

macOS, bash, awk, grep, tr, 51 52 bytes

/*/*/sy*r SPDisplaysDataType|awk '/so/{print$2$3$4}'

Carreras system_profiler, obtiene la SPDisplaysDataTypeinformación, busca la primera soen Resolution, e imprime la resolución de la pantalla. Para múltiples pantallas, esto imprime todas las resoluciones.

La variante anterior, mal compatible:

/*/*/sy*r SPDisplaysDataType|grep so|tr -d 'R :a-w'

Javascript, 36 bytes

s=screen;alert(s.width+"x"+s.height)

Procesando 3, 37 bytes

fullScreen();print(width+"x"+height);

fullScreen()hace que la aplicación se inicie con las dimensiones máximas: la resolución de pantalla. Un byte menos que lo obvio

print(displayWidth+"x"+displayHeight);

AutoHotKey, 34 bytes

SysGet,w,0
SysGet,h,1
Send,%w%x%h%

Guarde esto en un archivo con extensión .AHK y ejecútelo desde un símbolo del sistema

C (Windows), 79 78 77 bytes

¡Gracias a @Johan du Toit por guardar un byte!

#import<windows.h>
#define G GetSystemMetrics
f(){printf("%dx%d",G(0),G(1));}

PowerShell, 67 60 55 bytes

-7 gracias a Martin Ender

-5 (¡en realidad 12!) De Leaky Nun , la magia de Regex me supera.

Esto es largo pero no más largo que la System.Windows.Forms.SystemInformation.PrimaryMonitorSizesolución horrenda

(gwmi win32_videocontroller|% v*n)-replace" |x \d+\D+$"

primero Get-WmiObject( gwmi) para recuperar el Win32_VideoControllerobjeto, que contiene un miembro llamado VideoModeDescription, que es una cadena en el formato de 1920 x 1080 x 4294967296 colors, luego ejecuto un reemplazo de expresiones regulares para obtener el formato correcto.

PS H:\> (gwmi win32_videocontroller|% v*n)-replace" |x \d+\D+$"
1920x1080

Mathematica, 51 bytes

SystemInformation[][[1,5,2,1,2,1,2,2,;;,2]]~Infix~x

Es posible que esto no funcione para usted dependiendo de los dispositivos que haya conectado (no lo sé). Esto siempre debería funcionar (suponiendo que tenga al menos una pantalla conectada):

Infix[Last/@("FullScreenArea"/.SystemInformation["Devices","ScreenInformation"][[1]]),x]

Explicación

SystemInformation[] devuelve una expresión de la forma

SystemInformationData[{
  "Kernel" -> {__},
  "FrontEnd" -> {__},
  "Links" -> {__},
  "Parallel" -> {__},
  "Devices" -> {__},
  "Network" -> {__},
}]

Estamos interesados "Devices", a los que se puede acceder directamente como SystemInformation["Devices"]o como SystemInformation[][[1,5,2]]. El resultado será una lista del formulario.

{
  "ScreenInformation" -> {__},
  "GraphicsDevices" -> {__},
  "ControllerDevices" -> {__}
}

Queremos "ScreenInformation", al que se puede acceder como SystemInformation["Devices","ScreenInformation"]o más sucintamente como SystemInformation[][[1,5,2,1,2]]. El resultado será de la forma

{
  {
  "ScreenArea" -> {__},
  "FullScreenArea" -> {{0,w_},{0,h_}},
  "BitDepth" -> _,
  "Resolution" -> _
  },
  ___
}

La longitud de la lista será la cantidad de pantallas que haya conectado. La primera pantalla es SystemInformation[][[1,5,2,1,2,1]]y el ancho y la altura se pueden extraer como SystemInformation[][[1,5,2,1,2,1,2,2,;;,2]]Luego, simplemente insertamos un Infix xpara el formato de salida.

Java 7, 123114 bytes

String f(){java.awt.Dimension s=java.awt.Toolkit.getDefaultToolkit().getScreenSize();return s.width+"x"+s.height;}

Este método no funcionará en una instalación sin cabeza de Java (como en TIO) porque usa las bibliotecas awt. Bajo el capó, las llamadas getScreenSizeutilizan la interfaz nativa de Java para llamar (generalmente a una biblioteca C) para el ancho y la altura de la pantalla.

-9 bytes gracias a Olivier Grégoire por recordarme que puedo devolver la cadena en lugar de imprimirla.

C #, 101 95 89 bytes

_=>{var s=System.Windows.Forms.Screen.PrimaryScreen.Bounds;return s.Width+"x"+s.Height;};

-6 bytes gracias a @TheLethalCoder recordándome que OP no mencionó sobre la impresión, por lo que devolver una cadena también está bien. Y un -6 bytes adicionales al cambiarlo a lambda.

Bash + xrandr, 44 caracteres

read -aa<<<`xrandr`
echo ${a[7]}x${a[9]::-1}

xrandrpertenece al servidor X, en Ubuntu es proporcionado por el paquete x11-xserver-utils .

Ejecución de muestra:

bash-4.3$ read -aa<<<`xrandr`;echo ${a[7]}x${a[9]::-1}
1920x1080

xrandr + grep + util-linux, 30 caracteres

xrandr|grep -oP '\d+x\d+'|line

Gracias a:

• Markasoftware para la expresión regular (-11 caracteres)

Ejecución de muestra:

bash-4.3$ xrandr|grep -oP '\d+x\d+'|line
1920x1080

Python 2, 73 bytes

from ctypes import*
u=windll.user32.GetSystemMetrics;
print u(0),'x',u(1)

Octava , 41 bytes

Gracias a @Arjun y @StephenS por las correcciones.

fprintf('%ix%i',get(0,'ScreenSize')(3:4))

0es un identificador para el objeto gráfico raíz. Su propiedad 'ScreenSize'contiene las coordenadas de la pantalla en píxeles. Las entradas tercera y cuarta dan la información deseada.

APL (Dyalog) , 23 bytes

' '⎕R'x'⍕⌽⊃⎕WG'DevCaps'

⎕WG'DevCaps' W indow G et Dev ice Cap abilitie s

⊃ elige la primera propiedad (altura, ancho)

⌽ marcha atrás

⍕ formatear como texto

' '⎕R'x' R espacios EColoque con s "x"

Japt , 24 bytes

Ox`ØP(s×Çn)±d+"x"+ight

¡Pruébelo en línea!

La cadena comprimida representa with(screen)width+"x"+height. Oxevalúa esto como JavaScript, y el resultado se imprime implícitamente.

C (biblioteca SDL2) 113 88 84

(-4 caracteres debido a la ayuda de @AppleShell)

Sí. Se compila.

m[3];main(){SDL_Init(32);SDL_GetDesktopDisplayMode(0,m);printf("%dx%d",m[1],m[2]);}

Corre con : gcc snippet.c -lSDL2 && ./a.out

Python 2, 61 49 bytes

Gracias @ Jonathan-allan, @ felipe-nardi-batista

from Tkinter import*
print'%sx%s'%Tk().maxsize()

Para configuraciones de pantalla única, esto coincide con la salida del sitio. Esto proporciona una resolución completa para múltiples pantallas.

bash + xdpyinfo 42 31 bytes

xdpyinfo|grep dim|cut -d' ' -f7

Desde la página del manual:

xdpyinfo - is  a utility for displaying information about an X server.

@Floris @manatwork ¡Gracias por guardar algunos bytes!

xrandr + awk, 25 bytes

xrandr|awk /\*/{print\$1}

ZX Spectrum Basic, 10 bytes

solo para completar:

PRINT "256x192"

salidas 256x192 . El Spectrum tiene una resolución de pantalla fija fija.

Procesamiento, 51 bytes

void setup(){fullScreen();print(width+"x"+height);}

Esto genera en este formato: width height. Además, el programa crea una ventana que es del tamaño de la pantalla que está utilizando (porque cada programa de procesamiento crea una ventana por defecto) y este programa solo muestra la altura y el ancho de esta ventana / boceto.

xdpyinfo+ awk, 28 bytes

$ xdpyinfo|awk /dim/{print\$2}
3360x1050

Probado en Cygwin con cabezales dobles.

Tcl / Tk, 40

puts [winfo screenw .]x[winfo screenh .]

Lithp , 116 bytes

((import html-toolkit)
(htmlOnLoad #::((var S(index(getWindow)screen))
(print(+(index S width)"x"(index S height))))))

(Saltos de línea añadidos para facilitar la lectura)

Pruébalo en línea!

¡Finalmente, mi módulo html-toolkit se usa! Solo funciona en el enlace Pruébelo en línea, no funcionará desde la línea de comandos.

Se podrían guardar algunos bytes si 1024 x 768pudiera ser una salida válida. Solo usamos (+ .. "x" .. )para evitar printel espacio implícito.

Lua (marco de löve), 116 bytes

f,g=love.window.setFullscreen,love.graphics function love.draw()f(1)w,h=g.getDimensions()f(0>1)g.print(w.."x"..h)end

El programa cambia primero a pantalla completa, luego obtiene el ancho y la altura y luego lo imprime :)

xrandr y sh, 23 bytes

$ set `xrandr`;echo $6x$8
3360x1050

Probado en una caja CentOS 5 con pantalla redirigida a una máquina Cygwin con dos monitores. Aquí la xrandrsalida completa es

$ xrandr
 SZ:    Pixels          Physical       Refresh
*0   3360 x 1050   ( 889mm x 278mm )  *0
Current rotation - normal
Current reflection - none
Rotations possible - normal
Reflections possible - none

Ruby + xrandr, 37 bytes

puts `xrandr`.split[7..9].join[0..-2]

Solución alternativa (52 bytes):

puts `xrandr`.match(/t (\d+) (x) (\d+),/)[1..3].join

Rojo , 26 bytes

system/view/screens/1/size

Salidas por ejemplo:

1920x1080

El código se explica por sí mismo. El se 1refiere a la primera pantalla