Numéros de sortie, plus ou moins

15

Le défi

Étant donné une chaîne d'entrée (ou tableau) composée de <et >, sortie une séquence (tableau ou chaîne) d'entiers tels que:

  • les opérateurs sont tous corrects lorsqu'ils sont appliqués dans l'ordre entre les nombres consécutifs dans la sortie
  • tous les entiers sont positifs (1 ou plus)
  • la somme des nombres entiers est aussi petite que possible mathématiquement

Les entrées peuvent varier pour correspondre à "supérieur à" et "inférieur à" dans la langue choisie.

Comme sortie alternative, spécifiez simplement la somme des nombres dans la sortie. Indiquez la version que vous résolvez dans le titre de votre réponse.

Les exclusions et règles habituelles s'appliquent, le plus petit octet gagne.

Vous pouvez supposer que la chaîne d'entrée ne conduira jamais à un débordement d'entier dans votre langue, si cela vous aide.

Exemples

  • >donne 2 1quelles sommes3
  • >>>donne 4 3 2 1quelles sommes10
  • ><donne 2 1 2quelles sommes5
  • donne 1quelles sommes1
  • >>>>>>>>>donne 10 9 8 7 6 5 4 3 2 1quelles sommes55
  • >><<>><>>>donne 3 2 1 2 3 2 1 4 3 2 1quelles sommes24
  • ><>><>><>donne 2 1 3 2 1 3 2 1 2 1quelles sommes18
  • <<<<>donne 1 2 3 4 5 1quelles sommes16
  • <<<<><<>donne 1 2 3 4 5 1 2 3 1quelles sommes22
  • >><<donne 3 2 1 2 3quelles sommes11
simonalexander2005
la source
Pouvons-nous utiliser des symboles autres que >et <?
Erik the Outgolfer
@JonathanAllan Je pense que ce sont les exemples qui sont faux, et vous devez supposer que lorsque vous répondez, pas que la spécification est erronée. EDIT: Eh bien, je crains qu'ils ne soient pas valides, car c'est la spécification qui définit un défi, pas les cas de test.
Erik the Outgolfer
4
J'attends juste une réponse dans <> <.
Khuldraeseth na'Barya
1
Toutes mes excuses à tout le monde pour avoir foiré les exemples! Quant aux autres personnages, oui à condition qu'ils aient la même signification dans votre langue
simonalexander2005
3
@Scrooble Vous l'avez mal orthographié. C'est><>
Jo King

Réponses:

3

Gelée , 19 octets

0;+×¥@\
=”<µCṚÇṚ»Ç‘

Essayez-le en ligne!

La valeur de chaque nombre est max ( nombre de >immédiatement à sa droite , nombre de <immédiatement à sa gauche ) + 1 .


Alternativement ...

Essayez-le en ligne!

user202729
la source
Je n'aime pas les langues nécessitant un programme à transpiler comme Stax ... eh bien, Jelly est borderline. (nécessite un programme pour compresser les cordes) Au moins, Jelly gagne toujours.
user202729
Esthétiquement, je ne l'aime pas vraiment non plus. Mais ce que j'aime le plus dans une langue de golf, c'est ce qui permet à ses programmes d'être les plus petits. J'ai encore quelques idées de stax à propos de celui-ci ...
récursif
8

> <> , 40 38 octets

1v!rnr~<oa
?\i:0(?^3%\+$
{/?:-{:}-1/1:

Essayez-le en ligne!

Une langue appropriée. Pour référence ><>elle-même donne 2,1,2,1.

Comment ça fonctionne:

1v   Initialise the stack as 1 and enter loop
 \i:0(?^  If we're out of input, go to the first line
        3%\ Otherwise mod the input by 3, yielding 0 for < and 2 for >
        -1/Subtract 1 to get -1 and 1 respectively
    -{:}   Copy the previous number and subtract the above from it

 /?:    If the number is not 0, repeat the loop

?\        \+$  Otherwise:
                Increment each number until we reach the original 0
{/        /1:   And enter the first loop again

      ~<    When we're out of input, pop the extra -1 from EOF
   rnr      Output the first number
1v!         Push a 1 
        oa  Print a newline and repeat, popping the extra 1 each time
Jo King
la source
+1 pour indiquer la valeur de la langue elle-même. :) (Et parce que c'est juste une bonne réponse aussi, sinon je ne l'aurais pas +1.)
Kevin Cruijssen
5

Python 3, 93 octets

k=0
for r in input().split('<'):p=len(r);print(max(k,p)+1,*range(p,0,-1),end=' ');k=1+(p<1)*k

Essayez-le en ligne!

Débrouillé:

# offset, will be explained later
k = 0 
for run in input().split('<'):
    # p = length of sequence of '>'s, which will produce p+1 decreasing integers
    p = len(run)
    # will print:
    # p+1 p p-1 ... 1    or    k+1 p p-1 ... 1
    print(max(k, p) + 1, *range(p, 0, -1), end=' ')
    # offset of the next sequence: (i.e. -1 + the minimal value of the first integer)
    k = 1 + (k if p > 0 else 0)
Fons
la source
1
Ceci est mon premier golf!
Fons
5

Haskell , 119 octets

n%">"=r[1..n]
n%"<"=[1..n]
n%(c:b)|c==b!!0=(n+1)%b|a:s<-2%b,e:z<-r$n%[c]=r z++last(max:[min|c>'<'])a e:s
r=reverse
(2%)

Essayez-le en ligne!

Explication

L'idée ici est que nous avons des séries de >s ou de <s, qui correspondent chacune à des plages ascendantes et descendantes. Nous utilisons donc grouppour diviser la chaîne en groupes de caractères consécutifs. Notre travail consiste ensuite à les assembler de la bonne manière.

Lorsque nous avons, <>nous voulons assembler les deux listes en prenant la plus grande valeur finale par exemple

<<<<<<>>

est divisé

<<<<<<  >>

mappé à des plages

[1,2,3,4,5,6,7] [3,2,1]

Ensuite, lorsque nous cousons, nous tombons 3parce qu'il est plus petit ( 3pas plus grand que 7).

 [1,2,3,4,5,6,7,2,1]

Lorsque nous avons, ><nous faisons le contraire, nous laissons tomber la plus grande valeur.

Le code réel y parvient en créant un opérateur %. La définition de %est assez complexe, mais fondamentalement, elle se lit de gauche à droite en gardant une trace du nombre de caractères consécutifs identiques. Il fait cela dans la gauche avait la valeur de l'opérateur. Lorsque nous atteignons un endroit où les personnages changent, nous effectuons la couture comme je l'ai décrit.

Post Rock Garf Hunter
la source
Quel est le but de la dernière ligne (2%)?
siracusa
@siracusa C'est la fonction elle-même. C'est une fonction sans point, donc elle dit essentiellement appel %avec 2comme premier argument.
Post Rock Garf Hunter
Est-ce une pratique courante ici de simplement placer l'appel de fonction final sur la dernière ligne au lieu d'ajouter une mainimplémentation complète ?
siracusa
1
@siracusa Oui. Les soumissions sont autorisées en tant que fonctions nommées, fonctions anonymes ou programmes complets. Il s'agit d'une fonction anonyme. Je choisis l'anonymat simplement parce que c'est le plus court.
Post Rock Garf Hunter
@siracusa Consultez notre guide des règles du golf à Haskell .
Laikoni
4

Rétine 0.8.2 , 36 octets


1
{`\b(1+)>\1
1$&
}`(1+)<\1\b
$&1
1

Essayez-le en ligne!Le lien inclut des cas de test. Explication:


1

Insérez 1s avant, entre et après le< s et >s.

{`\b(1+)>\1
1$&
}`(1+)<\1\b
$&1

Incrémentez de manière répétée les entiers jusqu'à ce que toutes les comparaisons soient satisfaites.

1

Additionnez les entiers et convertissez-les en décimal.

Neil
la source
3

Java 10, 198 181 octets

s->{var p=s.split("(?<=(.))(?!\\1)");int l=p.length,L[]=new int[l],i=l,r=0,a,b;for(;i-->0;r+=a*-~a/2-(i<l-1?p[i].charAt(0)<61?a<(b=L[i+1])?a:b:1:0))a=L[i]=p[i].length()+1;return r;}

Essayez-le en ligne.

Explication:

s->{                      // Method with String parameter and integer return-type
  var p=s.split("(?<=(.))(?!\\1)");
                          //  Split the String into parts
                          //  (i.e. ">><<>><>>>" becomes [>>, <<, >>, <, >>>])
  int l=p.length,         //  Get the amount of parts
      L[]=new int[l],     //  Create an integer-array of the same size
      i=l,                //  Index-integer, starting at this size
      r=0,                //  Result-integer, starting at 0
      a,b;                //  Two temp integers to reduce the byte-count
  for(;i-->0;             //  Loop downwards over the array; range: (`l`,0]
      ;r+=                //    After every iteration: increase the result with:
          a*-~a/2         //     The triangle number of the current item
        -(i<l-1?          //     If it's not the last item:
           p[i].charAt(0)<61?
                          //      And the order of the current and previous is "<>":
            a<(b=L[i+1])? //       If the current item in `L` is smaller than the previous:
             a            //        Subtract the current item
            :             //       Else (the current is equal or larger than the previous):
             b            //        Subtract the previous item
           :              //      Else (the order of the two parts is "><" instead):
            1             //       Subtract 1
          :               //     Else (it's the last item in `L`):
           0))            //      Leave the result `r` unchanged
    a=L[i]=               //   Set both `a` and the current item in `L` to:
     p[i].length()+1;     //    The length of the part + 1
  return r;}              //  Return the result
Kevin Cruijssen
la source
2

Stax , 21 octets

éda╓~/└↨☺∟╒←║ç Γφ5←9h

Exécuter et déboguer

Il fonctionne en codant la longueur de l'entrée, puis en concaténant les plages générées ensemble. Déballé, non golfé et commenté, il ressemble à ceci.

|R      run-length encode
{       begin block
  H^R   range from [1 .. run length]
  _hh|1 -1 ** (character code / 2)
  *     multiply run; this will reverse it iff character is '>'
m       map runs using preceding block
O       push a 1 under the top of stack
{       begin block
  h|M   get the start of the generated range, and take max of it and top of stack
  _DE   push the rest (tail) of the generated range to the stack
F       foreach generated range
L|+     sum of all values on the stack

Exécutez celui-ci

récursif
la source
2

Perl 5 -p , 53 octets

#!/usr/bin/perl -p
s//1/g;1while s/(?=\b(1+)>\1)|(1+)<\2\b\K/1/;$_=y/1//

Essayez-le en ligne!

Ton Hospel
la source
1
Cette réponse semble avoir été implémentée sur la base des cas de test au lieu de la spécification de défi. Malheureusement, ils ont été identifiés comme faux .
Erik the Outgolfer
1
@EriktheOutgolfer Fixed
Ton Hospel
1

Rouge , 185 octets

func[s][repeat n 1 + length? s[l: 0 i: n - 1 while[i > 0 and(s/(i) = #"<")][i:  i - 1 l: l + 1]r: 0 i: n while[(i <= length? s)and(s/(i) = #">")][i: i + 1 r:
r + 1]prin[1 + max l r""]]]

Après l'explication de user202729 ...

Essayez-le en ligne!

f: func[s][
   repeat n 1 + length? s[
       l: 0
       i: n - 1
       while [i > 0 and (s/(i) = #"<")][ 
           i: i - 1
           l: l + 1
        ]
        r: 0
        i: n
        while [(i <= length? s) and (s/(i) = #">")][
            i: i + 1
            r: r + 1
        ]
        prin[1 + max l r ""]
    ]
]
Galen Ivanov
la source