La commande chaton

65

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

Afficher l'extrait de code

code-golf  string  file-system 
— Le numéro un
source
2
En indiquant explicitement "N'inscrivez que les caractères en [A-Z]minuscules" anticipez-vous l'entrée Unicode?
— AdmBorkBork
2
@TimmyD Oui, mais c'est principalement pour empêcher les gens d'utiliser des fonctions intégrées en minuscules.
— TheNumberOne
3
@FryAmTheEggman permalien
— Dennis
1
Que diriez - vous Ü, Ñet les goûts?
— Mât
2
C'est si agréable de ne pas voir de Pyth du tout dans un codegolf ...
— jmm

Réponses:

52

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É
— steve
source
2
Êtes-vous sûr que cela n'affecte pas les caractères Unicode?
— Martin Ender
7
@ MartinBüttner Ce n'est pas le cas . Nous sommes dans la catégorie «sinon» ici: «Les règles ASCII sont utilisées pour le changement de cas. La minuscule de tout caractère en dehors de la plage ASCII est le caractère lui-même. ”Mon +1 pour la réponse.
— xebtl
178

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
— Dennis
source
39
Le bon outil pour le travail.
— Digital Trauma
120
+1 pour n'avoir besoin que d'un chat pour faire un chaton, me prend toujours deux chats
— SnoringFrog
4
Cela me rappelle ces man womanblagues…
— xebtl
2
+1 pour avoir opté pour le clonage de chat plutôt que comme méthode d'accouplement pour créer une progéniture
— MD-Tech
25
@ SnoringFrog Il a frappé l'autre.
— TheNumberOne
22

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
— Jarmex
source
15

Python 3, 77 octets

from fileinput import*
print(end=b''.join(input(mode='rb')).lower().decode())
— Anders Kaseorg
source
1
C'est intelligent, en utilisant des octets pour éviter les changements non-ASCII.
— matsjoyce
11

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.

— Daniero
source
Est-ce que cela ne minimise que l’ASCII ou d’autres personnages Ä?
— Paŭlo Ebermann le
1
@ PaŭloEbermann: Je viens de le tester: echo "HelloÉ" | ruby -p kitten.rb->helloÉ
— Neil Slater le
Je jure qu'il y a eu tout un tas de commentaires à ce sujet hier. Je ne sais pas où ceux-ci sont allés, mais: oui, cela fonctionne selon les spécifications.
— daniero
5

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.

— AdmBorkBork
source
@ Nazek L'intégré "String".ToLower()serait également en minuscules caractères Unicode, ce qui est contraire aux règles. Il y a beaucoup de choses que PowerShell ne fait pas correctement en ce qui concerne Unicode, mais malheureusement, il s'agit d'un cas où cela fonctionne correctement.
— AdmBorkBork
5

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
Ä
— planificateur
source
5

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!

— dunpeal69
source
4

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
— Alex A.
source
4

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.
— Dennis
source
4

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
— bkul
source
1
Cela ne fonctionnera pas pour stdin, car vous ne lisez qu'une ligne et ne la mettez pas en minuscule.
— matsjoyce
@matsjoyce j'ai corrigé mon code. Merci pour le rappel! Malheureusement, il a ajouté quatre octets, mais en ne dépendant plus de inputne pas évaluer, je pouvais passer à Python 2 et supprimer les parenthèses print.
— bkul
3

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 
Ä
— Matsjoyce
source
3

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);
}
— algmyr
source
+1 parce que cela m'a appris que les paramètres int implicites ne sont possibles qu'avec la syntaxe K & R.
— Felix Dombek
2

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.

— Verbeia
source
@TheNumberOne - c'est comme ça que ça fonctionne dans Mathematica. Aucun autre code n'est nécessaire pour cela. Si vous voulez un exécutable, Mathematica n'est pas l'outil.
— Verbeia
Cela concatène-t-il les fichiers dont le nom est entré comme argument de ligne de commande, comme requis?
— msh210
Les arguments en ligne de commande n'existent pas dans Mathematica. Il connecte ses entrées de fonction. Aussi, vous n'avez pas besoin d'assigner à une variable.
— CalculatorFeline
2

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
                )
            );  
        }
    }
}
— RobIII
source
2

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.

— Kevin Reid
source
1
l x=[x..]!!sum[32|x>'@',x<'[']
— Anders Kaseorg
1

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);}}}
— souligner
source
1

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!

Essentiellement, cela se traduit en pusedocode.

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

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);
        }
}
— Dave Thompson
source
Cela échoue le premier cas de test.
— TheNumberOne
Cela ne remplit pas les spécifications. Il devrait se comporter comme un chat dans le sens où vous prenez les noms de fichiers comme arguments et si aucun nom de fichier n’est donné, lisez-le à partir de stdin. Vous lisez actuellement seulement de stdin.
— Algmyr
0

sed, 14 octets

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

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

— Ange
source
1
Puisqu'il s'agit simplement d'une façon élégante de dire LANG=C sed -f kitten.sed, je ne suis pas sûr de devoir appliquer une pénalité pour tenir compte de cela. Cette question ne précise pas comment compter les appels de programme, et cela ne semble pas être traité en méta.
— Angel
Cela concatène-t-il les fichiers dont le nom est entré comme argument de ligne de commande, comme requis?
— msh210
@ msh210 Oui, bien sûr.
— Angel
1
@ Ángel s/.*/\L&/pour une solution de neuf octets
— somewithpc
Merci à quelqu'un avec. Les deux s/.*/\L&/et s/./\L&/gsont en effet des solutions de 9 octets!
— Angel
0

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;}}
— Dorukayhan
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.