Faisons un peu de "deciph4r4ng"


58

Dans ce défi, votre tâche consiste à déchiffrer une chaîne. Heureusement, l'algorithme est assez simple: en lisant de gauche à droite, chaque chiffre N rencontré (0 à 9) doit être remplacé par le caractère précédant de N + 1 positions.

Exemple

La chaîne d'entrée "Prog2am0in6"serait décodée de cette façon:

exemple

Par conséquent, le résultat attendu est "Programming".

Clarifications et règles

  • La chaîne en entrée contiendra exclusivement des caractères ASCII compris entre 32 et 126. Vous pouvez supposer qu'il ne sera jamais vide.
  • La chaîne déchiffrée d'origine est garantie de ne contenir aucun chiffre.
  • Une fois qu'un caractère a été décodé, il peut être référencé par un chiffre ultérieur. Par exemple, "alp2c1"devrait être décodé comme "alpaca".
  • Les références ne seront jamais entourées d'une chaîne: seuls les caractères précédents peuvent être référencés.
  • Vous pouvez écrire un programme complet ou une fonction qui imprime ou produit le résultat.
  • C'est le code golf, donc la réponse la plus courte en octets est gagnante.
  • Les échappatoires standard sont interdites.

Cas de test

Input : abcd
Output: abcd

Input : a000
Output: aaaa

Input : ban111
Output: banana

Input : Hel0o W2r5d!
Output: Hello World!

Input : this 222a19e52
Output: this is a test

Input : golfin5 3s24o0d4f3r3y3u
Output: golfing is good for you

Input : Prog2am0in6 Puz0les7&1Cod74G4lf
Output: Programming Puzzles & Code Golf

Input : Replicants 4re3lik448ny3oth8r5mac6in8.8T64y'r371it9376a1b5n1fit7or2a1h2z17d.
Output: Replicants are like any other machine. They're either a benefit or a hazard.

Pouvons-nous recevoir l’entrée sous forme de tableau de chaînes de caractères uniques? Pouvons-nous supposer que le nombre ne sera jamais supérieur à 9?
Fəˈnɛtɪk

@ fəˈnɛtɪk En ce qui concerne le format d'entrée: je dirais non, à moins qu'il s'agisse du seul format acceptable pour votre langue. Nous avons affaire à un chiffre plutôt qu'à un nombre. Donc oui: il est garanti d’être <= 9 mais vous pouvez rencontrer plusieurs chiffres à la suite.
Arnauld

Serait 1bbabune entrée valide (avec la sortie attendue de abbab)? En d'autres termes, les références peuvent-elles entourer la chaîne?
Luc

@ Lucas Bon point. Non, 1bbabn'est pas valide. J'ai ajouté une clarification à ce sujet.
Arnauld

Réponses:


11

Gelée , 9 7 octets

~ịṭṭµ@/

Essayez-le en ligne!

Comment ça fonctionne

~ịṭṭµ@/  Main link. Argument: s

    µ    Combine the four links to the left into a chain (arity unknown).
     @   Swap the chains arguments. This makes it dyadic.
      /  Reduce s by the chain with swapped arguments. It will be called with
         right argument r (the result of the previous call, initially the first 
         character) and left argument c (the next character of s).
~            Bitwise NOT of c. This maps a digit 'd' to ~d = -(d+1), but all 
             non-digit characters 'D' to 0.
  ṭ          Tack; append c to r.
 ị           Index; select the character of the result to the right at the
             index from the result to the left. Indexing is 1-based and modular,
             so 0 is the last character, -1 the second to last, etc.
   ṭ         Tack; append the resulting character to r.    

13

Java 7, 81 à 80 octets

void a(char[]a){for(int i=0;++i<a.length;)if(a[i]>47&a[i]<58)a[i]=a[i-a[i]+47];}

Essayez-le en ligne!

Sauvé 1 octet grâce à Anders Tornblad . Le premier caractère ne peut pas être un chiffre, il n'a donc pas besoin d'être vérifié, ce qui signifie que nous pouvons effectuer une pré-incrémentation avant de vérifier notre condition de fin.


2
Comme le premier caractère ne peut jamais contenir un chiffre, vous n'avez pas à le vérifier. Par conséquent, votre boucle peut être for(int i=0;++i<a.length;){au lieu de cela, en sauvant un caractère.
Anders Tornblad

12

Haskell, 55 octets

o#c|c>'/',c<':'=o!!read[c]:o|1<2=c:o
reverse.foldl(#)[]

Exemple d'utilisation: reverse.foldl(#)[] $ "Prog2am0in6 Puz0les7&1Cod74G4lf"-> "Programming Puzzles & Code Golf". Essayez-le en ligne!

Réduisez la chaîne en une copie inversée d'elle-même avec les nombres remplacés par les caractères correspondants. "reverse", car de cette façon, nous avons un accès facile à la chaîne jusqu'à présent lors de l'indexation des nombres. Inverser à nouveau.


1
Wow, j'ai écrit cette solution exacte mais j'ai mis du temps à la poster :) Eh bien, au moins maintenant je sais que c'était une bonne solution, +1
Leo

11

C, 46 octets

f(char*s){for(;*s++;)*s=s[(*s-52)/6?0:47-*s];}

Essayez-le en ligne!


C,  52   49  48 octets

Merci à @ l4m2 d'avoir économisé un octet!

f(char*s){for(;*s++;)*s>47&*s<58?*s=s[47-*s]:0;}

Édite directement la chaîne d'entrée.

Essayez-le en ligne!

Version alternative à 50 octets:

f(char*s){for(;*s++;)*s=abs(*s-57)>9?*s:s[47-*s];}

Version récursive, 48 octets:

f(char*s){*s>47&*s<58?*s=s[47-*s]:0;*s++&&f(s);}

9

05AB1E , 11 octets

vydiÂyèëy}J

Essayez-le en ligne!

Explication

v            # for each character y in input
 ydi         # if y is a digit
    Â        #    push a reversed copy of the string we've built up so far
     yè      #    push the character at index y in the reversed string
       ë     # else
        y    #    push y
         }   # end if
          J  # join stack to a single string
             # output top of the stack at the end of the loop

J'ai vraiment besoin de vérifier si vous avez déjà répondu plus souvent avant de commencer.
Urne Octopus Magique

@carusocomputing: Vous pouvez toujours imaginer une meilleure astuce que celle que j'ai utilisée;)
Emigna

7

JavaScript (ES6), 59 53 octets

f=x=>/\d/.test(x)?f(x.replace(/\d/,(m,o)=>x[o+~m])):x

Sauvegardé 7 octets grâce à fəˈnɛtɪk.

f=x=>/\d/.test(x)?f(x.replace(/\d/,(m,o)=>x[o+~m])):x

console.log(f("Prog2am0in6"));
console.log(f("abcd"));
console.log(f("a000"));
console.log(f("ban111"));
console.log(f("Hel0o W2r5d!"));
console.log(f("this 222a19e52"));
console.log(f("golfin5 3s24o0d4f3r3y3u"));
console.log(f("Prog2am0in6 Puz0les7&1Cod74G4lf"));
console.log(f("Replicants 4re3lik448ny3oth8r5mac6in8.8T64y'r371it9376a1b5n1fit7or2a1h2z17d."));


.charAt (...) peut être remplacé par [...] pour une économie de 7 octets
fnɛtɪk

x.charAt (...) équivaut à x [...]
fnɛtɪk

@ fəˈnɛtɪk Oui, je pensais avoir déjà essayé cela, mais une erreur s'est produite. Merci!
Tom

1
o-m-1peut être remplacé par o+~m.
Neil

2
Comme f est appelé de manière récursive, le nombre de caractères du programme doit inclure la f=partie. Il s’agit donc de 54 octets et non de 52.
user5090812

5

Retina , 37 octets

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

\d
$*«»
r1+`(?<=(.)(?<-2>.)*)(«)*»
$1

Essayez-le en ligne!

Explication

\d
$*«»

Remplacez chaque chiffre d par d « s, suivi d'un ». Nous avons besoin de ce dernier a) pour pouvoir reconnaître les positions où d = 0 et b) comme séparateur entre les chiffres adjacents.

r1+`(?<=(.)(?<-2>.)*)(«)*»
$1

Répétez ( +) associez l'expression régulière sur la première ligne de droite à gauche ( r), puis remplacez le match le plus à gauche ( 1) par le remplacement de la deuxième ligne.

La regex elle-même correspond à l'un de nos chiffres maintenant unaires et compte le nombre de «s dans le groupe 2. La recherche arrière associe ensuite d caractères à (?<-2>.)*avant de capturer le caractère référencé dans le groupe 1. La chaîne de «s et »est ensuite remplacée par le caractère capturé .


5

MATL , 21 19 17 16 octets

"@t4Y2m?UQ$y]]&h

Essayez-le sur MATL Online!

Explication

        % Implicitly grab input as a string
"       % For each character in the input
  @     % Push that character to the stack
  t     % Make a copy of it
  4Y2   % Push the pre-defined array '0123456789' to the stack
  m     % Check if the current character is part of this array (a digit)
  ?     % If it is
    UQ  % Convert it to a number and add 1 (N)
    $y  % Make a copy of the element N-deep in the stack. MATL uses one-based indexing
        % So 1$y is the element at the top of the stack, 2$y is the next one down, etc.
  ]     % End of if statement
        % Non-digit characters remain on the stack as-is
]       % End of for loop
&h      % Horizontally concatenate the entire stack to form a string
        % Implicitly display the result

Belle utilisation de $ydans la nouvelle version!
Luis Mendo

@LuisMendo Merci! Les langues basées sur les piles conviennent parfaitement à ce défi
Suever

@LuisMendo Malheureusement, cela aurait pu être encore plus court si on Une travaillait que pour les chiffres. Malheureusement, les 'e'Urendements exp(1)ont été sinon, j'aurais pu me débarrasser de ces 4Y2trucs
Suever

Une autre de ces choses Octave ...
Luis Mendo

4

JavaScript (ES6), 51 octets

f=
s=>s.replace(/\d/g,(c,i)=>a[i]=a[i+=~c]||s[i],a=[])
<input oninput=o.textContent=f(this.value)><pre id=o>

a est utilisé pour stocker les chiffres remplacés pour traiter les chiffres faisant référence à d'autres chiffres.


`` `s => s.remplace (a = / \ d / g, (c, i) => a [i] = a [i + = ~ c] || s [i])` ``
l4m2

3

Perl 5 , 34 octets

33 octets de code + -pdrapeau.

s/\d/substr$_,-$&-1+pos,1/e&&redo

Essayez-le en ligne!

s/\d/.../eremplace le premier chiffre par ...évalué en tant que code Perl. (avec ...être substr$_,-$&-1+pos,1dans ce cas. substr$_,-$&-1+pos,1renvoie la sous-chaîne de $_longueur 1à index -$&-1+pos, où $&est le nombre qui vient de correspondre, et qui posest l'index du début de la correspondance. Nous devons juste redosi le remplacement a réussi pour remplacer chaque chiffre. (et le résultat est implicitement imprimé grâce à -pflag).


Ancienne approche, 47 octets:

44 octets de code + -Fdrapeau.

map{$F[$i]=$F[$i-$_-1]if/\d/;++$i}@F;print@F

Essayez-le en ligne!

Assez simple en fait. -Fflag divise les entrées de chaque caractère en @F. map{...}@Fitère à travers @F(c'est-à-dire chaque caractère de l'entrée). Si le caractère est un chiffre ( /\d/), nous le remplaçons par le caractère à l'index $i-$_-1. Le $iest la variable d'index actuelle (que nous maintenons en incrémentant à chaque caractère vu).


3

JavaScript ES6, 61 59 octets

Merci @ Luke pour le golf de 8 octets

x=>[...x].map((p,i,a)=>a[i]=/\d/.test(p)?a[i-1-p]:p).join``

Essayez-le en ligne!


x.split``pourrait aussi être [...x], [0-9]pourrait être \d, ensemble sauver 6B
Luke

A actuellement une erreur quelque part alors va résoudre ce problème en premier
fnɛtɪk

x=>[...x].map((p,i,a)=>+p+1?a[i-1-p]:p).join``pour 46 octets
Luke

Échec pour les espaces + "" donne 0, ce qui lui permet de saisir le caractère précédent
fnɛtɪk

x=>[...x].map((p,i,a)=>a[i]=1+p>9?a[i-1-p]:p).join``
l4m2

3

05AB1E , 27 17 octets

vyDdiU)DRXèU`X}}J

Essayez-le en ligne!

vy             }  # For each character
  Dd              #   Push is_number
    i         }   #   If it is
     U            #     Save save it
      )DR         #     Wrap the (reversed) stack into an array
         Xè       #     Get the character at the saved index
           U`X    #     Flatten the whole stack
                J # Join 

2

CJam, 13 octets

q{_A,s#)$\;}/

Démo en ligne.

Cette solution utilise l'opérateur "copier le n- ième élément de la pile" intégré de CJam $pour mettre en œuvre le décodage. Il commence par lire l'entrée (avec q), puis passe en boucle sur les caractères de la chaîne d'entrée et les dépose sur la pile (avec {}/). Toutefois, à l'intérieur du corps de la boucle, il duplique également chaque caractère après l'avoir placé dans la pile (avec _) et vérifie s'il s'agit d'un chiffre en recherchant sa position #dans la chaîne "0123456789", représentée de manière pratique par A,s.

Le résultat de cette recherche est soit la valeur numérique du chiffre, soit -1 si le caractère n'est pas un chiffre. L' )opérateur incrémente ensuite cette valeur de un et le $remplace par le caractère en cours à autant de positions situées sous le sommet de la pile. Enfin, \;supprime simplement la copie du caractère de saisie actuel que nous avons créé avec _la pile, car elle n’est plus nécessaire.


2

Befunge-98 , 45 43 octets

::::#@~\1p:1g::'9`!\'/`*j;'/--1g\1p\1g#;,1+

Essayez-le en ligne!

L'idée:

  1. Pour chaque caractère de la chaîne d'entrée,
    1. L'écrire à la ligne 2
    2. Si ce n'est pas un nombre, indiquez-le simplement
    3. Sinon, recherchez la valeur correcte, réécrivez-la, puis affichez-la
::::            ; There's a counter on the stack, duplicate it 4 times  ;
    #@~         ; Get the next char of input, exiting if there is none  ;
       \1p      ; At the location (counter, 1), write the input char    ;
          :1g   ; Re-obtain the char. Stack is now [counter * 4, input] ;

::                ; Stack: [counter * 4, input * 3]      ;
  '9`!\'/`*       ; If !(input > '9') and (input > '/')  ;
                  ; IE If ('0' <= input && input <= '9') ;
           j;...; ; Then execute the ...                 ;

; Stack: [counter * 4, input] ;
; The ... branch:             ;

'/-             ; input -> int. (input -= '/')             ;
   -            ; counter - int(input) - 1                 ;
                ; Stack: [counter * 3, lookupPosition ]    ;
    1g          ; Get the char that we want to find        ;
      \1p\1g#   ; Overwrite the current char (not the old) ;

; Both branches: ;
,1+             ; Print the number and increment the counter ;

Je n'ai pas pu obtenir cette version plus courte, mais celle-ci est de 44 octets:

s #@~\3p:3g::'9`!\'/`*j;'/--3g#;:10g3p,1+:::

Je pensais que je le partagerais à cause de l'astuce avec s- mais le stockage du compteur sur la pile conduit à cette amélioration d'un caractère



2

Python 2, 75 71 octets

s='';j=-1
for i in input():s+=s[j-int(i)]if'/'<i<':'else i;j+=1
print s

Essayez-le en ligne!

Edit: Correction pour les valeurs ASCII comprises entre 32 et 47 ; Correction pour le double décodage (par exemple "alp2c1" à "alpaca")


1
@Arnauld Nope. Désolé, je n'ai pas lu assez attentivement les spécifications. Je modifierai sous peu
junkie de maths

Il semble qu'il y ait un bug. pour 'Prog2am0in6 Puz0les7&1Cod74G4lf'vos impressions de programme Programming Puzzles &7Code1Golf! J'ai essayé avec les deux liens TIO partagés!
Keerthana Prabhakaran

@ KeerthanaPrabhakaran Merci! Fixé au prix de 0 octet! (Ma solution alternative n'a pas fait la coupe cependant)
junkie de mathématiques

C'est une bonne approche!
Keerthana Prabhakaran

Pouvez-vous expliquer '/' <i <':'. Je sais que c'est tester si c'est un nombre mais comment ça marche?
Matias K

2

PHP 7.1 67 59 octets

while(_&$c=$argn[$i++])$t.=($c^"0")<"
"?$t[~+$c]:$c;echo$t;

Prend la contribution de STDIN; courir comme pipe -nRou essayer en ligne .

  • _&$c=$s[$i++]boucle par chaîne ( _&$cil en résultera quelque chose d'autre "0"; ainsi, le seul caractère capable de rompre la boucle est la chaîne vide = fin de l'entrée)
  • $c^"0" bascule les bits 5 et 6 dans le code ascii
  • <"\n" vérifier si le résultat est <chr (10)
  • Si c'est le cas, il s'agit d'un chiffre: affiche le caractère précédent par index (et copie dans l'index actuel)
  • sinon imprimer ce personnage

Merci @Christoph d'avoir économisé 12%


1
Je sais que c'est une vieille réponse, mais: des décalages de chaîne négatifs! (et ça $s=$argn...?)for(;_&$c=$argn[$i++];)$t.=($c^"0")<"\n"?$t[~+$c]:$c;echo$t;
Christoph

2

Macro / touches Vim, 49 octets

^M représente le caractère de retour (0x0A, 1 octet).

qqqqq/[0-9]^Myl:exe 'norm '.(@"+1).'h'^Mylnphx@qq@q

Explication

qqq                                                     clear register q
   qq                                                   record into q
     /[0-9]^M                                           move the cursor to the next digit
             yl                                         yank the digit
               :exe 'norm '.(@"+1).'h'^M                move the cursor left that number of characters plus one
                                        yl              yank the char
                                          n             go back to the digit
                                           p            paste the char 
                                            hx          delete the digit
                                              @q        recursive call
                                                q       stop recording
                                                 @q     run the macro

2

APL (Dyalog Classic) , 25 23 octets

-2 octets grâce à @FrownyFrog

((⊂⌷⊢)⍣≡⍳∘≢-11|⎕d∘⍳)⊃¨⊂

Essayez-le en ligne!

les usages ⎕io←1

( ci - dessous représente une valeur intermédiaire dans l'évaluation)

⎕d est la ficelle '0123456789'

⎕d⍳⍵trouve les indices de caractères de (dans ce cas-ci) dans ⎕d; pour un non-chiffre l'index est 11

11|⍵ is modulo - les 11 deviennent des 0

≢⍵ est la longueur de

⍳≢⍵est 1 2 ...jusqu'à≢⍵

alors, (⍳≢⍵)-11|⎕d⍳⍵nous donne un vecteur i des indices où nous devrions chercher à obtenir les caractères résultants; Cependant, certains de ces indices peuvent être redirigés vers d’autres index encore (plus petits). Pour calculer la fermeture transitive (c'est-à-dire les indices effectifs), nous indexons le vecteur en lui-même ( ⊂⌷⊢un train équivalent à (⊂i)⌷iou i[i]) et nous le répétons jusqu'à ce qu'il se stabilise ( ⍣≡est connu sous le nom d' opérateur de point fixe ).

enfin nous indexons dans la chaîne d'origine: (...)⊃¨⊂


À quoi ressemblerait-il en train?
FrownyFrog

@FrownyFrog en effet, plus court
ngn


1

Japt , 24 octets

£Xn >J?U=UhYUgJ+Y-X):PÃU

Essayez-le en ligne!

Explication:

£Xn >J?U=UhYUgJ+Y-X):PÃU
£                     Ã    Iterate through the input (implicit U) 
                             X becomes the iterative item, Y becomes the index
 Xn                          Try parseInt(X)
    >J                       > -1
                               In this case, this checks if X is a digit
      ?                      If true:
       U=                      Set U to 
         UhY                     U with the char at index Y set to:     
            UgJ+Y-X               The index at -1+Y-X
                   ):        Else:
                     P         variable P (just a no-op in this case)
                       U   Finally, return U


1

Python 2 , 58 octets

lambda s:reduce(lambda t,c:t+(c+t)['/'<c<':'and~int(c)],s)

Ceci est essentiellement un portage de ma réponse Jelly, plus le contrôle des chiffres de la réponse Python de @ xnor.

Essayez-le en ligne!



1

JavaScript ES6, 54 octets

f=r=>[...r].reduce((a,s,i)=>a+(/\d/.test(s)?a[i+~s]:s))

f=r=>[...r].reduce((a,s,i)=>a+(/\d/.test(s)?a[i+~s]:s))

console.log(f("Prog2am0in6"));
console.log(f("abcd"));
console.log(f("a000"));
console.log(f("ban111"));
console.log(f("Hel0o W2r5d!"));
console.log(f("this 222a19e52"));
console.log(f("golfin5 3s24o0d4f3r3y3u"));
console.log(f("Prog2am0in6 Puz0les7&1Cod74G4lf"));
console.log(f("Replicants 4re3lik448ny3oth8r5mac6in8.8T64y'r371it9376a1b5n1fit7or2a1h2z17d."));


1
Bienvenue chez PPCG! Si vous n'avez pas besoin de votre nom de fonction pour les appels récursifs, les fonctions non nommées sont valides. Vous pouvez donc enregistrer deux octets sur le fichier f=.
Martin Ender

1

> <> (Poisson), 108 octets (= grille de 9 x 12)

01-r>:0(\
"/"&::;?/
)?\v    \
":/v!?(":
")\ :>:"0
 !?\
${/  \ -1
&>\ ~{:&$
\ \ :"0"=
/\- 1}$/?
:v&//}~/~
 \o}\&$/ 

Essayez-le ici pour voir le poisson nager dans les environs.

  • Ajoutez -1 à la pile d’entrée puis inversez la pile.
  • Boucle: Si la valeur supérieure est -1, alors se termine (nous avons parcouru tous les caractères). Autrement:
  • Mettez le personnage principal dans le registre; vérifiez si elle se situe dans la plage "0" à "9". Si c'est le cas:
    • faire pivoter la pile du nombre de places approprié
    • faire pointer le personnage
    • faire une rotation arrière et remplacer le numéro par le caractère du registre
  • Sortie; boucle de reprise.

1

8086 code machine, 35 octets

00000000  be 82 00 ac 98 50 2c 30  3c 09 77 0c 4e 89 f7 4e  |.....P,0<.w.N..N|
00000010  29 c6 58 ac aa 89 fe 50  5a b4 02 cd 21 80 fa 0d  |).X....PZ...!...|
00000020  75 e1 c3                                          |u..|
00000023


1

Japt v2.0a0, 16 octets

r\d@=hYUgY-°X¹gY

L'essayer


Explication

                     :Implicit input of string U
r                    :Replace
 \d                  :  RegEx /\d/g
   @                 :  Pass each match X at index Y through a function
     hY              :    Set the character at index Y in U
       UgY-°X        :    To the character at index Y-++X
    =        ¹       :    Reassign to U
              gY     :    Get the character at index Y

1

J , 20 octets

{~[:{~^:_#\-2+_1".,.

Essayez-le en ligne

                  ,.  Each character on a separate row
              _1".    Convert to numbers, replacing non-numbers with -1
                         (it becomes one row again)
            2+        Add 2.
         #\           Prefix lengths (range 1..length)
           -          Subtract
  [:{~^:_             Index into itself as long as it changes the result
{~                    Index into the original string

Crédit à l'inspiration pour l'ign.

22 octets

(],,{~1{._1-_1".[)/@|.

Ceci est un port de la réponse de la gelée.

                    |. The string backwards, because reduce is right-to-left.
            _1".[      The next character as a number (d), -1 if it's not a number,
                          and a space character produces an empty array.
         _1-           -1-d
      1{.              Take 1. If we have a nothing
                          at this point, that makes it a 0.
   ,                   Prepend the next character to the result of the previous call.
    {~                 Select the character. 0 is the first, _2 is second to last.
 ],                    Append the result.

Dans les deux solutions, la version utilisée par TIO en interprète un .comme le nombre 0. Le dernier test échoue. Les versions plus anciennes (≤7) semblent fonctionner correctement.

Essayez-le en ligne!

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.