Imprime tudo, exceto as três primeiras colunas

Muito complicado:

awk '{print " "$4" "$5" "$6" "$7" "$8" "$9" "$10" "$11" "$12" "$13}' things

Uma solução que não adiciona espaço em branco extra à esquerda ou à direita :

awk '{ for(i=4; i<NF; i++) printf "%s",$i OFS; if(NF) printf "%s",$NF; printf ORS}'

### Example ###
$ echo '1 2 3 4 5 6 7' |
  awk '{for(i=4;i<NF;i++)printf"%s",$i OFS;if(NF)printf"%s",$NF;printf ORS}' |
  tr ' ' '-'
4-5-6-7

Sudo_O propõe uma melhoria elegante usando o operador ternárioNF?ORS:OFS

$ echo '1 2 3 4 5 6 7' |
  awk '{ for(i=4; i<=NF; i++) printf "%s",$i (i==NF?ORS:OFS) }' |
  tr ' ' '-'
4-5-6-7

EdMorton oferece uma solução que preserva os espaços em branco originais entre os campos:

$ echo '1   2 3 4   5    6 7' |
  awk '{ sub(/([^ ]+ +){3}/,"") }1' |
  tr ' ' '-'
4---5----6-7

BinaryZebra também oferece duas soluções impressionantes:
^{(essas soluções preservam até mesmo espaços à direita da string original)}

$ echo -e ' 1   2\t \t3     4   5   6 7 \t 8\t ' |
  awk -v n=3 '{ for ( i=1; i<=n; i++) { sub("^["FS"]*[^"FS"]+["FS"]+","",$0);} } 1 ' |
  sed 's/ /./g;s/\t/->/g;s/^/"/;s/$/"/'
"4...5...6.7.->.8->."

$ echo -e ' 1   2\t \t3     4   5   6 7 \t 8\t ' |
  awk -v n=3 '{ print gensub("["FS"]*([^"FS"]+["FS"]+){"n"}","",1); }' |
  sed 's/ /./g;s/\t/->/g;s/^/"/;s/$/"/'
"4...5...6.7.->.8->."

A solução dada por larsr nos comentários é quase correta:

$ echo '1 2 3 4 5 6 7' | 
  awk '{for (i=3;i<=NF;i++) $(i-2)=$i; NF=NF-2; print $0}' | tr  ' ' '-'
3-4-5-6-7

Esta é a versão fixa e parametrizada da solução larsr :

$ echo '1 2 3 4 5 6 7' | 
  awk '{for(i=n;i<=NF;i++)$(i-(n-1))=$i;NF=NF-(n-1);print $0}' n=4 | tr ' ' '-'
4-5-6-7

Todas as outras respostas antes de setembro de 2013 são boas, mas adicione espaços extras:

• Exemplo de resposta adicionando espaços iniciais extras :

  $ echo '1 2 3 4 5 6 7' | 
    awk '{$1=$2=$3=""}1' | 
    tr  ' ' '-'
  ---4-5-6-7

• Exemplo de resposta adicionando espaço extra

  $ echo '1 2 3 4 5 6 7' | 
    awk '{for(i=4;i<=13;i++)printf "%s ",$i;printf "\n"}' | 
    tr ' ' '-'
  4-5-6-7-------

awk '{for(i=1;i<4;i++) $i="";print}' file

usar corte

$ cut -f4-13 file

ou se você insiste em awk e $ 13 é o último campo

$ awk '{$1=$2=$3="";print}' file

outro

$ awk '{for(i=4;i<=13;i++)printf "%s ",$i;printf "\n"}' file

Experimente isto:

awk '{ $1=""; $2=""; $3=""; print $0 }'

A maneira correta de fazer isso é com um intervalo RE, porque ele permite que você simplesmente informe quantos campos devem ser ignorados e retém o espaçamento entre campos para os campos restantes.

por exemplo, para pular os 3 primeiros campos sem afetar o espaçamento entre os campos restantes, dado o formato de entrada que parecemos estar discutindo nesta questão é simplesmente:

$ echo '1   2 3 4   5    6' |
awk '{sub(/([^ ]+ +){3}/,"")}1'
4   5    6

Se você deseja acomodar espaços à esquerda e não em branco, mas novamente com o FS padrão, é:

$ echo '  1   2 3 4   5    6' |
awk '{sub(/[[:space:]]*([^[:space:]]+[[:space:]]+){3}/,"")}1'
4   5    6

Se você tem um FS que é um RE que você não pode negar em um conjunto de caracteres, você pode convertê-lo em um único caractere primeiro (RS é ideal se for um único caractere, pois um RS NÃO PODE aparecer dentro de um campo, caso contrário, considere SUBSEP), em seguida, aplique a substituição do intervalo de RE e, em seguida, converta para o OFS. por exemplo, se cadeias de "." s separassem os campos:

$ echo '1...2.3.4...5....6' |
awk -F'[.]+' '{gsub(FS,RS);sub("([^"RS"]+["RS"]+){3}","");gsub(RS,OFS)}1'
4 5 6

Obviamente, se OFS é um único caractere E não pode aparecer nos campos de entrada, você pode reduzir isso para:

$ echo '1...2.3.4...5....6' |
awk -F'[.]+' '{gsub(FS,OFS); sub("([^"OFS"]+["OFS"]+){3}","")}1'
4 5 6

Então você tem o mesmo problema que com todas as soluções baseadas em loop que reatribuem os campos - os FSs são convertidos em OFSs. Se isso for um problema, você precisa examinar a função patsplit () do GNU awks.

Quase todas as respostas adicionam espaços iniciais, espaços finais ou algum outro problema de separação. Para selecionar a partir do quarto campo onde o separador é um espaço em branco e o separador de saída é um único espaço, usando awkseria:

awk '{for(i=4;i<=NF;i++)printf "%s",$i (i==NF?ORS:OFS)}' file

Para parametrizar o campo inicial, você pode fazer:

awk '{for(i=n;i<=NF;i++)printf "%s",$i (i==NF?ORS:OFS)}' n=4 file

E também o campo final:

awk '{for(i=n;i<=m=(m>NF?NF:m);i++)printf "%s",$i (i==m?ORS:OFS)}' n=4 m=10 file

awk '{$1=$2=$3="";$0=$0;$1=$1}1'

Entrada

1 2 3 4 5 6 7

Resultado

4 5 6 7

echo 1 2 3 4 5| awk '{ for (i=3; i<=NF; i++) print $i }'

Outra maneira de evitar o uso da instrução de impressão:

 $ awk '{$1=$2=$3=""}sub("^"FS"*","")' file

No awk, quando uma condição é verdadeira, imprimir é a ação padrão.

Não acredito que ninguém ofereceu uma casca simples:

while read -r a b c d; do echo "$d"; done < file

As opções 1 a 3 apresentam problemas com vários espaços em branco (mas são simples). Essa é a razão para desenvolver as opções 4 e 5, que processam vários espaços em branco sem nenhum problema. Obviamente, se as opções 4 ou 5 forem usadas com n=0ambas, os espaços em branco à esquerda serão preservados, o que n=0significa que não haverá divisão.

Opção 1

Uma solução de corte simples (funciona com delimitadores simples):

$ echo '1 2 3 4 5 6 7 8' | cut -d' ' -f4-
4 5 6 7 8

opção 2

Forçar um recálculo do awk às vezes resolve o problema (funciona com algumas versões do awk) de espaços iniciais adicionados:

$ echo '1 2 3 4 5 6 7 8' | awk '{ $1=$2=$3="";$0=$0;} NF=NF'
4 5 6 7 8

Opção 3

Imprimir cada campo formatado com printfdará mais controle:

$ echo '    1    2  3     4   5   6 7     8  ' |
  awk -v n=3 '{ for (i=n+1; i<=NF; i++){printf("%s%s",$i,i==NF?RS:OFS);} }'
4 5 6 7 8

No entanto, todas as respostas anteriores alteram todos os FS entre os campos para OFS. Vamos construir algumas soluções para isso.

Opção 4

Um loop com sub para remover campos e delimitadores é mais portátil e não aciona uma mudança de FS para OFS:

$ echo '    1    2  3     4   5   6 7     8  ' |
awk -v n=3 '{ for(i=1;i<=n;i++) { sub("^["FS"]*[^"FS"]+["FS"]+","",$0);} } 1 '
4   5   6 7     8

NOTA: O "^ [" FS "] *" é para aceitar uma entrada com espaços à esquerda.

Opção 5

É bem possível construir uma solução que não adicione espaços em branco extras à esquerda ou à direita e preserve os espaços em branco existentes usando a função gensubdo GNU awk, como este:

$ echo '    1    2  3     4   5   6 7     8  ' |
awk -v n=3 '{ print gensub("["FS"]*([^"FS"]+["FS"]+){"n"}","",1); }'
4   5   6 7     8 

Também pode ser usado para trocar uma lista de campos dada uma contagem n:

$ echo '    1    2  3     4   5   6 7     8  ' |
  awk -v n=3 '{ a=gensub("["FS"]*([^"FS"]+["FS"]+){"n"}","",1);
                b=gensub("^(.*)("a")","\\1",1);
                print "|"a"|","!"b"!";
               }'
|4   5   6 7     8  | !    1    2  3     !

Obviamente, nesse caso, o OFS é usado para separar as duas partes da linha e o espaço em branco posterior dos campos ainda é impresso.

Nota1: ["FS"]* é usado para permitir espaços à esquerda na linha de entrada.

Cut tem um sinalizador --complement que torna mais fácil (e rápido) excluir colunas. A sintaxe resultante é análoga ao que você deseja fazer - tornando a solução mais fácil de ler / entender. O complemento também funciona para o caso em que você deseja excluir colunas não contíguas.

$ foo='1 2 3 %s 5 6 7'
$ echo "$foo" | cut --complement -d' ' -f1-3
%s 5 6 7
$

Solução Perl que não adiciona espaços em branco à esquerda ou à direita:

perl -lane 'splice @F,0,3; print join " ",@F' file

O @Farray perl autosplit começa no índice 0enquanto os campos awk começam com$1

Solução Perl para dados delimitados por vírgulas:

perl -F, -lane 'splice @F,0,3; print join ",",@F' file

Solução Python:

python -c "import sys;[sys.stdout.write(' '.join(line.split()[3:]) + '\n') for line in sys.stdin]" < file

Para mim, a solução mais compacta e compatível com o pedido é

$ a='1   2\t \t3     4   5   6 7 \t 8\t '; 
$ echo -e "$a" | awk -v n=3 '{while (i<n) {i++; sub($1 FS"*", "")}; print $0}'

E se você tiver mais linhas para processar, como por exemplo o arquivo foo.txt , não se esqueça de redefinir i para 0:

$ awk -v n=3 '{i=0; while (i<n) {i++; sub($1 FS"*", "")}; print $0}' foo.txt

Obrigado ao seu fórum.

Como fiquei aborrecido com a primeira resposta muito votada, mas errada, encontrei o suficiente para escrever uma resposta lá, e aqui as respostas erradas estão marcadas como tal, aqui está a minha parte. Não gosto de soluções propostas, pois não vejo razão para tornar a resposta tão complexa.

Eu tenho um log onde depois de $ 5 com um endereço IP pode haver mais texto ou nenhum texto. Preciso de tudo, desde o endereço IP até o final da linha, caso haja algo depois de $ 5. No meu caso, isso está na verdade em um programa awk, não em um awk oneliner, então o awk deve resolver o problema. Quando tento remover os primeiros 4 campos usando a resposta antiga, de boa aparência e mais votada, mas completamente errada:

echo "  7 27.10.16. Thu 11:57:18 37.244.182.218 one two three" | awk '{$1=$2=$3=$4=""; printf "[%s]\n", $0}'

ele cospe uma resposta errada e inútil (acrescentei [] para demonstrar):

[    37.244.182.218 one two three]

Em vez disso, se as colunas têm largura fixa até o ponto de corte e o awk é necessário, a resposta correta e bastante simples é:

echo "  7 27.10.16. Thu 11:57:18 37.244.182.218 one two three" | awk '{printf "[%s]\n", substr($0,28)}'

que produz a saída desejada:

[37.244.182.218 one two three]

Encontrei essa outra possibilidade, talvez possa ser útil também ...

awk 'BEGIN {OFS=ORS="\t" }; {for(i=1; i<14; i++) print $i " "; print $NF "\n" }' your_file

_{^{Nota: 1. Para dados tabulares e da coluna $ 1 a $ 14}}

Use corte:

cut -d <The character between characters> -f <number of first column>,<number of last column> <file name>

por exemplo: se você file1contém:car.is.nice.equal.bmw

Executar: cut -d . -f1,3 file1 irá imprimircar.is.nice

Isso não está muito longe de algumas das respostas anteriores, mas resolve alguns problemas:

cols.sh:

#!/bin/bash
awk -v s=$1 '{for(i=s; i<=NF;i++) printf "%-5s", $i; print "" }'

Que você agora pode chamar com um argumento que será a coluna inicial:

$ echo "1 2 3 4 5 6 7 8 9 10 11 12 13 14" | ./cols.sh 3 
3    4    5    6    7    8    9    10   11   12   13   14

Ou:

$ echo "1 2 3 4 5 6 7 8 9 10 11 12 13 14" | ./cols.sh 7 
7    8    9    10   11   12   13   14

Este é indexado 1; se você preferir indexação zero, use i=s + 1.

Além disso, se você gostaria de ter argumentos para o índice inicial e índice final, altere o arquivo para:

#!/bin/bash
awk -v s=$1 -v e=$2 '{for(i=s; i<=e;i++) printf "%-5s", $i; print "" }'

Por exemplo:

$ echo "1 2 3 4 5 6 7 8 9 10 11 12 13 14" | ./cols.sh 7 9 
7    8    9

O %-5salinha o resultado como colunas de 5 caracteres de largura; se isso não for suficiente, aumente o número ou use %s(com um espaço) se você não se importar com o alinhamento.

Solução baseada em AWK printf que evita% problema e é única por não retornar nada (nenhum caractere de retorno) se houver menos de 4 colunas para imprimir:

awk 'NF > 3 { for(i=4; i<NF; i++) printf("%s ", $(i)); print $(i) }'

Teste:

$ x='1 2 3 %s 4 5 6'
$ echo "$x" | awk 'NF > 3 { for(i=4; i<NF; i++) printf("%s ", $(i)); print $(i) }'
%s 4 5 6
$ x='1 2 3'
$ echo "$x" | awk 'NF > 3 { for(i=4; i<NF; i++) printf("%s ", $(i)); print $(i) }'
$ x='1 2 3 '
$ echo "$x" | awk 'NF > 3 { for(i=4; i<NF; i++) printf("%s ", $(i)); print $(i) }'
$