Faire un convertisseur de liste numérique

20

Ne détestez-vous pas quand vous voulez copier-coller une liste de nombres (vecteur, tableau ...), d'un programme à un autre, mais le format sur lequel vous avez les chiffres ne correspond pas au format sur lequel vous en avez besoin ?

Par exemple, dans MATLAB, vous pouvez avoir une liste séparée par des espaces comme celle-ci:

[1 2 3 4 5]    (you can also have it comma separated, but that's not the point)

En Python, vous devrez insérer des virgules pour faire de cette liste une entrée valide, vous devrez donc la convertir en

[1, 2, 3, 4, 5]

pour le faire fonctionner. En C ++, vous voudrez peut-être quelque chose comme:

{16,2,77,29}

etc.

Pour simplifier la vie de tout le monde, créons un convertisseur de liste, qui prend une liste sur n'importe quel format * et génère une liste sur un autre format spécifié.

Les parenthèses valides sont:

[list]
{list}
(list)
<list>
list      (no surrounding brackets)

Les délimiteurs valides sont:

a,b,c
a;b;c
a b c
a,  b,  c       <-- Several spaces. Must only be supported as input.
a;     b; c     <-- Several spaces. Must only be supported as input.
a   b   c       <-- Several spaces. Must only be supported as input.

Remarque, l'entrée peut avoir n'importe quel nombre d'espaces entre les nombres, mais la sortie peut choisir d'avoir zéro espace (si ,ou ;est utilisé comme délimiteur), ou un seul espace (s'il est délimité par un espace).

En plus de la liste d'entrée, il y aura une chaîne (ou deux caractères) qui définit le format de sortie. La chaîne de format sera d' abord le type de support d'ouverture (uniquement), [, (, <, {ou (le dernier est un espace unique utilisé lorsqu'il n'y a pas de parenthèses autour). Le type de support sera suivi par le type de séparation, ,, ;ou (le dernier est un espace unique). Les deux caractères de format d'entrée doivent être pris comme un seul argument (chaîne ou deux caractères consécutifs) dans l'ordre décrit ci-dessus.

Quelques exemples de chaînes de format:

[,    <-- Output format:   [a,b,c]
{;    <-- Output format:   {a;b;c}
      <-- Two spaces, output list has format:   a b c

Règles:

  • La sortie ne peut pas avoir d'espaces de début
  • La sortie peut avoir des espaces de fin et une nouvelle ligne
    • La sortie doit seulement être la liste des numéros, pas ans =ou similaires
  • L'entrée sera une liste de nombres entiers ou décimaux (positifs et négatifs (et zéro)) et une chaîne de deux caractères
    • Si l'entrée se compose uniquement d' entiers, la liste de sortie doit avoir uniquement des entiers. Si la liste d'entrée se compose d'entiers et de nombres décimaux, tous les numéros de sortie peuvent être des nombres décimaux. (Il est facultatif de conserver les entiers sous forme d'entiers)
    • Le nombre maximum de chiffres après la virgule décimale qui doit être pris en charge est de 3.
    • L'entrée sera deux arguments. C'est-à-dire que les nombres sont dans un seul argument, et la chaîne de formatage est un seul argument.
  • Le code peut être un programme ou une fonction
  • L'entrée peut être un argument de fonction ou STDIN

Quelques exemples:

1 2 3 4
[,
[1,2,3,4]

<1;  2;  3>
 ;    <-- Space + semicolon
1;2;3
not valid:  1.000;2.000;3.000   (Input is only integers => Output must be integers)

{-1.3, 3.4, 4, 5.55555555}
[,
[-1.300,3.400,4.000,5.556]  (5.555 is also valid. Rounding is optional)
also valid: [-1.3,3.4,4,5.55555555]

Le code le plus court en octets gagne. Comme toujours, le gagnant sera sélectionné une semaine après le jour où le défi a été publié. Les réponses publiées plus tard peuvent toujours gagner si elles sont plus courtes que le gagnant actuel.

Classement

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) en tant que liste des solutions les plus courtes par langue et b) en tant que classement général.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les rayant. 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 code:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Afficher l'extrait de code

code-golf  string  syntax 
— Stewie Griffin
source
Les espaces de fin et de début sont-ils autorisés?
— overactor
@overactor, voir les deux premières règles. L'espace de début n'est pas correct, la fin est correcte.
— Stewie Griffin
Pouvons-nous prendre des informations dans l'ordre inverse? (délimiteurs en premier, liste en second)
— Martin Ender
@ MartinBüttner, oui. Il n'est pas spécifié qu'il doit être répertorié en premier, vous pouvez donc choisir.
— Stewie Griffin
J utilise _pour désigner les éléments négatifs. :(
— Zgarb

Réponses:

1

CJam, 27 octets

l)l_5ms`-SerS%*\S-_o_'(#(f-

Essayez-le ici.

Explication

l      e# Read the format string.
)      e# Extract the separator.
l_     e# Read the list.
5ms`   e# Get a string that contains -.0123456789.
-      e# Get the characters in the list that are not in the string.
Ser    e# Replace those characters with spaces.
S%     e# Split by those characters, with duplicates removed.
*      e# Join with the separator.
\S-    e# Remove spaces (if any) from the left bracket.
_o     e# Output a copy of that character before the stack.
_'(#   e# Find '( in the left bracket string.
(      e# Get -1 if '( is the first character, and -2 if it doesn't exist.
f-     e# Subtract the number from every character in the left bracket string,
          making a right bracket.
— jimmy23013
source
8

JavaScript (ES6), 75 82

En tant que fonction anonyme

Modifier: 2 octets enregistrés thx @ user81655 (et 5 autres en le examinant)

(l,[a,b])=>a.trim()+l.match(/[-\d.]+/g).join(b)+']})> '['[{(< '.indexOf(a)]

Extrait de test

F=(l,[a,b])=>a.trim()+l.match(/[-\d.]+/g).join(b)+']})> '['[{(< '.indexOf(a)]

// Test
console.log=x=>O.innerHTML+=x+'\n'
// default test suite
t=[['1 2 3 4','[,'],['<1;  2;  3>',' ;'],['{-1.3, 3.4, 4, 5.55555555}','[,']]
t.forEach(t=>console.log(t[0]+' *'+t[1]+'* '+F(t[0],t[1])))
function test() { console.log(P1.value+' *'+P2.value+'* '+F(P1.value,P2.value)) }
#P1 { width: 10em }
#P2 { width: 2em }
P1<input id=P1>
P2<input id=P2>
<button onclick="test()">-></button>
<pre id=O></pre>
Développer l'extrait

— edc65
source
6

CJam, 35 34 octets

l(S-l"{[<(,}]>);":BSerS%@*1$B5/~er

Testez-le ici.

Attend le format sur la première ligne et la liste sur la seconde.

Explication

l   e# Read the format line.
(   e# Pull off the first character, which is the opening bracket.
S-  e# Set complement with a space, which leaves brackets unchanged and turns a space
    e# into an empty string.
l   e# Read the list.
"{[<(,}]>);":B
    e# Push this string which contains all the characters in the list we want to ignore.
Ser e# Replace each occurrence of one of them with a space.
S%  e# Split the string around runs of spaces, to get the numbers.
@   e# Pull up the the delimiter string.
*   e# Join the numbers in the list with that character.
1$  e# Copy the opening bracket (which may be an empty string).
B5/ e# Push B again and split it into chunks of 5: ["{[<(," "}]>);"]
~   e# Unwrap the array to leave both chunks on the stack.
er  e# Use them for transliteration, to turn the opening bracket into a closing one.
— Martin Ender
source
5

Pyth, 33 octets

rjjezrXwJ"<>[]  {}(),;"d7@c6JChz6

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

Explication:

J"<>[]  {}(),;"  assign this string to J

rjjezrXwJd7@c6JChz6   implicit: z = first input string, e.g. "[;"
       w              read another string from input (the list of numbers)
      X Jd            replace every char of ^ that appears in J with a space
     r    7           parse ^ (the string of numbers and spaces) into a list
  jez                 put z[1] (the separator symbol) between the numbers
            c6J       split J into 6 pieces ["<>", "[]", "  ", "{}", "()", ",;"]
               Chz    ASCII-value of z[0] (opening bracket symbol)
           @          take the correspondent (mod 6) brackets from the list
 j                    and put the numbers between these brackets
r                 7   remove leading and trailing spaces
— Jakube
source
Pouvez-vous ajouter une explication sur son fonctionnement?
— Shelvacu
1
@Shel Vous y êtes.
— Jakube
5

PowerShell, 108 100 95 85 Octets

$i,$z=$args;($z[0]+($i-split'[^\d.-]+'-ne''-join$z[1])+' }) >]'[($z[0]-32)%6]).Trim()

(voir l'historique des révisions pour les versions précédentes)

Golfed encore 15 octets en retirant $bet les $svariables et le changement des parenthèses sur la chaîne intérieure.

Cela prend comme entrée deux chaînes et magasins eux dans $iet $z, nous construisons une nouvelle chaîne de sortie. Les parenthèses internes -splits $iavec une expression régulière pour sélectionner uniquement des chiffres numériques, puis -joins en arrière avec le délimiteur demandé. Nous concaténons cela avec le premier caractère de l'entrée du délimiteur (par exemple, [) et le fermons avec l'indexation dans une chaîne basée sur la valeur ASCII du premier caractère et quelques ruses de formulation. L'extérieur .Trim()supprime tous les espaces de début ou de fin.

— AdmBorkBork
source
Je pense que vous pourriez remplacer votre expression de parenthèse fermante "]})>"["[{(< ".IndexOf($b[0])]par quelque chose comme ' }) >]'[($b[0]-32)%6]. Le ($b[0]-32)%6vous donne 0,2,4,5,1des caractères de parenthèse ouvrante que vous pouvez utiliser pour indexer dans la chaîne de parenthèse fermante' }) >]' . Il pourrait y avoir une "formule" plus courte, mais cela semble suffisant.
— Danko Durbić
@ DankoDurbić Excellent! J'essayais de trouver des mathématiques pour sélectionner le bon caractère de sortie en fonction des valeurs ASCII, mais je n'ai pas trouvé la bonne formule. Je n'arrêtais pas de trébucher en ()étant juste à côté les uns des autres, mais les autres crochets ont un caractère entre, alors j'ai opté pour l'indexation. Merci!
— AdmBorkBork
Utiliser à la String.Replace()place de l' -replaceopérateur vous achèterait encore 2 octets (pas besoin d'échapper ou de définir une classe de caractère avec [])
— Mathias R. Jessen
@ MathiasR.Jessen Sauf si je manque quelque chose ici, le .Replace('[]{}()<>;,',' ')n'attrapera pas les caractères individuels mais essaiera plutôt de faire correspondre l'ensemble symbolique, qui n'existe pas. Nous aurions besoin d'utiliser Regex.Replace , qui implique un [regex]::appel .NET et allongerait plutôt le code.
— AdmBorkBork
@TessellatingHeckler Merci! J'ai joué à un autre octet en utilisant -ne''au lieu de |?{$_}.
— AdmBorkBork
4

Python 2, 96 octets

import re
lambda(a,(b,c)):(b+c.join(re.findall('[-\d\.]+',a))+'])>} '['[(<{ '.index(b)]).strip()

Appelez comme:

f(('{-1.3, 3.4, ,4, 5.55555555}','[,'))

Production:

[-1.3,3.4,4,5.55555555]
— TFeld
source
2

JavaScript (ES6), 82 92 116 92 bytes

(a,b)=>(c=a.match(/-?\d+(\.\d+)?/g).join(b[1]),d=b[0],d<"'"?c:d+c+"]}>)"["[{<(".indexOf(d)])

Une fonction anonyme, lancez-la comme ceci

((a,b)=>(c=a.match(/-?\d+(\.\d+)?/g).join(b[1]),d=b[0],d<"'"?c:d+c+"]}>)"["[{<(".indexOf(d)]))("{1;  2;3;   4}","<;")

Cela peut probablement être joué beaucoup plus loin.

Non golfé

(a,b)=>(                             // "{1;  2;3;   4}", "<;"
    c=a.match(/-?\d+(\.\d+)?/g)      // regex to match decimals
    .join(b[1]),                     // c -> "1;2;3;4"
    d=b[0],                          // d -> "<"
    d<"'" ?                          // if d is smaller than ' then ...
        c :                          // return just "1;2;3;4"
        d + c +                      // "<" + "1;2;3;4" + ...
        "]}>)" [ "[{<(".indexOf(d) ] // "]}>)"[2] -> ">"
)
— Bassdrop Cumberwubwubwub
source
Je pense que vous devez prendre un comme une chaîne, pas une liste.
— suracteur
Totalement mal compris: The input will be a list of integer or decimal numbers (both positive and negative (and zero)), and a string of two characters. Corrigé, merci
— Bassdrop Cumberwubwubwub
2

Mathematica, 108 octets

Mathematica est généralement maladroit avec des entrées de chaîne sauf si la chaîne est destinée à être interprétée comme un texte. 

c=Characters;t_~f~p_:=({b,s}=c@p;b<>Riffle[StringCases[t,NumberString],s]<>(b/.Thread[c@"[ {<(" -> c@"] }>)"]))

Explication

StringCases[t,NumberString]renvoie la liste des chaînes de nombres.

Riffleinsère les séparateurs entre les nombres.

/.Thread[c@"[ {<(" -> c@"] }>)"]) remplace le "support" gauche par le support droit.

<>est la forme infixe de StringJoin. Il colle les sous-chaînes.

— DavidC
source
2

Matlab, 85 octets

@(s,x)[x(1) strjoin(regexp(s,'-?\d+\.?\d*','match'),x(2)) x(1)+(x(1)~=32)+(x(1)~=40)]

Exemple d'utilisation:

>> @(s,x)[x(1) strjoin(regexp(s,'-?\d+\.?\d*','match'),x(2)) x(1)+(x(1)~=32)+(x(1)~=40)]
ans = 
    @(s,x)[x(1),strjoin(regexp(s,'-?\d+\.?\d*','match'),x(2)),x(1)+(x(1)~=32)+(x(1)~=40)]

>> ans('1 2.4 -3 -444.555 5', '[,')
ans =
[1,2.4,-3,-444.555,5]
— Luis Mendo
source
1

Julia, 95 octets

f(l,s)=(x=s[1]<33?"":s[1:1])*join(matchall(r"[\d.-]+",l),s[2])*string(x>""?s[1]+(s[1]<41?1:2):x)

Il s'agit d'une fonction fqui accepte deux chaînes et renvoie une chaîne.

Non golfé:

function f{T<:AbstractString}(l::T, s::T)
    # Extract the numbers from the input list
    n = matchall(r"[\d.-]+", l)

    # Join them back into a string separated by given separator
    j = join(n, s[2])

    # Set the opening bracket type as the empty string unless
    # the given bracket type is not a space
    x = s[1] < 33 ? "" : s[1:1]

    # Get the closing bracket type by adding 1 or 2 to the ASCII
    # value of the opening bracket unless it's an empty string
    c = string(x > "" ? s[1] + (s[1] < 41 ? 1 : 2) : x)

    # Put it all together and return
    return x * j * c
end
— Alex A.
source
1

Utilitaires Bash + GNU, 90

b=${2:0:1}
echo $b`sed "s/[][{}()<>]//g;s/[,; ]\+/${2:1}/g"<<<"$1"``tr '[{(<' ']})>'<<<$b`
— Traumatisme numérique
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.