Bonté Giza Golf!

41

Un "numéro de Giza", également appelé familièrement un numéro de Timmy, est un nombre quelconque où les chiffres représentent une pyramide ( A134810 ). Par exemple, "12321" est un nombre giza car il peut être visualisé comme ceci:

  3  
 2 2
1   1

Cependant, quelque chose comme "123321" n'est pas un nombre de Giza, car il y a deux chiffres en haut de la pyramide.

  33  
 2  2
1    1

En d'autres termes, un nombre est un nombre de Giza si toutes les conditions suivantes sont remplies:

  • Il a un nombre impair de chiffres et le chiffre du centre est le plus grand

  • C'est palindromique (la même lecture en avant ou en arrière), et

  • La première moitié des chiffres augmente strictement de un. (Puisqu'il doit être palindrome, cela signifie que la deuxième moitié des chiffres doit être strictement décroissante d'un)

Vous devez écrire un programme complet ou une fonction prenant un entier positif en entrée et déterminer s'il s'agit d'un nombre de Giza ou non. Vous pouvez prendre l’entrée sous forme de chaîne ou de nombre. S'il s'agit d' un nombre de Gizeh, indiquez une valeur de vérité . Sinon, une valeur de fausseté.

Il y a un total de 45 nombres de Giza, donc l'une quelconque de ces entrées doit donner une valeur de vérité:

1
2
3
4
5
6
7
8
9
121
232
343
454
565
676
787
898
12321
23432
34543
45654
56765
67876
78987
1234321
2345432
3456543
4567654
5678765
6789876
123454321
234565432
345676543
456787654
567898765
12345654321
23456765432
34567876543
45678987654
1234567654321
2345678765432
3456789876543
123456787654321
234567898765432
12345678987654321

Toute autre entrée doit donner une valeur de fausseté. Bien entendu, vous n'avez pas à gérer des entrées non valides, telles que des nombres non positifs, des nombres entiers ou des nombres.

Comme d'habitude, c'est du , donc les échappatoires standard sont interdites, et la réponse la plus courte en octets est gagnante!

DJMcMayhem
la source
qu'en est-il de 0? est-ce que c'est une thruthy?
Tuskiomi
@tuskiomi Techniquement, non, mais c'est sans importance parce que vous n'êtes pas obligé de traiter des nombres non positifs.
DJMcMayhem
1
Je pose la question parce que, s’il s’agit d’ un nombre giza, les chiffres 1210, 123210, etc. seraient également véridiques.
Tuskiomi
5
@tuskiomi Aucun de ceux-ci n'est palindromique ou n'a un nombre impair de chiffres. À moins que vous ne comptiez un 0 en tête, mais cela rend les choses beaucoup plus compliquées.
DJMcMayhem
1
@ nedla2004 Je pense que le 0 en tête rend les formats d'entrée plus compliqués. Pour que tout reste simple et agréable, nous dirons que vous pouvez supposer que les entrées ne contiendront pas de 0 au début.
DJMcMayhem

Réponses:

30

Python 2, 48 47 46 octets

lambda s:s[~len(s)/2:]in'987654321'>s==s[::-1]

Testez-le sur Ideone .

Comment ça marche

En Python, une comparaison chaînée renvoie True si et seulement si toutes les comparaisons individuelles font la même chose. Dans ce cas particulier, notre lambda renvoie True si et seulement si toutes les conditions suivantes sont remplies.

  • s[~len(s)/2:]in'987654321'

    Pour une chaîne s de longueur 2n + 1 , ~len(s)/2retourne ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , s[~len(s)/2:]donne donc les n + 1 caractères les plus à droite de s .

    De même, pour une chaîne s de longueur 2n , ~len(s)/2retourne ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (la division entière toujours arrondie vers -∞ , de sorte s[~len(s)/2:]qu'une fois de plus, on obtient le n + le plus à droite 1 caractères de s

    La comparaison renvoie True si et seulement si les n + 1 caractères les plus à droite forment une sous-chaîne de 987654321.

    Notez que s'ils le font et que s a 2n caractères, s ne peut pas être un palindrome; la n ième et (n + 1) ième caractère de droite soient distinctes, et celui - ci est le n ième caractère de gauche.

  • '987654321'>s

    Ceci compare les chaînes lexicographiquement. Comme 9 est le seul numéro de Gizeh commençant par 9 , tous les nombres de Gizeh satisfont à cette comparaison.

    Notez que la comparaison de ces chaînes ne fait pas partie de notre problème de décision; >sest simplement trois caractères plus court que and s.

  • s==s[::-1]

    Cela renvoie True si et seulement si s est un palindrome.

Dennis
la source
8
Cette réponse est une magie folle. Je comprends comment cela fonctionne, mais je n'arrive même pas à comprendre comment vous en êtes arrivé à ce résultat. Et pendant un instant, j'étais fier de mon 64. +1
DJMcMayhem
2
j'adore la comparaison garantie pour sauvegarder ces 3 octets
greyShift
22

Perl, 39 37 42 39 + 1 = 40 octets

En utilisant une nouvelle méthode, j'ai réussi à réduire un très grand nombre d'octets. Courez avec le -ndrapeau. Accepte les entrées à plusieurs reprises au moment de l'exécution, en imprimant 0 ou 1 en conséquence.

J'ai dû ajouter 5 octets parce que je réalisais que sans cela, le code fonctionnait pour des entrées telles que 1234567900987654321, qui n'est pas un nombre de Giza. Puisque les nombres de Giza ne contiennent jamais le chiffre 0 (et tous les faux positifs devraient nécessairement contenir le chiffre 0), ces 5 octets en tiennent compte.

say!/0/*($_- s/..?/1/gr**2)=~/^(.)\1*$/

Explication:

say!/0/*($_- s/..?/1/gr**2)=~/^(.)\1*$/  #$_ contains input by default.
   !/0/                                  #Ensure that the initial text doesn't contain the number 0
       *                                 #Since both halves of this line return either 0 or 1, multiplying them together only yields 1 if both are true (which we want).
             s/   / /gr                  #Perform a substitution regex on $_ (see below)
                                         #/g means keep replacing, /r means don't modify original string; return the result instead
               ..?                       #Replace 1 or 2 characters (2, if possible)...
                   1                     #...with the number 1
                       **2               #Square this number...
        ($_-              )              #...and subtract it from the input
                           =~            #Do a regex match on the result
                             /^      $/  #Make sure the regex matches the WHOLE string
                               (.)       #Match any character...
                                  \1*    #...followed by itself 0 or more times
say                                      #Finally, output the result of the whole line of code.

Le but de la regex de substitution est de construire une chaîne de 1 dont la longueur est la moitié de la longueur de l'entrée, arrondie à la fin. Ainsi, une entrée de 12321produira la chaîne 111, qui sera alors quadrillée (explication ci-dessous). Les entrées de longueur égale produiront des chaînes trop petites pour assurer la regex finale.

Ce code fonctionne pour les raisons suivantes:

        1         =         1**2
       121        =        11**2
      12321       =       111**2
     1234321      =      1111**2
    123454321     =     11111**2
   12345654321    =    111111**2
  1234567654321   =   1111111**2
 123456787654321  =  11111111**2
12345678987654321 = 111111111**2

Nous pouvons clairement voir que le nombre de 1 dans RHS est égal à 1/2 plus de la moitié de la taille de LHS. (1 de plus si on tronque). Aditionellement:

567898765 - 123454321 = 444444444, ce qui ne fait que répéter. Ainsi, lorsque nous soustrayons notre carré de notre nombre, si nous obtenons un repdigit, notre numéro d'origine est un nombre de Giza.

Ancien code et ancienne méthode (58 + 1 = 59 octets)

Enregistré 1 octet grâce à @Dada

Exécuter avec le -ndrapeau, le texte de pipe en utilisantecho

say$_==($;=join"",/(.)/..($==y///c/2+/(.)/)-1).$=.reverse$

Calcule le nombre unique de giza déterminé par la longueur et le premier nombre, et vérifie s'il correspond à l'entrée.

Run as echo -n "123454321" | perl -M5.010 -n giza.pl Returns 1si c'est un nombre de Giza, null sinon.

Gabriel Benamy
la source
2
C'est une belle observation pour la deuxième méthode.
Trichoplax
15

Gelée , 10 7 6 octets

9ẆŒBḌċ

Génère les 45 numéros de Giza, puis teste son appartenance.

Essayez-le en ligne! ou voir les nombres générés .

Comment ça marche

9ẆŒBḌċ  Main link. Argument: n

9       Set the return value to 9.
 Ẇ      Windows; yield all "substrings" of [1, ..., 9].
  ŒB    Bounce; map each [a, ..., b] to [a, ..., b, ..., a].
    Ḍ   Undecimal; convert the digit arrays to integers.
     ċ  Count the number of occurrences of n.
Dennis
la source
10

JavaScript (ES6), 46 45 42 41 octets

f=([c,...s])=>s+s&&c-s.pop()|c-~-f(s)?0:c

Prend les entrées sous forme de chaîne et renvoie une chaîne à un chiffre pour vérité, 0pour fausseté.

L'idée de base est de vérifier quelques points:

  • Si la chaîne est longue d'un caractère, OU
  • le premier caractère est identique au dernier, et
  • la partie médiane est aussi un numéro de Giza, et
  • le deuxième caractère est un de plus que le premier caractère ici.
ETHproductions
la source
Désolé, j'ai mal compris la question.
Neil
10

Java 7, 128 119 105 octets

boolean t(long n){long a=1,b=1,c=0;for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)a=a*10+1;return(n-b*b)%a<1&c<1;}

Pas plus de ficelles! Donc, maintenant je commence par générer un 111...nombre de la même longueur que input ( a), et un plus court en square ( b). Ensuite, vous pouvez soustraire b*bde l’entrée et vérifier la divisibilité par a. cest juste là pour vérifier impair / pair, payez-le sans souci> _>

Whitespaced:

boolean t(long n){
    long a=1,b=1,c=0;
    for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)
        a=a*10+1;
    return(n-b*b)%a<1&c<1;
}

Méthode ancienne, 119 octets

boolean g(char[]a){int i=1,l=a.length,b=1,d;for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)d=a[i]-a[i-1];return b>0?l%2>0:0>1;}

Parcourt le tableau en vérifiant la différence de 1 (ou -1, selon la moitié) entre chaque chiffre. Il suffit ensuite de vérifier que la longueur est impaire.

Whitespaced:

boolean g(char[]a){
    int i=1,l=a.length,b=1,d;
    for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)
        d=a[i]-a[i-1];
    return b>0?l%2>0:0>1;
}
Géobits
la source
Pourquoi avez-vous besoin de vérifier si le premier est le même que le dernier?
Nathan Merrill
3
Je n'ai aucune idée de ce que vous voulez dire> _>
Geobits
Est-ce une réponse valide compte tenu du problème spécifiant que la fonction doit prendre un entier positif? Bien sûr, un tableau de caractères peut représenter un entier positif, mais je pense que c'est une distinction importante.
Hypino
1
@ Hypino Le problème dit que l'entrée peut être considérée comme une chaîne ou un entier, et char[] compte ici comme une chaîne , alors je dirais que c'est valide.
Geobits
@ Geobits Ah j'ai raté la partie où il était dit que cela pouvait être pris comme une chaîne.
Hypino
6

05AB1E , 9 à 8 octets

La vérité est 1 , la fausseté est 0 .

9LŒ€ûJ¹å

Utilise le codage CP-1252 . Essayez-le en ligne!

Adnan
la source
Je pense que 2ä¬û¹Qcela fonctionnerait aussi bien et économiser deux octets.
Osable
@Osable 12521 n'est pas un nombre giza, cela échoue pour l'élément central.
Urne Magique Octopus
Je réalise maintenant que j'ai sauté le troisième point (chiffres consécutifs). Ça ne fait rien!
Osable
Ahhhh ... J'utilisais des préfixes, je garderai les sous-chaînes à l'esprit pour les efforts futurs, petit bidouillage soigné.
Urne magique Octopus
6

Python 2, 77, 76, 64 , 63 octets

f=lambda s:2>len(s)or(s[0]==s[-1]==`int(s[1])-1`and f(s[1:-1]))

Une solution récursive simple. Vérifie si les premier et dernier chiffres sont égaux et le deuxième chiffre moins un. Puis vérifie si le milieu est aussi un numéro de Giza. Renvoie true une fois qu'il est passé à un chiffre.

Un octet enregistré grâce à @Rod, un tonne d'octets sauvegardée grâce à DLosc et ETHProductions!

DJMcMayhem
la source
vous pouvez permuter len(s)==1avec 1==len(s)pour économiser 1 octet sur l'espace, aussi, le ands pourrait être remplacé par *pour économiser 3 octets
Rod
Juste pour ajouter au commentaire de Rod: ça 1ormarche aussi. (Tant que ce n'est pas un 0précédent le o--then Python pense que c'est un nombre octal.)
DLosc
1
Vous ne pouvez généralement pas remplacer andpar *lorsqu'un comportement de court-circuit est requis, comme dans une fonction récursive. Le premier anddoit être remplaçable, mais il nécessite deux jeux de parenthèses, ce qui annule toute économie. (cc: @Rod)
DLosc
1
Je ne sais pas beaucoup de Python, mais pourriez - vous 1) retirer le int()autour s[0]ou 2) l' utilisation s[0]==`int(s[1])-1` ?
ETHproductions
1
S'appuyant sur la suggestion de @ETHproductions: s[-1]==s[0]==`int(s[1])-1`(nécessite Python 2 en particulier).
DLosc
6

PowerShell v3 +, 147 108 67 octets

$args[0]-in(1..9+(1..8|%{$i=$_;++$_..9|%{-join($i..$_+--$_..$i)}}))

Approche radicalement changée. Génère tous les nombres possibles de Giza, puis vérifie si l'entrée $args[0]est -incette collection. Voici comment se forme la collection de nombres de Giza:

1..9+(1..8|%{$i=$_;++$_..9|%{-join($i..$_+--$_..$i)}})
      1..8|%{                                       }  # Loop from 1 up to 8
             $i=$_;                                    # Set $i to the current number
                   ++$_..9|%{                      }   # Loop from one higher up to 9
                                   $i..$_+--$_..$i     # Build two ranges and concatenate
                                                       # E.g., 2..5 + 4..2
                             -join(               )    # Join into a single string
1..9+(                                               ) # Array concatenate with 1 to 9

Exemple fonctionne:

PS C:\Tools\Scripts\golfing> 12321,5678765,121,4,123321,1232,5678,13631|%{"$_ --> "+(.\giza-numbers.ps1 "$_")}
12321 --> True
5678765 --> True
121 --> True
4 --> True
123321 --> False
1232 --> False
5678 --> False
13631 --> False
AdmBorkBork
la source
108 -> 67 ... on dirait que vous gagnez cette fois-ci (et probablement la plupart du temps): P
Yodle
5

Python 3, 65 octets

lambda x:len(x)<18and x[:len(x)//2+1]in'0123456789'and x[::-1]==x

Je ne suis pas tout à fait sûr, mais je pense que cela fonctionne.

0WJYxW9FMN
la source
1
Vous ne 0pouvez pas supprimer cela des chiffres commençant par Giza :) Il n'y aura pas non plus de chiffres de plus de 17 qui répondent à cette condition, vous n'avez donc pas besoin de cela. C'est essentiellement la même solution que Dennis a :)
Kade
@Shebang mais celui-ci a été posté en premier ...
Rod
@Rod Je ne prétendais pas qu'il a copié ou quoi que ce soit :)
Kade
@Shebang Je ne suis pas non plus c:
Rod
5

Python 2, 68 73 66 octets

lambda n:n==`int('1'+len(n)/2%9*'1')**2+int(len(n)*`int(n[0])-1`)`

en abusant du fait que 11^2=121, 111^2=12321et ainsi de suite, je calcule cela et ajoute 1111..suffisamment de temps pour compenser.
Exemples:
23432=111^2+11111*1
676=11^2+111*5

Barre
la source
Puisque vous n'appelez pas f, vous n'avez pas besoin de le nommer. Vous pouvez économiser deux octets en supprimantf=
DJMcMayhem
Vous devriez définir un plafond à ce sujet. L'entrée 1234567900987654321renvoie vrai, alors que cela devrait être faux.
Geobits
@Geobits ooops, corrigé (je suppose?)
Rod
4

Perl, 41 octets

40 octets de code + -pdrapeaux.

s/(.)(?=(.))/$1-$2/ge;$_=/^(-1(?1)1|).$/

Les sorties 1 si l’entrée est un nombre de Giza, rien sinon. Fournissez l'entrée sans nouvelle ligne finale pour l'exécuter:

echo -n '123456787654321' | perl -pe 's/(.)(?=(.))/$1-$2/ge;$_=/^(-1(?1)1|).$/'

Explications : s/(.)(?=(.))/$1-$2/geremplacez d’abord chaque chiffre $1(suivi de $2) par $1-$2. S'il s'agit d'un numéro de Gizeh, chacun des chiffres représentant un chiffre inférieur de moins au début et un chiffre supplémentaire à la fin, la chaîne ne doit contenir que -1la première partie et 1la seconde (sauf la dernière qui reste inchangée). . C’est ce que la deuxième partie /^(-1(?1)1|).$/vérifie: recherche d’un -1suivi de récursivité suivi d’un1 .

-1 octet grâce à Martin Ender.


Ma version précédente plus longue de 15 octets (assez différente donc je vais le laisser ici):

echo -n '123456787654321' | perl -F -pe '$\=$_ eq reverse;$\&=$F[$_-1]+1==$F[$_]for 1..@F/2}{'
Dada
la source
La seule partie de ce que je ne comprends pas est le but de |la deuxième expression régulière.
Gabriel Benamy
@GabrielBenamy C'est le cas de base du bloc récursif (c'est-à-dire qu'il ne correspond à rien et arrête la récursion).
Dada
3

> <> POISSON 57 52 49 48 octets

i:1+?!vi00.;n1<
%?v0n;>~l:1-?!^2
{:<11 ^?:=@:$+=

Edit 1: = renvoie 0 ou 1 si true, supprime donc une vérification et utilise cette valeur pour incrémenter, puis il vérifie l’égalité après tout de même. (sauvegardé 6 octets, perdu 1 pour la nouvelle ligne).

Éditez 2: 3 marqueurs directionnels ont été retirés et 11 placés dans l’espace pour décaler la pile sur une longueur égale afin de forcer la valeur false (3 octets enregistrés).,

Edit 3: dupliquez la longueur de la pile pour vérifier MOD par 2 et len ​​(1), cela a été fait en mettant la longueur deux fois auparavant, mais cela remplit maintenant un espace vide sur la ligne 2 (1 octet enregistré).

Sarcelle
la source
3

C #, 120 86 108 102 92 octets

x=I=>{var Z=I.Length;return Z<2?1>0:I[0]==I[Z-1]&I[1]-0==I[0]+1?x(I.Substring(1,Z-2)):0>1;};

Programme complet avec quelques cas de test:

class a
{
    static void Main()
    {
        Func<string, bool> x = null;

        x = I=>
        {
            var Z=I.Length;
            return Z==1?                           // length == 1?
                     1>0:                          // return true (middle of #)
                     I[0]==I[Z-1]&I[1]-0==I[0]+1?  // else start == end and the next number is 1 above the current?
                       x(I.Substring(1,Z-2)):      // recursive call on middle
                       0>1;                        // else false
        };

        Console.WriteLine("1 -> " + (x("1") == true));
        Console.WriteLine("9 -> " + (x("9") == true));
        Console.WriteLine("121 -> " + (x("121") == true));
        Console.WriteLine("12321 -> " + (x("12321") == true));
        Console.WriteLine("4567654 -> " + (x("4567654") == true));
        Console.WriteLine("12345678987654321 -> " + (x("12345678987654321") == true));
        Console.WriteLine("12 -> " + (x("12") == false));
        Console.WriteLine("1221 -> " + (x("1221") == false));
        Console.WriteLine("16436346 -> " + (x("16436346") == false));
        Console.WriteLine("123321 -> " + (x("123321") == false));
        Console.WriteLine("3454321 -> " + (x("3454321") == false));
        Console.WriteLine("13631 -> " + (x("13631") == false));
        Console.WriteLine("191 -> " + (x("13631") == false));
        Console.Read(); // For Visual Studio
    }
}

Hourra pour les conditionnels simple ligne, battant maintenant la réponse Java :)! Je dois également écrire mes premiers commentaires explicatifs, même s’il s’agit probablement d’explications. Merci à @Dada pour avoir trouvé un problème avec mon algorithme (c'était vrai pour les nombres en miroir comme 13631). À présent, la valeur inférieure à 100, car apparemment la vérification de la longueur% 2 est redondante.

Yodle
la source
1
Est-ce que cela ne reviendrait pas truepour des chiffres comme 13631? De plus, puisque vous passez un appel récursif à x, je pense que vous devez inclure x=votre nombre d'octets.
Dada
@ Dada Heh bon point, je savais qu'il me manquait quelque chose ... Et bien, je vais les ajouter au compte.
Yodle
Attendez, vous battez quoi maintenant? ;)
Geobits
@ Geits Dangit! Je verrai ce que je peux faire demain: P
Yodle
3

Bash, 111 octets

MISE À JOUR

Notez que la normalisation du nombre d'entrée peut probablement être complètement ignorée, si vous ajoutez simplement le premier chiffre à votre numéro GIZA généré , comme ceci:

01210 + 6 => 67876

et puis juste le comparer avec l'entrée directement.

Avertissement: celui-ci n'est pas vraiment optimisé, il s'agit donc davantage d'une preuve de concept que d'un véritable concurrent

Golfé

G() { I=`sed "s/./\0-${1::1}\n/g"<<<$1|bc`;Z=`seq 0 $((${#1}/2))`;A=`rev <<<$Z`;cmp -s <(echo $I) <<<$Z${A:1}

Algorithme

Tout numéro GIZA peut être normalisé sous sa forme canonique, en soustrayant son premier chiffre du reste:

67876 - 6 => 01210
78987 - 7 => 01210

et il n'y a qu'un seul GIZA canonique numéro d’une longueur donnée.

Sachant cela, nous pouvons facilement générer un nombre canonique GIZA en fonction de la longueur du nombre entré:

 Z=`seq 0 $((${#1}/2))`;A=`rev <<<$Z` => $Z${A:1}

puis normaliser le nombre saisi:

 I=`sed "s/./\0-${1::1}\n/g"<<<$1|bc`

et comparer

 cmp -s <(echo $I) <<<$Z${A:1};

Tester

for i in `seq 0 1000`; do G $i && echo $i; done

0
1
2
3
4
5
6
7
8
9    
121
232
343
454
565
676
787
898

...

G 12345678987654321 && echo "OK" || echo FALSE     
OK

G 123456789987654321 && echo "OK" || echo FALSE
FALSE
Zeppelin
la source
J'espère que cela ne vous dérange pas, j'ai implémenté une partie de cet algorithme dans ma réponse :)
FlipTack
1

En fait , 22 octets

9uR;∙`xR;RdX+εj`M;░#íu

Essayez-le en ligne!

Prend l'entrée en tant que chaîne entre guillemets (par exemple "12321" ). La sortie est un entier positif pour true, et0 pour false.

Explication:

9uR;∙`xR;RdX+εj`M;░#íu
9uR;∙                   cartesian product of [1,2,3,4,5,6,7,8,9,10] with itself
     `xR;RdX+εj`M       for each pair:
      x                   construct the half-open (end-exclusive) range ([1, 5] -> [1, 2, 3, 4])
       R                  reverse
        ;RdX+             duplicate, reverse, remove first element, prepend ([1, 2, 3, 4] -> [1, 2, 3, 4, 3, 2, 1])
             εj           concatenate into a string
                 ;░     filter out empty strings
                   #íu  test for membership
Mego
la source
1

Haskell, 62 octets

(`elem`[[j..pred i]++[i,pred i..j]|i<-['1'..'9'],j<-['1'..i]])

L'entrée est prise comme une chaîne.

Crée une liste de tous les numéros de Giza et vérifie si le numéro y est indiqué. La liste est créée en ipassant en boucle '1'..'9'puis jen '1'..icréant les éléments j .. i-1 , i , i-1 .. j.

nimi
la source
1

> <> , 62 octets

i:0(   ?v
v!1&!~{!<:=$:@&-1=+2=*>l!-3!1(!:?
>l!;2!n=!0?!<-1=n;

Essayez-le en ligne!

Sorties 1 pour un numéro de Giza; 0 sinon. Fonctionne en poussant l'entrée dans une file d'attente (ok, techniquement une pile réversible) et en testant à plusieurs reprises l'égalité, tout en s'assurant qu'elles sont exactement supérieures à la valeur précédente.

Brian Gradin
la source
1

CJam , 20 19 octets

l_$_W=),\ci>_W<W%+=

Suite de tests.

Explication

L'idée de base est de trouver les chiffres minimum et maximum, puis de créer un nombre de Gizeh à partir de ceux-ci et de vérifier qu'il correspond bien à la saisie.

l       e# Read input.
_$      e# Get a sorted copy of the input.
_W=     e# Get its last character, i.e. the maximum digit M.
),      e# Get a string with all characters from the null byte up to M.
\c      e# Get the first character of the sorted string, i.e. the minimum
        e# character m.
i>      e# Convert to its character code and discard that many leading
        e# characters from the string we generated before. Now we've got
        e# a string with all digits from m to M, inclusive.
_W<W%+  e# Palindromise it, by appending a reversed copy without M.
=       e# Check that it's equal to the input.

Au lieu du caractère minimum, nous pouvons également utiliser le premier caractère, pour le même nombre d'octets:

l_:e>),1$ci>_W<W%+=
Martin Ender
la source
1

Mathematica, 62 61 60 octets

2 octets enregistrés en raison de @MartinEnder .

MatchQ[{a:1...,b___}/;{b}==-{a}]@*Differences@*IntegerDigits

Composition des fonctions. Prend un nombre en entrée et retourne Trueou Falseen sortie.

LegionMammal978
la source
1

Retina, 55 54 36 octets

Le nombre d'octets suppose un codage ISO 8859-1.

.
$*1:
+`^(1+:)(1\1.*)\b\1$
$2
^1+:$

Essayez-le en ligne

Convertissez chaque chiffre en unaire, séparé par des deux points. Boucle, en supprimant les chiffres externes correspondants si le prochain chiffre est un. Correspond à un seul chiffre restant.

mbomb007
la source
1
Cela accepte12312
Martin Ender
1

PHP, 71 octets

for($t=$i=max(str_split($s=$argv[1]));$t!=$s&&--$i;)$t="$i$t$i";echo$i;

récupère le chiffre le plus élevé de l'entrée et décompte, en ajoutant le nouveau chiffre à une chaîne de comparaison jusqu'à ce que l'entrée et la chaîne de comparaison soient égales - ou $isoit 0.

imprime le chiffre le plus bas pour un numéro Timmy, 0sinon.

Titus
la source
1

Pushy , 30 15 octets

Je me suis réveillé ce matin et je me suis rendu compte que je pouvais faire la moitié de la longueur de ma réponse ...

s&K-kL2/OvhXwx#

(non concurrente car le défi linguistique postdates)

Entrée est donnée sur la ligne de commande: $ pushy gizas.pshy 3456543. Sorties 1pour la vérité et 0pour la fausseté. Voici la ventilation:

s                  % Split the number into its individual digits
 &K-               % Subtract all digits by the last 
    kL2/  h        % Get the halved length of the stack (+1)
        Ov X       % In stack 2, generate range (0, halved length)
            w      % Mirror the range 
             x#    % Check stack equality and output

L'algorithme a été inspiré par la réponse bash: normalisez d'abord le nombre ( 45654 -> 01210), puis générez le nombre giza normalisé de la même longueur (il n'y en a qu'un) et comparez.


Ancienne solution

s&K-Y?kL2%?L2/:.;&OvhXx#i;;;0#
FlipTack
la source
1

Raquette 292 octets

(let*((s(number->string n))(sn string->number)(st string)(lr list-ref)(sl(string->list s))(g(λ(i)(-(sn(st(lr sl(add1 i))))
(sn(st(lr sl i)))))))(cond[(even?(string-length s))#f][(not(equal? s(list->string(reverse sl))))#f][(andmap identity
(for/list((i(floor(/(length sl)2))))(= 1(g i))))]))

Ungolfed:

(define(f n)
  (let* ((s (number->string n))
         (sn string->number)
         (st string)
         (lr list-ref)
         (sl (string->list s))
         (g (λ (i) (- (sn(st(lr sl (add1 i))))
                      (sn(st(lr sl i)))))))
    (cond
      [(even? (string-length s))
       #f]
      [(not(equal? s (list->string (reverse sl))))
       #f]
      [else
       (andmap identity
               (for/list ((i (floor(/(length sl)2))))
                 (= 1 (g i))))]
      )))

Essai:

(f 12321) 
(f 123321)  ; only this should be false; 

(f 9)
(f 787)
(f 67876)
(f 4567654)
(f 123454321)
(f 12345654321)
(f 1234567654321)
(f 123456787654321)
(f 12345678987654321)

Sortie:

#t
#f
#t
#t
#t
#t
#t
#t
#t
#t
#t
rnso
la source
1

Java 8, 162 + 19 octets

19 pour import java.util.*;

s->{List f=new ArrayList();for(int i=0;i<9;){String l=String.valueOf(++i);for(int j=i;j>0;){f.add(l);String k=String.valueOf(--j);l=k+l+k;}}return f.contains(s);}

Une approche différente de l'autre réponse Java, je voulais essayer d'utiliser la méthode de création de tous les nombres possibles de Timmy et de vérifier si notre chaîne y était contenue.

Xanderhall
la source
1

Octave, 56 octets

@(n)nnz(n)<2||~(abs(diff(+n))-1)&&diff(+n(1:1+end/2))==1

Découvrez tous les cas de test ici .

Ce serait deux octets de moins dans MATLAB, car cela diff(n)fonctionne pour les chaînes. Dans Octave, vous avez besoin diff(+n).

Explication:

@(n)                  % Anonymous function taking a string `n` as argument
    nnz(n)<2          % True if there is only one element in n
            ||        % Short circuit or operator. Expression will be true if this is true
~(abs(diff(+n))-1)    % Takes the absolute value of the difference between adjacent numbers
                      % which should always be 1. Subtracts 1, to get 0
                      % and negates it to get 1 (true)
diff(+n(1:1+end/2))==1   % Checks if the difference between the first half of the numbers
                         % is 1.
                      % If either the first, or both the second and third argument is true
                      % then the function will return 1, otherwise 0. 
Stewie Griffin
la source
1

Mathematica, 56 octets

C'est un peu plus court:

MatchQ[Differences@IntegerDigits@#,{a:1...,b__}/;b==-a]&
Kelly Lowder
la source
1

Java 7, 129 119 109 octets

boolean e(char[]a){int l=a[0]-1,f=0,b=a.length-1;for(;f<b&&a[f]==++l&a[f++]==a[b--];);return f==b&l==a[b]-1;}

Ancienne méthode récursive, 119

boolean b(char[]a){int b=a.length;return b>1&&a[0]==a[b-1]&a[0]+1==a[1]?b(java.util.Arrays.copyOfRange(a,1,b-1)):b==1;}

-10 octets grâce à Geobits. Nous sommes liés

Essayez-le en ligne!

Poussée
la source
Je pense que vous pourriez économiser 1 octet avec bitwise and, je pense que vous l'avez utilisé une fois mais pas l'autre fois? Ou je le lis mal.
Yodle
@Yodle Je ne l'ai utilisé qu'une fois parce que je dois court-circuiter pour la première condition.
Poke
1
It looks like you're only using the import once, so you should be able to shorten this by using java.util.Arrays.copyOfRange(...) to skip the import line.
Geobits
@Geobits good catch... I derp
Poke
0

Cjam, 35 bytes

Probably very suboptimal... I'm a little out of practice!

q__W%=\_,_2%@@2/)<2ew{:-}%e`,1=]:e&

Try it online!

A Simmons
la source
0

Python 2, 50 82 81 80 bytes

def f(a):b=len(a)/2+1;print(1,0)[a[:b-1]!=a[b:][::-1]or a[:b]not in'123456789']

Simple approach. Just splits the string in half (missing out the middle character or one after the middle character if it is of even length), reverses the second half then compares the two and compares the first half with a string of 1 to 9.

Edit

Reposted after constructive feedback from fellow golfers and realising and correcting my mistakes.

-1 for losing a (waste of) space

-1 for reading the question again and realising that we don't need to take 0 into account. Really must stop golfing after a long day at work.

ElPedro
la source
1
This doesn't check if numbers are strictly increasing by one. For example, 13531, and 6543456 both incorrectly return True.
DJMcMayhem
1
Also, the strings '0' and '1' are both truthy.
Dennis
Absolutely right. It's been a long day. Will delete as invalid.
ElPedro
4
Thanks for the comments and not just downvoting.
ElPedro