Tâche

Votre tâche consiste à convertir des chaînes comme ceci:

abc^d+ef^g + hijk^l - M^NO^P (Ag^+)

Pour des chaînes comme celle-ci:

   d   g       l    N P    +
abc +ef  + hijk  - M O  (Ag )

Qui est une approximation de abc ^d + ef ^g + hijk ^l - M ^N O ^P (Ag ⁺ )

En d'autres termes, élevez les caractères directement à côté des carets jusqu'à la ligne supérieure, un caractère pour un caret.

Spécifications

• Des espaces blancs finaux supplémentaires dans la sortie sont autorisés.
• Aucun caret enchaîné comme m^n^one sera donné en entrée.
• Un caret ne sera pas immédiatement suivi d'un espace ou d'un autre caret.
• Un caret ne sera pas précédé immédiatement d'un espace.
• Tous les carets seront précédés d'au moins un caractère et suivis d'au moins un caractère.
• La chaîne d'entrée ne contiendra que des caractères ASCII imprimables (U + 0020 - U + 007E)
• Au lieu de deux lignes de sortie, vous êtes autorisé à sortir un tableau de deux chaînes.

Pour ceux qui parlent l'expression régulière: la chaîne d'entrée correspondra à cette expression régulière:

/^(?!.*(\^.\^|\^\^|\^ | \^))(?!\^)[ -~]*(?<!\^)$/

Classement

var QUESTION_ID=86647,OVERRIDE_USER=48934;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

V , 15 14 octets

ÄÒ +òf^xxé kPj

Essayez-le en ligne!

Une solution assez simple. Le défi parfait pour V!

Explication:

Ä                "Duplicate this current line
 Ò               "Replace this line with spaces
   +             "Move to the beginning of the next line
    ò         ò  "Recursively (The second ò is implicit):
     f^          "  Find a caret
       xx        "  Delete two characters. The second will be saved into the main register
         é       "  Insert a space
           k     "  Move up
            P    "  Paste from the main register
             j   "  Move down

Idéalement, en fonction du fonctionnement de la récursivité, cela s'exécutera une fois pour chaque caret.

Cheddar, 77 72 67 octets

l->l.chars.vfuse.replace("^\n"," ").lines.map(j->"%-2s"%j).turn(3)

Aucun regex!

J'adore cette réponse car c'est une merveilleuse démonstration des capacités de Cheddar. Principalement grâce à la fonction de remplacement ajoutée par Conor. Le PR à dev n'a jamais été fait donc la fonction de remplacement n'existe que sur cette branche (mise à jour: j'ai fait le PR et maintenant c'est sur la dernière branche beta avec laquelle vous pouvez installer npm install -g cheddar-lang)

J'ai trouvé un moyen de jouer au golf, mais malheureusement, une erreur se produit lorsque les longueurs des articles ne sont pas les mêmes:

["   denifednud   denifednug       denifednul    denifednuN denifednuP    denifednu+ ", "abcdenifednu +efdenifednu  + hijkdenifednu  - Mdenifednu Odenifednu  (Agdenifednu )"]

J'aurais pu économiser beaucoup d'octets en utilisant l'expression régulière, et en fait je viens de faire des expressions régulières pour Cheddar ... le seul problème est qu'il n'y a pas de fonctions d'expression régulière: /

Explication

l->                    // Function take input as `l`
   l.chars             // Get array of chars in input
   .vfuse              // Join with newlines
   .replace("^\n"," ") // Replace `^\n` with a space globally
   .lines              // Get the lines (see below for more details on what this returns)
   .map(j->            // Loop through each "line" `j` is arg
       "%-2s"          // C-like printf format.
                       // think of as: padRight(j, " ", 2)
                       // see below for more details
        % j            // Pass j as the string to insert
   ).turn(3)           // Turn the string 270 degrees (see below)
   .vfuse              // Vertically fuse to get result (this is not needed as we can output an array of the lines)

Pour mieux comprendre. C'est ce qui .linesrevient pour1^2

["1", " 2"]

le .turnavec tourner ceci:

1
 2

dans:

 2
1

Un autre exemple qui le rendra plus clair:

1
 2
2
 2

devient:

 2 2
1 2

Pourquoi formater?

Ce que %-2sfait est assez simple. %spécifie que nous commençons un "format", ou qu'une variable sera insérée dans cette chaîne à ce stade. -signifie pad droit de la chaîne, et 2est la longueur maximale. Par défaut, il remplit d'espaces. sspécifie juste que c'est une chaîne. Pour voir ce que ça fait:

"%-2s" % "a"  == "a "
"%-2s" % " a" == " a"

Perl, 21 + 1 = 22 octets

say'';s/\^(.)/♥[A\1↓/

Courez avec le -pdrapeau. Remplacez-le ♥par un ESCoctet brut ( 0x1b) et ↓par un onglet vertical ( 0x0b).

L'onglet vertical est l'idée de Martin Ender. Il a sauvé deux octets! Merci.

JavaScript (ES6), 56 55 octets

s=>[/.(\^(.))?/g,/\^.(())/g].map(r=>s.replace(r,' $2'))

Regexps à la rescousse bien sûr. Le premier remplace tous les caractères par des espaces, sauf s'il trouve un signe d'insertion, auquel cas il supprime le signe d'insertion et conserve le caractère après lui. (Ces caractères sont garantis d'exister.) Le second est le plus évident pour remplacer chaque caret et son caractère suivant par un espace.

Edit: sauvé 1 octet grâce à @Lynn qui a imaginé un moyen de réutiliser la chaîne de remplacement pour le deuxième remplacement permettant au remplacement d'être mappé sur un tableau d'expressions rationnelles.

Python 3, 157 101 98 85 83 74 octets

Cette solution conserve la trace du caractère précédent ^, puis décide de sortir sur la première ou la deuxième ligne en fonction de cela.

Sorties sous forme de tableau de ['firstline', 'secondline'].

a=['']*2
l=0
for c in input():x=c=='^';a[l]+=c*x;a[~l]+=' '*x;l=x
print(a)

Enregistré 13 15 octets grâce à @LeakyNun!

7 octets enregistrés grâce à @Joffan!

Python 2, 73 octets

l=['']*2;p=1
for c in input():b=c!='^';l[p]+=c*b;l[~p]+=' '*b;p=b
print l

Aucun regex. Se souvient si le caractère précédent était ^, et place le caractère actuel dans la ligne supérieure ou inférieure en fonction de cela, et un espace dans l'autre.

Pyth, 17 octets

CcsmX~Z1j;d;cQ\^2

             Q      input string
            c \^    split on '^'
   m                map for sections d:
    X      ;          insert a space at index:
     ~Z1                the old value of Z (initially 0), before setting Z to 1
                      into:
        j;d             the section joined on spaces
  s                 concatenate
 c              2   chop into groups of 2
C                   transpose

Renvoie un tableau de 2 chaînes. (Préparez-vous jà les rejoindre avec une nouvelle ligne.)

Essayez-le en ligne .

MATL , 18 octets

94=t1YSt~&vG*cw~Z)

Essayez-le en ligne!

94=    % Take input implicitly. Create logical array of the same size that contains
       % true for carets, false otherwise
t      % Push a copy of this array
1YS    % Circularly shift 1 unit to the right. This gives an array that contains true
       % for the elements right after a caret (superindices), and false for the rest 
t~     % Push a copy and negate
&v     % Concatenate vertically. This gives a 2D, 2-row array
G*     % Push the input again, multiply with broadcast. This gives a 2D array in
       % which the first row contains the superindices (characters after a caret)
       % and 0 for the rest; and the second row contains the non-superindices and
       % 0 for the superindices
c      % Convert to char
w      % Swap. Brings to top the array containing true for carets and false otherwise
~      % Negate
Z)     % Use as logical index to remove rows that contain carets. Display implicitly

Rubis, 47 + 1 (-n drapeau) = 48 octets

puts$_.gsub(/\^(.)|./){$1||" "},gsub(/\^./," ")

Exécutez-le comme ceci: ruby -ne 'puts$_.gsub(/\^(.)|./){$1||" "},gsub(/\^./," ")'

Python (2), 76 68 67 octets

-5 octets grâce à @LeakyNun

-3 octets grâce à @ KevinLau-notKenny

-1 octet grâce à @ValueInk

-0 octets grâce à @DrGreenEggsandIronMan

import re
lambda i,s=re.sub:[s("(?<!\^).\^?"," ",i),s("\^."," ",i)]

Cette fonction Lambda anonyme prend la chaîne d'entrée comme seul argument et renvoie les deux lignes de sortie séparées par une nouvelle ligne. Pour l'appeler, donnez-lui un nom en écrivant "f =" devant lui.

Regex assez simple: La première partie remplace le suivant par un espace: un caractère et une carotte caret ou seulement un char, mais seulement s'il n'y a pas caret devant eux. La deuxième partie remplace tout signe d'insertion dans la chaîne et le caractère suivant par un espace.

Convexe, 24 octets

®(?<!\^).\^?"SòNê®\^."Sò

Essayez-le en ligne!

Rétine, 16 octets

S`^
\^(.)
♥[A$1↓

Un portage de ma réponse Perl, souligné par Martin Ender. Remplacez ♥par un ESCoctet brut ( 0x1b) et ↓par une tabulation verticale ( 0x0b).

shell + TeX + catdvi, 51 43 octets

tex '\empty$'$1'$\end'>n;catdvi *i|head -n2

Utilise texpour composer de belles mathématiques, puis utilisecatdvi pour créer une représentation textuelle. La commande head supprime les indésirables (numérotation des pages, sauts de ligne) qui sont autrement présents.

Edit: Pourquoi faire la chose longue et appropriée et rediriger vers /dev/nullquand vous pouvez ignorer les effets secondaires et écrire dans un fichier à une seule lettre?

Exemple

Contribution: abc^d+ef^g + hijk^l - M^NO^P (Ag^+)

Sortie TeX (rognée en équation): Sortie finale:

   d   g     l  N P   +
abc +ef +hijk -M O (Ag )

Hypothèses: commencer dans un répertoire vide (ou spécifiquement un répertoire sans nom se terminant par "i"). L'entrée est un seul argument du script shell. L'entrée n'est pas une chaîne vide.

Quelqu'un me dit si c'est un abus de règle, surtout catdvi.

Haskell, 74 56 55 octets

g('^':c:r)=(c,' '):g r
g(c:r)=(' ',c):g r
g x=x
unzip.g

Renvoie une paire de chaînes. Exemple d'utilisation: unzip.g $ "abc^d+e:qf^g + hijk^l - M^NO^P: (Ag^+)"->(" d g l N P + ","abc +e:qf + hijk - M O : (Ag )")

gcrée une liste de paires, où le premier élément est le caractère dans la ligne supérieure et le deuxième élément est le caractère dans la ligne inférieure. unziple transforme en une paire de listes.

Modifier: @xnor a suggéré d' unzipéconomiser 18 octets. @Laikoni a trouvé un octet de plus à enregistrer. Merci!

Perl, 35 octets

Code de 34 octets + 1 pour -p

$_=s/\^(.)|./$1||$"/ger.s/\^./ /gr

Usage

perl -pe '$_=s/\^(.)|./$1||$"/ger.s/\^./ /gr' <<< 'abc^d+ef^g + hijk^l - M^NO^P (Ag^+)'
   d   g       l    N P    + 
abc +ef  + hijk  - M O  (Ag )

Remarque: C'est exactement la même chose que la réponse de Value Ink que j'ai espionnée par la suite. Supprime si nécessaire car cela n'ajoute pas vraiment à la solution Ruby.

Java 8 lambda, 132 128 112 112 caractères

i->{String[]r={"",""};for(char j=0,c;j<i.length();j++){c=i[j];r[0]+=c==94?i[++j]:32;r[1]+=c==94?32:c;}return r;}

La version non golfée ressemble à ceci:

public class Q86647 {

    static String[] printExponents(char[] input) {
        String[] result = {"",""};
        for (char j = 0, c; j < input.length(); j++) {
            c = input[j];
            result[0] += c == 94 ? input[++j] : 32;
            result[1] += c == 94 ? 32 : c;
        }
        return result;
    }
}

Les sorties sous forme de tableau, vérifiant simplement s'il y a un signe d'insertion et si c'est le cas, le caractère suivant sera placé dans la ligne supérieure, sinon il y aura un espace.

Mises à jour

Les caractères remplacés avec leurs valeurs ascii pour enregistrer 4 caractères.

Merci à @LeakyLun d'avoir indiqué d'utiliser un tableau de caractères comme entrée à la place.

Grâce aussi à @KevinCruijssen pour passer la intà charsauver quelques caractères.

Noix de coco , 122114 96 octets

Edit: 8 26 octets vers le bas avec l'aide de Leaky Nun.

def e(s,l)=''==l and s or"^"==l[0]and l[1]+e(s+' ',l[2:])or' '+e(s+l[0],l[1:])
f=print..e$('\n')

Donc, comme j'ai appris aujourd'hui, python a un opérateur conditionnel ternaire, ou en fait deux d'entre eux: <true_expr> if <condition> else <false_expr>et le <condition> and <true_expr> or <false_expr>dernier avec un caractère de moins.
Une version conforme python peut être idéée .

Premier essai:

def e(s,l):
 case l:
  match['^',c]+r:return c+e(s+' ',r)
  match[c]+r:return' '+e(s+c,r)
 else:return s
f=print..e$('\n')

Appel avec f("abc^d+ef^g + hijk^l - M^NO^P (Ag^+)")impressions

   d   g       l    N P    +
abc +ef  + hijk  - M O  (Ag )

Quelqu'un a déjà essayé le golf à la noix de coco? Il enrichit python avec des concepts de programmation plus fonctionnels comme la correspondance de motifs et la concaténation de fonctions (avec ..) utilisées ci-dessus. Comme c'est mon premier essai de noix de coco, tous les conseils seraient appréciés.

Cela pourrait certainement être raccourci car tout code python valide est également une noix de coco valide et des réponses plus courtes en python ont été publiées, mais j'ai essayé de trouver une solution purement fonctionnelle.

Dyalog APL, 34 octets

{(0 1=⊂b/¯1⌽b){⍺\⍺/⍵}¨⊂⍵/⍨b←⍵≠'∧'}

Il renvoie un vecteur à deux éléments avec les deux lignes

Exemple de course (la flèche en haut sert à formater le vecteur à deux éléments pour la consommation humaine):

      ↑{(0 1=⊂b/¯1⌽b){⍺\⍺/⍵}¨⊂⍵/⍨b←⍵≠'∧'}'abc∧d+ef∧g + hijk∧l - M∧NO∧P (Ag∧+)'
   d   g       l    N P    + 
abc +ef  + hijk  - M O  (Ag )

PowerShell v2 +, 88 83 octets

-join([char[]]$args[0]|%{if($c){$_;$b+=' '}elseif($_-94){$b+=$_;' '}$c=$_-eq94});$b

Un peu plus long que les autres, mais présente un peu de magie PowerShell et une logique un peu différente.

Essentiellement le même concept que les réponses Python - nous parcourons le caractère par caractère en entrée, nous rappelons si le précédent était un caret ( $c), et mettons le caractère actuel à l'endroit approprié. Cependant, la logique et la méthode pour déterminer où produire sont traitées un peu différemment, et sans tuple ni variables distinctes - nous testons si le caractère précédent était un signe d'insertion, et si c'est le cas, sortez le caractère dans le pipeline et concaténez un espace sur $b. Sinon, nous vérifions si le caractère actuel est un signe d'insertion elseif($_-94)et tant que ce n'est pas le cas, nous concaténons le caractère actuel $bet envoyons un espace au pipeline. Enfin, nous définissons si le personnage actuel est un curseur pour le prochain tour.

Nous rassemblons ces caractères du pipeline ensemble parens, les encapsulons dans un -joinqui les transforme en chaîne, et laissons cela $bsur le pipeline. La sortie à la fin est implicite avec une nouvelle ligne entre les deux.

À titre de comparaison, voici un port direct de la réponse Python @ xnor , à 85 octets :

$a=,''*2;[char[]]$args[($l=0)]|%{$a[!$l]+="$_"*($c=$_-ne94);$a[$l]+=' '*$c;$l=!$c};$a

Gema, 42 41 caractères

\^?=?@set{s;$s }
?=\ @append{s;?}
\Z=\n$s

Gema traite les entrées sous forme de flux, vous devez donc les résoudre en un seul passage: la première ligne est écrite immédiatement comme traitée, la deuxième ligne est collectée dans la variable $ s, puis sortie à la fin.

Exemple d'exécution:

bash-4.3$ gema '\^?=?@set{s;$s };?=\ @append{s;?};\Z=\n$s' <<< 'abc^d+ef^g + hijk^l - M^NO^P (Ag^+)'
   d   g       l    N P    +  
abc +ef  + hijk  - M O  (Ag )

Gomme de cannelle, 21 octets

0000000: 5306 6533 bd92 d1db 8899 8381 a2f8 8f8c  S.e3............
0000010: 1230 249e a1                             .0$..

Non compétitif. Essayez-le en ligne.

Explication

Je ne suis pas beaucoup un golfeur regex, donc il y a probablement une meilleure façon de le faire.

La chaîne se décompresse pour:

S(?<!\^)[^^]& &\^&`S\^.& 

(notez l'espace de fin)

La première Sétape reçoit une entrée et utilise un regard négatif pour remplacer tous les caractères autres que les carets sans caret précédent par un espace, puis supprime tous les carets. Ensuite, il sort immédiatement la chaîne d'entrée modifiée avec une nouvelle ligne et supprime cette Sétape. Étant donné que STDIN est maintenant épuisé et que l'étape précédente n'a fourni aucune entrée, la prochaineS étape reçoit à nouveau la dernière ligne de STDIN, puis remplace tous les carets suivis par n'importe quel caractère avec un espace et les affiche.

En Perl pseudo-code:

$first_stage_sub_1 = ($input =~ s/(?<!\^)[^^]/ /gr);
$first_stage_sub_2 = ($first_stage_sub_1 =~ s/\^//gr);
print $first_stage_sub_2, "\n";

$second_stage_sub = ($input =~ s/\^./ /gr);
print $second_stage_sub, "\n";

J , 28 27 octets

0|:t#]{."0~_1-_1|.t=.'^'~:]

Essayez-le en ligne!

                  t=.'^'~:]    0 for ^, 1 for the rest, define t
              _1|.             Shift right, now zeroes are for superscripts         
     ]{."0~_1-                 Prepend that many spaces to each character
   t#                          Remove the rows with carets
0|:                            Transpose

Il doit y avoir une meilleure façon ...