Envie a resolução de tela do dispositivo no formato específico de [width]x[height](sem os colchetes). Por exemplo, uma saída poderia ser 1440x900.

Aqui está um testador online que você pode usar para verificar sua própria resolução de tela.

JavaScript (ES6), 32 bytes

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

Saídas como função return. Adicione f=no início e chame like f(). Usa a inicialização de parâmetro _para inicializar o parâmetro no screenobjeto. O resto é auto-explicativo.

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

Nota: Passar um argumento para esta função fará com que ela falhe.

JavaScript (solução anterior), 35 bytes

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

Nunca pensei que um dia usaria with! Eu não acho que isso possa ser jogado ainda mais.

TI-BASIC, 30 32 29 bytes (não concorrente?)

* suspiro * O TI-BASIC leva um byte extra para cada letra minúscula.

+2 graças a @Timtech

-3 graças a @Timtech

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

Isso funciona apenas porque o TI-BASIC só pode ser executado em calculadoras com duas resoluções de tela diferentes: 96 por 64 e 320 por 240. Acabei de testar para ver qual tela tenho configurando o Zoom para algo diferente, dependendo da resolução da tela. produzindo a resolução correta.

Estou marcando isso como não competitivo por enquanto, pois é 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}'

Corridas system_profiler, recebe a SPDisplaysDataTypeinformação, pesquisas para o primeiro soem Resolution, e imprime a resolução da tela. Para várias telas, isso imprime todas as resoluções.

A variante anterior, que não é compatível:

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

Javascript, 36 bytes

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

Processando 3, 37 bytes

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

fullScreen()faz com que o aplicativo seja iniciado com as dimensões máximas - a resolução da tela. Um byte a menos que o óbvio

print(displayWidth+"x"+displayHeight);

AutoHotKey, 34 bytes

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

Salve isso em um arquivo com a extensão .AHK e execute-o em um prompt de comando

C (Windows), 79 78 77 bytes

Obrigado a @Johan du Toit por salvar um byte!

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

PowerShell, 67 60 55 bytes

-7 graças a Martin Ender

-5 (na verdade 12!) De Leaky Nun , a magia Regex está além de mim.

Isso é longo, mas não maior que a System.Windows.Forms.SystemInformation.PrimaryMonitorSizesolução horrenda

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

primeiro nós Get-WmiObject( gwmi) para recuperar o Win32_VideoControllerobjeto, que contém um membro chamado VideoModeDescription, que é uma string no formato de 1920 x 1080 x 4294967296 colors, então eu executo um regex replace para obter o formato correto.

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

Isso pode não funcionar para você, dependendo de quais dispositivos você conectou (não sei). Isso sempre deve funcionar (supondo que você tenha pelo menos uma tela conectada):

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

Explicação

SystemInformation[] retorna uma expressão do formulário

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

Estamos interessados "Devices", que podem ser acessados ​​diretamente como SystemInformation["Devices"]ou como SystemInformation[][[1,5,2]]. O resultado será uma lista do formulário

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

Queremos "ScreenInformation", que pode ser acessado de maneira SystemInformation["Devices","ScreenInformation"]mais ou mais sucinta SystemInformation[][[1,5,2,1,2]]. O resultado será da forma

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

O comprimento da lista será o número de telas que você conectou. A primeira tela é SystemInformation[][[1,5,2,1,2,1]]e a largura e a altura podem ser extraídas como SystemInformation[][[1,5,2,1,2,1,2,2,;;,2]]Então, basta inserir um Infix xpara o formato de saída.

Java 7, 123 114 bytes

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

Este método não funcionará em uma instalação decapitada de Java (como no TIO) porque usa as bibliotecas awt. Sob o capô, a chamada getScreenSizeusa a Java Native Interface para chamar (normalmente em uma biblioteca C) a largura e a altura da tela.

-9 bytes graças a Olivier Grégoire por me lembrar que eu posso retornar a string em vez de imprimi-la.

C #, 101 95 89 bytes

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

-6 bytes graças a @TheLethalCoder , lembrando-me de que o OP não mencionou sobre impressão, portanto, retornar uma string também é bom. E -6 bytes adicionais, alterando-o para um lambda.

Bash + xrandr, 44 caracteres

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

xrandrpertence ao servidor X, no Ubuntu é fornecido pelo pacote x11-xserver-utils .

Exemplo de execução:

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

Graças a:

• Software de marca para a expressão regular (-11 caracteres)

Exemplo de execução:

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)

Oitava , 41 bytes

Obrigado a @Arjun e @StephenS pelas correções.

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

0é um identificador para o objeto gráfico raiz. Sua propriedade 'ScreenSize'contém as coordenadas da tela em pixels. A terceira e quarta entradas fornecem as informações desejadas.

APL (Dyalog) , 23 bytes

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

⎕WG'DevCaps' W indow L et Dev gelo Tampão abilitie s

⊃ escolha a primeira propriedade (altura, largura)

⌽ marcha ré

⍕ formatar como texto

' '⎕R'x' R espaços EColoque com "x" s

Japt , 24 bytes

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

Teste online!

A sequência compactada representa with(screen)width+"x"+height. Oxavalia isso como JavaScript e o resultado é impresso implicitamente.

C (biblioteca SDL2) 113 88 84

(-4 caracteres devido à ajuda do @AppleShell)

Sim. compila.

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

Correr com : gcc snippet.c -lSDL2 && ./a.out

Python 2, 61 49 bytes

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

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

Para configurações de exibição única, isso corresponde à saída do site. Isso fornece resolução completa para vários monitores.

bash + xdpyinfo 42 31 bytes

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

Na página do manual:

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

@Floris @manatwork Obrigado por salvar alguns bytes!

xrandr + awk, 25 bytes

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

ZX Spectrum Basic, 10 bytes

apenas para completar:

PRINT "256x192"

saídas 256x192. O Spectrum possui uma resolução de tela fixa fixa.

Processando, 51 bytes

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

Isso gera neste formato: width height. Além disso, o programa cria uma janela com o tamanho da tela que você está usando (porque todos os programas de processamento criam uma janela por padrão) e esse programa apenas exibe a altura e a largura dessa janela / esboço.

xdpyinfo+ awk, 28 bytes

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

Testado em Cygwin com duas cabeças.

Tcl / Tk, 40

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

Lit , 116 bytes

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

(Quebras de linha adicionadas para facilitar a leitura)

Experimente online!

Finalmente, meu módulo html-toolkit é útil! Funciona apenas no link Experimente online, não funcionará na linha de comando.

Alguns bytes podem ser salvos se houver 1024 x 768saída válida. Nós apenas usamos (+ .. "x" .. )para evitar printo espaçamento implícito.

Lua (estrutura completa), 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

O programa muda primeiro para tela cheia, obtém a largura e a altura e as imprime :)

xrandr e sh, 23 bytes

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

Testado em uma caixa CentOS 5 com tela redirecionada para uma máquina Cygwin com dois monitores. Aqui a xrandrsaída total é

$ 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]

Solução alternativa (52 bytes):

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

Vermelho , 26 bytes

system/view/screens/1/size

Saídas por exemplo:

1920x1080

O código é bastante auto-explicativo. O 1refere-se à primeira tela