Imprimer le Nième nombre non palindromique

22

Un nombre palindromique (au cas où vous ne le sauriez pas) est un nombre qui se lit de la même manière en arrière et en avant (exemple, 11). Les 15 premiers numéros non palindromiques sont: 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26. Ceci est A029742 . J'ai constamment besoin de ces chiffres, mais mon bloc-notes est très petit, donc votre code doit être aussi court que possible.

Règles

  • Chaque soumission doit être un programme ou une fonction complète (par exemple, en C, vous ne pouvez pas simplement définir une fonction sans en-têtes, mais vous pouvez définir une fonction AVEC les en-têtes nécessaires).
  • Si c'est possible, fournissez un lien vers un site où votre programme peut être testé.
  • Votre programme ne doit rien écrire STDERR.
  • Vous pouvez prendre la saisie comme argument ou de STDIN(ou l'alternative la plus proche dans votre langue).
  • Les programmes sont notés en octets . Le jeu de caractères habituel est UTF-8, si vous en utilisez un autre, veuillez le préciser.
  • Les failles standard sont interdites.

Cas de test

1
==> 10

-----

5
==> 15

-----

12
==> 23

Notation

C'est le , donc le moins d'octets gagne.

Soumissions

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), 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

Classement

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

George Gibson
la source
1
Des tests?
Leaky Nun
@KennyLau Je vais en faire.
George Gibson
Pouvons-nous utiliser un index basé sur 0, 15serait donc le 4ème nombre?
nimi
@nimi Soit, mais veuillez préciser si le vôtre est indexé 0.
George Gibson
@nimi Désolé, c'est ce que je voulais dire, ont modifié pour clarifier.
George Gibson

Réponses:

9

Pyth, 7 octets

e.f!_I`

Suite de tests

Explication:

e.f!_I`
e.f!_I`ZQ    Implicit variable introduction.
 .f     Q    Find the first Q numbers whether the following is truthy,
             starting at 1, where Q is the input.
      `Z     Convert the number to a string.
     _I      Check if it's the same when reversed.
    !        Logical not.
 e           Return the last element of the list.
isaacg
la source
5

Haskell, 38 octets

([x|x<-[1..],(/=)<*>reverse$show x]!!)

Utilise un index basé sur 0. ([x|x<-[1..],(/=)<*>reverse$show x]!!) 11-> 23.

Le test de maintien ou non d'un nombre se (/=)<*>reverse$show xtraduit par (show x) /= (reverse (show x)), c'est- à -dire vérifier si la représentation sous forme de chaîne du nombre n'est pas égale à l'inverse de la représentation sous forme de chaîne.

nimi
la source
4

Brachylog , 14 11 octets

;0{<≜.↔¬}ⁱ⁽

-3 octets réservoirs à fataliser

Explication

; {      }ⁱ⁽        --  Find the nth number
 0                  --      (starting with 0)
   <                --      which is bigger then the previous one
    ≜               --      make explicit (otherwise it fucks up)
      .             --      which is the output
       ↔            --      and if reversed
        ¬           --      is not the output

Essayez-le en ligne!

Kroppeb
la source
;İ{ℕ≜.↔¬}ᶠ⁽test de 2 octets plus court.
Fatalize
En fait, l'utilisation iterateest plus courte d'un octet:;0{<≜.↔¬}ⁱ⁽
Fatalize
3

Gelée, 9 octets

1 octets grâce à @ Sp3000 .

ṚḌ_
0dz#Ṫ

Essayez-le en ligne!

Suite de tests.

Explication

DUḌ_   Helper link. Check if x is not palindrome.

D      Convert to decimal.
 U     Reverse.
  Ḍ    Convert back to integer.
   _   Subtract x from the result above.
       For 23, this will yield 32-23 = 9.
       Only yield 0 (falsy) if x is palindrome.
       If x is not a palindrome,
       it will return a truthy number.


0dz#Ṫ  Main link.

0      Start from 0.
   #   Find the first         numbers:
  ³                   <input>
 Ç         where the above link returns a truthy number.
    Ṫ  Yield the last of the matches.
Leaky Nun
la source
1
Fait amusant: essayez123Ṛ
Sp3000
@ Sp3000 Très intéressant en effet!
Leaky Nun
Vous pouvez supprimer le ³. Si vous placez l'entrée sur STDIN, vous pouvez également supprimer le 0. (Dans la dernière version de Jelly, ṚḌ_ø#Ṫça marche aussi, mais c'est plus récent que ce défi.)
Dennis
Ça ne marche pas pour moi ...
Leaky Nun
7 octets mais il peut utiliser des fonctionnalités plus récentes
caird coinheringaahing
3

05AB1E , 8 octets

Code:

µNÂÂQ>i¼

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Adnan
la source
Cela a probablement quelque chose à voir avec l'ancienne version de 05AB1E, mais par curiosité: pourquoi la double bifurquée Â? PS pour toute autre personne lisant ceci: peut maintenant être de 5 octets µNÂʽ.
Kevin Cruijssen
@KevinCruijssen: Probablement en raison de l'absence de sortie implicite de N (uniquement en haut de la pile). De plus, il peut être de 4 octets maintenant car le ½est également implicite.
Emigna
@Emigna Ah, complètement oublié d' ½être implicite, même si je l' ai mentionné dans un conseil que je me suis écrit ..>. <Thought la ¼(augmentation counter_variable par 1) était implicite pour la boucle while µpour un moment, mais il est en effet le ½( si le haut de la pile est 1: augmentez counter_variable de 1) à la place ..
Kevin Cruijssen
3

Clojure, 62 octets

#(nth(for[i(range):when(not=(seq(str i))(reverse(str i)))]i)%)

0 indexé. Générez une plage paresseusement infinie de nombres non palindromiques en utilisant la compréhension de la liste et prenez icelle-ci. Voir en ligne: https://ideone.com/54wXI3

cliffroot
la source
2

PowerShell v2 +, 65 octets

for(;$j-lt$args[0]){if(++$i-ne-join"$i"["$i".length..0]){$j++}}$i

Boucle à travers les nombres de 0(valeur implicite pour non initialisé $i) jusqu'à ce que nous trouvions l'entrée de $args[0]nombreuses correspondances, puis génère la dernière. Notez que nous n'initialisons pas la boucle, c'est donc $j=0implicite.

Chaque itération, nous pré-incrémentons $iet vérifions si elle n'est pas égale à $iinversée. Si c'est le cas, cela signifie que nous avons trouvé un non-palindrome, alors incrémentez $j. La boucle se poursuit ensuite autant de fois que nécessaire.

Exemples

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 100
120

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 5
15

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 55
70

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 212
245
AdmBorkBork
la source
2

Python 2, 60 octets

f=lambda n,i=0,j=1:j>n and i-1or f(n,i+1,j+(`i`!=`i`[::-1]))

Fonction à un index qui prend en entrée l' nargument via et retourne le ne nombre non palindromique.

Comment ça marche

Il s'agit d'une recherche récursive exhaustive, qui teste consécutivement des nombres entiers idans la plage [1,∞)jusqu'à ce que ndes nombres non palindromiques aient été trouvés; puisque iest pré-incrémenté, i-1est ensuite renvoyé. Tester si un nombre est palindromique est effectué en convertissant en chaîne, en inversant, puis en vérifiant si les chaînes d'origine et inversées sont égales.

Le code est logiquement équivalent à:

def f(n,test=0,count=1):
    if count>n:
        return test
    elif str(test)!=reversed(str(test)):
        return f(n,test+1,count+1)
    else:
        return f(n,test+1,count)

qui lui-même est essentiellement:

def f(n):
    test=0
    count=1
    while count<=n:
        if str(test)!=reversed(str(test)):
            count+=1
        test+=1
    return test-1

Essayez-le sur Ideone

TheBikingViking
la source
2

Clojure, 62 octets

#(nth(filter(fn[i](not=(seq i)(reverse i)))(map str(range)))%)

Une approche assez différente de l'autre réponse, mais de longueur égale.

NikoNyrh
la source
2

R , 133 117 93 76 octets

-16 octets grâce à JayCe. -41 octets grâce à Giuseppe.

x=scan();while({F=F+any((D=T%/%10^(1:nchar(T)-1)%%10)!=rev(D));F<=x})T=T+1;T

Essayez-le en ligne!

Robert S.
la source
1
Vous pouvez abuser de quelques octets F, etc.: TIO . Aussi, pourquoi restreignez-vous la boucle à (0:97)+10?
JayCe
1
utilisez le conseil n ° 3 de ma réponse Conseils pour jouer au golf en R pour extraire les chiffres; vous pouvez faire all(D==rev(D))Dest un vecteur de chiffres. Je pense qu'une whileboucle sera plus courte, et comme @JayCe le demande, pourquoi ne vérifiez-vous que les nombres entre 10 et 107?
Giuseppe
@Giuseppe Mis à jour avec vos recommandations. Encore un peu confus sur la façon de mettre en œuvre unwhile boucle tout en économisant des octets.
Robert S.
1
@RobertS. si vous avez des questions, n'hésitez pas à me cingler dans le salon R !
Giuseppe
2

Forth (gforth) , 103 99 octets

: f 9 swap 0 do begin 1+ dup 0 over begin 10 /mod >r swap 10 * + r> ?dup 0= until = 0= until loop ;

Essayez-le en ligne!

Explication

Boucle n fois, chaque itération trouve le prochain nombre non palindromique en incrémentant un compteur de 1 jusqu'à ce que le nombre ne soit pas égal à lui-même inversé

Code non golfé

Normalement, je ne "dégonfle" pas le code, mais comme ce code est un peu compliqué, je me suis dit que cela aiderait

: reverse ( s -- s )
    0 swap 
    begin 
        10 /mod
        >r swap
        10 * +
        r> ?dup 0=
    until 
; 

: f ( s -- s )
    9 swap 0
    0
    do
        begin
            1+ dup dup
            reverse =
        0= until
    loop
;

Explication du code

: f                \ start a new word definition
  9                \ start at 9, since all positive ints < 10 are palindromic
  swap 0           \ set up loop parameters from 0 to n-1
  do               \ start a counted loop       
    begin          \ start an indefinite loop
      1+ dup       \ increment counter and place a copy on the stack
      ( Reverse )
      0 over       \ add 0 to the stack (as a buffer) and copy the top counter above it
      begin        \ start another indefinite loop
        10 /mod    \ get the quotient and remainder of dividing the number by 10
        >r         \ store the quotient on the return stack
        swap 10 *  \ multiply the current buffer by 10
        +          \ add the remainder to the buffer
        r>         \ grab the quotient from the return stack
        ?dup       \ duplicate if not equal to 0
        0=         \ check if equal to 0
      until        \ end inner indefinite loop if quotient is 0
      ( End Reverse )
      = 0=         \ check if counter =/= reverse-counter            
    until          \ end the outer indefinite loop if counter =/= reverse-counter
  loop             \ end the counted loop
;                  \ end the word definition 
reffu
la source
1

Perl 6 , 29 octets

{grep({$_!= .flip},^Inf)[$_]}

(utilise un index basé sur 0)

{         # The $_ is implied above
  grep(   # V
    { $_ != $_.flip }, # only the non-palindromic elements of
    ^Inf               # an Infinite list ( 0,1,2,3 ...^ Inf )
  )[ $_ ]              # grab the value at the given index
}

Usage:

my &non-palindrome = {grep({$_!= .flip},^Inf)[$_]}

say non-palindrome 1  - 1; # 10
say non-palindrome 5  - 1; # 15
say non-palindrome 12 - 1; # 23

# this also works:
say non-palindrome 0..20;
# (10 12 13 14 15 16 17 18 19 20 21 23 24 25 26 27 28 29 30 31 32)
Brad Gilbert b2gills
la source
1

En fait, 17 octets

;τR9+;`$;R=Y`M@░E

Essayez-le en ligne!

Les valeurs sont indexées 1. Cela pourrait être facilement changé en 0 indexé en remplaçant le premier Rpar r. Mais Rc'est ce que j'ai initialement tapé, c'est donc ce que je veux dire.

Les nombres non palindromiques satisfont a(n) ≈ n + 10, ainsi 2n+9est une limite supérieure suffisante.

Explication:

;τR9+;`$;R=Y`M@░E
;τ9+R;             push n, range(1,(2*n)+10)
      `$;R=Y`M@░   take values that are not palindromic
                E  take nth element
Mego
la source
1

JavaScript (ES6), 54 octets

Utilise l'indexation basée sur 1. Fonctionne uniquement jusqu'au numéro 7624.

d=(i,a=0)=>i?d(i-=++a!=[...''+a].reverse().join``,a):a

Usage

d=(i,a=0)=>i?d(i-=++a!=[...''+a].reverse().join``,a):a
d(1)
10
d(123)
146
d(7624)
7800
d(7625)
// Uncaught RangeError: Maximum call stack size exceeded

JavaScript (ES6), 59 octets

N'utilise pas de récursivité et peut donc gérer des entrées beaucoup plus importantes.

i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a")

Usage

(i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(1)
10
(i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(7625)
7801
(i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(123456)
124579
Dom Hastings
la source
1

Javascript (à l'aide d'une bibliothèque externe) (97 octets)

n=>_.Sequence(n,i=>{i=_.From(i+"");if(!i.Reverse().SequenceEqual(i)){return i.Write("")}}).Last()

Lien vers la bibliothèque: https://github.com/mvegh1/Enumerable

Explication du code: la bibliothèque a une méthode statique appelée séquence, où le premier paramètre définit le nombre d'éléments que la séquence garantira de créer, et le deuxième paramètre est un prédicat acceptant la valeur d'itération actuelle, "i". Le prédicat convertit l'entier en une chaîne, qui est convertie en un tableau de caractères en appelant _.From. Le tableau de caractères est comparé à l'inversion du tableau de caractères, et s'ils ne sont pas égaux, le tableau de caractères est joint à nouveau dans une chaîne et renvoyé. Sinon, rien n'est retourné (ie le résultat n'est pas défini, ce que la bibliothèque ignorera toujours). Enfin, le dernier élément de la séquence, c'est-à-dire le Nième élément est retourné

entrez la description de l'image ici

applejacks01
la source
1

C, 84 octets

La fonction f(n)prend un entier net retourne n-thun nombre non palindromique (basé sur 1).

g(n,r){return n?g(n/10,r*10+n%10):r;}s;f(n){for(s=9;n--;g(++s,0)==s&&s++);return s;}

Testez-le sur Ideone!

C'est un code assez trivial, donc il y a probablement de la place pour des améliorations.

Jasmes
la source
Suggérer à la n=n?g(n/10,r*10+n%10):r;}s;f(n){for(s=9;n--;g(++s,0)-s||s++);n=s;place dereturn n?g(n/10,r*10+n%10):r;}s;f(n){for(s=9;n--;g(++s,0)==s&&s++);return s;
plafondcat
1

Rubis, 54 octets

Cette fonction est indexée 1 et est partiellement basée sur la réponse Javascript de Dom Hastings . Je pense qu'il y a un moyen de mieux jouer au golf, surtout avec cette dernière condition ternaire. De plus, cette fonction retourne actuellement une chaîne, qui devra peut-être être modifiée ultérieurement. Toutes les suggestions de golf sont les bienvenues.

f=->x,y=?9{x<1?y:(y.next!.reverse!=y)?f[x-1,y]:f[x,y]}

Non golfé:

def f(x, y="9")
 if x<1
  return y
 else
  y = y.next
  if y.reverse != y
   return f(x-1, y)
  else
   return f(x, y)
  end
 end
end
Sherlock9
la source
1

C ++ (GCC), 148 octets

Il est basé sur 1 et l'algorithme est vraiment naïf

#import <iostream>
using namespace std;int n,i=1;string s;main(){cin>>n;while(s=to_string(i+1),(n+=equal(begin(s),end(s),s.rbegin()))-i++);cout<<i;}
FoxyZ
la source
@enedil concernant votre édition: #importest une extension de compilation de gcc. Il est obsolète, mais cela n'a pas vraiment d'importance ici
ovs
1

APL NARS 35 caractères

r←v a;c
r←c←0
A:r+←1⋄c+←r≠⍎⌽⍕r⋄→A×⍳c<a

c'est la fonction v; "⍎⌽⍕" r traslate nombre r dans la chaîne, inversez cette chaîne, traslate de chaîne en nombre. Fonctions de test et d'aide:

  ⍝ return the one string for the basic types ('Char', 'Int', 'Float', 'Complex or Quaternion or Oction')
  ⍝ or one string for composite types ('Tensor 3' 'Tensor 4' etc 'Matrix', 'List', 'String')
  ⍝ follow the example in: /codegolf//a/39745
  type←{v←⍴⍴⍵⋄v>2:'Tensor ',⍕v⋄v=2:'Matrix'⋄(v=1)∧''≡0↑⍵:'String'⋄''≡0↑⍵:'Char'⋄v=1:'List'⋄⍵≢+⍵:'Complex or Quaternion or Oction'⋄⍵=⌈⍵:'Int'⋄'Float'}
  h←{'Int'≢type ⍵:¯1⋄(⍵<1)∨⍵>2e5:¯1⋄v ⍵} 
  h 1
10
  h 1.32
¯1
  h 7878
8057
  h¨3 5 12
13 15 23 
  h 6 7 8
¯1
  h '123'
¯1
  h '1'
¯1
  h 1.0
10
  h 1.0003
¯1
  h ¯2
¯1
  h 0
¯1
  h 200000
201200
  h 200001
¯1
RosLuP
la source
1

Husk , 6 octets

Ouais pour :)

!fS≠↔N

Essayez-le en ligne!

Explication

 f   N  -- filter the naturals by:
  S≠    --   is it not equal to..
    ↔   --   ..itself reversed
!       -- index into that list
ბიმო
la source
1

C # 7, 89 octets

n=>{int i=9;for(;n-->0;)if(Enumerable.SequenceEqual(++i+"",(""+i).Reverse()))i++;return i;}

1 indexé Try on Repl.It

n=>
  int i = 9;                                  | Start at 9. Iterate exactly n times. Assume n >= 1      
  for(;n-->0;)                                | Iterate n times
  if(EnumerableSequenceEqual(                 | Compare two sequences
  ++i+"",(""+i).Reverse())                    | Generate the forward and backward strings, which behave like char sequences for Linq
  i++                                         | If the sequences are equal, the number is a palindrome. Increment i to skip
  return i;                                   | Return the number after the for loop exits

Je ne pense pas que cela utilise des fonctionnalités de langage de c # 7, mais je l'ai mis car c'est ce que j'ai testé

ryzngard
la source
Bienvenue chez PPCG.
Jonathan Frech
1

Java 8, 117 95 94 octets

n->{int r=10;for(;n-->0;)if((++r+"").contains(new StringBuffer(r+"").reverse()))r++;return r;}

0 indexé

Explication:

Essayez-le ici.

n->{             // Method with integer as both parameter and return-type
  int r=10;      //  Result-integer, starting at 10
  for(;n-->0;)   //  Loop an amount of times equal to the input
    if((++r+"")  //   First raise `r` by 1, and then check if `r`
               .contains(new StringBuffer(r+"").reverse()))
                 //   is the same as `r` reversed (and thus a palindrome)
      r++;       //    And if it is: raise `r` by 1 again
  return r;}     //  Return result-integer
Kevin Cruijssen
la source
@ceilingcat Cela donne des résultats incorrects .. new StringBuffer(int)n'est pas égal à new StringBuffer(String), ni String.equals(StringBuffer)au lieu de String.equals(String).. Ceci est cependant une vieille réponse, donc je peux l'utiliser (++r+"").contains(new StringBuffer(r+"").reverse())pour économiser 1 octet.
Kevin Cruijssen
-2

TCC, 11 octets

?>!~<>;i;'T

Essayez-le en ligne!

            | Printing is implicit
?>          | Find n-th number for which the following is "T":
  !~        | If not equal...
    <>;     | reverse. No value specified, so input is assumed.
       i;   | Input, since double semicolons are ignored
         'T | ... print string "T"
brianush1
la source
1
Cela ne fonctionne pas avec le tcc.luafichier avec horodatage 16-07-26 12:46 UTC, qui n'avait pas la ?>commande. Si votre réponse nécessite une version de la langue postérieure au défi, vous devez la marquer comme non concurrente dans l'en-tête. Je supprimerai mon downvote quand vous le ferez.
Dennis
@Dennis Je suis tombé sur ce post vieux de deux ans et je voulais mentionner que les réponses ne doivent plus être marquées comme non concurrentes lorsque leur langue est postérieure au défi.
Jonathan Frech