Il est temps d'ajuster certains prix!

19

Je suis sûr que vous connaissez le système de prix de 9,99 $, au lieu d'utiliser 10 $. Eh bien, dans votre nouveau travail d'administrateur système dans un grand magasin de vente au détail, ils veulent que les prix adhèrent à un schéma similaire:

  • Tous les prix sont en dollars entiers, pas de cents.
  • Tous les prix doivent se terminer par 5 ou 9, en arrondissant au plus proche mais en augmentant si le dernier chiffre est juste entre 5 et 9. (S'applique au dernier chiffre 2 et 7)
  • L'entrée la plus basse est de 1 $, et le prix le plus bas devrait être de 5 $.

Votre entrée est une liste d'entiers:

12
8
41
27
144
99
3

Et la sortie devrait une liste des nouveaux prix. Dans le cas ci-dessus:

15
9
39
29
145
99
5
code-golf  number 
— ciscoheat
source
Pouvons-nous prendre les entrées une par une? Ou séparés par autre chose qu'une nouvelle ligne?
— mınxomaτ
Pour plus de simplicité, je pense que le format spécifié est le meilleur, vous pouvez donc vous concentrer sur la résolution du problème réel au lieu de gérer également le formatage. Mais bien sûr, un seul entier sur une ligne est autorisé. :)
— ciscoheat
1
Oui, une liste spécifique à une langue est probablement plus facile à gérer. Mais combien de temps puis-je continuer à modifier les spécifications? C'est l'une des raisons pour lesquelles j'ai hésité à publier quoi que ce soit dans le code golf.
— ciscoheat
2
La nouvelle ligne est désormais supprimée comme exigence, ne spécifiant que "une liste". J'espère que cela rendra les choses meilleures, pas pires ...!
— ciscoheat
6
"Mais combien de temps puis-je continuer à modifier les spécifications? C'est l'une des raisons pour lesquelles j'ai hésité à publier quoi que ce soit dans le golf de code." Dans le cas où vous ne le savez pas, vous pouvez publier des idées de défi dans le bac à sable où vous pouvez obtenir les commentaires de la communauté avant que le défi ne soit mis en ligne, de sorte que des choses comme celle-ci puissent (espérons-le) être signalées et corrigées avant que les modifications invalident les réponses existantes.
— Martin Ender

Réponses:

13

Brainfuck, 4428 octets (invalide)

Une fois que j'ai su que l'algorithme fonctionnait, j'ai perdu tout intérêt et je n'ai pas terminé le gestionnaire d'entrée. C'est pourquoi cette solution résout techniquement le problème, mais est très difficile à utiliser. Lorsque vous démarrez le programme dans un interpréteur interactif (plus vite c'est mieux), vous pouvez saisir votre "numéro". Il doit être entré dans Base256 si votre interprète ne prend pas en charge la conversion de numéro (le mien le fait). Le prix maximum que vous pouvez saisir est donc de 255.

Il effectue ensuite un modulo en boucle si le nombre est supérieur à 9 pour séparer tous les chiffres sauf le dernier. Les résultats de la division sont enregistrés, tandis que le dernier chiffre est arrondi à 5 ou 9. Ensuite, ils sont ajoutés et imprimés. Ensuite, le programme nettoie tous les registres utilisés (probablement exagérés) et demande le numéro suivant.

Il gère tous les cas spéciaux ( $1, $20/$21 -> $19etc.). Regardez-le courir pour le numéro 4ici (environ 3 minutes, vidéo raccourcie):

démo vidéo

Code

>+<+[>>>>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<[>[-]+<-]>
[<+>>>>>>>>>>>[-],>>[-]<[-]<[>+<<<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>>>
>>>>[-]>[<+<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>>>>>>[-]+++++++++>[<<<<+
>>>>-]<[<<<<<<+>+<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>[>>[<+<<<+>>>>-]<<<<[>>>>+<<<<-]
+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]>>[>>>>-<<<<[-]]<<<[-]<->>>>>>>>[<<<<<<<<->>>>
>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>[>>>>>+<<<<<<<<<<<<<<<->>>>>>>>>>[-]]<<<<<<<<<
-]>>>>>>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<<<<
<[>[-]+<-]>[<+>>>>>>>>>>>>[-]<[>+<<<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>
>>>>>[-]++++++++++>>>[<<<<<<<+>>>>>>>-]<<<<<<<[>>>>[<<<<<+<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<
<<<<<-]>>[>-[<<+<+>>>-]<<<[>>>+<<<-]+>[<->[-]]<[>>-[>>>>>>>>-<<<<<<<<[-]]+<<[-]]>>-]>>>>
>>>>+<<<<<<<]>>>>>[-]>>[<<+<<<<<<<<+>>>>>>>>>>-]<<<<<<<<<<[>>>>>>>>>>+<<<<<<<<<<-]>>>>>>
>[-]++++++++++>[<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>[>+<<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<
<<<-]>-]>>>>>>>>>[-]<<[>>+<<-][-]>>>[<<<+<<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[>>>>>>>>>>>+<
<<<<<<<<<<-]>>>>>>>[-]>>>[<<<+<<<<<<<+>>>>>>>>>>-]<<<<<<<<<<[>>>>>>>>>>+<<<<<<<<<<-]>>>>
>>>[>+<<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>>>>>[-]<<<[>>>+<<<-][-]>[<+<<<<<
<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>>>>>>[-]>>>[<<<+<<<<<<<+>>>>>>>>>>-]<<<<
<<<<<<[>>>>>>>>>>+<<<<<<<<<<-]>>>>>>>[>-<<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>
>>>>[-]<[>+<-]<<<<<<<<<-]>>>>>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>-]
<<<<<<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>>>>>>>>>[-]>>[<<+<<<<<<<<+>>>>>>>>>>-]<<<<<<<<<<[>>>>
>>>>>>+<<<<<<<<<<-]>>>>>>>[-]>[<<<<+>>>>-]<[<<<<<<+>+<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<
-]>>[>>[<+<<<+>>>>-]<<<<[>>>>+<<<<-]+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]>>[>>>>-<<
<<[-]]<<<[-]<->>>>>>>>[<<<<<<<<->>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>[>>>>>>>>>
>>>+<<<<<<<<<<<<<<<<<<<<<<->>>>>>>>>>[-]]<<<<<<<<<-]>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<+>>>>>
>>>>>>>>>>-]<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>>>>>>>>>[-]>[<+<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>
>>>>>>>>+<<<<<<<<<-]>>>>>>>[-]++++>[<<<<+>>>>-]<[<<<<<<+>+<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<
<<<<<-]>>[>>[<+<<<+>>>>-]<<<<[>>>>+<<<<-]+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]>>[>>
>>-<<<<[-]]<<<[-]<->>>>>>>>[<<<<<<<<->>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>[>>>>
>>+<<<<<<<<<<<<<<<<->>>>>>>>>>[-]]<<<<<<<<<-]<[>[-]+<-]>[<+>>>>>>>>>>>[-]+++++++++>>>>>>
>>+<<<<<<<<<<<<<<<<<<<->-]>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>-]<<<<<<<<<<<
<<<<<[>[-]+<-]>[<+>>>>>>>>>>[-]>[<+<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>
>>>>>[-]++>[<<<<+>>>>-]<[<<<<<<+>+<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>[>>[<+<<<+>>>>-
]<<<<[>>>>+<<<<-]+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]<[>>>>>>>-<<<<<<<[-]]>>>[-]>>
>[-]>>>>[<<<<+<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[>>>>>>>>>>>+<<<<<<<<<<<-]>>>>>>>>>>>>[-]+
++++++++<<<<<[<<<+>>>-]>>>>>[<<<<<<<<<<<+>+<<+>>>>>>>>>>>>-]<<<<<<<<<<<<[>>>>>>>>>>>>+<<
<<<<<<<<<<-]>>[>>[<+<<<+>>>>-]<<<<[>>>>+<<<<-]+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]
>>[>>>-<<<[-]]<<<[-]>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<<<<[[-]>>>>>>>[<<<<<<<+>+>>>>>>-]<<<
<<<[>>>>>>+<<<<<<-]<[>>>>>>>>-<<<<<<<<[-]]]->>>>>>>>[<<<<<<<<->>>>>>>>-]<<<<<<<<[>>>>>>>
>+<<<<<<<<-]>>>>>>>>[>>>>>>>>+<<<<<<<<<<<<<<<<<<->>>>>>>>>>[-]]<<<<<<<<<-]<[>[-]+<-]>[<+
>>>>>>>>>>[-]>>>[<<<+<<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[>>>>>>>>>>>+<<<<<<<<<<<-]>>>>>>>>
->>>[-]<<<[>>>+<<<-]>[-]>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<->-]>>>>>>>>>>>>>>>>>[<<<<<<
<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>>>>>>>>>>[-]+++++<<<<<
<<<<<-]>>>>>>>>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>>>-]<<<<[<<<<
<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>>>>>>>>>[-]>>>[<<
<+<<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[>>>>>>>>>>>+<<<<<<<<<<<-]>>>>>>>[-]>>[<<+<<<<<<<+>>>
>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>>>>>>[>+<<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<
<<-]>>>>>>>>>>>[-]<<<[>>>+<<<-][-]>>>[<<<+<<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[>>>>>>>>>>>+
<<<<<<<<<<<-]>[-]>[-]>[-]>[-]>>>>[<<<<<+[>+<<<<+>>>-]<<<[>>>+<<<-]+>>>>----------[<<<<->
>>>[-]]<<<<[>>+>[-]<<<-]>>[>>+<<<<+>>-]<<[>>+<<-]+>>>>----------[<<<<->>>>[-]]<<<<[>+>[-
]<<-]>>>>>>>>-]<<<<<<<[<++++++++[>++++++>++++++<<-]>.>.[-]<[-]]>[<<++++++++[>>++++++<<-]
>>.[-]]<<++++++++[>>>++++++<<<-]>>>.[-]<<<++++++++++.[-]>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<
<->-]<[>[-]+<-]>[<+<->>-]<<]
— mınxomaτ
source
Vous obtiendrez un vote pour l'ambition, j'aimerais pouvoir en donner plus d'un. :)
— ciscoheat
8
Je pense que ce gif a besoin d'un avertissement d'épilepsie.
— Alex A.
12

CJam, 19 17 octets

q~{2-Ab)4>59s=N}/

Testez-le ici.

Prend les entrées sous forme de liste de style CJam et renvoie les retours à la ligne séparés.

Explication

qN/{   e# Run this block for each line of the input...
  ~    e#   Evaluate the current line to get the integer.
  2-   e#   Subtract 2 to get all but the last digit right.
  Ab)  e#   Convert to base 10 (discarding a potential minus sign) and split off
       e#   the last digit.
  4>   e#   Test if it's greater than 4.
  59s= e#   Select the correct digit from the string "59" based on this result.
  N    e#   Push a line feed.
}/
— Martin Ender
source
11

Python 2, 47

lambda l:[max(5,(n+3)/5*5-(n-2)/5%2)for n in l]

Si nous regardons la séquence de valeurs arrondies, nous voyons qu'elles viennent par blocs de 5. 

... 25, 29, 29, 29, 29, 29, 35, 35, 35, 35, 35, 39, ...

Nous trouvons le bloc numérique dans lequel nous nous trouvons (n+3)/5(appelez cette valeur J). Ensuite, nous obtenons le bon multiple de 5avec J*5, et ajustons les choses comme 30vers le bas 29en soustrayant 1chaque fois qu'il Jest pair.

Pour 1donner un cas spécial 5plutôt que -1, nous passons le résultat à max(5,_).

— xnor
source
Pour corriger la version Pyth, je pense que vous pouvez le fairemeS,-*hJ/-d2K5K%J2KQ
— FryAmTheEggman
2
ou 2 octets plus court:m-|*K5hJ/-d2K6%J2Q
— Jakube
1
@Jakube C'est intelligent, que diriez-vous de l'afficher?
— xnor
Ok je le ferai. Mais vous pouvez prendre l'idée de votre réponse Python. Il enregistre un octet:lambda l:[((n+3)/5*5or 6)-(n-2)/5%2for n in l]
— Jakube
8

Rétine, 32 octets

Accepte l'entrée dans une liste séparée par des virgules. Il doit y avoir une virgule de fin. Sorties au même format.

T`d`aa555559`.,
T+`da`ad`\da
a
5

Explication:

T`               #Transliteration mode.
  d`aa555559`    #Map the digits 0-9 to aa55555999
             .,  #Map only the trailing digits.
T+`              #Do until input does not change.
   da`ad`        #Map a to 9, 0 to a, and 1-9 to 0-8
         \da     #Only do this to each a and the character before each a.
a                #Match all leftover a's. This only happens when the input contains the integer 1.
5                #Replace them with 5.
— Le numéro un
source
5

R, 51 49 47 43 octets

(f=((n=scan()-2)%/%5+1+(n<0))*5)-(f%%10==0)

Il devrait y avoir de la place pour améliorer cela, mais je pense qu'une stratégie différente pourrait être meilleure. Prend un vecteur d'entiers de l'analyse et génère un vecteur d'entiers. Essentiellement, cela utilise la division entière pour arrondir le nombre, ajoute 1 et le multiplie par cinq. Tout ce qui est divisible par 10 a 1 emporté. Si n = 1, il incrémente la division entière de 1.

Essai

> (f=((n=scan()-2)%/%5+1+(n<0))*5)-(f%%10==0)
1: 1
2: 12
3: 8
4: 41
5: 27
6: 144
7: 99
8: 3
9: 
Read 8 items
[1]   5  15   9  39  29 145  99   5
>
— MickyT
source
5

Python 3, 74 82 octets

a=eval(input())
for i in a:print(round(i,-1)+[5,-1][max(4,i-2)%10>4])

J'ai lutté pour la brièveté des valeurs inférieures à 11 et l'exigence de 1 pour évaluer à 5.

— Todd
source
On dirait que votre programme ne prend qu'un seul entier?
— daniero
@daniero correct, corrigé maintenant pour accepter la liste.
— Todd
4

Pyth, 21 18 29 28 octets

Merci à @Jakube d'avoir coupé 3 octets!

KeQJ-QKI<K2tJ.q;I<K6+J5;E+J9

Essayez-le ici.

EDIT: Apparemment, il n'était pas valide. Je l'ai réparé au prix de 11 octets; Je vais essayer de jouer au golf plus.

— RK.
source
eQest la même chose que %Q10, vous pouvez également inline l'affectation:I<KeQ6+-QK5;E+-QK9
— Jakube
Cool, je ne savais pas ça!
— RK.
Aucun problème. Mais votre approche est fausse. Vous devez arrondir à 9, si le dernier chiffre est 0ou1
— Jakube
Ah, je vais y travailler.
— RK.
4

Pyth, 21 octets

m?tdtt+d@jC"²a<"6ed5Q

Malheureusement, je dois dépenser 4 octets pour gérer correctement 1 $.

— orlp
source
Plutot malin. Vous pouvez gérer 1avec seulement 2 octets cependant. mt|t+d@jC"²a<"6ed6Q
— Jakube
4

Pyth, 18 octets

m-|*K5hJ/-d2K6%J2Q

Essayez-le en ligne: démonstration ou suite de tests

Cette réponse est basée sur la solution Python / Pyth de @ xor. La principale différence est que je traite le cas spécial 1différemment. Le résultat réel pour 1serait 0 - 1 = -1. En utilisant Python, orje peux remplacer le 0par un 6, résultant en 6 - 1 = 5. Cela évite la douleur de prendre le maximum 5et le résultat.

Explication:

m-|*K5hJ/-d2K6%J2Q
m                Q   map each number d of the input list Q to:
    K5                  K = 5
       J/-d2K           J = (d - 2) / K
   *K hJ                   K * (J + 1)
  |                     or
             6             6 # if K*(J+1)==0
 -            %J2       minus (J mod 2)
— Jakube
source
3

Hassium , 133 octets

func main(){i=[12,8,41,27,144,99,3];foreach(e in i){f=e%10;if(!(e/10==0))print(e/10);if(f<5)r=5;else if(f>5)r=9;elser=f;println(r);}}

Exécutez et voyez le développé en ligne: http://hassiumlang.com/Hassium/index.php?code=4f1c14f4d699b11da7a6392a74b720c4

— Jacob Misirian
source
Désolé pour le lien rompu, nous faisions un travail de base de données. Fonctionne maintenant.
— Jacob Misirian
Comme indiqué dans le wiki du code golf tag , les réponses doivent être des programmes ou des fonctions complets. Les extraits de code qui codent simplement en dur l'entrée ne sont pas autorisés, sauf indication contraire explicite de la question.
— Dennis
3

TI-BASIC, 19 octets

int(Ans/5+.6
max(5,5Ans-not(fPart(Ans/2

Utilise l'algorithme de xnor. TI-BASIC obtient gratuitement la vectorisation et la multiplication, mais nous dépensons quelques octets de plus car il n'a pas de modulo.

— lirtosiast
source
1

Haskell, 114 octets

g n
 |n>6=9-n
 |n>1=5-n
 |1>0=(-n-1)
f n=show$(read n)+(g$read$(:[])$last n)
main=interact(unlines.(map f).lines)

Explication:

La fonction grenvoie 9-nif n>6ou else 5-nif n>1ou else -n-1. greçoit le dernier chiffre et renvoie ce qui doit être ajouté au numéro d'entrée. futilise gpour obtenir la solution (plus beaucoup de manipulation de chaînes). mainaffiche le résultat de fpour chaque ligne d'entrée.

— HEGX64
source
1

Rubis, 55 50 + 1 octets

Lancez - le avec le ndrapeau, comme suit: ruby -n prices.rb. Entrez chaque prix sur une ligne distincte.

x=$_.to_i
p x<7?5:(x-2).round(-1)+(~/[2-6]$/?5:-1)
— daniero
source
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.