Um gatinho é muito parecido com um gato. Algumas das principais diferenças são fofura, falta de inteligência e tamanho. Da mesma forma, o catcomando é diferente do kittencomando. Felizmente, há apenas uma diferença neste caso. No comando kitten, todas as letras maiúsculas são substituídas por letras minúsculas.

Objetivo

Para implementar um programa que se comporta de maneira semelhante a cat. Todos os caracteres [A-Z]são emitidos em minúsculas.

Entrada

Uma lista de arquivos como argumentos de linha de comando. Se nenhum arquivo estiver listado, leia a partir da entrada padrão. A entrada pode conter caracteres não imprimíveis e caracteres fora do intervalo ASCII.

Resultado

Se a entrada for um monte de arquivos, concatene o conteúdo e produza todos os caracteres em minúsculas. Se estiver lendo STDIN, imprima o conteúdo de STDIN com todas as letras maiúsculas em minúsculas.

Nota: apenas coloque os caracteres em [A-Z]minúsculas. É inaceitável se outros caracteres forem minúsculos.

Exemplos

$ echo "HelLo" > file.txt
$ kitten file.txt
hello
$ echo "Good Bye" | kitten
good bye
$ echo "Ä" | kitten
Ä

Como de costume no code-golf , o mínimo de bytes vence.

Classificação

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

# Perl, 43 + 2 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=59029,OVERRIDE_USER=32700;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Perl, 6 bytes

Código de 5 bytes + linha de comando de 1 byte

$_=lc

Exemplo de uso:

echo ABCdef | perl -p kitten.pl
abcdef

Confirmação do comportamento correto do Unicode:

echo "HelloÉ" | perl -p kitten.pl
helloÉ

Bash, 19 bytes

cat "$@"|tr A-Z a-z

A melhor maneira de fazer gatinhos é usar gatos de verdade.

Exemplo de execução

$ ./kitten kitten
cat "$@"|tr a-z a-z

Perl, 11 bytes

Código de 10 bytes + linha de comando de 1 byte

y/A-Z/a-z/

Exemplo de uso:

perl -p entry.pl input1.txt input2.txt
echo "ABCdef" | perl -p entry.pl

Python 3, 77 bytes

from fileinput import*
print(end=b''.join(input(mode='rb')).lower().decode())

Ruby, 13 bytes

A contagem de bytes inclui 1 byte para o psinalizador. Executá-lo assim: ruby -p kitten.rb.

$_.downcase!

Recebe informações dos argumentos stdin ou file, assim como o gato adulto.

PowerShell, 112 bytes

function l([string]$a){97..122|%{[char]$b=$_;$a=$a-split$b-join$b};$a}if($args){$args|%{l(gc $_)}}else{l $input}

Horrivelmente ilegível. Aqui está uma versão ligeiramente expandida abaixo:

function l([string]$a){
  97..122|%{
    [char]$b=$_
    $a=$a-split$b-join$b
  }
  $a
}

if($args){
  $args|%{
    l(gc $_)
  }
}
else{
  l $input
}

Define uma função interna lque itera sobre um loop de 97 a 112 (ou seja, ASCII apara ASCII z). Divide a sequência de entrada sobre esse caractere (padrão sem distinção entre maiúsculas e minúsculas) e a junta novamente com a minúscula "correta". Observe que sim, isso significa que "Teste" se tornará brevemente "T st", pois está iterando no e, por exemplo. Não afeta a saída.

A segunda metade é a parte complicada de descobrir se temos entrada de pipeline (equivalente a stdin para PowerShell) ou entrada de linha de comando. A variável especial $argsestá presente apenas se a entrada da linha de comandos estiver presente; portanto, fazemos um loop sobre cada uma delas gc(para Get-Content) e as reduzimos até l. Caso contrário, nós apenas schlep nossa $inputaté l. Observe que poderíamos trocar nossas instruções if / else (ou seja, if($input)), mas como "input" é um caractere mais longo que "args", dessa maneira é mais curto.

Python 2, 53 bytes

from fileinput import*
print''.join(input()).lower(),

R, 97 bytes

cat(chartr("A-Z","a-z",sapply(if(length(a<-commandArgs(T))){a}else{"stdin"},readLines)),sep="\n")

Uso:

$ echo "HeLlo" > file.txt
$ Rscript kitten.R file.txt
hello
$ echo "Good Bye" | Rscript kitten.R
good bye
$ echo "bLABLa" > file2.txt
$ Rscript kitten.R file.txt file2.txt
hello
blabla
$ echo Ä | Rscript kitten.R
Ä

CoffeeScript , 292 bytes

f=require 'fs';d='';p=process;v=p.argv;s=p.stdin;l=((d)=>console.log d.replace /([A-Z])/g,(a,l)=>l.toLowerCase());if v.length>2 then(v.forEach (v,i)=>if i>1 then(f.exists v, (e) =>if e then(f.readFile v,'utf-8',(r,d)=>l d) else l v))else(s.resume();(s.on 'data',(c)=>d+=c);s.on 'end',()=>l d)

Uso:

$ echo "HelLo" > file.txt
$ coffee kitten.coffee file.txt
hello
$ echo "Good Bye" | coffee kitten.coffee
good bye
$ echo "Ä" | kitten
Ä
$ coffee kitten.coffee file.txt SoMeTeXt
sometext
hello

Minha primeira participação no codegolf, por favor, não seja rude :).

Com certeza, esse código pode ser jogado mais e o café / javascript não é a melhor opção para fazer isso, mas faz o que é esperado.

Quando ele lê argumentos, também se preocupa com a existência do arquivo (se o arquivo não existir, a sequência será criada).

Qualquer ajuda ou conselho para melhorar esse código é bem-vinda!

Julia, 123 bytes

f(s)=for l=readlines(s) print(replace(l,r"[A-Z]",lowercase))end
A=ARGS
length(A)>0?for i=A open(f,i)end:open(f,readline())

Ungolfed:

function file_to_lower(s::Stream)
    # Loop over the lines of the input stream
    for l in readlines(r)
        # Print the lowercased line
        print(replace(l, r"[A-Z]", lowercase))
    end
end

if length(ARGS) > 0
    # Loop over the files specified from the command line
    for i in ARGS
        # Open the file, apply the function, then close it
        open(file_to_lower, i)
    end
else
    # Get the input file from STDIN
    open(file_to_lower, readline())
end

CJam, 18 bytes

ea_:gs{q}?'_,_eler

A lista de arquivos deve ser fornecida na forma de URLs, que é o único formato que o CJam entende.

Execuções de exemplo

$ cjam kitten <<< "AaÁáÄä"
aaÁáÄä
$ cjam kitten file:///home/dennis/kitten file:///home/dennis/kitten
ea_:gs{q}?'_,_elerea_:gs{q}?'_,_eler

Como funciona

ea                  Push the array of command-line arguments.
  _                 Push a copy.
   :g               Retrieve the contents of all files with those URLS.
     s              Flatten the resulting array of strings.
      {q}           Push a block that reads all input from STDIN.
         ?          Select the string of the array of args is non-empty.
                    Otherwise, execute the code block.
          '_,       Push the string of all ASCII characters before _.
             _el    Push a copy and convert it to lowercase.
                er  Perform transliteration.

Python 2, 100 102 97 bytes

Funcionalidade corrigida (e 4 bytes adicionados) pelo matsjoyce. Felizmente, salvei dois bytes mudando para o Python 2.

from sys import*;print''.join(f.read().lower()for f in(map(open,argv[1:])if argv[1:]else[stdin]))

Recebe argumentos da linha de comando ou de STDIN se nenhum argumento foi encontrado.

Isso abusa dos argumentos padrão de algumas funções. Por padrão, openusa o modo de texto somente leitura, que é exatamente o que queremos. read, se chamado sem argumentos, retornará todo o texto no fluxo.

Ungolfed:

import sys

if len(sys.argv) > 1:              # If we have command-line arguments:
    source = []                    # Initialize an empty list
    for path in sys.argv[1:]:      # Iterate through every filename we have
        kitfile = open(path, 'rt') # Open the file in read-only text mode
        source.append(kitfile)     # Add it to the list
else:                              # Otherwise, if the args are empty:
    source = [sys.stdin]           # Set our source to STDIN wrapped in a list

kittened = []                      # Initialize an empty list
for kitfile in source:             # Iterate through every file (or just STDIN)
    text = kitfile.read()          # Read everything from the stream
    kitten_text = text.lower()     # Make it lowercase
    kittened.append(kitten_text)   # Add it to the list
final = ''.join(kittened)          # Join everything together
print final                        # Print the result

Python 3, 124 123 bytes

from sys import*
for f in list(map(open,argv[1:]))or[stdin]:print(f.read().translate({i:i+32for i in range(65,91)}),end="")

Python come gatinhos!

$ python kitten.py file.txt
hello
$ echo "Good Bye" | python kitten.py 
good bye
$ echo "Ä" | python kitten.py 
Ä

C, 106 108 bytes

Editar: corrigido um erro que aparecia ao espremer bytes. Stdin não estava trabalhando, agora está.

Tenho certeza de que conseguiria extrair alguns bytes, mas aqui está um envio fácil de entender, que não é abusivo em nenhum idioma:

main(n,s,f,c)void**s;{for(f=n-1?open(*++s,0,0):0;read(f,&c,1);putchar(64<c&c<91?c+32:c));n-->2&&main(n,s);}

E uma versão um pouco mais ordenada para leitura:

main(n,s,f,c)
void**s;
{
    for(f=n-1?open(*++s,0,0):0; read(f,&c,1); putchar(64<c&c<91?c+32:c));
    n-->2&&main(n,s);
}

Mathematica, 66 bytes

kit=StringReplace[#,x:RegularExpression["[A-Z]"]:>ToLowerCase[x]]&

Chamado como

kit@"HelLo"

O Mathematica já possui uma ToLowerCasefunção, mas também converte caracteres especiais (Unicode e matemáticos). Então eu tive que gatinhar. Esta função aceita qualquer entrada.

C #, 230 226 bytes

namespace System{using Linq;class P{static void Main(string[]a){Console.Write(string.Concat((a.Length>0?string.Concat(a.Select(f=>IO.File.ReadAllText(f))):Console.In.ReadToEnd()).Select(c=>c>'@'&&c<'['?char.ToLower(c):c)));}}}

Ungolfed:

namespace System
{
    using Linq;
    class P
    {
        static void Main(string[] a)
        {
            Console.Write(                                                  // Print...
                string.Concat(                                                  // ...all chars combined to a string...
                    (a.Length > 0 ?                                             // ...commandline arguments?...
                        string.Concat(a.Select(f => IO.File.ReadAllText(f))) :  // ...then all files as single string...
                        Console.In.ReadToEnd()                                  // ...else STDIN input
                    ).Select(c => c > '@' && c < '[' ? char.ToLower(c) : c)     // ...Lowercase only A..Z
                )
            );  
        }
    }
}

Haskell, 133

import System.Environment
main=getArgs>>=mapM_(>>=putStr.map l).f
f[]=[getContents]
f n=map readFile n
l x=[x..]!!sum[32|x>'@',x<'[']

O processamento de args no estilo de gato é derivado deste tutorial e , em seguida, reorganizado para barbear caracteres.

Explicando l, a função para minúsculas um caractere:

• sum[32|condition]é uma forma mais curta de if condition then 32 else 0.
• [x..]!!counté iterate succ x !! countis toEnum $ fromEnum x + counte menor que a importação e o uso Data.Char.toLowercom uma condição para restringi-lo ao ASCII.
• '@'e '['são os caracteres imediatamente anteriores Ae seguintes Z, para que eu possa usar em <vez de <=.

Graças ao Anders Kaseorg para contribuir o sum[...|...]e [x..]!!truques.

C #, 342 bytes

• pega a lista de arquivos dos argumentos passados.
• leia todos os caracteres em todos os arquivos que só serão convertidos em letras minúsculas se, e somente se, o caractere no intervalo A..Z o enviar para STDOUT.
• Se não houver uma lista de arquivos que leia STDIN, leia todos os caracteres, converta em letras minúsculas se e somente se o caractere no intervalo A..Z for enviado para STDOUT.

namespace System{
using IO;
using Linq;
class P{
static void Main(string[]a){
Action<char>e=C=>{var c=char.ToLower(C);Console.Out.Write(c>='a'&&c<='z'?c:C);};
if(a.Length>0)a.ToList().ForEach(f=>File.ReadAllText(f).ToCharArray().ToList().ForEach(e));
else 
while(true) Console.In.ReadLine().ToCharArray().ToList().ForEach(e);
}
}
}

C #, 319 bytes

forro único, o mesmo que acima:

namespace System{using IO;using Linq;class P{static void Main(string[]a){Action<char>e=C=>{var c=char.ToLower(C);Console.Out.Write(c>='a'&&c<='z'?c:C);};if(a.Length>0)a.ToList().ForEach(f=>File.ReadAllText(f).ToCharArray().ToList().ForEach(e));else while(true)Console.In.ReadLine().ToCharArray().ToList().ForEach(e);}}}

SILOS 179 caracteres

loadLine :
a = 256
x = get a
lbla
X = x
B = x
C = 91
B - 64
if B c
printChar x
GOTO x
lblc
C - x
if C D
printChar x
GOTO x
lblD
x + 32
printChar x
lblx
a + 1
x = get a
if x a
lblb

Sinta-se livre para experimentar este código online!

String input = input();
for(char c in input)
if(c is uppercase) print c + 32/*lowercase c*/else print c

C, 91 bytes

#include <stdio.h>
main(){int c;while(EOF!=(c=getc(stdin))){c=tolower(c);putc(c,stdout);}}

C, 98 bytes

#include <stdio.h>
main(){int c;while(EOF!=(c=getc(stdin))){if(c>64&&c<91)c+=32;putc(c,stdout);}}

Embora a legibilidade tenha mais do que bytes contados, a mesma lógica está escrita abaixo:

#include <stdio.h>
main()
{
int c;
        while (EOF != (c = getc(stdin))) {
                if ((c >= 'A') && ((c <= 'Z')))
                        c = (c - 'A') + 'a';
                putc(c,stdout);
        }
}

sed, 14 bytes

s/[A-Z]/\L\0/g

Corra com env -i sed -f kitten.sed.

Java, 198 bytes

b->B->{B="";for(java.io.File c:b)B+=new java.util.Scanner(c).useDelimiter("\\Z").next();for(int c=0;c++<B.length;)if(B.charAt(c)>64&B.charAt(c)<91)B=B.replace(B.charAt(c),B.charAt(c)|32);return B;};

Você é forçado a usar o lambda acima com arquivos, portanto, não há necessidade de receber informações do STDIN! Além disso, é um Function<File[], UnaryOperator<String>>. É usado como foo.apply(anArrayOfFiles).apply(anything).

Como algo que faz mais sentido para quem é novo em Java, são necessários 223 bytes:

String A(java.io.File[]b){String B="";for(java.io.File c:b)B+=new java.util.Scanner(c).useDelimiter("\\Z").next();for(int c=0;c++<B.length;)if(B.charAt(c)>64&B.charAt(c)<91)B=B.replace(B.charAt(c),B.charAt(c)|32);return B;}

Como algo que compila, ocupa 232 bytes:

class a{String A(java.io.File[]b){String B="";for(java.io.File c:b)B+=new java.util.Scanner(c).useDelimiter("\\Z").next();for(int c=0;c++<B.length;)if(B.charAt(c)>64&B.charAt(c)<91)B=B.replace(B.charAt(c),B.charAt(c)|32);return B;}}