Indexar um número

15

Dada uma sequência de dígitos ou um número inteiro como entrada, você terá que indexá-lo.

É assim que você modifica a entrada. Vamos usar 30043376111como exemplo:

Primeiro, encontre a soma dos índices de cada ocorrência dos respectivos dígitos:

0: 1 + 2 = 3
1: 8 + 9 + 10 = 27
3: 0 + 4 + 5 = 9
4: 3
6: 7
7: 6

Em seguida, construa um novo número inteiro ou sequência de caracteres onde os dígitos acima vão na ordem das somas de seus índices. No caso de vários dígitos produzirem a mesma soma, o dígito menor vem antes do maior:

047631

Por fim, remova todos os zeros à esquerda e retorne ou imprima o resultado:

47631

Você deve escrever um programa ou função que retorne ou imprima a entrada indexada.

Isso é , então o código mais curto em bytes vence!

Mais casos de teste podem ser adicionados, se solicitado.

Daniel
fonte
Para funções, está retornando uma string ok? Que tal pegar uma string como argumento?
Conor O'Brien
@ ConorO'Brien Dada uma sequência de dígitos ou um número inteiro
AdmBorkBork 28/03
@AdmBorkBork Bem, isso responde à pergunta de entrada> _> #
Conor O'Brien
@ ConorO'Brien Além disso, construa um novo número inteiro ou string , que pareça que retornar uma string também esteja OK.
AdmBorkBork

Respostas:

1

k, 7 bytes

.<+/'=$

repl online

  $30043376111 / convert to string($)
"30043376111"
  =$30043376111 / group(=) - return a mapping (dict) from unique chars to indices
"304761"!(0 4 5
 1 2
 ,3
 ,6
 ,7
 8 9 10)
  +/'=$30043376111 / sum(+/) each(') value in the dict
"304761"!9 3 3 6 7 27
  <+/'=$30043376111 / grade(<) ascending values - return keys from the dict
"047631"
  .<+/'=$30043376111 / execute(.) the string - convert it to a number
47631

A justaposição de funções é composição, portanto, nenhum parâmetro explícito ou entrada é necessária.

ngn
fonte
3

Haskell, 69 bytes

import Data.List
f x=0+read(nub$sortOn(\d->(sum$elemIndices d x,d))x)

Pega uma string, retorna um número. Exemplo de uso: f "30043376111"-> 47631. Experimente online!

Bem direto: classifique os dígitos da string de entrada primeiro na soma de seus índices e pelo dígito em si (-> pares de (soma ..., d)), remova duplicatas e converta em um número para remover as iniciais 0. O 0+é necessário para obter os tipos direita.

nimi
fonte
3

Empilhados , 59 bytes

:@q uniq[:q\eq q size:>*sum,]map[-1#]sortby[0#]map''#`'^0'-

Experimente online!

Isso pega uma sequência de caracteres (como $'1231231') como entrada da parte superior da pilha e deixa uma sequência na pilha.

Explicação

:@q uniq[:q\eq q size:>*sum,]map        stack: (str)
:                                       stack: (str str)
 @q                                     stack: (str)        ; store as `q`
    uniq                                stack: (str')       ; de-duplicate
        [                   ]map        map the inner over each element
         :                              stack: (chr chr)
          q\eq                          stack: (chr q')     ; `q'` is where equality occurs
               q size:>                 stack: (chr, q', k) ; `k` is range from 0, size(q')
                       *sum             stack: (chr, k')    ; `k'` is sum of indices
                           ,            stack: ((chr, k'))

Agora ficamos com pares de (chr, soma dos índices).

[-1#]sortby[0#]map''#`'^0'-
[   ]sortby                    sort by the inner function
 -                             vectorized subtraction of two pairs
  1#                           use the second element as the comparison
           [0#]map             get the first element of each row
                  ''#`         join by the empty string
                      '^0'-    remove all leading zeroes
Conor O'Brien
fonte
3

05AB1E , 29 28 bytes

-1 graças a Riley

TFN¹SQDg<ÝsÏON‚}){vyD0å_i1è,

Experimente online!

TFN            }             # Loop from 0 to 9.
   ¹SQ                       # Push 1 if index is same as `y`.
      Dg<ÝsÏ                 # Push index of the number instead of 1.
            ON‚              # Sum, combine with current `y`.
                ){           # Collect, sort 'em.
                  vyD0å_i1è, # Only print the ones with a count above 0.
Urna de polvo mágico
fonte
1
Você pode substituir TFNpara9Ývy
Riley
2
@Riley 05AB1E é uma linguagem estranha ... Parece que quanto mais você a usa, mais você tenta complicar TUDO ... Obrigado, sim, isso parece funcionar bem.
Urna de polvo mágico
3

JavaScript (ES6), 98 bytes

n=>+[...new Set(n)].sort().sort((a,b)=>(s=d=>[...n].reduce((S,D,i)=>S+i*(d==D),0))(a)-s(b)).join``

Pega uma string ne a converte em um conjunto e, em seguida, em uma matriz de dígitos distintos. Classifica esses dígitos em ordem numérica e, em seguida, classifica novamente de acordo com a soma dos índices. Concatena a matriz classificada em uma seqüência de caracteres e, finalmente, converte-se em um número para remover zeros à esquerda.

f=
n=>+[...new Set(n)].sort().sort((a,b)=>(s=d=>[...n].reduce((S,D,i)=>S+i*(d==D),0))(a)-s(b)).join``

console.log(f('30043376111'))

darrylyeo
fonte
o tipo repetido é necessário?
Conor O'Brien
Sim, "No caso de vários dígitos produzirem a mesma soma, o dígito menor vem antes do maior". Sem o primeiro .sort(), uma entrada de 1332 rendimentos 132 em vez de 123.
darrylyeo
Ah, tudo bem, entendo #
Conor O'Brien
2

PowerShell , 88 bytes

$a=@{};[char[]]"$args"|%{$a[$_]+=$i++};+-join(($a.GetEnumerator()|Sort value,name).Name)

Experimente online!

Define uma hashtable vazia $a, depois lança a entrada $argscomo uma charmatriz e percorre cada elemento |%{...}. Definimos o valor como "o elemento atual" de $aa ser incrementado $i++, para contar os índices de nossas entradas. Por exemplo, para entrada 300433766111, o primeiro loop $a[3]obtém +=0; o próximo loop, $a[0]obtém +=1; etc.

Em seguida, precisamos da Sortnossa hashtable. Infelizmente, devido a uma peculiaridade do idioma interno, isso significa que precisamos fazer $a.GetEnumerator()isso antes de podermos fazer a classificação real. Classificamos por value, depois por name, para satisfazer o requisito de dígitos menores serem classificados primeiro. Nós extraímos os .Names (em ordem ordenada), -joineles juntos em uma string e a convertemos como int +para remover zeros à esquerda. Isso é deixado no pipeline e a produção está implícita.

AdmBorkBork
fonte
2

Gelatina , 10 bytes

Ġ’S$ÞịDFQḌ

Experimente online!

Pega e retorna um número inteiro.

Quão?

Ġ’S$ÞịDFQḌ - Main link: n            e.g. 30043376111
Ġ          - group indices of n by value  [[2,3],[9,10,11],[1,5,6],[4],[8],[7]] (implicitly treats the number as a decimal list)
    Þ      - sort that by:
   $       -     last two links as a monad:
 ’         -         decrement (since Jelly is 1-indexed)
  S        -         sum                  [[2,3],[4],[7],[8],[1,5,6],[9,10,11]] (this leaves those indices of lower value to the left as required)
      D    - decimal list of n            [3,0,0,4,3,3,7,6,1,1,1]
     ị     - index into                   [[0,0],[4],[7],[6],[3,3,3],[1,1,1]]
       F   - flatten                      [0,0,4,7,6,3,3,3,1,1,1]
        Q  - unique                       [0,4,7,6,3,1]
         Ḍ - cast to a decimal number     47631
Jonathan Allan
fonte
1

PHP, 103 bytes

for(;$i<strlen($a="$argv[1]");)$r[$a[$i]]+=$i++;ksort($r);asort($r);echo ltrim(join(array_keys($r)),0);
Jörg Hülsermann
fonte
1

Python 2, 102 92 bytes

Agradecimentos a Ben Frankel por salvar 10 bytes!

a={}
for i,j in enumerate(input()):a[j]=a.get(j,0)+i
print int(''.join(sorted(a,key=a.get)))

Experimente Online!

Pega entrada como uma sequência e gera um número inteiro. Usa um dicionário para armazenar a soma dos índices e depois os classifica por valor. Converte em um número inteiro para eliminar os zeros à esquerda, porque inté menor que .lsplit('0').

viciado em matemática
fonte
a[j]=a.get(j,0)+isalva 10 bytes.
Ben Frankel
1

Python 3.5, 86 85 bytes

Obrigado @Ben Frankel por salvar um byte:

f=lambda s:int(''.join(sorted({*s},key=lambda d:sum(i*(c==d)for i,c in enumerate(s)))))

Código antigo:

lambda s:int(''.join(sorted({*s},key=lambda d:sum(i for i,c in enumerate(s)if c==d))))

Função anônima pegando uma sequência de dígitos e retornando um número inteiro

RootTwo
fonte
sum(i*(c==d)forsalva 1 byte.
Ben Frankel
1

Pip , 18 bytes

+J:$+(a@*_)SKSNUQa

Pega o número como um argumento de linha de comando. Experimente online!

Explicação

                    a is 1st cmdline arg (implicit)
               UQa  Get unique digits in a
             SN     Sort (numerically)
           SK       Then sort with this key function:
      a@*_           Find all indices of argument in a
   $+(    )          and sum them
 J:                 Join the resulting list back into a string (: is used to lower the
                    precedence of J)
+                   Convert to number (eliminates leading 0)
                    Print (implicit)
DLosc
fonte
0

C #, 245 bytes

using System.Linq;s=>{var a=new int[10];for(int i=0,l=0;i<10;i++){a[i]=-1;while((l=s.IndexOf(i+"",l+1))!=-1)a[i]+=l;}return string.Concat(a.Select((c,i)=>new{c,i}).OrderBy(o=>o.c).ThenBy(o=>o.i).Where(o=>o.c>-1).Select(o=>o.i)).TrimStart('0');};

Não estou feliz com o tempo que acabou sendo e provavelmente pode ser mais curto, mas foi com isso que acabei.

TheLethalCoder
fonte
0

Perl 6 ,  65 61  52 bytes

{+[~] {}.push(.comb.map:{$_=>$++}).sort({.value.sum,.key})».key}

Tente

{+[~] {}.push(.comb.antipairs).sort({.value.sum,.key})».key}

Tente

{+[~] .comb.antipairs.Bag.sort({.value,.key})».key}

Tente

Expandido

{      # bare block lambda with implicit parameter 「$_」

  +    # turn the following into a Numeric
  [~]  # reduce the following using &infix:<~> (join)

    .comb              # list of digits from 「$_」 (implicit method call)
    .antipairs         # get a list of 「value => index」 pairs from above list
    .Bag               # combine them together (does the sum)
    .sort(
      { .value, .key } # sort it by the sum of indexes, then by the digit
    )».key             # get the list of digits from that
}
Brad Gilbert b2gills
fonte
0

Scala, 123 104 bytes

(_:String).zipWithIndex.groupBy(_._1).toSeq.sortBy(c=>c._2.map(_._2).sum->c._1).map(_._1).mkString.toInt

Exemplo (usando o Scala REPL):

scala> (_:String).zipWithIndex.groupBy(_._1).toSeq.sortBy(c=>c._2.map(_._2).sum->c._1).map(_._1).mkString.toInt
res0: String => Int = <function1>

scala> res0("30043376111")
res1: Int = 47631

Bem simples, usando tupla como predicado de classificação para classificação secundária.

Jacob
fonte
0

Pitão, 9 bytes

sosxNcQ1{

Experimente online

Toma uma sequência de dígitos como entrada.

sosxNcQ1{
sosxNcQ1{Q    Implicit variable introduction
        {Q    Unique digits
 o            Order by
     cQ1      Chop input into list of individual characters.
   xN         Find all indexes of the digit in question in the list.
  s           Sum
s             Convert string to integer.
isaacg
fonte