Sappiamo tutti che se google la parola "google" si romperà Internet.

Il tuo compito è creare una funzione che accetti una stringa e restituisca la sua lunghezza, nel minor numero possibile di caratteri Unicode.

Tuttavia, se la stringa specificata è google(minuscola), causerà un errore.

Ad esempio, g('bing')verrà restituito 4ma g('google')causerà un errore.

Fornisci un esempio di utilizzo e, se possibile, l'errore.

Python 2, 29

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

Dà un ZeroDivisionErroron "google"e la lunghezza altrimenti. Questo sfrutta i booleani di Python 0e 1.

Excel, 23 caratteri

Incollalo in una cella diversa da A1 e digita la query di ricerca in A1.

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

Per esempio:

C #, 43 byte

Un miglioramento rispetto alla risposta di Salah Alami. Recruit ha lanciato un'eccezione di overflow dello stack fornendo "google"

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

Pyth, 14 13 caratteri

L/lbnb"google

Definisce una funzione con nome y.

Questo divide la lunghezza per 1 se la stringa non è google e per 0 altrimenti. L'idea non è nuova, ma mi è venuta in mente in modo indipendente.

Provalo online.

Come funziona

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 byte

Grazie a Tom Carpenter per la rasatura di 1 byte!

Grazie a Stewie Griffin per la rasatura di 2 byte!

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

A differenza delle altre soluzioni più eleganti, eseguire una divisione per operazione zero in MATLAB non darà un errore, ma piuttosto Inf. Questa soluzione trova la lunghezza della stringa di nnz. La stringa prodotta è in modo tale da indicizzare dall'inizio della stringa fino alla fine, che è essenzialmente una copia della stringa. Tuttavia, ciò che è importante è che l'inizio di dove accedere alla stringa sia prodotto verificando se l'input è uguale o meno 'google'. In caso contrario, questo produce un indice iniziale di 1 e indicizziamo normalmente la stringa ... poiché MATLAB inizia a indicizzare su 1. Se è uguale, l'indice prodotto è 0 e MATLAB genererà un errore di indicizzazione affermando che il L'indice deve essere un numero intero positivo. Il extra+è garantire che l'output del controllo di uguaglianza sia numerico anziché booleano / logical. Se si omette, +verrà generato un avviso, ma poiché le specifiche di questa sfida non consentono avvisi, +è necessario ... completando così il codice.

L'esempio usa

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

Una versione più divertente, 83 77 76 74 72 byte

Grazie a Tom Carpenter per la rasatura di 1 byte!

Grazie a Stewie Griffin per la rasatura di 2 byte!

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

Quanto sopra non è una presentazione ufficiale, ma è qualcosa che è un po 'più divertente da eseguire. Abusando evaldi funzioni anonime, ciò che il codice fa è che controlla se la stringa di input è uguale a 'google'... e se lo è, questo aprirà il browser web integrato di MATLAB e mostrerà la pagina di errore 404 di Google che prova ad accedere al sottopagina situata in iquando non esiste. In caso contrario, visualizziamo normalmente la lunghezza della stringa.

L'esempio usa

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

ans =

     4

>> f('google')
>> 

L'ultima chiamata usando 'google'ci dà questa schermata:

JavaScript ES6, 34 27 25 caratteri

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

Genera un errore di riferimento Δper google.

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

TI-BASIC, 15 byte

Diamine, mentre ci siamo , potrebbe anche ottenere una risposta TI-BASIC qui.

Il formato di input è "string":prgmNAME. Ringraziamo Thomas Kwa per averlo trovato per primo!

length(Ans)+log(Ans≠"GOOGLE

(Guida: aggiungi 1 byte per ogni lettera minuscola sostituendo una maiuscola. Quindi s/GOOGLE/google/g => +6 bytes.)

ahhhhh casi di test!

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

APL (14)

(⍴÷'google'∘≢)

Spiegazione:

• ⍴: lunghezza
• ÷: diviso per
• 'google∘≢: argomento non è uguale a 'google'.

⍴dà la lunghezza della stringa, che è diviso da 1 se la stringa non è uguale a google(che dà la lunghezza posteriore invariato), oppure 0 se la stringa non uguale google(dando un errore).

Python 3, 30 byte

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

Indicizza l'elenco di funzioni a 1 elemento, aumentando un IndexErrorse il u=='google'predicato è True(= 1). Tale funzionale.

Molte varianti. Wow:

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

Se la sfida è stata invertita (errore su tutto ciò che non è "google"), è possibile salvare un carattere:

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

Ma conosci già la lunghezza, quindi basta codificarla.

Haskell, 24 byte

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

Produzione:

Main> g "google"

Program error: pattern match failure: g "google"

Main> g "bing"
4

CJam, 16 caratteri

{_,\"google"=!/}

Questo divide la lunghezza per 1 se la stringa non è google e per 0 altrimenti. L'idea non è nuova, ma mi è venuta in mente in modo indipendente.

Provalo online.

Come funziona

_                 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.

Ottava, 63 byte

So che è più lungo della soluzione Matlab (che funzionerebbe anche in Octave), ma è particolarmente malvagio. Sto creando una funzione anonima (malvagia) usando letterali (malvagi) letterali (malvagi) contenenti handle di funzioni dipendenti da una funzione di callback (stessa, quindi ricorsiva, malvagia) che deve essere trasmessa tramite argomento. Quindi creo un altro anonimo che sostanzialmente riduce la funzione all'argomento stringa e corregge il secondo argomento di fas f(molto malvagio). Qualsiasi essere umano sano non lo farebbe mai, perché è quasi illeggibile come Perl o regex (o cjam / pyth / qualsiasi altro esolang).

Quindi, se la stringa non è "google", verrà chiamato il secondo argomento dell'array di celle che genera la lunghezza della stringa. Altrimenti verrà chiamata la prima funzione, che viene passata come callback (e si passa anche come callback a se stessa) che in seguito è la funzione stessa. L'errore è fondamentalmente un errore di profondità massima di ricorsione.

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

JavaScript, 25 byte

Esempio JavaScript semplice e piacevole:

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

Se viene inserito "google", passa a ReferenceError

Esempio

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

APL, 19 17 byte

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

Questa è una funzione monadica senza nome che genererà un errore di sintassi se l'input è google. Ciò si ottiene tentando di prendere il logaritmo naturale del nulla.

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

Provalo online

Hai salvato due byte grazie a Dennis!

R, 46 byte

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

A meno che non stia leggendo male, il post originale non ha mai specificato che il codice doveva essere sintassi corretta.

Esempio:

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

Non ho mai aggiunto nulla per il parametro "no" dell'istruzione ifelse, quindi verrà restituito un errore se questo parametro viene evocato.

Perl, 31 29 byte

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

-2b grazie all'opera d'arte

Uso:

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

Se potessi cavarmela con un programma piuttosto che una funzione, quanto segue sarebbe valido con solo 20 byte (riga di comando +1 byte)

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

L'errore è la divisione per zero.

Spiegazione:

y///crestituisce la lunghezza, quindi !/^google$/restituirà 0 se l'input corrisponde a "google".

Uso:

perl -p entry.pl input.txt

Haskell - 30 caratteri

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

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

Python 3, 35 byte

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

Java 7: 53 52 byte

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

Il codice sopra genererà ArithmeticExceptionper divisione per zero e per qualsiasi Stringaltro che google. Vale la pena notare che ==confronta i riferimenti e non funzionerà per gli Stringoggetti.

Java 8: 29 byte

(Basato sul suggerimento fornito nel commento seguente)

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

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

Bene, la divisione per zero è solo un comportamento indefinito, che non definirei un errore. Quindi il mio approccio.

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

uso

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

MUMPS, 28 byte

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

Uso:

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

<SELECT>g^MYROUTINE

Perché? Bene, $S[ELECT]fondamentalmente è un'affermazione if-else compatta multi-clausola - quasi come un pattern-match in un linguaggio come Haskell o Rust. Tranne ... a differenza di Haskell o Rust, i pattern non sono controllati per completezza, perché il concetto di "sicurezza in fase di compilazione" è completamente estraneo a MUMPS. Quindi, se il tuo input è un modello di cui non hai tenuto conto, ricevi un delizioso errore di runtime chiamato <SELECT>.

Ruby, 34 30 27 26

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

Sconosciuto tgenera un'eccezione.

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

Modifica: versione totalmente leggibile ed evidente che è più corta ...

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

Vecchio: sembra abbastanza simile ad altre idee. Aumenterà ArgumentErrorse x è "google".

JavaScript, 47 byte

Bello e semplice.

Modifica: ora è conforme alle regole

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

analisi

Errore generato

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

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

Nessun errore generato

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

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

C, 66 48

Originale:

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

Usando OSX gcc,
l("duck");ritorna 4,
l("google");causa Floating point exception: 8.

Su altre piattaforme, potrebbe essere necessario regolare le costanti per l'endianness.

Più breve :

meno inganno, stessi risultati.

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

Rubino, 29 byte

All'inizio ho trovato qualcosa di molto simile al primo tentativo di @Borsunho, ma il mio era leggermente più lungo e ha pubblicato il suo prima che avessi finito. Venne con questo prima che i suoi 30 byte modificassero :)

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

Esempi di utilizzo:

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

Rubino , 25 byte

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

Sostituito String#sizecon il nuovo plus unario. Provalo online!

> <>, 55 byte

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

Ho pensato di provare, non il mio miglior tentativo di golf o algoritmo, comunque. Non è una funzione in sé, ma penso che questo dovrebbe comunque essere qualificato. Vedrò se posso modificarlo in una versione migliore.

Se ti è permesso stampare la lunghezza e quindi l'errore, ecco una soluzione a 46 byte:

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

49 byte soluzione precedente di questa natura:

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

Sono felice di mettere una spiegazione se c'è qualche interesse, e per favore fatemi sapere se c'è qualcosa di sbagliato nella mia risposta o se avete suggerimenti sul golf.

Javascript ES6, 51 27 25 byte

Ciao, sono nuovo a programmare il golf, quindi probabilmente questo può essere giocato a golf molto di più, ma ecco qui:

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

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

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

e alcuni 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

Modifica: aggiunto? per sostituire if e sostituire Error con un oggetto non definito.

Modifica 2: mi sono reso conto che il mio conteggio dei byte era errato e ho rimosso g =

GolfScript, 14 16 caratteri

{.,\'google'=!/}

Come molti altri, confronta semplicemente l'input 'google'e divide la lunghezza per l'inverso del risultato.

Programmi di esempio:

• Con'bing' (uscita: 4)
• Con'google' (output: errore: tentativo di dividere per zero. )

Bloccato , 16 byte

s_l1u"google"=-/

Seguendo un metodo simile alla maggior parte delle persone, verrà generato un errore di divisione per 0 sull'input di "google".

Lotto di Windows, 118 caratteri

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

L'output è% stringlength%.

Codice completo:

@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

Modificato dalla risposta di Joshua Honig, qui .