Generator palindromu palindromowego

22

Utwórz program, który konwertuje ciąg wejściowy na palindrom, zaczynając od ciągu wejściowego. Sam program musi być palindromem.

Na przykład wpisz neverod:, wydrukuj neveroddoreven. Powinieneś także obsługiwać dane wejściowe zawierające wiele słów i wiele wierszy.

tmp
źródło
2
To wydaje się bardzo podobne do tego pytania , z tym wyjątkiem, że generujemy zamiast sprawdzać. Istnieją jednak takie same sztuczki, aby program stał się palindromem.
Sp3000,
2
Rozumiem całkowicie pytanie, ale pytanie zostało odrzucone?
John Dvorak,
2
@JanDvorak Zgaduję, ponieważ wykorzystuje komentarze do utworzenia palindromu, co konkretnie czyni tę strategię OK. To nie jest bardzo interesujący sposób i jest szczególnie zbanowany w co najmniej jednym pytaniu wymagającym kodu palindromicznego: codegolf.stackexchange.com/q/28190/15599 . Tomek, witaj w programowaniu łamigłówek i codegolf. W każdym razie jestem wdzięczny, abyś miał dostęp do naszej piaskownicy meta.codegolf.stackexchange.com/q/2140/15599, jednak zalecamy pozostanie i odpowiedź na kilka pytań, zanim zadasz kolejne. Pamiętaj też, aby szukać podobnych pytań przed opublikowaniem
Level River St
Czy funkcje są dozwolone (zamiast całych programów)?
nimi
Czy możemy użyć ogranicznika dla wygenerowanego palindromu? tj. neverod-> neverodadoreven(z apomiędzy)
Rɪᴋᴇʀ

Odpowiedzi:

26

Dyalog APL, 6 4

⌽,,⌽

Wypróbuj tutaj.

Inne rozwiązania:

⌽,⊢⊢,⌽
⌽⊢⊢,⊢⊢⌽

Wyjaśnienie

Są po prostu:

{⌽((,⍵),(⌽⍵))}
{⌽((,⍵)⊢((⊢⍵),(⌽⍵)))}
{(⌽⍵)⊢((⊢⍵),((⊢⍵)⊢(⌽⍵)))}

Monadyczny ,i nic nie robi na łańcuchach. Dyadic ,to konkatenacja. Dyadic zwraca właściwy operand. I oczywiście jest to odwrócenie.

jimmy23013
źródło
1
Pamiętaj, że działa to tylko w APL Dyalog.
FUZxxl,
22

piet 19x2 = 38

http://www.pietfiddle.net/img/aoNhlwC47U.png?cs=15&rot=4

Akceptuje dane wejściowe, dopóki nie napotka 0x00. Nie kończy się, ale dane wyjściowe będą poprawne.

captncraig
źródło
3
Symetryczny: tak; palindromic:?
niebieski
@Blue Nie sądzę, aby można było zrobić palindromiczny plik obrazu PNG z powodu nagłówka i stopki. Ponadto kompresja PNG oznacza, że ​​bajty na obrazie prawie na pewno nie są palindromiczne.
Esolanging Fruit,
1
@EsolangingFruit Choć można argumentować, że obraz palindromu powinien być centrosymetryczny.
Jonathan Frech,
17

APL, 9

⍞←Z,⌽,Z←⍞

Wyjaśnienie:

       Z←⍞  ⍝ read a line from the keyboard, and store it in Z
      ,     ⍝ flatten into one-dimensional array (this has no effect here)
     ⌽      ⍝ reverse
   Z,       ⍝ concatenate Z to its reverse
⍞←         ⍝ explicit output (not necessary, but it makes it a palindrome)
marinus
źródło
13

CJam, 13 bajtów

qL;_-1%1-_;Lq

qL;                 "Read the input, Put an empty array on stack and pop that array";
   _-1%             "Now the string is on top, make a copy and reverse the copy";
       1-           "Remove occurrences of integer 1 from the reverse string. [no-op]";
         _;         "Copy the reversed string and pop it";
           Lq       "Put an empty array on stack and read the remaining input. Remaining";
                    "input will be empty as we already read whole of the input";

Wypróbuj online tutaj


lub..

GolfScript, 9 bajtów

.-1%}%1-.

.                 "Input is already on stack. Make a copy";
 -1%              "Reverse the copy";
    }             "This marks the beginning of a super comment. Anything after this in the";
                  "code is a comment";
     %1-.         "no-op comment";

Wypróbuj tutaj

Optymalizator
źródło
Myślę, że znalazłeś błąd w parserze GolfScript ze swoim „super-komentarzem”. Pamiętaj, że zwykły #komentarz będzie tam równie dobrze działał.
Ilmari Karonen
@IlmariKaronen To nie ja, }był znany jako super komentarz od wieków :)
Optimizer
8

C ++, 162 bajty

#include<cstdio>//
main(){int c=getchar();if(c>0)putchar(c),main(),putchar(c);}//};)c(rahctup,)(niam,)c(rahctup)0>c(fi;)(rahcteg=c tni{)(niam
//>oidtsc<edulcni#

C, 117 bajtów

main(c){c=getchar();if(c>0)putchar(c),main(),putchar(c);}//};)c(rahctup,)(niam,)c(rahctup)0>c(fi;)(rahcteg=c{)c(niam
tmp
źródło
1
niech Bóg błogosławi dwa ukośniki lol
Abr001am
7

Haskell, 102 + 22 = 124 bajty

a b fa=fa<|>b
fa=reverse>>=a
main=interact fa
niam=main
af tcaretni=niam
a=>>esrever=af
b>|<af=af b a

Musi to zostać uruchomione z Control.Applicativemodułem w zakresie, który można ustawić za pomocą pliku inicjującego ghci .ghci: :m Control.Applicative(-> +22 bajtów).

Bez sztuczki komentowania, tylko 7 funkcji, z których 4 nigdy nie są wywoływane.

Jeśli funkcje (zamiast programów) są dozwolone:

Haskell, 55 + 22 = 77 bajtów

a b fa=fa<|>b
f=reverse>>=a
a=>>esrever=f
b>|<af=af b a

Zastosowanie f "qwer"->"qwerrewq"

Edycja: poprzednia wersja była po prostu zła.

nimi
źródło
3

Pyth, 11 bajtów

+z_z " z_z+

W Pyth wszystko poprzedzone spacją nie jest drukowane. Więc po prostu dodajemy do siebie znak negatywny ciągu, wstawiamy spację, rozpoczynamy ciąg znaków i odbijamy lewą stronę cytatu „

Wypróbuj online tutaj

Optymalizator
źródło
3

Ruby, 44

s=gets p
s+=s.reverse||esrever.s=+s
p steg=s

Pobiera ciąg multilinii jako dane wejściowe ze standardowego wejścia, wyświetla Rubinową reprezentację tego łańcucha połączoną z jego odwrotnością. Można przyciąć znak, zastępując ||go, #aby skomentować martwy kod w drugim wierszu.

histocrat
źródło
s=gets p! =p steg=s
CalculatorFeline
... prawda, nie mam pojęcia, co mam na myśli.
histocrat
3

Jolf, 9 bajtów

Nowszy język, niekonkurujący

Spróbuj tutaj

aη+i_i+ηa

Objaśnienie: Właśnie zacząłem Jolfa i nie sądzę, że wyjaśniam to poprawnie.

aη         alert function, arity of the function can't be reduced by 1 so it stays at 1
  +i_i     concatenate the input with the reversed input
      +η   arity of the add reduced by 1, it just takes the following character (a)
        a  returns the input
puchnie
źródło
1
Witamy w PPCG! Widziałem twoją drugą odpowiedź i doceniam, że używasz tego języka! To moje własne wynalazki, mam nadzieję, że ci się podobają :) To naprawdę fajne rozwiązanie, bardzo dobrze zrobione! Podoba mi się sposób, w jaki zastosowałeś ηrozwiązanie, bardzo dobrze zrobione. Można zapisać dwa bajty eliminując MU, jak: a+i_i+a. (Jolf ma również niejawne dane wejściowe do uzupełnienia pozostałych argumentów, ale to nie jest problem, ponieważ tylko jedna informacja jest podana na raz.) Nadal trzymałbym twoje oryginalne rozwiązanie w odpowiedzi.
Conor O'Brien
@ Cᴏɴᴏʀ O'Bʀɪᴇɴ Thanks! Po prostu wybrałem język golfa, który nie wydawał się zbyt przerażający, i wskoczyłem do niego, cieszę się, że go rozumiem. Próbowałem dowiedzieć się, skąd pochodzi η i zdałem sobie sprawę, że to od próby ustalenia mojego punktu początkowego + i_i +. Dzięki za informację!
puchnie
3

PowerShell, 67

$args|%{$_+-join$_[$_.Length..0]}#}]0..htgneL._$[_$nioj-+_${%|sgra$

Wypróbuj online

Jak sugeruje @mazzy, kod można skrócić o 12 bajtów, gdy używany jest zakres statyczny. Ogranicza to jednak długość wejściową do 9 KB. Teoretycznie możliwe byłoby 9 MB, ale znacznie spowolniłoby to kod.

$args|%{$_+-join$_[9kb..0]}#}]0..bk9[_$nioj-+_${%|sgra$
J. Bergmann
źródło
1
Alternatywne 67 bajtów:param($s)$s+-join$s[$s.Length..0]#]0..htgneL.s$[s$nioj-+s$)s$(marap
mazzy
jeśli długość ciągu wejściowego jest mniejsza niż 9 KB, to $args|%{$_+-join$_[9Kb..0]}#}]0..bK9[_$nioj-+_${%|sgra$(55 bajtów)
mazzy
2

Fuzzy Octo Guacamole, 17 bajtów

FOG jest nowszy niż to wyzwanie, więc nie jest konkurencyjny.

^dz''sjX@Xjs''zd^

Alt rozwiązanie w 19 bajtach:

^Czs''.jX@Xj.''szC^

Obie pobierają dane wejściowe, duplikują i odwracają oraz dołączają do stosu.

Wyjaśnienie:

^dz''sj@js''zd^
^                # Get input
 d               # Duplicate ToS (input)
  z              # Reverse ToS
   ''            # Push empty string (for joining separator)
     s           # Move the empty string to the inactive stack
      j          # Join the active stack with the top of the inactive stack as the delimiter and push the result.
       X         # Print the ToS
        @        # End the program
        Xjs''zd^  # Backwards version of the beginning.
Rɪᴋᴇʀ
źródło
Ponadto, niekonkurujący: P
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ ups. : P
Rɪᴋᴇʀ
1

tinyBF , 40

|=||==>|=|=|=+|=>==||==>=|+=|=|=|>==||=|

Moją pierwszą myślą było Brainfuck, ale nie można dopasować aparatów ortodontycznych ... na szczęście tinyBF ma prostszą kontrolę przepływu.

Bez komentarzy, pobiera ciąg zakończony znakiem zerowym jako dane wejściowe i zwraca wynik w ciągu zakończonym znakiem zerowym. Możesz to przetestować tutaj , ale ostrzegaj, że się nie zatrzymuje (chociaż Firefox przynajmniej monituje o zatrzymanie niereagującego skryptu).

Skomentowano:

|=|                        Retrieve a byte of input.
|                          Positive (opening) bracket.
   ==                      Output the byte.
   >                       Move the pointer in positive direction.
   |=|                     Retrieve a byte of input.
   =                       Switch direction to negative.
|                          Negative (closing) bracket.
=                          Switch direction.
+                          Increment byte to execute return loop.
|                          Opening bracket.
   =>                      Move the pointer in negative direction.
   ==                      Output the byte.
|                          Closing bracket.
|=|                        Output the null terminator.
|==>|=|=|=+|=>==|          ...and keep null terminating it just to be sure.

Zauważ, że jeśli zakodujesz go w instrukcjach 2-bitowych, zmniejszy on rozmiar do 10 bajtów (nie byłby to palindrom).

Komintern
źródło
1

Python 3, 59 bajtów

a=input()#
print(a+a[::-1])#([1-::]a+a)tnirp
#()tupni=a

Starałem się jak najlepiej znaleźć rozwiązanie wykorzystujące tylko jedną linię, ale nie miałem szczęścia.

Python 3, 79 bajtów

a=input()#()tupni=a#
print(a+a[::-1])#([1-::]a+a)tnirp
#a=input()#()tupni=a

Moja oryginalna próba, w której każda linia jest palindromem. Nie sądzę, aby było to konieczne, ale na wszelki wypadek je uwzględniłem.

Noomann
źródło
1
lambdaprint((lambda a:a+a[::-1])(input()))#)))(tupni()]1-::[a+a:a adbmal((tnirp
Jednowierszowy,
Bardzo dobrze. Mniej znam się na lambdach, ale powoli się do nich przyzwyczajam. Dzięki za udostępnienie.
Noomann,
1

Vitsy, 9 bajtów

z:Zr?rZ:z
z          Grab all string input from the command line arguments.
 :         Duplicate this stack.
  Z        Print all elements in this stack as a string.
   r       Reverse (reverses an empty stack).
    ?      Go right a stack.
     r     Reverse (reverses the input).
      Z    Print all elements in this stack as a string.
       :   Duplicate the stack (duplicates an empty stack).
        z  Grab all input from the command line (the command line arguments stack is already empty).

Wypróbuj online!

Addison Crump
źródło
1

Befunge , 37 bajtów

~:0`!#v_:,
  >:#,_@_,#:>  
,:_v#!`0:~

Wypróbuj online!

Górna linia popycha i drukuje każdy znak danych wejściowych. Druga linia (przed @) wypisuje stos w odwrotnej kolejności, ale wchodzimy po stronie kierunkowej, _aby zużyć -1 wygenerowane po zakończeniu odczytu danych wejściowych. Druga połowa kodu (w tym te brzydkie końcowe znaki nowej linii) sprawia, że ​​źródło jest palindromem, ale nigdy nie działa.

Linus
źródło
1

C # ( 33 32 + 1) * 2 = 68 66 bajtów

zapisano 2 bajty na użycie .Aggregate ()

s=>s+s.Aggregate("",(a,b)=>b+a);//;)a+b>=)b,a(,""(etagerggA.s+s>=s

Och, stara dobra lambda, możesz ją złapać

Func<string, string> f=<lambda here>

a następnie zadzwoń za pomocą

f("neverod")
hstde
źródło
1

Perl, 45 bajtów

;print$_=<>,~~reverse;m;esrever~~,><=_$tnirp;

Całkiem proste, prints input ( $_=<>), po którym następuje reverse. reversezwraca, $_ponieważ używamy go w kontekście skalarnym przez prefiks z ~~. Następnie dopasowujemy ( m//używając ;jako separatora), w pustym kontekście, do rewersu skryptu.

Jeśli możemy zagwarantować, nie będziemy musieli tworzyć palindromu esrever,><=_$tnirp, możemy skrócić kod do 43 bajtów :

g.print$_=<>,reverse.m.esrever,><=_$tnirp.g

Stosowanie

echo -n 'neverod' | perl -e 'g.print$_=<>,reverse.m.esrever,><=_$tnirp.g'
neveroddoreven

Perl, 26 bajtów

Zawiera 25 bajtów kodu + 1 dla -p.

$_.=reverse;m;esrever=._$

Nie sądzę, że jest to poprawne, ponieważ wymaga -pflagi, której nie sądzę można łatwo połączyć z treścią skryptu, aby stworzyć prawdziwy palindrom. Prawie takie same wywołania jak powyżej, ale opiera się na tym, że -pdodaje także ;zakulisowe (w nowszych Perlach ...), aby zamknąć m//.

Stosowanie

echo -n 'neverod' | perl -pe ';$_.=reverse;m;esrever=._$;'
neveroddoreven
Dom Hastings
źródło
0

Pyth, 15 lat

 k k+ z_z +k k 

Zwróć uwagę na miejsce na początku i na końcu.

Dość irytujące zadanie w Pyth. z_zwypisuje żądany palindrom, ale wypisuje z(ciąg wejściowy) i _zodwrotny na dwóch różnych liniach. +łączy dwa słowa, ale +na końcu wymaga dwóch nowych instrukcji na końcu (i na początku). Wybieram ki k, które są tylko pustymi ciągami. Następnie dużo białych znaków, które hamują drukowanie (i drukowanie pustych miejsc, które generują oczywiście przerwy linii).

Ponieważ białe znaki pomijają każde wyjście oprócz +z_z, możesz zastąpić kliterał si literą arity 0. Np . 1 2+ z_z +2 1Lub T Z+ z_z +Z T.

Wypróbuj online .

Jakube
źródło
1
I have an 11 one in Pyth, which I did not post yet coz I thought you will surely beat it ;)
Optimizer
0

Javascript, 137 bytes

I'm not using the "comment trick" but I am using the escaped quotation mark trick lol.

"a\"};))''(nioj.)(esrever.)''(tilps.b(tacnoc.b nruter{)b(a noitcnuf";function a(b){return b.concat(b.split('').reverse().join(''));};"\a"
Steve
źródło
4
I don't think this counts; the two central chars are ";. Adding a ; as the last char inside the string should fix this.
ETHproductions
As it stands this answer is invalid. Please either fix it or remove it.
Jonathan Frech
0

JavaScript, 58 bytes

p=>p+[...p].reverse().join``//``nioj.)(esrever.]p...[+p>=p
ericw31415
źródło
0

PHP, 28+1+28=57 bytes

<?=($x=$argv[1]).strrev($x);#;)x$(verrts.)]1[vgra$=x$(=?<

takes input from command line argument. quote for multi-word, escape newlines for multi-line.

Titus
źródło
0

Python 2, 51 bytes

s=input();print s+s[::-1]#]1-::[s+s tnirp;)(tupni=s

I'm surprised no-one thought of this! Needs quoted input (' or "). If functions were allowed, I could have done this for 37 bytes instead:

lambda x:x+x[::-1]#]1-::[x+x:x adbmal
Erik the Outgolfer
źródło
0

C++14, 152 116 bytes

As unnamed lambda, assumes s to be string

[](auto s){decltype(s)r;for(auto c:s){r=c+r;}return s+r;}//};r+s nruter};r+c=r{)s:c otua(rof;r)s(epytlced{)s otua(][

Old solution:

[](auto s){auto r=s;for(auto p=s.rbegin()-1;++p!=s.rend();r+=*p);return r;}//};r nruter;)p*=+r;)(dner.s=!p++;1-)(nigebr.s=p otua(rof;s=r otua{)s otua(][

Usage:

auto f=[](auto s){decltype(s)r;for(auto c:s){r=c+r;}return s+r;};

main(){
 string a="123456789";
 cout << f(a) << endl;
}
Karl Napf
źródło
0

05AB1E, 5 bytes

«q«Â

Try it online.

Explanation:

        # Bifurcate (short for Duplicate & Reverse) the (implicit) input
         #  i.e. "neverod" → "neverod" and "doreven"
 «       # Concat both together
         #  i.e. "neverod" and "doreven" → "neveroddoreven"
  q      # Exit the program (and implicitly output the concatted result)
   «Â    # No-ops

Or alternatively:

R«q«R

Try it online.

Where R is reverse, and the « takes the input implicitly again to concat with.


NOTE: If we are allowed to output neverodoreven for the input neverod, which is still a palindrome, it can be done in 1 byte instead with the palindromize builtin:

û

Try it online.

Kevin Cruijssen
źródło
0

x86-64 Assembly (Microsoft x64 calling convention), 89 bytes:

80 39 00 48 8B D1 4C 8B C1 74 0B 48 FF C2 49 FF C0 80 3A 00 75 F5 48 FF CA 8A 02 41 88 00 48 8B C2 48 FF CA 49 FF C0 48 3B C1 77 ED C3 ED 77 C1 3B 48 C0 FF 49 CA FF 48 C2 8B 48 00 88 41 02 8A CA FF 48 F5 75 00 3A 80 C0 FF 49 C2 FF 48 0B 74 C1 8B 4C D1 8B 48 00 39 80

Disassembled:

 0000000000000000: 80 39 00           cmp         byte ptr [rcx],0
 0000000000000003: 48 8B D1           mov         rdx,rcx
 0000000000000006: 4C 8B C1           mov         r8,rcx
 0000000000000009: 74 0B              je          0000000000000016
 000000000000000B: 48 FF C2           inc         rdx
 000000000000000E: 49 FF C0           inc         r8
 0000000000000011: 80 3A 00           cmp         byte ptr [rdx],0
 0000000000000014: 75 F5              jne         000000000000000B
 0000000000000016: 48 FF CA           dec         rdx
 0000000000000019: 8A 02              mov         al,byte ptr [rdx]
 000000000000001B: 41 88 00           mov         byte ptr [r8],al
 000000000000001E: 48 8B C2           mov         rax,rdx
 0000000000000021: 48 FF CA           dec         rdx
 0000000000000024: 49 FF C0           inc         r8
 0000000000000027: 48 3B C1           cmp         rax,rcx
 000000000000002A: 77 ED              ja          0000000000000019
 000000000000002C: C3                 ret
 000000000000002D: ED                 in          eax,dx
 000000000000002E: 77 C1              ja          FFFFFFFFFFFFFFF1
 0000000000000030: 3B 48 C0           cmp         ecx,dword ptr [rax-40h]
 0000000000000033: FF 49 CA           dec         dword ptr [rcx-36h]
 0000000000000036: FF 48 C2           dec         dword ptr [rax-3Eh]
 0000000000000039: 8B 48 00           mov         ecx,dword ptr [rax]
 000000000000003C: 88 41 02           mov         byte ptr [rcx+2],al
 000000000000003F: 8A CA              mov         cl,dl
 0000000000000041: FF 48 F5           dec         dword ptr [rax-0Bh]
 0000000000000044: 75 00              jne         0000000000000046
 0000000000000046: 3A 80 C0 FF 49 C2  cmp         al,byte ptr [rax+FFFFFFFFC249FFC0h]
 000000000000004C: FF 48 0B           dec         dword ptr [rax+0Bh]
 000000000000004F: 74 C1              je          0000000000000012
 0000000000000051: 8B 4C D1 8B        mov         ecx,dword ptr [rcx+rdx*8-75h]
 0000000000000055: 48 00 39           add         byte ptr [rcx],dil
 0000000000000058: 80

Note that the code after the ret instruction at 2C is unreachable so it doesn't matter that it's nonsense

Govind Parmar
źródło
0

Japt, 4 bytes

êêêê

Try it online!

How it works

U.ê("ê".ê("ê"))  Transpiled to JS

       .ê("ê")   String.ê(string): true if `this` is palindrome
    "ê".ê("ê")   true (treated same as 1)
U.ê(          )  String.ê(number): palindromify
                   "abc"->"abccba" if `number` is odd, "abcba" otherwise
                 `true` is odd number, so we achieve the desired function

Alternative 4 bytes

pwwp

Try it online!

How it works

U.p("w".w("p"))  Transpiled to JS
    "w".w(   )   Reverse of "w" ("p" is ignored)
U.p("w")         Append U.w(), which is reverse of U, to the right of U
Bubbler
źródło
0

Backhand, 33 27 bytes

iH~0}|{<:: oi]io ::<{|}0~Hi

Try it online!

Unlike a lot of the solutions here, this one actually does use the palindromised code!

Explanation:

i  0 |{      Get the first character and enter the loop
        :  o    Output the character while preserving it
              i  :     Get input and duplicate it
                   <{  Turn around
             ]         Increment the copy to check if EOF   
    }| <    Loop again if not EOF
  ~   If EOF, pop the extra copy of EOF
 H    Terminate, printing the contents of the stack.

Altogether, the unexecuted instructions are:

       :   i  o :   |}0~Hi
Jo King
źródło