Berechnen Sie das Quadrat einer Ganzzahl mit Einschränkungen [geschlossen]

8

Das Puzzle

Sie müssen ein Programm oder eine Funktion p (n) schreiben, die das Quadrat der Eingabe zurückgibt, und Sie können davon ausgehen, dass die Eingabe eine nicht negative Ganzzahl ist. Einfacher ausgedrückt, geben Sie n 2 zurück .

Regeln

  1. Es ist Ihnen nicht gestattet, *oder /(oder einen anderen Potenz- oder Quadratwurzeloperator wie POWoder SQRT, wenn Ihre Sprache solche Funktionen enthält) zu verwenden.
  2. Sie dürfen keine Schleife oder Konstruktionen verwenden, die einer Schleife ähnlich sind. Beispiel für schleifenartige Konstruktionen sind GOTOund Rekursion.

Beispiel

Function p(n)
Dim r()
ReDim r(n)
p = Len(Join(r, Space(n)))
End Function

Seien Sie kreativ und (ab) nutzen Sie die Funktionen und Merkmale, die Ihnen die Sprache Ihrer Wahl bietet.

*bearbeiten

Schleifenartige Strukturen sind Schleifen, mit denen Sie eine oder mehrere Anweisungen wiederholen können

-wenn Sie stdout "1"Ihrem Code ein hinzufügen könnten und diese Ausgabe am Ende n-mal wiederholen würden, würde dies als Schleife gelten

Dwana
quelle
1
@ Dwana Sind nicht der zweite Teil der ersten Regel und die dritte Regel gleich?
Def
14
Dies hätte nicht wieder geöffnet werden dürfen, da es immer noch an Klarheit mangelt, was als "schleifenartig" gilt. ZB was ist mit Falten?
Peter Taylor
5
@ PeterTaylor oder Karten für diese Angelegenheit.
Martin Ender
7
@dwana Können Sie diese Dinge in Ihren Regeln genau beschreiben: (1) Sind integrierte Funktionen, die von Natur aus Schleifen enthalten, wie Karten, Iteratoren, Falten, Reduzieren usw. zulässig? (2) Ist die Auswertung von Zeichenfolgen als Code mit eval / exec zulässig?
Optimierer
4
Dies ist größtenteils ein Duplikat einer früheren Codegolf-Herausforderung, bei der nach dem Allgemeineren gefragt wurde, m*nanstatt das n*nzu verwenden *. Siehe codegolf.stackexchange.com/a/18283/14485
Mark Lakata

Antworten:

42

CJam setzt seine Brille auf

q~33c

(*_*)

(*_")>⌐■-■

(⌐■_■)

"]sG>4%,)

Eingabe über STDIN

Probieren Sie den Code hier aus

Beachten Sie, dass *der Code nicht als Multiplikation, sondern als Verknüpfungsoperator verwendet wird

Beachten Sie auch, dass der coole Teil des Codes nicht nur eine Zeichenfolge ist, sondern die Hälfte davon der Code, der zum Finden des Quadrats erforderlich ist. Also .. HANDEL MIT IHM

Dies wird Ihnen helfen, damit umzugehen:

q~33c                    "Read the number and put ASCII character 33 on stack with it"
(                        "Decrease it to get ASCII code 32 character, which is a space";
 *_                      "Repeat the space input number times and make another copy";
   *                     "Put that many spaces in between each space. Now we have";
    )                    "n*n spaces string. We take out the last space out of it";
(                        "Decrement the space to get ASCII 31 character";
 *                       "Fill the n*n - 1 spaces with that to get 2*n*n - 3";
  _                      "string. Then copy it again.";
   ")>⌐■-■               "Put the sun glasses in";
(⌐■_■)                   "Wear the sun glasses. Be cool.";
"]s                      "Add everything to a single string of 4*n*n - 6 + 16"
   G>                    "length. Remove first 16 characters";
     4%                  "Take every 4th character from that string to get n*n - 1"
       ,)                "length string. Take length and increment to get n*n";
Optimierer
quelle
20

Rubin

def square(n)
  case n
  when 0..1
    n
  when 2..36
    '100'.to_i(n)
  else
    raise RangeError, 'Integer overflow!'
  end
end
Histokrat
quelle
10
Das ist wirklich klug.
Ypnypn
3
Für die Aufzeichnung funktioniert dies in Mathematica weit willkürliche ganze Zahlen (einschließlich 0 und negativ), ohne dass spezielle Fälle behandelt werden müssen : FromDigits[{1, 0, 0}, Input[]]. Gleiches in CJam:4Ybl~b
Martin Ender
20

APL? ∊⍵⍵

{+/ ∊⍵⍵ ⍴1}

Diese Antwort ist allen Personen gewidmet, die "" "setzen, wenn sie die APL-Symbole sehen :-)

Beispiele

      {+/∊⍵⍵⍴1} 3
9
      {+/∊⍵⍵⍴1}¨⍳20
1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400

Erläuterung

{       }   This function takes a number ⍵,
{   ⍵⍵⍴1}   builds a matrix of ⍵ by ⍵ all filled with ones,
{+/∊    }   and sums all its elements together.
Tobia
quelle
3
eww ... <! - Platzhalter ->
Kroltan
4
Summiert nicht alle Elemente einer Matrix-Pseudo-Schleife? Das Summieren erfolgt über Reduzieren oder Falten, beide werden wiederholt
Optimizer
+/in anderen Sprachen heißt sum()und ich sehe viele Antworten damit. Aus dem gleichen Grund konnten Sie nicht *in CJam verwenden.
Tobia
Ich verstehe Ihren Standpunkt, aber das Verbinden erfordert nicht das Lesen des Werts jedes einzelnen Elements, so dass es ohne eine Schleife auf einer niedrigen Ebene selbst durchgeführt werden kann. Das Summieren der Elemente der Matrix muss tatsächlich über alle Elemente laufen, die hinzugefügt werden sollen. Alternativ können Sie beispielsweise die Matrix abflachen und ihre Länge ermitteln.
Optimierer
2
Das sieht aus wie das Symbol für einen gepressten Schinken!?
FreeAsInBeer
15

Missbrauch einiger Funktionen in Mathematica

Zweimal die Fläche eines gleichschenkligen rechtwinkligen Dreiecks

a =RegionMeasure@SASTriangle[n,ArcSin[1], n] 
a+a

Die Fläche eines Quadrats. Na sicher!

RegionMeasure[Rectangle[{0, 0}, {n, n}]]

Die gleiche Idee in einer anderen Form:

Integrate[n, {x, 0, n}]  (* thx to DigitalTrauma *)

Die Anzahl der Elemente in einer quadratischen Matrix:

 Length[Flatten[Normal[AdjacencyMatrix[RandomGraph[{n, RandomInteger[n]}]]]]]

oder

 Plus@@Flatten[ConstantArray[1, {n, n}]]

oder

 Length@Flatten[Outer[f,Range[n],Range[n]]]

oder

 Length[Distribute[p[Range[n],Range[n]],List]]

usw...

DavidC
quelle
1
Noch einer : k[n_] := Integrate[n, {x, 0, n}]?
Digitales Trauma
DigitalTrauma, Integratesehr schön, aber es iteriert, was ich für eine Form des Loopings halte.
DavidC
Stimmt, obwohl ich denke, dass es sich nur um implizite Schleifen handelt. Mit dem gleichen Argument würde ich behaupten Areaund Freunde sind implizite Multiplikation (aber auch erlaubt)
Digital Trauma
13

C.

p(n){int a[n];return(&a)[n]-a;}

Hinweis:

  • Arrays mit variabler Länge werden seit C99 bedingt unterstützt.
  • Implizit intwird verwendet, um die Anzahl der Zeichen und Stilpunkte zu reduzieren.
ecatmur
quelle
6
stackoverflow.com/q/27828822/1530508
ApproachingDarknessFish
12

Mathematica

Eine weitere Antwort mit einigen lustigen Mathematica-Funktionen

n = Input[];
g = EdgeCount@CompleteGraph@n;
g + g + n

Ein vollständiger Graph mit nEckpunkten hat binom(n,2) = n(n-1)/2Kanten (dies ist auch die n-te Dreieckszahl). Das Ergebnis ist also einfach doppelt so hoch wie die Eingabe.

Martin Ender
quelle
1
Sehr klug, mit Grafiken.
DavidC
12

Python 2

Rein mathematisch, um verbotene Operationen zu vermeiden:

import cmath
n=input()
if n:
  l=complex(0, -cmath.log(n) - cmath.log(n))
  print int(round(abs(complex(cmath.cos(l),cmath.sin(l)))))
else:
  print 0

Dies ist der übliche exp(ln(x)*y)Trick, der auf dieses Problem zugeschnitten ist:

  • Weil y 2 ist, können wir einfach ln(x)+ln(x)die Multiplikation loswerden.
  • Ich hatte das Gefühl, dass dies math.exp()dem verbotenen "POW" für Fairplay etwas zu nahe kommt, also wird stattdessen das Ganze in einen Komplex umgewandelt und Eulers Identität wird verwendet, um das exp()mit cos()und zu ersetzensin()
  • Um Situationen zu vermeiden, in denen eine explizite Multiplikation / Division durch ierforderlich complex()ist, wird stattdessen die Funktion verwendet.
Digitales Trauma
quelle
2
Wenn Sie zu wechseln math.log, können cmath.logSie mit negativen Zahlen umgehen. Das brauchen Sie dann auch nicht import math.
FryAmTheEggman
inputmacht nicht das, was Sie in Python 2 denken, und in Python 3 printist eine Funktion anstelle einer Anweisung.
Cristian Ciupitu
@CristianCiupitu Was macht meiner Meinung nach inputin Python 2? ;-). Ich würde dies sicherlich anders schreiben, wenn dies Produktionscode wäre, aber für die Zwecke dieser Herausforderung ist es in Ordnung, solange die Eingabe ein wohlgeformter numerischer Ausdruck ist. Ich verstehe, dass es dort eine implizite Bewertung und ihre potenzielle Bösartigkeit gibt.
Digitales Trauma
8

Pure Bash

Keine expliziten Schleifen oder Arithmetik:

(($1))||{ echo 0;exit;}
eval a=({1..$1}{1..$1})
echo ${#a[@]}

Verwendet Bash-Erweiterungen, um zwei Listen 1-n zu erstellen und diese in Klammern zu erweitern und die Größe des resultierenden Arrays anzuzeigen.


Ähnliche Methode, aber stattdessen Coreutils verwenden:

join <(seq -f "1 %g" $1) <(seq -f "1 %g" $1) | wc -l
Digitales Trauma
quelle
8

R, köstliche Ineffizienz mit Monte Carlo

Die Erwartung E[x]für die Form- / Skalenparametrisierung der Gammaverteilung ist shape*scale.

Ich sehe kein meanVerbot, also hier ist die Beispiellösung mitmean()

f = function(n, k = 1e9){round((mean(rgamma(k, shape = n, scale = n))))}
f(99) 

Ohne Verwendung mean()ist es möglich zu verwenden mode[x], was gleich ist (shape-1)*scale, aber dies beinhaltet das Schreiben einer add.oneFunktion zum Umgehen und +1dann das Schreiben einer anderen ModeFunktion zum Tabellieren des Modus.

add.one = function(x) length(c(seq(x),NA))
Mode = function(x) (u<-unique(x))[which.max(tabulate(match(x,u)))]
f.mode = function(n, k = 1e9){Mode(round(rgamma(k, shape = add.one(n), scale = n)))

Die Genauigkeit ist nicht garantiert, aber für 1.000.000.000 Proben sollte ein Gesetz von großer Anzahl gelten, was mir für alle meine Testfälle die richtigen Ergebnisse gebracht hat.

Vlo
quelle
Ich dachte an einen ähnlichen Hack, +1
Shadowtalker
7

Java

Erster Eintrag, funktioniert das so?

int g(int n){
    int[] a = new int[n];
    Arrays.fill(a,n);
    return IntStream.of(a).sum();       
}
Anders Sundheim
quelle
... nicht lustig u_u
6

C #

Erstellt eine Zeichenfolge mit n Zeichen und ersetzt dann jedes Zeichen durch die Zeichenfolge mit n Zeichen. Dies erzeugt einen String mit einer Länge von n * n.

using System;

public class Test
{
    public static void Main()
    {
        int n = Int32.Parse(Console.ReadLine());
        String s = "".PadLeft(n, 'X');
        Console.WriteLine(s.Replace("X", s).Length);
    }
}

Testen Sie es hier: http://ideone.com/lubIFg .

hetzi
quelle
2
Das ist kreativ!
TheNumberOne
5

Matlab

Eine Warnung: Dies basiert hauptsächlich auf Mathematik. Erwarten Sie also keinen ausgefallenen Quellcode

Beachten Sie, dass a = n^2iff log(a) = log(n)*2iff log(log(a)) = log(log(n))+log(2). Diese Funktion findet also nur die Null der Funktion, f(a) = log(log(n))+log(2) - log(log(a))die offensichtlich bei ist a = n^2.

function s = g(n)
    f = @(a) log(log(n))+log(2)-log(log(a));
    s = fnzeros(f);
end

Hier einige andere nicht sehr kreative Funktionen:

Hier summiert das Programm die Zahl 1+2+3+...+n = 1/2 * (n^2+n)zweimal und subtrahiert n, so dass das Ergebnis immer istn^2

g=@(n)sum(1:n)+sum(1:n)-n

Diese Funktion erstellt eine n x nMatrix von Zufallszahlen (zwischen 0 und 1) und gibt dann die Anzahl der Elemente zurück.

g=@(n)numel(rand(n));

Die folgende Funktion erstellt eine Vandermonde-Matrix des Vektors (0,0,n)und gibt den Eintrag aus, aus dem bestehtn^2

function s = g(n)
    a = vander([0,0,n]);
    s = a(3,1)
end

Diese Funktion erstellt die Umkehrung einer Hilbert-Matrix mit einer Größe, nbei der sich immer das obere linke Element befindetn^2

function s = g(n)
    a = invhilb(n);
    s = a(1);
end
fehlerhaft
quelle
Anzeige Nr. 3: Natürlich würde man in realen Anwendungen g=@(n)nnz(nan(n));aus Gründen der Effizienz und Kürze verwenden. ;-)
Knedlsepp
Wenn es um Effizienz geht, denke ich, dass die explizite Berechnung der Inversen der Hilbert-Matrix effizienter ist : function s = g(n); a = inv(hilb(n)); s = a(1); end. Aber
andererseits
5

C.

sizeof(char[n][n])

Es funktioniert bis zu INT_MAX in konstanter Zeit und ohne Speicherzuweisung.

Beispiel:

#include <stdio.h>
#include <limits.h>
int main(){
    for( int n=0 ; n<10 ; n++ ){
        printf("%d: %ld\n", n, sizeof(char[n][n]));
    }
    int n = INT_MAX;
    printf("%d: %ld\n", n, sizeof(char[n][n]));
}

Anzeigen

0: 0
1: 1
2: 4
3: 9
4: 16
5: 25
6: 36
7: 49
8: 64
9: 81
2147483647: 4611686014132420609
Florian F.
quelle
Vielleicht machen Sie deutlich, dass die Schleife nur ein Wrapper ist, um das Programm zu zeigen, das auf mehreren Werten läuft
masterX244
4

Java

Dies ist die erste Antwort, die wirklich keine Schleifen oder Rekursionen verwendet.

int square(int n){
    if (n > 0){
        n = -n;
    }
    return m(n,0) + m(n,1) + m(n,2) + m(n,3) + m(n,4) + m(n,5) + m(n,6) + m(n,7) + m(n,8) + m(n,9) + m(n,10) +
            m(n,11) + m(n,12) + m(n,13) + m(n,14) + m(n,15) + m(n,16) + m(n,17) + m(n,18) + m(n,19) + m(n,20) +
            m(n,21) + m(n,22) + m(n,23) + m(n,24) + m(n,25) + m(n,26) + m(n,27) + m(n,28) + m(n,29) + m(n,30) + m(n,31);
}

int m(int number, int index){
    if (number >> index << 31 >>> 31 == 0){
        return 0;
    } else {
        return number << index;
    }
}
Die Nummer eins
quelle
@FlorianF Alle anderen Antworten rufen Funktionen auf, die Schleifen verwenden. Soweit ich weiß, zählt das 32-malige Aufrufen einer Funktion und das anschließende Hinzufügen der Ergebnisse nicht als Schleifen. Wenn ich die Anweisung hinzugefügt System.out.print(1)zu m, würde druckt das Programm 1genau 32 - mal, nicht n - mal.
TheNumberOne
3

GolfScript

Histocrat hat eine Möglichkeit zur Verwendung der Basiskonvertierung aufgezeigt: Hier ist eine andere.

{.,1base.++}:p;

Präparation

{       # Function boilerplate
  .     # Duplicate the input. Stack: x x
  ,     # Turn the second one into an array [0 1 ... x-1]
  1base # Sum the elements of the array. Stack: x x(x-1)/2
  .+    # Double. Stack: x x(x-1)
  +     # Add. Stack: x*x
}:p;    # Question asks for the function to be called p
        # The fact that this destroys the built-in p is unfortunate, but required
Peter Taylor
quelle
2

Emacs Lisp

(defmacro square-it (n)
  (cons '+ (make-list n n)))

(square-it 11) ;; => 121

Ein einfaches Makro, das erweitert (square-it 5)wird (+ 5 5 5 5 5). Natürlich muss die Eingabe eine Kompilierungszeitkonstante sein.

Jordon Biondo
quelle
2

Javascript

function square(i) {
    return new Array(++i).join(new Array(i).join(' ')).length;
}
bjb568
quelle
2

Haskell

Es gibt viele Möglichkeiten, wenn Bereiche [x..y]erlaubt sind, einige davon sind:

f n|x<-sum[1..n]=x+x-n
f n=sum$take n[n,n..]
f n=length$[1..n]>>[1..n]
f n=sum$[1..n]>>[1..n]>>[1]

Die beiden letzteren verwenden die Monad-Instanz von Listen. für Listen xs, yshält das xs>>ysist ysan sich selbst angehängten length xsZeiten.

Ein weiterer Trick ist einfach

import Data.Monoid
f x=x<>x

Wenn diese Funktion ein 'geeignetes' Argument erhält (das natürlich aus der Typklasse stammt Num), wird das Quadrat zurückgegeben. Product 3 :: Num a => Product aist ein Beispiel für ein solches Argument.

Grundsätzlich ist diese Funktion, wenn sie angewendet Product awird (die in der NumKlasse iff ain i ist) mappend, mit sich selbst verbunden und gibt zurück Product (a*a).

Wenn wir strenger darüber sind, was eine Zahl ist / an welchen Zahlen unsere Funktion arbeiten soll, können wir definieren fals

import Data.Monoid
f n|x<-Product n=getProduct$x<>x
stolzer haskeller
quelle
2

Java

Dies ist zu lang, um die Antwort Integer.MAX_VALUEeinzugeben , aber im Grunde kommt eine der Codezeilen so oft vor, wie sie ungefähr dem Quadrat von (das ist 46340) entspricht. : D.

Ohne Kommentare oder Zeilenumbrüche würde der eingegebene Code 1.112.155 Zeichen umfassen.

int s(int n){
    if(n==0|n==1)return n;
    int c=2,r=n+n;
    if(n==c++)return r;r+=n;
    if(n==c++)return r;r+=n;
    if(n==c++)return r;r+=n;
    if(n==c++)return r;r+=n;
    if(n==c++)return r;r+=n;
    if(n==c++)return r;r+=n;
                            //... (same line of code a total of 46336 times)
    if(n==c++)return r;r+=n;
    if(n==c++)return r;
    return n==c?r+n:r+n+n; //r = 46340^2
}
mbomb007
quelle
2

R.

Diese Funktion basiert auf dem Zählen aller möglichen Kombinationen von zwei Sequenzen im Bereich von 1 bis n. Der Wert 0 wird separat behandelt.

f <- function(n) if (n) nrow(expand.grid(s <- seq(n), s)) else 0
Sven Hohenstein
quelle
2

Clojure

(def squares (lazy-cat [0] (map (fn [sq x] (+ sq x x 1)) squares (range))))

Unendliche Folge aller Quadrate ab 0. Die Funktion:

(defn square [n] (nth squares n))
Jarlax
quelle
1

J.

Einige ASCII Kunst ...

p =. ( $ @,@  ( ($*) ([-])"*/ ($*) ))
randomra
quelle
1

Perl:

$n=8;
$x = "$n +" x $n;
$x =~ s/\+$//;
print eval $x;
michael501
quelle
1

SQL (PostGIS)

Verwenden Sie den Bereich und erstellen Sie Hüllkurvenfunktionen in der PostGIS-Erweiterung von PostGreSQL, um eine quadratische Geometrie zu erstellen und den Bereich zurückzugeben. Könnte geändert werden, um auch das Float-Quadrat zurückzugeben.

CREATE FUNCTION square(n int)RETURNS int AS $$
BEGIN 
    RETURN ST_Area(ST_MakeEnvelope(0,0,n,n));
END;
$$LANGUAGE plpgsql;

In Benutzung;

SELECT square(150);

Square Integer
--------------
22500
MickyT
quelle
1

Python

Verwendet einfache Mathematik. Basierend auf der Summe einer arithmetischen Folge.

s=lambda n:(sum(range(n))<<1)+n

Erläuterung:

a = sum(range(n)) # sum of arithmetic progression from 1 to n-1:  n*(n-1)/2
b = a<<1          # bitshift left by 1 (multiply by 2):  n*n - n
c = b+n           # add n:  n*n

Obwohl Summe und Bereich wahrscheinlich implizite Schleifen enthalten, gibt
es gemäß der Fragenspezifikation keine Möglichkeit, hier eine Druckanweisung einzufügen, um sie zu wiederholen, also ... :)

Vektorisiert
quelle
1

Bash

yes|xargs -L$1|xargs -L$1|head -n1|iconv -futf16|wc -m

Funktioniert nur, wenn n <256 ist.

jimmy23013
quelle
1

PHP

function square($v) {
    return array_sum(array_fill(0, $v, $v));
}

arbeitet mit einer Ganzzahl im Bereich [0; 46340]

Bearbeiten: Ich habe gerade @ thebestone Code gesehen und es ist im Grunde das gleiche

ANZEIGE
quelle
1

Perl

$_=<>;chop;s/./$_/g;print

Das Programm erwartet, dass die eingegebene Nummer in unärer Form (dh Basis 1) quadriert wird. Die Ausgabe ist ebenfalls unär. Es ersetzt einfach jede Ziffer durch die ganze Zahl.

Anwendungsbeispiel:

perl -e '$_=<>;chop;s/./$_/g;print'
000                                   # <- user input
000000000                             # <- output
Nimi
quelle
1

Scala:

scala> val q = (n:Int) =>(List.fill (n)(n)).sum
q: Int => Int = <function1>

scala> q(9)
res21: Int = 81
Benutzer unbekannt
quelle
1

Scala:

scala> val s=(n:Int)=>(("x"*(n))*n).size
s: Int => Int = <function1>

scala> s(7)
res22: Int = 49
Benutzer unbekannt
quelle
"Ja wirklich?" Sieht es aus wie eine Schleife oder wissen Sie, dass es eine versteckte Schleife geben muss?
Benutzer unbekannt