Un chaton ressemble beaucoup à un chat. Certaines des principales différences sont la gentillesse, le manque d’intelligence et la taille. De même, la catcommande est différente de la kittencommande. Heureusement, il n'y a qu'une seule différence dans ce cas. Dans la commande chaton, toutes les lettres majuscules sont remplacées par des lettres minuscules.

Objectif

Pour mettre en œuvre un programme qui se comporte de la même manière que cat. Tous les caractères [A-Z]sont en minuscule.

Contribution

Une liste de fichiers comme arguments de ligne de commande. Si aucun fichier n'est répertorié, lisez-le à partir de l'entrée standard. L'entrée peut contenir des caractères non imprimables et des caractères situés en dehors de la plage ASCII.

Sortie

Si l'entrée est un groupe de fichiers, concaténez le contenu et affichez tous les caractères en minuscule. Si vous lisez à partir de STDIN, indiquez le contenu de STDIN avec toutes les lettres majuscules en minuscule.

Remarque: Ne mettez que les caractères en [A-Z]minuscule. C'est inacceptable si d'autres caractères sont en minuscules.

Exemples

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

Comme d'habitude avec le code-golf , le moins d'octets gagne.

Classements

Voici un extrait de pile permettant de générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](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 octets

5 octets de code + 1 octet en ligne de commande

$_=lc

Exemple d'utilisation:

echo ABCdef | perl -p kitten.pl
abcdef

Confirmation du bon comportement Unicode:

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

Bash, 19 octets

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

La meilleure façon de faire des chatons est d'utiliser des chats réels.

Exemple d'exécution

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

Perl, 11 octets

10 octets de code + 1 octet en ligne de commande

y/A-Z/a-z/

Exemple d'utilisation:

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

Python 3, 77 octets

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

Ruby, 13 octets

Le nombre d'octets comprend 1 octet pour le pdrapeau. Exécuter comme ceci: ruby -p kitten.rb.

$_.downcase!

Accepte les arguments stdin ou file, comme un chat adulte.

PowerShell, 112 octets

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

Horriblement illisible. Voici une version légèrement développée ci-dessous:

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

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

Définit une fonction interne lqui itère sur une boucle de 97 à 112 (c.-à-d., ASCII aà ASCII z). Divise la chaîne d'entrée sur ce caractère (yay par défaut, insensible à la casse), le rejoint avec la minuscule "correcte". Notez que oui, cela signifie que "Test" deviendrait brièvement "T st", car il est itératif e, par exemple. N'affecte pas la sortie.

La seconde moitié est la partie la plus délicate pour déterminer si nous avons une entrée de pipeline (équivalente à stdin pour PowerShell) ou une entrée de ligne de commande. La variable spéciale $argsn’est présente que si une entrée de ligne de commande est présente, nous lançons donc une boucle sur chacune d’elles, gc(pour Get-Content) et schlep jusqu’à l. Autrement, nous ne ferons que $inputgrimper l. Notez que nous pourrions échanger nos instructions if / else (c'est-à-dire if($input)), mais comme "input" est un caractère plus long que "args", cette méthode est plus courte.

Python 2, 53 octets

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

R, 97 octets

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

Usage:

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

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)

Usage:

$ 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

Ma première participation sur codegolf alors ne soyez pas impoli :).

Bien sûr, ce code peut être joué plus souvent et café / javascript n'est pas le meilleur choix pour le faire, mais il fait ce qui est attendu.

Lorsqu'il lit les arguments, il prend également en compte l'existence du fichier (si le fichier n'existe pas, la chaîne est chatonée).

Toute aide ou conseil pour améliorer ce code est la bienvenue!

Julia, 123 octets

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 octets

ea_:gs{q}?'_,_eler

La liste des fichiers doit être fournie sous la forme d'URL, qui est le seul format que CJam comprend.

Exemple fonctionne

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

Comment ça fonctionne

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 octets

Fonctionnalité corrigée (et 4 octets ajoutés) par matsjoyce. Heureusement, j'ai économisé deux octets en passant à Python 2.

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

Prend des arguments à partir de la ligne de commande ou de STDIN si aucun argument n'a été trouvé.

Cela abuse des arguments par défaut de certaines fonctions. Par défaut, openutilise le mode texte en lecture seule, ce qui est exactement ce que nous voulons. read, si appelé sans arguments, renverra tout le texte du flux.

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 octets

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 mange des chatons!

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

C, 106 108 octets

Edit: Correction d'une erreur qui se glissait lorsque l'on compressait des octets. Stdin ne fonctionnait pas, maintenant ça l'est.

Je suis sûr que je pourrais gagner quelques octets, mais voici une soumission facile à comprendre, pas du tout abusive de la langue:

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);}

Et une version un peu plus proprement formatée pour la lecture:

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 octets

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

Appelé comme

kit@"HelLo"

Mathematica a déjà une ToLowerCasefonction, mais convertit également des caractères spéciaux (Unicode et mathématiques). Alors j'ai dû le chatoniser. Cette fonction prendra n'importe quelle entrée.

C #, 230 226 octets

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<'[']

Le traitement des arguments de type chat est dérivé de ce didacticiel , puis réorganisé pour raser les personnages.

Expliquant l, la fonction pour mettre en minuscule un caractère:

• sum[32|condition]est une forme plus courte de if condition then 32 else 0.
• [x..]!!countis iterate succ x !! countis toEnum $ fromEnum x + countet est plus court que l'importation et l'utilisation Data.Char.toLoweravec une condition pour la limiter à ASCII.
• '@'et '['sont les caractères précédant Aet suivant immédiatement Z, afin que je puisse utiliser à la <place de <=.

Merci à Anders Kaseorg pour ses contributions sum[...|...]et [x..]!!astuces.

C #, 342 octets

• prend la liste des fichiers des arguments passés.
• lit chaque caractère dans chaque fichier que seulement convertit en minuscule si et seulement si le caractère dans la plage A..Z l'envoie ensuite à STDOUT.
• S'il n'y a pas de liste de fichiers qui lit STDIN, lit chaque caractère, convertit en minuscule si et seulement si le caractère de la plage A..Z l'envoie à 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 octets

monocouche, comme ci-dessus:

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 caractères

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

N'hésitez pas à essayer ce code en ligne!

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

C, 91 octets

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

C, 98 octets

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

Bien que si la lisibilité importait plus que le nombre d'octets, la même logique est écrite ci-dessous:

#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 octets

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

Courez avec env -i sed -f kitten.sed.

Java, 198 octets

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;};

Vous êtes obligé d'utiliser le lambda ci-dessus avec des fichiers, vous n'avez donc pas besoin de prendre l'entrée de STDIN! En outre, c'est un Function<File[], UnaryOperator<String>>. C'est utilisé comme foo.apply(anArrayOfFiles).apply(anything).

Pour les nouveaux utilisateurs de Java, cela prend plus de 223 octets:

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;}

Comme quelque chose qui compile, cela prend 232 octets:

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;}}