Dimensões do terminal de saída (colunas e linhas) em qualquer formato decimal de dois números *. Por exemplo, uma saída poderia ser 80x25.

^{Inspiração . Prompt .
_{* A saída deve ter as duas medidas em uma única ou duas linhas consecutivas e pode haver não mais do que uma linha de saída inicial e / ou final (opcionalmente seguida por uma nova linha). As (até quatro) linhas não devem ter mais que max (cols, 1 + len (str (cols)) + len (str (ro‌ ws))).}}

* sh, 9

stty size

Saída:

97 364

Código de máquina 8086, 11 bytes (em função, não concorrente)

Não é realmente competitivo, pois não possui saída visível. Isso está apenas mostrando a maneira mais curta de encontrar as dimensões atuais da tela, sem o código padrão necessário para a impressão.

00000000  6a 40 1f a0 84 00 40 8a  26 4a 00                 |j@....@.&J.|
0000000b

Como funciona:

6a 40           |   push 0x40       ; bios data segment
1f              |   pop ds
a0 84 00        |   mov al, [0x84]  ; console rows - 1
40              |   inc ax
8a 26 4a 00     |   mov ah, [0x4a]  ; console columns

Código de máquina 8086, 48 bytes (como um programa completo)

00000000  1f bf 30 01 a0 84 04 40  e8 1a 00 b0 78 aa a0 4a  |..0....@....x..J|
00000010  04 e8 11 00 8d 8d d0 fe  8d 75 ff 06 1f fd ac cd  |.........u......|
00000020  29 e2 fb cd 20 d4 0a 0c  30 aa c1 e8 08 75 f6 c3  |)... ...0....u..|
00000030

Como funciona:

                |   org 0x100
                |   use16
1f              |       pop ds              ; clear ds (the stack always contains 0 on entry)
bf 30 01        |       mov di, d           ; set destination ptr
a0 84 04        |       mov al, [0x484]     ; console rows - 1
40              |       inc ax
e8 1a 00        |       call to_ascii       ; convert to ascii
b0 78           |       mov al, 'x'
aa              |       stosb
a0 4a 04        |       mov al, [0x44a]     ; console columns
e8 11 00        |       call to_ascii
8d 8d d0 fe     |       lea cx, [di-d]      ; number of characters to print
8d 75 ff        |       lea si, [di-1]      ; set source ptr
06              |       push es
1f              |       pop ds
fd              |       std                 ; reverse direction flag
ac              |   @@: lodsb               ; load (al = *si--)
cd 29           |       int 0x29            ; print al to console, bypassing stdout
e2 fb           |       loop @b             ; repeat while (--cx != 0)
cd 20           |       int 0x20            ; terminate
                |   
                |   to_ascii:
d4 0a           |       aam 10              ; ah = (al / 10), al = (al % 10)
0c 30           |       or al, 0x30         ; convert al to ascii number
aa              |       stosb               ; store (*di++ = al)
c1 e8 08        |       shr ax, 8           ; shift ah to al
75 f6           |       jnz to_ascii        ; repeat if non-zero
c3              |       ret
                |   
                |   d rb 0

Bash, 22 20 caracteres

echo $COLUMNS $LINES

Graças a:

• Maçaneta para formato de saída ideal (2 caracteres)

Exemplo de execução:

bash-4.3$ echo $COLUMNS $LINES
80 24

xterm, 6 bytes

Como você não precisa de formato específico, pode simplesmente usar o resizecomando (6 caracteres) de xterm:

$ resize
COLUMNS=120;
LINES=31;
export COLUMNS LINES;

sh, 20 bytes

tput lines;tput cols

.. Muito óbvio, talvez ..

Python 3 , 30 bytes

import os
os.get_terminal_size

Como ele não funciona no TIO, uma alternativa é usada lá:

Experimente online!

C (somente Linux), 63 61

short m[4];main(){ioctl(0,21523,m);printf("%dx%d",*m,m[1]);}

APL (Dyalog) , 3 bytes

^{(Postar uma resposta já que esse realmente não é o meu desafio.)}

⎕SD S creen D imensions

Exemplo de execução:

      ⎕SD
25 79

C #, 59 bytes

using c=System.Console;_=>c.WindowWidth+"x"+c.WindowHeight;

Compila para a Func<int, string, no entanto, a entrada não é usada.

NodeJS, 50 48 46 bytes

> s=process.stdout;console.log(s.columns,s.rows)
80 25

Usos process.stdouts columnse rowsvalores.

Ruby, 41 36 21 + 13 = 34 bytes

Executar com o sinalizador de linha de comando -rio/console

p IO.console.winsize

Este é o meu primeiro golfe Ruby, então me diga se há algo que eu possa fazer melhor.

5 bytes economizados graças ao SztupY

2 bytes economizados graças ao manatwork

Isso gera altura e largura como uma lista de comprimento dois.

Exemplo de saída:

[25, 80]

GNU adiante, 7 bytes

form .s

form - urows ucols gforth "form"

O número de linhas e colunas no terminal.

Saída de amostra

<2> 24 80

Experimente Online!

C # 94 bytes (aplicativo inteiro)

A resposta completa do aplicativo MetaColon pode ser bastante reduzida:

using c=System.Console;class P{static void Main(){c.Write(c.WindowWidth+' '+c.WindowHeight);}}

Modo PowerShell +, 11 bytes?

A saída pode não ser aceitável na forma atual.

o modecomando é um utilitário padrão do Windows

Meta Post sobre o uso de modesem especificarcon

(mode)[3,4]

obtém a saída do modo:

<Whitespace>
Status for device CON:
----------------------
    Lines:          3000
    Columns:        120
    Keyboard rate:  31
    Keyboard delay: 1
    Code page:      850

então a quarta e a quinta linhas ( [3,4]) produzindo:

PS H:\> (mode)[3,4]
    Lines:          3000
    Columns:        120

Rápido, 99 bytes

import Foundation;var w=winsize();ioctl(STDOUT_FILENO,UInt(TIOCGWINSZ),&w);print(w.ws_col,w.ws_row)

Obrigado ao pessoal do Vapor pelo pacote do console .

Lote, 25 19 18 17 bytes

_{^{Economizou 6 bytes canalizando diretamente para o comando "find".
Economizou 1 byte graças a Adám / OP .
Guardado 1 byte graças a um comentário de OP .}}

mode con|find "n"

Isso gera o próprio comando, já que o eco está ativado, mas, como comentado pelo OP , uma linha inicial está OK.

_{Dependendo da sua configuração, ele pode funcionar com apenas 13 bytes. No entanto, parece que ter qualquer coisa usando portas COM causará saída excessivamente detalhada.}

mode|find "n"

C #, 85 bytes

()=>System.Console.Write(System.Console.WindowWidth+"x"+System.Console.WindowHeight);

Se você deseja um código de aplicativo completo, teríamos 115 101 94 bytes :

using C=System.Console;class P{static void Main()=>C.Write(C.WindowWidth+"x"+C.WindowHeight);}

No entanto, você também pode significar o tamanho do buffer , teríamos 85 bytes novamente

()=>System.Console.Write(System.Console.BufferWidth+"x"+System.Console.BufferHeight);

Ou como um código de aplicativo completo (obviamente 115 101 94 Bytes novamente):

using C=System.Console;class P{static void Main()=>C.Write(C.BufferWidth+"x"+C.BufferHeight);}

Economizou 14 bytes em todo o código do aplicativo com a ajuda de Caius Jard

Java 8 (sem bibliotecas), Windows, 270 bytes

Postagem separada por recomendação de Adam.

interface B{static void main(String[] a)throws Exception{Object[]r=new java.io.BufferedReader(new java.io.InputStreamReader(Runtime.getRuntime().exec("cmd /c mode").getInputStream())).lines().toArray();System.out.print(r[3]+"\n"+r[4]);}}

Ungolfed:

interface B {
    static void main(String[] a) throws Exception {
        Object[] r = new java.io.BufferedReader(new java.io.InputStreamReader(
                Runtime.getRuntime().exec("cmd /c mode").getInputStream())
        ).lines().toArray();
        System.out.print(r[3] + "\n" + r[4]);
    }
}

8 , 24 16 12 bytes

Revisado após o comentário de Anders Tornblad.

con:size? .s

Retorna o tamanho atual do console em linhas e colunas, imprimindo o conteúdo da pilha.

Saída:

2  n: 000000000285e5e0 1   300
1  n: 000000000285e4c0 1   90

Java + * nix, 113

interface B{static void main(String[] a)throws Exception{new ProcessBuilder("stty","size").inheritIO().start();}}

Ungolfed:

interface B{
    static void main(String[] a)throws Exception{
        new ProcessBuilder("stty","size").inheritIO().start();
    }
}

ProcessBuilder.inheritIOfaz com que uma entrada / saída do processo filho seja herdada; esse é o padrão em C com exec. Em Java, o padrão é "canalizado". Como você pode ver, isso é muito mais curto do que usar Runtime.getRuntime().exec()(que também é preterido) e construir uma BufferedReaderchamada longa e complicada que é o resultado da aparente falta de vontade dos designers da API Java de adicionar uma sobrecarga por conveniência.

Vermelho , 19 bytes

system/console/size

Saída:

>> system/console/size
== 106x26

Também pode obter a resolução da tela como na pergunta anterior

Commodore 64 BASIC, 7 bytes

?"40x25

O C64 possui um console de texto de tamanho fixo de 40 x 25 caracteres. Não é necessário consultar o tamanho do console, o que é uma coisa boa, pois não há como consultá-lo.

Kotlin + Jline 2 , 58 bytes

{print(jline.TerminalFactory.get().run{"$width $height"})}

Porque porque não? Acontece que a lib padrão, na verdade, não tem como determinar o tamanho do console, por isso é necessário puxar uma biblioteca, para que você não queira iniciar outro processo e analisar o fluxo de entrada ... seria uma pena se alguém fizesse isso.

Empilhados , 7 bytes

termdim

Deixa a saída na pilha, como é permitido por padrão. Exemplo de uso:

λ stacked -pe "termdim"
(117 26)

Bônus: termdim'x'#`tê-lo 117x26.

C (linux, somente C89), 45 41

inspirado por https://codegolf.stackexchange.com/a/118696/42186 por @dieter

main(m){ioctl(0,21523,&m);write(1,&m,4);}

isso gera o tamanho como dados binários. Não tenho certeza se isso conta como "qualquer formato". Você precisaria de algo extra (tabela hexdump, od, ascii) (ou um emulador de terminal esotérico que faça isso automaticamente para você) para torná-lo legível por humanos. Exemplo de uso:

$ ./a.out | od -sAn
     58    204

O tamanho do terminal é 204 cols por 58 linhas.

Obrigado a @ Random832 por usar em odvez de hexdump.