Nous savons tous que si vous recherchez le mot "google" sur Google, cela cassera Internet.

Votre tâche consiste à créer une fonction qui accepte une chaîne et renvoie sa longueur, avec le moins de caractères Unicode possibles.

Cependant, si la chaîne donnée est google(minuscule), une erreur sera générée.

Par exemple, g('bing')retournera 4mais g('google')causera une erreur.

Veuillez fournir un exemple d'utilisation et l'erreur si possible.

Python 2, 29

lambda x:len(x)/(x!='google')

Donne un ZeroDivisionErrorsur "google", et la longueur autrement. Cela profite de l’égalisation des booléens de Python 0et 1.

Excel, 23 caractères

Collez-le dans une cellule autre que A1 et tapez votre requête de recherche dans A1.

=LEN(A1)/(A1<>"google")

Par exemple:

C #, 43 octets

Une amélioration par rapport à la réponse de Salah Alami. Rechute pour renvoyer une exception de débordement de pile en fournissant "google"

int g(string s)=>s!="google"?s.Length:g(s);

Pyth, 14 13 caractères

L/lbnb"google

Définit une fonction nommée y.

Cela divise la longueur par 1 si la chaîne n'est pas google et par 0 sinon. L'idée n'est pas nouvelle, mais je l'ai proposée indépendamment.

Essayez-le en ligne.

Comment ça fonctionne

L                 Define y(b):
  lb                Compute len(b).
    nb"google       Compute (b != "google").
 /                  Set _ = len(b) / (b != "google").
                  Return _. (implicit)

MATLAB, 63 41 40 38 36 octets

Merci à Tom Carpenter d’avoir supprimé 1 octet!

Merci à Stewie Griffin d'avoir réduit de 2 octets!

@(x)nnz(x(+~strcmp('google',x):end))

Contrairement aux autres solutions plus élégantes, effectuer une division par zéro dans MATLAB ne donnera pas une erreur, mais plutôt Inf. Cette solution trouve la longueur de la chaîne par nnz. La chaîne produite est telle que vous indexez du début à la fin de la chaîne, ce qui est essentiellement une copie de la chaîne. Cependant, l’important est que le début de l’accès à la chaîne soit généré en vérifiant si l’entrée est égale ou non 'google'. Si ce n'est pas le cas, cela produit un index de début égal à 1 et nous indexons normalement dans la chaîne ... car MATLAB commence à indexer à 1. S'il est égal, l'index produit est 0 et MATLAB émettra une erreur d'indexation indiquant que le index doit être un entier positif. L'extra+est de s'assurer que le résultat du contrôle d'égalité est numérique plutôt que booléen / logical. Omettre le +produira un avertissement, mais comme les spécifications de ce défi ne permettent pas les avertissements, le +est requis ... complétant ainsi le code.

Exemple d'utilisations

>> f=@(x)nnz(x(+~strcmp('google',x):end)) %// Declare anonymous function

f = 

    @(x)nnz(x(+~strcmp('google',x):end))

>> f('bing')

ans =

     4

>> f('google')
Subscript indices must either be real positive integers or logicals.

Error in @(x)nnz(x(+~strcmp('google',x):end))

Une version plus amusante, 83 77 76 74 72 octets

Merci à Tom Carpenter d’avoir supprimé 1 octet!

Merci à Stewie Griffin d'avoir réduit de 2 octets!

@(x)eval('if strcmp(''google'',x),web([x ''.com/i'']);else nnz(x),end');

Ce qui précède n’est pas une candidature officielle, mais c’est quelque chose de plus amusant à exécuter. Utilisant abusivement evaldes fonctions anonymes, le code vérifie si la chaîne de saisie est égale à 'google'... sous-page située à iquand cela n'existe pas. Sinon, nous affichons la longueur de la chaîne normalement.

Exemple d'utilisations

>> f=@(x)eval('if strcmp(''google'',x),web([x ''.com/i'']);else nnz(x),end'); %// Declare anonymous function
>> f('bing')

ans =

     4

>> f('google')
>> 

Le dernier appel en utilisant 'google'nous donne cet écran:

JavaScript ES6, 34 27 25 caractères

f=>f=='google'?Δ:f.length

Lance une ReferenceError sur Δpour Google.

alert((f=>f=='google'?Δ:f.length)('test'))

TI-BASIC, 15 octets

Heck, pendant que nous y sommes , autant obtenir une réponse TI-BASIC ici.

Le format d'entrée est "string":prgmNAME. Nous remercions Thomas Kwa de l' avoir trouvé en premier!

length(Ans)+log(Ans≠"GOOGLE

(Guide: ajoutez 1 octet pour chaque lettre minuscule en remplaçant une lettre majuscule. Donc s/GOOGLE/google/g => +6 bytes.)

ahhhhh cas de test!

"GOGGLE":prgmG
               6
"BING":prgmG
               4
"GOOGLE":prgmG
           Error

APL (14)

(⍴÷'google'∘≢)

Explication:

• ⍴: longueur
• ÷: divisé par
• 'google∘≢: l'argument n'est pas égal à 'google'.

⍴donne la longueur de la chaîne, divisée par 1 si la chaîne n'est pas égale google(ce qui rend la longueur inchangée), ou par 0 si la chaîne est égale google(en donnant une erreur).

Python 3, 30 octets

lambda u:[len][u=='google'](u)

Indexe la liste de fonctions à 1 élément, en soulevant un IndexErrorsi le u=='google'prédicat est True(= 1). Tellement fonctionnel.

Beaucoup de variantes. Sensationnel:

lambda u:[len(u)][u=='google']
lambda u:len([u][u=='google'])

Si le défi était inversé (erreur sur tout ce qui n'est pas "google"), vous pourriez enregistrer un caractère:

lambda u:{'google':len}[u](u)

Mais vous connaissez déjà la longueur, il suffit donc de la coder en dur.

Haskell, 24 octets

g s|s/="google"=length s

Sortie:

Main> g "google"

Program error: pattern match failure: g "google"

Main> g "bing"
4

CJam, 16 caractères

{_,\"google"=!/}

Cela divise la longueur par 1 si la chaîne n'est pas google et par 0 sinon. L'idée n'est pas nouvelle, mais je l'ai proposée indépendamment.

Essayez-le en ligne.

Comment ça fonctionne

_                 Push a copy of the string on the stack.
 ,                Compute the length of the copy.
  \               Swap the length and the original string.
   "google"=      Push 1 if the string is "google", 0 otherwise.
            !     Apply logical NOT. Maps 1 to 0 and 0 to 1.
             /    Divide the length by the Boolean.

Octave, 63 octets

Je sais que c'est plus long que la solution Matlab (qui fonctionnerait aussi dans Octave), mais c'est particulièrement pervers. Je crée une fonction anonyme (mal) en utilisant un tableau de cellules (mal) des littéraux (mal) contenant des descripteurs de fonction dépendants d'une fonction de rappel (elle-même, donc récursive, mal) qui doivent être transmis via un argument. Ensuite, je crée un autre anonyme qui réduit fondamentalement la fonction à l'argument chaîne et corrige le deuxième argument de fas f(très diabolique). Aucun humain sensé ne le ferait jamais, car il est presque aussi illisible que Perl ou regex (ou cjam / pyth / tout autre esolang).

Donc, si la chaîne n'est pas "google", le deuxième argument du tableau de cellules sera appelé, ce qui donnera la longueur de la chaîne. Sinon, la première fonction sera appelée, qui sera transmise comme rappel (et se transmettra elle-même comme rappel), qui sera plus tard la fonction elle-même. L'erreur est fondamentalement une erreur de profondeur de récursivité maximale.

f=@(s,f){@()f(s,f),numel(s)}{2-strcmp(s,'google')}();@(s)f(s,f)

JavaScript, 25 octets

Exemple JavaScript simple et agréable:

e=>e!='google'?e.length:g

Si "google" est entré, alors il passe un ReferenceError

Exemple

alert((e=>e!='google'?e.length:g)('test'))

APL, 19 17 octets

{⍵≡'google':⍟⋄≢⍵}

Il s'agit d'une fonction monadique non nommée qui générera une erreur de syntaxe si l'entrée est google. Ceci est accompli en essayant de prendre le logarithme naturel de rien.

{
 ⍵≡'google':          ⍝ If the right argument is "google"...
            ⍟⋄        ⍝ Compute log(<nothing>), which brings only sadness
              ≢⍵      ⍝ Otherwise compute the length
}

Essayez-le en ligne

Sauvé deux octets grâce à Dennis!

R, 46 octets

g=function(x)ifelse(x!="google",nchar(x),)

À moins que je ne me trompe, le message d'origine n'a jamais précisé que le code devait être une syntaxe correcte.

Exemple:

> g("bing")
[1] 4
> g("google")
Error in ifelse(x != "google", nchar(x), ) : 
  argument "no" is missing, with no default

Je n’ai jamais rien ajouté pour le paramètre "no" de l’instruction ifelse, ce qui renverra une erreur si ce paramètre est évoqué.

Perl, 31 29 octets

sub{$_=pop;y///c/!/^google$/}

-2b grâce à manatwork

Usage:

sub{$_=pop;y///c/!/^google$/}->("google")

Si je pouvais m'en tirer avec un programme plutôt qu'une fonction, les éléments suivants seraient valables avec seulement 20 octets (ligne de commande de +1 octet)

$_=y///c/!/^google$/

L'erreur est la division par zéro.

Explication:

y///cretourne la longueur, puis !/^google$/retournera 0 si l'entrée correspond à "google".

Usage:

perl -p entry.pl input.txt

Haskell - 30 caractères

g"google"=error"!";g s=length s

>g "google"
 *Exception: !
>g "str"
 3

Python 3, 35 octets

lambda n:len(n)if n!='google'else d

Java 7: 53 52 octets

int g(String _){return"google"==_?0/0:_.length();} 

Le code ci-dessus jettera ArithmeticException pour la division par zéro et pour tout Stringautre que google. Il convient de noter que ==compare la référence et ne fonctionnera pas pour les Stringobjets.

Java 8: 29 octets

(Basé sur la suggestion donnée dans le commentaire ci-dessous)

s->s=="google"?0/0:s.length()

C ++ 11, 54 (code) + 14 (#include) = 68

Eh bien, la division par zéro n’est qu’un comportement indéfini, ce que je n’appellerais pas une erreur. Donc mon approche.

#include<ios>
[](std::string s){return s!="google"?s.size():throw;};

usage

[](std::string s){return s!="google"?s.size():throw;}("google");

MUMPS, 28 octets

g(s) q $S(s'="google":$L(s))

Usage:

>w $$g^MYROUTINE("bing")                                      
4
>w $$g^MYROUTINE("google")

<SELECT>g^MYROUTINE

Pourquoi? Eh bien, il $S[ELECT]s’agit en gros d’une déclaration multipartite if-else, presque semblable à une correspondance de motif dans un langage comme Haskell ou Rust. Sauf que, contrairement à Haskell ou Rust, les motifs ne sont pas vérifiés quant à leur exhaustivité, car la notion de "sécurité au moment de la compilation" est totalement étrangère à MUMPS. Donc, si votre entrée est un motif que vous n'avez pas pris en compte, vous obtenez une belle erreur d'exécution appelée <SELECT>.

Ruby, 34 30 27 26

->x{x=='google'?t: x.size}

Unknown tdéclenche une exception.

->x{x=='google'?fail():x.size}

Edit: version totalement lisible et évidente qui est plus courte ...

->x{x[x=~/^(?!google$)/..-1].size}

Old: Assez similaire à d'autres idées semble-t-il Sera levé ArgumentErrorsi x est 'google'.

JavaScript, 47 octets

Sympa et simple.

Edit: se conforme maintenant aux règles

function f(g){if(g=="google")a;return g.length}

Essai

Erreur levée

function f(g){if(g=="google")a;return g.length}

alert(f("Hello"))
alert(f("google"))
alert(f("hi"))

Aucune erreur jetée

function f(g){if(g=="google")a;return g.length}

alert(f("Hello"))
alert(f("bing"))
alert(f("hi"))

C, 66 48

Original:

int l(long*s){return strlen(s)/((*s&~(-1L<<56))!=0x656c676f6f67);}

Utilisation de OSX gcc,
l("duck");retours 4,
l("google");causes Floating point exception: 8.

Sur d'autres plates-formes, il peut être nécessaire d'ajuster les constantes en fonction de l'endianité.

Plus court :

moins d'astuce, mêmes résultats.

 l(int*s){return strlen(s)/!!strcmp(s,"Google");}

Ruby, 29 octets

J'ai tout d'abord proposé quelque chose de très similaire à la première tentative de @ Borsunho, mais la mienne était légèrement plus longue et il l'a postée avant la fin. Entré avec cela avant son édition de 30 octets :)

->s{s[/^(?!google$).*/].size}

Exemples d'utilisation:

$ irb
2.2.1 :001 > f = ->s{s[/^(?!google$).*/].size}
 => #<Proc:0x007fa0ea03eb60@(irb):1 (lambda)> 
2.2.1 :002 > f[""]
 => 0 
2.2.1 :003 > f["bing"]
 => 4 
2.2.1 :004 > f["google"]
NoMethodError: undefined method `size' for nil:NilClass
  from (irb):1:in `block in irb_binding'
  from (irb):4:in `[]'
  from (irb):4
  from /Users/daniel/.rvm/rubies/ruby-2.2.1/bin/irb:11:in `<main>'

Ruby , 25 octets

->s{+s[/^(?!google$).*/]}

Remplacé String#sizepar le nouveau plus unaire. Essayez-le en ligne!

> <>, 55 octets

i:0(?v
31&l~<v0"google"~~.?%2l
$v?(2l<S?*=2l=6:+={
&<;n

Je pensais que j'allais tenter le coup, pas ma meilleure tentative de golf ni mon meilleur algorithme. Pas une fonction en soi, mais je pense que cela devrait quand même être admissible. Je verrai si je peux éditer une meilleure version.

Si vous êtes autorisé à imprimer la longueur puis l'erreur, voici une solution de 46 octets:

i:0(?v
2lnl~<v0"google";?%
$;?(2l<S?*=2l=6:+={

Solution précédente de 49 octets de cette nature:

i:0(?v
l0nl~<v;!?=7
:;?(2l<S?*=2l=6:+=@@g3
elgoog

Je serai heureux de fournir une explication si cela vous intéresse, et s'il vous plaît, laissez-moi savoir si ma réponse a un problème ou si vous avez des suggestions pour le golf.

Javascript ES6, 51 27 25 octets

Salut, je suis nouveau sur le code de golf, donc cela peut probablement être joué beaucoup plus, mais voici:

_=>_=="google"?a:_.length

g=_=>_=="google"?a:_.length

g=_=>{if("google"==_)throw Error();return _.length}

et quelques test:

(_=>_=="google"?a:_.length)("bing")//4
(_=>_=="google"?a:_.length)("google")// Error: a is not defined

g("bing")// returns 4
g("google")// Error: a is not defined

Edit: ajouté? pour remplacer if et remplacer Error par un objet non défini.

Edit 2: j’ai réalisé que mon nombre d’octets était faux et j’ai supprimé le g =

GolfScript, 14 à 16 caractères

{.,\'google'=!/}

Comme beaucoup d'autres, compare simplement l'entrée à 'google'et divise la longueur par l'inverse du résultat.

Exemples de programmes:

• Avec'bing' (sortie: 4)
• Avec'google' (sortie: Erreur: Tentative de division par zéro. )

Coincé , 16 octets

s_l1u"google"=-/

Suivre une méthode similaire à la plupart des gens provoquera une erreur de division par 0 sur "google" en cours de saisie.

Lot Windows, 118 caractères

IF /I "%string%"=="google" exit
echo %string%> string.txt
for %%? in (string.txt) do ( SET /A stringlength=%%~z? - 2 )

La sortie est% stringlength%.

Code complet:

@echo off
del string.txt
cls
echo Type your string
echo.
set /p string=String:
IF /I "%string%"=="google" goto err
echo %string%> string.txt
for %%? in (string.txt) do ( SET /A stringlength=%%~z? - 2 )
cls
echo %stringlength%
pause
del string.txt
:err
color c
echo There seems to be an error with your input...
pause>nul

Modifié à partir de la réponse de Joshua Honig, ici .